From 9f32ea202ae671225a3080d5aee1ce50ba7f8b5c Mon Sep 17 00:00:00 2001
From: Scott Duensing <scott@kangaroopunch.com>
Date: Mon, 14 Mar 2022 20:24:37 -0500
Subject: [PATCH] SQLite compiling for dos!

---
 .gitignore                                    |     1 +
 LICENSE                                       |     5 +
 Makefile.djgpp                                |     7 +-
 buildPrerequisites.sh                         |    23 +-
 client/src/browser.c                          |    28 +-
 client/src/thirdparty/sqlite-3.4.2/Makefile   |   629 +
 .../src/thirdparty/sqlite-3.4.2/Makefile.arm  |   138 +
 .../src/thirdparty/sqlite-3.4.2/Makefile.in   |   629 +
 .../sqlite-3.4.2/Makefile.linux-gcc           |   128 +
 .../src/thirdparty/sqlite-3.4.2/Makefile.org  |   622 +
 client/src/thirdparty/sqlite-3.4.2/README     |    35 +
 client/src/thirdparty/sqlite-3.4.2/VERSION    |     1 +
 client/src/thirdparty/sqlite-3.4.2/aclocal.m4 |  6470 +++++
 .../thirdparty/sqlite-3.4.2/addopcodes.awk    |    32 +
 .../sqlite-3.4.2/art/2005osaward.gif          |     3 +
 .../thirdparty/sqlite-3.4.2/art/SQLite.eps    |   Bin 0 -> 24155 bytes
 .../thirdparty/sqlite-3.4.2/art/SQLite.gif    |     3 +
 .../sqlite-3.4.2/art/SQLiteLogo3.tiff         |   Bin 0 -> 85156 bytes
 .../sqlite-3.4.2/art/SQLite_big.gif           |     3 +
 .../thirdparty/sqlite-3.4.2/art/nocopy.gif    |     3 +
 .../sqlite-3.4.2/art/powered_by_sqlite.gif    |     3 +
 .../src/thirdparty/sqlite-3.4.2/config.guess  |  1532 ++
 client/src/thirdparty/sqlite-3.4.2/config.log |  1565 ++
 .../src/thirdparty/sqlite-3.4.2/config.status |   774 +
 client/src/thirdparty/sqlite-3.4.2/config.sub |  1640 ++
 client/src/thirdparty/sqlite-3.4.2/configure  | 20477 ++++++++++++++++
 .../src/thirdparty/sqlite-3.4.2/configure.ac  |   582 +
 .../sqlite-3.4.2/contrib/sqlitecon.tcl        |   679 +
 .../thirdparty/sqlite-3.4.2/doc/lemon.html    |   892 +
 .../thirdparty/sqlite-3.4.2/doc/report1.txt   |   121 +
 client/src/thirdparty/sqlite-3.4.2/ex1        |   Bin 0 -> 2048 bytes
 .../thirdparty/sqlite-3.4.2/examples/c1.bat   |     4 +
 .../thirdparty/sqlite-3.4.2/examples/c2.bat   |     4 +
 .../thirdparty/sqlite-3.4.2/examples/c3.bat   |     4 +
 .../sqlite-3.4.2/examples/example1.cpp        |    36 +
 .../sqlite-3.4.2/examples/example2.cpp        |    71 +
 .../sqlite-3.4.2/examples/example3.c          |    64 +
 .../sqlite-3.4.2/examples/libsqlite3.a        |   Bin 0 -> 1839418 bytes
 .../sqlite-3.4.2/examples/notes.txt           |    14 +
 .../sqlite-3.4.2/examples/sqlite3.h           |  4804 ++++
 .../thirdparty/sqlite-3.4.2/ext/README.txt    |     2 +
 .../sqlite-3.4.2/ext/fts1/CVS/Entries         |    15 +
 .../sqlite-3.4.2/ext/fts1/CVS/Repository      |     1 +
 .../thirdparty/sqlite-3.4.2/ext/fts1/CVS/Root |     1 +
 .../sqlite-3.4.2/ext/fts1/README.txt          |     2 +
 .../sqlite-3.4.2/ext/fts1/ft_hash.c           |   404 +
 .../sqlite-3.4.2/ext/fts1/ft_hash.h           |   111 +
 .../thirdparty/sqlite-3.4.2/ext/fts1/fts1.c   |  3345 +++
 .../thirdparty/sqlite-3.4.2/ext/fts1/fts1.h   |    11 +
 .../sqlite-3.4.2/ext/fts1/fts1_hash.c         |   369 +
 .../sqlite-3.4.2/ext/fts1/fts1_hash.h         |   112 +
 .../sqlite-3.4.2/ext/fts1/fts1_porter.c       |   643 +
 .../sqlite-3.4.2/ext/fts1/fts1_tokenizer.h    |    90 +
 .../sqlite-3.4.2/ext/fts1/fts1_tokenizer1.c   |   221 +
 .../sqlite-3.4.2/ext/fts1/fulltext.c          |  1496 ++
 .../sqlite-3.4.2/ext/fts1/fulltext.h          |    11 +
 .../sqlite-3.4.2/ext/fts1/simple_tokenizer.c  |   174 +
 .../sqlite-3.4.2/ext/fts1/tokenizer.h         |    89 +
 .../sqlite-3.4.2/ext/fts2/CVS/Entries         |    13 +
 .../sqlite-3.4.2/ext/fts2/CVS/Repository      |     1 +
 .../thirdparty/sqlite-3.4.2/ext/fts2/CVS/Root |     1 +
 .../sqlite-3.4.2/ext/fts2/README.tokenizers   |   133 +
 .../sqlite-3.4.2/ext/fts2/README.txt          |     4 +
 .../thirdparty/sqlite-3.4.2/ext/fts2/fts2.c   |  5937 +++++
 .../thirdparty/sqlite-3.4.2/ext/fts2/fts2.h   |    26 +
 .../sqlite-3.4.2/ext/fts2/fts2_hash.c         |   369 +
 .../sqlite-3.4.2/ext/fts2/fts2_hash.h         |   112 +
 .../sqlite-3.4.2/ext/fts2/fts2_icu.c          |   257 +
 .../sqlite-3.4.2/ext/fts2/fts2_porter.c       |   642 +
 .../sqlite-3.4.2/ext/fts2/fts2_tokenizer.c    |   371 +
 .../sqlite-3.4.2/ext/fts2/fts2_tokenizer.h    |   145 +
 .../sqlite-3.4.2/ext/fts2/fts2_tokenizer1.c   |   229 +
 .../sqlite-3.4.2/ext/fts2/mkfts2amal.tcl      |   116 +
 .../sqlite-3.4.2/ext/fts3/CVS/Entries         |    13 +
 .../sqlite-3.4.2/ext/fts3/CVS/Repository      |     1 +
 .../thirdparty/sqlite-3.4.2/ext/fts3/CVS/Root |     1 +
 .../sqlite-3.4.2/ext/fts3/README.tokenizers   |   133 +
 .../sqlite-3.4.2/ext/fts3/README.txt          |     4 +
 .../thirdparty/sqlite-3.4.2/ext/fts3/fts3.c   |  6403 +++++
 .../thirdparty/sqlite-3.4.2/ext/fts3/fts3.h   |    26 +
 .../sqlite-3.4.2/ext/fts3/fts3_hash.c         |   374 +
 .../sqlite-3.4.2/ext/fts3/fts3_hash.h         |   110 +
 .../sqlite-3.4.2/ext/fts3/fts3_icu.c          |   258 +
 .../sqlite-3.4.2/ext/fts3/fts3_porter.c       |   642 +
 .../sqlite-3.4.2/ext/fts3/fts3_tokenizer.c    |   371 +
 .../sqlite-3.4.2/ext/fts3/fts3_tokenizer.h    |   145 +
 .../sqlite-3.4.2/ext/fts3/fts3_tokenizer1.c   |   230 +
 .../sqlite-3.4.2/ext/fts3/mkfts3amal.tcl      |   115 +
 .../sqlite-3.4.2/ext/icu/CVS/Entries          |     3 +
 .../sqlite-3.4.2/ext/icu/CVS/Repository       |     1 +
 .../thirdparty/sqlite-3.4.2/ext/icu/CVS/Root  |     1 +
 .../sqlite-3.4.2/ext/icu/README.txt           |   170 +
 .../src/thirdparty/sqlite-3.4.2/ext/icu/icu.c |   499 +
 client/src/thirdparty/sqlite-3.4.2/install.sh |   251 +
 client/src/thirdparty/sqlite-3.4.2/libtool    |  7625 ++++++
 client/src/thirdparty/sqlite-3.4.2/ltmain.sh  |  6971 ++++++
 client/src/thirdparty/sqlite-3.4.2/main.mk    |   486 +
 client/src/thirdparty/sqlite-3.4.2/mkdll.sh   |    46 +
 client/src/thirdparty/sqlite-3.4.2/mkextu.sh  |    13 +
 client/src/thirdparty/sqlite-3.4.2/mkextw.sh  |    22 +
 .../src/thirdparty/sqlite-3.4.2/mkopcodc.awk  |    31 +
 .../src/thirdparty/sqlite-3.4.2/mkopcodec.awk |    31 +
 .../src/thirdparty/sqlite-3.4.2/mkopcodeh.awk |   157 +
 client/src/thirdparty/sqlite-3.4.2/mkso.sh    |    29 +
 .../src/thirdparty/sqlite-3.4.2/notesDOS.txt  |    18 +
 client/src/thirdparty/sqlite-3.4.2/publish.sh |   132 +
 .../thirdparty/sqlite-3.4.2/publish_osx.sh    |    35 +
 .../src/thirdparty/sqlite-3.4.2/spec.template |    62 +
 .../src/thirdparty/sqlite-3.4.2/sqlite.pc.in  |    12 +
 client/src/thirdparty/sqlite-3.4.2/sqlite3.1  |   229 +
 client/src/thirdparty/sqlite-3.4.2/sqlite3.pc |    13 +
 .../src/thirdparty/sqlite-3.4.2/sqlite3.pc.in |    13 +
 .../src/thirdparty/sqlite-3.4.2/src/alter.c   |   630 +
 .../src/thirdparty/sqlite-3.4.2/src/analyze.c |   425 +
 .../src/thirdparty/sqlite-3.4.2/src/attach.c  |   527 +
 client/src/thirdparty/sqlite-3.4.2/src/auth.c |   234 +
 .../src/thirdparty/sqlite-3.4.2/src/btmutex.c |   317 +
 .../src/thirdparty/sqlite-3.4.2/src/btree.c   |  6943 ++++++
 .../src/thirdparty/sqlite-3.4.2/src/btree.h   |   203 +
 .../thirdparty/sqlite-3.4.2/src/btreeInt.h    |   650 +
 .../src/thirdparty/sqlite-3.4.2/src/build.c   |  3467 +++
 .../thirdparty/sqlite-3.4.2/src/callback.c    |   378 +
 .../thirdparty/sqlite-3.4.2/src/complete.c    |   271 +
 client/src/thirdparty/sqlite-3.4.2/src/date.c |  1038 +
 .../src/thirdparty/sqlite-3.4.2/src/delete.c  |   510 +
 .../sqlite-3.4.2/src/experimental.c           |    37 +
 client/src/thirdparty/sqlite-3.4.2/src/expr.c |  2983 +++
 .../src/thirdparty/sqlite-3.4.2/src/fault.c   |   147 +
 client/src/thirdparty/sqlite-3.4.2/src/func.c |  1572 ++
 client/src/thirdparty/sqlite-3.4.2/src/hash.c |   419 +
 client/src/thirdparty/sqlite-3.4.2/src/hash.h |   110 +
 .../src/thirdparty/sqlite-3.4.2/src/insert.c  |  1663 ++
 .../src/thirdparty/sqlite-3.4.2/src/journal.c |   238 +
 .../src/thirdparty/sqlite-3.4.2/src/legacy.c  |   134 +
 .../src/thirdparty/sqlite-3.4.2/src/limits.h  |   158 +
 .../src/thirdparty/sqlite-3.4.2/src/loadext.c |   518 +
 client/src/thirdparty/sqlite-3.4.2/src/main.c |  1509 ++
 .../src/thirdparty/sqlite-3.4.2/src/malloc.c  |   239 +
 client/src/thirdparty/sqlite-3.4.2/src/md5.c  |   387 +
 client/src/thirdparty/sqlite-3.4.2/src/mem1.c |   232 +
 client/src/thirdparty/sqlite-3.4.2/src/mem2.c |   456 +
 client/src/thirdparty/sqlite-3.4.2/src/mem3.c |   653 +
 client/src/thirdparty/sqlite-3.4.2/src/mem4.c |   398 +
 .../src/thirdparty/sqlite-3.4.2/src/mutex.c   |   126 +
 .../src/thirdparty/sqlite-3.4.2/src/mutex.h   |    82 +
 .../thirdparty/sqlite-3.4.2/src/mutex_os2.c   |   245 +
 .../thirdparty/sqlite-3.4.2/src/mutex_unix.c  |   298 +
 .../thirdparty/sqlite-3.4.2/src/mutex_w32.c   |   219 +
 client/src/thirdparty/sqlite-3.4.2/src/os.c   |   267 +
 client/src/thirdparty/sqlite-3.4.2/src/os.h   |   275 +
 .../thirdparty/sqlite-3.4.2/src/os_common.h   |   127 +
 .../src/thirdparty/sqlite-3.4.2/src/os_os2.c  |   989 +
 .../src/thirdparty/sqlite-3.4.2/src/os_os2.h  |    73 +
 .../src/thirdparty/sqlite-3.4.2/src/os_test.c |   463 +
 .../src/thirdparty/sqlite-3.4.2/src/os_test.h |    40 +
 .../src/thirdparty/sqlite-3.4.2/src/os_unix.c |  2758 +++
 .../src/thirdparty/sqlite-3.4.2/src/os_unix.h |   116 +
 .../src/thirdparty/sqlite-3.4.2/src/os_win.c  |  1557 ++
 .../src/thirdparty/sqlite-3.4.2/src/os_win.h  |    40 +
 .../src/thirdparty/sqlite-3.4.2/src/pager.c   |  5133 ++++
 .../src/thirdparty/sqlite-3.4.2/src/pager.h   |   125 +
 .../src/thirdparty/sqlite-3.4.2/src/parse.y   |  1114 +
 .../src/thirdparty/sqlite-3.4.2/src/pragma.c  |  1227 +
 .../src/thirdparty/sqlite-3.4.2/src/prepare.c |   768 +
 .../src/thirdparty/sqlite-3.4.2/src/printf.c  |   904 +
 .../src/thirdparty/sqlite-3.4.2/src/random.c  |   121 +
 .../src/thirdparty/sqlite-3.4.2/src/select.c  |  3705 +++
 .../src/thirdparty/sqlite-3.4.2/src/server.c  |   485 +
 .../src/thirdparty/sqlite-3.4.2/src/shell.c   |  2087 ++
 .../thirdparty/sqlite-3.4.2/src/sqlite.h.in   |  4804 ++++
 .../thirdparty/sqlite-3.4.2/src/sqlite3ext.h  |   350 +
 .../thirdparty/sqlite-3.4.2/src/sqliteInt.h   |  2089 ++
 .../thirdparty/sqlite-3.4.2/src/sqliteLimit.h |   179 +
 .../src/thirdparty/sqlite-3.4.2/src/table.c   |   199 +
 .../thirdparty/sqlite-3.4.2/src/tclsqlite.c   |  2591 ++
 .../src/thirdparty/sqlite-3.4.2/src/test1.c   |  4641 ++++
 .../src/thirdparty/sqlite-3.4.2/src/test2.c   |   619 +
 .../src/thirdparty/sqlite-3.4.2/src/test3.c   |  1668 ++
 .../src/thirdparty/sqlite-3.4.2/src/test4.c   |   716 +
 .../src/thirdparty/sqlite-3.4.2/src/test5.c   |   217 +
 .../src/thirdparty/sqlite-3.4.2/src/test6.c   |   879 +
 .../src/thirdparty/sqlite-3.4.2/src/test7.c   |   723 +
 .../src/thirdparty/sqlite-3.4.2/src/test8.c   |  1218 +
 .../src/thirdparty/sqlite-3.4.2/src/test9.c   |   193 +
 .../thirdparty/sqlite-3.4.2/src/test_async.c  |  1708 ++
 .../sqlite-3.4.2/src/test_autoext.c           |   164 +
 .../thirdparty/sqlite-3.4.2/src/test_btree.c  |   247 +
 .../thirdparty/sqlite-3.4.2/src/test_config.c |   477 +
 .../thirdparty/sqlite-3.4.2/src/test_devsym.c |   346 +
 .../thirdparty/sqlite-3.4.2/src/test_hexio.c  |   336 +
 .../sqlite-3.4.2/src/test_loadext.c           |    57 +
 .../thirdparty/sqlite-3.4.2/src/test_malloc.c |   513 +
 .../thirdparty/sqlite-3.4.2/src/test_md5.c    |   388 +
 .../sqlite-3.4.2/src/test_onefile.c           |   824 +
 .../thirdparty/sqlite-3.4.2/src/test_schema.c |   358 +
 .../thirdparty/sqlite-3.4.2/src/test_server.c |   491 +
 .../thirdparty/sqlite-3.4.2/src/test_tclvar.c |   327 +
 .../thirdparty/sqlite-3.4.2/src/test_thread.c |   332 +
 .../thirdparty/sqlite-3.4.2/src/tokenize.c    |   503 +
 .../src/thirdparty/sqlite-3.4.2/src/trigger.c |   851 +
 .../src/thirdparty/sqlite-3.4.2/src/update.c  |   669 +
 client/src/thirdparty/sqlite-3.4.2/src/utf.c  |   545 +
 client/src/thirdparty/sqlite-3.4.2/src/util.c |   724 +
 .../src/thirdparty/sqlite-3.4.2/src/vacuum.c  |   263 +
 client/src/thirdparty/sqlite-3.4.2/src/vdbe.c |  4816 ++++
 client/src/thirdparty/sqlite-3.4.2/src/vdbe.h |   183 +
 .../src/thirdparty/sqlite-3.4.2/src/vdbeInt.h |   422 +
 .../src/thirdparty/sqlite-3.4.2/src/vdbeapi.c |  1066 +
 .../src/thirdparty/sqlite-3.4.2/src/vdbeaux.c |  2314 ++
 .../thirdparty/sqlite-3.4.2/src/vdbeblob.c    |   337 +
 .../thirdparty/sqlite-3.4.2/src/vdbefifo.c    |   114 +
 .../src/thirdparty/sqlite-3.4.2/src/vdbemem.c |  1040 +
 client/src/thirdparty/sqlite-3.4.2/src/vtab.c |   798 +
 .../src/thirdparty/sqlite-3.4.2/src/where.c   |  2843 +++
 .../thirdparty/sqlite-3.4.2/tclinstaller.tcl  |    32 +
 .../src/thirdparty/sqlite-3.4.2/tool/diffdb.c |    44 +
 .../thirdparty/sqlite-3.4.2/tool/fragck.tcl   |   149 +
 .../src/thirdparty/sqlite-3.4.2/tool/lemon.c  |  4822 ++++
 .../src/thirdparty/sqlite-3.4.2/tool/lempar.c |   769 +
 .../thirdparty/sqlite-3.4.2/tool/memleak.awk  |    29 +
 .../thirdparty/sqlite-3.4.2/tool/memleak2.awk |    29 +
 .../thirdparty/sqlite-3.4.2/tool/memleak3.tcl |   233 +
 .../sqlite-3.4.2/tool/mkkeywordhash.c         |   559 +
 .../thirdparty/sqlite-3.4.2/tool/mkopts.tcl   |    51 +
 .../sqlite-3.4.2/tool/mksqlite3c.tcl          |   278 +
 .../sqlite-3.4.2/tool/mksqlite3internalh.tcl  |   145 +
 .../thirdparty/sqlite-3.4.2/tool/omittest.tcl |   176 +
 .../sqlite-3.4.2/tool/opcodeDoc.awk           |    23 +
 .../thirdparty/sqlite-3.4.2/tool/report1.txt  |    66 +
 .../src/thirdparty/sqlite-3.4.2/tool/showdb.c |    86 +
 .../sqlite-3.4.2/tool/showjournal.c           |    76 +
 .../thirdparty/sqlite-3.4.2/tool/soak1.tcl    |   103 +
 .../sqlite-3.4.2/tool/space_used.tcl          |   111 +
 .../sqlite-3.4.2/tool/spaceanal.tcl           |   863 +
 .../sqlite-3.4.2/tool/speedtest.tcl           |   275 +
 .../sqlite-3.4.2/tool/speedtest2.tcl          |   207 +
 .../thirdparty/sqlite-3.4.2/www/34to35.tcl    |  1006 +
 .../src/thirdparty/sqlite-3.4.2/www/arch.fig  |    64 +
 .../src/thirdparty/sqlite-3.4.2/www/arch.gif  |     3 +
 .../src/thirdparty/sqlite-3.4.2/www/arch.png  |     3 +
 .../src/thirdparty/sqlite-3.4.2/www/arch.tcl  |   221 +
 .../src/thirdparty/sqlite-3.4.2/www/arch2.fig |   123 +
 .../src/thirdparty/sqlite-3.4.2/www/arch2.gif |     3 +
 .../thirdparty/sqlite-3.4.2/www/arch2b.fig    |   125 +
 .../src/thirdparty/sqlite-3.4.2/www/audit.tcl |   214 +
 .../thirdparty/sqlite-3.4.2/www/autoinc.tcl   |   109 +
 .../sqlite-3.4.2/www/c_interface.tcl          |  1116 +
 .../src/thirdparty/sqlite-3.4.2/www/capi3.tcl |   516 +
 .../thirdparty/sqlite-3.4.2/www/capi3ref.tcl  |  1882 ++
 .../thirdparty/sqlite-3.4.2/www/changes.tcl   |  1880 ++
 .../thirdparty/sqlite-3.4.2/www/common.tcl    |    90 +
 .../thirdparty/sqlite-3.4.2/www/compile.tcl   |   278 +
 .../thirdparty/sqlite-3.4.2/www/conflict.tcl  |    91 +
 .../sqlite-3.4.2/www/copyright-release.html   |   109 +
 .../sqlite-3.4.2/www/copyright-release.pdf    |   Bin 0 -> 2848 bytes
 .../thirdparty/sqlite-3.4.2/www/copyright.tcl |   126 +
 .../thirdparty/sqlite-3.4.2/www/datatype3.tcl |   440 +
 .../thirdparty/sqlite-3.4.2/www/datatypes.tcl |   243 +
 .../thirdparty/sqlite-3.4.2/www/different.tcl |   224 +
 .../thirdparty/sqlite-3.4.2/www/direct1b.gif  |     3 +
 .../src/thirdparty/sqlite-3.4.2/www/docs.tcl  |   159 +
 .../thirdparty/sqlite-3.4.2/www/download.tcl  |   236 +
 .../thirdparty/sqlite-3.4.2/www/dynload.tcl   |    70 +
 .../src/thirdparty/sqlite-3.4.2/www/faq.tcl   |   463 +
 .../sqlite-3.4.2/www/fileformat.tcl           |   785 +
 .../sqlite-3.4.2/www/formatchng.tcl           |   285 +
 .../thirdparty/sqlite-3.4.2/www/fullscanb.gif |     3 +
 .../sqlite-3.4.2/www/index-ex1-x-b.gif        |     3 +
 .../src/thirdparty/sqlite-3.4.2/www/index.tcl |   115 +
 .../sqlite-3.4.2/www/indirect1b1.gif          |     3 +
 .../src/thirdparty/sqlite-3.4.2/www/lang.tcl  |  2207 ++
 .../thirdparty/sqlite-3.4.2/www/limits.tcl    |   318 +
 .../thirdparty/sqlite-3.4.2/www/lockingv3.tcl |   570 +
 .../src/thirdparty/sqlite-3.4.2/www/mingw.tcl |   160 +
 .../thirdparty/sqlite-3.4.2/www/mkapidoc.tcl  |   176 +
 .../src/thirdparty/sqlite-3.4.2/www/nulls.tcl |   329 +
 .../thirdparty/sqlite-3.4.2/www/oldnews.tcl   |   509 +
 .../thirdparty/sqlite-3.4.2/www/omitted.tcl   |    85 +
 .../thirdparty/sqlite-3.4.2/www/opcode.tcl    |   243 +
 .../thirdparty/sqlite-3.4.2/www/optimizer.tcl |   265 +
 .../sqlite-3.4.2/www/optimizing.tcl           |    15 +
 .../sqlite-3.4.2/www/optoverview.tcl          |   516 +
 .../thirdparty/sqlite-3.4.2/www/pragma.tcl    |   635 +
 .../sqlite-3.4.2/www/quickstart.tcl           |   110 +
 .../thirdparty/sqlite-3.4.2/www/shared.gif    |     3 +
 .../sqlite-3.4.2/www/sharedcache.tcl          |   221 +
 .../src/thirdparty/sqlite-3.4.2/www/speed.tcl |   495 +
 .../thirdparty/sqlite-3.4.2/www/sqlite.tcl    |   582 +
 .../thirdparty/sqlite-3.4.2/www/support.tcl   |    79 +
 .../sqlite-3.4.2/www/table-ex1b2.gif          |     3 +
 .../thirdparty/sqlite-3.4.2/www/tclsqlite.tcl |   666 +
 .../src/thirdparty/sqlite-3.4.2/www/vdbe.tcl  |  1988 ++
 .../thirdparty/sqlite-3.4.2/www/version3.tcl  |   293 +
 .../thirdparty/sqlite-3.4.2/www/whentouse.tcl |   254 +
 shared/util.c                                 |    39 +
 shared/util.h                                 |    11 +-
 296 files changed, 209948 insertions(+), 28 deletions(-)
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/Makefile
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/Makefile.arm
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/Makefile.in
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/Makefile.linux-gcc
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/Makefile.org
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/README
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/VERSION
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/aclocal.m4
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/addopcodes.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/2005osaward.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/SQLite.eps
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/SQLite.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/SQLiteLogo3.tiff
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/SQLite_big.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/nocopy.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/art/powered_by_sqlite.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/config.guess
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/config.log
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/config.status
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/config.sub
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/configure
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/configure.ac
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/contrib/sqlitecon.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/doc/lemon.html
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/doc/report1.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ex1
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/c1.bat
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/c2.bat
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/c3.bat
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/example1.cpp
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/example2.cpp
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/example3.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/libsqlite3.a
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/notes.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/examples/sqlite3.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/README.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Entries
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Repository
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Root
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/README.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_porter.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/simple_tokenizer.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts1/tokenizer.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Entries
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Repository
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Root
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.tokenizers
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_icu.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_porter.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts2/mkfts2amal.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Entries
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Repository
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Root
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.tokenizers
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_icu.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_porter.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/fts3/mkfts3amal.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Entries
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Repository
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Root
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/icu/README.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ext/icu/icu.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/install.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/libtool
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/ltmain.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/main.mk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkdll.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkextu.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkextw.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkopcodc.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkopcodec.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkopcodeh.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/mkso.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/notesDOS.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/publish.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/publish_osx.sh
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/spec.template
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/sqlite.pc.in
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/sqlite3.1
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/sqlite3.pc
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/sqlite3.pc.in
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/alter.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/analyze.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/attach.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/auth.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/btmutex.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/btree.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/btree.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/btreeInt.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/build.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/callback.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/complete.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/date.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/delete.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/experimental.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/expr.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/fault.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/func.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/hash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/hash.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/insert.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/journal.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/legacy.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/limits.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/loadext.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/main.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/malloc.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/md5.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mem1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mem2.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mem3.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mem4.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mutex.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mutex.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mutex_os2.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mutex_unix.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/mutex_w32.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_common.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_os2.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_os2.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_test.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_test.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_unix.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_unix.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_win.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/os_win.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/pager.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/pager.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/parse.y
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/pragma.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/prepare.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/printf.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/random.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/select.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/server.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/shell.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/sqlite.h.in
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/sqlite3ext.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/sqliteInt.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/sqliteLimit.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/table.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/tclsqlite.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test1.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test2.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test3.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test4.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test5.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test6.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test7.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test8.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test9.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_async.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_autoext.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_btree.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_config.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_devsym.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_hexio.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_loadext.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_malloc.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_md5.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_onefile.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_schema.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_server.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_tclvar.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/test_thread.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/tokenize.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/trigger.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/update.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/utf.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/util.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vacuum.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbe.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbe.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbeInt.h
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbeapi.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbeaux.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbeblob.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbefifo.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vdbemem.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/vtab.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/src/where.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tclinstaller.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/diffdb.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/fragck.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/lemon.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/lempar.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/memleak.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/memleak2.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/memleak3.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/mkkeywordhash.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/mkopts.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3c.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3internalh.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/omittest.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/opcodeDoc.awk
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/report1.txt
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/showdb.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/showjournal.c
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/soak1.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/space_used.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/spaceanal.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/speedtest.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/tool/speedtest2.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/34to35.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch.fig
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch.png
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch2.fig
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch2.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/arch2b.fig
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/audit.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/autoinc.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/c_interface.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/capi3.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/capi3ref.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/changes.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/common.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/compile.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/conflict.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/copyright-release.html
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/copyright-release.pdf
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/copyright.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/datatype3.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/datatypes.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/different.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/direct1b.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/docs.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/download.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/dynload.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/faq.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/fileformat.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/formatchng.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/fullscanb.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/index-ex1-x-b.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/index.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/indirect1b1.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/lang.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/limits.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/lockingv3.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/mingw.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/mkapidoc.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/nulls.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/oldnews.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/omitted.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/opcode.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/optimizer.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/optimizing.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/optoverview.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/pragma.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/quickstart.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/shared.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/sharedcache.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/speed.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/sqlite.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/support.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/table-ex1b2.gif
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/tclsqlite.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/vdbe.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/version3.tcl
 create mode 100644 client/src/thirdparty/sqlite-3.4.2/www/whentouse.tcl

diff --git a/.gitignore b/.gitignore
index d93ba10..8a94e30 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ obj/
 retired/
 test/
 doors/
+client/src/thirdparty/sqlite-3.4.2/build
 
 */out/
 
diff --git a/LICENSE b/LICENSE
index 284f6bb..e796eed 100644
--- a/LICENSE
+++ b/LICENSE
@@ -58,6 +58,11 @@ SHA256
 https://github.com/ilvn/SHA256
 MIT
 
+SQLite 3.4.2
+------------
+https://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/distributions/1.2/repos/pkg-html/sqlite.html
+Public Domain
+
 stb_ds.h
 --------
 https://github.com/nothings/stb
diff --git a/Makefile.djgpp b/Makefile.djgpp
index de02ed2..11b0d21 100644
--- a/Makefile.djgpp
+++ b/Makefile.djgpp
@@ -35,10 +35,10 @@ BINDIR		= bin
 CFLAGS		:= $(DEBUG)
 #CFLAGS      += -DALLEGRONOTAVAIL -DALLEGRONOTPROGS -DDZCOMM_SRC
 CFLAGS      += -I$(SRCDIR)/client/src -I$(SRCDIR)/client/src/system -I$(SRCDIR)/client/src/dos -I$(SRCDIR)/client/src/gui -I$(SRCDIR)/client/src/thirdparty
-CFLAGS      += -I$(SRCDIR)/shared -I$(SRCDIR)/shared/thirdparty
+CFLAGS      += -I$(SRCDIR)/client/src/thirdparty/sqlite-3.4.2/build -I$(SRCDIR)/shared -I$(SRCDIR)/shared/thirdparty
 #CFLAGS      += -I$(SRCDIR)/client/src/thirdparty/dzcomm -I$(SRCDIR)/client/src/thirdparty/dzcomm/include
 CPPFLAGS	:=
-LDFLAGS		:=
+LDFLAGS		:= -L$(SRCDIR)/client/src/thirdparty/sqlite-3.4.2/build/.libs -lsqlite3
 #LDFLAGS		+= -L$(SRCDIR)/client/src/thirdparty/dzcomm -ldzcom
 PREFIX		:= /usr/local
 TARGET_ARCH :=
@@ -58,7 +58,7 @@ ALL_LDLIBS		:= -lc
 
 
 # Source, Binaries, Dependencies
-SRC			:= $(shell find $(SRCDIR) -type f -name '*.c' | grep -v '/linux/' | grep -v '/server/' | grep -v '/primes/' | grep -v '/font/' | grep -v '/precache/' | grep -v '/retired/' | grep -v '/test/')
+SRC			:= $(shell find $(SRCDIR) -type f -name '*.c' | grep -v '/linux/' | grep -v '/server/' | grep -v '/primes/' | grep -v '/font/' | grep -v '/precache/' | grep -v '/retired/' | grep -v '/test/' | grep -v '/sqlite-3.4.2/')
 OBJ			:= $(patsubst $(SRCDIR)/%,$(OBJDIR)/%,$(SRC:.c=.o))
 DEP			:= $(OBJ:.o=.d)
 BIN			:= $(BINDIR)/$(TARGET)
@@ -126,4 +126,3 @@ install: $(BIN)
 clean:
 	$(RM) $(OBJ) $(DEP) $(BIN)
 	$(RMDIR) $(OBJDIR) $(BINDIR) 2> /dev/null; true
-
diff --git a/buildPrerequisites.sh b/buildPrerequisites.sh
index 894d595..65f6208 100755
--- a/buildPrerequisites.sh
+++ b/buildPrerequisites.sh
@@ -78,11 +78,22 @@ function outputLicense() {
 }
 
 
-pushd font/data
-createEmbeddedBinary vga8x14 dat ../../client/src/embedded
-popd
+# Include DJGPP into the path for this script
+PATH=/opt/cross/djgpp/bin:$PATH
 
-pushd client/data
-createEmbeddedBinary mouse png ../../client/src/embedded
-popd
+#pushd font/data
+#createEmbeddedBinary vga8x14 dat ../../client/src/embedded
+#popd
 
+# Build SQLite
+pushd client/src/thirdparty/sqlite-3.4.2
+[[ -d build ]] && rm -rf build
+mkdir -p build
+cd build
+sh ../configure \
+	--disable-tcl \
+	--disable-threadsafe\
+	--build=x86_64-linux-gnu \
+	--host=i586-pc-msdosdjgpp
+make
+popd
diff --git a/client/src/browser.c b/client/src/browser.c
index d89a488..aebae23 100644
--- a/client/src/browser.c
+++ b/client/src/browser.c
@@ -29,6 +29,7 @@
 #include "listbox.h"
 
 #include "network.h"
+#include "util.h"
 
 
 static WindowT     *_winBrowser        = NULL;
@@ -62,6 +63,8 @@ static void packetHandler(PacketDecodeDataT *packet);
 
 void browserShow(void) {
 
+	char **lines = NULL;
+
 	TagItemT uiBrowser[] = {
 		T_START,
 			T_WINDOW, O(_winBrowser),
@@ -200,19 +203,18 @@ void browserShow(void) {
 	guiDebugAreaShow(W(_btnBoxTab));
 	guiDebugAreaShow(W(_btnInfoTab));
 
-	//                               123456789012345678901234567890123456789012345678901234567
-	listboxItemAdd(_lstDescription, "The Post-Terran Minerals Corporation (PTMC) digs up");
-	listboxItemAdd(_lstDescription, "minerals on all nine planets of the solar system,");
-	listboxItemAdd(_lstDescription, "employing humans and robots to do its job. Unfortunately,");
-	listboxItemAdd(_lstDescription, "the mining robots are now being controlled by a hacker,");
-	listboxItemAdd(_lstDescription, "and have taken the human workers hostage. The PTMC has");
-	listboxItemAdd(_lstDescription, "tried to get the robots back under their control, but");
-	listboxItemAdd(_lstDescription, "communication with the mining stations has been lost. In");
-	listboxItemAdd(_lstDescription, "desperation, the PTMC modifies a Pyro-GX ship for combat");
-	listboxItemAdd(_lstDescription, "and hires a mercenary, codenamed 'Material Defender', to");
-	listboxItemAdd(_lstDescription, "fly it. The mission is to destroy the infected mines and");
-	listboxItemAdd(_lstDescription, "rescue human hostages, destroying any hostile robot that");
-	listboxItemAdd(_lstDescription, "gets in the way.");
+	lines = utilWrapText(
+		"The Post-Terran Minerals Corporation (PTMC) digs up minerals on all nine planets of the solar system, "
+		"employing humans and robots to do its job. Unfortunately, the mining robots are now being controlled by a hacker, "
+		"and have taken the human workers hostage. The PTMC has tried to get the robots back under their control, but "
+		"communication with the mining stations has been lost. In desperation, the PTMC modifies a Pyro-GX ship for combat "
+		"and hires a mercenary, codenamed 'Material Defender', to fly it. The mission is to destroy the infected mines and "
+		"rescue human hostages, destroying any hostile robot that gets in the way.", 57);
+	while (arrlen(lines) > 0) {
+		listboxItemAdd(_lstDescription, lines[0]);
+		DEL(lines[0]);
+		arrdel(lines, 0);
+	}
 
 	listboxItemAdd(_lstInfo, "123456789012345678901234567890123456789012345678901234567");
 	listboxItemAdd(_lstInfo, "2");
diff --git a/client/src/thirdparty/sqlite-3.4.2/Makefile b/client/src/thirdparty/sqlite-3.4.2/Makefile
new file mode 100644
index 0000000..f56a0c4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/Makefile
@@ -0,0 +1,629 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This makefile is suppose to be configured automatically using the
+# autoconf.  But if that does not work for you, you can configure
+# the makefile manually.  Just set the parameters below to values that
+# work well for your system.
+#
+# If the configure script does not work out-of-the-box, you might
+# be able to get it to work by giving it some hints.  See the comment
+# at the beginning of configure.in for additional information.
+#
+
+# The toplevel directory of the source tree.  This is the directory
+# that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = .
+
+# C Compiler and options for use in building executables that
+# will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+
+# C Compile and options for use in building executables that 
+# will run on the target platform.  (BCC and TCC are usually the
+# same unless your are cross-compiling.)
+#
+TCC = gcc -g -O2 -I. -I${TOP}/src
+
+# Define -DNDEBUG to compile without debugging (i.e., for production usage)
+# Omitting the define will cause extra debugging code to be inserted and
+# includes extra comments when "EXPLAIN stmt" is used.
+#
+TCC += -DNDEBUG 
+
+# Compiler options needed for programs that use the TCL library.
+#
+TCC += 
+
+# The library that programs using TCL must link against.
+#
+LIBTCL =  
+
+# Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS = -DHAVE_READLINE=0 
+
+# The library that programs using readline() must link against.
+#
+LIBREADLINE = 
+
+# Should the database engine be compiled threadsafe
+#
+TCC += -DSQLITE_THREADSAFE=0
+
+# The pthreads library if needed
+#
+LIBPTHREAD=
+
+# Do threads override each others locks by default (1), or do we test (-1)
+#
+TCC += -DSQLITE_THREAD_OVERRIDE_LOCK=-1
+
+# The fdatasync library
+TLIBS = 
+
+# Flags controlling use of the in memory btree implementation
+#
+# TEMP_STORE is 0 to force temporary tables to be in a file, 1 to
+# default to file, 2 to default to memory, and 3 to force temporary
+# tables to always be in memory.
+#
+TEMP_STORE = -DTEMP_STORE=1
+
+# Version numbers and release number for the SQLite being compiled.
+#
+VERSION = 3.5
+VERSION_NUMBER = 3005006
+RELEASE = 3.5.6
+
+# Filename extensions
+#
+BEXE = .exe
+TEXE = .exe
+
+# The following variable is "1" if the configure script was able to locate
+# the tclConfig.sh file.  It is an empty string otherwise.  When this
+# variable is "1", the TCL extension library (libtclsqlite3.so) is built
+# and installed.
+#
+HAVE_TCL = 
+
+# The suffix used on shared libraries.  Ex:  ".dll", ".so", ".dylib"
+#
+SHLIB_SUFFIX = @TCL_SHLIB_SUFFIX@
+
+# The directory into which to store package information for
+
+# Some standard variables and programs
+#
+prefix = /dev/env/DJDIR
+exec_prefix = ${prefix}
+libdir = ${exec_prefix}/lib
+INSTALL = /dev/env/DJDIR/bin/ginstall -c
+LIBTOOL = ./libtool
+ALLOWRELEASE = 
+
+# libtool compile/link/install
+LTCOMPILE = $(LIBTOOL) --mode=compile --tag=CC $(TCC)
+LTLINK = $(LIBTOOL) --mode=link $(TCC) 
+LTINSTALL = $(LIBTOOL) --mode=install $(INSTALL)
+
+# nawk compatible awk.
+NAWK = gawk
+
+# You should not have to change anything below this line
+###############################################################################
+TCC += -DSQLITE_OMIT_LOAD_EXTENSION=1
+
+# Object files for the SQLite library.
+#
+LIBOBJ = alter.lo analyze.lo attach.lo auth.lo btmutex.lo btree.lo build.lo \
+         callback.lo complete.lo date.lo \
+         delete.lo expr.lo fault.lo func.lo \
+         hash.lo journal.lo insert.lo loadext.lo \
+         main.lo malloc.lo mem1.lo mem2.lo mem3.lo mem4.lo mutex.lo \
+         mutex_os2.lo mutex_unix.lo mutex_w32.lo \
+         opcodes.lo os.lo os_unix.lo os_win.lo os_os2.lo \
+         pager.lo parse.lo pragma.lo prepare.lo printf.lo random.lo \
+         select.lo table.lo tokenize.lo trigger.lo update.lo \
+         util.lo vacuum.lo \
+         vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbefifo.lo vdbemem.lo \
+         where.lo utf.lo legacy.lo vtab.lo
+
+# All of the source code files.
+#
+SRC = \
+  $(TOP)/src/alter.c \
+  $(TOP)/src/analyze.c \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/auth.c \
+  $(TOP)/src/btmutex.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/btree.h \
+  $(TOP)/src/build.c \
+  $(TOP)/src/callback.c \
+  $(TOP)/src/complete.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/delete.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/fault.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/hash.c \
+  $(TOP)/src/hash.h \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/journal.c \
+  $(TOP)/src/legacy.c \
+  $(TOP)/src/loadext.c \
+  $(TOP)/src/main.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/mem1.c \
+  $(TOP)/src/mem2.c \
+  $(TOP)/src/mem3.c \
+  $(TOP)/src/mem4.c \
+  $(TOP)/src/mutex.c \
+  $(TOP)/src/mutex_os2.c \
+  $(TOP)/src/mutex_unix.c \
+  $(TOP)/src/mutex_w32.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pager.h \
+  $(TOP)/src/parse.y \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/shell.c \
+  $(TOP)/src/sqlite.h.in \
+  $(TOP)/src/sqliteInt.h \
+  $(TOP)/src/table.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/trigger.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/update.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vacuum.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbe.h \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbeblob.c \
+  $(TOP)/src/vdbefifo.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/vdbeInt.h \
+  $(TOP)/src/vtab.c \
+  $(TOP)/src/where.c
+
+# Source code for extensions
+#
+SRC += \
+  $(TOP)/ext/fts1/fts1.c \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.c \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_porter.c \
+  $(TOP)/ext/fts1/fts1_tokenizer.h \
+  $(TOP)/ext/fts1/fts1_tokenizer1.c
+
+
+# Source code to the test files.
+#
+TESTSRC = \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/build.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/test1.c \
+  $(TOP)/src/test2.c \
+  $(TOP)/src/test3.c \
+  $(TOP)/src/test4.c \
+  $(TOP)/src/test5.c \
+  $(TOP)/src/test6.c \
+  $(TOP)/src/test7.c \
+  $(TOP)/src/test8.c \
+  $(TOP)/src/test9.c \
+  $(TOP)/src/test_autoext.c \
+  $(TOP)/src/test_async.c \
+  $(TOP)/src/test_btree.c \
+  $(TOP)/src/test_config.c \
+  $(TOP)/src/test_devsym.c \
+  $(TOP)/src/test_hexio.c \
+  $(TOP)/src/test_malloc.c \
+  $(TOP)/src/test_md5.c \
+  $(TOP)/src/test_onefile.c \
+  $(TOP)/src/test_schema.c \
+  $(TOP)/src/test_server.c \
+  $(TOP)/src/test_tclvar.c \
+  $(TOP)/src/test_thread.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/where.c \
+  parse.c
+
+# Header files used by all library source files.
+#
+HDR = \
+   sqlite3.h  \
+   $(TOP)/src/btree.h \
+   $(TOP)/src/btreeInt.h \
+   $(TOP)/src/hash.h \
+   $(TOP)/src/sqliteLimit.h \
+   $(TOP)/src/mutex.h \
+   opcodes.h \
+   $(TOP)/src/os.h \
+   $(TOP)/src/os_common.h \
+   $(TOP)/src/sqlite3ext.h \
+   $(TOP)/src/sqliteInt.h  \
+   $(TOP)/src/vdbe.h \
+   parse.h
+
+# Header files used by extensions
+#
+HDR += \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_tokenizer.h
+
+# Header files used by the VDBE submodule
+#
+VDBEHDR = \
+   $(HDR) \
+   $(TOP)/src/vdbeInt.h
+
+# This is the default Makefile target.  The objects listed here
+# are what get build when you type just "make" with no arguments.
+#
+all:	sqlite3.h libsqlite3.la sqlite3$(TEXE) $(HAVE_TCL:1=libtclsqlite3.la)
+
+Makefile: $(TOP)/Makefile.in
+	./config.status
+
+# Generate the file "last_change" which contains the date of change
+# of the most recently modified source code file
+#
+last_change:	$(SRC)
+	cat $(SRC) | grep '$$Id: ' | sort -k 5 | tail -1 \
+          | $(NAWK) '{print $$5,$$6}' >last_change
+
+libsqlite3.la:	$(LIBOBJ)
+	$(LTLINK) -o libsqlite3.la $(LIBOBJ) $(LIBPTHREAD) \
+		${ALLOWRELEASE} -rpath $(libdir) -version-info "8:6:8"
+
+libtclsqlite3.la:	tclsqlite.lo libsqlite3.la
+	$(LTLINK) -o libtclsqlite3.la tclsqlite.lo \
+		$(LIBOBJ)  $(LIBPTHREAD) \
+                -rpath $(libdir)/sqlite \
+		-version-info "8:6:8"
+
+sqlite3$(TEXE):	$(TOP)/src/shell.c libsqlite3.la sqlite3.h
+	$(LTLINK) $(READLINE_FLAGS) $(LIBPTHREAD) \
+		-o $@ $(TOP)/src/shell.c libsqlite3.la \
+		$(LIBREADLINE) $(TLIBS)
+
+# This target creates a directory named "tsrc" and fills it with
+# copies of all of the C source code and header files needed to
+# build on the target system.  Some of the C source code and header
+# files are automatically generated.  This target takes care of
+# all that automatic generation.
+#
+target_source:	$(SRC) parse.c opcodes.c keywordhash.h $(VDBEHDR) 
+	rm -rf tsrc
+	mkdir -p tsrc
+	cp $(SRC) $(VDBEHDR) tsrc
+	rm tsrc/sqlite.h.in tsrc/parse.y
+	cp parse.c opcodes.c keywordhash.h tsrc
+
+sqlite3.c:	target_source $(TOP)/tool/mksqlite3c.tcl
+	tclsh $(TOP)/tool/mksqlite3c.tcl
+
+# Rules to build the LEMON compiler generator
+#
+lemon$(BEXE):	$(TOP)/tool/lemon.c $(TOP)/tool/lempar.c
+	$(BCC) -o lemon$(BEXE) $(TOP)/tool/lemon.c
+	cp $(TOP)/tool/lempar.c .
+
+
+# Rules to build individual files
+#
+alter.lo:	$(TOP)/src/alter.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/alter.c
+
+analyze.lo:	$(TOP)/src/analyze.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/analyze.c
+
+attach.lo:	$(TOP)/src/attach.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/attach.c
+
+auth.lo:	$(TOP)/src/auth.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/auth.c
+
+btmutex.lo:	$(TOP)/src/btmutex.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/btmutex.c
+
+btree.lo:	$(TOP)/src/btree.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/btree.c
+
+build.lo:	$(TOP)/src/build.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/build.c
+
+callback.lo:	$(TOP)/src/callback.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/callback.c
+
+complete.lo:	$(TOP)/src/complete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/complete.c
+
+date.lo:	$(TOP)/src/date.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/date.c
+
+delete.lo:	$(TOP)/src/delete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/delete.c
+
+expr.lo:	$(TOP)/src/expr.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/expr.c
+
+fault.lo:	$(TOP)/src/fault.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/fault.c
+
+func.lo:	$(TOP)/src/func.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/func.c
+
+hash.lo:	$(TOP)/src/hash.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/hash.c
+
+insert.lo:	$(TOP)/src/insert.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/insert.c
+
+journal.lo:	$(TOP)/src/journal.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/journal.c
+
+legacy.lo:	$(TOP)/src/legacy.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/legacy.c
+
+loadext.lo:	$(TOP)/src/loadext.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/loadext.c
+
+main.lo:	$(TOP)/src/main.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/main.c
+
+malloc.lo:	$(TOP)/src/malloc.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/malloc.c
+
+mem1.lo:	$(TOP)/src/mem1.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem1.c
+
+mem2.lo:	$(TOP)/src/mem2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem2.c
+
+mem3.lo:	$(TOP)/src/mem3.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem3.c
+
+mem4.lo:	$(TOP)/src/mem4.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem4.c
+
+mutex.lo:	$(TOP)/src/mutex.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex.c
+
+mutex_os2.lo:	$(TOP)/src/mutex_os2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_os2.c
+
+mutex_unix.lo:	$(TOP)/src/mutex_unix.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_unix.c
+
+mutex_w32.lo:	$(TOP)/src/mutex_w32.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_w32.c
+
+pager.lo:	$(TOP)/src/pager.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/pager.c
+
+opcodes.lo:	opcodes.c
+	$(LTCOMPILE) -c opcodes.c
+
+opcodes.c:	opcodes.h $(TOP)/mkopcodec.awk
+	sort -n -b -k 3 opcodes.h | $(NAWK) -f $(TOP)/mkopcodec.awk >opcodes.c
+
+opcodes.h:	parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
+	cat parse.h $(TOP)/src/vdbe.c | $(NAWK) -f $(TOP)/mkopcodeh.awk >opcodes.h
+
+os.lo:	$(TOP)/src/os.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os.c
+
+os_unix.lo:	$(TOP)/src/os_unix.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_unix.c
+
+os_win.lo:	$(TOP)/src/os_win.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_win.c
+
+os_os2.lo:	$(TOP)/src/os_os2.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_os2.c
+
+parse.lo:	parse.c $(HDR)
+	$(LTCOMPILE) -c parse.c
+
+parse.h:	parse.c
+
+parse.c:	$(TOP)/src/parse.y lemon$(BEXE) $(TOP)/addopcodes.awk
+	cp $(TOP)/src/parse.y .
+	./lemon$(BEXE) $(OPTS) parse.y
+	mv parse.h parse.h.temp
+	$(NAWK) -f $(TOP)/addopcodes.awk parse.h.temp >parse.h
+
+pragma.lo:	$(TOP)/src/pragma.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/pragma.c
+
+prepare.lo:	$(TOP)/src/prepare.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/prepare.c
+
+printf.lo:	$(TOP)/src/printf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/printf.c
+
+random.lo:	$(TOP)/src/random.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/random.c
+
+select.lo:	$(TOP)/src/select.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/select.c
+
+sqlite3.h:	$(TOP)/src/sqlite.h.in 
+	sed -e s/--VERS--/$(RELEASE)/ $(TOP)/src/sqlite.h.in | \
+	sed -e s/--VERSION-NUMBER--/$(VERSION_NUMBER)/ >sqlite3.h
+
+table.lo:	$(TOP)/src/table.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/table.c
+
+tclsqlite.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tclsqlite.c
+
+tokenize.lo:	$(TOP)/src/tokenize.c keywordhash.h $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tokenize.c
+
+keywordhash.h:	$(TOP)/tool/mkkeywordhash.c
+	$(BCC) -o mkkeywordhash$(BEXE) $(OPTS) $(TOP)/tool/mkkeywordhash.c
+	./mkkeywordhash$(BEXE) >keywordhash.h
+
+trigger.lo:	$(TOP)/src/trigger.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/trigger.c
+
+update.lo:	$(TOP)/src/update.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/update.c
+
+utf.lo:	$(TOP)/src/utf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/utf.c
+
+util.lo:	$(TOP)/src/util.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/util.c
+
+vacuum.lo:	$(TOP)/src/vacuum.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/vacuum.c
+
+vdbe.lo:	$(TOP)/src/vdbe.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbe.c
+
+vdbeapi.lo:	$(TOP)/src/vdbeapi.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeapi.c
+
+vdbeaux.lo:	$(TOP)/src/vdbeaux.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeaux.c
+
+vdbeblob.lo:	$(TOP)/src/vdbeblob.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeblob.c
+
+vdbefifo.lo:	$(TOP)/src/vdbefifo.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbefifo.c
+
+vdbemem.lo:	$(TOP)/src/vdbemem.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbemem.c
+
+vtab.lo:	$(TOP)/src/vtab.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vtab.c
+
+where.lo:	$(TOP)/src/where.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/where.c
+
+tclsqlite-shell.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCLSH=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite-stubs.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCL_USE_STUBS=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite3:	tclsqlite-shell.lo libsqlite3.la
+	$(LTLINK) -o tclsqlite3 tclsqlite-shell.lo \
+		 libsqlite3.la $(LIBTCL)
+
+testfixture$(TEXE):	$(TOP)/src/tclsqlite.c libsqlite3.la $(TESTSRC)
+	$(LTLINK) -DTCLSH=1 -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1 \
+                -DSQLITE_NO_SYNC=1 $(TEMP_STORE) \
+		-o testfixture $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libsqlite3.la $(LIBTCL)
+
+
+fulltest:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/all.test
+
+test:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/quick.test
+
+sqlite3_analyzer$(TEXE):	$(TOP)/src/tclsqlite.c libtclsqlite3.la \
+				$(TESTSRC) $(TOP)/tool/spaceanal.tcl
+	sed \
+	  -e '/^#/d' \
+	  -e 's,\\,\\\\,g' \
+	  -e 's,",\\",g' \
+	  -e 's,^,",' \
+	  -e 's,$$,\\n",' \
+	  $(TOP)/tool/spaceanal.tcl >spaceanal_tcl.h
+	$(LTLINK) -DTCLSH=2 -DSQLITE_TEST=1 $(TEMP_STORE)\
+                -o sqlite3_analyzer$(EXE) $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libtclsqlite3.la $(LIBTCL)
+
+
+install:	sqlite3$(BEXE) libsqlite3.la sqlite3.h ${HAVE_TCL:1=tcl_install}
+	$(INSTALL) -d $(DESTDIR)$(libdir)
+	$(LTINSTALL) libsqlite3.la $(DESTDIR)$(libdir)
+	$(INSTALL) -d $(DESTDIR)$(exec_prefix)/bin
+	$(LTINSTALL) sqlite3$(BEXE) $(DESTDIR)$(exec_prefix)/bin
+	$(INSTALL) -d $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 sqlite3.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 $(TOP)/src/sqlite3ext.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -d $(DESTDIR)$(libdir)/pkgconfig; 
+	$(INSTALL) -m 0644 sqlite3.pc $(DESTDIR)$(libdir)/pkgconfig; 
+
+tcl_install:	libtclsqlite3.la
+	tclsh $(TOP)/tclinstaller.tcl $(VERSION)
+
+clean:	
+	rm -f *.lo *.la *.o sqlite3$(TEXE) libsqlite3.la
+	rm -f sqlite3.h opcodes.*
+	rm -rf .libs .deps 
+	rm -f lemon$(BEXE) lempar.c parse.* sqlite*.tar.gz
+	rm -f mkkeywordhash$(BEXE) keywordhash.h
+	rm -f $(PUBLISH)
+	rm -f *.da *.bb *.bbg gmon.out
+	rm -f testfixture$(TEXE) test.db
+	rm -f common.tcl
+	rm -f sqlite3.dll sqlite3.lib sqlite3.def
+
+distclean:	clean
+	rm -f config.log config.status libtool Makefile config.h sqlite3.pc
+
+#
+# Windows section
+#
+dll: sqlite3.dll
+
+REAL_LIBOBJ = $(LIBOBJ:%.lo=.libs/%.o)
+
+$(REAL_LIBOBJ): $(LIBOBJ)
+
+sqlite3.def: $(REAL_LIBOBJ)
+	echo 'EXPORTS' >sqlite3.def
+	nm $(REAL_LIBOBJ) | grep ' T ' | grep ' _sqlite3_' \
+		| sed 's/^.* _//' >>sqlite3.def
+
+sqlite3.dll: $(REAL_LIBOBJ) sqlite3.def
+	$(TCC) -shared -o sqlite3.dll sqlite3.def \
+		-Wl,"--strip-all" $(REAL_LIBOBJ)
diff --git a/client/src/thirdparty/sqlite-3.4.2/Makefile.arm b/client/src/thirdparty/sqlite-3.4.2/Makefile.arm
new file mode 100644
index 0000000..921826b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/Makefile.arm
@@ -0,0 +1,138 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This is a template makefile for SQLite.  Most people prefer to
+# use the autoconf generated "configure" script to generate the
+# makefile automatically.  But that does not work for everybody
+# and in every situation.  If you are having problems with the
+# "configure" script, you might want to try this makefile as an
+# alternative.  Create a copy of this file, edit the parameters
+# below and type "make".
+#
+
+#### The directory where to find the mingw32ce tools
+MINGW32CE = /opt/mingw32ce/bin
+
+#### The target prefix of the mingw32ce tools
+TARGET = arm-wince-mingw32ce
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = ../sqlite
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+USLEEP = 
+#USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+THREADSAFE = -DTHREADSAFE=1
+#THREADSAFE = -DTHREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+#TLIBS = -lrt    # fdatasync on Solaris 8
+TLIBS = 
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1 -DOS_WIN=1 -D_WIN32_WCE=1
+#OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+EXE = .exe
+#EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+#TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+TCC = $(MINGW32CE)/$(TARGET)-gcc -O2
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#### Tools used to build a static library.
+#
+#AR = ar cr
+#AR = /opt/mingw/bin/i386-mingw32-ar cr
+AR = $(MINGW32CE)/$(TARGET)-ar cr
+#RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+RANLIB = $(MINGW32CE)/$(TARGET)-ranlib
+
+#MKSHLIB = gcc -shared
+#SO = so
+#SHPREFIX = lib
+MKSHLIB = $(MINGW32CE)/$(TARGET)-gcc -shared
+SO = dll
+SHPREFIX =
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.4linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.4win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.4linux/libtcl8.4g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.4win/libtcl84s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+TCLOBJ =
+#TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+# You should not have to change anything below this line
+###############################################################################
+include $(TOP)/main.mk
diff --git a/client/src/thirdparty/sqlite-3.4.2/Makefile.in b/client/src/thirdparty/sqlite-3.4.2/Makefile.in
new file mode 100644
index 0000000..6e01c4c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/Makefile.in
@@ -0,0 +1,629 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This makefile is suppose to be configured automatically using the
+# autoconf.  But if that does not work for you, you can configure
+# the makefile manually.  Just set the parameters below to values that
+# work well for your system.
+#
+# If the configure script does not work out-of-the-box, you might
+# be able to get it to work by giving it some hints.  See the comment
+# at the beginning of configure.in for additional information.
+#
+
+# The toplevel directory of the source tree.  This is the directory
+# that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = @srcdir@
+
+# C Compiler and options for use in building executables that
+# will run on the platform that is doing the build.
+#
+BCC = @BUILD_CC@ @BUILD_CFLAGS@
+
+# C Compile and options for use in building executables that 
+# will run on the target platform.  (BCC and TCC are usually the
+# same unless your are cross-compiling.)
+#
+TCC = @CC@ @CFLAGS@ -I. -I${TOP}/src
+
+# Define -DNDEBUG to compile without debugging (i.e., for production usage)
+# Omitting the define will cause extra debugging code to be inserted and
+# includes extra comments when "EXPLAIN stmt" is used.
+#
+TCC += @TARGET_DEBUG@ @XTHREADCONNECT@
+
+# Compiler options needed for programs that use the TCL library.
+#
+TCC += @TCL_INCLUDE_SPEC@
+
+# The library that programs using TCL must link against.
+#
+LIBTCL = @TCL_LIB_SPEC@ @TCL_LIBS@
+
+# Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS = -DHAVE_READLINE=@TARGET_HAVE_READLINE@ @TARGET_READLINE_INC@
+
+# The library that programs using readline() must link against.
+#
+LIBREADLINE = @TARGET_READLINE_LIBS@
+
+# Should the database engine be compiled threadsafe
+#
+TCC += -DSQLITE_THREADSAFE=@SQLITE_THREADSAFE@
+
+# The pthreads library if needed
+#
+LIBPTHREAD=@TARGET_THREAD_LIB@
+
+# Do threads override each others locks by default (1), or do we test (-1)
+#
+TCC += -DSQLITE_THREAD_OVERRIDE_LOCK=@THREADSOVERRIDELOCKS@
+
+# The fdatasync library
+TLIBS = @LIBS@
+
+# Flags controlling use of the in memory btree implementation
+#
+# TEMP_STORE is 0 to force temporary tables to be in a file, 1 to
+# default to file, 2 to default to memory, and 3 to force temporary
+# tables to always be in memory.
+#
+TEMP_STORE = -DTEMP_STORE=@TEMP_STORE@
+
+# Version numbers and release number for the SQLite being compiled.
+#
+VERSION = @VERSION@
+VERSION_NUMBER = @VERSION_NUMBER@
+RELEASE = @RELEASE@
+
+# Filename extensions
+#
+BEXE = @BUILD_EXEEXT@
+TEXE = @TARGET_EXEEXT@
+
+# The following variable is "1" if the configure script was able to locate
+# the tclConfig.sh file.  It is an empty string otherwise.  When this
+# variable is "1", the TCL extension library (libtclsqlite3.so) is built
+# and installed.
+#
+HAVE_TCL = @HAVE_TCL@
+
+# The suffix used on shared libraries.  Ex:  ".dll", ".so", ".dylib"
+#
+SHLIB_SUFFIX = @TCL_SHLIB_SUFFIX@
+
+# The directory into which to store package information for
+
+# Some standard variables and programs
+#
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+libdir = @libdir@
+INSTALL = @INSTALL@
+LIBTOOL = ./libtool
+ALLOWRELEASE = @ALLOWRELEASE@
+
+# libtool compile/link/install
+LTCOMPILE = $(LIBTOOL) --mode=compile --tag=CC $(TCC)
+LTLINK = $(LIBTOOL) --mode=link $(TCC) @LDFLAGS@
+LTINSTALL = $(LIBTOOL) --mode=install $(INSTALL)
+
+# nawk compatible awk.
+NAWK = @AWK@
+
+# You should not have to change anything below this line
+###############################################################################
+TCC += -DSQLITE_OMIT_LOAD_EXTENSION=1
+
+# Object files for the SQLite library.
+#
+LIBOBJ = alter.lo analyze.lo attach.lo auth.lo btmutex.lo btree.lo build.lo \
+         callback.lo complete.lo date.lo \
+         delete.lo expr.lo fault.lo func.lo \
+         hash.lo journal.lo insert.lo loadext.lo \
+         main.lo malloc.lo mem1.lo mem2.lo mem3.lo mem4.lo mutex.lo \
+         mutex_os2.lo mutex_unix.lo mutex_w32.lo \
+         opcodes.lo os.lo os_unix.lo os_win.lo os_os2.lo \
+         pager.lo parse.lo pragma.lo prepare.lo printf.lo random.lo \
+         select.lo table.lo tokenize.lo trigger.lo update.lo \
+         util.lo vacuum.lo \
+         vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbefifo.lo vdbemem.lo \
+         where.lo utf.lo legacy.lo vtab.lo
+
+# All of the source code files.
+#
+SRC = \
+  $(TOP)/src/alter.c \
+  $(TOP)/src/analyze.c \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/auth.c \
+  $(TOP)/src/btmutex.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/btree.h \
+  $(TOP)/src/build.c \
+  $(TOP)/src/callback.c \
+  $(TOP)/src/complete.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/delete.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/fault.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/hash.c \
+  $(TOP)/src/hash.h \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/journal.c \
+  $(TOP)/src/legacy.c \
+  $(TOP)/src/loadext.c \
+  $(TOP)/src/main.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/mem1.c \
+  $(TOP)/src/mem2.c \
+  $(TOP)/src/mem3.c \
+  $(TOP)/src/mem4.c \
+  $(TOP)/src/mutex.c \
+  $(TOP)/src/mutex_os2.c \
+  $(TOP)/src/mutex_unix.c \
+  $(TOP)/src/mutex_w32.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pager.h \
+  $(TOP)/src/parse.y \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/shell.c \
+  $(TOP)/src/sqlite.h.in \
+  $(TOP)/src/sqliteInt.h \
+  $(TOP)/src/table.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/trigger.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/update.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vacuum.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbe.h \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbeblob.c \
+  $(TOP)/src/vdbefifo.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/vdbeInt.h \
+  $(TOP)/src/vtab.c \
+  $(TOP)/src/where.c
+
+# Source code for extensions
+#
+SRC += \
+  $(TOP)/ext/fts1/fts1.c \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.c \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_porter.c \
+  $(TOP)/ext/fts1/fts1_tokenizer.h \
+  $(TOP)/ext/fts1/fts1_tokenizer1.c
+
+
+# Source code to the test files.
+#
+TESTSRC = \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/build.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/test1.c \
+  $(TOP)/src/test2.c \
+  $(TOP)/src/test3.c \
+  $(TOP)/src/test4.c \
+  $(TOP)/src/test5.c \
+  $(TOP)/src/test6.c \
+  $(TOP)/src/test7.c \
+  $(TOP)/src/test8.c \
+  $(TOP)/src/test9.c \
+  $(TOP)/src/test_autoext.c \
+  $(TOP)/src/test_async.c \
+  $(TOP)/src/test_btree.c \
+  $(TOP)/src/test_config.c \
+  $(TOP)/src/test_devsym.c \
+  $(TOP)/src/test_hexio.c \
+  $(TOP)/src/test_malloc.c \
+  $(TOP)/src/test_md5.c \
+  $(TOP)/src/test_onefile.c \
+  $(TOP)/src/test_schema.c \
+  $(TOP)/src/test_server.c \
+  $(TOP)/src/test_tclvar.c \
+  $(TOP)/src/test_thread.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/where.c \
+  parse.c
+
+# Header files used by all library source files.
+#
+HDR = \
+   sqlite3.h  \
+   $(TOP)/src/btree.h \
+   $(TOP)/src/btreeInt.h \
+   $(TOP)/src/hash.h \
+   $(TOP)/src/sqliteLimit.h \
+   $(TOP)/src/mutex.h \
+   opcodes.h \
+   $(TOP)/src/os.h \
+   $(TOP)/src/os_common.h \
+   $(TOP)/src/sqlite3ext.h \
+   $(TOP)/src/sqliteInt.h  \
+   $(TOP)/src/vdbe.h \
+   parse.h
+
+# Header files used by extensions
+#
+HDR += \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_tokenizer.h
+
+# Header files used by the VDBE submodule
+#
+VDBEHDR = \
+   $(HDR) \
+   $(TOP)/src/vdbeInt.h
+
+# This is the default Makefile target.  The objects listed here
+# are what get build when you type just "make" with no arguments.
+#
+all:	sqlite3.h libsqlite3.la sqlite3$(TEXE) $(HAVE_TCL:1=libtclsqlite3.la)
+
+Makefile: $(TOP)/Makefile.in
+	./config.status
+
+# Generate the file "last_change" which contains the date of change
+# of the most recently modified source code file
+#
+last_change:	$(SRC)
+	cat $(SRC) | grep '$$Id: ' | sort -k 5 | tail -1 \
+          | $(NAWK) '{print $$5,$$6}' >last_change
+
+libsqlite3.la:	$(LIBOBJ)
+	$(LTLINK) -o libsqlite3.la $(LIBOBJ) $(LIBPTHREAD) \
+		${ALLOWRELEASE} -rpath $(libdir) -version-info "8:6:8"
+
+libtclsqlite3.la:	tclsqlite.lo libsqlite3.la
+	$(LTLINK) -o libtclsqlite3.la tclsqlite.lo \
+		$(LIBOBJ) @TCL_STUB_LIB_SPEC@ $(LIBPTHREAD) \
+                -rpath $(libdir)/sqlite \
+		-version-info "8:6:8"
+
+sqlite3$(TEXE):	$(TOP)/src/shell.c libsqlite3.la sqlite3.h
+	$(LTLINK) $(READLINE_FLAGS) $(LIBPTHREAD) \
+		-o $@ $(TOP)/src/shell.c libsqlite3.la \
+		$(LIBREADLINE) $(TLIBS)
+
+# This target creates a directory named "tsrc" and fills it with
+# copies of all of the C source code and header files needed to
+# build on the target system.  Some of the C source code and header
+# files are automatically generated.  This target takes care of
+# all that automatic generation.
+#
+target_source:	$(SRC) parse.c opcodes.c keywordhash.h $(VDBEHDR) 
+	rm -rf tsrc
+	mkdir -p tsrc
+	cp $(SRC) $(VDBEHDR) tsrc
+	rm tsrc/sqlite.h.in tsrc/parse.y
+	cp parse.c opcodes.c keywordhash.h tsrc
+
+sqlite3.c:	target_source $(TOP)/tool/mksqlite3c.tcl
+	tclsh $(TOP)/tool/mksqlite3c.tcl
+
+# Rules to build the LEMON compiler generator
+#
+lemon$(BEXE):	$(TOP)/tool/lemon.c $(TOP)/tool/lempar.c
+	$(BCC) -o lemon$(BEXE) $(TOP)/tool/lemon.c
+	cp $(TOP)/tool/lempar.c .
+
+
+# Rules to build individual files
+#
+alter.lo:	$(TOP)/src/alter.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/alter.c
+
+analyze.lo:	$(TOP)/src/analyze.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/analyze.c
+
+attach.lo:	$(TOP)/src/attach.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/attach.c
+
+auth.lo:	$(TOP)/src/auth.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/auth.c
+
+btmutex.lo:	$(TOP)/src/btmutex.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/btmutex.c
+
+btree.lo:	$(TOP)/src/btree.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/btree.c
+
+build.lo:	$(TOP)/src/build.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/build.c
+
+callback.lo:	$(TOP)/src/callback.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/callback.c
+
+complete.lo:	$(TOP)/src/complete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/complete.c
+
+date.lo:	$(TOP)/src/date.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/date.c
+
+delete.lo:	$(TOP)/src/delete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/delete.c
+
+expr.lo:	$(TOP)/src/expr.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/expr.c
+
+fault.lo:	$(TOP)/src/fault.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/fault.c
+
+func.lo:	$(TOP)/src/func.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/func.c
+
+hash.lo:	$(TOP)/src/hash.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/hash.c
+
+insert.lo:	$(TOP)/src/insert.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/insert.c
+
+journal.lo:	$(TOP)/src/journal.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/journal.c
+
+legacy.lo:	$(TOP)/src/legacy.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/legacy.c
+
+loadext.lo:	$(TOP)/src/loadext.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/loadext.c
+
+main.lo:	$(TOP)/src/main.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/main.c
+
+malloc.lo:	$(TOP)/src/malloc.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/malloc.c
+
+mem1.lo:	$(TOP)/src/mem1.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem1.c
+
+mem2.lo:	$(TOP)/src/mem2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem2.c
+
+mem3.lo:	$(TOP)/src/mem3.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem3.c
+
+mem4.lo:	$(TOP)/src/mem4.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem4.c
+
+mutex.lo:	$(TOP)/src/mutex.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex.c
+
+mutex_os2.lo:	$(TOP)/src/mutex_os2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_os2.c
+
+mutex_unix.lo:	$(TOP)/src/mutex_unix.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_unix.c
+
+mutex_w32.lo:	$(TOP)/src/mutex_w32.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_w32.c
+
+pager.lo:	$(TOP)/src/pager.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/pager.c
+
+opcodes.lo:	opcodes.c
+	$(LTCOMPILE) -c opcodes.c
+
+opcodes.c:	opcodes.h $(TOP)/mkopcodec.awk
+	sort -n -b -k 3 opcodes.h | $(NAWK) -f $(TOP)/mkopcodec.awk >opcodes.c
+
+opcodes.h:	parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
+	cat parse.h $(TOP)/src/vdbe.c | $(NAWK) -f $(TOP)/mkopcodeh.awk >opcodes.h
+
+os.lo:	$(TOP)/src/os.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os.c
+
+os_unix.lo:	$(TOP)/src/os_unix.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_unix.c
+
+os_win.lo:	$(TOP)/src/os_win.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_win.c
+
+os_os2.lo:	$(TOP)/src/os_os2.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_os2.c
+
+parse.lo:	parse.c $(HDR)
+	$(LTCOMPILE) -c parse.c
+
+parse.h:	parse.c
+
+parse.c:	$(TOP)/src/parse.y lemon$(BEXE) $(TOP)/addopcodes.awk
+	cp $(TOP)/src/parse.y .
+	./lemon$(BEXE) $(OPTS) parse.y
+	mv parse.h parse.h.temp
+	$(NAWK) -f $(TOP)/addopcodes.awk parse.h.temp >parse.h
+
+pragma.lo:	$(TOP)/src/pragma.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/pragma.c
+
+prepare.lo:	$(TOP)/src/prepare.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/prepare.c
+
+printf.lo:	$(TOP)/src/printf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/printf.c
+
+random.lo:	$(TOP)/src/random.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/random.c
+
+select.lo:	$(TOP)/src/select.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/select.c
+
+sqlite3.h:	$(TOP)/src/sqlite.h.in 
+	sed -e s/--VERS--/$(RELEASE)/ $(TOP)/src/sqlite.h.in | \
+	sed -e s/--VERSION-NUMBER--/$(VERSION_NUMBER)/ >sqlite3.h
+
+table.lo:	$(TOP)/src/table.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/table.c
+
+tclsqlite.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tclsqlite.c
+
+tokenize.lo:	$(TOP)/src/tokenize.c keywordhash.h $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tokenize.c
+
+keywordhash.h:	$(TOP)/tool/mkkeywordhash.c
+	$(BCC) -o mkkeywordhash$(BEXE) $(OPTS) $(TOP)/tool/mkkeywordhash.c
+	./mkkeywordhash$(BEXE) >keywordhash.h
+
+trigger.lo:	$(TOP)/src/trigger.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/trigger.c
+
+update.lo:	$(TOP)/src/update.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/update.c
+
+utf.lo:	$(TOP)/src/utf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/utf.c
+
+util.lo:	$(TOP)/src/util.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/util.c
+
+vacuum.lo:	$(TOP)/src/vacuum.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/vacuum.c
+
+vdbe.lo:	$(TOP)/src/vdbe.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbe.c
+
+vdbeapi.lo:	$(TOP)/src/vdbeapi.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeapi.c
+
+vdbeaux.lo:	$(TOP)/src/vdbeaux.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeaux.c
+
+vdbeblob.lo:	$(TOP)/src/vdbeblob.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeblob.c
+
+vdbefifo.lo:	$(TOP)/src/vdbefifo.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbefifo.c
+
+vdbemem.lo:	$(TOP)/src/vdbemem.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbemem.c
+
+vtab.lo:	$(TOP)/src/vtab.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vtab.c
+
+where.lo:	$(TOP)/src/where.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/where.c
+
+tclsqlite-shell.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCLSH=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite-stubs.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCL_USE_STUBS=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite3:	tclsqlite-shell.lo libsqlite3.la
+	$(LTLINK) -o tclsqlite3 tclsqlite-shell.lo \
+		 libsqlite3.la $(LIBTCL)
+
+testfixture$(TEXE):	$(TOP)/src/tclsqlite.c libsqlite3.la $(TESTSRC)
+	$(LTLINK) -DTCLSH=1 -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1 \
+                -DSQLITE_NO_SYNC=1 $(TEMP_STORE) \
+		-o testfixture $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libsqlite3.la $(LIBTCL)
+
+
+fulltest:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/all.test
+
+test:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/quick.test
+
+sqlite3_analyzer$(TEXE):	$(TOP)/src/tclsqlite.c libtclsqlite3.la \
+				$(TESTSRC) $(TOP)/tool/spaceanal.tcl
+	sed \
+	  -e '/^#/d' \
+	  -e 's,\\,\\\\,g' \
+	  -e 's,",\\",g' \
+	  -e 's,^,",' \
+	  -e 's,$$,\\n",' \
+	  $(TOP)/tool/spaceanal.tcl >spaceanal_tcl.h
+	$(LTLINK) -DTCLSH=2 -DSQLITE_TEST=1 $(TEMP_STORE)\
+                -o sqlite3_analyzer$(EXE) $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libtclsqlite3.la $(LIBTCL)
+
+
+install:	sqlite3$(BEXE) libsqlite3.la sqlite3.h ${HAVE_TCL:1=tcl_install}
+	$(INSTALL) -d $(DESTDIR)$(libdir)
+	$(LTINSTALL) libsqlite3.la $(DESTDIR)$(libdir)
+	$(INSTALL) -d $(DESTDIR)$(exec_prefix)/bin
+	$(LTINSTALL) sqlite3$(BEXE) $(DESTDIR)$(exec_prefix)/bin
+	$(INSTALL) -d $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 sqlite3.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 $(TOP)/src/sqlite3ext.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -d $(DESTDIR)$(libdir)/pkgconfig; 
+	$(INSTALL) -m 0644 sqlite3.pc $(DESTDIR)$(libdir)/pkgconfig; 
+
+tcl_install:	libtclsqlite3.la
+	tclsh $(TOP)/tclinstaller.tcl $(VERSION)
+
+clean:	
+	rm -f *.lo *.la *.o sqlite3$(TEXE) libsqlite3.la
+	rm -f sqlite3.h opcodes.*
+	rm -rf .libs .deps 
+	rm -f lemon$(BEXE) lempar.c parse.* sqlite*.tar.gz
+	rm -f mkkeywordhash$(BEXE) keywordhash.h
+	rm -f $(PUBLISH)
+	rm -f *.da *.bb *.bbg gmon.out
+	rm -f testfixture$(TEXE) test.db
+	rm -f common.tcl
+	rm -f sqlite3.dll sqlite3.lib sqlite3.def
+
+distclean:	clean
+	rm -f config.log config.status libtool Makefile config.h sqlite3.pc
+
+#
+# Windows section
+#
+dll: sqlite3.dll
+
+REAL_LIBOBJ = $(LIBOBJ:%.lo=.libs/%.o)
+
+$(REAL_LIBOBJ): $(LIBOBJ)
+
+sqlite3.def: $(REAL_LIBOBJ)
+	echo 'EXPORTS' >sqlite3.def
+	nm $(REAL_LIBOBJ) | grep ' T ' | grep ' _sqlite3_' \
+		| sed 's/^.* _//' >>sqlite3.def
+
+sqlite3.dll: $(REAL_LIBOBJ) sqlite3.def
+	$(TCC) -shared -o sqlite3.dll sqlite3.def \
+		-Wl,"--strip-all" $(REAL_LIBOBJ)
diff --git a/client/src/thirdparty/sqlite-3.4.2/Makefile.linux-gcc b/client/src/thirdparty/sqlite-3.4.2/Makefile.linux-gcc
new file mode 100644
index 0000000..2bb6184
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/Makefile.linux-gcc
@@ -0,0 +1,128 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This is a template makefile for SQLite.  Most people prefer to
+# use the autoconf generated "configure" script to generate the
+# makefile automatically.  But that does not work for everybody
+# and in every situation.  If you are having problems with the
+# "configure" script, you might want to try this makefile as an
+# alternative.  Create a copy of this file, edit the parameters
+# below and type "make".
+#
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = ../sqlite
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+#USLEEP = 
+USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+#THREADSAFE = -DTHREADSAFE=1
+THREADSAFE = -DTHREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+#TLIBS = -lrt    # fdatasync on Solaris 8
+TLIBS = 
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1
+OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+#EXE = .exe
+EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#### Tools used to build a static library.
+#
+AR = ar cr
+#AR = /opt/mingw/bin/i386-mingw32-ar cr
+RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+
+MKSHLIB = gcc -shared
+SO = so
+SHPREFIX = lib
+# SO = dll
+# SHPREFIX =
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.4linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.4win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.4linux/libtcl8.4g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.4win/libtcl84s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+#TCLOBJ =
+TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+# You should not have to change anything below this line
+###############################################################################
+include $(TOP)/main.mk
diff --git a/client/src/thirdparty/sqlite-3.4.2/Makefile.org b/client/src/thirdparty/sqlite-3.4.2/Makefile.org
new file mode 100644
index 0000000..5efb24a
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/Makefile.org
@@ -0,0 +1,622 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This makefile is suppose to be configured automatically using the
+# autoconf.  But if that does not work for you, you can configure
+# the makefile manually.  Just set the parameters below to values that
+# work well for your system.
+#
+# If the configure script does not work out-of-the-box, you might
+# be able to get it to work by giving it some hints.  See the comment
+# at the beginning of configure.in for additional information.
+#
+
+# The toplevel directory of the source tree.  This is the directory
+# that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = @srcdir@
+
+# C Compiler and options for use in building executables that
+# will run on the platform that is doing the build.
+#
+BCC = @BUILD_CC@ @BUILD_CFLAGS@
+
+# C Compile and options for use in building executables that 
+# will run on the target platform.  (BCC and TCC are usually the
+# same unless your are cross-compiling.)
+#
+TCC = @CC@ @CFLAGS@ -I. -I${TOP}/src
+
+# Define -DNDEBUG to compile without debugging (i.e., for production usage)
+# Omitting the define will cause extra debugging code to be inserted and
+# includes extra comments when "EXPLAIN stmt" is used.
+#
+TCC += @TARGET_DEBUG@ @XTHREADCONNECT@
+
+# Compiler options needed for programs that use the TCL library.
+#
+TCC += @TCL_INCLUDE_SPEC@
+
+# The library that programs using TCL must link against.
+#
+LIBTCL = @TCL_LIB_SPEC@ @TCL_LIBS@
+
+# Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS = -DHAVE_READLINE=@TARGET_HAVE_READLINE@ @TARGET_READLINE_INC@
+
+# The library that programs using readline() must link against.
+#
+LIBREADLINE = @TARGET_READLINE_LIBS@
+
+# Should the database engine be compiled threadsafe
+#
+TCC += -DSQLITE_THREADSAFE=@SQLITE_THREADSAFE@
+
+# The pthreads library if needed
+#
+LIBPTHREAD=@TARGET_THREAD_LIB@
+
+# Do threads override each others locks by default (1), or do we test (-1)
+#
+TCC += -DSQLITE_THREAD_OVERRIDE_LOCK=@THREADSOVERRIDELOCKS@
+
+# The fdatasync library
+TLIBS = @LIBS@
+
+# Flags controlling use of the in memory btree implementation
+#
+# TEMP_STORE is 0 to force temporary tables to be in a file, 1 to
+# default to file, 2 to default to memory, and 3 to force temporary
+# tables to always be in memory.
+#
+TEMP_STORE = -DTEMP_STORE=@TEMP_STORE@
+
+# Version numbers and release number for the SQLite being compiled.
+#
+VERSION = @VERSION@
+VERSION_NUMBER = @VERSION_NUMBER@
+RELEASE = @RELEASE@
+
+# Filename extensions
+#
+BEXE = @BUILD_EXEEXT@
+TEXE = @TARGET_EXEEXT@
+
+# The following variable is "1" if the configure script was able to locate
+# the tclConfig.sh file.  It is an empty string otherwise.  When this
+# variable is "1", the TCL extension library (libtclsqlite3.so) is built
+# and installed.
+#
+HAVE_TCL = @HAVE_TCL@
+
+# The suffix used on shared libraries.  Ex:  ".dll", ".so", ".dylib"
+#
+SHLIB_SUFFIX = @TCL_SHLIB_SUFFIX@
+
+# The directory into which to store package information for
+
+# Some standard variables and programs
+#
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+libdir = @libdir@
+INSTALL = @INSTALL@
+LIBTOOL = ./libtool
+ALLOWRELEASE = @ALLOWRELEASE@
+
+# libtool compile/link/install
+LTCOMPILE = $(LIBTOOL) --mode=compile --tag=CC $(TCC)
+LTLINK = $(LIBTOOL) --mode=link $(TCC) @LDFLAGS@
+LTINSTALL = $(LIBTOOL) --mode=install $(INSTALL)
+
+# nawk compatible awk.
+NAWK = @AWK@
+
+# You should not have to change anything below this line
+###############################################################################
+TCC += -DSQLITE_OMIT_LOAD_EXTENSION=1
+
+# Object files for the SQLite library.
+#
+LIBOBJ = alter.lo analyze.lo attach.lo auth.lo btmutex.lo btree.lo build.lo \
+         callback.lo complete.lo date.lo \
+         delete.lo expr.lo func.lo hash.lo journal.lo insert.lo loadext.lo \
+         main.lo malloc.lo mem1.lo mem2.lo mem3.lo mem4.lo mutex.lo \
+         mutex_os2.lo mutex_unix.lo mutex_w32.lo \
+         opcodes.lo os.lo os_unix.lo os_win.lo os_os2.lo \
+         pager.lo parse.lo pragma.lo prepare.lo printf.lo random.lo \
+         select.lo table.lo tokenize.lo trigger.lo update.lo \
+         util.lo vacuum.lo \
+         vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbefifo.lo vdbemem.lo \
+         where.lo utf.lo legacy.lo vtab.lo
+
+# All of the source code files.
+#
+SRC = \
+  $(TOP)/src/alter.c \
+  $(TOP)/src/analyze.c \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/auth.c \
+  $(TOP)/src/btmutex.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/btree.h \
+  $(TOP)/src/build.c \
+  $(TOP)/src/callback.c \
+  $(TOP)/src/complete.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/delete.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/hash.c \
+  $(TOP)/src/hash.h \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/journal.c \
+  $(TOP)/src/legacy.c \
+  $(TOP)/src/loadext.c \
+  $(TOP)/src/main.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/mem1.c \
+  $(TOP)/src/mem2.c \
+  $(TOP)/src/mem3.c \
+  $(TOP)/src/mem4.c \
+  $(TOP)/src/mutex.c \
+  $(TOP)/src/mutex_os2.c \
+  $(TOP)/src/mutex_unix.c \
+  $(TOP)/src/mutex_w32.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pager.h \
+  $(TOP)/src/parse.y \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/shell.c \
+  $(TOP)/src/sqlite.h.in \
+  $(TOP)/src/sqliteInt.h \
+  $(TOP)/src/table.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/trigger.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/update.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vacuum.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbe.h \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbeblob.c \
+  $(TOP)/src/vdbefifo.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/vdbeInt.h \
+  $(TOP)/src/vtab.c \
+  $(TOP)/src/where.c
+
+# Source code for extensions
+#
+SRC += \
+  $(TOP)/ext/fts1/fts1.c \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.c \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_porter.c \
+  $(TOP)/ext/fts1/fts1_tokenizer.h \
+  $(TOP)/ext/fts1/fts1_tokenizer1.c
+
+
+# Source code to the test files.
+#
+TESTSRC = \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/build.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/test1.c \
+  $(TOP)/src/test2.c \
+  $(TOP)/src/test3.c \
+  $(TOP)/src/test4.c \
+  $(TOP)/src/test5.c \
+  $(TOP)/src/test6.c \
+  $(TOP)/src/test7.c \
+  $(TOP)/src/test8.c \
+  $(TOP)/src/test9.c \
+  $(TOP)/src/test_autoext.c \
+  $(TOP)/src/test_async.c \
+  $(TOP)/src/test_btree.c \
+  $(TOP)/src/test_config.c \
+  $(TOP)/src/test_hexio.c \
+  $(TOP)/src/test_malloc.c \
+  $(TOP)/src/test_md5.c \
+  $(TOP)/src/test_onefile.c \
+  $(TOP)/src/test_schema.c \
+  $(TOP)/src/test_server.c \
+  $(TOP)/src/test_tclvar.c \
+  $(TOP)/src/test_thread.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/where.c \
+  parse.c
+
+# Header files used by all library source files.
+#
+HDR = \
+   sqlite3.h  \
+   $(TOP)/src/btree.h \
+   $(TOP)/src/btreeInt.h \
+   $(TOP)/src/hash.h \
+   $(TOP)/src/sqliteLimit.h \
+   $(TOP)/src/mutex.h \
+   opcodes.h \
+   $(TOP)/src/os.h \
+   $(TOP)/src/os_common.h \
+   $(TOP)/src/sqlite3ext.h \
+   $(TOP)/src/sqliteInt.h  \
+   $(TOP)/src/vdbe.h \
+   parse.h
+
+# Header files used by extensions
+#
+HDR += \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_tokenizer.h
+
+# Header files used by the VDBE submodule
+#
+VDBEHDR = \
+   $(HDR) \
+   $(TOP)/src/vdbeInt.h
+
+# This is the default Makefile target.  The objects listed here
+# are what get build when you type just "make" with no arguments.
+#
+all:	sqlite3.h libsqlite3.la sqlite3$(TEXE) $(HAVE_TCL:1=libtclsqlite3.la)
+
+Makefile: $(TOP)/Makefile.in
+	./config.status
+
+# Generate the file "last_change" which contains the date of change
+# of the most recently modified source code file
+#
+last_change:	$(SRC)
+	cat $(SRC) | grep '$$Id: ' | sort -k 5 | tail -1 \
+          | $(NAWK) '{print $$5,$$6}' >last_change
+
+libsqlite3.la:	$(LIBOBJ)
+	$(LTLINK) -o libsqlite3.la $(LIBOBJ) $(LIBPTHREAD) \
+		${ALLOWRELEASE} -rpath $(libdir) -version-info "8:6:8"
+
+libtclsqlite3.la:	tclsqlite.lo libsqlite3.la
+	$(LTLINK) -o libtclsqlite3.la tclsqlite.lo \
+		$(LIBOBJ) @TCL_STUB_LIB_SPEC@ $(LIBPTHREAD) \
+                -rpath $(libdir)/sqlite \
+		-version-info "8:6:8"
+
+sqlite3$(TEXE):	$(TOP)/src/shell.c libsqlite3.la sqlite3.h
+	$(LTLINK) $(READLINE_FLAGS) $(LIBPTHREAD) \
+		-o $@ $(TOP)/src/shell.c libsqlite3.la \
+		$(LIBREADLINE) $(TLIBS)
+
+# This target creates a directory named "tsrc" and fills it with
+# copies of all of the C source code and header files needed to
+# build on the target system.  Some of the C source code and header
+# files are automatically generated.  This target takes care of
+# all that automatic generation.
+#
+target_source:	$(SRC) parse.c opcodes.c keywordhash.h $(VDBEHDR) 
+	rm -rf tsrc
+	mkdir -p tsrc
+	cp $(SRC) $(VDBEHDR) tsrc
+	rm tsrc/sqlite.h.in tsrc/parse.y
+	cp parse.c opcodes.c keywordhash.h tsrc
+
+sqlite3.c:	target_source $(TOP)/tool/mksqlite3c.tcl
+	tclsh $(TOP)/tool/mksqlite3c.tcl
+
+# Rules to build the LEMON compiler generator
+#
+lemon$(BEXE):	$(TOP)/tool/lemon.c $(TOP)/tool/lempar.c
+	$(BCC) -o lemon$(BEXE) $(TOP)/tool/lemon.c
+	cp $(TOP)/tool/lempar.c .
+
+
+# Rules to build individual files
+#
+alter.lo:	$(TOP)/src/alter.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/alter.c
+
+analyze.lo:	$(TOP)/src/analyze.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/analyze.c
+
+attach.lo:	$(TOP)/src/attach.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/attach.c
+
+auth.lo:	$(TOP)/src/auth.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/auth.c
+
+btmutex.lo:	$(TOP)/src/btmutex.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/btmutex.c
+
+btree.lo:	$(TOP)/src/btree.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/btree.c
+
+build.lo:	$(TOP)/src/build.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/build.c
+
+callback.lo:	$(TOP)/src/callback.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/callback.c
+
+complete.lo:	$(TOP)/src/complete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/complete.c
+
+date.lo:	$(TOP)/src/date.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/date.c
+
+delete.lo:	$(TOP)/src/delete.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/delete.c
+
+expr.lo:	$(TOP)/src/expr.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/expr.c
+
+func.lo:	$(TOP)/src/func.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/func.c
+
+hash.lo:	$(TOP)/src/hash.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/hash.c
+
+insert.lo:	$(TOP)/src/insert.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/insert.c
+
+journal.lo:	$(TOP)/src/journal.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/journal.c
+
+legacy.lo:	$(TOP)/src/legacy.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/legacy.c
+
+loadext.lo:	$(TOP)/src/loadext.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/loadext.c
+
+main.lo:	$(TOP)/src/main.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/main.c
+
+malloc.lo:	$(TOP)/src/malloc.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/malloc.c
+
+mem1.lo:	$(TOP)/src/mem1.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem1.c
+
+mem2.lo:	$(TOP)/src/mem2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem2.c
+
+mem3.lo:	$(TOP)/src/mem3.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem3.c
+
+mem4.lo:	$(TOP)/src/mem4.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mem4.c
+
+mutex.lo:	$(TOP)/src/mutex.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex.c
+
+mutex_os2.lo:	$(TOP)/src/mutex_os2.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_os2.c
+
+mutex_unix.lo:	$(TOP)/src/mutex_unix.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_unix.c
+
+mutex_w32.lo:	$(TOP)/src/mutex_w32.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/mutex_w32.c
+
+pager.lo:	$(TOP)/src/pager.c $(HDR) $(TOP)/src/pager.h
+	$(LTCOMPILE) -c $(TOP)/src/pager.c
+
+opcodes.lo:	opcodes.c
+	$(LTCOMPILE) -c opcodes.c
+
+opcodes.c:	opcodes.h $(TOP)/mkopcodec.awk
+	sort -n -b -k 3 opcodes.h | $(NAWK) -f $(TOP)/mkopcodec.awk >opcodes.c
+
+opcodes.h:	parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
+	cat parse.h $(TOP)/src/vdbe.c | $(NAWK) -f $(TOP)/mkopcodeh.awk >opcodes.h
+
+os.lo:	$(TOP)/src/os.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os.c
+
+os_unix.lo:	$(TOP)/src/os_unix.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_unix.c
+
+os_win.lo:	$(TOP)/src/os_win.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_win.c
+
+os_os2.lo:	$(TOP)/src/os_os2.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/os_os2.c
+
+parse.lo:	parse.c $(HDR)
+	$(LTCOMPILE) -c parse.c
+
+parse.h:	parse.c
+
+parse.c:	$(TOP)/src/parse.y lemon$(BEXE) $(TOP)/addopcodes.awk
+	cp $(TOP)/src/parse.y .
+	./lemon$(BEXE) $(OPTS) parse.y
+	mv parse.h parse.h.temp
+	$(NAWK) -f $(TOP)/addopcodes.awk parse.h.temp >parse.h
+
+pragma.lo:	$(TOP)/src/pragma.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/pragma.c
+
+prepare.lo:	$(TOP)/src/prepare.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/prepare.c
+
+printf.lo:	$(TOP)/src/printf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/printf.c
+
+random.lo:	$(TOP)/src/random.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/random.c
+
+select.lo:	$(TOP)/src/select.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/select.c
+
+sqlite3.h:	$(TOP)/src/sqlite.h.in 
+	sed -e s/--VERS--/$(RELEASE)/ $(TOP)/src/sqlite.h.in | \
+	sed -e s/--VERSION-NUMBER--/$(VERSION_NUMBER)/ >sqlite3.h
+
+table.lo:	$(TOP)/src/table.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/table.c
+
+tclsqlite.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tclsqlite.c
+
+tokenize.lo:	$(TOP)/src/tokenize.c keywordhash.h $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/tokenize.c
+
+keywordhash.h:	$(TOP)/tool/mkkeywordhash.c
+	$(BCC) -o mkkeywordhash$(BEXE) $(OPTS) $(TOP)/tool/mkkeywordhash.c
+	./mkkeywordhash$(BEXE) >keywordhash.h
+
+trigger.lo:	$(TOP)/src/trigger.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/trigger.c
+
+update.lo:	$(TOP)/src/update.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/update.c
+
+utf.lo:	$(TOP)/src/utf.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/utf.c
+
+util.lo:	$(TOP)/src/util.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/util.c
+
+vacuum.lo:	$(TOP)/src/vacuum.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/vacuum.c
+
+vdbe.lo:	$(TOP)/src/vdbe.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbe.c
+
+vdbeapi.lo:	$(TOP)/src/vdbeapi.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeapi.c
+
+vdbeaux.lo:	$(TOP)/src/vdbeaux.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeaux.c
+
+vdbeblob.lo:	$(TOP)/src/vdbeblob.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbeblob.c
+
+vdbefifo.lo:	$(TOP)/src/vdbefifo.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbefifo.c
+
+vdbemem.lo:	$(TOP)/src/vdbemem.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vdbemem.c
+
+vtab.lo:	$(TOP)/src/vtab.c $(VDBEHDR)
+	$(LTCOMPILE) -c $(TOP)/src/vtab.c
+
+where.lo:	$(TOP)/src/where.c $(HDR)
+	$(LTCOMPILE) -c $(TOP)/src/where.c
+
+tclsqlite-shell.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCLSH=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite-stubs.lo:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(LTCOMPILE) -DTCL_USE_STUBS=1 -o $@ -c $(TOP)/src/tclsqlite.c
+
+tclsqlite3:	tclsqlite-shell.lo libsqlite3.la
+	$(LTLINK) -o tclsqlite3 tclsqlite-shell.lo \
+		 libsqlite3.la $(LIBTCL)
+
+testfixture$(TEXE):	$(TOP)/src/tclsqlite.c libsqlite3.la $(TESTSRC)
+	$(LTLINK) -DTCLSH=1 -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1 \
+                -DSQLITE_NO_SYNC=1 $(TEMP_STORE) \
+		-o testfixture $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libsqlite3.la $(LIBTCL)
+
+
+fulltest:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/all.test
+
+test:	testfixture$(TEXE) sqlite3$(TEXE)
+	./testfixture $(TOP)/test/quick.test
+
+sqlite3_analyzer$(TEXE):	$(TOP)/src/tclsqlite.c libtclsqlite3.la \
+				$(TESTSRC) $(TOP)/tool/spaceanal.tcl
+	sed \
+	  -e '/^#/d' \
+	  -e 's,\\,\\\\,g' \
+	  -e 's,",\\",g' \
+	  -e 's,^,",' \
+	  -e 's,$$,\\n",' \
+	  $(TOP)/tool/spaceanal.tcl >spaceanal_tcl.h
+	$(LTLINK) -DTCLSH=2 -DSQLITE_TEST=1 $(TEMP_STORE)\
+                -o sqlite3_analyzer$(EXE) $(TESTSRC) $(TOP)/src/tclsqlite.c \
+		libtclsqlite3.la $(LIBTCL)
+
+
+install:	sqlite3$(BEXE) libsqlite3.la sqlite3.h ${HAVE_TCL:1=tcl_install}
+	$(INSTALL) -d $(DESTDIR)$(libdir)
+	$(LTINSTALL) libsqlite3.la $(DESTDIR)$(libdir)
+	$(INSTALL) -d $(DESTDIR)$(exec_prefix)/bin
+	$(LTINSTALL) sqlite3$(BEXE) $(DESTDIR)$(exec_prefix)/bin
+	$(INSTALL) -d $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 sqlite3.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -m 0644 $(TOP)/src/sqlite3ext.h $(DESTDIR)$(prefix)/include
+	$(INSTALL) -d $(DESTDIR)$(libdir)/pkgconfig; 
+	$(INSTALL) -m 0644 sqlite3.pc $(DESTDIR)$(libdir)/pkgconfig; 
+
+tcl_install:	libtclsqlite3.la
+	tclsh $(TOP)/tclinstaller.tcl $(VERSION)
+
+clean:	
+	rm -f *.lo *.la *.o sqlite3$(TEXE) libsqlite3.la
+	rm -f sqlite3.h opcodes.*
+	rm -rf .libs .deps 
+	rm -f lemon$(BEXE) lempar.c parse.* sqlite*.tar.gz
+	rm -f mkkeywordhash$(BEXE) keywordhash.h
+	rm -f $(PUBLISH)
+	rm -f *.da *.bb *.bbg gmon.out
+	rm -f testfixture$(TEXE) test.db
+	rm -f common.tcl
+	rm -f sqlite3.dll sqlite3.lib sqlite3.def
+
+distclean:	clean
+	rm -f config.log config.status libtool Makefile config.h sqlite3.pc
+
+#
+# Windows section
+#
+dll: sqlite3.dll
+
+REAL_LIBOBJ = $(LIBOBJ:%.lo=.libs/%.o)
+
+$(REAL_LIBOBJ): $(LIBOBJ)
+
+sqlite3.def: $(REAL_LIBOBJ)
+	echo 'EXPORTS' >sqlite3.def
+	nm $(REAL_LIBOBJ) | grep ' T ' | grep ' _sqlite3_' \
+		| sed 's/^.* _//' >>sqlite3.def
+
+sqlite3.dll: $(REAL_LIBOBJ) sqlite3.def
+	$(TCC) -shared -o sqlite3.dll sqlite3.def \
+		-Wl,"--strip-all" $(REAL_LIBOBJ)
diff --git a/client/src/thirdparty/sqlite-3.4.2/README b/client/src/thirdparty/sqlite-3.4.2/README
new file mode 100644
index 0000000..6e4f392
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/README
@@ -0,0 +1,35 @@
+This directory contains source code to 
+
+    SQLite: An Embeddable SQL Database Engine
+
+To compile the project, first create a directory in which to place
+the build products.  It is recommended, but not required, that the
+build directory be separate from the source directory.  Cd into the
+build directory and then from the build directory run the configure
+script found at the root of the source tree.  Then run "make".
+
+For example:
+
+    tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
+    mkdir bld                ;#  Build will occur in a sibling directory
+    cd bld                   ;#  Change to the build directory
+    ../sqlite/configure      ;#  Run the configure script
+    make                     ;#  Run the makefile.
+    make install             ;#  (Optional) Install the build products
+
+The configure script uses autoconf 2.50 and libtool.  If the configure
+script does not work out for you, there is a generic makefile named
+"Makefile.linux-gcc" in the top directory of the source tree that you
+can copy and edit to suite your needs.  Comments on the generic makefile
+show what changes are needed.
+
+The linux binaries on the website are created using the generic makefile,
+not the configure script.  The configure script is unmaintained.  (You
+can volunteer to take over maintenance of the configure script, if you want!)
+The windows binaries on the website are created using MinGW32 configured
+as a cross-compiler running under Linux.  For details, see the ./publish.sh
+script at the top-level of the source tree.
+
+Contacts:
+
+   http://www.sqlite.org/
diff --git a/client/src/thirdparty/sqlite-3.4.2/VERSION b/client/src/thirdparty/sqlite-3.4.2/VERSION
new file mode 100644
index 0000000..c492825
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/VERSION
@@ -0,0 +1 @@
+3.5.6
diff --git a/client/src/thirdparty/sqlite-3.4.2/aclocal.m4 b/client/src/thirdparty/sqlite-3.4.2/aclocal.m4
new file mode 100644
index 0000000..27b6c66
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/aclocal.m4
@@ -0,0 +1,6470 @@
+# generated automatically by aclocal 1.10 -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006  Free Software Foundation, Inc.
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+
+# serial 48 AC_PROG_LIBTOOL
+
+
+# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
+# -----------------------------------------------------------
+# If this macro is not defined by Autoconf, define it here.
+m4_ifdef([AC_PROVIDE_IFELSE],
+         [],
+         [m4_define([AC_PROVIDE_IFELSE],
+	         [m4_ifdef([AC_PROVIDE_$1],
+		           [$2], [$3])])])
+
+
+# AC_PROG_LIBTOOL
+# ---------------
+AC_DEFUN([AC_PROG_LIBTOOL],
+[AC_REQUIRE([_AC_PROG_LIBTOOL])dnl
+dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX
+dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.
+  AC_PROVIDE_IFELSE([AC_PROG_CXX],
+    [AC_LIBTOOL_CXX],
+    [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX
+  ])])
+dnl And a similar setup for Fortran 77 support
+  AC_PROVIDE_IFELSE([AC_PROG_F77],
+    [AC_LIBTOOL_F77],
+    [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77
+])])
+
+dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.
+dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run
+dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.
+  AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+    [AC_LIBTOOL_GCJ],
+    [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+      [AC_LIBTOOL_GCJ],
+      [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],
+	[AC_LIBTOOL_GCJ],
+      [ifdef([AC_PROG_GCJ],
+	     [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])
+       ifdef([A][M_PROG_GCJ],
+	     [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])
+       ifdef([LT_AC_PROG_GCJ],
+	     [define([LT_AC_PROG_GCJ],
+		defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])
+])])# AC_PROG_LIBTOOL
+
+
+# _AC_PROG_LIBTOOL
+# ----------------
+AC_DEFUN([_AC_PROG_LIBTOOL],
+[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_CXX])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_F77])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_GCJ])dnl
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+AC_SUBST(LIBTOOL)dnl
+
+# Prevent multiple expansion
+define([AC_PROG_LIBTOOL], [])
+])# _AC_PROG_LIBTOOL
+
+
+# AC_LIBTOOL_SETUP
+# ----------------
+AC_DEFUN([AC_LIBTOOL_SETUP],
+[AC_PREREQ(2.50)dnl
+AC_REQUIRE([AC_ENABLE_SHARED])dnl
+AC_REQUIRE([AC_ENABLE_STATIC])dnl
+AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_PROG_LD])dnl
+AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
+AC_REQUIRE([AC_PROG_NM])dnl
+
+AC_REQUIRE([AC_PROG_LN_S])dnl
+AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
+# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+AC_REQUIRE([AC_OBJEXT])dnl
+AC_REQUIRE([AC_EXEEXT])dnl
+dnl
+
+AC_LIBTOOL_SYS_MAX_CMD_LEN
+AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+AC_LIBTOOL_OBJDIR
+
+AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+_LT_AC_PROG_ECHO_BACKSLASH
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e 1s/^X//'
+[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
+
+# Same as above, but do not quote variable references.
+[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+# Constants:
+rm="rm -f"
+
+# Global variables:
+default_ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+ltmain="$ac_aux_dir/ltmain.sh"
+ofile="$default_ofile"
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+AC_CHECK_TOOL(AR, ar, false)
+AC_CHECK_TOOL(RANLIB, ranlib, :)
+AC_CHECK_TOOL(STRIP, strip, :)
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$AR" && AR=ar
+test -z "$AR_FLAGS" && AR_FLAGS=cru
+test -z "$AS" && AS=as
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+test -z "$LD" && LD=ld
+test -z "$LN_S" && LN_S="ln -s"
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+test -z "$NM" && NM=nm
+test -z "$SED" && SED=sed
+test -z "$OBJDUMP" && OBJDUMP=objdump
+test -z "$RANLIB" && RANLIB=:
+test -z "$STRIP" && STRIP=:
+test -z "$ac_objext" && ac_objext=o
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+fi
+
+_LT_CC_BASENAME([$compiler])
+
+# Only perform the check for file, if the check method requires it
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    AC_PATH_MAGIC
+  fi
+  ;;
+esac
+
+AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)
+AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
+enable_win32_dll=yes, enable_win32_dll=no)
+
+AC_ARG_ENABLE([libtool-lock],
+    [AC_HELP_STRING([--disable-libtool-lock],
+	[avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+AC_ARG_WITH([pic],
+    [AC_HELP_STRING([--with-pic],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [pic_mode="$withval"],
+    [pic_mode=default])
+test -z "$pic_mode" && pic_mode=default
+
+# Check if we have a version mismatch between libtool.m4 and ltmain.sh.
+#
+# Note:  This should be in AC_LIBTOOL_SETUP, _after_ $ltmain have been defined.
+#        We also should do it _before_ AC_LIBTOOL_LANG_C_CONFIG that actually
+#        calls AC_LIBTOOL_CONFIG and creates libtool.
+#
+_LT_VERSION_CHECK
+
+# Use C for the default configuration in the libtool script
+tagname=
+AC_LIBTOOL_LANG_C_CONFIG
+_LT_AC_TAGCONFIG
+])# AC_LIBTOOL_SETUP
+
+
+# _LT_VERSION_CHECK
+# -----------------
+AC_DEFUN([_LT_VERSION_CHECK],
+[AC_MSG_CHECKING([for correct ltmain.sh version])
+if test "x$ltmain" = "x" ; then
+  AC_MSG_RESULT(no)
+  AC_MSG_ERROR([
+
+*** @<:@Gentoo@:>@ sanity check failed! ***
+*** \$ltmain is not defined, please check the patch for consistency! ***
+])
+fi
+gentoo_lt_version="1.5.22"
+gentoo_ltmain_version=`sed -n '/^[[ 	]]*VERSION=/{s/^[[ 	]]*VERSION=//;p;q;}' "$ltmain"`
+if test "x$gentoo_lt_version" != "x$gentoo_ltmain_version" ; then
+  AC_MSG_RESULT(no)
+  AC_MSG_ERROR([
+
+*** @<:@Gentoo@:>@ sanity check failed! ***
+*** libtool.m4 and ltmain.sh have a version mismatch! ***
+*** (libtool.m4 = $gentoo_lt_version, ltmain.sh = $gentoo_ltmain_version) ***
+
+Please run:
+
+  libtoolize --copy --force
+
+if appropriate, please contact the maintainer of this
+package (or your distribution) for help.
+])
+else
+  AC_MSG_RESULT(yes)
+fi
+])# _LT_VERSION_CHECK
+
+
+# _LT_AC_SYS_COMPILER
+# -------------------
+AC_DEFUN([_LT_AC_SYS_COMPILER],
+[AC_REQUIRE([AC_PROG_CC])dnl
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+])# _LT_AC_SYS_COMPILER
+
+
+# _LT_CC_BASENAME(CC)
+# -------------------
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+AC_DEFUN([_LT_CC_BASENAME],
+[for cc_temp in $1""; do
+  case $cc_temp in
+    compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
+    distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+])
+
+
+# _LT_COMPILER_BOILERPLATE
+# ------------------------
+# Check for compiler boilerplate output or warnings with
+# the simple compiler test code.
+AC_DEFUN([_LT_COMPILER_BOILERPLATE],
+[ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+])# _LT_COMPILER_BOILERPLATE
+
+
+# _LT_LINKER_BOILERPLATE
+# ----------------------
+# Check for linker boilerplate output or warnings with
+# the simple link test code.
+AC_DEFUN([_LT_LINKER_BOILERPLATE],
+[ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+])# _LT_LINKER_BOILERPLATE
+
+
+# _LT_AC_SYS_LIBPATH_AIX
+# ----------------------
+# Links a minimal program and checks the executable
+# for the system default hardcoded library path. In most cases,
+# this is /usr/lib:/lib, but when the MPI compilers are used
+# the location of the communication and MPI libs are included too.
+# If we don't find anything, use the default library path according
+# to the aix ld manual.
+AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],
+[AC_LINK_IFELSE(AC_LANG_PROGRAM,[
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi],[])
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+])# _LT_AC_SYS_LIBPATH_AIX
+
+
+# _LT_AC_SHELL_INIT(ARG)
+# ----------------------
+AC_DEFUN([_LT_AC_SHELL_INIT],
+[ifdef([AC_DIVERSION_NOTICE],
+	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
+	 [AC_DIVERT_PUSH(NOTICE)])
+$1
+AC_DIVERT_POP
+])# _LT_AC_SHELL_INIT
+
+
+# _LT_AC_PROG_ECHO_BACKSLASH
+# --------------------------
+# Add some code to the start of the generated configure script which
+# will find an echo command which doesn't interpret backslashes.
+AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],
+[_LT_AC_SHELL_INIT([
+# Check that we are running under the correct shell.
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+case X$ECHO in
+X*--fallback-echo)
+  # Remove one level of quotation (which was required for Make).
+  ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
+  ;;
+esac
+
+echo=${ECHO-echo}
+if test "X[$]1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X[$]1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell.
+  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
+fi
+
+if test "X[$]1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+[$]*
+EOF
+  exit 0
+fi
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+if test -z "$ECHO"; then
+if test "X${echo_test_string+set}" != Xset; then
+# find a string as large as possible, as long as the shell can cope with it
+  for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+    if (echo_test_string=`eval $cmd`) 2>/dev/null &&
+       echo_test_string=`eval $cmd` &&
+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
+    then
+      break
+    fi
+  done
+fi
+
+if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+   test "X$echo_testing_string" = "X$echo_test_string"; then
+  :
+else
+  # The Solaris, AIX, and Digital Unix default echo programs unquote
+  # backslashes.  This makes it impossible to quote backslashes using
+  #   echo "$something" | sed 's/\\/\\\\/g'
+  #
+  # So, first we look for a working echo in the user's PATH.
+
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for dir in $PATH /usr/ucb; do
+    IFS="$lt_save_ifs"
+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      echo="$dir/echo"
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+
+  if test "X$echo" = Xecho; then
+    # We didn't find a better echo, so look for alternatives.
+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      # This shell has a builtin print -r that does the trick.
+      echo='print -r'
+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
+	 test "X$CONFIG_SHELL" != X/bin/ksh; then
+      # If we have ksh, try running configure again with it.
+      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+      export ORIGINAL_CONFIG_SHELL
+      CONFIG_SHELL=/bin/ksh
+      export CONFIG_SHELL
+      exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
+    else
+      # Try using printf.
+      echo='printf %s\n'
+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+	 test "X$echo_testing_string" = "X$echo_test_string"; then
+	# Cool, printf works
+	:
+      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
+	export CONFIG_SHELL
+	SHELL="$CONFIG_SHELL"
+	export SHELL
+	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+      elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+      else
+	# maybe with a smaller string...
+	prev=:
+
+	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
+	  then
+	    break
+	  fi
+	  prev="$cmd"
+	done
+
+	if test "$prev" != 'sed 50q "[$]0"'; then
+	  echo_test_string=`eval $prev`
+	  export echo_test_string
+	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
+	else
+	  # Oops.  We lost completely, so just stick with echo.
+	  echo=echo
+	fi
+      fi
+    fi
+  fi
+fi
+fi
+
+# Copy echo and quote the copy suitably for passing to libtool from
+# the Makefile, instead of quoting the original, which is used later.
+ECHO=$echo
+if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
+   ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
+fi
+
+AC_SUBST(ECHO)
+])])# _LT_AC_PROG_ECHO_BACKSLASH
+
+
+# _LT_AC_LOCK
+# -----------
+AC_DEFUN([_LT_AC_LOCK],
+[AC_ARG_ENABLE([libtool-lock],
+    [AC_HELP_STRING([--disable-libtool-lock],
+	[avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *ELF-32*)
+      HPUX_IA64_MODE="32"
+      ;;
+    *ELF-64*)
+      HPUX_IA64_MODE="64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '[#]line __oline__ "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+   if test "$lt_cv_prog_gnu_ld" = yes; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -melf32bsmip"
+      ;;
+    *N32*)
+      LD="${LD-ld} -melf32bmipn32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -melf64bmip"
+      ;;
+    esac
+   else
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -32"
+      ;;
+    *N32*)
+      LD="${LD-ld} -n32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -64"
+      ;;
+    esac
+   fi
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+    *32-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_i386"
+          ;;
+        ppc64-*linux*|powerpc64-*linux*)
+          LD="${LD-ld} -m elf32ppclinux"
+          ;;
+        s390x-*linux*)
+          LD="${LD-ld} -m elf_s390"
+          ;;
+        sparc64-*linux*)
+          LD="${LD-ld} -m elf32_sparc"
+          ;;
+      esac
+      ;;
+    *64-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        ppc*-*linux*|powerpc*-*linux*)
+          LD="${LD-ld} -m elf64ppc"
+          ;;
+        s390*-*linux*)
+          LD="${LD-ld} -m elf64_s390"
+          ;;
+        sparc*-*linux*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+    [AC_LANG_PUSH(C)
+     AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+     AC_LANG_POP])
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+sparc*-*solaris*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*) LD="${LD-ld} -m elf64_sparc" ;;
+      *)    LD="${LD-ld} -64" ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
+[*-*-cygwin* | *-*-mingw* | *-*-pw32*)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+  ])
+esac
+
+need_locks="$enable_libtool_lock"
+
+])# _LT_AC_LOCK
+
+
+# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],
+[AC_REQUIRE([LT_AC_PROG_SED])
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+  ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$3"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       $2=yes
+     fi
+   fi
+   $rm conftest*
+])
+
+if test x"[$]$2" = xyes; then
+    ifelse([$5], , :, [$5])
+else
+    ifelse([$6], , :, [$6])
+fi
+])# AC_LIBTOOL_COMPILER_OPTION
+
+
+# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#                          [ACTION-SUCCESS], [ACTION-FAILURE])
+# ------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],
+[AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $3"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&AS_MESSAGE_LOG_FD
+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         $2=yes
+       fi
+     else
+       $2=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+])
+
+if test x"[$]$2" = xyes; then
+    ifelse([$4], , :, [$4])
+else
+    ifelse([$5], , :, [$5])
+fi
+])# AC_LIBTOOL_LINKER_OPTION
+
+
+# AC_LIBTOOL_SYS_MAX_CMD_LEN
+# --------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],
+[# find the maximum length of command line arguments
+AC_MSG_CHECKING([the maximum length of command line arguments])
+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+  i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ 	]]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    # If test is not a shell built-in, we'll probably end up computing a
+    # maximum length that is only half of the actual maximum length, but
+    # we can't tell.
+    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+    while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \
+	       = "XX$teststring") >/dev/null 2>&1 &&
+	    new_result=`expr "X$teststring" : ".*" 2>&1` &&
+	    lt_cv_sys_max_cmd_len=$new_result &&
+	    test $i != 17 # 1/2 MB should be enough
+    do
+      i=`expr $i + 1`
+      teststring=$teststring$teststring
+    done
+    teststring=
+    # Add a significant safety factor because C++ compilers can tack on massive
+    # amounts of additional arguments before passing them to the linker.
+    # It appears as though 1/2 is a usable value.
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    ;;
+  esac
+])
+if test -n $lt_cv_sys_max_cmd_len ; then
+  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+else
+  AC_MSG_RESULT(none)
+fi
+])# AC_LIBTOOL_SYS_MAX_CMD_LEN
+
+
+# _LT_AC_CHECK_DLFCN
+# ------------------
+AC_DEFUN([_LT_AC_CHECK_DLFCN],
+[AC_CHECK_HEADERS(dlfcn.h)dnl
+])# _LT_AC_CHECK_DLFCN
+
+
+# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+#                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+# ---------------------------------------------------------------------
+AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+if test "$cross_compiling" = yes; then :
+  [$4]
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<EOF
+[#line __oline__ "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" void exit (int);
+#endif
+
+void fnord() { int i=42;}
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+    exit (status);
+}]
+EOF
+  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) $1 ;;
+      x$lt_dlneed_uscore) $2 ;;
+      x$lt_dlunknown|x*) $3 ;;
+    esac
+  else :
+    # compilation failed
+    $3
+  fi
+fi
+rm -fr conftest*
+])# _LT_AC_TRY_DLOPEN_SELF
+
+
+# AC_LIBTOOL_DLOPEN_SELF
+# ----------------------
+AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32*)
+    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen_libs=
+   ;;
+
+  cygwin*)
+    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen_libs=
+   ;;
+
+  darwin*)
+  # if libdl is installed we need to link against it
+    AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
+    lt_cv_dlopen="dyld"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ])
+   ;;
+
+  *)
+    AC_CHECK_FUNC([shl_load],
+	  [lt_cv_dlopen="shl_load"],
+      [AC_CHECK_LIB([dld], [shl_load],
+	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],
+	[AC_CHECK_FUNC([dlopen],
+	      [lt_cv_dlopen="dlopen"],
+	  [AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+	    [AC_CHECK_LIB([svld], [dlopen],
+		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+	      [AC_CHECK_LIB([dld], [dld_link],
+		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
+	      ])
+	    ])
+	  ])
+	])
+      ])
+    ;;
+  esac
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  else
+    enable_dlopen=no
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS="$CPPFLAGS"
+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS="$LDFLAGS"
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS="$LIBS"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    AC_CACHE_CHECK([whether a program can dlopen itself],
+	  lt_cv_dlopen_self, [dnl
+	  _LT_AC_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
+	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
+    ])
+
+    if test "x$lt_cv_dlopen_self" = xyes; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
+    	  lt_cv_dlopen_self_static, [dnl
+	  _LT_AC_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
+	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
+      ])
+    fi
+
+    CPPFLAGS="$save_CPPFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+    LIBS="$save_LIBS"
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+])# AC_LIBTOOL_DLOPEN_SELF
+
+
+# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])
+# ---------------------------------
+# Check to see if options -c and -o are simultaneously supported by compiler
+AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],
+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+     fi
+   fi
+   chmod u+w . 2>&AS_MESSAGE_LOG_FD
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+])
+])# AC_LIBTOOL_PROG_CC_C_O
+
+
+# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])
+# -----------------------------------------
+# Check to see if we can do hard links to lock some files if needed
+AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS],
+[AC_REQUIRE([_LT_AC_LOCK])dnl
+
+hard_links="nottested"
+if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  AC_MSG_CHECKING([if we can lock with hard links])
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  AC_MSG_RESULT([$hard_links])
+  if test "$hard_links" = no; then
+    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS
+
+
+# AC_LIBTOOL_OBJDIR
+# -----------------
+AC_DEFUN([AC_LIBTOOL_OBJDIR],
+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
+[rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null])
+objdir=$lt_cv_objdir
+])# AC_LIBTOOL_OBJDIR
+
+
+# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])
+# ----------------------------------------------
+# Check hardcoding attributes.
+AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],
+[AC_MSG_CHECKING([how to hardcode library paths into programs])
+_LT_AC_TAGVAR(hardcode_action, $1)=
+if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \
+   test -n "$_LT_AC_TAGVAR(runpath_var, $1)" || \
+   test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
+     test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then
+    # Linking always hardcodes the temporary library directory.
+    _LT_AC_TAGVAR(hardcode_action, $1)=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    _LT_AC_TAGVAR(hardcode_action, $1)=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  _LT_AC_TAGVAR(hardcode_action, $1)=unsupported
+fi
+AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])
+
+if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH
+
+
+# AC_LIBTOOL_SYS_LIB_STRIP
+# ------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],
+[striplib=
+old_striplib=
+AC_MSG_CHECKING([whether stripping libraries is possible])
+if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  AC_MSG_RESULT([yes])
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+   darwin*)
+       if test -n "$STRIP" ; then
+         striplib="$STRIP -x"
+         AC_MSG_RESULT([yes])
+       else
+  AC_MSG_RESULT([no])
+fi
+       ;;
+   *)
+  AC_MSG_RESULT([no])
+    ;;
+  esac
+fi
+])# AC_LIBTOOL_SYS_LIB_STRIP
+
+
+# AC_LIBTOOL_SYS_DYNAMIC_LINKER
+# -----------------------------
+# PORTME Fill in your ld.so characteristics
+AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],
+[AC_MSG_CHECKING([dynamic linker characteristics])
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[[01]] | aix4.[[01]].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[[45]]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  linux*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      supports_anon_versioning=no
+      case `$LD -v 2>/dev/null` in
+        *\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test $supports_anon_versioning = yes; then
+        archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+$echo "local: *; };" >> $output_objdir/$libname.ver~
+        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        $archive_expsym_cmds="$archive_cmds"
+      fi
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[[123]]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  # Handle Gentoo/FreeBSD as it was Linux
+  case $host_vendor in
+    gentoo)
+      version_type=linux ;;
+    *)
+      version_type=freebsd-$objformat ;;
+  esac
+
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+    linux)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+      soname_spec='${libname}${release}${shared_ext}$major'
+      need_lib_prefix=no
+      need_version=no
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
+  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  freebsd*) # from 4.6 on
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix3*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+    *)                         need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[[89]] | openbsd2.[[89]].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      export_dynamic_flag_spec='${wl}-Blargedynsym'
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+    shlibpath_overrides_runpath=no
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    shlibpath_overrides_runpath=yes
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+AC_MSG_RESULT([$dynamic_linker])
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+])# AC_LIBTOOL_SYS_DYNAMIC_LINKER
+
+
+# _LT_AC_TAGCONFIG
+# ----------------
+AC_DEFUN([_LT_AC_TAGCONFIG],
+[AC_ARG_WITH([tags],
+    [AC_HELP_STRING([--with-tags@<:@=TAGS@:>@],
+        [include additional configurations @<:@automatic@:>@])],
+    [tagnames="$withval"])
+
+if test -f "$ltmain" && test -n "$tagnames"; then
+  if test ! -f "${ofile}"; then
+    AC_MSG_WARN([output file `$ofile' does not exist])
+  fi
+
+  if test -z "$LTCC"; then
+    eval "`$SHELL ${ofile} --config | grep '^LTCC='`"
+    if test -z "$LTCC"; then
+      AC_MSG_WARN([output file `$ofile' does not look like a libtool script])
+    else
+      AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])
+    fi
+  fi
+  if test -z "$LTCFLAGS"; then
+    eval "`$SHELL ${ofile} --config | grep '^LTCFLAGS='`"
+  fi
+
+  # Extract list of available tagged configurations in $ofile.
+  # Note that this assumes the entire list is on one line.
+  available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'`
+
+  lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+  for tagname in $tagnames; do
+    IFS="$lt_save_ifs"
+    # Check whether tagname contains only valid characters
+    case `$echo "X$tagname" | $Xsed -e 's:[[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]]::g'` in
+    "") ;;
+    *)  AC_MSG_ERROR([invalid tag name: $tagname])
+	;;
+    esac
+
+    if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null
+    then
+      AC_MSG_ERROR([tag name \"$tagname\" already exists])
+    fi
+
+    # Update the list of available tags.
+    if test -n "$tagname"; then
+      echo appending configuration tag \"$tagname\" to $ofile
+
+      case $tagname in
+      CXX)
+	if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+	    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+	    (test "X$CXX" != "Xg++"))) ; then
+	  AC_LIBTOOL_LANG_CXX_CONFIG
+	else
+	  tagname=""
+	fi
+	;;
+
+      F77)
+	if test -n "$F77" && test "X$F77" != "Xno"; then
+	  AC_LIBTOOL_LANG_F77_CONFIG
+	else
+	  tagname=""
+	fi
+	;;
+
+      GCJ)
+	if test -n "$GCJ" && test "X$GCJ" != "Xno"; then
+	  AC_LIBTOOL_LANG_GCJ_CONFIG
+	else
+	  tagname=""
+	fi
+	;;
+
+      RC)
+	AC_LIBTOOL_LANG_RC_CONFIG
+	;;
+
+      *)
+	AC_MSG_ERROR([Unsupported tag name: $tagname])
+	;;
+      esac
+
+      # Append the new tag name to the list of available tags.
+      if test -n "$tagname" ; then
+      available_tags="$available_tags $tagname"
+    fi
+    fi
+  done
+  IFS="$lt_save_ifs"
+
+  # Now substitute the updated list of available tags.
+  if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then
+    mv "${ofile}T" "$ofile"
+    chmod +x "$ofile"
+  else
+    rm -f "${ofile}T"
+    AC_MSG_ERROR([unable to update list of available tagged configurations.])
+  fi
+fi
+])# _LT_AC_TAGCONFIG
+
+
+# AC_LIBTOOL_DLOPEN
+# -----------------
+# enable checks for dlopen support
+AC_DEFUN([AC_LIBTOOL_DLOPEN],
+ [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])
+])# AC_LIBTOOL_DLOPEN
+
+
+# AC_LIBTOOL_WIN32_DLL
+# --------------------
+# declare package support for building win32 DLLs
+AC_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_BEFORE([$0], [AC_LIBTOOL_SETUP])
+])# AC_LIBTOOL_WIN32_DLL
+
+
+# AC_ENABLE_SHARED([DEFAULT])
+# ---------------------------
+# implement the --enable-shared flag
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+AC_DEFUN([AC_ENABLE_SHARED],
+[define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
+AC_ARG_ENABLE([shared],
+    [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]AC_ENABLE_SHARED_DEFAULT)
+])# AC_ENABLE_SHARED
+
+
+# AC_DISABLE_SHARED
+# -----------------
+# set the default shared flag to --disable-shared
+AC_DEFUN([AC_DISABLE_SHARED],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+AC_ENABLE_SHARED(no)
+])# AC_DISABLE_SHARED
+
+
+# AC_ENABLE_STATIC([DEFAULT])
+# ---------------------------
+# implement the --enable-static flag
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+AC_DEFUN([AC_ENABLE_STATIC],
+[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl
+AC_ARG_ENABLE([static],
+    [AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]AC_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]AC_ENABLE_STATIC_DEFAULT)
+])# AC_ENABLE_STATIC
+
+
+# AC_DISABLE_STATIC
+# -----------------
+# set the default static flag to --disable-static
+AC_DEFUN([AC_DISABLE_STATIC],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+AC_ENABLE_STATIC(no)
+])# AC_DISABLE_STATIC
+
+
+# AC_ENABLE_FAST_INSTALL([DEFAULT])
+# ---------------------------------
+# implement the --enable-fast-install flag
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+AC_DEFUN([AC_ENABLE_FAST_INSTALL],
+[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl
+AC_ARG_ENABLE([fast-install],
+    [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT)
+])# AC_ENABLE_FAST_INSTALL
+
+
+# AC_DISABLE_FAST_INSTALL
+# -----------------------
+# set the default to --disable-fast-install
+AC_DEFUN([AC_DISABLE_FAST_INSTALL],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+AC_ENABLE_FAST_INSTALL(no)
+])# AC_DISABLE_FAST_INSTALL
+
+
+# AC_LIBTOOL_PICMODE([MODE])
+# --------------------------
+# implement the --with-pic flag
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+AC_DEFUN([AC_LIBTOOL_PICMODE],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+pic_mode=ifelse($#,1,$1,default)
+])# AC_LIBTOOL_PICMODE
+
+
+# AC_PROG_EGREP
+# -------------
+# This is predefined starting with Autoconf 2.54, so this conditional
+# definition can be removed once we require Autoconf 2.54 or later.
+m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP],
+[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
+   [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+    then ac_cv_prog_egrep='grep -E'
+    else ac_cv_prog_egrep='egrep'
+    fi])
+ EGREP=$ac_cv_prog_egrep
+ AC_SUBST([EGREP])
+])])
+
+
+# AC_PATH_TOOL_PREFIX
+# -------------------
+# find a file program which can recognise shared library
+AC_DEFUN([AC_PATH_TOOL_PREFIX],
+[AC_REQUIRE([AC_PROG_EGREP])dnl
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
+[case $MAGIC_CMD in
+[[\\/*] |  ?:[\\/]*])
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+dnl $ac_dummy forces splitting on constant user-supplied paths.
+dnl POSIX.2 word splitting is done only on the output of word expansions,
+dnl not every word.  This closes a longstanding sh security hole.
+  ac_dummy="ifelse([$2], , $PATH, [$2])"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$1; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/$1"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac])
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  AC_MSG_RESULT($MAGIC_CMD)
+else
+  AC_MSG_RESULT(no)
+fi
+])# AC_PATH_TOOL_PREFIX
+
+
+# AC_PATH_MAGIC
+# -------------
+# find a file program which can recognise a shared library
+AC_DEFUN([AC_PATH_MAGIC],
+[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
+  else
+    MAGIC_CMD=:
+  fi
+fi
+])# AC_PATH_MAGIC
+
+
+# AC_PROG_LD
+# ----------
+# find the pathname to the GNU or non-GNU linker
+AC_DEFUN([AC_PROG_LD],
+[AC_ARG_WITH([gnu-ld],
+    [AC_HELP_STRING([--with-gnu-ld],
+	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
+    [test "$withval" = no || with_gnu_ld=yes],
+    [with_gnu_ld=no])
+AC_REQUIRE([LT_AC_PROG_SED])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  AC_MSG_CHECKING([for ld used by $CC])
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [[\\/]]* | ?:[[\\/]]*)
+      re_direlt='/[[^/]][[^/]]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  AC_MSG_CHECKING([for GNU ld])
+else
+  AC_MSG_CHECKING([for non-GNU ld])
+fi
+AC_CACHE_VAL(lt_cv_path_LD,
+[if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test "$with_gnu_ld" != no && break
+	;;
+      *)
+	test "$with_gnu_ld" != yes && break
+	;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi])
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  AC_MSG_RESULT($LD)
+else
+  AC_MSG_RESULT(no)
+fi
+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
+AC_PROG_LD_GNU
+])# AC_PROG_LD
+
+
+# AC_PROG_LD_GNU
+# --------------
+AC_DEFUN([AC_PROG_LD_GNU],
+[AC_REQUIRE([AC_PROG_EGREP])dnl
+AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
+[# I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac])
+with_gnu_ld=$lt_cv_prog_gnu_ld
+])# AC_PROG_LD_GNU
+
+
+# AC_PROG_LD_RELOAD_FLAG
+# ----------------------
+# find reload flag for linker
+#   -- PORTME Some linkers may need a different reload flag.
+AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],
+[AC_CACHE_CHECK([for $LD option to reload object files],
+  lt_cv_ld_reload_flag,
+  [lt_cv_ld_reload_flag='-r'])
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  darwin*)
+    if test "$GCC" = yes; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+])# AC_PROG_LD_RELOAD_FLAG
+
+
+# AC_DEPLIBS_CHECK_METHOD
+# -----------------------
+# how to check for library dependencies
+#  -- PORTME fill in with the dynamic library characteristics
+AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],
+[AC_CACHE_CHECK([how to recognise dependent libraries],
+lt_cv_deplibs_check_method,
+[lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix4* | aix5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[[45]]*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump'.
+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | kfreebsd*-gnu | dragonfly*)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix3*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd*)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+nto-qnx*)
+  lt_cv_deplibs_check_method=unknown
+  ;;
+
+openbsd*)
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+])
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+])# AC_DEPLIBS_CHECK_METHOD
+
+
+# AC_PROG_NM
+# ----------
+# find the pathname to a BSD-compatible name lister
+AC_DEFUN([AC_PROG_NM],
+[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,
+[if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  lt_nm_to_check="${ac_tool_prefix}nm"
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then 
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS="$lt_save_ifs"
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm="$ac_dir/$lt_tmp_nm"
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+	*/dev/null* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS="$lt_save_ifs"
+  done
+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
+fi])
+NM="$lt_cv_path_NM"
+])# AC_PROG_NM
+
+
+# AC_CHECK_LIBM
+# -------------
+# check for math library
+AC_DEFUN([AC_CHECK_LIBM],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+LIBM=
+case $host in
+*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)
+  # These system don't have libm, or don't need it
+  ;;
+*-ncr-sysv4.3*)
+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
+  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
+  ;;
+*)
+  AC_CHECK_LIB(m, cos, LIBM="-lm")
+  ;;
+esac
+])# AC_CHECK_LIBM
+
+
+# AC_LIBLTDL_CONVENIENCE([DIRECTORY])
+# -----------------------------------
+# sets LIBLTDL to the link flags for the libltdl convenience library and
+# LTDLINCL to the include flags for the libltdl header and adds
+# --enable-ltdl-convenience to the configure arguments.  Note that
+# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,
+# it is assumed to be `libltdl'.  LIBLTDL will be prefixed with
+# '${top_builddir}/' and LTDLINCL will be prefixed with '${top_srcdir}/'
+# (note the single quotes!).  If your package is not flat and you're not
+# using automake, define top_builddir and top_srcdir appropriately in
+# the Makefiles.
+AC_DEFUN([AC_LIBLTDL_CONVENIENCE],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+  case $enable_ltdl_convenience in
+  no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
+  "") enable_ltdl_convenience=yes
+      ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
+  esac
+  LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la
+  LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
+  # For backwards non-gettext consistent compatibility...
+  INCLTDL="$LTDLINCL"
+])# AC_LIBLTDL_CONVENIENCE
+
+
+# AC_LIBLTDL_INSTALLABLE([DIRECTORY])
+# -----------------------------------
+# sets LIBLTDL to the link flags for the libltdl installable library and
+# LTDLINCL to the include flags for the libltdl header and adds
+# --enable-ltdl-install to the configure arguments.  Note that
+# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,
+# and an installed libltdl is not found, it is assumed to be `libltdl'.
+# LIBLTDL will be prefixed with '${top_builddir}/'# and LTDLINCL with
+# '${top_srcdir}/' (note the single quotes!).  If your package is not
+# flat and you're not using automake, define top_builddir and top_srcdir
+# appropriately in the Makefiles.
+# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
+AC_DEFUN([AC_LIBLTDL_INSTALLABLE],
+[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
+  AC_CHECK_LIB(ltdl, lt_dlinit,
+  [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
+  [if test x"$enable_ltdl_install" = xno; then
+     AC_MSG_WARN([libltdl not installed, but installation disabled])
+   else
+     enable_ltdl_install=yes
+   fi
+  ])
+  if test x"$enable_ltdl_install" = x"yes"; then
+    ac_configure_args="$ac_configure_args --enable-ltdl-install"
+    LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la
+    LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
+  else
+    ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
+    LIBLTDL="-lltdl"
+    LTDLINCL=
+  fi
+  # For backwards non-gettext consistent compatibility...
+  INCLTDL="$LTDLINCL"
+])# AC_LIBLTDL_INSTALLABLE
+
+
+# AC_LIBTOOL_CXX
+# --------------
+# enable support for C++ libraries
+AC_DEFUN([AC_LIBTOOL_CXX],
+[AC_REQUIRE([_LT_AC_LANG_CXX])
+])# AC_LIBTOOL_CXX
+
+
+# _LT_AC_LANG_CXX
+# ---------------
+AC_DEFUN([_LT_AC_LANG_CXX],
+[AC_REQUIRE([AC_PROG_CXX])
+AC_REQUIRE([_LT_AC_PROG_CXXCPP])
+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])
+])# _LT_AC_LANG_CXX
+
+# _LT_AC_PROG_CXXCPP
+# ------------------
+AC_DEFUN([_LT_AC_PROG_CXXCPP],
+[
+AC_REQUIRE([AC_PROG_CXX])
+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+    (test "X$CXX" != "Xg++"))) ; then
+  AC_PROG_CXXCPP
+fi
+])# _LT_AC_PROG_CXXCPP
+
+# AC_LIBTOOL_F77
+# --------------
+# enable support for Fortran 77 libraries
+AC_DEFUN([AC_LIBTOOL_F77],
+[AC_REQUIRE([_LT_AC_LANG_F77])
+])# AC_LIBTOOL_F77
+
+
+# _LT_AC_LANG_F77
+# ---------------
+AC_DEFUN([_LT_AC_LANG_F77],
+[AC_REQUIRE([AC_PROG_F77])
+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}F77])
+])# _LT_AC_LANG_F77
+
+
+# AC_LIBTOOL_GCJ
+# --------------
+# enable support for GCJ libraries
+AC_DEFUN([AC_LIBTOOL_GCJ],
+[AC_REQUIRE([_LT_AC_LANG_GCJ])
+])# AC_LIBTOOL_GCJ
+
+
+# _LT_AC_LANG_GCJ
+# ---------------
+AC_DEFUN([_LT_AC_LANG_GCJ],
+[AC_PROVIDE_IFELSE([AC_PROG_GCJ],[],
+  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],[],
+    [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],[],
+      [ifdef([AC_PROG_GCJ],[AC_REQUIRE([AC_PROG_GCJ])],
+	 [ifdef([A][M_PROG_GCJ],[AC_REQUIRE([A][M_PROG_GCJ])],
+	   [AC_REQUIRE([A][C_PROG_GCJ_OR_A][M_PROG_GCJ])])])])])])
+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}GCJ])
+])# _LT_AC_LANG_GCJ
+
+
+# AC_LIBTOOL_RC
+# -------------
+# enable support for Windows resource files
+AC_DEFUN([AC_LIBTOOL_RC],
+[AC_REQUIRE([LT_AC_PROG_RC])
+_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}RC])
+])# AC_LIBTOOL_RC
+
+
+# AC_LIBTOOL_LANG_C_CONFIG
+# ------------------------
+# Ensure that the configuration vars for the C compiler are
+# suitably defined.  Those variables are subsequently used by
+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
+AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG], [_LT_AC_LANG_C_CONFIG])
+AC_DEFUN([_LT_AC_LANG_C_CONFIG],
+[lt_save_CC="$CC"
+AC_LANG_PUSH(C)
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}\n'
+
+_LT_AC_SYS_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
+AC_LIBTOOL_PROG_COMPILER_PIC($1)
+AC_LIBTOOL_PROG_CC_C_O($1)
+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+AC_LIBTOOL_PROG_LD_SHLIBS($1)
+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+AC_LIBTOOL_SYS_LIB_STRIP
+AC_LIBTOOL_DLOPEN_SELF
+
+# Report which library types will actually be built
+AC_MSG_CHECKING([if libtool supports shared libraries])
+AC_MSG_RESULT([$can_build_shared])
+
+AC_MSG_CHECKING([whether to build shared libraries])
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case $host_os in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+
+aix4* | aix5*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+    ;;
+esac
+AC_MSG_RESULT([$enable_shared])
+
+AC_MSG_CHECKING([whether to build static libraries])
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+AC_MSG_RESULT([$enable_static])
+
+AC_LIBTOOL_CONFIG($1)
+
+AC_LANG_POP
+CC="$lt_save_CC"
+])# AC_LIBTOOL_LANG_C_CONFIG
+
+
+# AC_LIBTOOL_LANG_CXX_CONFIG
+# --------------------------
+# Ensure that the configuration vars for the C compiler are
+# suitably defined.  Those variables are subsequently used by
+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
+AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG], [_LT_AC_LANG_CXX_CONFIG(CXX)])
+AC_DEFUN([_LT_AC_LANG_CXX_CONFIG],
+[AC_LANG_PUSH(C++)
+AC_REQUIRE([AC_PROG_CXX])
+AC_REQUIRE([_LT_AC_PROG_CXXCPP])
+
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_AC_TAGVAR(allow_undefined_flag, $1)=
+_LT_AC_TAGVAR(always_export_symbols, $1)=no
+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_direct, $1)=no
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+_LT_AC_TAGVAR(hardcode_automatic, $1)=no
+_LT_AC_TAGVAR(module_cmds, $1)=
+_LT_AC_TAGVAR(module_expsym_cmds, $1)=
+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_AC_TAGVAR(no_undefined_flag, $1)=
+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Dependencies to place before and after the object being linked:
+_LT_AC_TAGVAR(predep_objects, $1)=
+_LT_AC_TAGVAR(postdep_objects, $1)=
+_LT_AC_TAGVAR(predeps, $1)=
+_LT_AC_TAGVAR(postdeps, $1)=
+_LT_AC_TAGVAR(compiler_lib_search_path, $1)=
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_LD=$LD
+lt_save_GCC=$GCC
+GCC=$GXX
+lt_save_with_gnu_ld=$with_gnu_ld
+lt_save_path_LD=$lt_cv_path_LD
+if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+else
+  $as_unset lt_cv_prog_gnu_ld
+fi
+if test -n "${lt_cv_path_LDCXX+set}"; then
+  lt_cv_path_LD=$lt_cv_path_LDCXX
+else
+  $as_unset lt_cv_path_LD
+fi
+test -z "${LDCXX+set}" || LD=$LDCXX
+CC=${CXX-"c++"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+
+# We don't want -fno-exception wen compiling C++ code, so set the
+# no_builtin_flag separately
+if test "$GXX" = yes; then
+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+else
+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+fi
+
+if test "$GXX" = yes; then
+  # Set up default GNU C++ configuration
+
+  AC_PROG_LD
+
+  # Check if GNU C++ uses GNU ld as the underlying linker, since the
+  # archiving commands below assume that GNU ld is being used.
+  if test "$with_gnu_ld" = yes; then
+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+    #     investigate it a little bit more. (MM)
+    wlarc='${wl}'
+
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if eval "`$CC -print-prog-name=ld` --help 2>&1" | \
+	grep 'no-whole-archive' > /dev/null; then
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    else
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+  else
+    with_gnu_ld=no
+    wlarc=
+
+    # A generic and very simple default shared library creation
+    # command for GNU C++ for the case where it uses the native
+    # linker, instead of GNU ld.  If possible, this setting should
+    # overridden to take advantage of the native linker features on
+    # the platform it is being used on.
+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+  fi
+
+  # Commands to make compiler produce verbose output that lists
+  # what "hidden" libraries, object files and flags are used when
+  # linking a shared library.
+  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+else
+  GXX=no
+  with_gnu_ld=no
+  wlarc=
+fi
+
+# PORTME: fill in a description of your system's C++ link characteristics
+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+_LT_AC_TAGVAR(ld_shlibs, $1)=yes
+case $host_os in
+  aix3*)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  aix4* | aix5*)
+    if test "$host_cpu" = ia64; then
+      # On IA64, the linker does run time linking by default, so we don't
+      # have to do anything special.
+      aix_use_runtimelinking=no
+      exp_sym_flag='-Bexport'
+      no_entry_flag=""
+    else
+      aix_use_runtimelinking=no
+
+      # Test if we are trying to use run time linking or normal
+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+      # need to do runtime linking.
+      case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
+	for ld_flag in $LDFLAGS; do
+	  case $ld_flag in
+	  *-brtl*)
+	    aix_use_runtimelinking=yes
+	    break
+	    ;;
+	  esac
+	done
+	;;
+      esac
+
+      exp_sym_flag='-bexport'
+      no_entry_flag='-bnoentry'
+    fi
+
+    # When large executables or shared objects are built, AIX ld can
+    # have problems creating the table of contents.  If linking a library
+    # or program results in "error TOC overflow" add -mminimal-toc to
+    # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+    # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+    _LT_AC_TAGVAR(archive_cmds, $1)=''
+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+    if test "$GXX" = yes; then
+      case $host_os in aix4.[[012]]|aix4.[[012]].*)
+      # We only want to do this on AIX 4.2 and lower, the check
+      # below for broken collect2 doesn't work under 4.3+
+	collect2name=`${CC} -print-prog-name=collect2`
+	if test -f "$collect2name" && \
+	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	then
+	  # We have reworked collect2
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	else
+	  # We have old collect2
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+	fi
+	;;
+      esac
+      shared_flag='-shared'
+      if test "$aix_use_runtimelinking" = yes; then
+	shared_flag="$shared_flag "'${wl}-G'
+      fi
+    else
+      # not using gcc
+      if test "$host_cpu" = ia64; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	shared_flag='-G'
+      else
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag='${wl}-G'
+	else
+	  shared_flag='${wl}-bM:SRE'
+	fi
+      fi
+    fi
+
+    # It seems that -bexpall does not export symbols beginning with
+    # underscore (_), so it is better to generate a list of symbols to export.
+    _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+    if test "$aix_use_runtimelinking" = yes; then
+      # Warning - without using the other runtime loading flags (-brtl),
+      # -berok will link without error, but may produce a broken library.
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
+      # Determine the default libpath from the value encoded in an empty executable.
+      _LT_AC_SYS_LIBPATH_AIX
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+     else
+      if test "$host_cpu" = ia64; then
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+      else
+	# Determine the default libpath from the value encoded in an empty executable.
+	_LT_AC_SYS_LIBPATH_AIX
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	# Warning - without using the other run time loading flags,
+	# -berok will link without error, but may produce a broken library.
+	_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+	# Exported symbols can be pulled into shared objects from archives
+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+	# This is similar to how AIX traditionally builds its shared libraries.
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+      fi
+    fi
+    ;;
+
+  beos*)
+    if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+      # support --undefined.  This deserves some investigation.  FIXME
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+    else
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    fi
+    ;;
+
+  chorus*)
+    case $cc_basename in
+      *)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+    esac
+    ;;
+
+  cygwin* | mingw* | pw32*)
+    # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+    # as there is no search path for DLLs.
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+    _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+    _LT_AC_TAGVAR(always_export_symbols, $1)=no
+    _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+
+    if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      # If the export-symbols file already is a .def file (1st line
+      # is EXPORTS), use it as is; otherwise, prepend...
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	cp $export_symbols $output_objdir/$soname.def;
+      else
+	echo EXPORTS > $output_objdir/$soname.def;
+	cat $export_symbols >> $output_objdir/$soname.def;
+      fi~
+      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+    else
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    fi
+  ;;
+      darwin* | rhapsody*)
+        case $host_os in
+        rhapsody* | darwin1.[[012]])
+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[[012]])
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+        esac
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+    if test "$GXX" = yes ; then
+      lt_int_apple_cc_single_mod=no
+      output_verbose_link_cmd='echo'
+      if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then
+       lt_int_apple_cc_single_mod=yes
+      fi
+      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      else
+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+        fi
+        _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          else
+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          fi
+            _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+          _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         _LT_AC_TAGVAR(ld_shlibs, $1)=no
+          ;;
+      esac
+      fi
+        ;;
+
+  dgux*)
+    case $cc_basename in
+      ec++*)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      ghcx*)
+	# Green Hills C++ Compiler
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+    esac
+    ;;
+  freebsd[[12]]*)
+    # C++ shared libraries reported to be fairly broken before switch to ELF
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  freebsd-elf*)
+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+    ;;
+  freebsd* | kfreebsd*-gnu | dragonfly*)
+    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+    # conventions
+    _LT_AC_TAGVAR(ld_shlibs, $1)=yes
+    ;;
+  gnu*)
+    ;;
+  hpux9*)
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+    _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+				# but as the default
+				# location of the library.
+
+    case $cc_basename in
+    CC*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    aCC*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      #
+      # There doesn't appear to be a way to prevent this compiler from
+      # explicitly linking system object files so we need to strip them
+      # from the output so that they don't get included in the library
+      # dependencies.
+      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[[-]]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+      ;;
+    *)
+      if test "$GXX" = yes; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+        # FIXME: insert proper C++ library support
+        _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+    esac
+    ;;
+  hpux10*|hpux11*)
+    if test $with_gnu_ld = no; then
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+      case $host_cpu in
+      hppa*64*|ia64*)
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
+        ;;
+      *)
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+        ;;
+      esac
+    fi
+    case $host_cpu in
+    hppa*64*|ia64*)
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+    *)
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+					      # but as the default
+					      # location of the library.
+      ;;
+    esac
+
+    case $cc_basename in
+      CC*)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      aCC*)
+	case $host_cpu in
+	hppa*64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	ia64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	esac
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes; then
+	  if test $with_gnu_ld = no; then
+	    case $host_cpu in
+	    hppa*64*)
+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    ia64*)
+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    *)
+	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    esac
+	  fi
+	else
+	  # FIXME: insert proper C++ library support
+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+	fi
+	;;
+    esac
+    ;;
+  interix3*)
+    _LT_AC_TAGVAR(hardcode_direct, $1)=no
+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+    # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+    # Instead, shared libraries are loaded at an image base (0x10000000 by
+    # default) and relocated if they conflict, which is a slow very memory
+    # consuming and fragmenting process.  To avoid this, we pick a random,
+    # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+    # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+    ;;
+  irix5* | irix6*)
+    case $cc_basename in
+      CC*)
+	# SGI C++
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+
+	# Archives containing C++ object files must be created using
+	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+	# necessary to make sure instantiated templates are included
+	# in the archive.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
+	;;
+      *)
+	if test "$GXX" = yes; then
+	  if test "$with_gnu_ld" = no; then
+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	  else
+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'
+	  fi
+	fi
+	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+	;;
+    esac
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+    ;;
+  linux*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir'
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+	# Archives containing C++ object files must be created using
+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+	;;
+      icpc*)
+	# Intel C++
+	with_gnu_ld=yes
+	# version 8.0 and above of icpc choke on multiply defined symbols
+	# if we add $predep_objects and $postdep_objects, however 7.1 and
+	# earlier do not add the objects themselves.
+	case `$CC -V 2>&1` in
+	*"Version 7."*)
+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+  	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	  ;;
+	*)  # Version 8.0 or newer
+	  tmp_idyn=
+	  case $host_cpu in
+	    ia64*) tmp_idyn=' -i_dynamic';;
+	  esac
+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	  ;;
+	esac
+	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	;;
+      pgCC*)
+        # Portland Group C++ compiler
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+        ;;
+      cxx*)
+	# Compaq C++
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+	runpath_var=LD_RUN_PATH
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+    esac
+    ;;
+  lynxos*)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  m88k*)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  mvs*)
+    case $cc_basename in
+      cxx*)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+    esac
+    ;;
+  netbsd*)
+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+      wlarc=
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+    fi
+    # Workaround some broken pre-1.5 toolchains
+    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+    ;;
+  openbsd2*)
+    # C++ shared libraries are fairly broken
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  openbsd*)
+    _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    fi
+    output_verbose_link_cmd='echo'
+    ;;
+  osf3*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	# Archives containing C++ object files must be created using
+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+
+	;;
+      RCC*)
+	# Rational C++ 2.4.1
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      cxx*)
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	  # Commands to make compiler produce verbose output that lists
+	  # what "hidden" libraries, object files and flags are used when
+	  # linking a shared library.
+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+	else
+	  # FIXME: insert proper C++ library support
+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+	fi
+	;;
+    esac
+    ;;
+  osf4* | osf5*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	# Archives containing C++ object files must be created using
+	# the KAI C++ compiler.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'
+	;;
+      RCC*)
+	# Rational C++ 2.4.1
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      cxx*)
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+	  echo "-hidden">> $lib.exp~
+	  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version	$verstring` -update_registry ${output_objdir}/so_locations -o $lib~
+	  $rm $lib.exp'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	 _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	  # Commands to make compiler produce verbose output that lists
+	  # what "hidden" libraries, object files and flags are used when
+	  # linking a shared library.
+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+	else
+	  # FIXME: insert proper C++ library support
+	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+	fi
+	;;
+    esac
+    ;;
+  psos*)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  sunos4*)
+    case $cc_basename in
+      CC*)
+	# Sun C++ 4.x
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      lcc*)
+	# Lucid
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+    esac
+    ;;
+  solaris*)
+    case $cc_basename in
+      CC*)
+	# Sun C++ 4.2, 5.x and Centerline C++
+        _LT_AC_TAGVAR(archive_cmds_need_lc,$1)=yes
+	_LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	$CC -G${allow_undefined_flag}  ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+	case $host_os in
+	  solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+	  *)
+	    # The C++ compiler is used as linker so we must use $wl
+	    # flag to pass the commands to the underlying system
+	    # linker. We must also pass each convience library through
+	    # to the system linker between allextract/defaultextract.
+	    # The C++ compiler will combine linker options so we
+	    # cannot just pass the convience library names through
+	    # without $wl.
+	    # Supported since Solaris 2.6 (maybe 2.5.1?)
+	    _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
+	    ;;
+	esac
+	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+	output_verbose_link_cmd='echo'
+
+	# Archives containing C++ object files must be created using
+	# "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	# necessary to make sure instantiated templates are included
+	# in the archive.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+	;;
+      gcx*)
+	# Green Hills C++ Compiler
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+	# The C++ compiler must be used to create the archive.
+	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+	;;
+      *)
+	# GNU C++ compiler with Solaris linker
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
+	  if $CC --version | grep -v '^2\.7' > /dev/null; then
+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""
+	  else
+	    # g++ 2.7 appears to require `-G' NOT `-shared' on this
+	    # platform.
+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""
+	  fi
+
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
+	fi
+	;;
+    esac
+    ;;
+  sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+    runpath_var='LD_RUN_PATH'
+
+    case $cc_basename in
+      CC*)
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      *)
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+    esac
+    ;;
+  sysv5* | sco3.2v5* | sco5v6*)
+    # Note: We can NOT use -z defs as we might desire, because we do not
+    # link with -lc, and that would cause any symbols used from libc to
+    # always be unresolved, which means just about no library would
+    # ever link correctly.  If we're not using GNU ld we use -z text
+    # though, which does catch some bad symbols but isn't as heavy-handed
+    # as -z defs.
+    # For security reasons, it is highly recommended that you always
+    # use absolute paths for naming shared libraries, and exclude the
+    # DT_RUNPATH tag from executables and libraries.  But doing so
+    # requires that you compile everything twice, which is a pain.
+    # So that behaviour is only enabled if SCOABSPATH is set to a
+    # non-empty value in the environment.  Most likely only useful for
+    # creating official distributions of packages.
+    # This is a hack until libtool officially supports absolute path
+    # names for shared libraries.
+    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+    _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+    runpath_var='LD_RUN_PATH'
+
+    case $cc_basename in
+      CC*)
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      *)
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+    esac
+    ;;
+  tandem*)
+    case $cc_basename in
+      NCC*)
+	# NonStop-UX NCC 3.20
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	;;
+    esac
+    ;;
+  vxworks*)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+  *)
+    # FIXME: insert proper C++ library support
+    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    ;;
+esac
+AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
+test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+_LT_AC_TAGVAR(GCC, $1)="$GXX"
+_LT_AC_TAGVAR(LD, $1)="$LD"
+
+AC_LIBTOOL_POSTDEP_PREDEP($1)
+AC_LIBTOOL_PROG_COMPILER_PIC($1)
+AC_LIBTOOL_PROG_CC_C_O($1)
+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+AC_LIBTOOL_PROG_LD_SHLIBS($1)
+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+
+AC_LIBTOOL_CONFIG($1)
+
+AC_LANG_POP
+CC=$lt_save_CC
+LDCXX=$LD
+LD=$lt_save_LD
+GCC=$lt_save_GCC
+with_gnu_ldcxx=$with_gnu_ld
+with_gnu_ld=$lt_save_with_gnu_ld
+lt_cv_path_LDCXX=$lt_cv_path_LD
+lt_cv_path_LD=$lt_save_path_LD
+lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+])# AC_LIBTOOL_LANG_CXX_CONFIG
+
+# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])
+# ------------------------------------
+# Figure out "hidden" library dependencies from verbose
+# compiler output when linking a shared library.
+# Parse the compiler output and extract the necessary
+# objects, libraries and library flags.
+AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[
+dnl we can't use the lt_simple_compile_test_code here,
+dnl because it contains code intended for an executable,
+dnl not a library.  It's possible we should let each
+dnl tag define a new lt_????_link_test_code variable,
+dnl but it's only used here...
+ifelse([$1],[],[cat > conftest.$ac_ext <<EOF
+int a;
+void foo (void) { a = 0; }
+EOF
+],[$1],[CXX],[cat > conftest.$ac_ext <<EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+EOF
+],[$1],[F77],[cat > conftest.$ac_ext <<EOF
+      subroutine foo
+      implicit none
+      integer*4 a
+      a=0
+      return
+      end
+EOF
+],[$1],[GCJ],[cat > conftest.$ac_ext <<EOF
+public class foo {
+  private int a;
+  public void bar (void) {
+    a = 0;
+  }
+};
+EOF
+])
+dnl Parse the compiler output and extract the necessary
+dnl objects, libraries and library flags.
+if AC_TRY_EVAL(ac_compile); then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  # The `*' in the case matches for architectures that use `case' in
+  # $output_verbose_cmd can trigger glob expansion during the loop
+  # eval without this substitution.
+  output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`
+
+  for p in `eval $output_verbose_link_cmd`; do
+    case $p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test $p = "-L" \
+	  || test $p = "-R"; then
+	 prev=$p
+	 continue
+       else
+	 prev=
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 case $p in
+	 -L* | -R*)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then
+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
+	   else
+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then
+	   _LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"
+	 else
+	   _LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"
+	 fi
+       fi
+       ;;
+
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then
+	   _LT_AC_TAGVAR(predep_objects, $1)="$p"
+	 else
+	   _LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"
+	 fi
+       else
+	 if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then
+	   _LT_AC_TAGVAR(postdep_objects, $1)="$p"
+	 else
+	   _LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling $1 test program"
+fi
+
+$rm -f confest.$objext
+
+# PORTME: override above test on systems where it is broken
+ifelse([$1],[CXX],
+[case $host_os in
+interix3*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  _LT_AC_TAGVAR(predep_objects,$1)=
+  _LT_AC_TAGVAR(postdep_objects,$1)=
+  _LT_AC_TAGVAR(postdeps,$1)=
+  ;;
+
+solaris*)
+  case $cc_basename in
+  CC*)
+    # Adding this requires a known-good setup of shared libraries for
+    # Sun compiler versions before 5.6, else PIC objects from an old
+    # archive will be linked into the output, leading to subtle bugs.
+    _LT_AC_TAGVAR(postdeps,$1)='-lCstd -lCrun'
+    ;;
+  esac
+  ;;
+esac
+])
+
+case " $_LT_AC_TAGVAR(postdeps, $1) " in
+*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;
+esac
+])# AC_LIBTOOL_POSTDEP_PREDEP
+
+# AC_LIBTOOL_LANG_F77_CONFIG
+# --------------------------
+# Ensure that the configuration vars for the C compiler are
+# suitably defined.  Those variables are subsequently used by
+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
+AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG], [_LT_AC_LANG_F77_CONFIG(F77)])
+AC_DEFUN([_LT_AC_LANG_F77_CONFIG],
+[AC_REQUIRE([AC_PROG_F77])
+AC_LANG_PUSH(Fortran 77)
+
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_AC_TAGVAR(allow_undefined_flag, $1)=
+_LT_AC_TAGVAR(always_export_symbols, $1)=no
+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_direct, $1)=no
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+_LT_AC_TAGVAR(hardcode_automatic, $1)=no
+_LT_AC_TAGVAR(module_cmds, $1)=
+_LT_AC_TAGVAR(module_expsym_cmds, $1)=
+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_AC_TAGVAR(no_undefined_flag, $1)=
+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="      program t\n      end\n"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${F77-"f77"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+
+AC_MSG_CHECKING([if libtool supports shared libraries])
+AC_MSG_RESULT([$can_build_shared])
+
+AC_MSG_CHECKING([whether to build shared libraries])
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case $host_os in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+aix4* | aix5*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+  ;;
+esac
+AC_MSG_RESULT([$enable_shared])
+
+AC_MSG_CHECKING([whether to build static libraries])
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+AC_MSG_RESULT([$enable_static])
+
+_LT_AC_TAGVAR(GCC, $1)="$G77"
+_LT_AC_TAGVAR(LD, $1)="$LD"
+
+AC_LIBTOOL_PROG_COMPILER_PIC($1)
+AC_LIBTOOL_PROG_CC_C_O($1)
+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+AC_LIBTOOL_PROG_LD_SHLIBS($1)
+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+
+AC_LIBTOOL_CONFIG($1)
+
+AC_LANG_POP
+CC="$lt_save_CC"
+])# AC_LIBTOOL_LANG_F77_CONFIG
+
+
+# AC_LIBTOOL_LANG_GCJ_CONFIG
+# --------------------------
+# Ensure that the configuration vars for the C compiler are
+# suitably defined.  Those variables are subsequently used by
+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
+AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG], [_LT_AC_LANG_GCJ_CONFIG(GCJ)])
+AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG],
+[AC_LANG_SAVE
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${GCJ-"gcj"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+
+AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
+AC_LIBTOOL_PROG_COMPILER_PIC($1)
+AC_LIBTOOL_PROG_CC_C_O($1)
+AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+AC_LIBTOOL_PROG_LD_SHLIBS($1)
+AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+
+AC_LIBTOOL_CONFIG($1)
+
+AC_LANG_RESTORE
+CC="$lt_save_CC"
+])# AC_LIBTOOL_LANG_GCJ_CONFIG
+
+
+# AC_LIBTOOL_LANG_RC_CONFIG
+# -------------------------
+# Ensure that the configuration vars for the Windows resource compiler are
+# suitably defined.  Those variables are subsequently used by
+# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
+AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG], [_LT_AC_LANG_RC_CONFIG(RC)])
+AC_DEFUN([_LT_AC_LANG_RC_CONFIG],
+[AC_LANG_SAVE
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="$lt_simple_compile_test_code"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${RC-"windres"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+
+AC_LIBTOOL_CONFIG($1)
+
+AC_LANG_RESTORE
+CC="$lt_save_CC"
+])# AC_LIBTOOL_LANG_RC_CONFIG
+
+
+# AC_LIBTOOL_CONFIG([TAGNAME])
+# ----------------------------
+# If TAGNAME is not passed, then create an initial libtool script
+# with a default configuration from the untagged config vars.  Otherwise
+# add code to config.status for appending the configuration named by
+# TAGNAME from the matching tagged config vars.
+AC_DEFUN([AC_LIBTOOL_CONFIG],
+[# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    _LT_AC_TAGVAR(compiler, $1) \
+    _LT_AC_TAGVAR(CC, $1) \
+    _LT_AC_TAGVAR(LD, $1) \
+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1) \
+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1) \
+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1) \
+    _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) \
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1) \
+    _LT_AC_TAGVAR(thread_safe_flag_spec, $1) \
+    _LT_AC_TAGVAR(whole_archive_flag_spec, $1) \
+    _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1) \
+    _LT_AC_TAGVAR(old_archive_cmds, $1) \
+    _LT_AC_TAGVAR(old_archive_from_new_cmds, $1) \
+    _LT_AC_TAGVAR(predep_objects, $1) \
+    _LT_AC_TAGVAR(postdep_objects, $1) \
+    _LT_AC_TAGVAR(predeps, $1) \
+    _LT_AC_TAGVAR(postdeps, $1) \
+    _LT_AC_TAGVAR(compiler_lib_search_path, $1) \
+    _LT_AC_TAGVAR(archive_cmds, $1) \
+    _LT_AC_TAGVAR(archive_expsym_cmds, $1) \
+    _LT_AC_TAGVAR(postinstall_cmds, $1) \
+    _LT_AC_TAGVAR(postuninstall_cmds, $1) \
+    _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) \
+    _LT_AC_TAGVAR(allow_undefined_flag, $1) \
+    _LT_AC_TAGVAR(no_undefined_flag, $1) \
+    _LT_AC_TAGVAR(export_symbols_cmds, $1) \
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) \
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1) \
+    _LT_AC_TAGVAR(hardcode_libdir_separator, $1) \
+    _LT_AC_TAGVAR(hardcode_automatic, $1) \
+    _LT_AC_TAGVAR(module_cmds, $1) \
+    _LT_AC_TAGVAR(module_expsym_cmds, $1) \
+    _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1) \
+    _LT_AC_TAGVAR(exclude_expsyms, $1) \
+    _LT_AC_TAGVAR(include_expsyms, $1); do
+
+    case $var in
+    _LT_AC_TAGVAR(old_archive_cmds, $1) | \
+    _LT_AC_TAGVAR(old_archive_from_new_cmds, $1) | \
+    _LT_AC_TAGVAR(archive_cmds, $1) | \
+    _LT_AC_TAGVAR(archive_expsym_cmds, $1) | \
+    _LT_AC_TAGVAR(module_cmds, $1) | \
+    _LT_AC_TAGVAR(module_expsym_cmds, $1) | \
+    _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) | \
+    _LT_AC_TAGVAR(export_symbols_cmds, $1) | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\[$]0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\[$]0 --fallback-echo"[$]/[$]0 --fallback-echo"/'`
+    ;;
+  esac
+
+ifelse([$1], [],
+  [cfgfile="${ofile}T"
+  trap "$rm \"$cfgfile\"; exit 1" 1 2 15
+  $rm -f "$cfgfile"
+  AC_MSG_NOTICE([creating $ofile])],
+  [cfgfile="$ofile"])
+
+  cat <<__EOF__ >> "$cfgfile"
+ifelse([$1], [],
+[#! $SHELL
+
+# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
+# Free Software Foundation, Inc.
+#
+# This file is part of GNU Libtool:
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="$SED -e 1s/^X//"
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# The names of the tagged configurations supported by this script.
+available_tags=
+
+# ### BEGIN LIBTOOL CONFIG],
+[# ### BEGIN LIBTOOL TAG CONFIG: $tagname])
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_[]_LT_AC_TAGVAR(compiler, $1)
+
+# Is the compiler the GNU C compiler?
+with_gcc=$_LT_AC_TAGVAR(GCC, $1)
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_[]_LT_AC_TAGVAR(LD, $1)
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_static, $1)
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_[]_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_[]_LT_AC_TAGVAR(whole_archive_flag_spec, $1)
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_[]_LT_AC_TAGVAR(thread_safe_flag_spec, $1)
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_cmds, $1)
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_new_cmds, $1)
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_[]_LT_AC_TAGVAR(archive_cmds, $1)
+archive_expsym_cmds=$lt_[]_LT_AC_TAGVAR(archive_expsym_cmds, $1)
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_[]_LT_AC_TAGVAR(module_cmds, $1)
+module_expsym_cmds=$lt_[]_LT_AC_TAGVAR(module_expsym_cmds, $1)
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_[]_LT_AC_TAGVAR(predep_objects, $1)
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_[]_LT_AC_TAGVAR(postdep_objects, $1)
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_[]_LT_AC_TAGVAR(predeps, $1)
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_[]_LT_AC_TAGVAR(postdeps, $1)
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_[]_LT_AC_TAGVAR(compiler_lib_search_path, $1)
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_[]_LT_AC_TAGVAR(allow_undefined_flag, $1)
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_[]_LT_AC_TAGVAR(no_undefined_flag, $1)
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$_LT_AC_TAGVAR(hardcode_action, $1)
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_separator, $1)
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$_LT_AC_TAGVAR(hardcode_direct, $1)
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$_LT_AC_TAGVAR(hardcode_minus_L, $1)
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$_LT_AC_TAGVAR(hardcode_automatic, $1)
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$_LT_AC_TAGVAR(link_all_deplibs, $1)
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$_LT_AC_TAGVAR(fix_srcfile_path, $1)"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$_LT_AC_TAGVAR(always_export_symbols, $1)
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_[]_LT_AC_TAGVAR(export_symbols_cmds, $1)
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_[]_LT_AC_TAGVAR(exclude_expsyms, $1)
+
+# Symbols that must always be exported.
+include_expsyms=$lt_[]_LT_AC_TAGVAR(include_expsyms, $1)
+
+ifelse([$1],[],
+[# ### END LIBTOOL CONFIG],
+[# ### END LIBTOOL TAG CONFIG: $tagname])
+
+__EOF__
+
+ifelse([$1],[], [
+  case $host_os in
+  aix3*)
+    cat <<\EOF >> "$cfgfile"
+
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+EOF
+    ;;
+  esac
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)
+
+  mv -f "$cfgfile" "$ofile" || \
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+])
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+])# AC_LIBTOOL_CONFIG
+
+
+# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])
+# -------------------------------------------
+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],
+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+
+_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+
+if test "$GCC" = yes; then
+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+
+  AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
+    lt_cv_prog_compiler_rtti_exceptions,
+    [-fno-rtti -fno-exceptions], [],
+    [_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
+fi
+])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI
+
+
+# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+# ---------------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],
+[AC_REQUIRE([AC_CANONICAL_HOST])
+AC_REQUIRE([AC_PROG_NM])
+AC_REQUIRE([AC_OBJEXT])
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+AC_MSG_CHECKING([command to parse $NM output from $compiler object])
+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
+[
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[[BCDEGRST]]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
+
+# Transform an extracted symbol line into a proper C declaration
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[[BCDT]]'
+  ;;
+cygwin* | mingw* | pw32*)
+  symcode='[[ABCDGISTW]]'
+  ;;
+hpux*) # Its linker distinguishes data from code symbols
+  if test "$host_cpu" = ia64; then
+    symcode='[[ABCDEGRST]]'
+  fi
+  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+  ;;
+linux*)
+  if test "$host_cpu" = ia64; then
+    symcode='[[ABCDGIRSTW]]'
+    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+    lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[[BCDEGRST]]'
+  ;;
+osf*)
+  symcode='[[BCDEGQRST]]'
+  ;;
+solaris*)
+  symcode='[[BDRT]]'
+  ;;
+sco3.2v5*)
+  symcode='[[DT]]'
+  ;;
+sysv4.2uw2*)
+  symcode='[[DT]]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[[ABDT]]'
+  ;;
+sysv4)
+  symcode='[[DFNSTU]]'
+  ;;
+esac
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[[ABCDGIRSTW]]' ;;
+esac
+
+# Try without a prefix undercore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ 	]]\($symcode$symcode*\)[[ 	]][[ 	]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+EOF
+
+  if AC_TRY_EVAL(ac_compile); then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if grep ' nm_test_var$' "$nlist" >/dev/null; then
+	if grep ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<EOF > conftest.$ac_ext
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'
+
+	  cat <<EOF >> conftest.$ac_ext
+#if defined (__STDC__) && __STDC__
+# define lt_ptr_t void *
+#else
+# define lt_ptr_t char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+const struct {
+  const char *name;
+  lt_ptr_t address;
+}
+lt_preloaded_symbols[[]] =
+{
+EOF
+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext
+	  cat <<\EOF >> conftest.$ac_ext
+  {0, (lt_ptr_t) 0}
+};
+
+#ifdef __cplusplus
+}
+#endif
+EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_save_LIBS="$LIBS"
+	  lt_save_CFLAGS="$CFLAGS"
+	  LIBS="conftstm.$ac_objext"
+	  CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
+	  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
+	    pipe_works=yes
+	  fi
+	  LIBS="$lt_save_LIBS"
+	  CFLAGS="$lt_save_CFLAGS"
+	else
+	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
+    fi
+  else
+    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
+    cat conftest.$ac_ext >&5
+  fi
+  rm -f conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+])
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  AC_MSG_RESULT(failed)
+else
+  AC_MSG_RESULT(ok)
+fi
+]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+
+
+# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])
+# ---------------------------------------
+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],
+[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=
+_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=
+
+AC_MSG_CHECKING([for $compiler option to produce PIC])
+ ifelse([$1],[CXX],[
+  # C++ specific cases for pic, static, wl, etc.
+  if test "$GXX" = yes; then
+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+      ;;
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | os2* | pw32*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+      ;;
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix4* | aix5*)
+	# All AIX code is PIC.
+	if test "$host_cpu" = ia64; then
+	  # AIX 5 now supports IA64 processor
+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	else
+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68*)
+	  # Green Hills C++ Compiler
+	  # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+       darwin*)
+         # PIC is the default on this platform
+         # Common symbols not allowed in MH_DYLIB files
+         case $cc_basename in
+           xlc*)
+           _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
+           _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+           ;;
+         esac
+       ;;
+      dgux*)
+	case $cc_basename in
+	  ec++*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  ghcx*)
+	    # Green Hills C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | kfreebsd*-gnu | dragonfly*)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+	    if test "$host_cpu" != ia64; then
+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	    fi
+	    ;;
+	  aCC*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+	    case $host_cpu in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      interix*)
+	# This is c89, which is MS Visual C++ (no shared libs)
+	# Anyone wants to do a port?
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux*)
+	case $cc_basename in
+	  KCC*)
+	    # KAI C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	    ;;
+	  icpc* | ecpc*)
+	    # Intel C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	    ;;
+	  pgCC*)
+	    # Portland Group C++ compiler.
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	  cxx*)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd*)
+	;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    ;;
+	  RCC*)
+	    # Rational C++ 2.4.1
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  cxx*)
+	    # Digital/Compaq C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+	    ;;
+	  gcx*)
+	    # Green Hills C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.x
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	  lcc*)
+	    # Lucid
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC*)
+	    # NonStop-UX NCC 3.20
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+	case $cc_basename in
+	  CC*)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	esac
+	;;
+      vxworks*)
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+	;;
+    esac
+  fi
+],
+[
+  if test "$GCC" = yes; then
+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+      ;;
+
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      enable_shared=no
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      else
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+      darwin*)
+        # PIC is the default on this platform
+        # Common symbols not allowed in MH_DYLIB files
+       case $cc_basename in
+         xlc*)
+         _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
+         _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+         ;;
+       esac
+       ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC (with -KPIC) is the default.
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    newsos6)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    linux*)
+      case $cc_basename in
+      icc* | ecc*)
+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      pgcc* | pgf77* | pgf90* | pgf95*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+        ;;
+      ccc*)
+        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        # All Alpha code is PIC.
+        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+        ;;
+      esac
+      ;;
+
+    osf3* | osf4* | osf5*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # All OSF/1 code is PIC.
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    solaris*)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    unicos*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+
+    uts4*)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+    esac
+  fi
+])
+AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)])
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then
+  AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works],
+    _LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1),
+    [$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])], [],
+    [case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in
+     "" | " "*) ;;
+     *) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;;
+     esac],
+    [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+     _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
+fi
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+    ;;
+  *)
+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])"
+    ;;
+esac
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_AC_TAGVAR(lt_prog_compiler_static, $1)\"
+AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
+  _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),
+  $lt_tmp_static_flag,
+  [],
+  [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])
+])
+
+
+# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME])
+# ------------------------------------
+# See if the linker supports building shared libraries.
+AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS],
+[AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+ifelse([$1],[CXX],[
+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  case $host_os in
+  aix4* | aix5*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to AIX nm, but means don't demangle with GNU nm
+    if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+    else
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
+  ;;
+  cygwin* | mingw*)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([[^ ]]*\) [[^ ]]*/\1 DATA/;/^I /d;/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  *)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  esac
+],[
+  runpath_var=
+  _LT_AC_TAGVAR(allow_undefined_flag, $1)=
+  _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+  _LT_AC_TAGVAR(archive_cmds, $1)=
+  _LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+  _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)=
+  _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)=
+  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+  _LT_AC_TAGVAR(thread_safe_flag_spec, $1)=
+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+  _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+  _LT_AC_TAGVAR(hardcode_automatic, $1)=no
+  _LT_AC_TAGVAR(module_cmds, $1)=
+  _LT_AC_TAGVAR(module_expsym_cmds, $1)=
+  _LT_AC_TAGVAR(always_export_symbols, $1)=no
+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  _LT_AC_TAGVAR(include_expsyms, $1)=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  _LT_AC_TAGVAR(exclude_expsyms, $1)="_GLOBAL_OFFSET_TABLE_"
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  extract_expsyms_cmds=
+  # Just being paranoid about ensuring that cc_basename is set.
+  _LT_CC_BASENAME([$compiler])
+  case $host_os in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  _LT_AC_TAGVAR(ld_shlibs, $1)=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+  	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>/dev/null` in
+      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	cat <<EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+EOF
+      fi
+      ;;
+
+    amigaos*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we can't use
+      # them.
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+      # as there is no search path for DLLs.
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(always_export_symbols, $1)=no
+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    interix3*)
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    linux*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	tmp_addflag=
+	case $cc_basename,$host_cpu in
+	pgcc*)				# Portland Group C compiler
+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers
+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	esac
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+	if test $supports_anon_versioning = yes; then
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~
+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+  $echo "local: *; };" >> $output_objdir/$libname.ver~
+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+	fi
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	cat <<EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+EOF
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) 
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'
+	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'
+	  else
+	    _LT_AC_TAGVAR(ld_shlibs, $1)=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+    esac
+
+    if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no; then
+      runpath_var=
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	_LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+      fi
+      ;;
+
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+	else
+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
+	  for ld_flag in $LDFLAGS; do
+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+  	    aix_use_runtimelinking=yes
+  	    break
+  	  fi
+	  done
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      _LT_AC_TAGVAR(archive_cmds, $1)=''
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[[012]]|aix4.[[012]].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" && \
+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	  then
+  	  # We have reworked collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	  else
+  	  # We have old collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag="$shared_flag "'${wl}-G'
+	fi
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+	  fi
+	fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
+       # Determine the default libpath from the value encoded in an empty executable.
+       _LT_AC_SYS_LIBPATH_AIX
+       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+       else
+	if test "$host_cpu" = ia64; then
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an empty executable.
+	 _LT_AC_SYS_LIBPATH_AIX
+	 _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+	  # Exported symbols can be pulled into shared objects from archives
+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+	  # This is similar to how AIX traditionally builds its shared libraries.
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      # see comment about different semantics on the GNU ld section
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    bsdi[[45]]*)
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='true'
+      # FIXME: Should let the user specify the lib program.
+      _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'
+      _LT_AC_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'
+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
+    darwin* | rhapsody*)
+      case $host_os in
+        rhapsody* | darwin1.[[012]])
+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[[012]])
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+      esac
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+    if test "$GCC" = yes ; then
+    	output_verbose_link_cmd='echo'
+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+         _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+         _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+         _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         _LT_AC_TAGVAR(ld_shlibs, $1)=no
+          ;;
+      esac
+    fi
+      ;;
+
+    dgux*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    freebsd1*)
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | kfreebsd*-gnu | dragonfly*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	_LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	case $host_cpu in
+	hppa*64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+	  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    newsos6)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    openbsd*)
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      else
+       case $host_os in
+	 openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
+	   _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	   ;;
+	 *)
+	   _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	   ;;
+       esac
+      fi
+      ;;
+
+    os2*)
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(archive_cmds, $1)='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      else
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    solaris*)
+      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
+      if test "$GCC" = yes; then
+	wlarc='${wl}'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
+      else
+	wlarc=''
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      case $host_os in
+      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+      *)
+ 	# The compiler driver will combine linker options so we
+ 	# cannot just pass the convience library names through
+ 	# without $wl, iff we do not link with $LD.
+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.
+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)
+ 	case $wlarc in
+ 	'')
+ 	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;
+ 	*)
+ 	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;
+ 	esac ;;
+      esac
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+        ;;
+	motorola)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4.3*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	_LT_AC_TAGVAR(ld_shlibs, $1)=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7*)
+      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    esac
+  fi
+])
+AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
+test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in
+x|xyes)
+  # Assume -lc should be added
+  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $_LT_AC_TAGVAR(archive_cmds, $1) in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      AC_MSG_CHECKING([whether -lc should be explicitly linked in])
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
+	pic_flag=$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1)
+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=
+        if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1)
+        then
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+        else
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+        fi
+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)])
+      ;;
+    esac
+  fi
+  ;;
+esac
+])# AC_LIBTOOL_PROG_LD_SHLIBS
+
+
+# _LT_AC_FILE_LTDLL_C
+# -------------------
+# Be careful that the start marker always follows a newline.
+AC_DEFUN([_LT_AC_FILE_LTDLL_C], [
+# /* ltdll.c starts here */
+# #define WIN32_LEAN_AND_MEAN
+# #include <windows.h>
+# #undef WIN32_LEAN_AND_MEAN
+# #include <stdio.h>
+#
+# #ifndef __CYGWIN__
+# #  ifdef __CYGWIN32__
+# #    define __CYGWIN__ __CYGWIN32__
+# #  endif
+# #endif
+#
+# #ifdef __cplusplus
+# extern "C" {
+# #endif
+# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
+# #ifdef __cplusplus
+# }
+# #endif
+#
+# #ifdef __CYGWIN__
+# #include <cygwin/cygwin_dll.h>
+# DECLARE_CYGWIN_DLL( DllMain );
+# #endif
+# HINSTANCE __hDllInstance_base;
+#
+# BOOL APIENTRY
+# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
+# {
+#   __hDllInstance_base = hInst;
+#   return TRUE;
+# }
+# /* ltdll.c ends here */
+])# _LT_AC_FILE_LTDLL_C
+
+
+# _LT_AC_TAGVAR(VARNAME, [TAGNAME])
+# ---------------------------------
+AC_DEFUN([_LT_AC_TAGVAR], [ifelse([$2], [], [$1], [$1_$2])])
+
+
+# old names
+AC_DEFUN([AM_PROG_LIBTOOL],   [AC_PROG_LIBTOOL])
+AC_DEFUN([AM_ENABLE_SHARED],  [AC_ENABLE_SHARED($@)])
+AC_DEFUN([AM_ENABLE_STATIC],  [AC_ENABLE_STATIC($@)])
+AC_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+AC_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+AC_DEFUN([AM_PROG_LD],        [AC_PROG_LD])
+AC_DEFUN([AM_PROG_NM],        [AC_PROG_NM])
+
+# This is just to silence aclocal about the macro not being used
+ifelse([AC_DISABLE_FAST_INSTALL])
+
+AC_DEFUN([LT_AC_PROG_GCJ],
+[AC_CHECK_TOOL(GCJ, gcj, no)
+  test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
+  AC_SUBST(GCJFLAGS)
+])
+
+AC_DEFUN([LT_AC_PROG_RC],
+[AC_CHECK_TOOL(RC, windres, no)
+])
+
+# NOTE: This macro has been submitted for inclusion into   #
+#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
+#  a released version of Autoconf we should remove this    #
+#  macro and use it instead.                               #
+# LT_AC_PROG_SED
+# --------------
+# Check for a fully-functional sed program, that truncates
+# as few characters as possible.  Prefer GNU sed if found.
+AC_DEFUN([LT_AC_PROG_SED],
+[AC_MSG_CHECKING([for a sed that does not truncate output])
+AC_CACHE_VAL(lt_cv_path_SED,
+[# Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for lt_ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+      fi
+    done
+  done
+done
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+  test ! -f $lt_ac_sed && continue
+  cat /dev/null > conftest.in
+  lt_ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+  # Check for GNU sed and select it if it is found.
+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+    lt_cv_path_SED=$lt_ac_sed
+    break
+  fi
+  while true; do
+    cat conftest.in conftest.in >conftest.tmp
+    mv conftest.tmp conftest.in
+    cp conftest.in conftest.nl
+    echo >>conftest.nl
+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+    cmp -s conftest.out conftest.nl || break
+    # 10000 chars as input seems more than enough
+    test $lt_ac_count -gt 10 && break
+    lt_ac_count=`expr $lt_ac_count + 1`
+    if test $lt_ac_count -gt $lt_ac_max; then
+      lt_ac_max=$lt_ac_count
+      lt_cv_path_SED=$lt_ac_sed
+    fi
+  done
+done
+])
+SED=$lt_cv_path_SED
+AC_MSG_RESULT([$SED])
+])
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/addopcodes.awk b/client/src/thirdparty/sqlite-3.4.2/addopcodes.awk
new file mode 100644
index 0000000..b806b1d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/addopcodes.awk
@@ -0,0 +1,32 @@
+#!/usr/bin/awk
+#
+# This script appends additional token codes to the end of the
+# parse.h file that lemon generates.  These extra token codes are
+# not used by the parser.  But they are used by the tokenizer and/or
+# the code generator.
+#
+#
+BEGIN {
+  max = 0
+}
+/^#define TK_/ {
+  print $0
+  if( max<$3 ) max = $3
+}
+END {
+  printf "#define TK_%-29s %4d\n", "TO_TEXT",         max+1
+  printf "#define TK_%-29s %4d\n", "TO_BLOB",         max+2
+  printf "#define TK_%-29s %4d\n", "TO_NUMERIC",      max+3
+  printf "#define TK_%-29s %4d\n", "TO_INT",          max+4
+  printf "#define TK_%-29s %4d\n", "TO_REAL",         max+5
+  printf "#define TK_%-29s %4d\n", "END_OF_FILE",     max+6
+  printf "#define TK_%-29s %4d\n", "ILLEGAL",         max+7
+  printf "#define TK_%-29s %4d\n", "SPACE",           max+8
+  printf "#define TK_%-29s %4d\n", "UNCLOSED_STRING", max+9
+  printf "#define TK_%-29s %4d\n", "COMMENT",         max+10
+  printf "#define TK_%-29s %4d\n", "FUNCTION",        max+11
+  printf "#define TK_%-29s %4d\n", "COLUMN",          max+12
+  printf "#define TK_%-29s %4d\n", "AGG_FUNCTION",    max+13
+  printf "#define TK_%-29s %4d\n", "AGG_COLUMN",      max+14
+  printf "#define TK_%-29s %4d\n", "CONST_FUNC",      max+15
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/art/2005osaward.gif b/client/src/thirdparty/sqlite-3.4.2/art/2005osaward.gif
new file mode 100644
index 0000000..76da760
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/art/2005osaward.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f625758f8ab9fd01eaa0921c9d6fd92d20aea3312f51fce7160e75a2717c441
+size 3750
diff --git a/client/src/thirdparty/sqlite-3.4.2/art/SQLite.eps b/client/src/thirdparty/sqlite-3.4.2/art/SQLite.eps
new file mode 100644
index 0000000000000000000000000000000000000000..1f334ecf7b49ee6e596802d5cf8e208caebb034f
GIT binary patch
literal 24155
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
DOHLiR

literal 0
HcmV?d00001

diff --git a/client/src/thirdparty/sqlite-3.4.2/art/SQLite.gif b/client/src/thirdparty/sqlite-3.4.2/art/SQLite.gif
new file mode 100644
index 0000000..4517a50
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/art/SQLite.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1abd4686487a78afd48a991976eff4bfef98187d67d31d11fb9f25ea89d127b0
+size 3062
diff --git a/client/src/thirdparty/sqlite-3.4.2/art/SQLiteLogo3.tiff b/client/src/thirdparty/sqlite-3.4.2/art/SQLiteLogo3.tiff
new file mode 100644
index 0000000000000000000000000000000000000000..70b88e78057d7aa046d489e025273ba38d774c1b
GIT binary patch
literal 85156
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%0A2vxehzOjQ>q9f8Q0p_RnbfbgOQW+j
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%0A#>p9H
zyTw=*tRFZm<H*7l_`L{<*lpN2ARkflToX`smCveO<FhQPUn>v0(J&8oa_1>KX&&i&
z2kj6~BSAf!>0d_nnv4m-k(=(~mzF0ng&#u93|Rs1)(7}`#cVM=$nqX{5dY@kzhD6t
z6Ao%4>#o7>JNuKsD^)NSm7LML8L)oV^z|$JCb=9_{6v~!6%8XDP2m@~fg*?J7WS`*
zZCm?Q^gm03bENdf00CS|gM%)9#iOz-tG0)vBTl_tcJE@d>F5UjSJ$RP9DT;EABg#!
zQ5PB_@i`caMT*Y@#LFderwQ%<#hlEm{CF{}an<VA66X<6uID;&i-8734N1U`I28Ea
zHEnSSw!0)4O?mNGx><hYNO8tv;kWmJojgy+N{MFu+l@<)-7h#kTKaj2A)v#Zv?Tsp
zeBL*SBJ}Sh7*ad~f}?T4qw7Djsd{U|9|aD5i(dU{^=oX3G6T#>{_g#TxFh3mkL4=S
zgKMEIbX3D5gQsu2T8+Bmrt{yXo39D8r4OaFby41uLcWR3*SNNE@MYurR?d%ZUVUoz
zeh!RZ4q?O;ZJAQc^>Ab`48Oo3hDq~6W?&$MA=T4bTkG2JepW^!*8V)%KjnIR&VjrT
zH}2=G*F{jQVu3H*jbY?Rf&>}UTcP~R`$*k9!vy3tM8o!>&}~VdN=zABI^~=hj?8}o
zzYui~lhL_G5x^y^Z5^)wI9`k6!2aLT%`aPy^PbiYMS#4rKM>gW84PC(JypuAm7x_&
zpU<resgzWIWq3Q3cn?!zw??s^gpsLj@ZZ~8yYAG)`temDd1xV!b5s8w*mE%u<QZ$7
zU2m029wc7Cuh`!(KjBaOS?fYi{1rSNCEIw;Y=ZFP0)GBeKL*$K{s2y;CoJvh_Mh<i
zUmNmnK8u(-*Og)tW3-SUN$z&ieLMADObJgQ#lj1A_*4tOn_F)OTLG-TakzE>5{MZ6
z%3CaxKXy2_v@cpJ3v(-3LIIN`sgB8{qiB%aa09=Q<elu&P?d}+Etk`^&V6WpS1x@f
zOtD*@M%&HFkMEy>JwS$D=cgB9gkraPG&k5Po7;Jf_a8>!_gPn}Pgos*Z<gZ7x=--?
zru3L>0Xm9AczNux<9PKSM)bhojzEt1@J?l$+{+&VuT&l<X-bh4c41`k*KZ29Yv16P
zp8*N^8(|;Y&<&R<mt)Glc~0)d(p|vKpW>y$WK!rTVx;nGFAxagahBip%P~H`P5^4z
zpg+3if5{H~{}y)sTj<-P=&B;1p0jH8;}j<)uTFQ;u6w_;^2mPD<7;{Cp@k!+A=vJU
z8QbF{?P-r?P0@oaf6O@UXE_hx6&v~o4DbB!X4-Ki+%qk}Ld%-d7}G#jFh7$2>aoJ)
zeX!Ox_08h<X>vix(TOmRMW&_BcXh8_2Kt0+odAcaoV%5Pm-zoU(<FSH6nXFNRy{#<
zV>Z9UMI{|qf#i5HXHK7JC^<O#uh94J6q?u$NU@QTjT&rYw~rhAG5xC_o))u@_dM=;
znQd2Q${Mdco@trBywCGmLiq<-N1_D>^VY8+2FDvA(Bth%9*QOD8$zlHDyK|3)u^Qt
z@~Qq6`u<A_ZL}bm1Ng2$0FMv^1%W_dr~vQ}{MQ(?4vZmx##A8i*%2`G@AK5ad78h+
z5May-q5`hv0iH7n=KT9Sa0blv=R9z05IvatKb~W*0_Fn&cL0GwVDmyS|3Ai+V1d7{
z1+D-~{iple{_{L=9SB7G_uugd1Z@Hi${-L!IS9nQ0|N0of<WS`Adp572xKV?0(p6X
zK=Cnv0`naZs0+AwR15@KF9m^V$sn+VBM7We0s^bbfxsGmAh1p}2&^9o0-vD)flb4K
zd)I(KRO!Gm0C){25D4ZA0?~Z|fjCuw*Xjm=IP^du0S*v|?=)~c2Ydv;y%ABs*b@X2
pbO)Y`0)c3XfqSR}4>)k2L*P*eJb?EGz5}8^z=A-MEdO!*{{Rlf?4kew

literal 0
HcmV?d00001

diff --git a/client/src/thirdparty/sqlite-3.4.2/art/SQLite_big.gif b/client/src/thirdparty/sqlite-3.4.2/art/SQLite_big.gif
new file mode 100644
index 0000000..ac52837
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/art/SQLite_big.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de2d04b2e4cf1a9ba33ed0fa4056ac35bac9a4ddb8b0c8aba6b01be56d06e963
+size 7428
diff --git a/client/src/thirdparty/sqlite-3.4.2/art/nocopy.gif b/client/src/thirdparty/sqlite-3.4.2/art/nocopy.gif
new file mode 100644
index 0000000..30544bf
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/art/nocopy.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c3c04918ca0a9cc5b7e6d1f195895fad18a438779da0e7f17814dadafa57f8d
+size 3449
diff --git a/client/src/thirdparty/sqlite-3.4.2/art/powered_by_sqlite.gif b/client/src/thirdparty/sqlite-3.4.2/art/powered_by_sqlite.gif
new file mode 100644
index 0000000..4511919
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/art/powered_by_sqlite.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a45d4d509612d93c868aab01492fc4ae9b30107a99db0d92ac18686af9a3c69
+size 3391
diff --git a/client/src/thirdparty/sqlite-3.4.2/config.guess b/client/src/thirdparty/sqlite-3.4.2/config.guess
new file mode 100644
index 0000000..6960a39
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/config.guess
@@ -0,0 +1,1532 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+#   Inc.
+
+timestamp='2007-01-15'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Originally written by Per Bothner <per@bothner.com>.
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub.  If it succeeds, it prints the system name on stdout, and
+# exits with 0.  Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit build system type.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > $dummy.c ;
+	for c in cc gcc c89 c99 ; do
+	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found ;
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+if [ "${UNAME_SYSTEM}" = "Linux" ] ; then
+	eval $set_cc_for_build
+	cat << EOF > $dummy.c
+	#include <features.h>
+	#ifdef __UCLIBC__
+	# ifdef __UCLIBC_CONFIG_VERSION__
+	LIBC=uclibc __UCLIBC_CONFIG_VERSION__
+	# else
+	LIBC=uclibc
+	# endif
+	#else
+	LIBC=gnu
+	#endif
+EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep LIBC= | sed -e 's: ::g'`
+fi
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+	# NetBSD (nbsd) targets should (where applicable) match one or
+	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+	case "${UNAME_MACHINE_ARCH}" in
+	    armeb) machine=armeb-unknown ;;
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
+	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+	esac
+	# The Operating System including object format, if it has switched
+	# to ELF recently, or will in the future.
+	case "${UNAME_MACHINE_ARCH}" in
+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval $set_cc_for_build
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep __ELF__ >/dev/null
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+	        os=netbsd
+		;;
+	esac
+	# The OS release
+	# Debian GNU/NetBSD machines have a different userland, and
+	# thus, need a distinct triplet. However, they do not need
+	# kernel version information, so it can be replaced with a
+	# suitable tag, in the style of linux-gnu.
+	case "${UNAME_VERSION}" in
+	    Debian*)
+		release='-gnu'
+		;;
+	    *)
+		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+		;;
+	esac
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "${machine}-${os}${release}"
+	exit ;;
+    *:OpenBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+	exit ;;
+    *:ekkoBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+	exit ;;
+    *:SolidBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+	exit ;;
+    macppc:MirBSD:*:*)
+	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    *:MirBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    alpha:OSF1:*:*)
+	case $UNAME_RELEASE in
+	*4.0)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+		;;
+	*5.*)
+	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		;;
+	esac
+	# According to Compaq, /usr/sbin/psrinfo has been available on
+	# OSF/1 and Tru64 systems produced since 1995.  I hope that
+	# covers most systems running today.  This code pipes the CPU
+	# types through head -n 1, so we only detect the type of CPU 0.
+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+	case "$ALPHA_CPU_TYPE" in
+	    "EV4 (21064)")
+		UNAME_MACHINE="alpha" ;;
+	    "EV4.5 (21064)")
+		UNAME_MACHINE="alpha" ;;
+	    "LCA4 (21066/21068)")
+		UNAME_MACHINE="alpha" ;;
+	    "EV5 (21164)")
+		UNAME_MACHINE="alphaev5" ;;
+	    "EV5.6 (21164A)")
+		UNAME_MACHINE="alphaev56" ;;
+	    "EV5.6 (21164PC)")
+		UNAME_MACHINE="alphapca56" ;;
+	    "EV5.7 (21164PC)")
+		UNAME_MACHINE="alphapca57" ;;
+	    "EV6 (21264)")
+		UNAME_MACHINE="alphaev6" ;;
+	    "EV6.7 (21264A)")
+		UNAME_MACHINE="alphaev67" ;;
+	    "EV6.8CB (21264C)")
+		UNAME_MACHINE="alphaev68" ;;
+	    "EV6.8AL (21264B)")
+		UNAME_MACHINE="alphaev68" ;;
+	    "EV6.8CX (21264D)")
+		UNAME_MACHINE="alphaev68" ;;
+	    "EV6.9A (21264/EV69A)")
+		UNAME_MACHINE="alphaev69" ;;
+	    "EV7 (21364)")
+		UNAME_MACHINE="alphaev7" ;;
+	    "EV7.9 (21364A)")
+		UNAME_MACHINE="alphaev79" ;;
+	esac
+	# A Pn.n version is a patched version.
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+	exit ;;
+    Alpha\ *:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# Should we change UNAME_MACHINE based on the output of uname instead
+	# of the specific Alpha model?
+	echo alpha-pc-interix
+	exit ;;
+    21064:Windows_NT:50:3)
+	echo alpha-dec-winnt3.5
+	exit ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-unknown-sysv4
+	exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-amigaos
+	exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-morphos
+	exit ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit ;;
+    *:z/VM:*:*)
+	echo s390-ibm-zvmoe
+	exit ;;
+    *:OS400:*:*)
+        echo powerpc-ibm-os400
+	exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix${UNAME_RELEASE}
+	exit ;;
+    arm:riscos:*:*|arm:RISCOS:*:*)
+	echo arm-unknown-riscos
+	exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit ;;
+    DRS?6000:unix:4.0:6*)
+	echo sparc-icl-nx6
+	exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+	case `/usr/bin/uname -p` in
+	    sparc) echo sparc-icl-nx7; exit ;;
+	esac ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    i86pc:SunOS:5.*:*)
+	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	exit ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos${UNAME_RELEASE}
+	exit ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos${UNAME_RELEASE}
+		;;
+	    sun4)
+		echo sparc-sun-sunos${UNAME_RELEASE}
+		;;
+	esac
+	exit ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos${UNAME_RELEASE}
+	exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+        exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+        echo m68k-milan-mint${UNAME_RELEASE}
+        exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+        echo m68k-hades-mint${UNAME_RELEASE}
+        exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+        echo m68k-unknown-mint${UNAME_RELEASE}
+        exit ;;
+    m68k:machten:*:*)
+	echo m68k-apple-machten${UNAME_RELEASE}
+	exit ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten${UNAME_RELEASE}
+	exit ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix${UNAME_RELEASE}
+	exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c &&
+	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+	  SYSTEM_NAME=`$dummy $dummyarg` &&
+	    { echo "$SYSTEM_NAME"; exit; }
+	echo mips-mips-riscos${UNAME_RELEASE}
+	exit ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit ;;
+    Motorola:*:4.3:PL8-*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit ;;
+    AViiON:dgux:*:*)
+        # DG/UX returns AViiON for all architectures
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+	then
+	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+	       [ ${TARGET_BINARY_INTERFACE}x = x ]
+	    then
+		echo m88k-dg-dgux${UNAME_RELEASE}
+	    else
+		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+	    fi
+	else
+	    echo i586-dg-dgux${UNAME_RELEASE}
+	fi
+ 	exit ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+	echo i386-ibm-aix
+	exit ;;
+    ia64:AIX:*:*)
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval $set_cc_for_build
+		sed 's/^		//' << EOF >$dummy.c
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+		then
+			echo "$SYSTEM_NAME"
+		else
+			echo rs6000-ibm-aix3.2.5
+		fi
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit ;;
+    *:AIX:*:[45])
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+	echo romp-ibm-bsd4.4
+	exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+	exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit ;;
+    9000/[34678]??:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	case "${UNAME_MACHINE}" in
+	    9000/31? )            HP_ARCH=m68000 ;;
+	    9000/[34]?? )         HP_ARCH=m68k ;;
+	    9000/[678][0-9][0-9])
+		if [ -x /usr/bin/getconf ]; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+                    case "${sc_cpu_version}" in
+                      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+                      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+                      532)                      # CPU_PA_RISC2_0
+                        case "${sc_kernel_bits}" in
+                          32) HP_ARCH="hppa2.0n" ;;
+                          64) HP_ARCH="hppa2.0w" ;;
+			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
+                        esac ;;
+                    esac
+		fi
+		if [ "${HP_ARCH}" = "" ]; then
+		    eval $set_cc_for_build
+		    sed 's/^              //' << EOF >$dummy.c
+
+              #define _HPUX_SOURCE
+              #include <stdlib.h>
+              #include <unistd.h>
+
+              int main ()
+              {
+              #if defined(_SC_KERNEL_BITS)
+                  long bits = sysconf(_SC_KERNEL_BITS);
+              #endif
+                  long cpu  = sysconf (_SC_CPU_VERSION);
+
+                  switch (cpu)
+              	{
+              	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+              	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+              	case CPU_PA_RISC2_0:
+              #if defined(_SC_KERNEL_BITS)
+              	    switch (bits)
+              		{
+              		case 64: puts ("hppa2.0w"); break;
+              		case 32: puts ("hppa2.0n"); break;
+              		default: puts ("hppa2.0"); break;
+              		} break;
+              #else  /* !defined(_SC_KERNEL_BITS) */
+              	    puts ("hppa2.0"); break;
+              #endif
+              	default: puts ("hppa1.0"); break;
+              	}
+                  exit (0);
+              }
+EOF
+		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+		    test -z "$HP_ARCH" && HP_ARCH=hppa
+		fi ;;
+	esac
+	if [ ${HP_ARCH} = "hppa2.0w" ]
+	then
+	    eval $set_cc_for_build
+
+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+	    # generating 64-bit code.  GNU and HP use different nomenclature:
+	    #
+	    # $ CC_FOR_BUILD=cc ./config.guess
+	    # => hppa2.0w-hp-hpux11.23
+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+	    # => hppa64-hp-hpux11.23
+
+	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+		grep __LP64__ >/dev/null
+	    then
+		HP_ARCH="hppa2.0w"
+	    else
+		HP_ARCH="hppa64"
+	    fi
+	fi
+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	exit ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ia64-hp-hpux${HPUX_REV}
+	exit ;;
+    3050*:HI-UX:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+		{ echo "$SYSTEM_NAME"; exit; }
+	echo unknown-hitachi-hiuxwe2
+	exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+	echo hppa1.1-hp-bsd
+	exit ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+	echo hppa1.1-hp-osf
+	exit ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit ;;
+    i*86:OSF1:*:*)
+	if [ -x /usr/sbin/sysversion ] ; then
+	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	else
+	    echo ${UNAME_MACHINE}-unknown-osf1
+	fi
+	exit ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+        exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+        exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+        exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+        exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+        exit ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*[A-Z]90:*:*:*)
+	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    *:UNICOS/mp:*:*)
+	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        exit ;;
+    5000:UNIX_System_V:4.*:*)
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+        echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+	exit ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:BSD/OS:*:*)
+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:FreeBSD:*:*)
+	case ${UNAME_MACHINE} in
+	    pc98)
+		echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	    amd64)
+		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	    *)
+		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	esac
+	exit ;;
+    i*:CYGWIN*:*)
+	echo ${UNAME_MACHINE}-pc-cygwin
+	exit ;;
+    *:MINGW*:*)
+	echo ${UNAME_MACHINE}-pc-mingw32
+	exit ;;
+    i*:windows32*:*)
+    	# uname -m includes "-pc" on this system.
+    	echo ${UNAME_MACHINE}-mingw32
+	exit ;;
+    i*:PW*:*)
+	echo ${UNAME_MACHINE}-pc-pw32
+	exit ;;
+    x86:Interix*:[3456]*)
+	echo i586-pc-interix${UNAME_RELEASE}
+	exit ;;
+    EM64T:Interix*:[3456]* | authenticamd:Interix*:[3456]*)
+	echo x86_64-unknown-interix${UNAME_RELEASE}
+	exit ;;
+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+	echo i${UNAME_MACHINE}-pc-mks
+	exit ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+	# UNAME_MACHINE based on the output of uname instead of i386?
+	echo i586-pc-interix
+	exit ;;
+    i*:UWIN*:*)
+	echo ${UNAME_MACHINE}-pc-uwin
+	exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+	echo x86_64-unknown-cygwin
+	exit ;;
+    p*:CYGWIN*:*)
+	echo powerpcle-unknown-cygwin
+	exit ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    *:GNU:*:*)
+	# the GNU system
+	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	exit ;;
+    *:GNU/*:*:*)
+	# other systems with GNU libc and userland
+	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
+	exit ;;
+    i*86:Minix:*:*)
+	echo ${UNAME_MACHINE}-pc-minix
+	exit ;;
+    arm*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    avr32*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    cris:Linux:*:*)
+	echo cris-axis-linux-${LIBC}
+	exit ;;
+    crisv32:Linux:*:*)
+	echo crisv32-axis-linux-${LIBC}
+	exit ;;
+    frv:Linux:*:*)
+    	echo frv-unknown-linux-${LIBC}
+	exit ;;
+    ia64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m32r*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m68*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    mips:Linux:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef mips
+	#undef mipsel
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=mipsel
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=mips
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+	    /^CPU/{
+		s: ::g
+		p
+	    }'`"
+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	;;
+    mips64:Linux:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef mips64
+	#undef mips64el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=mips64el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=mips64
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+	    /^CPU/{
+		s: ::g
+		p
+	    }'`"
+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	;;
+    or32:Linux:*:*)
+	echo or32-unknown-linux-${LIBC}
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-${LIBC}
+	exit ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-${LIBC}
+	exit ;;
+    alpha:Linux:*:*)
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+        esac
+	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+	if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+	  *)    echo hppa-unknown-linux-${LIBC} ;;
+	esac
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-${LIBC}
+	exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo ${UNAME_MACHINE}-ibm-linux
+	exit ;;
+    sh64*:Linux:*:*)
+    	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sh*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    vax:Linux:*:*)
+	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+	exit ;;
+    x86_64:Linux:*:*)
+	echo x86_64-unknown-linux-${LIBC}
+	exit ;;
+    xtensa:Linux:*:*)
+    	echo xtensa-unknown-linux-${LIBC}
+	exit ;;
+    i*86:Linux:*:*)
+	# The BFD linker knows what the default object file format is, so
+	# first see if it will tell us. cd to the root directory to prevent
+	# problems with other programs or directories called `ld' in the path.
+	# Set LC_ALL=C to ensure ld outputs messages in English.
+	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
+			 | sed -ne '/supported targets:/!d
+				    s/[ 	][ 	]*/ /g
+				    s/.*supported targets: *//
+				    s/ .*//
+				    p'`
+        case "$ld_supported_targets" in
+	  elf32-i386)
+		TENTATIVE="${UNAME_MACHINE}-pc-linux-${LIBC}"
+		;;
+	  a.out-i386-linux)
+		echo "${UNAME_MACHINE}-pc-linux-${LIBC}aout"
+		exit ;;
+	  coff-i386)
+		echo "${UNAME_MACHINE}-pc-linux-${LIBC}coff"
+		exit ;;
+	  "")
+		# Either a pre-BFD a.out linker (linux-gnuoldld) or
+		# one that does not give us useful --help.
+		echo "${UNAME_MACHINE}-pc-linux-${LIBC}oldld"
+		exit ;;
+	esac
+	# This should get integrated into the C code below, but now we hack
+	if [ "$LIBC" != "gnu" ] ; then echo "$TENTATIVE" && exit 0 ; fi
+	# Determine whether the default compiler is a.out or elf
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#include <features.h>
+	#ifdef __ELF__
+	# ifdef __GLIBC__
+	#  if __GLIBC__ >= 2
+	LIBC=gnu
+	#  else
+	LIBC=gnulibc1
+	#  endif
+	# else
+	LIBC=gnulibc1
+	# endif
+	#else
+	#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+	LIBC=gnu
+	#else
+	LIBC=gnuaout
+	#endif
+	#endif
+	#ifdef __dietlibc__
+	LIBC=dietlibc
+	#endif
+EOF
+	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+	    /^LIBC/{
+		s: ::g
+		p
+	    }'`"
+	test x"${LIBC}" != x && {
+		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+		exit
+	}
+	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
+	;;
+    i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
+	echo i386-sequent-sysv4
+	exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+        # Unixware is an offshoot of SVR4, but it has its own version
+        # number series starting with 2...
+        # I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+        # Use sysv4.2uw... so that sysv4* matches it.
+	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+	exit ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo ${UNAME_MACHINE}-pc-os2-emx
+	exit ;;
+    i*86:XTS-300:*:STOP)
+	echo ${UNAME_MACHINE}-unknown-stop
+	exit ;;
+    i*86:atheos:*:*)
+	echo ${UNAME_MACHINE}-unknown-atheos
+	exit ;;
+    i*86:syllable:*:*)
+	echo ${UNAME_MACHINE}-pc-syllable
+	exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
+	echo i386-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    i*86:*DOS:*:*)
+	echo ${UNAME_MACHINE}-pc-msdosdjgpp
+	exit ;;
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+	else
+		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+	fi
+	exit ;;
+    i*86:*:5:[678]*)
+    	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	exit ;;
+    i*86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+	else
+		echo ${UNAME_MACHINE}-pc-sysv32
+	fi
+	exit ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+        # uname -m prints for DJGPP always 'pc', but it prints nothing about
+        # the processor, so we play safe by assuming i386.
+	echo i386-pc-msdosdjgpp
+        exit ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	fi
+	exit ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+	echo m68k-convergent-sysv
+	exit ;;
+    M680?0:D-NIX:5.3:*)
+	echo m68k-diab-dnix
+	exit ;;
+    M68*:*:R3V[5678]*:*)
+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+          && { echo i486-ncr-sysv4; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+	echo m68k-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    rs6000:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
+	echo powerpc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+	echo mips-dde-sysv${UNAME_RELEASE}
+	exit ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo ${UNAME_MACHINE}-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit ;;
+    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+                      # says <Richard.M.Bartel@ccMail.Census.GOV>
+        echo i586-unisys-sysv4
+        exit ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit ;;
+    i*86:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo ${UNAME_MACHINE}-stratus-vos
+	exit ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux${UNAME_RELEASE}
+	exit ;;
+    news*:NEWS-OS:6*:*)
+	echo mips-sony-newsos6
+	exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if [ -d /usr/nec ]; then
+	        echo mips-nec-sysv${UNAME_RELEASE}
+	else
+	        echo mips-unknown-sysv${UNAME_RELEASE}
+	fi
+        exit ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-6:SUPER-UX:*:*)
+	echo sx6-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux${UNAME_RELEASE}
+	exit ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Rhapsody:*:*)
+	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Darwin:*:*)
+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+	case $UNAME_PROCESSOR in
+	    unknown) UNAME_PROCESSOR=powerpc ;;
+	esac
+	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+	exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+	UNAME_PROCESSOR=`uname -p`
+	if test "$UNAME_PROCESSOR" = "x86"; then
+		UNAME_PROCESSOR=i386
+		UNAME_MACHINE=pc
+	fi
+	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+	exit ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit ;;
+    NSE-?:NONSTOP_KERNEL:*:*)
+	echo nse-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSR-?:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit ;;
+    DS/*:UNIX_System_V:*:*)
+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+	exit ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = "386"; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo ${UNAME_MACHINE}-unknown-plan9
+	exit ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit ;;
+    SEI:*:*:SEIUX)
+        echo mips-sei-seiux${UNAME_RELEASE}
+	exit ;;
+    *:DragonFly:*:*)
+	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+	exit ;;
+    *:*VMS:*:*)
+    	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	case "${UNAME_MACHINE}" in
+	    A*) echo alpha-dec-vms ; exit ;;
+	    I*) echo ia64-dec-vms ; exit ;;
+	    V*) echo vax-dec-vms ; exit ;;
+	esac ;;
+    *:XENIX:*:SysV)
+	echo i386-pc-xenix
+	exit ;;
+    i*86:skyos:*:*)
+	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+	exit ;;
+    i*86:rdos:*:*)
+	echo ${UNAME_MACHINE}-pc-rdos
+	exit ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+eval $set_cc_for_build
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+          "4"
+#else
+	  ""
+#endif
+         ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+  printf ("arm-acorn-riscix\n"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+  printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+    struct utsname un;
+
+    uname(&un);
+
+    if (strncmp(un.version, "V2", 2) == 0) {
+	printf ("i386-sequent-ptx2\n"); exit (0);
+    }
+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+	printf ("i386-sequent-ptx1\n"); exit (0);
+    }
+    printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+# if !defined (ultrix)
+#  include <sys/param.h>
+#  if defined (BSD)
+#   if BSD == 43
+      printf ("vax-dec-bsd4.3\n"); exit (0);
+#   else
+#    if BSD == 199006
+      printf ("vax-dec-bsd4.3reno\n"); exit (0);
+#    else
+      printf ("vax-dec-bsd\n"); exit (0);
+#    endif
+#   endif
+#  else
+    printf ("vax-dec-bsd\n"); exit (0);
+#  endif
+# else
+    printf ("vax-dec-ultrix\n"); exit (0);
+# endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
+	{ echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+    case `getsysinfo -f cpu_type` in
+    c1*)
+	echo c1-convex-bsd
+	exit ;;
+    c2*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit ;;
+    c34*)
+	echo c34-convex-bsd
+	exit ;;
+    c38*)
+	echo c38-convex-bsd
+	exit ;;
+    c4*)
+	echo c4-convex-bsd
+	exit ;;
+    esac
+fi
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
+and
+  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/client/src/thirdparty/sqlite-3.4.2/config.log b/client/src/thirdparty/sqlite-3.4.2/config.log
new file mode 100644
index 0000000..92a07e9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/config.log
@@ -0,0 +1,1565 @@
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by configure, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  $ configure --disable-tcl --disable-threadsafe
+
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = SCHREIBTISCH_GP
+uname -m = pc
+uname -r = 5
+uname -s = MS-DOS
+uname -v = 50
+
+/usr/bin/uname -p = unknown
+/bin/uname -X     = unknown
+
+/bin/arch              = unknown
+/usr/bin/arch -k       = unknown
+/usr/convex/getsysinfo = unknown
+hostinfo               = unknown
+/bin/machine           = unknown
+/usr/bin/oslevel       = unknown
+/bin/universe          = unknown
+
+PATH: /dev/e/usr/local/bin
+PATH: /dev/e/usr/local
+PATH: /dev/e/djgpp/bin
+PATH: /dev/e/djgpp/mwin/src/lib
+PATH: /dev/c/progra~1/pcconn~1/
+PATH: /dev/c/windows/system32
+PATH: /dev/c/windows
+PATH: /dev/c/windows/system32/wbem
+PATH: /dev/d/devkitpro/msys/bin
+PATH: /dev/c/progra~1/doxygen/bin
+PATH: /dev/c/progra~1/miktex~1.9/miktex/bin/
+PATH: /dev/c/progra~1/tortoi~1/bin
+PATH: /dev/e/watcom2/binw
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+configure:1407: loading site script e:/djgpp/share/config.site
+| #! /bin/sh
+| # Version 1.3 by Mark E. Updated April 9, 2001.
+| # Modify or replace this file only if you know what your doing.
+| 
+| # Sanity check
+| 
+| if test "x${DJDIR}" = "x"; then
+|   echo "Your DJGPP installation is not setup correctly. DJDIR is not set."
+|   exit 1
+| fi
+| 
+| # The root of the DJGPP tree serves as the default prefix.
+| # Allow for cases where a top-level Cygnus/Red Hat-style configure script
+| # calls Autoconf configure scripts in subdirectories.
+| if test "x$ac_default_prefix" = "x/usr/local"; then
+| ac_default_prefix="/dev/env/DJDIR"
+| fi
+| 
+| # This is required for config.status script to be run, since
+| # ./configure runs it by invoking ${CONFIG_SHELL-/bin/sh}
+| 
+| export CONFIG_SHELL='/dev/env/DJDIR/bin/sh.exe'
+| export SHELL=${CONFIG_SHELL}
+| 
+| # $INSTALL must be an absolute path name, otherwise config.status
+| # will try to prepend ./ and ../ to it when it goes into subdirs.
+| 
+| export INSTALL=${INSTALL='/dev/env/DJDIR/bin/ginstall -c'}
+| 
+| # Help out libtool
+| ac_exeext=".exe"
+| export lt_cv_sys_max_cmd_len=12288
+| 
+| # Variables to help DJGPP tools be detected.
+| if test -n "${PACKAGE_VERSION}" ; then
+| ac_executable_extensions=".exe"
+| export PATH_SEPARATOR=';'
+| else
+| # Settings for Autoconf 2.50 and above.
+| export PATH_SEPARATOR=:
+| fi
+| 
+| export TEST_FINDS_EXE=Y
+| 
+| # Force the test for 'ln -s' to report no.
+| export LN_S="cp -p"
+| ac_cv_prog_LN_S="cp -p"
+| 
+configure:1418: loading cache /dev/null
+configure:1616: checking build system type
+configure:1634: result: i386-pc-msdosdjgpp
+configure:1642: checking host system type
+configure:1656: result: i386-pc-msdosdjgpp
+configure:1710: checking for gcc
+configure:1726: found /dev/e/djgpp/bin/gcc
+configure:1736: result: gcc
+configure:1980: checking for C compiler version
+configure:1983: gcc --version </dev/null >&5
+gcc.exe (GCC) 4.5.3
+Copyright (C) 2010 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+configure:1986: $? = 0
+configure:1988: gcc -v </dev/null >&5
+Using built-in specs.
+COLLECT_GCC=e:/djgpp/bin/gcc.exe
+COLLECT_LTO_WRAPPER=e:/djgpp/bin/../libexec/gcc/djgpp/4.53/lto-wrapper.exe
+Target: djgpp
+Configured with: /v204/gcc-4.53/configure djgpp --prefix=/dev/env/DJDIR --disable-nls --disable-werror --enable-languages=c,c++,fortran,objc,obj-c++,ada
+Thread model: single
+gcc version 4.5.3 (GCC) 
+configure:1991: $? = 0
+configure:1993: gcc -V </dev/null >&5
+gcc.exe: '-V' option must have argument
+configure:1996: $? = 1
+configure:2019: checking for C compiler default output file name
+configure:2022: gcc    conftest.c  >&5
+configure:2025: $? = 0
+configure:2071: result: a.exe
+configure:2076: checking whether the C compiler works
+configure:2082: ./a.exe
+configure:2085: $? = 0
+configure:2102: result: yes
+configure:2109: checking whether we are cross compiling
+configure:2111: result: no
+configure:2114: checking for suffix of executables
+configure:2116: gcc -o conftest.exe    conftest.c  >&5
+configure:2119: $? = 0
+configure:2144: result: .exe
+configure:2150: checking for suffix of object files
+configure:2171: gcc -c   conftest.c >&5
+configure:2174: $? = 0
+configure:2196: result: o
+configure:2200: checking whether we are using the GNU C compiler
+configure:2224: gcc -c   conftest.c >&5
+configure:2230: $? = 0
+configure:2234: test -z 
+			 || test ! -s conftest.err
+configure:2237: $? = 0
+configure:2240: test -s conftest.o
+configure:2243: $? = 0
+configure:2256: result: yes
+configure:2262: checking whether gcc accepts -g
+configure:2283: gcc -c -g  conftest.c >&5
+configure:2289: $? = 0
+configure:2293: test -z 
+			 || test ! -s conftest.err
+configure:2296: $? = 0
+configure:2299: test -s conftest.o
+configure:2302: $? = 0
+configure:2313: result: yes
+configure:2330: checking for gcc option to accept ANSI C
+configure:2400: gcc  -c -g -O2  conftest.c >&5
+configure:2406: $? = 0
+configure:2410: test -z 
+			 || test ! -s conftest.err
+configure:2413: $? = 0
+configure:2416: test -s conftest.o
+configure:2419: $? = 0
+configure:2437: result: none needed
+configure:2455: gcc -c -g -O2  conftest.c >&5
+conftest.c:2:9: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'me'
+configure:2461: $? = 1
+configure: failed program was:
+| #ifndef __cplusplus
+|   choke me
+| #endif
+configure:2594: checking for a sed that does not truncate output
+configure:2648: result: /dev/e/djgpp/bin/sed
+configure:2651: checking for egrep
+configure:2661: result: grep -E
+configure:2677: checking for ld used by gcc
+configure:2744: result: e:/djgpp/bin/ld.exe
+configure:2753: checking if the linker (e:/djgpp/bin/ld.exe) is GNU ld
+configure:2768: result: yes
+configure:2773: checking for e:/djgpp/bin/ld.exe option to reload object files
+configure:2780: result: -r
+configure:2798: checking for BSD-compatible nm
+configure:2847: result: /dev/e/djgpp/bin/nm -B
+configure:2851: checking whether ln -s works
+configure:2858: result: no, using ln
+configure:2862: checking how to recognise dependent libraries
+configure:3038: result: unknown
+configure:3275: checking how to run the C preprocessor
+configure:3310: gcc -E  conftest.c
+configure:3316: $? = 0
+configure:3348: gcc -E  conftest.c
+conftest.c:9:28: fatal error: ac_nonexistent.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:3354: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| /* end confdefs.h.  */
+| #include <ac_nonexistent.h>
+configure:3393: result: gcc -E
+configure:3417: gcc -E  conftest.c
+configure:3423: $? = 0
+configure:3455: gcc -E  conftest.c
+conftest.c:9:28: fatal error: ac_nonexistent.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:3461: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| /* end confdefs.h.  */
+| #include <ac_nonexistent.h>
+configure:3505: checking for ANSI C header files
+configure:3530: gcc -c -g -O2  conftest.c >&5
+configure:3536: $? = 0
+configure:3540: test -z 
+			 || test ! -s conftest.err
+configure:3543: $? = 0
+configure:3546: test -s conftest.o
+configure:3549: $? = 0
+configure:3635: gcc -o conftest.exe -g -O2   conftest.c  >&5
+conftest.c: In function 'main':
+conftest.c:26:7: warning: incompatible implicit declaration of built-in function 'exit'
+configure:3638: $? = 0
+configure:3640: ./conftest.exe
+configure:3643: $? = 0
+configure:3658: result: yes
+configure:3682: checking for sys/types.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for sys/stat.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for stdlib.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for string.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for memory.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for strings.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for inttypes.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for stdint.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3682: checking for unistd.h
+configure:3698: gcc -c -g -O2  conftest.c >&5
+configure:3704: $? = 0
+configure:3708: test -z 
+			 || test ! -s conftest.err
+configure:3711: $? = 0
+configure:3714: test -s conftest.o
+configure:3717: $? = 0
+configure:3728: result: yes
+configure:3754: checking dlfcn.h usability
+configure:3766: gcc -c -g -O2  conftest.c >&5
+configure:3772: $? = 0
+configure:3776: test -z 
+			 || test ! -s conftest.err
+configure:3779: $? = 0
+configure:3782: test -s conftest.o
+configure:3785: $? = 0
+configure:3795: result: yes
+configure:3799: checking dlfcn.h presence
+configure:3809: gcc -E  conftest.c
+configure:3815: $? = 0
+configure:3835: result: yes
+configure:3870: checking for dlfcn.h
+configure:3877: result: yes
+configure:3942: checking for g++
+configure:3971: result: no
+configure:3942: checking for c++
+configure:3971: result: no
+configure:3942: checking for gpp
+configure:3958: found /dev/e/djgpp/bin/gpp
+configure:3968: result: gpp
+configure:3984: checking for C++ compiler version
+configure:3987: gpp --version </dev/null >&5
+gpp.exe (GCC) 4.5.3
+Copyright (C) 2010 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+configure:3990: $? = 0
+configure:3992: gpp -v </dev/null >&5
+Using built-in specs.
+COLLECT_GCC=e:/djgpp/bin/gpp.exe
+COLLECT_LTO_WRAPPER=e:/djgpp/bin/../libexec/gcc/djgpp/4.53/lto-wrapper.exe
+Target: djgpp
+Configured with: /v204/gcc-4.53/configure djgpp --prefix=/dev/env/DJDIR --disable-nls --disable-werror --enable-languages=c,c++,fortran,objc,obj-c++,ada
+Thread model: single
+gcc version 4.5.3 (GCC) 
+configure:3995: $? = 0
+configure:3997: gpp -V </dev/null >&5
+gpp.exe: '-V' option must have argument
+configure:4000: $? = 1
+configure:4003: checking whether we are using the GNU C++ compiler
+configure:4027: gpp -c   conftest.cc >&5
+configure:4033: $? = 0
+configure:4037: test -z 
+			 || test ! -s conftest.err
+configure:4040: $? = 0
+configure:4043: test -s conftest.o
+configure:4046: $? = 0
+configure:4059: result: yes
+configure:4065: checking whether gpp accepts -g
+configure:4086: gpp -c -g  conftest.cc >&5
+configure:4092: $? = 0
+configure:4096: test -z 
+			 || test ! -s conftest.err
+configure:4099: $? = 0
+configure:4102: test -s conftest.o
+configure:4105: $? = 0
+configure:4116: result: yes
+configure:4158: gpp -c -g -O2  conftest.cc >&5
+configure:4164: $? = 0
+configure:4168: test -z 
+			 || test ! -s conftest.err
+configure:4171: $? = 0
+configure:4174: test -s conftest.o
+configure:4177: $? = 0
+configure:4203: gpp -c -g -O2  conftest.cc >&5
+conftest.cc: In function 'int main()':
+conftest.cc:24:9: error: 'exit' was not declared in this scope
+configure:4209: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| /* end confdefs.h.  */
+| 
+| int
+| main ()
+| {
+| exit (42);
+|   ;
+|   return 0;
+| }
+configure:4158: gpp -c -g -O2  conftest.cc >&5
+conftest.cc:20:40: error: 'void std::exit(int)' should have been declared inside 'std'
+In file included from conftest.cc:21:0:
+e:/djgpp/include/stdlib.h:62:48: error: declaration of 'void std::exit(int)' throws different exceptions
+conftest.cc:20:17: error: from previous declaration 'void std::exit(int) throw ()'
+configure:4164: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| /* end confdefs.h.  */
+| extern "C" void std::exit (int) throw (); using std::exit;
+| #include <stdlib.h>
+| int
+| main ()
+| {
+| exit (42);
+|   ;
+|   return 0;
+| }
+configure:4158: gpp -c -g -O2  conftest.cc >&5
+conftest.cc:20:31: error: 'void std::exit(int)' should have been declared inside 'std'
+configure:4164: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| /* end confdefs.h.  */
+| extern "C" void std::exit (int); using std::exit;
+| #include <stdlib.h>
+| int
+| main ()
+| {
+| exit (42);
+|   ;
+|   return 0;
+| }
+configure:4158: gpp -c -g -O2  conftest.cc >&5
+In file included from conftest.cc:21:0:
+e:/djgpp/include/stdlib.h:62:48: error: declaration of 'void exit(int)' throws different exceptions
+conftest.cc:20:17: error: from previous declaration 'void exit(int) throw ()'
+configure:4164: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| /* end confdefs.h.  */
+| extern "C" void exit (int) throw ();
+| #include <stdlib.h>
+| int
+| main ()
+| {
+| exit (42);
+|   ;
+|   return 0;
+| }
+configure:4158: gpp -c -g -O2  conftest.cc >&5
+configure:4164: $? = 0
+configure:4168: test -z 
+			 || test ! -s conftest.err
+configure:4171: $? = 0
+configure:4174: test -s conftest.o
+configure:4177: $? = 0
+configure:4203: gpp -c -g -O2  conftest.cc >&5
+configure:4209: $? = 0
+configure:4213: test -z 
+			 || test ! -s conftest.err
+configure:4216: $? = 0
+configure:4219: test -s conftest.o
+configure:4222: $? = 0
+configure:4255: checking how to run the C++ preprocessor
+configure:4286: gpp -E  conftest.cc
+configure:4292: $? = 0
+configure:4324: gpp -E  conftest.cc
+conftest.cc:23:28: fatal error: ac_nonexistent.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:4330: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| #include <ac_nonexistent.h>
+configure:4369: result: gpp -E
+configure:4393: gpp -E  conftest.cc
+configure:4399: $? = 0
+configure:4431: gpp -E  conftest.cc
+conftest.cc:23:28: fatal error: ac_nonexistent.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:4437: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| #include <ac_nonexistent.h>
+configure:4534: checking for g77
+configure:4563: result: no
+configure:4534: checking for f77
+configure:4563: result: no
+configure:4534: checking for xlf
+configure:4563: result: no
+configure:4534: checking for frt
+configure:4563: result: no
+configure:4534: checking for pgf77
+configure:4563: result: no
+configure:4534: checking for fort77
+configure:4563: result: no
+configure:4534: checking for fl32
+configure:4563: result: no
+configure:4534: checking for af77
+configure:4563: result: no
+configure:4534: checking for f90
+configure:4563: result: no
+configure:4534: checking for xlf90
+configure:4563: result: no
+configure:4534: checking for pgf90
+configure:4563: result: no
+configure:4534: checking for epcf90
+configure:4563: result: no
+configure:4534: checking for f95
+configure:4563: result: no
+configure:4534: checking for fort
+configure:4563: result: no
+configure:4534: checking for xlf95
+configure:4563: result: no
+configure:4534: checking for ifc
+configure:4563: result: no
+configure:4534: checking for efc
+configure:4563: result: no
+configure:4534: checking for pgf95
+configure:4563: result: no
+configure:4534: checking for lf95
+configure:4563: result: no
+configure:4534: checking for gfortran
+configure:4563: result: no
+configure:4578: checking for Fortran 77 compiler version
+configure:4578:  --version </dev/null >&5
+configure: --version: command not found
+configure:4581: $? = 127
+configure:4583:  -v </dev/null >&5
+configure: -v: command not found
+configure:4586: $? = 127
+configure:4588:  -V </dev/null >&5
+configure: -V: command not found
+configure:4591: $? = 127
+configure:4599: checking whether we are using the GNU Fortran 77 compiler
+configure:4613:  -c  conftest.F >&5
+configure: -c: command not found
+configure:4619: $? = 127
+configure: failed program was:
+|       program main
+| #ifndef __GNUC__
+|        choke me
+| #endif
+| 
+|       end
+configure:4645: result: no
+configure:4651: checking whether  accepts -g
+configure:4663:  -c -g conftest.f >&5
+configure: -c: command not found
+configure:4669: $? = 127
+configure: failed program was:
+|       program main
+| 
+|       end
+configure:4694: result: no
+configure:4724: checking the maximum length of command line arguments
+configure:4833: result: 12288
+configure:4844: checking command to parse /dev/e/djgpp/bin/nm -B output from gcc object
+configure:4949: gcc -c -g -O2  conftest.c >&5
+configure:4952: $? = 0
+configure:4956: /dev/e/djgpp/bin/nm -B conftest.o \| sed -n -e 's/^.*[ 	]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ 	][ 	]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' \> conftest.nm
+configure:4959: $? = 0
+cannot find nm_test_var in conftest.nm
+configure:4949: gcc -c -g -O2  conftest.c >&5
+configure:4952: $? = 0
+configure:4956: /dev/e/djgpp/bin/nm -B conftest.o \| sed -n -e 's/^.*[ 	]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ 	][ 	]*_\([_A-Za-z][_A-Za-z0-9]*\)$/\1 _\2 \2/p' \> conftest.nm
+configure:4959: $? = 0
+configure:5011: gcc -o conftest.exe -g -O2   conftest.c conftstm.o >&5
+configure:5014: $? = 0
+configure:5052: result: ok
+configure:5056: checking for objdir
+configure:5071: result: .libs
+configure:5161: checking for ar
+configure:5177: found /dev/e/djgpp/bin/ar
+configure:5188: result: ar
+configure:5241: checking for ranlib
+configure:5257: found /dev/e/djgpp/bin/ranlib
+configure:5268: result: ranlib
+configure:5321: checking for strip
+configure:5337: found /dev/e/djgpp/bin/strip
+configure:5348: result: strip
+configure:5571: checking for correct ltmain.sh version
+configure:5621: result: yes
+configure:5681: checking if gcc supports -fno-rtti -fno-exceptions
+configure:5702: gcc -c -g -O2  -fno-rtti -fno-exceptions conftest.c >&5
+cc1.exe: warning: command line option "-fno-rtti" is valid for C++/ObjC++ but not for C
+configure:5706: $? = 0
+configure:5716: result: no
+configure:5731: checking for gcc option to produce PIC
+configure:5941: result: 
+configure:6012: checking if gcc static flag -static works
+configure:6040: result: yes
+configure:6050: checking if gcc supports -c -o file.o
+configure:6074: gcc -c -g -O2  -o out/conftest2.o conftest.c >&5
+configure:6078: $? = 0
+configure:6097: result: yes
+configure:6123: checking whether the gcc linker (e:/djgpp/bin/ld.exe) supports shared libraries
+configure:7081: result: no
+configure:7148: checking dynamic linker characteristics
+configure:7773: result: no
+configure:7782: checking how to hardcode library paths into programs
+configure:7807: result: unsupported
+configure:7821: checking whether stripping libraries is possible
+configure:7826: result: yes
+configure:8660: checking if libtool supports shared libraries
+configure:8662: result: no
+configure:8665: checking whether to build shared libraries
+configure:8686: result: no
+configure:8689: checking whether to build static libraries
+configure:8693: result: yes
+configure:8785: creating libtool
+configure:9373: checking for ld used by gpp
+configure:9440: result: e:/djgpp/bin/ld.exe
+configure:9449: checking if the linker (e:/djgpp/bin/ld.exe) is GNU ld
+configure:9464: result: yes
+configure:9515: checking whether the gpp linker (e:/djgpp/bin/ld.exe) supports shared libraries
+configure:10453: result: no
+configure:10471: gpp -c -g -O2  conftest.cpp >&5
+configure:10474: $? = 0
+configure:10593: checking for gpp option to produce PIC
+configure:10867: result: 
+configure:10938: checking if gpp static flag -static works
+configure:10966: result: yes
+configure:10976: checking if gpp supports -c -o file.o
+configure:11000: gpp -c -g -O2  -o out/conftest2.o conftest.cpp >&5
+configure:11004: $? = 0
+configure:11023: result: yes
+configure:11049: checking whether the gpp linker (e:/djgpp/bin/ld.exe) supports shared libraries
+configure:11074: result: no
+configure:11141: checking dynamic linker characteristics
+configure:11766: result: no
+configure:11775: checking how to hardcode library paths into programs
+configure:11800: result: immediate
+configure:18037: checking for a BSD-compatible install
+configure:18092: result: /dev/env/DJDIR/bin/ginstall -c
+configure:18107: checking for gawk
+configure:18123: found /dev/e/djgpp/bin/gawk
+configure:18133: result: gawk
+configure:18270: checking whether to support threadsafe operation
+configure:18274: result: no
+configure:18378: checking whether to allow connections to be shared across threads
+configure:18382: result: no
+configure:18404: checking whether threads can override each others locks
+configure:18408: result: no
+configure:18427: checking whether to support shared library linked as release mode or not
+configure:18431: result: no
+configure:18450: checking whether to use an in-ram database for temporary tables
+configure:18460: result: no
+configure:18487: checking if executables have the .exe suffix
+configure:18494: result: unknown
+configure:18742: checking for library containing tgetent
+configure:18772: gcc -o conftest.exe -g -O2   conftest.c  >&5
+e:\djgpp\tmp/cc4Vnn5f.o: In function `main':
+e:/myprogs/sqlite-3.5.6/conftest.c:34: undefined reference to `_tgetent'
+collect2: ld returned 1 exit status
+configure:18778: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char tgetent ();
+| int
+| main ()
+| {
+| tgetent ();
+|   ;
+|   return 0;
+| }
+configure:18827: gcc -o conftest.exe -g -O2   conftest.c -lreadline   >&5
+e:/djgpp/bin/ld.exe: cannot find -lreadline
+collect2: ld returned 1 exit status
+configure:18833: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char tgetent ();
+| int
+| main ()
+| {
+| tgetent ();
+|   ;
+|   return 0;
+| }
+configure:18827: gcc -o conftest.exe -g -O2   conftest.c -lncurses   >&5
+e:/djgpp/bin/ld.exe: cannot find -lncurses
+collect2: ld returned 1 exit status
+configure:18833: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char tgetent ();
+| int
+| main ()
+| {
+| tgetent ();
+|   ;
+|   return 0;
+| }
+configure:18827: gcc -o conftest.exe -g -O2   conftest.c -lcurses   >&5
+e:/djgpp/bin/ld.exe: cannot find -lcurses
+collect2: ld returned 1 exit status
+configure:18833: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char tgetent ();
+| int
+| main ()
+| {
+| tgetent ();
+|   ;
+|   return 0;
+| }
+configure:18827: gcc -o conftest.exe -g -O2   conftest.c -ltermcap   >&5
+e:/djgpp/bin/ld.exe: cannot find -ltermcap
+collect2: ld returned 1 exit status
+configure:18833: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char tgetent ();
+| int
+| main ()
+| {
+| tgetent ();
+|   ;
+|   return 0;
+| }
+configure:18861: result: no
+configure:18870: checking for readline in -lreadline
+configure:18900: gcc -o conftest.exe -g -O2   conftest.c -lreadline   >&5
+e:/djgpp/bin/ld.exe: cannot find -lreadline
+collect2: ld returned 1 exit status
+configure:18906: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char readline ();
+| int
+| main ()
+| {
+| readline ();
+|   ;
+|   return 0;
+| }
+configure:18932: result: no
+configure:18965: checking readline.h usability
+configure:18977: gcc -c -g -O2  conftest.c >&5
+conftest.c:57:22: fatal error: readline.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:18983: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| #include <stdio.h>
+| #if HAVE_SYS_TYPES_H
+| # include <sys/types.h>
+| #endif
+| #if HAVE_SYS_STAT_H
+| # include <sys/stat.h>
+| #endif
+| #if STDC_HEADERS
+| # include <stdlib.h>
+| # include <stddef.h>
+| #else
+| # if HAVE_STDLIB_H
+| #  include <stdlib.h>
+| # endif
+| #endif
+| #if HAVE_STRING_H
+| # if !STDC_HEADERS && HAVE_MEMORY_H
+| #  include <memory.h>
+| # endif
+| # include <string.h>
+| #endif
+| #if HAVE_STRINGS_H
+| # include <strings.h>
+| #endif
+| #if HAVE_INTTYPES_H
+| # include <inttypes.h>
+| #else
+| # if HAVE_STDINT_H
+| #  include <stdint.h>
+| # endif
+| #endif
+| #if HAVE_UNISTD_H
+| # include <unistd.h>
+| #endif
+| #include <readline.h>
+configure:19006: result: no
+configure:19010: checking readline.h presence
+configure:19020: gcc -E  conftest.c
+conftest.c:23:22: fatal error: readline.h: No such file or directory (ENOENT)
+compilation terminated.
+configure:19026: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| #include <readline.h>
+configure:19046: result: no
+configure:19081: checking for readline.h
+configure:19088: result: no
+configure:19101: checking for /usr/include/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/include/readline/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/local/include/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/local/include/readline/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/local/readline/include/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/local/readline/include/readline/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/contrib/include/readline.h
+configure:19116: result: no
+configure:19101: checking for /usr/contrib/include/readline/readline.h
+configure:19116: result: no
+configure:19101: checking for /mingw/include/readline.h
+configure:19116: result: no
+configure:19101: checking for /mingw/include/readline/readline.h
+configure:19116: result: no
+configure:19155: checking for library containing fdatasync
+configure:19185: gcc -o conftest.exe -g -O2   conftest.c  >&5
+e:\djgpp\tmp/ccyMkDkD.o: In function `main':
+e:/myprogs/sqlite-3.5.6/conftest.c:34: undefined reference to `_fdatasync'
+collect2: ld returned 1 exit status
+configure:19191: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char fdatasync ();
+| int
+| main ()
+| {
+| fdatasync ();
+|   ;
+|   return 0;
+| }
+configure:19240: gcc -o conftest.exe -g -O2   conftest.c -lrt   >&5
+e:/djgpp/bin/ld.exe: cannot find -lrt
+collect2: ld returned 1 exit status
+configure:19246: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char fdatasync ();
+| int
+| main ()
+| {
+| fdatasync ();
+|   ;
+|   return 0;
+| }
+configure:19274: result: no
+configure:19301: checking for usleep
+configure:19358: gcc -o conftest.exe -g -O2   conftest.c  >&5
+configure:19364: $? = 0
+configure:19368: test -z 
+			 || test ! -s conftest.err
+configure:19371: $? = 0
+configure:19374: test -s conftest.exe
+configure:19377: $? = 0
+configure:19389: result: yes
+configure:19400: checking for fdatasync
+configure:19457: gcc -o conftest.exe -g -O2   conftest.c  >&5
+e:\djgpp\tmp/cc7M3rBg.o: In function `main':
+e:/myprogs/sqlite-3.5.6/conftest.c:63: undefined reference to `_fdatasync'
+e:\djgpp\tmp/cc7M3rBg.o:conftest.c:(.data+0x0): undefined reference to `_fdatasync'
+collect2: ld returned 1 exit status
+configure:19463: $? = 1
+configure: failed program was:
+| /* confdefs.h.  */
+| 
+| #define PACKAGE_NAME ""
+| #define PACKAGE_TARNAME ""
+| #define PACKAGE_VERSION ""
+| #define PACKAGE_STRING ""
+| #define PACKAGE_BUGREPORT ""
+| #define STDC_HEADERS 1
+| #define HAVE_SYS_TYPES_H 1
+| #define HAVE_SYS_STAT_H 1
+| #define HAVE_STDLIB_H 1
+| #define HAVE_STRING_H 1
+| #define HAVE_MEMORY_H 1
+| #define HAVE_STRINGS_H 1
+| #define HAVE_INTTYPES_H 1
+| #define HAVE_STDINT_H 1
+| #define HAVE_UNISTD_H 1
+| #define HAVE_DLFCN_H 1
+| #ifdef __cplusplus
+| extern "C" void exit (int);
+| #endif
+| /* end confdefs.h.  */
+| /* Define fdatasync to an innocuous variant, in case <limits.h> declares fdatasync.
+|    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+| #define fdatasync innocuous_fdatasync
+| 
+| /* System header to define __stub macros and hopefully few prototypes,
+|     which can conflict with char fdatasync (); below.
+|     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+|     <limits.h> exists even on freestanding compilers.  */
+| 
+| #ifdef __STDC__
+| # include <limits.h>
+| #else
+| # include <assert.h>
+| #endif
+| 
+| #undef fdatasync
+| 
+| /* Override any gcc2 internal prototype to avoid an error.  */
+| #ifdef __cplusplus
+| extern "C"
+| {
+| #endif
+| /* We use char because int might match the return type of a gcc2
+|    builtin and then its argument prototype would still apply.  */
+| char fdatasync ();
+| /* The GNU C library defines this for functions which it implements
+|     to always fail with ENOSYS.  Some functions are actually named
+|     something starting with __ and the normal name is an alias.  */
+| #if defined (__stub_fdatasync) || defined (__stub___fdatasync)
+| choke me
+| #else
+| char (*f) () = fdatasync;
+| #endif
+| #ifdef __cplusplus
+| }
+| #endif
+| 
+| int
+| main ()
+| {
+| return f != fdatasync;
+|   ;
+|   return 0;
+| }
+configure:19488: result: no
+configure:19625: creating ./config.status
+
+## ---------------------- ##
+## Running config.status. ##
+## ---------------------- ##
+
+This file was extended by config.status, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  CONFIG_FILES    = 
+  CONFIG_HEADERS  = 
+  CONFIG_LINKS    = 
+  CONFIG_COMMANDS = 
+  $ ./config.status 
+
+on SCHREIBTISCH_GP
+
+config.status:700: creating Makefile
+config.status:700: creating sqlite3.pc
+
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+
+ac_cv_build=i386-pc-msdosdjgpp
+ac_cv_build_alias=i386-pc-msdosdjgpp
+ac_cv_c_compiler_gnu=yes
+ac_cv_cxx_compiler_gnu=yes
+ac_cv_env_CC_set=
+ac_cv_env_CC_value=
+ac_cv_env_CFLAGS_set=
+ac_cv_env_CFLAGS_value=
+ac_cv_env_CPPFLAGS_set=
+ac_cv_env_CPPFLAGS_value=
+ac_cv_env_CPP_set=
+ac_cv_env_CPP_value=
+ac_cv_env_CXXCPP_set=
+ac_cv_env_CXXCPP_value=
+ac_cv_env_CXXFLAGS_set=
+ac_cv_env_CXXFLAGS_value=
+ac_cv_env_CXX_set=
+ac_cv_env_CXX_value=
+ac_cv_env_F77_set=
+ac_cv_env_F77_value=
+ac_cv_env_FFLAGS_set=
+ac_cv_env_FFLAGS_value=
+ac_cv_env_LDFLAGS_set=
+ac_cv_env_LDFLAGS_value=
+ac_cv_env_build_alias_set=
+ac_cv_env_build_alias_value=
+ac_cv_env_host_alias_set=
+ac_cv_env_host_alias_value=
+ac_cv_env_target_alias_set=
+ac_cv_env_target_alias_value=
+ac_cv_exeext=.exe
+ac_cv_f77_compiler_gnu=no
+ac_cv_file__mingw_include_readline_h=no
+ac_cv_file__mingw_include_readline_readline_h=no
+ac_cv_file__usr_contrib_include_readline_h=no
+ac_cv_file__usr_contrib_include_readline_readline_h=no
+ac_cv_file__usr_include_readline_h=no
+ac_cv_file__usr_include_readline_readline_h=no
+ac_cv_file__usr_local_include_readline_h=no
+ac_cv_file__usr_local_include_readline_readline_h=no
+ac_cv_file__usr_local_readline_include_readline_h=no
+ac_cv_file__usr_local_readline_include_readline_readline_h=no
+ac_cv_func_fdatasync=no
+ac_cv_func_usleep=yes
+ac_cv_header_dlfcn_h=yes
+ac_cv_header_inttypes_h=yes
+ac_cv_header_memory_h=yes
+ac_cv_header_readline_h=no
+ac_cv_header_stdc=yes
+ac_cv_header_stdint_h=yes
+ac_cv_header_stdlib_h=yes
+ac_cv_header_string_h=yes
+ac_cv_header_strings_h=yes
+ac_cv_header_sys_stat_h=yes
+ac_cv_header_sys_types_h=yes
+ac_cv_header_unistd_h=yes
+ac_cv_host=i386-pc-msdosdjgpp
+ac_cv_host_alias=i386-pc-msdosdjgpp
+ac_cv_lib_readline_readline=no
+ac_cv_objext=o
+ac_cv_prog_AWK=gawk
+ac_cv_prog_CPP='gcc -E'
+ac_cv_prog_CXXCPP='gpp -E'
+ac_cv_prog_LN_S='cp -p'
+ac_cv_prog_ac_ct_AR=ar
+ac_cv_prog_ac_ct_CC=gcc
+ac_cv_prog_ac_ct_CXX=gpp
+ac_cv_prog_ac_ct_RANLIB=ranlib
+ac_cv_prog_ac_ct_STRIP=strip
+ac_cv_prog_cc_g=yes
+ac_cv_prog_cc_stdc=
+ac_cv_prog_cxx_g=yes
+ac_cv_prog_egrep='grep -E'
+ac_cv_prog_f77_g=no
+ac_cv_search_fdatasync=no
+ac_cv_search_tgetent=no
+lt_cv_deplibs_check_method=unknown
+lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_ld_reload_flag=-r
+lt_cv_objdir=.libs
+lt_cv_path_LD=e:/djgpp/bin/ld.exe
+lt_cv_path_LDCXX=e:/djgpp/bin/ld.exe
+lt_cv_path_NM='/dev/e/djgpp/bin/nm -B'
+lt_cv_path_SED=/dev/e/djgpp/bin/sed
+lt_cv_prog_compiler_c_o=yes
+lt_cv_prog_compiler_c_o_CXX=yes
+lt_cv_prog_compiler_rtti_exceptions=no
+lt_cv_prog_gnu_ld=yes
+lt_cv_prog_gnu_ldcxx=yes
+lt_cv_sys_global_symbol_pipe='sed -n -e '\''s/^.*[ 	]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ 	][ 	]*_\([_A-Za-z][_A-Za-z0-9]*\)$/\1 _\2 \2/p'\'''
+lt_cv_sys_global_symbol_to_c_name_address='sed -n -e '\''s/^: \([^ ]*\) $/  {\"\1\", (lt_ptr) 0},/p'\'' -e '\''s/^[BCDEGRST] \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr) \&\2},/p'\'''
+lt_cv_sys_global_symbol_to_cdecl='sed -n -e '\''s/^. .* \(.*\)$/extern int \1;/p'\'''
+lt_cv_sys_max_cmd_len=12288
+lt_lt_cv_prog_compiler_c_o='"yes"'
+lt_lt_cv_prog_compiler_c_o_CXX='"yes"'
+lt_lt_cv_sys_global_symbol_pipe='"sed -n -e '\''s/^.*[ 	]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ 	][ 	]*_\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 _\\2 \\2/p'\''"'
+lt_lt_cv_sys_global_symbol_to_c_name_address='"sed -n -e '\''s/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (lt_ptr) 0},/p'\'' -e '\''s/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (lt_ptr) \\&\\2},/p'\''"'
+lt_lt_cv_sys_global_symbol_to_cdecl='"sed -n -e '\''s/^. .* \\(.*\\)\$/extern int \\1;/p'\''"'
+
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+
+ALLOWRELEASE=''
+AR='ar'
+AWK='gawk'
+BUILD_CC='gcc'
+BUILD_CFLAGS='-g -O2'
+BUILD_EXEEXT='.exe'
+CC='gcc'
+CFLAGS='-g -O2'
+CPP='gcc -E'
+CPPFLAGS=''
+CXX='gpp'
+CXXCPP='gpp -E'
+CXXFLAGS='-g -O2'
+DEFS='-DPACKAGE_NAME=\"\" -DPACKAGE_TARNAME=\"\" -DPACKAGE_VERSION=\"\" -DPACKAGE_STRING=\"\" -DPACKAGE_BUGREPORT=\"\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_DLFCN_H=1 '
+ECHO='echo'
+ECHO_C=''
+ECHO_N='-n'
+ECHO_T=''
+EGREP='grep -E'
+EXEEXT='.exe'
+F77=''
+FFLAGS=''
+HAVE_TCL=''
+INSTALL_DATA='${INSTALL} -m 644'
+INSTALL_PROGRAM='${INSTALL}'
+INSTALL_SCRIPT='${INSTALL}'
+LDFLAGS=''
+LIBOBJS=''
+LIBS=''
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+LN_S='ln'
+LTLIBOBJS=''
+OBJEXT='o'
+OS_OS2='0'
+OS_UNIX='0'
+OS_WIN='1'
+PACKAGE_BUGREPORT=''
+PACKAGE_NAME=''
+PACKAGE_STRING=''
+PACKAGE_TARNAME=''
+PACKAGE_VERSION=''
+PATH_SEPARATOR=':'
+RANLIB='ranlib'
+RELEASE='3.5.6'
+SHELL='/dev/env/DJDIR/bin/sh.exe'
+SQLITE_THREADSAFE='0'
+STRIP='strip'
+TARGET_DEBUG='-DNDEBUG'
+TARGET_EXEEXT='.exe'
+TARGET_HAVE_READLINE='0'
+TARGET_READLINE_INC=''
+TARGET_READLINE_LIBS=''
+TARGET_THREAD_LIB=''
+TCL_BIN_DIR=''
+TCL_INCLUDE_SPEC=''
+TCL_LIBS=''
+TCL_LIB_FILE=''
+TCL_LIB_FLAG=''
+TCL_LIB_SPEC=''
+TCL_SRC_DIR=''
+TCL_STUB_LIB_FILE=''
+TCL_STUB_LIB_FLAG=''
+TCL_STUB_LIB_SPEC=''
+TCL_VERSION=''
+TEMP_STORE='1'
+THREADSOVERRIDELOCKS='-1'
+VERSION='3.5'
+VERSION_NUMBER='3005006'
+XTHREADCONNECT=''
+ac_ct_AR='ar'
+ac_ct_CC='gcc'
+ac_ct_CXX='gpp'
+ac_ct_F77=''
+ac_ct_RANLIB='ranlib'
+ac_ct_STRIP='strip'
+bindir='${exec_prefix}/bin'
+build='i386-pc-msdosdjgpp'
+build_alias=''
+build_cpu='i386'
+build_os='msdosdjgpp'
+build_vendor='pc'
+datadir='${prefix}/share'
+exec_prefix='${prefix}'
+host='SCHREIBTISCH_GP'
+host_alias=''
+host_cpu='i386'
+host_os='msdosdjgpp'
+host_vendor='pc'
+includedir='${prefix}/include'
+infodir='${prefix}/info'
+libdir='${exec_prefix}/lib'
+libexecdir='${exec_prefix}/libexec'
+localstatedir='${prefix}/var'
+mandir='${prefix}/man'
+oldincludedir='/usr/include'
+prefix='/dev/env/DJDIR'
+program_prefix=''
+program_transform_name='s,x,x,'
+sbindir='${exec_prefix}/sbin'
+sharedstatedir='${prefix}/com'
+sysconfdir='${prefix}/etc'
+target_alias=''
+
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+
+#define HAVE_DLFCN_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_STRING_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_UNISTD_H 1
+#define PACKAGE_BUGREPORT ""
+#define PACKAGE_NAME ""
+#define PACKAGE_STRING ""
+#define PACKAGE_TARNAME ""
+#define PACKAGE_VERSION ""
+#define STDC_HEADERS 1
+#endif
+#ifdef __cplusplus
+extern "C" void exit (int);
+
+configure: exit 0
diff --git a/client/src/thirdparty/sqlite-3.4.2/config.status b/client/src/thirdparty/sqlite-3.4.2/config.status
new file mode 100644
index 0000000..38e924d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/config.status
@@ -0,0 +1,774 @@
+#! /dev/env/DJDIR/bin/sh.exe
+# Generated by configure.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+SHELL=${CONFIG_SHELL-/dev/env/DJDIR/bin/sh.exe}
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+  set -o posix
+fi
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  # We could just check for DJGPP; but this test a) works b) is more generic
+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+  if test -f conf$$.exe; then
+    # Don't use ln at all; we don't have any links
+    as_ln_s='cp -p'
+  else
+    as_ln_s='ln -s'
+  fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" 	$as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+exec 6>&1
+
+# Open the log real soon, to keep \$[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.  Logging --version etc. is OK.
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+} >&5
+cat >&5 <<_CSEOF
+
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+_CSEOF
+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+echo >&5
+config_files=" Makefile sqlite3.pc"
+
+ac_cs_usage="\
+\`$as_me' instantiates files from templates according to the
+current configuration.
+
+Usage: $0 [OPTIONS] [FILE]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number, then exit
+  -q, --quiet      do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+  --file=FILE[:TEMPLATE]
+		   instantiate the configuration file FILE
+
+Configuration files:
+$config_files
+
+Report bugs to <bug-autoconf@gnu.org>."
+ac_cs_version="\
+config.status
+configured by configure, generated by GNU Autoconf 2.59,
+  with options \"'--disable-tcl' '--disable-threadsafe'\"
+
+Copyright (C) 2003 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+srcdir=.
+INSTALL="/dev/env/DJDIR/bin/ginstall -c"
+# If no file are specified by the user, then we need to provide default
+# value.  By we need to know if files were specified by the user.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=*)
+    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  -*)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  *) # This is not an option, so the user has probably given explicit
+     # arguments.
+     ac_option=$1
+     ac_need_defaults=false;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --vers* | -V )
+    echo "$ac_cs_version"; exit 0 ;;
+  --he | --h)
+    # Conflict between --help and --header
+    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; };;
+  --help | --hel | -h )
+    echo "$ac_cs_usage"; exit 0 ;;
+  --debug | --d* | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+    ac_need_defaults=false;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; } ;;
+
+  *) ac_config_targets="$ac_config_targets $1" ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+if $ac_cs_recheck; then
+  echo "running /dev/env/DJDIR/bin/sh.exe configure " '--disable-tcl' '--disable-threadsafe' $ac_configure_extra_args " --no-create --no-recursion" >&6
+  exec /dev/env/DJDIR/bin/sh.exe configure '--disable-tcl' '--disable-threadsafe' $ac_configure_extra_args --no-create --no-recursion
+fi
+
+for ac_config_target in $ac_config_targets
+do
+  case "$ac_config_target" in
+  # Handling of arguments.
+  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+  "sqlite3.pc" ) CONFIG_FILES="$CONFIG_FILES sqlite3.pc" ;;
+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason to put it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Create a temporary directory, and hook for its removal unless debugging.
+$debug ||
+{
+  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
+  trap '{ (exit 1); exit 1; }' 1 2 13 15
+}
+
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
+  test -n "$tmp" && test -d "$tmp"
+}  ||
+{
+  tmp=./confstat$$-$RANDOM
+  (umask 077 && mkdir $tmp)
+} ||
+{
+   echo "$me: cannot create a temporary directory in ." >&2
+   { (exit 1); exit 1; }
+}
+
+
+#
+# CONFIG_FILES section.
+#
+
+# No need to generate the scripts if there are no CONFIG_FILES.
+# This happens for instance when ./config.status config.h
+if test -n "$CONFIG_FILES"; then
+  # Protect against being on the right side of a sed subst in config.status.
+  sed 's/,@/@@/; s/@,/@@/; s/,;t t$/@;t t/; /@;t t$/s/[\\&,]/\\&/g;
+   s/@@/,@/; s/@@/@,/; s/@;t t$/,;t t/' >$tmp/subs.sed <<\CEOF
+s,@SHELL@,/dev/env/DJDIR/bin/sh.exe,;t t
+s,@PATH_SEPARATOR@,:,;t t
+s,@PACKAGE_NAME@,,;t t
+s,@PACKAGE_TARNAME@,,;t t
+s,@PACKAGE_VERSION@,,;t t
+s,@PACKAGE_STRING@,,;t t
+s,@PACKAGE_BUGREPORT@,,;t t
+s,@exec_prefix@,${prefix},;t t
+s,@prefix@,/dev/env/DJDIR,;t t
+s,@program_transform_name@,s,x,x,,;t t
+s,@bindir@,${exec_prefix}/bin,;t t
+s,@sbindir@,${exec_prefix}/sbin,;t t
+s,@libexecdir@,${exec_prefix}/libexec,;t t
+s,@datadir@,${prefix}/share,;t t
+s,@sysconfdir@,${prefix}/etc,;t t
+s,@sharedstatedir@,${prefix}/com,;t t
+s,@localstatedir@,${prefix}/var,;t t
+s,@libdir@,${exec_prefix}/lib,;t t
+s,@includedir@,${prefix}/include,;t t
+s,@oldincludedir@,/usr/include,;t t
+s,@infodir@,${prefix}/info,;t t
+s,@mandir@,${prefix}/man,;t t
+s,@build_alias@,,;t t
+s,@host_alias@,,;t t
+s,@target_alias@,,;t t
+s,@DEFS@,-DPACKAGE_NAME=\"\" -DPACKAGE_TARNAME=\"\" -DPACKAGE_VERSION=\"\" -DPACKAGE_STRING=\"\" -DPACKAGE_BUGREPORT=\"\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_DLFCN_H=1 ,;t t
+s,@ECHO_C@,,;t t
+s,@ECHO_N@,-n,;t t
+s,@ECHO_T@,,;t t
+s,@LIBS@,,;t t
+s,@build@,i386-pc-msdosdjgpp,;t t
+s,@build_cpu@,i386,;t t
+s,@build_vendor@,pc,;t t
+s,@build_os@,msdosdjgpp,;t t
+s,@host@,SCHREIBTISCH_GP,;t t
+s,@host_cpu@,i386,;t t
+s,@host_vendor@,pc,;t t
+s,@host_os@,msdosdjgpp,;t t
+s,@CC@,gcc,;t t
+s,@CFLAGS@,-g -O2,;t t
+s,@LDFLAGS@,,;t t
+s,@CPPFLAGS@,,;t t
+s,@ac_ct_CC@,gcc,;t t
+s,@EXEEXT@,.exe,;t t
+s,@OBJEXT@,o,;t t
+s,@EGREP@,grep -E,;t t
+s,@LN_S@,ln,;t t
+s,@ECHO@,echo,;t t
+s,@AR@,ar,;t t
+s,@ac_ct_AR@,ar,;t t
+s,@RANLIB@,ranlib,;t t
+s,@ac_ct_RANLIB@,ranlib,;t t
+s,@STRIP@,strip,;t t
+s,@ac_ct_STRIP@,strip,;t t
+s,@CPP@,gcc -E,;t t
+s,@CXX@,gpp,;t t
+s,@CXXFLAGS@,-g -O2,;t t
+s,@ac_ct_CXX@,gpp,;t t
+s,@CXXCPP@,gpp -E,;t t
+s,@F77@,,;t t
+s,@FFLAGS@,,;t t
+s,@ac_ct_F77@,,;t t
+s,@LIBTOOL@,$(SHELL) $(top_builddir)/libtool,;t t
+s,@INSTALL_PROGRAM@,${INSTALL},;t t
+s,@INSTALL_SCRIPT@,${INSTALL},;t t
+s,@INSTALL_DATA@,${INSTALL} -m 644,;t t
+s,@AWK@,gawk,;t t
+s,@program_prefix@,,;t t
+s,@VERSION@,3.5,;t t
+s,@RELEASE@,3.5.6,;t t
+s,@VERSION_NUMBER@,3005006,;t t
+s,@BUILD_CC@,gcc,;t t
+s,@BUILD_CFLAGS@,-g -O2,;t t
+s,@SQLITE_THREADSAFE@,0,;t t
+s,@TARGET_THREAD_LIB@,,;t t
+s,@XTHREADCONNECT@,,;t t
+s,@THREADSOVERRIDELOCKS@,-1,;t t
+s,@ALLOWRELEASE@,,;t t
+s,@TEMP_STORE@,1,;t t
+s,@BUILD_EXEEXT@,.exe,;t t
+s,@OS_UNIX@,0,;t t
+s,@OS_WIN@,1,;t t
+s,@OS_OS2@,0,;t t
+s,@TARGET_EXEEXT@,.exe,;t t
+s,@TCL_VERSION@,,;t t
+s,@TCL_BIN_DIR@,,;t t
+s,@TCL_SRC_DIR@,,;t t
+s,@TCL_LIBS@,,;t t
+s,@TCL_INCLUDE_SPEC@,,;t t
+s,@TCL_LIB_FILE@,,;t t
+s,@TCL_LIB_FLAG@,,;t t
+s,@TCL_LIB_SPEC@,,;t t
+s,@TCL_STUB_LIB_FILE@,,;t t
+s,@TCL_STUB_LIB_FLAG@,,;t t
+s,@TCL_STUB_LIB_SPEC@,,;t t
+s,@HAVE_TCL@,,;t t
+s,@TARGET_READLINE_LIBS@,,;t t
+s,@TARGET_READLINE_INC@,,;t t
+s,@TARGET_HAVE_READLINE@,0,;t t
+s,@TARGET_DEBUG@,-DNDEBUG,;t t
+s,@LIBOBJS@,,;t t
+s,@LTLIBOBJS@,,;t t
+CEOF
+
+  # Split the substitutions into bite-sized pieces for seds with
+  # small command number limits, like on Digital OSF/1 and HP-UX.
+  ac_max_sed_lines=48
+  ac_sed_frag=1 # Number of current file.
+  ac_beg=1 # First line for current file.
+  ac_end=$ac_max_sed_lines # Line after last line for current file.
+  ac_more_lines=:
+  ac_sed_cmds=
+  while $ac_more_lines; do
+    if test $ac_beg -gt 1; then
+      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    else
+      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    fi
+    if test ! -s $tmp/subs.frag; then
+      ac_more_lines=false
+    else
+      # The purpose of the label and of the branching condition is to
+      # speed up the sed processing (if there are no `@' at all, there
+      # is no need to browse any of the substitutions).
+      # These are the two extra sed commands mentioned above.
+      (echo ':t
+  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+      if test -z "$ac_sed_cmds"; then
+	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+      else
+	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+      fi
+      ac_sed_frag=`expr $ac_sed_frag + 1`
+      ac_beg=$ac_end
+      ac_end=`expr $ac_end + $ac_max_sed_lines`
+    fi
+  done
+  if test -z "$ac_sed_cmds"; then
+    ac_sed_cmds=cat
+  fi
+fi # test -n "$CONFIG_FILES"
+
+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case $ac_file in
+  - | *:- | *:-:* ) # input from stdin
+	cat >$tmp/stdin
+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  * )   ac_file_in=$ac_file.in ;;
+  esac
+
+  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  { if $as_mkdir_p; then
+    mkdir -p "$ac_dir"
+  else
+    as_dir="$ac_dir"
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+  ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
+  esac
+
+  if test x"$ac_file" != x-; then
+    { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+    rm -f "$ac_file"
+  fi
+  # Let's still pretend it is `configure' which instantiates (i.e., don't
+  # use $as_me), people would be surprised to read:
+  #    /* config.h.  Generated by config.status.  */
+  if test x"$ac_file" = x-; then
+    configure_input=
+  else
+    configure_input="$ac_file.  "
+  fi
+  configure_input=$configure_input"Generated from `echo $ac_file_in |
+				     sed 's,.*/,,'` by configure."
+
+  # First look for the input files in the build tree, otherwise in the
+  # src tree.
+  ac_file_inputs=`IFS=:
+    for f in $ac_file_in; do
+      case $f in
+      -) echo $tmp/stdin ;;
+      [\\/$]*)
+	 # Absolute (can't be DOS-style, as IFS=:)
+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 echo "$f";;
+      *) # Relative
+	 if test -f "$f"; then
+	   # Build tree
+	   echo "$f"
+	 elif test -f "$srcdir/$f"; then
+	   # Source tree
+	   echo "$srcdir/$f"
+	 else
+	   # /dev/null tree
+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 fi;;
+      esac
+    done` || { (exit 1); exit 1; }
+  sed "/^[	 ]*VPATH[	 ]*=/{
+s/:*\$(srcdir):*/:/;
+s/:*\${srcdir}:*/:/;
+s/:*@srcdir@:*/:/;
+s/^\([^=]*=[	 ]*\):*/\1/;
+s/:*$//;
+s/^[^=]*=[	 ]*$//;
+}
+
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s,@configure_input@,$configure_input,;t t
+s,@srcdir@,$ac_srcdir,;t t
+s,@abs_srcdir@,$ac_abs_srcdir,;t t
+s,@top_srcdir@,$ac_top_srcdir,;t t
+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+s,@builddir@,$ac_builddir,;t t
+s,@abs_builddir@,$ac_abs_builddir,;t t
+s,@top_builddir@,$ac_top_builddir,;t t
+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+s,@INSTALL@,$ac_INSTALL,;t t
+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+  rm -f $tmp/stdin
+  if test x"$ac_file" != x-; then
+    mv $tmp/out $ac_file
+  else
+    cat $tmp/out
+    rm -f $tmp/out
+  fi
+
+done
+
+{ (exit 0); exit 0; }
diff --git a/client/src/thirdparty/sqlite-3.4.2/config.sub b/client/src/thirdparty/sqlite-3.4.2/config.sub
new file mode 100644
index 0000000..2a4932e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/config.sub
@@ -0,0 +1,1640 @@
+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+#   Inc.
+
+timestamp='2007-01-18'
+
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit ;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \
+  uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple | -axis | -knuth | -cray)
+		os=
+		basic_machine=$1
+		;;
+	-sim | -cisco | -oki | -wec | -winbond)
+		os=
+		basic_machine=$1
+		;;
+	-scout)
+		;;
+	-wrs)
+		os=-vxworks
+		basic_machine=$1
+		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+ 	-chorusrdb)
+ 		os=-chorusrdb
+		basic_machine=$1
+ 		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco6)
+		os=-sco5v6
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5)
+		os=-sco3.2v5
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5v6*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-udk*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-windowsnt*)
+		os=`echo $os | sed -e 's/windowsnt/winnt/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+	-mint | -mint[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	1750a | 580 \
+	| a29k \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+	| am33_2.0 \
+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
+	| bfin \
+	| c4x | clipper \
+	| d10v | d30v | dlx | dsp16xx | dvp \
+	| fido | fr30 | frv \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| i370 | i860 | i960 | ia64 \
+	| ip2k | iq2000 \
+	| m32c | m32r | m32rle | m68000 | m68k | m88k \
+	| maxq | mb | microblaze | mcore | mep \
+	| mips | mipsbe | mipseb | mipsel | mipsle \
+	| mips16 \
+	| mips64 | mips64el \
+	| mips64vr | mips64vrel \
+	| mips64orion | mips64orionel \
+	| mips64vr4100 | mips64vr4100el \
+	| mips64vr4300 | mips64vr4300el \
+	| mips64vr5000 | mips64vr5000el \
+	| mips64vr5900 | mips64vr5900el \
+	| mipsisa32 | mipsisa32el \
+	| mipsisa32r2 | mipsisa32r2el \
+	| mipsisa64 | mipsisa64el \
+	| mipsisa64r2 | mipsisa64r2el \
+	| mipsisa64sb1 | mipsisa64sb1el \
+	| mipsisa64sr71k | mipsisa64sr71kel \
+	| mipstx39 | mipstx39el \
+	| mn10200 | mn10300 \
+	| mt \
+	| msp430 \
+	| nios | nios2 \
+	| ns16k | ns32k \
+	| or32 \
+	| pdp10 | pdp11 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+	| pyramid \
+	| score \
+	| sh | sh[1234] | sh[24]a | sh[24]a*eb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+	| sh64 | sh64le \
+	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+	| spu | strongarm \
+	| tahoe | thumb | tic4x | tic80 | tron \
+	| v850 | v850e \
+	| we32k \
+	| x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \
+	| z8k)
+		basic_machine=$basic_machine-unknown
+		;;
+	m6811 | m68hc11 | m6812 | m68hc12)
+		# Motorola 68HC11/12.
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+		;;
+	ms1)
+		basic_machine=mt-unknown
+		;;
+
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i*86 | x86_64)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	580-* \
+	| a29k-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+	| avr-* | avr32-* \
+	| bfin-* | bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+	| clipper-* | craynv-* | cydra-* \
+	| d10v-* | d30v-* | dlx-* \
+	| elxsi-* \
+	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| i*86-* | i860-* | i960-* | ia64-* \
+	| ip2k-* | iq2000-* \
+	| m32c-* | m32r-* | m32rle-* \
+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | maxq-* | mcore-* \
+	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+	| mips16-* \
+	| mips64-* | mips64el-* \
+	| mips64vr-* | mips64vrel-* \
+	| mips64orion-* | mips64orionel-* \
+	| mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* \
+	| mips64vr5000-* | mips64vr5000el-* \
+	| mips64vr5900-* | mips64vr5900el-* \
+	| mipsisa32-* | mipsisa32el-* \
+	| mipsisa32r2-* | mipsisa32r2el-* \
+	| mipsisa64-* | mipsisa64el-* \
+	| mipsisa64r2-* | mipsisa64r2el-* \
+	| mipsisa64sb1-* | mipsisa64sb1el-* \
+	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
+	| mipstx39-* | mipstx39el-* \
+	| mmix-* \
+	| mt-* \
+	| msp430-* \
+	| nios-* | nios2-* \
+	| none-* | np1-* | ns16k-* | ns32k-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+	| pyramid-* \
+	| romp-* | rs6000-* \
+	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]a*eb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+	| sparclite-* \
+	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
+	| tahoe-* | thumb-* \
+	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+	| tron-* \
+	| v850-* | v850e-* | vax-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \
+	| xstormy16-* | xtensa-* \
+	| ymp-* \
+	| z8k-*)
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	386bsd)
+		basic_machine=i386-unknown
+		os=-bsd
+		;;
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	a29khif)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+    	abacus)
+		basic_machine=abacus-unknown
+		;;
+	adobe68k)
+		basic_machine=m68010-adobe
+		os=-scout
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amd64)
+		basic_machine=x86_64-pc
+		;;
+	amd64-*)
+		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-unknown
+		;;
+	amigaos | amigados)
+		basic_machine=m68k-unknown
+		os=-amigaos
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-unknown
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	apollo68bsd)
+		basic_machine=m68k-apollo
+		os=-bsd
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	c90)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | j90)
+		basic_machine=j90-cray
+		os=-unicos
+		;;
+	craynv)
+		basic_machine=craynv-cray
+		os=-unicosmp
+		;;
+	cr16c)
+		basic_machine=cr16c-unknown
+		os=-elf
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	crisv32 | crisv32-* | etraxfs*)
+		basic_machine=crisv32-axis
+		;;
+	cris | cris-* | etrax*)
+		basic_machine=cris-axis
+		;;
+	crx)
+		basic_machine=crx-unknown
+		os=-elf
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	decsystem10* | dec10*)
+		basic_machine=pdp10-dec
+		os=-tops10
+		;;
+	decsystem20* | dec20*)
+		basic_machine=pdp10-dec
+		os=-tops20
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	djgpp)
+		basic_machine=i586-pc
+		os=-msdosdjgpp
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2* | dpx2*-bull)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	es1800 | OSE68k | ose68k | ose | OSE)
+		basic_machine=m68k-ericsson
+		os=-ose
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	go32)
+		basic_machine=i386-pc
+		os=-go32
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	h8300xray)
+		basic_machine=h8300-hitachi
+		os=-xray
+		;;
+	h8500hms)
+		basic_machine=h8500-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp3k9[0-9][0-9] | hp9[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k6[0-9][0-9] | hp6[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k7[0-79][0-9] | hp7[0-79][0-9])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k78[0-9] | hp78[0-9])
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][13679] | hp8[0-9][13679])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppa-next)
+		os=-nextstep3
+		;;
+	hppaosf)
+		basic_machine=hppa1.1-hp
+		os=-osf
+		;;
+	hppro)
+		basic_machine=hppa1.1-hp
+		os=-proelf
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+	i*86v32)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i*86v4*)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i*86v)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i*86sol2)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	i386mach)
+		basic_machine=i386-mach
+		os=-mach
+		;;
+	i386-vsta | vsta)
+		basic_machine=i386-unknown
+		os=-vsta
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	m88k-omron*)
+		basic_machine=m88k-omron
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	mingw32)
+		basic_machine=i386-pc
+		os=-mingw32
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+	mipsEE* | ee | ps2)
+		basic_machine=mips64r5900el-scei
+		case $os in
+		    -linux*)
+			;;
+		    *)
+			os=-elf
+			;;
+		esac
+		;;
+	iop)
+		basic_machine=mipsel-scei
+		os=-irx
+		;;
+	dvp)
+		basic_machine=dvp-scei
+		os=-elf
+		;;
+	mips3*-*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	monitor)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	morphos)
+		basic_machine=powerpc-unknown
+		os=-morphos
+		;;
+	msdos)
+		basic_machine=i386-pc
+		os=-msdos
+		;;
+	ms1-*)
+		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+		;;
+	mvs)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	netbsd386)
+		basic_machine=i386-unknown
+		os=-netbsd
+		;;
+	netwinder)
+		basic_machine=armv4l-rebel
+		os=-linux
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	necv70)
+		basic_machine=v70-nec
+		os=-sysv
+		;;
+	next | m*-next )
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	mon960)
+		basic_machine=i960-intel
+		os=-mon960
+		;;
+	nonstopux)
+		basic_machine=mips-compaq
+		os=-nonstopux
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	nsr-tandem)
+		basic_machine=nsr-tandem
+		;;
+	op50n-* | op60c-*)
+		basic_machine=hppa1.1-oki
+		os=-proelf
+		;;
+	openrisc | openrisc-*)
+		basic_machine=or32-unknown
+		;;
+	os400)
+		basic_machine=powerpc-ibm
+		os=-os400
+		;;
+	OSE68000 | ose68000)
+		basic_machine=m68000-ericsson
+		os=-ose
+		;;
+	os68k)
+		basic_machine=m68k-none
+		os=-os68k
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+	pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pc98)
+		basic_machine=i386-pc
+		;;
+	pc98-*)
+		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentium | p5 | k5 | k6 | nexgen | viac3)
+		basic_machine=i586-pc
+		;;
+	pentiumpro | p6 | 6x86 | athlon | athlon_*)
+		basic_machine=i686-pc
+		;;
+	pentiumii | pentium2 | pentiumiii | pentium3)
+		basic_machine=i686-pc
+		;;
+	pentium4)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-* | 6x86-* | athlon-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentium4-*)
+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=power-ibm
+		;;
+	ppc)	basic_machine=powerpc-unknown
+		;;
+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle | ppc-le | powerpc-little)
+		basic_machine=powerpcle-unknown
+		;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64)	basic_machine=powerpc64-unknown
+		;;
+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+		basic_machine=powerpc64le-unknown
+		;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	pw32)
+		basic_machine=i586-unknown
+		os=-pw32
+		;;
+	rdos)
+		basic_machine=i386-pc
+		os=-rdos
+		;;
+	rom68k)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	s390 | s390-*)
+		basic_machine=s390-ibm
+		;;
+	s390x | s390x-*)
+		basic_machine=s390x-ibm
+		;;
+	sa29200)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	sb1)
+		basic_machine=mipsisa64sb1-unknown
+		;;
+	sb1el)
+		basic_machine=mipsisa64sb1el-unknown
+		;;
+	sde)
+		basic_machine=mipsisa32-sde
+		os=-elf
+		;;
+	sei)
+		basic_machine=mips-sei
+		os=-seiux
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh)
+		basic_machine=sh-hitachi
+		os=-hms
+		;;
+	sh5el)
+		basic_machine=sh5le-unknown
+		;;
+	sh64)
+		basic_machine=sh64-unknown
+		;;
+	sparclite-wrs | simso-wrs)
+		basic_machine=sparclite-wrs
+		os=-vxworks
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	st2000)
+		basic_machine=m68k-tandem
+		;;
+	stratus)
+		basic_machine=i860-stratus
+		os=-sysv4
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	sv1)
+		basic_machine=sv1-cray
+		os=-unicos
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	t3e)
+		basic_machine=alphaev5-cray
+		os=-unicos
+		;;
+	t90)
+		basic_machine=t90-cray
+		os=-unicos
+		;;
+	tic54x | c54x*)
+		basic_machine=tic54x-unknown
+		os=-coff
+		;;
+	tic55x | c55x*)
+		basic_machine=tic55x-unknown
+		os=-coff
+		;;
+	tic6x | c6x*)
+		basic_machine=tic6x-unknown
+		os=-coff
+		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
+	toad1)
+		basic_machine=pdp10-xkl
+		os=-tops20
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	tpf)
+		basic_machine=s390x-ibm
+		os=-tpf
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	v810 | necv810)
+		basic_machine=v810-nec
+		os=-none
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+	vpp*|vx|vx-*)
+		basic_machine=f301-fujitsu
+		;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	w65*)
+		basic_machine=w65-wdc
+		os=-none
+		;;
+	w89k-*)
+		basic_machine=hppa1.1-winbond
+		os=-proelf
+		;;
+	xbox)
+		basic_machine=i686-pc
+		os=-mingw32
+		;;
+	xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	z8k-*-coff)
+		basic_machine=z8k-unknown
+		os=-sim
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		basic_machine=hppa1.1-winbond
+		;;
+	op50n)
+		basic_machine=hppa1.1-oki
+		;;
+	op60c)
+		basic_machine=hppa1.1-oki
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	mmix)
+		basic_machine=mmix-knuth
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp10)
+		# there are many clones, so DEC is not a safe bet
+		basic_machine=pdp10-unknown
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)
+		basic_machine=sh-unknown
+		;;
+	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+		basic_machine=sparc-sun
+		;;
+	cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	mac | mpw | mac-mpw)
+		basic_machine=m68k-apple
+		;;
+	pmac | pmac-mpw)
+		basic_machine=powerpc-apple
+		;;
+	*-unknown)
+		# Make sure to match an already-canonicalized machine name.
+		;;
+	*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-svr4*)
+		os=-sysv4
+		;;
+	-unixware*)
+		os=-sysv4.2uw
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# First accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST END IN A *, to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+	      | -openbsd* | -solidbsd* \
+	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -chorusos* | -chorusrdb* \
+	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \
+	      | -uxpv* | -beos* | -mpeix* | -udk* \
+	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -irx*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-qnx*)
+		case $basic_machine in
+		    x86-* | i*86-*)
+			;;
+		    *)
+			os=-nto$os
+			;;
+		esac
+		;;
+	-nto-qnx*)
+		;;
+	-nto*)
+		os=`echo $os | sed -e 's|nto|nto-qnx|'`
+		;;
+	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+		;;
+	-mac*)
+		os=`echo $os | sed -e 's|mac|macos|'`
+		;;
+	-linux-dietlibc)
+		os=-linux-dietlibc
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo $os | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo $os | sed -e 's|sunos6|solaris3|'`
+		;;
+	-opened*)
+		os=-openedition
+		;;
+        -os400*)
+		os=-os400
+		;;
+	-wince*)
+		os=-wince
+		;;
+	-osfrose*)
+		os=-osfrose
+		;;
+	-osf*)
+		os=-osf
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-atheos*)
+		os=-atheos
+		;;
+	-syllable*)
+		os=-syllable
+		;;
+	-386bsd)
+		os=-bsd
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-nova*)
+		os=-rtmk-nova
+		;;
+	-ns2 )
+		os=-nextstep2
+		;;
+	-nsk*)
+		os=-nsk
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+        -tpf*)
+		os=-tpf
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-ose*)
+		os=-ose
+		;;
+	-es1800*)
+		os=-ose
+		;;
+	-xenix)
+		os=-xenix
+		;;
+	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+		os=-mint
+		;;
+	-aros*)
+		os=-aros
+		;;
+	-kaos*)
+		os=-kaos
+		;;
+	-zvmoe)
+		os=-zvmoe
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+        score-*)
+		os=-elf
+		;;
+        spu-*)
+		os=-elf
+		;;
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-rebel)
+		os=-linux
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+        c4x-* | tic4x-*)
+        	os=-coff
+		;;
+	# This must come before the *-dec entry.
+	pdp10-*)
+		os=-tops20
+		;;
+	pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		# This also exists in the configure program, but was not the
+		# default.
+		# os=-sunos4
+		;;
+	m68*-cisco)
+		os=-aout
+		;;
+        mep-*)
+		os=-elf
+		;;
+	mips*-cisco)
+		os=-elf
+		;;
+	mips*-*)
+		os=-elf
+		;;
+	or32-*)
+		os=-coff
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	*-be)
+		os=-beos
+		;;
+	*-haiku)
+		os=-haiku
+		;;
+	*-ibm)
+		os=-aix
+		;;
+    	*-knuth)
+		os=-mmixware
+		;;
+	*-wec)
+		os=-proelf
+		;;
+	*-winbond)
+		os=-proelf
+		;;
+	*-oki)
+		os=-proelf
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigaos
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next )
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-next)
+		os=-nextstep3
+		;;
+	*-gould)
+		os=-sysv
+		;;
+	*-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+	*-sgi)
+		os=-irix
+		;;
+	*-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f30[01]-fujitsu | f700-fujitsu)
+		os=-uxpv
+		;;
+	*-rom68k)
+		os=-coff
+		;;
+	*-*bug)
+		os=-coff
+		;;
+	*-apple)
+		os=-macos
+		;;
+	*-atari*)
+		os=-mint
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-aix*)
+				vendor=ibm
+				;;
+			-beos*)
+				vendor=be
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-mpeix*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs* | -opened*)
+				vendor=ibm
+				;;
+			-os400*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-tpf*)
+				vendor=ibm
+				;;
+			-vxsim* | -vxworks* | -windiss*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+			-hms*)
+				vendor=hitachi
+				;;
+			-mpw* | -macos*)
+				vendor=apple
+				;;
+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+				vendor=atari
+				;;
+			-vos*)
+				vendor=stratus
+				;;
+		esac
+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/client/src/thirdparty/sqlite-3.4.2/configure b/client/src/thirdparty/sqlite-3.4.2/configure
new file mode 100644
index 0000000..b7ec403
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/configure
@@ -0,0 +1,20477 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.59.
+#
+# Copyright (C) 2003 Free Software Foundation, Inc.
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+  set -o posix
+fi
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  # We could just check for DJGPP; but this test a) works b) is more generic
+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+  if test -f conf$$.exe; then
+    # Don't use ln at all; we don't have any links
+    as_ln_s='cp -p'
+  else
+    as_ln_s='ln -s'
+  fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" 	$as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+
+
+# Check that we are running under the correct shell.
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+case X$ECHO in
+X*--fallback-echo)
+  # Remove one level of quotation (which was required for Make).
+  ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','`
+  ;;
+esac
+
+echo=${ECHO-echo}
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell.
+  exec $SHELL "$0" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit 0
+fi
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+if test -z "$ECHO"; then
+if test "X${echo_test_string+set}" != Xset; then
+# find a string as large as possible, as long as the shell can cope with it
+  for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+    if (echo_test_string=`eval $cmd`) 2>/dev/null &&
+       echo_test_string=`eval $cmd` &&
+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
+    then
+      break
+    fi
+  done
+fi
+
+if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+   test "X$echo_testing_string" = "X$echo_test_string"; then
+  :
+else
+  # The Solaris, AIX, and Digital Unix default echo programs unquote
+  # backslashes.  This makes it impossible to quote backslashes using
+  #   echo "$something" | sed 's/\\/\\\\/g'
+  #
+  # So, first we look for a working echo in the user's PATH.
+
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for dir in $PATH /usr/ucb; do
+    IFS="$lt_save_ifs"
+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      echo="$dir/echo"
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+
+  if test "X$echo" = Xecho; then
+    # We didn't find a better echo, so look for alternatives.
+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      # This shell has a builtin print -r that does the trick.
+      echo='print -r'
+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
+	 test "X$CONFIG_SHELL" != X/bin/ksh; then
+      # If we have ksh, try running configure again with it.
+      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+      export ORIGINAL_CONFIG_SHELL
+      CONFIG_SHELL=/bin/ksh
+      export CONFIG_SHELL
+      exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}
+    else
+      # Try using printf.
+      echo='printf %s\n'
+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+	 test "X$echo_testing_string" = "X$echo_test_string"; then
+	# Cool, printf works
+	:
+      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
+	export CONFIG_SHELL
+	SHELL="$CONFIG_SHELL"
+	export SHELL
+	echo="$CONFIG_SHELL $0 --fallback-echo"
+      elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	echo="$CONFIG_SHELL $0 --fallback-echo"
+      else
+	# maybe with a smaller string...
+	prev=:
+
+	for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
+	  then
+	    break
+	  fi
+	  prev="$cmd"
+	done
+
+	if test "$prev" != 'sed 50q "$0"'; then
+	  echo_test_string=`eval $prev`
+	  export echo_test_string
+	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}
+	else
+	  # Oops.  We lost completely, so just stick with echo.
+	  echo=echo
+	fi
+      fi
+    fi
+  fi
+fi
+fi
+
+# Copy echo and quote the copy suitably for passing to libtool from
+# the Makefile, instead of quoting the original, which is used later.
+ECHO=$echo
+if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then
+   ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
+fi
+
+
+
+
+tagnames=${tagnames+${tagnames},}CXX
+
+tagnames=${tagnames+${tagnames},}F77
+
+# Name of the host.
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+exec 6>&1
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_config_libobj_dir=.
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+# Maximum number of lines to put in a shell here document.
+# This variable seems obsolete.  It should probably be removed, and
+# only ac_max_sed_lines should be used.
+: ${ac_max_here_lines=38}
+
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+
+ac_unique_file="src/sqlite.h.in"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#if HAVE_STRING_H
+# if !STDC_HEADERS && HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT EGREP LN_S ECHO AR ac_ct_AR RANLIB ac_ct_RANLIB STRIP ac_ct_STRIP CPP CXX CXXFLAGS ac_ct_CXX CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AWK program_prefix VERSION RELEASE VERSION_NUMBER BUILD_CC BUILD_CFLAGS SQLITE_THREADSAFE TARGET_THREAD_LIB XTHREADCONNECT THREADSOVERRIDELOCKS ALLOWRELEASE TEMP_STORE BUILD_EXEEXT OS_UNIX OS_WIN OS_OS2 TARGET_EXEEXT TCL_VERSION TCL_BIN_DIR TCL_SRC_DIR TCL_LIBS TCL_INCLUDE_SPEC TCL_LIB_FILE TCL_LIB_FLAG TCL_LIB_SPEC TCL_STUB_LIB_FILE TCL_STUB_LIB_FLAG TCL_STUB_LIB_SPEC HAVE_TCL TARGET_READLINE_LIBS TARGET_READLINE_INC TARGET_HAVE_READLINE TARGET_DEBUG LIBOBJS LTLIBOBJS'
+ac_subst_files=''
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datadir='${prefix}/share'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+libdir='${exec_prefix}/lib'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+infodir='${prefix}/info'
+mandir='${prefix}/man'
+
+ac_prev=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval "$ac_prev=\$ac_option"
+    ac_prev=
+    continue
+  fi
+
+  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_option in
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+  | --da=*)
+    datadir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+    eval "enable_$ac_feature=no" ;;
+
+  -enable-* | --enable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+    case $ac_option in
+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "enable_$ac_feature='$ac_optarg'" ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst \
+  | --locals | --local | --loca | --loc | --lo)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package| sed 's/-/_/g'`
+    case $ac_option in
+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "with_$ac_package='$ac_optarg'" ;;
+
+  -without-* | --without-*)
+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package | sed 's/-/_/g'`
+    eval "with_$ac_package=no" ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) { echo "$as_me: error: unrecognized option: $ac_option
+Try \`$0 --help' for more information." >&2
+   { (exit 1); exit 1; }; }
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+   { (exit 1); exit 1; }; }
+    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+    eval "$ac_envvar='$ac_optarg'"
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  { echo "$as_me: error: missing argument to $ac_option" >&2
+   { (exit 1); exit 1; }; }
+fi
+
+# Be sure to have absolute paths.
+for ac_var in exec_prefix prefix
+do
+  eval ac_val=$`echo $ac_var`
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# Be sure to have absolute paths.
+for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+	      localstatedir libdir includedir oldincludedir infodir mandir
+do
+  eval ac_val=$`echo $ac_var`
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* ) ;;
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+    If a cross compiler is detected then cross compile mode will be used." >&2
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then its parent.
+  ac_confdir=`(dirname "$0") 2>/dev/null ||
+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$0" : 'X\(//\)[^/]' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$0" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r $srcdir/$ac_unique_file; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r $srcdir/$ac_unique_file; then
+  if test "$ac_srcdir_defaulted" = yes; then
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+   { (exit 1); exit 1; }; }
+  else
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+   { (exit 1); exit 1; }; }
+  fi
+fi
+(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+   { (exit 1); exit 1; }; }
+srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+ac_env_build_alias_set=${build_alias+set}
+ac_env_build_alias_value=$build_alias
+ac_cv_env_build_alias_set=${build_alias+set}
+ac_cv_env_build_alias_value=$build_alias
+ac_env_host_alias_set=${host_alias+set}
+ac_env_host_alias_value=$host_alias
+ac_cv_env_host_alias_set=${host_alias+set}
+ac_cv_env_host_alias_value=$host_alias
+ac_env_target_alias_set=${target_alias+set}
+ac_env_target_alias_value=$target_alias
+ac_cv_env_target_alias_set=${target_alias+set}
+ac_cv_env_target_alias_value=$target_alias
+ac_env_CC_set=${CC+set}
+ac_env_CC_value=$CC
+ac_cv_env_CC_set=${CC+set}
+ac_cv_env_CC_value=$CC
+ac_env_CFLAGS_set=${CFLAGS+set}
+ac_env_CFLAGS_value=$CFLAGS
+ac_cv_env_CFLAGS_set=${CFLAGS+set}
+ac_cv_env_CFLAGS_value=$CFLAGS
+ac_env_LDFLAGS_set=${LDFLAGS+set}
+ac_env_LDFLAGS_value=$LDFLAGS
+ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+ac_cv_env_LDFLAGS_value=$LDFLAGS
+ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_env_CPPFLAGS_value=$CPPFLAGS
+ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+ac_env_CPP_set=${CPP+set}
+ac_env_CPP_value=$CPP
+ac_cv_env_CPP_set=${CPP+set}
+ac_cv_env_CPP_value=$CPP
+ac_env_CXX_set=${CXX+set}
+ac_env_CXX_value=$CXX
+ac_cv_env_CXX_set=${CXX+set}
+ac_cv_env_CXX_value=$CXX
+ac_env_CXXFLAGS_set=${CXXFLAGS+set}
+ac_env_CXXFLAGS_value=$CXXFLAGS
+ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
+ac_cv_env_CXXFLAGS_value=$CXXFLAGS
+ac_env_CXXCPP_set=${CXXCPP+set}
+ac_env_CXXCPP_value=$CXXCPP
+ac_cv_env_CXXCPP_set=${CXXCPP+set}
+ac_cv_env_CXXCPP_value=$CXXCPP
+ac_env_F77_set=${F77+set}
+ac_env_F77_value=$F77
+ac_cv_env_F77_set=${F77+set}
+ac_cv_env_F77_value=$F77
+ac_env_FFLAGS_set=${FFLAGS+set}
+ac_env_FFLAGS_value=$FFLAGS
+ac_cv_env_FFLAGS_set=${FFLAGS+set}
+ac_cv_env_FFLAGS_value=$FFLAGS
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures this package to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+_ACEOF
+
+  cat <<_ACEOF
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+			  [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+			  [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR           user executables [EPREFIX/bin]
+  --sbindir=DIR          system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR       program executables [EPREFIX/libexec]
+  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+  --libdir=DIR           object code libraries [EPREFIX/lib]
+  --includedir=DIR       C header files [PREFIX/include]
+  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+  --infodir=DIR          info documentation [PREFIX/info]
+  --mandir=DIR           man documentation [PREFIX/man]
+_ACEOF
+
+  cat <<\_ACEOF
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-shared[=PKGS]
+                          build shared libraries [default=yes]
+  --enable-static[=PKGS]
+                          build static libraries [default=yes]
+  --enable-fast-install[=PKGS]
+                          optimize for fast installation [default=yes]
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+  --enable-threadsafe     Support threadsafe operation
+  --enable-cross-thread-connections
+                          Allow connection sharing across threads
+  --enable-threads-override-locks
+                          Threads can override each others locks
+  --enable-releasemode    Support libtool link to release mode
+  --enable-tempstore      Use an in-ram database for temporary tables
+                          (never,no,yes,always)
+  --disable-tcl           do not build TCL extension
+  --disable-readline      disable readline support [default=detect]
+  --enable-debug          enable debugging & verbose explain
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
+  --with-pic              try to use only PIC/non-PIC objects [default=use
+                          both]
+  --with-tags[=TAGS]
+                          include additional configurations [automatic]
+  --with-hints=FILE       Read configuration options from FILE
+  --with-tcl=DIR          directory containing tcl configuration
+                          (tclConfig.sh)
+  --with-readline-lib     specify readline library
+  --with-readline-inc     specify readline include paths
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+              headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+  CXX         C++ compiler command
+  CXXFLAGS    C++ compiler flags
+  CXXCPP      C++ preprocessor
+  F77         Fortran 77 compiler command
+  FFLAGS      Fortran 77 compiler flags
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+_ACEOF
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  ac_popdir=`pwd`
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d $ac_dir || continue
+    ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+    cd $ac_dir
+    # Check for guested configure; otherwise get Cygnus style configure.
+    if test -f $ac_srcdir/configure.gnu; then
+      echo
+      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+    elif test -f $ac_srcdir/configure; then
+      echo
+      $SHELL $ac_srcdir/configure  --help=recursive
+    elif test -f $ac_srcdir/configure.ac ||
+	   test -f $ac_srcdir/configure.in; then
+      echo
+      $ac_configure --help
+    else
+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi
+    cd $ac_popdir
+  done
+fi
+
+test -n "$ac_init_help" && exit 0
+if $ac_init_version; then
+  cat <<\_ACEOF
+
+Copyright (C) 2003 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit 0
+fi
+exec 5>config.log
+cat >&5 <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by $as_me, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  echo "PATH: $as_dir"
+done
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_sep=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
+    2)
+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+      # Get rid of the leading space.
+      ac_sep=" "
+      ;;
+    esac
+  done
+done
+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Be sure not to use single quotes in there, as some shells,
+# such as our DU 5.0 friend, will then `close' the trap.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+{
+  (set) 2>&1 |
+    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+    *ac_space=\ *)
+      sed -n \
+	"s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+      ;;
+    *)
+      sed -n \
+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      ;;
+    esac;
+}
+    echo
+
+    cat <<\_ASBOX
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+_ASBOX
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=$`echo $ac_var`
+      echo "$ac_var='"'"'$ac_val'"'"'"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      cat <<\_ASBOX
+## ------------- ##
+## Output files. ##
+## ------------- ##
+_ASBOX
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=$`echo $ac_var`
+	echo "$ac_var='"'"'$ac_val'"'"'"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+      echo
+      sed "/^$/d" confdefs.h | sort
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      echo "$as_me: caught signal $ac_signal"
+    echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core &&
+  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+     ' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -rf conftest* confdefs.h
+# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+echo >confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer explicitly selected file to automatically selected ones.
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+  fi
+fi
+for ac_site_file in $CONFIG_SITE; do
+  if test -r "$ac_site_file"; then
+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special
+  # files actually), so we avoid doing that.
+  if test -f "$cache_file"; then
+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . $cache_file;;
+      *)                      . ./$cache_file;;
+    esac
+  fi
+else
+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
+echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in `(set) 2>&1 |
+	       sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+  eval ac_new_val="\$ac_env_${ac_var}_value"
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
+echo "$as_me:   former value:  $ac_old_val" >&2;}
+	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
+echo "$as_me:   current value: $ac_new_val" >&2;}
+	ac_cache_corrupted=:
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
+echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# The following RCS revision string applies to configure.in
+# $Revision: 1.45 $
+
+#########
+# Programs needed
+#
+# Check whether --enable-shared or --disable-shared was given.
+if test "${enable_shared+set}" = set; then
+  enableval="$enable_shared"
+  p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac
+else
+  enable_shared=yes
+fi;
+
+# Check whether --enable-static or --disable-static was given.
+if test "${enable_static+set}" = set; then
+  enableval="$enable_static"
+  p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac
+else
+  enable_static=yes
+fi;
+
+# Check whether --enable-fast-install or --disable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then
+  enableval="$enable_fast_install"
+  p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac
+else
+  enable_fast_install=yes
+fi;
+
+ac_aux_dir=
+for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+  if test -f $ac_dir/install-sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f $ac_dir/install.sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f $ac_dir/shtool; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
+
+# Make sure we can run config.sub.
+$ac_config_sub sun4 >/dev/null 2>&1 ||
+  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+echo "$as_me: error: cannot run $ac_config_sub" >&2;}
+   { (exit 1); exit 1; }; }
+
+echo "$as_me:$LINENO: checking build system type" >&5
+echo $ECHO_N "checking build system type... $ECHO_C" >&6
+if test "${ac_cv_build+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_build_alias=$build_alias
+test -z "$ac_cv_build_alias" &&
+  ac_cv_build_alias=`$ac_config_guess`
+test -z "$ac_cv_build_alias" &&
+  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+   { (exit 1); exit 1; }; }
+ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+echo "${ECHO_T}$ac_cv_build" >&6
+build=$ac_cv_build
+build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+
+echo "$as_me:$LINENO: checking host system type" >&5
+echo $ECHO_N "checking host system type... $ECHO_C" >&6
+if test "${ac_cv_host+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_host_alias=$host_alias
+test -z "$ac_cv_host_alias" &&
+  ac_cv_host_alias=$ac_cv_build_alias
+ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+echo "${ECHO_T}$ac_cv_host" >&6
+host=$ac_cv_host
+host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  CC=$ac_ct_CC
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  CC=$ac_ct_CC
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$ac_ct_CC" && break
+done
+
+  CC=$ac_ct_CC
+fi
+
+fi
+
+
+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&5
+echo "$as_me: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO:" \
+     "checking for C compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+  (eval $ac_compiler --version </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+  (eval $ac_compiler -v </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+  (eval $ac_compiler -V </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+  (eval $ac_link_default) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # Find the output, starting from the most likely.  This scheme is
+# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+# resort.
+
+# Be careful to initialize this variable, since it used to be cached.
+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+ac_cv_exeext=
+# b.out is created by i960 compilers.
+for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+	;;
+    conftest.$ac_ext )
+	# This is the source file.
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	# FIXME: I believe we export ac_cv_exeext for Libtool,
+	# but it would be cool to find out if it's true.  Does anybody
+	# maintain Libtool? --akim.
+	export ac_cv_exeext
+	break;;
+    * )
+	break;;
+  esac
+done
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
+See \`config.log' for more details." >&5
+echo "$as_me: error: C compiler cannot create executables
+See \`config.log' for more details." >&2;}
+   { (exit 77); exit 77; }; }
+fi
+
+ac_exeext=$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_file" >&5
+echo "${ECHO_T}$ac_file" >&6
+
+# Check the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+# If not cross compiling, check that we can run a simple program.
+if test "$cross_compiling" != yes; then
+  if { ac_try='./$ac_file'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+    fi
+  fi
+fi
+echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+
+rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+# Check the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+echo "$as_me:$LINENO: result: $cross_compiling" >&5
+echo "${ECHO_T}$cross_compiling" >&6
+
+echo "$as_me:$LINENO: checking for suffix of executables" >&5
+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  export ac_cv_exeext
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+echo "${ECHO_T}$ac_cv_exeext" >&6
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+echo "$as_me:$LINENO: checking for suffix of object files" >&5
+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
+if test "${ac_cv_objext+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+echo "${ECHO_T}$ac_cv_objext" >&6
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
+if test "${ac_cv_c_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
+GCC=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+CFLAGS="-g"
+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_cc_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_cc_g=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_stdc+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_prog_cc_stdc=no
+ac_save_CC=$CC
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std1 is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std1.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+# Don't try gcc -ansi; that turns off useful extensions and
+# breaks some systems' header files.
+# AIX			-qlanglvl=ansi
+# Ultrix and OSF/1	-std1
+# HP-UX 10.20 and later	-Ae
+# HP-UX older versions	-Aa -D_HPUX_SOURCE
+# SVR4			-Xc -D__EXTENSIONS__
+for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_cc_stdc=$ac_arg
+break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext
+done
+rm -f conftest.$ac_ext conftest.$ac_objext
+CC=$ac_save_CC
+
+fi
+
+case "x$ac_cv_prog_cc_stdc" in
+  x|xno)
+    echo "$as_me:$LINENO: result: none needed" >&5
+echo "${ECHO_T}none needed" >&6 ;;
+  *)
+    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+    CC="$CC $ac_cv_prog_cc_stdc" ;;
+esac
+
+# Some people use a C++ compiler to compile C.  Since we use `exit',
+# in C++ we need to declare it.  In case someone uses the same compiler
+# for both compiling C and C++ we need to have the C++ compiler decide
+# the declaration of exit, since it's the most demanding environment.
+cat >conftest.$ac_ext <<_ACEOF
+#ifndef __cplusplus
+  choke me
+#endif
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  for ac_declaration in \
+   '' \
+   'extern "C" void std::exit (int) throw (); using std::exit;' \
+   'extern "C" void std::exit (int); using std::exit;' \
+   'extern "C" void exit (int) throw ();' \
+   'extern "C" void exit (int);' \
+   'void exit (int);'
+do
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+#include <stdlib.h>
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+continue
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+done
+rm -f conftest*
+if test -n "$ac_declaration"; then
+  echo '#ifdef __cplusplus' >>confdefs.h
+  echo $ac_declaration      >>confdefs.h
+  echo '#endif'             >>confdefs.h
+fi
+
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5
+echo $ECHO_N "checking for a sed that does not truncate output... $ECHO_C" >&6
+if test "${lt_cv_path_SED+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  # Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for lt_ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+      fi
+    done
+  done
+done
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+  test ! -f $lt_ac_sed && continue
+  cat /dev/null > conftest.in
+  lt_ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+  # Check for GNU sed and select it if it is found.
+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+    lt_cv_path_SED=$lt_ac_sed
+    break
+  fi
+  while true; do
+    cat conftest.in conftest.in >conftest.tmp
+    mv conftest.tmp conftest.in
+    cp conftest.in conftest.nl
+    echo >>conftest.nl
+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+    cmp -s conftest.out conftest.nl || break
+    # 10000 chars as input seems more than enough
+    test $lt_ac_count -gt 10 && break
+    lt_ac_count=`expr $lt_ac_count + 1`
+    if test $lt_ac_count -gt $lt_ac_max; then
+      lt_ac_max=$lt_ac_count
+      lt_cv_path_SED=$lt_ac_sed
+    fi
+  done
+done
+
+fi
+
+SED=$lt_cv_path_SED
+echo "$as_me:$LINENO: result: $SED" >&5
+echo "${ECHO_T}$SED" >&6
+
+echo "$as_me:$LINENO: checking for egrep" >&5
+echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+if test "${ac_cv_prog_egrep+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+    then ac_cv_prog_egrep='grep -E'
+    else ac_cv_prog_egrep='egrep'
+    fi
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+ EGREP=$ac_cv_prog_egrep
+
+
+
+# Check whether --with-gnu-ld or --without-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then
+  withval="$with_gnu_ld"
+  test "$withval" = no || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi;
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  echo "$as_me:$LINENO: checking for ld used by $CC" >&5
+echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  echo "$as_me:$LINENO: checking for GNU ld" >&5
+echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
+else
+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
+fi
+if test "${lt_cv_path_LD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test "$with_gnu_ld" != no && break
+	;;
+      *)
+	test "$with_gnu_ld" != yes && break
+	;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  echo "$as_me:$LINENO: result: $LD" >&5
+echo "${ECHO_T}$LD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+   { (exit 1); exit 1; }; }
+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
+if test "${lt_cv_prog_gnu_ld+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
+if test "${lt_cv_ld_reload_flag+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_ld_reload_flag='-r'
+fi
+echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  darwin*)
+    if test "$GCC" = yes; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+
+echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
+if test "${lt_cv_path_NM+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  lt_nm_to_check="${ac_tool_prefix}nm"
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS="$lt_save_ifs"
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm="$ac_dir/$lt_tmp_nm"
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+	*/dev/null* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS="$lt_save_ifs"
+  done
+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
+fi
+fi
+echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5
+echo "${ECHO_T}$lt_cv_path_NM" >&6
+NM="$lt_cv_path_NM"
+
+echo "$as_me:$LINENO: checking whether ln -s works" >&5
+echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+echo "${ECHO_T}no, using $LN_S" >&6
+fi
+
+echo "$as_me:$LINENO: checking how to recognise dependent libraries" >&5
+echo $ECHO_N "checking how to recognise dependent libraries... $ECHO_C" >&6
+if test "${lt_cv_deplibs_check_method+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix4* | aix5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[45]*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump'.
+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | kfreebsd*-gnu | dragonfly*)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]'
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix3*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd*)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+nto-qnx*)
+  lt_cv_deplibs_check_method=unknown
+  ;;
+
+openbsd*)
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then
+  enableval="$enable_libtool_lock"
+
+fi;
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *ELF-32*)
+      HPUX_IA64_MODE="32"
+      ;;
+    *ELF-64*)
+      HPUX_IA64_MODE="64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '#line 3088 "configure"' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+   if test "$lt_cv_prog_gnu_ld" = yes; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -melf32bsmip"
+      ;;
+    *N32*)
+      LD="${LD-ld} -melf32bmipn32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -melf64bmip"
+      ;;
+    esac
+   else
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -32"
+      ;;
+    *N32*)
+      LD="${LD-ld} -n32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -64"
+      ;;
+    esac
+   fi
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    case `/usr/bin/file conftest.o` in
+    *32-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_i386"
+          ;;
+        ppc64-*linux*|powerpc64-*linux*)
+          LD="${LD-ld} -m elf32ppclinux"
+          ;;
+        s390x-*linux*)
+          LD="${LD-ld} -m elf_s390"
+          ;;
+        sparc64-*linux*)
+          LD="${LD-ld} -m elf32_sparc"
+          ;;
+      esac
+      ;;
+    *64-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        ppc*-*linux*|powerpc*-*linux*)
+          LD="${LD-ld} -m elf64ppc"
+          ;;
+        s390*-*linux*)
+          LD="${LD-ld} -m elf64_s390"
+          ;;
+        sparc*-*linux*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
+if test "${lt_cv_cc_needs_belf+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  lt_cv_cc_needs_belf=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+lt_cv_cc_needs_belf=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+sparc*-*solaris*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*) LD="${LD-ld} -m elf64_sparc" ;;
+      *)    LD="${LD-ld} -64" ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+
+esac
+
+need_locks="$enable_libtool_lock"
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test "${ac_cv_prog_CPP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+echo "$as_me:$LINENO: result: $CPP" >&5
+echo "${ECHO_T}$CPP" >&6
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  :
+else
+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&5
+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+if test "${ac_cv_header_stdc+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_header_stdc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_header_stdc=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then
+  :
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ctype.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      exit(2);
+  exit (0);
+}
+_ACEOF
+rm -f conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+ac_cv_header_stdc=no
+fi
+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+fi
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+echo "${ECHO_T}$ac_cv_header_stdc" >&6
+if test $ac_cv_header_stdc = yes; then
+
+cat >>confdefs.h <<\_ACEOF
+#define STDC_HEADERS 1
+_ACEOF
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+
+
+
+
+
+
+
+
+
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_Header=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_Header=no"
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+
+for ac_header in dlfcn.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ------------------------------------------ ##
+## Report this to the AC_PACKAGE_NAME lists.  ##
+## ------------------------------------------ ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=\$ac_header_preproc"
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CXX"; then
+  ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+  echo "$as_me:$LINENO: result: $CXX" >&5
+echo "${ECHO_T}$CXX" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+    test -n "$CXX" && break
+  done
+fi
+if test -z "$CXX"; then
+  ac_ct_CXX=$CXX
+  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CXX"; then
+  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CXX="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
+echo "${ECHO_T}$ac_ct_CXX" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$ac_ct_CXX" && break
+done
+test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
+
+  CXX=$ac_ct_CXX
+fi
+
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO:" \
+     "checking for C++ compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+  (eval $ac_compiler --version </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+  (eval $ac_compiler -v </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+  (eval $ac_compiler -V </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+
+echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
+if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
+GXX=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CXXFLAGS=${CXXFLAGS+set}
+ac_save_CXXFLAGS=$CXXFLAGS
+CXXFLAGS="-g"
+echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
+echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_cxx_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_cxx_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_cxx_g=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
+if test "$ac_test_CXXFLAGS" = set; then
+  CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+  if test "$GXX" = yes; then
+    CXXFLAGS="-g -O2"
+  else
+    CXXFLAGS="-g"
+  fi
+else
+  if test "$GXX" = yes; then
+    CXXFLAGS="-O2"
+  else
+    CXXFLAGS=
+  fi
+fi
+for ac_declaration in \
+   '' \
+   'extern "C" void std::exit (int) throw (); using std::exit;' \
+   'extern "C" void std::exit (int); using std::exit;' \
+   'extern "C" void exit (int) throw ();' \
+   'extern "C" void exit (int);' \
+   'void exit (int);'
+do
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+#include <stdlib.h>
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+continue
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+done
+rm -f conftest*
+if test -n "$ac_declaration"; then
+  echo '#ifdef __cplusplus' >>confdefs.h
+  echo $ac_declaration      >>confdefs.h
+  echo '#endif'             >>confdefs.h
+fi
+
+ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+
+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+    (test "X$CXX" != "Xg++"))) ; then
+  ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
+echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
+if test -z "$CXXCPP"; then
+  if test "${ac_cv_prog_CXXCPP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+      # Double quotes because CXXCPP needs to be expanded
+    for CXXCPP in "$CXX -E" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_cxx_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_cxx_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  break
+fi
+
+    done
+    ac_cv_prog_CXXCPP=$CXXCPP
+
+fi
+  CXXCPP=$ac_cv_prog_CXXCPP
+else
+  ac_cv_prog_CXXCPP=$CXXCPP
+fi
+echo "$as_me:$LINENO: result: $CXXCPP" >&5
+echo "${ECHO_T}$CXXCPP" >&6
+ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_cxx_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_cxx_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  :
+else
+  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details." >&5
+echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+fi
+
+
+ac_ext=f
+ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
+ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_f77_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  for ac_prog in g77 f77 xlf frt pgf77 fort77 fl32 af77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 ifc efc pgf95 lf95 gfortran
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_F77+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$F77"; then
+  ac_cv_prog_F77="$F77" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+F77=$ac_cv_prog_F77
+if test -n "$F77"; then
+  echo "$as_me:$LINENO: result: $F77" >&5
+echo "${ECHO_T}$F77" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+    test -n "$F77" && break
+  done
+fi
+if test -z "$F77"; then
+  ac_ct_F77=$F77
+  for ac_prog in g77 f77 xlf frt pgf77 fort77 fl32 af77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 ifc efc pgf95 lf95 gfortran
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_F77"; then
+  ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_F77="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_F77=$ac_cv_prog_ac_ct_F77
+if test -n "$ac_ct_F77"; then
+  echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
+echo "${ECHO_T}$ac_ct_F77" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$ac_ct_F77" && break
+done
+
+  F77=$ac_ct_F77
+fi
+
+
+# Provide some information about the compiler.
+echo "$as_me:4578:" \
+     "checking for Fortran 77 compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+  (eval $ac_compiler --version </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+  (eval $ac_compiler -v </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+  (eval $ac_compiler -V </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+rm -f a.out
+
+# If we don't use `.F' as extension, the preprocessor is not run on the
+# input file.  (Note that this only needs to work for GNU compilers.)
+ac_save_ext=$ac_ext
+ac_ext=F
+echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6
+if test "${ac_cv_f77_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+      program main
+#ifndef __GNUC__
+       choke me
+#endif
+
+      end
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_f77_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_f77_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6
+ac_ext=$ac_save_ext
+ac_test_FFLAGS=${FFLAGS+set}
+ac_save_FFLAGS=$FFLAGS
+FFLAGS=
+echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
+echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_f77_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  FFLAGS=-g
+cat >conftest.$ac_ext <<_ACEOF
+      program main
+
+      end
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_f77_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_f77_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_f77_g=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
+echo "${ECHO_T}$ac_cv_prog_f77_g" >&6
+if test "$ac_test_FFLAGS" = set; then
+  FFLAGS=$ac_save_FFLAGS
+elif test $ac_cv_prog_f77_g = yes; then
+  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
+    FFLAGS="-g -O2"
+  else
+    FFLAGS="-g"
+  fi
+else
+  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
+    FFLAGS="-O2"
+  else
+    FFLAGS=
+  fi
+fi
+
+G77=`test $ac_compiler_gnu = yes && echo yes`
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+
+# find the maximum length of command line arguments
+echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
+if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+    i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ 	]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    # If test is not a shell built-in, we'll probably end up computing a
+    # maximum length that is only half of the actual maximum length, but
+    # we can't tell.
+    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+    while (test "X"`$SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \
+	       = "XX$teststring") >/dev/null 2>&1 &&
+	    new_result=`expr "X$teststring" : ".*" 2>&1` &&
+	    lt_cv_sys_max_cmd_len=$new_result &&
+	    test $i != 17 # 1/2 MB should be enough
+    do
+      i=`expr $i + 1`
+      teststring=$teststring$teststring
+    done
+    teststring=
+    # Add a significant safety factor because C++ compilers can tack on massive
+    # amounts of additional arguments before passing them to the linker.
+    # It appears as though 1/2 is a usable value.
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    ;;
+  esac
+
+fi
+
+if test -n $lt_cv_sys_max_cmd_len ; then
+  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
+else
+  echo "$as_me:$LINENO: result: none" >&5
+echo "${ECHO_T}none" >&6
+fi
+
+
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
+echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6
+if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Transform an extracted symbol line into a proper C declaration
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[BCDT]'
+  ;;
+cygwin* | mingw* | pw32*)
+  symcode='[ABCDGISTW]'
+  ;;
+hpux*) # Its linker distinguishes data from code symbols
+  if test "$host_cpu" = ia64; then
+    symcode='[ABCDEGRST]'
+  fi
+  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+  ;;
+linux*)
+  if test "$host_cpu" = ia64; then
+    symcode='[ABCDGIRSTW]'
+    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+    lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[BCDEGRST]'
+  ;;
+osf*)
+  symcode='[BCDEGQRST]'
+  ;;
+solaris*)
+  symcode='[BDRT]'
+  ;;
+sco3.2v5*)
+  symcode='[DT]'
+  ;;
+sysv4.2uw2*)
+  symcode='[DT]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[ABDT]'
+  ;;
+sysv4)
+  symcode='[DFNSTU]'
+  ;;
+esac
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[ABCDGIRSTW]' ;;
+esac
+
+# Try without a prefix undercore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ 	]\($symcode$symcode*\)[ 	][ 	]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+EOF
+
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
+  (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if grep ' nm_test_var$' "$nlist" >/dev/null; then
+	if grep ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<EOF > conftest.$ac_ext
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'
+
+	  cat <<EOF >> conftest.$ac_ext
+#if defined (__STDC__) && __STDC__
+# define lt_ptr_t void *
+#else
+# define lt_ptr_t char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+const struct {
+  const char *name;
+  lt_ptr_t address;
+}
+lt_preloaded_symbols[] =
+{
+EOF
+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext
+	  cat <<\EOF >> conftest.$ac_ext
+  {0, (lt_ptr_t) 0}
+};
+
+#ifdef __cplusplus
+}
+#endif
+EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_save_LIBS="$LIBS"
+	  lt_save_CFLAGS="$CFLAGS"
+	  LIBS="conftstm.$ac_objext"
+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+	  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && test -s conftest${ac_exeext}; then
+	    pipe_works=yes
+	  fi
+	  LIBS="$lt_save_LIBS"
+	  CFLAGS="$lt_save_CFLAGS"
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.$ac_ext >&5
+  fi
+  rm -f conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  echo "$as_me:$LINENO: result: failed" >&5
+echo "${ECHO_T}failed" >&6
+else
+  echo "$as_me:$LINENO: result: ok" >&5
+echo "${ECHO_T}ok" >&6
+fi
+
+echo "$as_me:$LINENO: checking for objdir" >&5
+echo $ECHO_N "checking for objdir... $ECHO_C" >&6
+if test "${lt_cv_objdir+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+echo "$as_me:$LINENO: result: $lt_cv_objdir" >&5
+echo "${ECHO_T}$lt_cv_objdir" >&6
+objdir=$lt_cv_objdir
+
+
+
+
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e 1s/^X//'
+sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+# Constants:
+rm="rm -f"
+
+# Global variables:
+default_ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+ltmain="$ac_aux_dir/ltmain.sh"
+ofile="$default_ofile"
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ar; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_AR+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AR="${ac_tool_prefix}ar"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  echo "$as_me:$LINENO: result: $AR" >&5
+echo "${ECHO_T}$AR" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_AR"; then
+  ac_ct_AR=$AR
+  # Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AR="ar"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="false"
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
+echo "${ECHO_T}$ac_ct_AR" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  AR=$ac_ct_AR
+else
+  AR="$ac_cv_prog_AR"
+fi
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  echo "$as_me:$LINENO: result: $RANLIB" >&5
+echo "${ECHO_T}$RANLIB" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+echo "${ECHO_T}$ac_ct_RANLIB" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  RANLIB=$ac_ct_RANLIB
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  echo "$as_me:$LINENO: result: $STRIP" >&5
+echo "${ECHO_T}$STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+echo "${ECHO_T}$ac_ct_STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  STRIP=$ac_ct_STRIP
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$AR" && AR=ar
+test -z "$AR_FLAGS" && AR_FLAGS=cru
+test -z "$AS" && AS=as
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+test -z "$LD" && LD=ld
+test -z "$LN_S" && LN_S="ln -s"
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+test -z "$NM" && NM=nm
+test -z "$SED" && SED=sed
+test -z "$OBJDUMP" && OBJDUMP=objdump
+test -z "$RANLIB" && RANLIB=:
+test -z "$STRIP" && STRIP=:
+test -z "$ac_objext" && ac_objext=o
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+fi
+
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+
+# Only perform the check for file, if the check method requires it
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/${ac_tool_prefix}file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+echo "${ECHO_T}$MAGIC_CMD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    echo "$as_me:$LINENO: checking for file" >&5
+echo $ECHO_N "checking for file... $ECHO_C" >&6
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+echo "${ECHO_T}$MAGIC_CMD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+enable_dlopen=no
+enable_win32_dll=no
+
+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then
+  enableval="$enable_libtool_lock"
+
+fi;
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+
+# Check whether --with-pic or --without-pic was given.
+if test "${with_pic+set}" = set; then
+  withval="$with_pic"
+  pic_mode="$withval"
+else
+  pic_mode=default
+fi;
+test -z "$pic_mode" && pic_mode=default
+
+# Check if we have a version mismatch between libtool.m4 and ltmain.sh.
+#
+# Note:  This should be in AC_LIBTOOL_SETUP, _after_ $ltmain have been defined.
+#        We also should do it _before_ AC_LIBTOOL_LANG_C_CONFIG that actually
+#        calls AC_LIBTOOL_CONFIG and creates libtool.
+#
+echo "$as_me:$LINENO: checking for correct ltmain.sh version" >&5
+echo $ECHO_N "checking for correct ltmain.sh version... $ECHO_C" >&6
+if test "x$ltmain" = "x" ; then
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+  { { echo "$as_me:$LINENO: error:
+
+*** [Gentoo] sanity check failed! ***
+*** \$ltmain is not defined, please check the patch for consistency! ***
+" >&5
+echo "$as_me: error:
+
+*** [Gentoo] sanity check failed! ***
+*** \$ltmain is not defined, please check the patch for consistency! ***
+" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+gentoo_lt_version="1.5.22"
+gentoo_ltmain_version=`sed -n '/^[ 	]*VERSION=/{s/^[ 	]*VERSION=//;p;q;}' "$ltmain"`
+if test "x$gentoo_lt_version" != "x$gentoo_ltmain_version" ; then
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+  { { echo "$as_me:$LINENO: error:
+
+*** [Gentoo] sanity check failed! ***
+*** libtool.m4 and ltmain.sh have a version mismatch! ***
+*** (libtool.m4 = $gentoo_lt_version, ltmain.sh = $gentoo_ltmain_version) ***
+
+Please run:
+
+  libtoolize --copy --force
+
+if appropriate, please contact the maintainer of this
+package (or your distribution) for help.
+" >&5
+echo "$as_me: error:
+
+*** [Gentoo] sanity check failed! ***
+*** libtool.m4 and ltmain.sh have a version mismatch! ***
+*** (libtool.m4 = $gentoo_lt_version, ltmain.sh = $gentoo_ltmain_version) ***
+
+Please run:
+
+  libtoolize --copy --force
+
+if appropriate, please contact the maintainer of this
+package (or your distribution) for help.
+" >&2;}
+   { (exit 1); exit 1; }; }
+else
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+fi
+
+
+# Use C for the default configuration in the libtool script
+tagname=
+lt_save_CC="$CC"
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}\n'
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+
+
+
+lt_prog_compiler_no_builtin_flag=
+
+if test "$GCC" = yes; then
+  lt_prog_compiler_no_builtin_flag=' -fno-builtin'
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_rtti_exceptions=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:5702: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:5706: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6
+
+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
+
+  if test "$GCC" = yes; then
+    lt_prog_compiler_wl='-Wl,'
+    lt_prog_compiler_static='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+      ;;
+
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      ;;
+
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared=no
+      enable_shared=no
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic=-Kconform_pic
+      fi
+      ;;
+
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='-fPIC'
+	;;
+      esac
+      ;;
+
+    *)
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      else
+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+      darwin*)
+        # PIC is the default on this platform
+        # Common symbols not allowed in MH_DYLIB files
+       case $cc_basename in
+         xlc*)
+         lt_prog_compiler_pic='-qnocommon'
+         lt_prog_compiler_wl='-Wl,'
+         ;;
+       esac
+       ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    linux*)
+      case $cc_basename in
+      icc* | ecc*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-KPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      pgcc* | pgf77* | pgf90* | pgf95*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fpic'
+	lt_prog_compiler_static='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static='-non_shared'
+        ;;
+      esac
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+	lt_prog_compiler_wl='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl='-Qoption ld '
+      lt_prog_compiler_pic='-PIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	lt_prog_compiler_pic='-Kconform_pic'
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_can_build_shared=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic='-pic'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic" >&6
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+
+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6
+if test "${lt_prog_compiler_pic_works+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_pic_works=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:5970: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:5974: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_prog_compiler_pic_works=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_works" >&6
+
+if test x"$lt_prog_compiler_pic_works" = xyes; then
+    case $lt_prog_compiler_pic in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+     esac
+else
+    lt_prog_compiler_pic=
+     lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic=
+    ;;
+  *)
+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+    ;;
+esac
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
+if test "${lt_prog_compiler_static_works+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_static_works=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_prog_compiler_static_works=yes
+       fi
+     else
+       lt_prog_compiler_static_works=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works" >&5
+echo "${ECHO_T}$lt_prog_compiler_static_works" >&6
+
+if test x"$lt_prog_compiler_static_works" = xyes; then
+    :
+else
+    lt_prog_compiler_static=
+fi
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_c_o+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:6074: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:6078: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  echo "$as_me:$LINENO: result: $hard_links" >&5
+echo "${ECHO_T}$hard_links" >&6
+  if test "$hard_links" = no; then
+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
+
+  runpath_var=
+  allow_undefined_flag=
+  enable_shared_with_static_runtimes=no
+  archive_cmds=
+  archive_expsym_cmds=
+  old_archive_From_new_cmds=
+  old_archive_from_expsyms_cmds=
+  export_dynamic_flag_spec=
+  whole_archive_flag_spec=
+  thread_safe_flag_spec=
+  hardcode_libdir_flag_spec=
+  hardcode_libdir_flag_spec_ld=
+  hardcode_libdir_separator=
+  hardcode_direct=no
+  hardcode_minus_L=no
+  hardcode_shlibpath_var=unsupported
+  link_all_deplibs=unknown
+  hardcode_automatic=no
+  module_cmds=
+  module_expsym_cmds=
+  always_export_symbols=no
+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  exclude_expsyms="_GLOBAL_OFFSET_TABLE_"
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  extract_expsyms_cmds=
+  # Just being paranoid about ensuring that cc_basename is set.
+  for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+  case $host_os in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  ld_shlibs=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'
+    export_dynamic_flag_spec='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
+	whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+  	whole_archive_flag_spec=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>/dev/null` in
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	ld_shlibs=no
+	cat <<EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+EOF
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we can't use
+      # them.
+      ld_shlibs=no
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      allow_undefined_flag=unsupported
+      always_export_symbols=no
+      enable_shared_with_static_runtimes=yes
+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    interix3*)
+      hardcode_direct=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    linux*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	tmp_addflag=
+	case $cc_basename,$host_cpu in
+	pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	esac
+	archive_cmds='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+	if test $supports_anon_versioning = yes; then
+	  archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+  $echo "local: *; };" >> $output_objdir/$libname.ver~
+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+	fi
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+	ld_shlibs=no
+	cat <<EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+EOF
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'
+	  else
+	    ld_shlibs=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+    esac
+
+    if test "$ld_shlibs" = no; then
+      runpath_var=
+      hardcode_libdir_flag_spec=
+      export_dynamic_flag_spec=
+      whole_archive_flag_spec=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag=unsupported
+      always_export_symbols=yes
+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct=unsupported
+      fi
+      ;;
+
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+	  for ld_flag in $LDFLAGS; do
+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+  	    aix_use_runtimelinking=yes
+  	    break
+  	  fi
+	  done
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds=''
+      hardcode_direct=yes
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" && \
+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	  then
+  	  # We have reworked collect2
+  	  hardcode_direct=yes
+	  else
+  	  # We have old collect2
+  	  hardcode_direct=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  hardcode_minus_L=yes
+  	  hardcode_libdir_flag_spec='-L$libdir'
+  	  hardcode_libdir_separator=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag="$shared_flag "'${wl}-G'
+	fi
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+	  fi
+	fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='-berok'
+       # Determine the default libpath from the value encoded in an empty executable.
+       cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+       hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+	archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+       else
+	if test "$host_cpu" = ia64; then
+	  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag="-z nodefs"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an empty executable.
+	 cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+	 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag=' ${wl}-bernotok'
+	  allow_undefined_flag=' ${wl}-berok'
+	  # Exported symbols can be pulled into shared objects from archives
+	  whole_archive_flag_spec='$convenience'
+	  archive_cmds_need_lc=yes
+	  # This is similar to how AIX traditionally builds its shared libraries.
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      # see comment about different semantics on the GNU ld section
+      ld_shlibs=no
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec=' '
+      allow_undefined_flag=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      old_archive_From_new_cmds='true'
+      # FIXME: Should let the user specify the lib program.
+      old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs'
+      fix_srcfile_path='`cygpath -w "$srcfile"`'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    darwin* | rhapsody*)
+      case $host_os in
+        rhapsody* | darwin1.[012])
+         allow_undefined_flag='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           allow_undefined_flag='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[012])
+               allow_undefined_flag='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               allow_undefined_flag='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+      esac
+      archive_cmds_need_lc=no
+      hardcode_direct=no
+      hardcode_automatic=yes
+      hardcode_shlibpath_var=unsupported
+      whole_archive_flag_spec=''
+      link_all_deplibs=yes
+    if test "$GCC" = yes ; then
+    	output_verbose_link_cmd='echo'
+        archive_cmds='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+      archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      module_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+         archive_cmds='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+         module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+         archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          module_expsym_cmds='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         ld_shlibs=no
+          ;;
+      esac
+    fi
+      ;;
+
+    dgux*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    freebsd1*)
+      ld_shlibs=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | kfreebsd*-gnu | dragonfly*)
+      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	archive_cmds='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      export_dynamic_flag_spec='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator=:
+
+	hardcode_direct=yes
+	export_dynamic_flag_spec='${wl}-E'
+
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_libdir_flag_spec_ld='+b $libdir'
+	  hardcode_direct=no
+	  hardcode_shlibpath_var=no
+	  ;;
+	*)
+	  hardcode_direct=yes
+	  export_dynamic_flag_spec='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec_ld='-rpath $libdir'
+      fi
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      link_all_deplibs=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    newsos6)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_shlibpath_var=no
+      ;;
+
+    openbsd*)
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+	hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+	export_dynamic_flag_spec='${wl}-E'
+      else
+       case $host_os in
+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+	   archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	   hardcode_libdir_flag_spec='-R$libdir'
+	   ;;
+	 *)
+	   archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	   hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+	   ;;
+       esac
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      hardcode_libdir_separator=:
+      ;;
+
+    solaris*)
+      no_undefined_flag=' -z text'
+      if test "$GCC" = yes; then
+	wlarc='${wl}'
+	archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
+      else
+	wlarc=''
+	archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_shlibpath_var=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+ 	# The compiler driver will combine linker options so we
+ 	# cannot just pass the convience library names through
+ 	# without $wl, iff we do not link with $LD.
+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.
+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)
+ 	case $wlarc in
+ 	'')
+ 	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;
+ 	*)
+ 	  whole_archive_flag_spec='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;
+ 	esac ;;
+      esac
+      link_all_deplibs=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds='$CC -r -o $output$reload_objs'
+	  hardcode_direct=no
+        ;;
+	motorola)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var=no
+      export_dynamic_flag_spec='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)
+      no_undefined_flag='${wl}-z,text'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag='${wl}-z,text'
+      allow_undefined_flag='${wl}-z,nodefs'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      export_dynamic_flag_spec='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      ld_shlibs=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $ld_shlibs" >&5
+echo "${ECHO_T}$ld_shlibs" >&6
+test "$ld_shlibs" = no && can_build_shared=no
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $archive_cmds in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$lt_prog_compiler_wl
+	pic_flag=$lt_prog_compiler_pic
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$allow_undefined_flag
+        allow_undefined_flag=
+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
+  (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+        then
+	  archive_cmds_need_lc=no
+        else
+	  archive_cmds_need_lc=yes
+        fi
+        allow_undefined_flag=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc" >&5
+echo "${ECHO_T}$archive_cmds_need_lc" >&6
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  linux*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      supports_anon_versioning=no
+      case `$LD -v 2>/dev/null` in
+        *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test $supports_anon_versioning = yes; then
+        archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+$echo "local: *; };" >> $output_objdir/$libname.ver~
+        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        $archive_expsym_cmds="$archive_cmds"
+      fi
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[123]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  # Handle Gentoo/FreeBSD as it was Linux
+  case $host_vendor in
+    gentoo)
+      version_type=linux ;;
+    *)
+      version_type=freebsd-$objformat ;;
+  esac
+
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+    linux)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+      soname_spec='${libname}${release}${shared_ext}$major'
+      need_lib_prefix=no
+      need_version=no
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  freebsd*) # from 4.6 on
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix3*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+    *)                         need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[89] | openbsd2.[89].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      export_dynamic_flag_spec='${wl}-Blargedynsym'
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+    shlibpath_overrides_runpath=no
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    shlibpath_overrides_runpath=yes
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+echo "$as_me:$LINENO: result: $dynamic_linker" >&5
+echo "${ECHO_T}$dynamic_linker" >&6
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" || \
+   test -n "$runpath_var" || \
+   test "X$hardcode_automatic" = "Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$hardcode_direct" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, )" != no &&
+     test "$hardcode_minus_L" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+echo "$as_me:$LINENO: result: $hardcode_action" >&5
+echo "${ECHO_T}$hardcode_action" >&6
+
+if test "$hardcode_action" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+striplib=
+old_striplib=
+echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5
+echo $ECHO_N "checking whether stripping libraries is possible... $ECHO_C" >&6
+if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+   darwin*)
+       if test -n "$STRIP" ; then
+         striplib="$STRIP -x"
+         echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+       else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+       ;;
+   *)
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+    ;;
+  esac
+fi
+
+if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32*)
+    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen_libs=
+   ;;
+
+  cygwin*)
+    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen_libs=
+   ;;
+
+  darwin*)
+  # if libdl is installed we need to link against it
+    echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
+if test "${ac_cv_lib_dl_dlopen+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main ()
+{
+dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_dl_dlopen=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_dl_dlopen=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
+if test $ac_cv_lib_dl_dlopen = yes; then
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+
+    lt_cv_dlopen="dyld"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+
+fi
+
+   ;;
+
+  *)
+    echo "$as_me:$LINENO: checking for shl_load" >&5
+echo $ECHO_N "checking for shl_load... $ECHO_C" >&6
+if test "${ac_cv_func_shl_load+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define shl_load to an innocuous variant, in case <limits.h> declares shl_load.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define shl_load innocuous_shl_load
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char shl_load (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef shl_load
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char shl_load ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_shl_load) || defined (__stub___shl_load)
+choke me
+#else
+char (*f) () = shl_load;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != shl_load;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_func_shl_load=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_func_shl_load=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5
+echo "${ECHO_T}$ac_cv_func_shl_load" >&6
+if test $ac_cv_func_shl_load = yes; then
+  lt_cv_dlopen="shl_load"
+else
+  echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
+echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
+if test "${ac_cv_lib_dld_shl_load+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char shl_load ();
+int
+main ()
+{
+shl_load ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_dld_shl_load=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_dld_shl_load=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
+echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
+if test $ac_cv_lib_dld_shl_load = yes; then
+  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"
+else
+  echo "$as_me:$LINENO: checking for dlopen" >&5
+echo $ECHO_N "checking for dlopen... $ECHO_C" >&6
+if test "${ac_cv_func_dlopen+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define dlopen to an innocuous variant, in case <limits.h> declares dlopen.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define dlopen innocuous_dlopen
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char dlopen (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef dlopen
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_dlopen) || defined (__stub___dlopen)
+choke me
+#else
+char (*f) () = dlopen;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != dlopen;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_func_dlopen=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_func_dlopen=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5
+echo "${ECHO_T}$ac_cv_func_dlopen" >&6
+if test $ac_cv_func_dlopen = yes; then
+  lt_cv_dlopen="dlopen"
+else
+  echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
+if test "${ac_cv_lib_dl_dlopen+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main ()
+{
+dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_dl_dlopen=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_dl_dlopen=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
+if test $ac_cv_lib_dl_dlopen = yes; then
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+  echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5
+echo $ECHO_N "checking for dlopen in -lsvld... $ECHO_C" >&6
+if test "${ac_cv_lib_svld_dlopen+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main ()
+{
+dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_svld_dlopen=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_svld_dlopen=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5
+echo "${ECHO_T}$ac_cv_lib_svld_dlopen" >&6
+if test $ac_cv_lib_svld_dlopen = yes; then
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
+else
+  echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5
+echo $ECHO_N "checking for dld_link in -ldld... $ECHO_C" >&6
+if test "${ac_cv_lib_dld_dld_link+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dld_link ();
+int
+main ()
+{
+dld_link ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_dld_dld_link=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_dld_dld_link=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5
+echo "${ECHO_T}$ac_cv_lib_dld_dld_link" >&6
+if test $ac_cv_lib_dld_dld_link = yes; then
+  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+    ;;
+  esac
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  else
+    enable_dlopen=no
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS="$CPPFLAGS"
+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS="$LDFLAGS"
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS="$LIBS"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5
+echo $ECHO_N "checking whether a program can dlopen itself... $ECHO_C" >&6
+if test "${lt_cv_dlopen_self+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  	  if test "$cross_compiling" = yes; then :
+  lt_cv_dlopen_self=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<EOF
+#line 8456 "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" void exit (int);
+#endif
+
+void fnord() { int i=42;}
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+    exit (status);
+}
+EOF
+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5
+echo "${ECHO_T}$lt_cv_dlopen_self" >&6
+
+    if test "x$lt_cv_dlopen_self" = xyes; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5
+echo $ECHO_N "checking whether a statically linked program can dlopen itself... $ECHO_C" >&6
+if test "${lt_cv_dlopen_self_static+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  	  if test "$cross_compiling" = yes; then :
+  lt_cv_dlopen_self_static=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<EOF
+#line 8556 "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" void exit (int);
+#endif
+
+void fnord() { int i=42;}
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+    exit (status);
+}
+EOF
+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self_static=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5
+echo "${ECHO_T}$lt_cv_dlopen_self_static" >&6
+    fi
+
+    CPPFLAGS="$save_CPPFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+    LIBS="$save_LIBS"
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+
+# Report which library types will actually be built
+echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5
+echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6
+echo "$as_me:$LINENO: result: $can_build_shared" >&5
+echo "${ECHO_T}$can_build_shared" >&6
+
+echo "$as_me:$LINENO: checking whether to build shared libraries" >&5
+echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case $host_os in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+
+aix4* | aix5*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+    ;;
+esac
+echo "$as_me:$LINENO: result: $enable_shared" >&5
+echo "${ECHO_T}$enable_shared" >&6
+
+echo "$as_me:$LINENO: checking whether to build static libraries" >&5
+echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+echo "$as_me:$LINENO: result: $enable_static" >&5
+echo "${ECHO_T}$enable_static" >&6
+
+# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    compiler \
+    CC \
+    LD \
+    lt_prog_compiler_wl \
+    lt_prog_compiler_pic \
+    lt_prog_compiler_static \
+    lt_prog_compiler_no_builtin_flag \
+    export_dynamic_flag_spec \
+    thread_safe_flag_spec \
+    whole_archive_flag_spec \
+    enable_shared_with_static_runtimes \
+    old_archive_cmds \
+    old_archive_from_new_cmds \
+    predep_objects \
+    postdep_objects \
+    predeps \
+    postdeps \
+    compiler_lib_search_path \
+    archive_cmds \
+    archive_expsym_cmds \
+    postinstall_cmds \
+    postuninstall_cmds \
+    old_archive_from_expsyms_cmds \
+    allow_undefined_flag \
+    no_undefined_flag \
+    export_symbols_cmds \
+    hardcode_libdir_flag_spec \
+    hardcode_libdir_flag_spec_ld \
+    hardcode_libdir_separator \
+    hardcode_automatic \
+    module_cmds \
+    module_expsym_cmds \
+    lt_cv_prog_compiler_c_o \
+    exclude_expsyms \
+    include_expsyms; do
+
+    case $var in
+    old_archive_cmds | \
+    old_archive_from_new_cmds | \
+    archive_cmds | \
+    archive_expsym_cmds | \
+    module_cmds | \
+    module_expsym_cmds | \
+    old_archive_from_expsyms_cmds | \
+    export_symbols_cmds | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\$0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+cfgfile="${ofile}T"
+  trap "$rm \"$cfgfile\"; exit 1" 1 2 15
+  $rm -f "$cfgfile"
+  { echo "$as_me:$LINENO: creating $ofile" >&5
+echo "$as_me: creating $ofile" >&6;}
+
+  cat <<__EOF__ >> "$cfgfile"
+#! $SHELL
+
+# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
+# Free Software Foundation, Inc.
+#
+# This file is part of GNU Libtool:
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="$SED -e 1s/^X//"
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# The names of the tagged configurations supported by this script.
+available_tags=
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU C compiler?
+with_gcc=$GCC
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_thread_safe_flag_spec
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_old_archive_cmds
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_predep_objects
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_postdep_objects
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_predeps
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_postdeps
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$hardcode_automatic
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# ### END LIBTOOL CONFIG
+
+__EOF__
+
+
+  case $host_os in
+  aix3*)
+    cat <<\EOF >> "$cfgfile"
+
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+EOF
+    ;;
+  esac
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)
+
+  mv -f "$cfgfile" "$ofile" || \
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+
+# Check whether --with-tags or --without-tags was given.
+if test "${with_tags+set}" = set; then
+  withval="$with_tags"
+  tagnames="$withval"
+fi;
+
+if test -f "$ltmain" && test -n "$tagnames"; then
+  if test ! -f "${ofile}"; then
+    { echo "$as_me:$LINENO: WARNING: output file \`$ofile' does not exist" >&5
+echo "$as_me: WARNING: output file \`$ofile' does not exist" >&2;}
+  fi
+
+  if test -z "$LTCC"; then
+    eval "`$SHELL ${ofile} --config | grep '^LTCC='`"
+    if test -z "$LTCC"; then
+      { echo "$as_me:$LINENO: WARNING: output file \`$ofile' does not look like a libtool script" >&5
+echo "$as_me: WARNING: output file \`$ofile' does not look like a libtool script" >&2;}
+    else
+      { echo "$as_me:$LINENO: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&5
+echo "$as_me: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&2;}
+    fi
+  fi
+  if test -z "$LTCFLAGS"; then
+    eval "`$SHELL ${ofile} --config | grep '^LTCFLAGS='`"
+  fi
+
+  # Extract list of available tagged configurations in $ofile.
+  # Note that this assumes the entire list is on one line.
+  available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'`
+
+  lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+  for tagname in $tagnames; do
+    IFS="$lt_save_ifs"
+    # Check whether tagname contains only valid characters
+    case `$echo "X$tagname" | $Xsed -e 's:[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]::g'` in
+    "") ;;
+    *)  { { echo "$as_me:$LINENO: error: invalid tag name: $tagname" >&5
+echo "$as_me: error: invalid tag name: $tagname" >&2;}
+   { (exit 1); exit 1; }; }
+	;;
+    esac
+
+    if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null
+    then
+      { { echo "$as_me:$LINENO: error: tag name \"$tagname\" already exists" >&5
+echo "$as_me: error: tag name \"$tagname\" already exists" >&2;}
+   { (exit 1); exit 1; }; }
+    fi
+
+    # Update the list of available tags.
+    if test -n "$tagname"; then
+      echo appending configuration tag \"$tagname\" to $ofile
+
+      case $tagname in
+      CXX)
+	if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+	    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+	    (test "X$CXX" != "Xg++"))) ; then
+	  ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+
+
+archive_cmds_need_lc_CXX=no
+allow_undefined_flag_CXX=
+always_export_symbols_CXX=no
+archive_expsym_cmds_CXX=
+export_dynamic_flag_spec_CXX=
+hardcode_direct_CXX=no
+hardcode_libdir_flag_spec_CXX=
+hardcode_libdir_flag_spec_ld_CXX=
+hardcode_libdir_separator_CXX=
+hardcode_minus_L_CXX=no
+hardcode_shlibpath_var_CXX=unsupported
+hardcode_automatic_CXX=no
+module_cmds_CXX=
+module_expsym_cmds_CXX=
+link_all_deplibs_CXX=unknown
+old_archive_cmds_CXX=$old_archive_cmds
+no_undefined_flag_CXX=
+whole_archive_flag_spec_CXX=
+enable_shared_with_static_runtimes_CXX=no
+
+# Dependencies to place before and after the object being linked:
+predep_objects_CXX=
+postdep_objects_CXX=
+predeps_CXX=
+postdeps_CXX=
+compiler_lib_search_path_CXX=
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+objext_CXX=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_LD=$LD
+lt_save_GCC=$GCC
+GCC=$GXX
+lt_save_with_gnu_ld=$with_gnu_ld
+lt_save_path_LD=$lt_cv_path_LD
+if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+else
+  $as_unset lt_cv_prog_gnu_ld
+fi
+if test -n "${lt_cv_path_LDCXX+set}"; then
+  lt_cv_path_LD=$lt_cv_path_LDCXX
+else
+  $as_unset lt_cv_path_LD
+fi
+test -z "${LDCXX+set}" || LD=$LDCXX
+CC=${CXX-"c++"}
+compiler=$CC
+compiler_CXX=$CC
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+
+# We don't want -fno-exception wen compiling C++ code, so set the
+# no_builtin_flag separately
+if test "$GXX" = yes; then
+  lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
+else
+  lt_prog_compiler_no_builtin_flag_CXX=
+fi
+
+if test "$GXX" = yes; then
+  # Set up default GNU C++ configuration
+
+
+# Check whether --with-gnu-ld or --without-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then
+  withval="$with_gnu_ld"
+  test "$withval" = no || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi;
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  echo "$as_me:$LINENO: checking for ld used by $CC" >&5
+echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  echo "$as_me:$LINENO: checking for GNU ld" >&5
+echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
+else
+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
+fi
+if test "${lt_cv_path_LD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test "$with_gnu_ld" != no && break
+	;;
+      *)
+	test "$with_gnu_ld" != yes && break
+	;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  echo "$as_me:$LINENO: result: $LD" >&5
+echo "${ECHO_T}$LD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+   { (exit 1); exit 1; }; }
+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
+if test "${lt_cv_prog_gnu_ld+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+  # Check if GNU C++ uses GNU ld as the underlying linker, since the
+  # archiving commands below assume that GNU ld is being used.
+  if test "$with_gnu_ld" = yes; then
+    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+    archive_expsym_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+    hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'
+    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+    #     investigate it a little bit more. (MM)
+    wlarc='${wl}'
+
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if eval "`$CC -print-prog-name=ld` --help 2>&1" | \
+	grep 'no-whole-archive' > /dev/null; then
+      whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    else
+      whole_archive_flag_spec_CXX=
+    fi
+  else
+    with_gnu_ld=no
+    wlarc=
+
+    # A generic and very simple default shared library creation
+    # command for GNU C++ for the case where it uses the native
+    # linker, instead of GNU ld.  If possible, this setting should
+    # overridden to take advantage of the native linker features on
+    # the platform it is being used on.
+    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+  fi
+
+  # Commands to make compiler produce verbose output that lists
+  # what "hidden" libraries, object files and flags are used when
+  # linking a shared library.
+  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+else
+  GXX=no
+  with_gnu_ld=no
+  wlarc=
+fi
+
+# PORTME: fill in a description of your system's C++ link characteristics
+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
+ld_shlibs_CXX=yes
+case $host_os in
+  aix3*)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+  aix4* | aix5*)
+    if test "$host_cpu" = ia64; then
+      # On IA64, the linker does run time linking by default, so we don't
+      # have to do anything special.
+      aix_use_runtimelinking=no
+      exp_sym_flag='-Bexport'
+      no_entry_flag=""
+    else
+      aix_use_runtimelinking=no
+
+      # Test if we are trying to use run time linking or normal
+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+      # need to do runtime linking.
+      case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+	for ld_flag in $LDFLAGS; do
+	  case $ld_flag in
+	  *-brtl*)
+	    aix_use_runtimelinking=yes
+	    break
+	    ;;
+	  esac
+	done
+	;;
+      esac
+
+      exp_sym_flag='-bexport'
+      no_entry_flag='-bnoentry'
+    fi
+
+    # When large executables or shared objects are built, AIX ld can
+    # have problems creating the table of contents.  If linking a library
+    # or program results in "error TOC overflow" add -mminimal-toc to
+    # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+    # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+    archive_cmds_CXX=''
+    hardcode_direct_CXX=yes
+    hardcode_libdir_separator_CXX=':'
+    link_all_deplibs_CXX=yes
+
+    if test "$GXX" = yes; then
+      case $host_os in aix4.[012]|aix4.[012].*)
+      # We only want to do this on AIX 4.2 and lower, the check
+      # below for broken collect2 doesn't work under 4.3+
+	collect2name=`${CC} -print-prog-name=collect2`
+	if test -f "$collect2name" && \
+	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	then
+	  # We have reworked collect2
+	  hardcode_direct_CXX=yes
+	else
+	  # We have old collect2
+	  hardcode_direct_CXX=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L_CXX=yes
+	  hardcode_libdir_flag_spec_CXX='-L$libdir'
+	  hardcode_libdir_separator_CXX=
+	fi
+	;;
+      esac
+      shared_flag='-shared'
+      if test "$aix_use_runtimelinking" = yes; then
+	shared_flag="$shared_flag "'${wl}-G'
+      fi
+    else
+      # not using gcc
+      if test "$host_cpu" = ia64; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	shared_flag='-G'
+      else
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag='${wl}-G'
+	else
+	  shared_flag='${wl}-bM:SRE'
+	fi
+      fi
+    fi
+
+    # It seems that -bexpall does not export symbols beginning with
+    # underscore (_), so it is better to generate a list of symbols to export.
+    always_export_symbols_CXX=yes
+    if test "$aix_use_runtimelinking" = yes; then
+      # Warning - without using the other runtime loading flags (-brtl),
+      # -berok will link without error, but may produce a broken library.
+      allow_undefined_flag_CXX='-berok'
+      # Determine the default libpath from the value encoded in an empty executable.
+      cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+      hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+      archive_expsym_cmds_CXX="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+     else
+      if test "$host_cpu" = ia64; then
+	hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib'
+	allow_undefined_flag_CXX="-z nodefs"
+	archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+      else
+	# Determine the default libpath from the value encoded in an empty executable.
+	cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_cxx_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+	hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+	# Warning - without using the other run time loading flags,
+	# -berok will link without error, but may produce a broken library.
+	no_undefined_flag_CXX=' ${wl}-bernotok'
+	allow_undefined_flag_CXX=' ${wl}-berok'
+	# Exported symbols can be pulled into shared objects from archives
+	whole_archive_flag_spec_CXX='$convenience'
+	archive_cmds_need_lc_CXX=yes
+	# This is similar to how AIX traditionally builds its shared libraries.
+	archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+      fi
+    fi
+    ;;
+
+  beos*)
+    if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+      allow_undefined_flag_CXX=unsupported
+      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+      # support --undefined.  This deserves some investigation.  FIXME
+      archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+    else
+      ld_shlibs_CXX=no
+    fi
+    ;;
+
+  chorus*)
+    case $cc_basename in
+      *)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+    esac
+    ;;
+
+  cygwin* | mingw* | pw32*)
+    # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
+    # as there is no search path for DLLs.
+    hardcode_libdir_flag_spec_CXX='-L$libdir'
+    allow_undefined_flag_CXX=unsupported
+    always_export_symbols_CXX=no
+    enable_shared_with_static_runtimes_CXX=yes
+
+    if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+      archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      # If the export-symbols file already is a .def file (1st line
+      # is EXPORTS), use it as is; otherwise, prepend...
+      archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	cp $export_symbols $output_objdir/$soname.def;
+      else
+	echo EXPORTS > $output_objdir/$soname.def;
+	cat $export_symbols >> $output_objdir/$soname.def;
+      fi~
+      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+    else
+      ld_shlibs_CXX=no
+    fi
+  ;;
+      darwin* | rhapsody*)
+        case $host_os in
+        rhapsody* | darwin1.[012])
+         allow_undefined_flag_CXX='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           allow_undefined_flag_CXX='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[012])
+               allow_undefined_flag_CXX='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               allow_undefined_flag_CXX='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+        esac
+      archive_cmds_need_lc_CXX=no
+      hardcode_direct_CXX=no
+      hardcode_automatic_CXX=yes
+      hardcode_shlibpath_var_CXX=unsupported
+      whole_archive_flag_spec_CXX=''
+      link_all_deplibs_CXX=yes
+
+    if test "$GXX" = yes ; then
+      lt_int_apple_cc_single_mod=no
+      output_verbose_link_cmd='echo'
+      if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then
+       lt_int_apple_cc_single_mod=yes
+      fi
+      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+       archive_cmds_CXX='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      else
+          archive_cmds_CXX='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+        fi
+        module_cmds_CXX='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+            archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          else
+            archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          fi
+            module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+          archive_cmds_CXX='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+          module_cmds_CXX='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+          archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         ld_shlibs_CXX=no
+          ;;
+      esac
+      fi
+        ;;
+
+  dgux*)
+    case $cc_basename in
+      ec++*)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      ghcx*)
+	# Green Hills C++ Compiler
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+    esac
+    ;;
+  freebsd[12]*)
+    # C++ shared libraries reported to be fairly broken before switch to ELF
+    ld_shlibs_CXX=no
+    ;;
+  freebsd-elf*)
+    archive_cmds_need_lc_CXX=no
+    ;;
+  freebsd* | kfreebsd*-gnu | dragonfly*)
+    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+    # conventions
+    ld_shlibs_CXX=yes
+    ;;
+  gnu*)
+    ;;
+  hpux9*)
+    hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+    hardcode_libdir_separator_CXX=:
+    export_dynamic_flag_spec_CXX='${wl}-E'
+    hardcode_direct_CXX=yes
+    hardcode_minus_L_CXX=yes # Not in the search PATH,
+				# but as the default
+				# location of the library.
+
+    case $cc_basename in
+    CC*)
+      # FIXME: insert proper C++ library support
+      ld_shlibs_CXX=no
+      ;;
+    aCC*)
+      archive_cmds_CXX='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      #
+      # There doesn't appear to be a way to prevent this compiler from
+      # explicitly linking system object files so we need to strip them
+      # from the output so that they don't get included in the library
+      # dependencies.
+      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[-]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+      ;;
+    *)
+      if test "$GXX" = yes; then
+        archive_cmds_CXX='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+      fi
+      ;;
+    esac
+    ;;
+  hpux10*|hpux11*)
+    if test $with_gnu_ld = no; then
+      hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator_CXX=:
+
+      case $host_cpu in
+      hppa*64*|ia64*)
+	hardcode_libdir_flag_spec_ld_CXX='+b $libdir'
+        ;;
+      *)
+	export_dynamic_flag_spec_CXX='${wl}-E'
+        ;;
+      esac
+    fi
+    case $host_cpu in
+    hppa*64*|ia64*)
+      hardcode_direct_CXX=no
+      hardcode_shlibpath_var_CXX=no
+      ;;
+    *)
+      hardcode_direct_CXX=yes
+      hardcode_minus_L_CXX=yes # Not in the search PATH,
+					      # but as the default
+					      # location of the library.
+      ;;
+    esac
+
+    case $cc_basename in
+      CC*)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      aCC*)
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	  ;;
+	esac
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes; then
+	  if test $with_gnu_ld = no; then
+	    case $host_cpu in
+	    hppa*64*)
+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    ia64*)
+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    *)
+	      archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      ;;
+	    esac
+	  fi
+	else
+	  # FIXME: insert proper C++ library support
+	  ld_shlibs_CXX=no
+	fi
+	;;
+    esac
+    ;;
+  interix3*)
+    hardcode_direct_CXX=no
+    hardcode_shlibpath_var_CXX=no
+    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+    export_dynamic_flag_spec_CXX='${wl}-E'
+    # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+    # Instead, shared libraries are loaded at an image base (0x10000000 by
+    # default) and relocated if they conflict, which is a slow very memory
+    # consuming and fragmenting process.  To avoid this, we pick a random,
+    # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+    # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+    archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+    archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+    ;;
+  irix5* | irix6*)
+    case $cc_basename in
+      CC*)
+	# SGI C++
+	archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+
+	# Archives containing C++ object files must be created using
+	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+	# necessary to make sure instantiated templates are included
+	# in the archive.
+	old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
+	;;
+      *)
+	if test "$GXX" = yes; then
+	  if test "$with_gnu_ld" = no; then
+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	  else
+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'
+	  fi
+	fi
+	link_all_deplibs_CXX=yes
+	;;
+    esac
+    hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+    hardcode_libdir_separator_CXX=:
+    ;;
+  linux*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+
+	hardcode_libdir_flag_spec_CXX='${wl}--rpath,$libdir'
+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+
+	# Archives containing C++ object files must be created using
+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
+	;;
+      icpc*)
+	# Intel C++
+	with_gnu_ld=yes
+	# version 8.0 and above of icpc choke on multiply defined symbols
+	# if we add $predep_objects and $postdep_objects, however 7.1 and
+	# earlier do not add the objects themselves.
+	case `$CC -V 2>&1` in
+	*"Version 7."*)
+  	  archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+  	  archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	  ;;
+	*)  # Version 8.0 or newer
+	  tmp_idyn=
+	  case $host_cpu in
+	    ia64*) tmp_idyn=' -i_dynamic';;
+	  esac
+  	  archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	  archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	  ;;
+	esac
+	archive_cmds_need_lc_CXX=no
+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+	whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	;;
+      pgCC*)
+        # Portland Group C++ compiler
+	archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+  	archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+
+	hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'
+	export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+	whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+        ;;
+      cxx*)
+	# Compaq C++
+	archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+	runpath_var=LD_RUN_PATH
+	hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+	hardcode_libdir_separator_CXX=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+    esac
+    ;;
+  lynxos*)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+  m88k*)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+  mvs*)
+    case $cc_basename in
+      cxx*)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+    esac
+    ;;
+  netbsd*)
+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+      archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+      wlarc=
+      hardcode_libdir_flag_spec_CXX='-R$libdir'
+      hardcode_direct_CXX=yes
+      hardcode_shlibpath_var_CXX=no
+    fi
+    # Workaround some broken pre-1.5 toolchains
+    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+    ;;
+  openbsd2*)
+    # C++ shared libraries are fairly broken
+    ld_shlibs_CXX=no
+    ;;
+  openbsd*)
+    hardcode_direct_CXX=yes
+    hardcode_shlibpath_var_CXX=no
+    archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
+      export_dynamic_flag_spec_CXX='${wl}-E'
+      whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    fi
+    output_verbose_link_cmd='echo'
+    ;;
+  osf3*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+	hardcode_libdir_separator_CXX=:
+
+	# Archives containing C++ object files must be created using
+	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
+
+	;;
+      RCC*)
+	# Rational C++ 2.4.1
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      cxx*)
+	allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+
+	hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+	hardcode_libdir_separator_CXX=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+	  archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+
+	  hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+	  hardcode_libdir_separator_CXX=:
+
+	  # Commands to make compiler produce verbose output that lists
+	  # what "hidden" libraries, object files and flags are used when
+	  # linking a shared library.
+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+	else
+	  # FIXME: insert proper C++ library support
+	  ld_shlibs_CXX=no
+	fi
+	;;
+    esac
+    ;;
+  osf4* | osf5*)
+    case $cc_basename in
+      KCC*)
+	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	# KCC will only create a shared library if the output file
+	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+	# to its proper name (with version) after linking.
+	archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+	hardcode_libdir_separator_CXX=:
+
+	# Archives containing C++ object files must be created using
+	# the KAI C++ compiler.
+	old_archive_cmds_CXX='$CC -o $oldlib $oldobjs'
+	;;
+      RCC*)
+	# Rational C++ 2.4.1
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      cxx*)
+	allow_undefined_flag_CXX=' -expect_unresolved \*'
+	archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+	  echo "-hidden">> $lib.exp~
+	  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version	$verstring` -update_registry ${output_objdir}/so_locations -o $lib~
+	  $rm $lib.exp'
+
+	hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+	hardcode_libdir_separator_CXX=:
+
+	# Commands to make compiler produce verbose output that lists
+	# what "hidden" libraries, object files and flags are used when
+	# linking a shared library.
+	#
+	# There doesn't appear to be a way to prevent this compiler from
+	# explicitly linking system object files so we need to strip them
+	# from the output so that they don't get included in the library
+	# dependencies.
+	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+	;;
+      *)
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+	 archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+
+	  hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+	  hardcode_libdir_separator_CXX=:
+
+	  # Commands to make compiler produce verbose output that lists
+	  # what "hidden" libraries, object files and flags are used when
+	  # linking a shared library.
+	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
+
+	else
+	  # FIXME: insert proper C++ library support
+	  ld_shlibs_CXX=no
+	fi
+	;;
+    esac
+    ;;
+  psos*)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+  sunos4*)
+    case $cc_basename in
+      CC*)
+	# Sun C++ 4.x
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      lcc*)
+	# Lucid
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+    esac
+    ;;
+  solaris*)
+    case $cc_basename in
+      CC*)
+	# Sun C++ 4.2, 5.x and Centerline C++
+        archive_cmds_need_lc_CXX=yes
+	no_undefined_flag_CXX=' -zdefs'
+	archive_cmds_CXX='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	$CC -G${allow_undefined_flag}  ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	hardcode_libdir_flag_spec_CXX='-R$libdir'
+	hardcode_shlibpath_var_CXX=no
+	case $host_os in
+	  solaris2.[0-5] | solaris2.[0-5].*) ;;
+	  *)
+	    # The C++ compiler is used as linker so we must use $wl
+	    # flag to pass the commands to the underlying system
+	    # linker. We must also pass each convience library through
+	    # to the system linker between allextract/defaultextract.
+	    # The C++ compiler will combine linker options so we
+	    # cannot just pass the convience library names through
+	    # without $wl.
+	    # Supported since Solaris 2.6 (maybe 2.5.1?)
+	    whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
+	    ;;
+	esac
+	link_all_deplibs_CXX=yes
+
+	output_verbose_link_cmd='echo'
+
+	# Archives containing C++ object files must be created using
+	# "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	# necessary to make sure instantiated templates are included
+	# in the archive.
+	old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+	;;
+      gcx*)
+	# Green Hills C++ Compiler
+	archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+	# The C++ compiler must be used to create the archive.
+	old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+	;;
+      *)
+	# GNU C++ compiler with Solaris linker
+	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+	  no_undefined_flag_CXX=' ${wl}-z ${wl}defs'
+	  if $CC --version | grep -v '^2\.7' > /dev/null; then
+	    archive_cmds_CXX='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""
+	  else
+	    # g++ 2.7 appears to require `-G' NOT `-shared' on this
+	    # platform.
+	    archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+	    archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""
+	  fi
+
+	  hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir'
+	fi
+	;;
+    esac
+    ;;
+  sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+    no_undefined_flag_CXX='${wl}-z,text'
+    archive_cmds_need_lc_CXX=no
+    hardcode_shlibpath_var_CXX=no
+    runpath_var='LD_RUN_PATH'
+
+    case $cc_basename in
+      CC*)
+	archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      *)
+	archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+    esac
+    ;;
+  sysv5* | sco3.2v5* | sco5v6*)
+    # Note: We can NOT use -z defs as we might desire, because we do not
+    # link with -lc, and that would cause any symbols used from libc to
+    # always be unresolved, which means just about no library would
+    # ever link correctly.  If we're not using GNU ld we use -z text
+    # though, which does catch some bad symbols but isn't as heavy-handed
+    # as -z defs.
+    # For security reasons, it is highly recommended that you always
+    # use absolute paths for naming shared libraries, and exclude the
+    # DT_RUNPATH tag from executables and libraries.  But doing so
+    # requires that you compile everything twice, which is a pain.
+    # So that behaviour is only enabled if SCOABSPATH is set to a
+    # non-empty value in the environment.  Most likely only useful for
+    # creating official distributions of packages.
+    # This is a hack until libtool officially supports absolute path
+    # names for shared libraries.
+    no_undefined_flag_CXX='${wl}-z,text'
+    allow_undefined_flag_CXX='${wl}-z,nodefs'
+    archive_cmds_need_lc_CXX=no
+    hardcode_shlibpath_var_CXX=no
+    hardcode_libdir_flag_spec_CXX='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+    hardcode_libdir_separator_CXX=':'
+    link_all_deplibs_CXX=yes
+    export_dynamic_flag_spec_CXX='${wl}-Bexport'
+    runpath_var='LD_RUN_PATH'
+
+    case $cc_basename in
+      CC*)
+	archive_cmds_CXX='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      *)
+	archive_cmds_CXX='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+    esac
+    ;;
+  tandem*)
+    case $cc_basename in
+      NCC*)
+	# NonStop-UX NCC 3.20
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+      *)
+	# FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+    esac
+    ;;
+  vxworks*)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+  *)
+    # FIXME: insert proper C++ library support
+    ld_shlibs_CXX=no
+    ;;
+esac
+echo "$as_me:$LINENO: result: $ld_shlibs_CXX" >&5
+echo "${ECHO_T}$ld_shlibs_CXX" >&6
+test "$ld_shlibs_CXX" = no && can_build_shared=no
+
+GCC_CXX="$GXX"
+LD_CXX="$LD"
+
+
+cat > conftest.$ac_ext <<EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+EOF
+
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  # The `*' in the case matches for architectures that use `case' in
+  # $output_verbose_cmd can trigger glob expansion during the loop
+  # eval without this substitution.
+  output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`
+
+  for p in `eval $output_verbose_link_cmd`; do
+    case $p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test $p = "-L" \
+	  || test $p = "-R"; then
+	 prev=$p
+	 continue
+       else
+	 prev=
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 case $p in
+	 -L* | -R*)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$compiler_lib_search_path_CXX"; then
+	     compiler_lib_search_path_CXX="${prev}${p}"
+	   else
+	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$postdeps_CXX"; then
+	   postdeps_CXX="${prev}${p}"
+	 else
+	   postdeps_CXX="${postdeps_CXX} ${prev}${p}"
+	 fi
+       fi
+       ;;
+
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 if test -z "$predep_objects_CXX"; then
+	   predep_objects_CXX="$p"
+	 else
+	   predep_objects_CXX="$predep_objects_CXX $p"
+	 fi
+       else
+	 if test -z "$postdep_objects_CXX"; then
+	   postdep_objects_CXX="$p"
+	 else
+	   postdep_objects_CXX="$postdep_objects_CXX $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling CXX test program"
+fi
+
+$rm -f confest.$objext
+
+# PORTME: override above test on systems where it is broken
+case $host_os in
+interix3*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  predep_objects_CXX=
+  postdep_objects_CXX=
+  postdeps_CXX=
+  ;;
+
+solaris*)
+  case $cc_basename in
+  CC*)
+    # Adding this requires a known-good setup of shared libraries for
+    # Sun compiler versions before 5.6, else PIC objects from an old
+    # archive will be linked into the output, leading to subtle bugs.
+    postdeps_CXX='-lCstd -lCrun'
+    ;;
+  esac
+  ;;
+esac
+
+
+case " $postdeps_CXX " in
+*" -lc "*) archive_cmds_need_lc_CXX=no ;;
+esac
+
+lt_prog_compiler_wl_CXX=
+lt_prog_compiler_pic_CXX=
+lt_prog_compiler_static_CXX=
+
+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
+
+  # C++ specific cases for pic, static, wl, etc.
+  if test "$GXX" = yes; then
+    lt_prog_compiler_wl_CXX='-Wl,'
+    lt_prog_compiler_static_CXX='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_CXX='-Bstatic'
+      fi
+      ;;
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
+      ;;
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | os2* | pw32*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic_CXX='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      lt_prog_compiler_pic_CXX=
+      ;;
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic_CXX=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	;;
+      *)
+	lt_prog_compiler_pic_CXX='-fPIC'
+	;;
+      esac
+      ;;
+    *)
+      lt_prog_compiler_pic_CXX='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix4* | aix5*)
+	# All AIX code is PIC.
+	if test "$host_cpu" = ia64; then
+	  # AIX 5 now supports IA64 processor
+	  lt_prog_compiler_static_CXX='-Bstatic'
+	else
+	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68*)
+	  # Green Hills C++ Compiler
+	  # _LT_AC_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+       darwin*)
+         # PIC is the default on this platform
+         # Common symbols not allowed in MH_DYLIB files
+         case $cc_basename in
+           xlc*)
+           lt_prog_compiler_pic_CXX='-qnocommon'
+           lt_prog_compiler_wl_CXX='-Wl,'
+           ;;
+         esac
+       ;;
+      dgux*)
+	case $cc_basename in
+	  ec++*)
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  ghcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | kfreebsd*-gnu | dragonfly*)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
+	    if test "$host_cpu" != ia64; then
+	      lt_prog_compiler_pic_CXX='+Z'
+	    fi
+	    ;;
+	  aCC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
+	    case $host_cpu in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      lt_prog_compiler_pic_CXX='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      interix*)
+	# This is c89, which is MS Visual C++ (no shared libs)
+	# Anyone wants to do a port?
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux*)
+	case $cc_basename in
+	  KCC*)
+	    # KAI C++ Compiler
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    lt_prog_compiler_pic_CXX='-fPIC'
+	    ;;
+	  icpc* | ecpc*)
+	    # Intel C++
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-static'
+	    ;;
+	  pgCC*)
+	    # Portland Group C++ compiler.
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-fpic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  cxx*)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx*)
+	    lt_prog_compiler_pic_CXX='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd*)
+	;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC*)
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    ;;
+	  RCC*)
+	    # Rational C++ 2.4.1
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  cxx*)
+	    # Digital/Compaq C++
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    lt_prog_compiler_wl_CXX='-Qoption ld '
+	    ;;
+	  gcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.x
+	    lt_prog_compiler_pic_CXX='-pic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  lcc*)
+	    # Lucid
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC*)
+	    # NonStop-UX NCC 3.20
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	esac
+	;;
+      vxworks*)
+	;;
+      *)
+	lt_prog_compiler_can_build_shared_CXX=no
+	;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_CXX" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_CXX" >&6
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_CXX"; then
+
+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... $ECHO_C" >&6
+if test "${lt_prog_compiler_pic_works_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_pic_works_CXX=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:10896: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:10900: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_prog_compiler_pic_works_CXX=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_CXX" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_works_CXX" >&6
+
+if test x"$lt_prog_compiler_pic_works_CXX" = xyes; then
+    case $lt_prog_compiler_pic_CXX in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
+     esac
+else
+    lt_prog_compiler_pic_CXX=
+     lt_prog_compiler_can_build_shared_CXX=no
+fi
+
+fi
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic_CXX=
+    ;;
+  *)
+    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
+    ;;
+esac
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
+if test "${lt_prog_compiler_static_works_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_static_works_CXX=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_prog_compiler_static_works_CXX=yes
+       fi
+     else
+       lt_prog_compiler_static_works_CXX=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_CXX" >&5
+echo "${ECHO_T}$lt_prog_compiler_static_works_CXX" >&6
+
+if test x"$lt_prog_compiler_static_works_CXX" = xyes; then
+    :
+else
+    lt_prog_compiler_static_CXX=
+fi
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_c_o_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_c_o_CXX=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:11000: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:11004: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_CXX=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_CXX" >&6
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  echo "$as_me:$LINENO: result: $hard_links" >&5
+echo "${ECHO_T}$hard_links" >&6
+  if test "$hard_links" = no; then
+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
+
+  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  case $host_os in
+  aix4* | aix5*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to AIX nm, but means don't demangle with GNU nm
+    if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+    else
+      export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    export_symbols_cmds_CXX="$ltdll_cmds"
+  ;;
+  cygwin* | mingw*)
+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([^ ]*\) [^ ]*/\1 DATA/;/^I /d;/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  *)
+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  esac
+
+echo "$as_me:$LINENO: result: $ld_shlibs_CXX" >&5
+echo "${ECHO_T}$ld_shlibs_CXX" >&6
+test "$ld_shlibs_CXX" = no && can_build_shared=no
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_CXX" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc_CXX=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $archive_cmds_CXX in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$lt_prog_compiler_wl_CXX
+	pic_flag=$lt_prog_compiler_pic_CXX
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
+        allow_undefined_flag_CXX=
+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
+  (eval $archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+        then
+	  archive_cmds_need_lc_CXX=no
+        else
+	  archive_cmds_need_lc_CXX=yes
+        fi
+        allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_CXX" >&5
+echo "${ECHO_T}$archive_cmds_need_lc_CXX" >&6
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  linux*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      supports_anon_versioning=no
+      case `$LD -v 2>/dev/null` in
+        *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test $supports_anon_versioning = yes; then
+        archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+$echo "local: *; };" >> $output_objdir/$libname.ver~
+        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        $archive_expsym_cmds="$archive_cmds"
+      fi
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[123]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  # Handle Gentoo/FreeBSD as it was Linux
+  case $host_vendor in
+    gentoo)
+      version_type=linux ;;
+    *)
+      version_type=freebsd-$objformat ;;
+  esac
+
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+    linux)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+      soname_spec='${libname}${release}${shared_ext}$major'
+      need_lib_prefix=no
+      need_version=no
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  freebsd*) # from 4.6 on
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix3*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+    *)                         need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[89] | openbsd2.[89].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      export_dynamic_flag_spec='${wl}-Blargedynsym'
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+    shlibpath_overrides_runpath=no
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    shlibpath_overrides_runpath=yes
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+echo "$as_me:$LINENO: result: $dynamic_linker" >&5
+echo "${ECHO_T}$dynamic_linker" >&6
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
+hardcode_action_CXX=
+if test -n "$hardcode_libdir_flag_spec_CXX" || \
+   test -n "$runpath_var_CXX" || \
+   test "X$hardcode_automatic_CXX" = "Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$hardcode_direct_CXX" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, CXX)" != no &&
+     test "$hardcode_minus_L_CXX" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action_CXX=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action_CXX=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action_CXX=unsupported
+fi
+echo "$as_me:$LINENO: result: $hardcode_action_CXX" >&5
+echo "${ECHO_T}$hardcode_action_CXX" >&6
+
+if test "$hardcode_action_CXX" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    compiler_CXX \
+    CC_CXX \
+    LD_CXX \
+    lt_prog_compiler_wl_CXX \
+    lt_prog_compiler_pic_CXX \
+    lt_prog_compiler_static_CXX \
+    lt_prog_compiler_no_builtin_flag_CXX \
+    export_dynamic_flag_spec_CXX \
+    thread_safe_flag_spec_CXX \
+    whole_archive_flag_spec_CXX \
+    enable_shared_with_static_runtimes_CXX \
+    old_archive_cmds_CXX \
+    old_archive_from_new_cmds_CXX \
+    predep_objects_CXX \
+    postdep_objects_CXX \
+    predeps_CXX \
+    postdeps_CXX \
+    compiler_lib_search_path_CXX \
+    archive_cmds_CXX \
+    archive_expsym_cmds_CXX \
+    postinstall_cmds_CXX \
+    postuninstall_cmds_CXX \
+    old_archive_from_expsyms_cmds_CXX \
+    allow_undefined_flag_CXX \
+    no_undefined_flag_CXX \
+    export_symbols_cmds_CXX \
+    hardcode_libdir_flag_spec_CXX \
+    hardcode_libdir_flag_spec_ld_CXX \
+    hardcode_libdir_separator_CXX \
+    hardcode_automatic_CXX \
+    module_cmds_CXX \
+    module_expsym_cmds_CXX \
+    lt_cv_prog_compiler_c_o_CXX \
+    exclude_expsyms_CXX \
+    include_expsyms_CXX; do
+
+    case $var in
+    old_archive_cmds_CXX | \
+    old_archive_from_new_cmds_CXX | \
+    archive_cmds_CXX | \
+    archive_expsym_cmds_CXX | \
+    module_cmds_CXX | \
+    module_expsym_cmds_CXX | \
+    old_archive_from_expsyms_cmds_CXX | \
+    export_symbols_cmds_CXX | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\$0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+cfgfile="$ofile"
+
+  cat <<__EOF__ >> "$cfgfile"
+# ### BEGIN LIBTOOL TAG CONFIG: $tagname
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_CXX
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_compiler_CXX
+
+# Is the compiler the GNU C compiler?
+with_gcc=$GCC_CXX
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_LD_CXX
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_CXX
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_CXX
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_CXX
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_thread_safe_flag_spec_CXX
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_old_archive_cmds_CXX
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_archive_cmds_CXX
+archive_expsym_cmds=$lt_archive_expsym_cmds_CXX
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_module_cmds_CXX
+module_expsym_cmds=$lt_module_expsym_cmds_CXX
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_predep_objects_CXX
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_postdep_objects_CXX
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_predeps_CXX
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_postdeps_CXX
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_CXX
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_CXX
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_CXX
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_CXX
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct_CXX
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L_CXX
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$hardcode_automatic_CXX
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_CXX
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path_CXX"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols_CXX
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_CXX
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_CXX
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_CXX
+
+# ### END LIBTOOL TAG CONFIG: $tagname
+
+__EOF__
+
+
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC=$lt_save_CC
+LDCXX=$LD
+LD=$lt_save_LD
+GCC=$lt_save_GCC
+with_gnu_ldcxx=$with_gnu_ld
+with_gnu_ld=$lt_save_with_gnu_ld
+lt_cv_path_LDCXX=$lt_cv_path_LD
+lt_cv_path_LD=$lt_save_path_LD
+lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+
+	else
+	  tagname=""
+	fi
+	;;
+
+      F77)
+	if test -n "$F77" && test "X$F77" != "Xno"; then
+
+ac_ext=f
+ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
+ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_f77_compiler_gnu
+
+
+archive_cmds_need_lc_F77=no
+allow_undefined_flag_F77=
+always_export_symbols_F77=no
+archive_expsym_cmds_F77=
+export_dynamic_flag_spec_F77=
+hardcode_direct_F77=no
+hardcode_libdir_flag_spec_F77=
+hardcode_libdir_flag_spec_ld_F77=
+hardcode_libdir_separator_F77=
+hardcode_minus_L_F77=no
+hardcode_automatic_F77=no
+module_cmds_F77=
+module_expsym_cmds_F77=
+link_all_deplibs_F77=unknown
+old_archive_cmds_F77=$old_archive_cmds
+no_undefined_flag_F77=
+whole_archive_flag_spec_F77=
+enable_shared_with_static_runtimes_F77=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+objext_F77=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="      program t\n      end\n"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${F77-"f77"}
+compiler=$CC
+compiler_F77=$CC
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+
+echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5
+echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6
+echo "$as_me:$LINENO: result: $can_build_shared" >&5
+echo "${ECHO_T}$can_build_shared" >&6
+
+echo "$as_me:$LINENO: checking whether to build shared libraries" >&5
+echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case $host_os in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+aix4* | aix5*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+  ;;
+esac
+echo "$as_me:$LINENO: result: $enable_shared" >&5
+echo "${ECHO_T}$enable_shared" >&6
+
+echo "$as_me:$LINENO: checking whether to build static libraries" >&5
+echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+echo "$as_me:$LINENO: result: $enable_static" >&5
+echo "${ECHO_T}$enable_static" >&6
+
+GCC_F77="$G77"
+LD_F77="$LD"
+
+lt_prog_compiler_wl_F77=
+lt_prog_compiler_pic_F77=
+lt_prog_compiler_static_F77=
+
+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
+
+  if test "$GCC" = yes; then
+    lt_prog_compiler_wl_F77='-Wl,'
+    lt_prog_compiler_static_F77='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_F77='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      lt_prog_compiler_pic_F77='-m68020 -resident32 -malways-restore-a4'
+      ;;
+
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic_F77='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic_F77='-fno-common'
+      ;;
+
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared_F77=no
+      enable_shared=no
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic_F77=-Kconform_pic
+      fi
+      ;;
+
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic_F77='-fPIC'
+	;;
+      esac
+      ;;
+
+    *)
+      lt_prog_compiler_pic_F77='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_F77='-Bstatic'
+      else
+	lt_prog_compiler_static_F77='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+      darwin*)
+        # PIC is the default on this platform
+        # Common symbols not allowed in MH_DYLIB files
+       case $cc_basename in
+         xlc*)
+         lt_prog_compiler_pic_F77='-qnocommon'
+         lt_prog_compiler_wl_F77='-Wl,'
+         ;;
+       esac
+       ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic_F77='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic_F77='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static_F77='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static_F77='-non_shared'
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic_F77='-KPIC'
+      lt_prog_compiler_static_F77='-Bstatic'
+      ;;
+
+    linux*)
+      case $cc_basename in
+      icc* | ecc*)
+	lt_prog_compiler_wl_F77='-Wl,'
+	lt_prog_compiler_pic_F77='-KPIC'
+	lt_prog_compiler_static_F77='-static'
+        ;;
+      pgcc* | pgf77* | pgf90* | pgf95*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl_F77='-Wl,'
+	lt_prog_compiler_pic_F77='-fpic'
+	lt_prog_compiler_static_F77='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl_F77='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static_F77='-non_shared'
+        ;;
+      esac
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static_F77='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic_F77='-KPIC'
+      lt_prog_compiler_static_F77='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+	lt_prog_compiler_wl_F77='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl_F77='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl_F77='-Qoption ld '
+      lt_prog_compiler_pic_F77='-PIC'
+      lt_prog_compiler_static_F77='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      lt_prog_compiler_pic_F77='-KPIC'
+      lt_prog_compiler_static_F77='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	lt_prog_compiler_pic_F77='-Kconform_pic'
+	lt_prog_compiler_static_F77='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      lt_prog_compiler_pic_F77='-KPIC'
+      lt_prog_compiler_static_F77='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl_F77='-Wl,'
+      lt_prog_compiler_can_build_shared_F77=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic_F77='-pic'
+      lt_prog_compiler_static_F77='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared_F77=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_F77" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_F77" >&6
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_F77"; then
+
+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works" >&5
+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works... $ECHO_C" >&6
+if test "${lt_prog_compiler_pic_works_F77+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_pic_works_F77=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic_F77"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:12607: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:12611: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_prog_compiler_pic_works_F77=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_F77" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_works_F77" >&6
+
+if test x"$lt_prog_compiler_pic_works_F77" = xyes; then
+    case $lt_prog_compiler_pic_F77 in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic_F77=" $lt_prog_compiler_pic_F77" ;;
+     esac
+else
+    lt_prog_compiler_pic_F77=
+     lt_prog_compiler_can_build_shared_F77=no
+fi
+
+fi
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic_F77=
+    ;;
+  *)
+    lt_prog_compiler_pic_F77="$lt_prog_compiler_pic_F77"
+    ;;
+esac
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_F77 eval lt_tmp_static_flag=\"$lt_prog_compiler_static_F77\"
+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
+if test "${lt_prog_compiler_static_works_F77+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_static_works_F77=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_prog_compiler_static_works_F77=yes
+       fi
+     else
+       lt_prog_compiler_static_works_F77=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_F77" >&5
+echo "${ECHO_T}$lt_prog_compiler_static_works_F77" >&6
+
+if test x"$lt_prog_compiler_static_works_F77" = xyes; then
+    :
+else
+    lt_prog_compiler_static_F77=
+fi
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_c_o_F77+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_c_o_F77=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:12711: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:12715: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_F77=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_F77" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_F77" >&6
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o_F77" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  echo "$as_me:$LINENO: result: $hard_links" >&5
+echo "${ECHO_T}$hard_links" >&6
+  if test "$hard_links" = no; then
+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
+
+  runpath_var=
+  allow_undefined_flag_F77=
+  enable_shared_with_static_runtimes_F77=no
+  archive_cmds_F77=
+  archive_expsym_cmds_F77=
+  old_archive_From_new_cmds_F77=
+  old_archive_from_expsyms_cmds_F77=
+  export_dynamic_flag_spec_F77=
+  whole_archive_flag_spec_F77=
+  thread_safe_flag_spec_F77=
+  hardcode_libdir_flag_spec_F77=
+  hardcode_libdir_flag_spec_ld_F77=
+  hardcode_libdir_separator_F77=
+  hardcode_direct_F77=no
+  hardcode_minus_L_F77=no
+  hardcode_shlibpath_var_F77=unsupported
+  link_all_deplibs_F77=unknown
+  hardcode_automatic_F77=no
+  module_cmds_F77=
+  module_expsym_cmds_F77=
+  always_export_symbols_F77=no
+  export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms_F77=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  exclude_expsyms_F77="_GLOBAL_OFFSET_TABLE_"
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  extract_expsyms_cmds=
+  # Just being paranoid about ensuring that cc_basename is set.
+  for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+  case $host_os in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  ld_shlibs_F77=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec_F77='${wl}--rpath ${wl}$libdir'
+    export_dynamic_flag_spec_F77='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
+	whole_archive_flag_spec_F77="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+  	whole_archive_flag_spec_F77=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>/dev/null` in
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	ld_shlibs_F77=no
+	cat <<EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+EOF
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_minus_L_F77=yes
+
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we can't use
+      # them.
+      ld_shlibs_F77=no
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag_F77=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds_F77='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	ld_shlibs_F77=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, F77) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      allow_undefined_flag_F77=unsupported
+      always_export_symbols_F77=no
+      enable_shared_with_static_runtimes_F77=yes
+      export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	archive_expsym_cmds_F77='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs_F77=no
+      fi
+      ;;
+
+    interix3*)
+      hardcode_direct_F77=no
+      hardcode_shlibpath_var_F77=no
+      hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec_F77='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds_F77='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds_F77='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    linux*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	tmp_addflag=
+	case $cc_basename,$host_cpu in
+	pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec_F77='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec_F77='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	esac
+	archive_cmds_F77='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+	if test $supports_anon_versioning = yes; then
+	  archive_expsym_cmds_F77='$echo "{ global:" > $output_objdir/$libname.ver~
+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+  $echo "local: *; };" >> $output_objdir/$libname.ver~
+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+	fi
+      else
+	ld_shlibs_F77=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds_F77='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+	ld_shlibs_F77=no
+	cat <<EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+EOF
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs_F77=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs_F77=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec_F77='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+	    archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'
+	    archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'
+	  else
+	    ld_shlibs_F77=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds_F77='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs_F77=no
+      fi
+      ;;
+    esac
+
+    if test "$ld_shlibs_F77" = no; then
+      runpath_var=
+      hardcode_libdir_flag_spec_F77=
+      export_dynamic_flag_spec_F77=
+      whole_archive_flag_spec_F77=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag_F77=unsupported
+      always_export_symbols_F77=yes
+      archive_expsym_cmds_F77='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L_F77=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct_F77=unsupported
+      fi
+      ;;
+
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+	  export_symbols_cmds_F77='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds_F77='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+	  for ld_flag in $LDFLAGS; do
+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+  	    aix_use_runtimelinking=yes
+  	    break
+  	  fi
+	  done
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds_F77=''
+      hardcode_direct_F77=yes
+      hardcode_libdir_separator_F77=':'
+      link_all_deplibs_F77=yes
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" && \
+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	  then
+  	  # We have reworked collect2
+  	  hardcode_direct_F77=yes
+	  else
+  	  # We have old collect2
+  	  hardcode_direct_F77=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  hardcode_minus_L_F77=yes
+  	  hardcode_libdir_flag_spec_F77='-L$libdir'
+  	  hardcode_libdir_separator_F77=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag="$shared_flag "'${wl}-G'
+	fi
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+	  fi
+	fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols_F77=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag_F77='-berok'
+       # Determine the default libpath from the value encoded in an empty executable.
+       cat >conftest.$ac_ext <<_ACEOF
+      program main
+
+      end
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_f77_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+       hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath"
+	archive_expsym_cmds_F77="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+       else
+	if test "$host_cpu" = ia64; then
+	  hardcode_libdir_flag_spec_F77='${wl}-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag_F77="-z nodefs"
+	  archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an empty executable.
+	 cat >conftest.$ac_ext <<_ACEOF
+      program main
+
+      end
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_f77_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+	 hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag_F77=' ${wl}-bernotok'
+	  allow_undefined_flag_F77=' ${wl}-berok'
+	  # Exported symbols can be pulled into shared objects from archives
+	  whole_archive_flag_spec_F77='$convenience'
+	  archive_cmds_need_lc_F77=yes
+	  # This is similar to how AIX traditionally builds its shared libraries.
+	  archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_minus_L_F77=yes
+      # see comment about different semantics on the GNU ld section
+      ld_shlibs_F77=no
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec_F77=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec_F77=' '
+      allow_undefined_flag_F77=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      archive_cmds_F77='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      old_archive_From_new_cmds_F77='true'
+      # FIXME: Should let the user specify the lib program.
+      old_archive_cmds_F77='lib /OUT:$oldlib$oldobjs$old_deplibs'
+      fix_srcfile_path_F77='`cygpath -w "$srcfile"`'
+      enable_shared_with_static_runtimes_F77=yes
+      ;;
+
+    darwin* | rhapsody*)
+      case $host_os in
+        rhapsody* | darwin1.[012])
+         allow_undefined_flag_F77='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           allow_undefined_flag_F77='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[012])
+               allow_undefined_flag_F77='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               allow_undefined_flag_F77='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+      esac
+      archive_cmds_need_lc_F77=no
+      hardcode_direct_F77=no
+      hardcode_automatic_F77=yes
+      hardcode_shlibpath_var_F77=unsupported
+      whole_archive_flag_spec_F77=''
+      link_all_deplibs_F77=yes
+    if test "$GCC" = yes ; then
+    	output_verbose_link_cmd='echo'
+        archive_cmds_F77='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      module_cmds_F77='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+      archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+         archive_cmds_F77='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+         module_cmds_F77='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+         archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         ld_shlibs_F77=no
+          ;;
+      esac
+    fi
+      ;;
+
+    dgux*)
+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    freebsd1*)
+      ld_shlibs_F77=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec_F77='-R$libdir'
+      hardcode_direct_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct_F77=yes
+      hardcode_minus_L_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | kfreebsd*-gnu | dragonfly*)
+      archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec_F77='-R$libdir'
+      hardcode_direct_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	archive_cmds_F77='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds_F77='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator_F77=:
+      hardcode_direct_F77=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L_F77=yes
+      export_dynamic_flag_spec_F77='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_F77='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator_F77=:
+
+	hardcode_direct_F77=yes
+	export_dynamic_flag_spec_F77='${wl}-E'
+
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L_F77=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_F77='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator_F77=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_libdir_flag_spec_ld_F77='+b $libdir'
+	  hardcode_direct_F77=no
+	  hardcode_shlibpath_var_F77=no
+	  ;;
+	*)
+	  hardcode_direct_F77=yes
+	  export_dynamic_flag_spec_F77='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L_F77=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	archive_cmds_F77='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec_ld_F77='-rpath $libdir'
+      fi
+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_F77=:
+      link_all_deplibs_F77=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds_F77='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec_F77='-R$libdir'
+      hardcode_direct_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    newsos6)
+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct_F77=yes
+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_F77=:
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    openbsd*)
+      hardcode_direct_F77=yes
+      hardcode_shlibpath_var_F77=no
+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+	hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'
+	export_dynamic_flag_spec_F77='${wl}-E'
+      else
+       case $host_os in
+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+	   archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	   hardcode_libdir_flag_spec_F77='-R$libdir'
+	   ;;
+	 *)
+	   archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	   hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir'
+	   ;;
+       esac
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_minus_L_F77=yes
+      allow_undefined_flag_F77=unsupported
+      archive_cmds_F77='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      old_archive_From_new_cmds_F77='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	allow_undefined_flag_F77=' -expect_unresolved \*'
+	archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_F77=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir'
+      else
+	allow_undefined_flag_F77=' -expect_unresolved \*'
+	archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds_F77='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec_F77='-rpath $libdir'
+      fi
+      hardcode_libdir_separator_F77=:
+      ;;
+
+    solaris*)
+      no_undefined_flag_F77=' -z text'
+      if test "$GCC" = yes; then
+	wlarc='${wl}'
+	archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
+      else
+	wlarc=''
+	archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      fi
+      hardcode_libdir_flag_spec_F77='-R$libdir'
+      hardcode_shlibpath_var_F77=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+ 	# The compiler driver will combine linker options so we
+ 	# cannot just pass the convience library names through
+ 	# without $wl, iff we do not link with $LD.
+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.
+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)
+ 	case $wlarc in
+ 	'')
+ 	  whole_archive_flag_spec_F77='-z allextract$convenience -z defaultextract' ;;
+ 	*)
+ 	  whole_archive_flag_spec_F77='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;
+ 	esac ;;
+      esac
+      link_all_deplibs_F77=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds_F77='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_F77='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_direct_F77=yes
+      hardcode_minus_L_F77=yes
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct_F77=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds_F77='$CC -r -o $output$reload_objs'
+	  hardcode_direct_F77=no
+        ;;
+	motorola)
+	  archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct_F77=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var_F77=no
+      export_dynamic_flag_spec_F77='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var_F77=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs_F77=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)
+      no_undefined_flag_F77='${wl}-z,text'
+      archive_cmds_need_lc_F77=no
+      hardcode_shlibpath_var_F77=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds_F77='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_F77='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag_F77='${wl}-z,text'
+      allow_undefined_flag_F77='${wl}-z,nodefs'
+      archive_cmds_need_lc_F77=no
+      hardcode_shlibpath_var_F77=no
+      hardcode_libdir_flag_spec_F77='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      hardcode_libdir_separator_F77=':'
+      link_all_deplibs_F77=yes
+      export_dynamic_flag_spec_F77='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds_F77='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_F77='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_F77='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec_F77='-L$libdir'
+      hardcode_shlibpath_var_F77=no
+      ;;
+
+    *)
+      ld_shlibs_F77=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $ld_shlibs_F77" >&5
+echo "${ECHO_T}$ld_shlibs_F77" >&6
+test "$ld_shlibs_F77" = no && can_build_shared=no
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_F77" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc_F77=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $archive_cmds_F77 in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$lt_prog_compiler_wl_F77
+	pic_flag=$lt_prog_compiler_pic_F77
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$allow_undefined_flag_F77
+        allow_undefined_flag_F77=
+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
+  (eval $archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+        then
+	  archive_cmds_need_lc_F77=no
+        else
+	  archive_cmds_need_lc_F77=yes
+        fi
+        allow_undefined_flag_F77=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_F77" >&5
+echo "${ECHO_T}$archive_cmds_need_lc_F77" >&6
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  linux*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      supports_anon_versioning=no
+      case `$LD -v 2>/dev/null` in
+        *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test $supports_anon_versioning = yes; then
+        archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+$echo "local: *; };" >> $output_objdir/$libname.ver~
+        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        $archive_expsym_cmds="$archive_cmds"
+      fi
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[123]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  # Handle Gentoo/FreeBSD as it was Linux
+  case $host_vendor in
+    gentoo)
+      version_type=linux ;;
+    *)
+      version_type=freebsd-$objformat ;;
+  esac
+
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+    linux)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+      soname_spec='${libname}${release}${shared_ext}$major'
+      need_lib_prefix=no
+      need_version=no
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  freebsd*) # from 4.6 on
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix3*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+    *)                         need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[89] | openbsd2.[89].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      export_dynamic_flag_spec='${wl}-Blargedynsym'
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+    shlibpath_overrides_runpath=no
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    shlibpath_overrides_runpath=yes
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+echo "$as_me:$LINENO: result: $dynamic_linker" >&5
+echo "${ECHO_T}$dynamic_linker" >&6
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
+hardcode_action_F77=
+if test -n "$hardcode_libdir_flag_spec_F77" || \
+   test -n "$runpath_var_F77" || \
+   test "X$hardcode_automatic_F77" = "Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$hardcode_direct_F77" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, F77)" != no &&
+     test "$hardcode_minus_L_F77" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action_F77=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action_F77=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action_F77=unsupported
+fi
+echo "$as_me:$LINENO: result: $hardcode_action_F77" >&5
+echo "${ECHO_T}$hardcode_action_F77" >&6
+
+if test "$hardcode_action_F77" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    compiler_F77 \
+    CC_F77 \
+    LD_F77 \
+    lt_prog_compiler_wl_F77 \
+    lt_prog_compiler_pic_F77 \
+    lt_prog_compiler_static_F77 \
+    lt_prog_compiler_no_builtin_flag_F77 \
+    export_dynamic_flag_spec_F77 \
+    thread_safe_flag_spec_F77 \
+    whole_archive_flag_spec_F77 \
+    enable_shared_with_static_runtimes_F77 \
+    old_archive_cmds_F77 \
+    old_archive_from_new_cmds_F77 \
+    predep_objects_F77 \
+    postdep_objects_F77 \
+    predeps_F77 \
+    postdeps_F77 \
+    compiler_lib_search_path_F77 \
+    archive_cmds_F77 \
+    archive_expsym_cmds_F77 \
+    postinstall_cmds_F77 \
+    postuninstall_cmds_F77 \
+    old_archive_from_expsyms_cmds_F77 \
+    allow_undefined_flag_F77 \
+    no_undefined_flag_F77 \
+    export_symbols_cmds_F77 \
+    hardcode_libdir_flag_spec_F77 \
+    hardcode_libdir_flag_spec_ld_F77 \
+    hardcode_libdir_separator_F77 \
+    hardcode_automatic_F77 \
+    module_cmds_F77 \
+    module_expsym_cmds_F77 \
+    lt_cv_prog_compiler_c_o_F77 \
+    exclude_expsyms_F77 \
+    include_expsyms_F77; do
+
+    case $var in
+    old_archive_cmds_F77 | \
+    old_archive_from_new_cmds_F77 | \
+    archive_cmds_F77 | \
+    archive_expsym_cmds_F77 | \
+    module_cmds_F77 | \
+    module_expsym_cmds_F77 | \
+    old_archive_from_expsyms_cmds_F77 | \
+    export_symbols_cmds_F77 | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\$0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+cfgfile="$ofile"
+
+  cat <<__EOF__ >> "$cfgfile"
+# ### BEGIN LIBTOOL TAG CONFIG: $tagname
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_F77
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_F77
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_compiler_F77
+
+# Is the compiler the GNU C compiler?
+with_gcc=$GCC_F77
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_LD_F77
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_F77
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_F77
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_F77
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_F77
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_F77
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_F77
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_F77
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_thread_safe_flag_spec_F77
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_old_archive_cmds_F77
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_F77
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_F77
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_archive_cmds_F77
+archive_expsym_cmds=$lt_archive_expsym_cmds_F77
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_module_cmds_F77
+module_expsym_cmds=$lt_module_expsym_cmds_F77
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_predep_objects_F77
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_postdep_objects_F77
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_predeps_F77
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_postdeps_F77
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_F77
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_F77
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_F77
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_F77
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_F77
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_F77
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_F77
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct_F77
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L_F77
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_F77
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$hardcode_automatic_F77
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_F77
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path_F77"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols_F77
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_F77
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_F77
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_F77
+
+# ### END LIBTOOL TAG CONFIG: $tagname
+
+__EOF__
+
+
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+	else
+	  tagname=""
+	fi
+	;;
+
+      GCJ)
+	if test -n "$GCJ" && test "X$GCJ" != "Xno"; then
+
+
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+objext_GCJ=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${GCJ-"gcj"}
+compiler=$CC
+compiler_GCJ=$CC
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+archive_cmds_need_lc_GCJ=no
+
+old_archive_cmds_GCJ=$old_archive_cmds
+
+
+lt_prog_compiler_no_builtin_flag_GCJ=
+
+if test "$GCC" = yes; then
+  lt_prog_compiler_no_builtin_flag_GCJ=' -fno-builtin'
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_rtti_exceptions=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:14951: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:14955: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6
+
+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
+    lt_prog_compiler_no_builtin_flag_GCJ="$lt_prog_compiler_no_builtin_flag_GCJ -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+lt_prog_compiler_wl_GCJ=
+lt_prog_compiler_pic_GCJ=
+lt_prog_compiler_static_GCJ=
+
+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
+echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
+
+  if test "$GCC" = yes; then
+    lt_prog_compiler_wl_GCJ='-Wl,'
+    lt_prog_compiler_static_GCJ='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_GCJ='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      # FIXME: we need at least 68020 code to build shared libraries, but
+      # adding the `-m68020' flag to GCC prevents building anything better,
+      # like `-m68040'.
+      lt_prog_compiler_pic_GCJ='-m68020 -resident32 -malways-restore-a4'
+      ;;
+
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic_GCJ='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic_GCJ='-fno-common'
+      ;;
+
+    interix3*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared_GCJ=no
+      enable_shared=no
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic_GCJ=-Kconform_pic
+      fi
+      ;;
+
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic_GCJ='-fPIC'
+	;;
+      esac
+      ;;
+
+    *)
+      lt_prog_compiler_pic_GCJ='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_GCJ='-Bstatic'
+      else
+	lt_prog_compiler_static_GCJ='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+      darwin*)
+        # PIC is the default on this platform
+        # Common symbols not allowed in MH_DYLIB files
+       case $cc_basename in
+         xlc*)
+         lt_prog_compiler_pic_GCJ='-qnocommon'
+         lt_prog_compiler_wl_GCJ='-Wl,'
+         ;;
+       esac
+       ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic_GCJ='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic_GCJ='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static_GCJ='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static_GCJ='-non_shared'
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic_GCJ='-KPIC'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      ;;
+
+    linux*)
+      case $cc_basename in
+      icc* | ecc*)
+	lt_prog_compiler_wl_GCJ='-Wl,'
+	lt_prog_compiler_pic_GCJ='-KPIC'
+	lt_prog_compiler_static_GCJ='-static'
+        ;;
+      pgcc* | pgf77* | pgf90* | pgf95*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl_GCJ='-Wl,'
+	lt_prog_compiler_pic_GCJ='-fpic'
+	lt_prog_compiler_static_GCJ='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl_GCJ='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static_GCJ='-non_shared'
+        ;;
+      esac
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static_GCJ='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic_GCJ='-KPIC'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+	lt_prog_compiler_wl_GCJ='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl_GCJ='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl_GCJ='-Qoption ld '
+      lt_prog_compiler_pic_GCJ='-PIC'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      lt_prog_compiler_pic_GCJ='-KPIC'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	lt_prog_compiler_pic_GCJ='-Kconform_pic'
+	lt_prog_compiler_static_GCJ='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      lt_prog_compiler_pic_GCJ='-KPIC'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl_GCJ='-Wl,'
+      lt_prog_compiler_can_build_shared_GCJ=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic_GCJ='-pic'
+      lt_prog_compiler_static_GCJ='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared_GCJ=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_GCJ" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_GCJ" >&6
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_GCJ"; then
+
+echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works" >&5
+echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works... $ECHO_C" >&6
+if test "${lt_prog_compiler_pic_works_GCJ+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_pic_works_GCJ=no
+  ac_outfile=conftest.$ac_objext
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic_GCJ"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:15219: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:15223: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_prog_compiler_pic_works_GCJ=yes
+     fi
+   fi
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works_GCJ" >&5
+echo "${ECHO_T}$lt_prog_compiler_pic_works_GCJ" >&6
+
+if test x"$lt_prog_compiler_pic_works_GCJ" = xyes; then
+    case $lt_prog_compiler_pic_GCJ in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic_GCJ=" $lt_prog_compiler_pic_GCJ" ;;
+     esac
+else
+    lt_prog_compiler_pic_GCJ=
+     lt_prog_compiler_can_build_shared_GCJ=no
+fi
+
+fi
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic_GCJ=
+    ;;
+  *)
+    lt_prog_compiler_pic_GCJ="$lt_prog_compiler_pic_GCJ"
+    ;;
+esac
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_GCJ eval lt_tmp_static_flag=\"$lt_prog_compiler_static_GCJ\"
+echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
+if test "${lt_prog_compiler_static_works_GCJ+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_prog_compiler_static_works_GCJ=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_prog_compiler_static_works_GCJ=yes
+       fi
+     else
+       lt_prog_compiler_static_works_GCJ=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works_GCJ" >&5
+echo "${ECHO_T}$lt_prog_compiler_static_works_GCJ" >&6
+
+if test x"$lt_prog_compiler_static_works_GCJ" = xyes; then
+    :
+else
+    lt_prog_compiler_static_GCJ=
+fi
+
+
+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
+echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
+if test "${lt_cv_prog_compiler_c_o_GCJ+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_prog_compiler_c_o_GCJ=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:15323: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:15327: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_GCJ=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o_GCJ" >&5
+echo "${ECHO_T}$lt_cv_prog_compiler_c_o_GCJ" >&6
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o_GCJ" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
+echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  echo "$as_me:$LINENO: result: $hard_links" >&5
+echo "${ECHO_T}$hard_links" >&6
+  if test "$hard_links" = no; then
+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
+
+  runpath_var=
+  allow_undefined_flag_GCJ=
+  enable_shared_with_static_runtimes_GCJ=no
+  archive_cmds_GCJ=
+  archive_expsym_cmds_GCJ=
+  old_archive_From_new_cmds_GCJ=
+  old_archive_from_expsyms_cmds_GCJ=
+  export_dynamic_flag_spec_GCJ=
+  whole_archive_flag_spec_GCJ=
+  thread_safe_flag_spec_GCJ=
+  hardcode_libdir_flag_spec_GCJ=
+  hardcode_libdir_flag_spec_ld_GCJ=
+  hardcode_libdir_separator_GCJ=
+  hardcode_direct_GCJ=no
+  hardcode_minus_L_GCJ=no
+  hardcode_shlibpath_var_GCJ=unsupported
+  link_all_deplibs_GCJ=unknown
+  hardcode_automatic_GCJ=no
+  module_cmds_GCJ=
+  module_expsym_cmds_GCJ=
+  always_export_symbols_GCJ=no
+  export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms_GCJ=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  exclude_expsyms_GCJ="_GLOBAL_OFFSET_TABLE_"
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  extract_expsyms_cmds=
+  # Just being paranoid about ensuring that cc_basename is set.
+  for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+  case $host_os in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  ld_shlibs_GCJ=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec_GCJ='${wl}--rpath ${wl}$libdir'
+    export_dynamic_flag_spec_GCJ='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
+	whole_archive_flag_spec_GCJ="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+  	whole_archive_flag_spec_GCJ=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>/dev/null` in
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	ld_shlibs_GCJ=no
+	cat <<EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+EOF
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_minus_L_GCJ=yes
+
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we can't use
+      # them.
+      ld_shlibs_GCJ=no
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag_GCJ=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds_GCJ='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	ld_shlibs_GCJ=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, GCJ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      allow_undefined_flag_GCJ=unsupported
+      always_export_symbols_GCJ=no
+      enable_shared_with_static_runtimes_GCJ=yes
+      export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	archive_expsym_cmds_GCJ='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs_GCJ=no
+      fi
+      ;;
+
+    interix3*)
+      hardcode_direct_GCJ=no
+      hardcode_shlibpath_var_GCJ=no
+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec_GCJ='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds_GCJ='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds_GCJ='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    linux*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	tmp_addflag=
+	case $cc_basename,$host_cpu in
+	pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec_GCJ='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95*)	# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec_GCJ='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)		# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	esac
+	archive_cmds_GCJ='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+	if test $supports_anon_versioning = yes; then
+	  archive_expsym_cmds_GCJ='$echo "{ global:" > $output_objdir/$libname.ver~
+  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+  $echo "local: *; };" >> $output_objdir/$libname.ver~
+	  $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+	fi
+      else
+	ld_shlibs_GCJ=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds_GCJ='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+	ld_shlibs_GCJ=no
+	cat <<EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+EOF
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs_GCJ=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs_GCJ=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec_GCJ='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+	    archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'
+	    archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'
+	  else
+	    ld_shlibs_GCJ=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds_GCJ='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs_GCJ=no
+      fi
+      ;;
+    esac
+
+    if test "$ld_shlibs_GCJ" = no; then
+      runpath_var=
+      hardcode_libdir_flag_spec_GCJ=
+      export_dynamic_flag_spec_GCJ=
+      whole_archive_flag_spec_GCJ=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag_GCJ=unsupported
+      always_export_symbols_GCJ=yes
+      archive_expsym_cmds_GCJ='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L_GCJ=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct_GCJ=unsupported
+      fi
+      ;;
+
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	if $NM -V 2>&1 | grep 'GNU' > /dev/null; then
+	  export_symbols_cmds_GCJ='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds_GCJ='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+	  for ld_flag in $LDFLAGS; do
+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+  	    aix_use_runtimelinking=yes
+  	    break
+  	  fi
+	  done
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds_GCJ=''
+      hardcode_direct_GCJ=yes
+      hardcode_libdir_separator_GCJ=':'
+      link_all_deplibs_GCJ=yes
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" && \
+  	   strings "$collect2name" | grep resolve_lib_name >/dev/null
+	  then
+  	  # We have reworked collect2
+  	  hardcode_direct_GCJ=yes
+	  else
+  	  # We have old collect2
+  	  hardcode_direct_GCJ=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  hardcode_minus_L_GCJ=yes
+  	  hardcode_libdir_flag_spec_GCJ='-L$libdir'
+  	  hardcode_libdir_separator_GCJ=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag="$shared_flag "'${wl}-G'
+	fi
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+	  fi
+	fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols_GCJ=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag_GCJ='-berok'
+       # Determine the default libpath from the value encoded in an empty executable.
+       cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+       hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath"
+	archive_expsym_cmds_GCJ="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+       else
+	if test "$host_cpu" = ia64; then
+	  hardcode_libdir_flag_spec_GCJ='${wl}-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag_GCJ="-z nodefs"
+	  archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an empty executable.
+	 cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+	 hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag_GCJ=' ${wl}-bernotok'
+	  allow_undefined_flag_GCJ=' ${wl}-berok'
+	  # Exported symbols can be pulled into shared objects from archives
+	  whole_archive_flag_spec_GCJ='$convenience'
+	  archive_cmds_need_lc_GCJ=yes
+	  # This is similar to how AIX traditionally builds its shared libraries.
+	  archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_minus_L_GCJ=yes
+      # see comment about different semantics on the GNU ld section
+      ld_shlibs_GCJ=no
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec_GCJ=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec_GCJ=' '
+      allow_undefined_flag_GCJ=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      archive_cmds_GCJ='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      old_archive_From_new_cmds_GCJ='true'
+      # FIXME: Should let the user specify the lib program.
+      old_archive_cmds_GCJ='lib /OUT:$oldlib$oldobjs$old_deplibs'
+      fix_srcfile_path_GCJ='`cygpath -w "$srcfile"`'
+      enable_shared_with_static_runtimes_GCJ=yes
+      ;;
+
+    darwin* | rhapsody*)
+      case $host_os in
+        rhapsody* | darwin1.[012])
+         allow_undefined_flag_GCJ='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           allow_undefined_flag_GCJ='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[012])
+               allow_undefined_flag_GCJ='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               allow_undefined_flag_GCJ='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+      esac
+      archive_cmds_need_lc_GCJ=no
+      hardcode_direct_GCJ=no
+      hardcode_automatic_GCJ=yes
+      hardcode_shlibpath_var_GCJ=unsupported
+      whole_archive_flag_spec_GCJ=''
+      link_all_deplibs_GCJ=yes
+    if test "$GCC" = yes ; then
+    	output_verbose_link_cmd='echo'
+        archive_cmds_GCJ='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      module_cmds_GCJ='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+      archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    else
+      case $cc_basename in
+        xlc*)
+         output_verbose_link_cmd='echo'
+         archive_cmds_GCJ='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+         module_cmds_GCJ='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
+         archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         ld_shlibs_GCJ=no
+          ;;
+      esac
+    fi
+      ;;
+
+    dgux*)
+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    freebsd1*)
+      ld_shlibs_GCJ=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec_GCJ='-R$libdir'
+      hardcode_direct_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct_GCJ=yes
+      hardcode_minus_L_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | kfreebsd*-gnu | dragonfly*)
+      archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec_GCJ='-R$libdir'
+      hardcode_direct_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	archive_cmds_GCJ='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds_GCJ='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator_GCJ=:
+      hardcode_direct_GCJ=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L_GCJ=yes
+      export_dynamic_flag_spec_GCJ='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_GCJ='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator_GCJ=:
+
+	hardcode_direct_GCJ=yes
+	export_dynamic_flag_spec_GCJ='${wl}-E'
+
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L_GCJ=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_GCJ='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator_GCJ=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_libdir_flag_spec_ld_GCJ='+b $libdir'
+	  hardcode_direct_GCJ=no
+	  hardcode_shlibpath_var_GCJ=no
+	  ;;
+	*)
+	  hardcode_direct_GCJ=yes
+	  export_dynamic_flag_spec_GCJ='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L_GCJ=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	archive_cmds_GCJ='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec_ld_GCJ='-rpath $libdir'
+      fi
+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_GCJ=:
+      link_all_deplibs_GCJ=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+	archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds_GCJ='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec_GCJ='-R$libdir'
+      hardcode_direct_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    newsos6)
+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct_GCJ=yes
+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_GCJ=:
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    openbsd*)
+      hardcode_direct_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+	hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'
+	export_dynamic_flag_spec_GCJ='${wl}-E'
+      else
+       case $host_os in
+	 openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+	   archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	   hardcode_libdir_flag_spec_GCJ='-R$libdir'
+	   ;;
+	 *)
+	   archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	   hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir'
+	   ;;
+       esac
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_minus_L_GCJ=yes
+      allow_undefined_flag_GCJ=unsupported
+      archive_cmds_GCJ='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      old_archive_From_new_cmds_GCJ='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	allow_undefined_flag_GCJ=' -expect_unresolved \*'
+	archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator_GCJ=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir'
+      else
+	allow_undefined_flag_GCJ=' -expect_unresolved \*'
+	archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds_GCJ='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec_GCJ='-rpath $libdir'
+      fi
+      hardcode_libdir_separator_GCJ=:
+      ;;
+
+    solaris*)
+      no_undefined_flag_GCJ=' -z text'
+      if test "$GCC" = yes; then
+	wlarc='${wl}'
+	archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
+      else
+	wlarc=''
+	archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      fi
+      hardcode_libdir_flag_spec_GCJ='-R$libdir'
+      hardcode_shlibpath_var_GCJ=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+ 	# The compiler driver will combine linker options so we
+ 	# cannot just pass the convience library names through
+ 	# without $wl, iff we do not link with $LD.
+ 	# Luckily, gcc supports the same syntax we need for Sun Studio.
+ 	# Supported since Solaris 2.6 (maybe 2.5.1?)
+ 	case $wlarc in
+ 	'')
+ 	  whole_archive_flag_spec_GCJ='-z allextract$convenience -z defaultextract' ;;
+ 	*)
+ 	  whole_archive_flag_spec_GCJ='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;
+ 	esac ;;
+      esac
+      link_all_deplibs_GCJ=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds_GCJ='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_GCJ='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_direct_GCJ=yes
+      hardcode_minus_L_GCJ=yes
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct_GCJ=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds_GCJ='$CC -r -o $output$reload_objs'
+	  hardcode_direct_GCJ=no
+        ;;
+	motorola)
+	  archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct_GCJ=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var_GCJ=no
+      export_dynamic_flag_spec_GCJ='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var_GCJ=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs_GCJ=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)
+      no_undefined_flag_GCJ='${wl}-z,text'
+      archive_cmds_need_lc_GCJ=no
+      hardcode_shlibpath_var_GCJ=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds_GCJ='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_GCJ='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag_GCJ='${wl}-z,text'
+      allow_undefined_flag_GCJ='${wl}-z,nodefs'
+      archive_cmds_need_lc_GCJ=no
+      hardcode_shlibpath_var_GCJ=no
+      hardcode_libdir_flag_spec_GCJ='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      hardcode_libdir_separator_GCJ=':'
+      link_all_deplibs_GCJ=yes
+      export_dynamic_flag_spec_GCJ='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds_GCJ='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds_GCJ='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds_GCJ='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec_GCJ='-L$libdir'
+      hardcode_shlibpath_var_GCJ=no
+      ;;
+
+    *)
+      ld_shlibs_GCJ=no
+      ;;
+    esac
+  fi
+
+echo "$as_me:$LINENO: result: $ld_shlibs_GCJ" >&5
+echo "${ECHO_T}$ld_shlibs_GCJ" >&6
+test "$ld_shlibs_GCJ" = no && can_build_shared=no
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_GCJ" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc_GCJ=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $archive_cmds_GCJ in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
+echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$lt_prog_compiler_wl_GCJ
+	pic_flag=$lt_prog_compiler_pic_GCJ
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$allow_undefined_flag_GCJ
+        allow_undefined_flag_GCJ=
+        if { (eval echo "$as_me:$LINENO: \"$archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
+  (eval $archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+        then
+	  archive_cmds_need_lc_GCJ=no
+        else
+	  archive_cmds_need_lc_GCJ=yes
+        fi
+        allow_undefined_flag_GCJ=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      echo "$as_me:$LINENO: result: $archive_cmds_need_lc_GCJ" >&5
+echo "${ECHO_T}$archive_cmds_need_lc_GCJ" >&6
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
+echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  linux*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      supports_anon_versioning=no
+      case `$LD -v 2>/dev/null` in
+        *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test $supports_anon_versioning = yes; then
+        archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~
+cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+$echo "local: *; };" >> $output_objdir/$libname.ver~
+        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        $archive_expsym_cmds="$archive_cmds"
+      fi
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[123]*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  # Handle Gentoo/FreeBSD as it was Linux
+  case $host_vendor in
+    gentoo)
+      version_type=linux ;;
+    *)
+      version_type=freebsd-$objformat ;;
+  esac
+
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+    linux)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+      soname_spec='${libname}${release}${shared_ext}$major'
+      need_lib_prefix=no
+      need_version=no
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  freebsd*) # from 4.6 on
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+interix3*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+    *)                         need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[89] | openbsd2.[89].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      export_dynamic_flag_spec='${wl}-Blargedynsym'
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+    shlibpath_overrides_runpath=no
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    shlibpath_overrides_runpath=yes
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+echo "$as_me:$LINENO: result: $dynamic_linker" >&5
+echo "${ECHO_T}$dynamic_linker" >&6
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
+echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
+hardcode_action_GCJ=
+if test -n "$hardcode_libdir_flag_spec_GCJ" || \
+   test -n "$runpath_var_GCJ" || \
+   test "X$hardcode_automatic_GCJ" = "Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$hardcode_direct_GCJ" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, GCJ)" != no &&
+     test "$hardcode_minus_L_GCJ" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action_GCJ=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action_GCJ=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action_GCJ=unsupported
+fi
+echo "$as_me:$LINENO: result: $hardcode_action_GCJ" >&5
+echo "${ECHO_T}$hardcode_action_GCJ" >&6
+
+if test "$hardcode_action_GCJ" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    compiler_GCJ \
+    CC_GCJ \
+    LD_GCJ \
+    lt_prog_compiler_wl_GCJ \
+    lt_prog_compiler_pic_GCJ \
+    lt_prog_compiler_static_GCJ \
+    lt_prog_compiler_no_builtin_flag_GCJ \
+    export_dynamic_flag_spec_GCJ \
+    thread_safe_flag_spec_GCJ \
+    whole_archive_flag_spec_GCJ \
+    enable_shared_with_static_runtimes_GCJ \
+    old_archive_cmds_GCJ \
+    old_archive_from_new_cmds_GCJ \
+    predep_objects_GCJ \
+    postdep_objects_GCJ \
+    predeps_GCJ \
+    postdeps_GCJ \
+    compiler_lib_search_path_GCJ \
+    archive_cmds_GCJ \
+    archive_expsym_cmds_GCJ \
+    postinstall_cmds_GCJ \
+    postuninstall_cmds_GCJ \
+    old_archive_from_expsyms_cmds_GCJ \
+    allow_undefined_flag_GCJ \
+    no_undefined_flag_GCJ \
+    export_symbols_cmds_GCJ \
+    hardcode_libdir_flag_spec_GCJ \
+    hardcode_libdir_flag_spec_ld_GCJ \
+    hardcode_libdir_separator_GCJ \
+    hardcode_automatic_GCJ \
+    module_cmds_GCJ \
+    module_expsym_cmds_GCJ \
+    lt_cv_prog_compiler_c_o_GCJ \
+    exclude_expsyms_GCJ \
+    include_expsyms_GCJ; do
+
+    case $var in
+    old_archive_cmds_GCJ | \
+    old_archive_from_new_cmds_GCJ | \
+    archive_cmds_GCJ | \
+    archive_expsym_cmds_GCJ | \
+    module_cmds_GCJ | \
+    module_expsym_cmds_GCJ | \
+    old_archive_from_expsyms_cmds_GCJ | \
+    export_symbols_cmds_GCJ | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\$0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+cfgfile="$ofile"
+
+  cat <<__EOF__ >> "$cfgfile"
+# ### BEGIN LIBTOOL TAG CONFIG: $tagname
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_GCJ
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_GCJ
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_compiler_GCJ
+
+# Is the compiler the GNU C compiler?
+with_gcc=$GCC_GCJ
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_LD_GCJ
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_GCJ
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_GCJ
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_GCJ
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_GCJ
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_GCJ
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_GCJ
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_GCJ
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_thread_safe_flag_spec_GCJ
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_old_archive_cmds_GCJ
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_GCJ
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_GCJ
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_archive_cmds_GCJ
+archive_expsym_cmds=$lt_archive_expsym_cmds_GCJ
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_module_cmds_GCJ
+module_expsym_cmds=$lt_module_expsym_cmds_GCJ
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_predep_objects_GCJ
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_postdep_objects_GCJ
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_predeps_GCJ
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_postdeps_GCJ
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_GCJ
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_GCJ
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_GCJ
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_GCJ
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_GCJ
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_GCJ
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_GCJ
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct_GCJ
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L_GCJ
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_GCJ
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$hardcode_automatic_GCJ
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_GCJ
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path_GCJ"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols_GCJ
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_GCJ
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_GCJ
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_GCJ
+
+# ### END LIBTOOL TAG CONFIG: $tagname
+
+__EOF__
+
+
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+	else
+	  tagname=""
+	fi
+	;;
+
+      RC)
+
+
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+objext_RC=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="$lt_simple_compile_test_code"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$rm conftest*
+
+ac_outfile=conftest.$ac_objext
+printf "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$rm conftest*
+
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${RC-"windres"}
+compiler=$CC
+compiler_RC=$CC
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
+
+lt_cv_prog_compiler_c_o_RC=yes
+
+# The else clause should only fire when bootstrapping the
+# libtool distribution, otherwise you forgot to ship ltmain.sh
+# with your package, and you will get complaints that there are
+# no rules to generate ltmain.sh.
+if test -f "$ltmain"; then
+  # See if we are running on zsh, and set the options which allow our commands through
+  # without removal of \ escapes.
+  if test -n "${ZSH_VERSION+set}" ; then
+    setopt NO_GLOB_SUBST
+  fi
+  # Now quote all the things that may contain metacharacters while being
+  # careful not to overquote the AC_SUBSTed values.  We take copies of the
+  # variables and quote the copies for generation of the libtool script.
+  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
+    SED SHELL STRIP \
+    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
+    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
+    deplibs_check_method reload_flag reload_cmds need_locks \
+    lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
+    lt_cv_sys_global_symbol_to_c_name_address \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    old_postinstall_cmds old_postuninstall_cmds \
+    compiler_RC \
+    CC_RC \
+    LD_RC \
+    lt_prog_compiler_wl_RC \
+    lt_prog_compiler_pic_RC \
+    lt_prog_compiler_static_RC \
+    lt_prog_compiler_no_builtin_flag_RC \
+    export_dynamic_flag_spec_RC \
+    thread_safe_flag_spec_RC \
+    whole_archive_flag_spec_RC \
+    enable_shared_with_static_runtimes_RC \
+    old_archive_cmds_RC \
+    old_archive_from_new_cmds_RC \
+    predep_objects_RC \
+    postdep_objects_RC \
+    predeps_RC \
+    postdeps_RC \
+    compiler_lib_search_path_RC \
+    archive_cmds_RC \
+    archive_expsym_cmds_RC \
+    postinstall_cmds_RC \
+    postuninstall_cmds_RC \
+    old_archive_from_expsyms_cmds_RC \
+    allow_undefined_flag_RC \
+    no_undefined_flag_RC \
+    export_symbols_cmds_RC \
+    hardcode_libdir_flag_spec_RC \
+    hardcode_libdir_flag_spec_ld_RC \
+    hardcode_libdir_separator_RC \
+    hardcode_automatic_RC \
+    module_cmds_RC \
+    module_expsym_cmds_RC \
+    lt_cv_prog_compiler_c_o_RC \
+    exclude_expsyms_RC \
+    include_expsyms_RC; do
+
+    case $var in
+    old_archive_cmds_RC | \
+    old_archive_from_new_cmds_RC | \
+    archive_cmds_RC | \
+    archive_expsym_cmds_RC | \
+    module_cmds_RC | \
+    module_expsym_cmds_RC | \
+    old_archive_from_expsyms_cmds_RC | \
+    export_symbols_cmds_RC | \
+    extract_expsyms_cmds | reload_cmds | finish_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case $lt_echo in
+  *'\$0 --fallback-echo"')
+    lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+cfgfile="$ofile"
+
+  cat <<__EOF__ >> "$cfgfile"
+# ### BEGIN LIBTOOL TAG CONFIG: $tagname
+
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_RC
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_RC
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# An echo program that does not interpret backslashes.
+echo=$lt_echo
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A C compiler.
+LTCC=$lt_LTCC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_LTCFLAGS
+
+# A language-specific compiler.
+CC=$lt_compiler_RC
+
+# Is the compiler the GNU C compiler?
+with_gcc=$GCC_RC
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# The linker used to build libraries.
+LD=$lt_LD_RC
+
+# Whether we need hard or soft links.
+LN_S=$lt_LN_S
+
+# A BSD-compatible nm program.
+NM=$lt_NM
+
+# A symbol stripping program
+STRIP=$lt_STRIP
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=$MAGIC_CMD
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_RC
+
+# Object file suffix (normally "o").
+objext="$ac_objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='$shrext_cmds'
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_RC
+pic_mode=$pic_mode
+
+# What is the maximum length of a command?
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_RC
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_RC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_RC
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_RC
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_RC
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$lt_thread_safe_flag_spec_RC
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$lt_RANLIB
+old_archive_cmds=$lt_old_archive_cmds_RC
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_RC
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_RC
+
+# Commands used to build and install a shared archive.
+archive_cmds=$lt_archive_cmds_RC
+archive_expsym_cmds=$lt_archive_expsym_cmds_RC
+postinstall_cmds=$lt_postinstall_cmds
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=$lt_module_cmds_RC
+module_expsym_cmds=$lt_module_expsym_cmds_RC
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=$lt_predep_objects_RC
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=$lt_postdep_objects_RC
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=$lt_predeps_RC
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=$lt_postdeps_RC
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_RC
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$lt_file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_RC
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_RC
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$lt_finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_RC
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC
+
+# If ld is used when linking, flag to hardcode \$libdir into
+# a binary during linking. This must work even if \$libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_RC
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC
+
+# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct_RC
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L_RC
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_RC
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=$hardcode_automatic_RC
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="$variables_saved_for_relink"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_RC
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path_RC"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols_RC
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_RC
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_RC
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_RC
+
+# ### END LIBTOOL TAG CONFIG: $tagname
+
+__EOF__
+
+
+else
+  # If there is no Makefile yet, we rely on a make rule to execute
+  # `config.status --recheck' to rerun these tests and create the
+  # libtool script then.
+  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
+  if test -f "$ltmain_in"; then
+    test -f Makefile && make "$ltmain"
+  fi
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+	;;
+
+      *)
+	{ { echo "$as_me:$LINENO: error: Unsupported tag name: $tagname" >&5
+echo "$as_me: error: Unsupported tag name: $tagname" >&2;}
+   { (exit 1); exit 1; }; }
+	;;
+      esac
+
+      # Append the new tag name to the list of available tags.
+      if test -n "$tagname" ; then
+      available_tags="$available_tags $tagname"
+    fi
+    fi
+  done
+  IFS="$lt_save_ifs"
+
+  # Now substitute the updated list of available tags.
+  if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then
+    mv "${ofile}T" "$ofile"
+    chmod +x "$ofile"
+  else
+    rm -f "${ofile}T"
+    { { echo "$as_me:$LINENO: error: unable to update list of available tagged configurations." >&5
+echo "$as_me: error: unable to update list of available tagged configurations." >&2;}
+   { (exit 1); exit 1; }; }
+  fi
+fi
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+# Prevent multiple expansion
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
+if test -z "$INSTALL"; then
+if test "${ac_cv_path_install+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in
+  ./ | .// | /cC/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	    break 3
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+done
+
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  We don't cache a
+    # path for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the path is relative.
+    INSTALL=$ac_install_sh
+  fi
+fi
+echo "$as_me:$LINENO: result: $INSTALL" >&5
+echo "${ECHO_T}$INSTALL" >&6
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_AWK+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  echo "$as_me:$LINENO: result: $AWK" >&5
+echo "${ECHO_T}$AWK" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$AWK" && break
+done
+
+
+#########
+# Set up an appropriate program prefix
+#
+if test "$program_prefix" = "NONE"; then
+  program_prefix=""
+fi
+
+
+VERSION=`cat $srcdir/VERSION | sed 's/^\([0-9]*\.*[0-9]*\).*/\1/'`
+echo "Version set to $VERSION"
+
+RELEASE=`cat $srcdir/VERSION`
+echo "Release set to $RELEASE"
+
+VERSION_NUMBER=`cat $srcdir/VERSION  \
+                           | sed 's/[^0-9]/ /g' \
+                | awk '{printf "%d%03d%03d",$1,$2,$3}'`
+echo "Version number set to $VERSION_NUMBER"
+
+
+#########
+# Check to see if the --with-hints=FILE option is used.  If there is none,
+# then check for a files named "$host.hints" and ../$hosts.hints where
+# $host is the hostname of the build system.  If still no hints are
+# found, try looking in $system.hints and ../$system.hints where
+# $system is the result of uname -s.
+#
+
+# Check whether --with-hints or --without-hints was given.
+if test "${with_hints+set}" = set; then
+  withval="$with_hints"
+  hints=$withval
+fi;
+if test "$hints" = ""; then
+  host=`hostname | sed 's/\..*//'`
+  if test -r $host.hints; then
+    hints=$host.hints
+  else
+     if test -r ../$host.hints; then
+       hints=../$host.hints
+     fi
+  fi
+fi
+if test "$hints" = ""; then
+  sys=`uname -s`
+  if test -r $sys.hints; then
+    hints=$sys.hints
+  else
+     if test -r ../$sys.hints; then
+       hints=../$sys.hints
+     fi
+  fi
+fi
+if test "$hints" != ""; then
+  echo "$as_me:$LINENO: result: reading hints from $hints" >&5
+echo "${ECHO_T}reading hints from $hints" >&6
+  . $hints
+fi
+
+#########
+# Locate a compiler for the build machine.  This compiler should
+# generate command-line programs that run on the build machine.
+#
+if test x"$cross_compiling" = xno; then
+	BUILD_CC=$CC
+	BUILD_CFLAGS=$CFLAGS
+else
+	if test "${BUILD_CC+set}" != set; then
+		for ac_prog in gcc cc cl
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_BUILD_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$BUILD_CC"; then
+  ac_cv_prog_BUILD_CC="$BUILD_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_BUILD_CC="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+BUILD_CC=$ac_cv_prog_BUILD_CC
+if test -n "$BUILD_CC"; then
+  echo "$as_me:$LINENO: result: $BUILD_CC" >&5
+echo "${ECHO_T}$BUILD_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$BUILD_CC" && break
+done
+
+	fi
+	if test "${BUILD_CFLAGS+set}" != set; then
+		BUILD_CFLAGS="-g"
+	fi
+fi
+
+
+
+##########
+# Do we want to support multithreaded use of sqlite
+#
+# Check whether --enable-threadsafe or --disable-threadsafe was given.
+if test "${enable_threadsafe+set}" = set; then
+  enableval="$enable_threadsafe"
+
+else
+  enable_threadsafe=yes
+fi;
+echo "$as_me:$LINENO: checking whether to support threadsafe operation" >&5
+echo $ECHO_N "checking whether to support threadsafe operation... $ECHO_C" >&6
+if test "$enable_threadsafe" = "no"; then
+  SQLITE_THREADSAFE=0
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+else
+  SQLITE_THREADSAFE=1
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+fi
+
+
+if test "$SQLITE_THREADSAFE" = "1"; then
+  LIBS=""
+
+echo "$as_me:$LINENO: checking for pthread_create in -lpthread" >&5
+echo $ECHO_N "checking for pthread_create in -lpthread... $ECHO_C" >&6
+if test "${ac_cv_lib_pthread_pthread_create+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpthread  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char pthread_create ();
+int
+main ()
+{
+pthread_create ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_pthread_pthread_create=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_pthread_pthread_create=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_create" >&5
+echo "${ECHO_T}$ac_cv_lib_pthread_pthread_create" >&6
+if test $ac_cv_lib_pthread_pthread_create = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBPTHREAD 1
+_ACEOF
+
+  LIBS="-lpthread $LIBS"
+
+fi
+
+  TARGET_THREAD_LIB="$LIBS"
+  LIBS=""
+else
+  TARGET_THREAD_LIB=""
+fi
+
+
+##########
+# Do we want to allow a connection created in one thread to be used
+# in another thread.  This does not work on many Linux systems (ex: RedHat 9)
+# due to bugs in the threading implementations.  This is thus off by default.
+#
+# Check whether --enable-cross-thread-connections or --disable-cross-thread-connections was given.
+if test "${enable_cross_thread_connections+set}" = set; then
+  enableval="$enable_cross_thread_connections"
+
+else
+  enable_xthreadconnect=no
+fi;
+echo "$as_me:$LINENO: checking whether to allow connections to be shared across threads" >&5
+echo $ECHO_N "checking whether to allow connections to be shared across threads... $ECHO_C" >&6
+if test "$enable_xthreadconnect" = "no"; then
+  XTHREADCONNECT=''
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+else
+  XTHREADCONNECT='-DSQLITE_ALLOW_XTHREAD_CONNECT=1'
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+fi
+
+
+##########
+# Do we want to set threadsOverrideEachOthersLocks variable to be 1 (true) by
+# default. Normally, a test at runtime is performed to determine the
+# appropriate value of this variable. Use this option only if you're sure that
+# threads can safely override each others locks in all runtime situations.
+#
+# Check whether --enable-threads-override-locks or --disable-threads-override-locks was given.
+if test "${enable_threads_override_locks+set}" = set; then
+  enableval="$enable_threads_override_locks"
+
+else
+  enable_threads_override_locks=no
+fi;
+echo "$as_me:$LINENO: checking whether threads can override each others locks" >&5
+echo $ECHO_N "checking whether threads can override each others locks... $ECHO_C" >&6
+if test "$enable_threads_override_locks" = "no"; then
+  THREADSOVERRIDELOCKS='-1'
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+else
+  THREADSOVERRIDELOCKS='1'
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+fi
+
+
+##########
+# Do we want to support release
+#
+# Check whether --enable-releasemode or --disable-releasemode was given.
+if test "${enable_releasemode+set}" = set; then
+  enableval="$enable_releasemode"
+
+else
+  enable_releasemode=no
+fi;
+echo "$as_me:$LINENO: checking whether to support shared library linked as release mode or not" >&5
+echo $ECHO_N "checking whether to support shared library linked as release mode or not... $ECHO_C" >&6
+if test "$enable_releasemode" = "no"; then
+  ALLOWRELEASE=""
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+else
+  ALLOWRELEASE="-release `cat $srcdir/VERSION`"
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+fi
+
+
+##########
+# Do we want temporary databases in memory
+#
+# Check whether --enable-tempstore or --disable-tempstore was given.
+if test "${enable_tempstore+set}" = set; then
+  enableval="$enable_tempstore"
+
+else
+  enable_tempstore=no
+fi;
+echo "$as_me:$LINENO: checking whether to use an in-ram database for temporary tables" >&5
+echo $ECHO_N "checking whether to use an in-ram database for temporary tables... $ECHO_C" >&6
+case "$enable_tempstore" in
+  never )
+    TEMP_STORE=0
+    echo "$as_me:$LINENO: result: never" >&5
+echo "${ECHO_T}never" >&6
+  ;;
+  no )
+    TEMP_STORE=1
+    echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+  ;;
+  always )
+     TEMP_STORE=3
+    echo "$as_me:$LINENO: result: always" >&5
+echo "${ECHO_T}always" >&6
+  ;;
+  yes )
+     TEMP_STORE=3
+    echo "$as_me:$LINENO: result: always" >&5
+echo "${ECHO_T}always" >&6
+  ;;
+  * )
+    TEMP_STORE=1
+    echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+  ;;
+esac
+
+
+
+###########
+# Lots of things are different if we are compiling for Windows using
+# the CYGWIN environment.  So check for that special case and handle
+# things accordingly.
+#
+echo "$as_me:$LINENO: checking if executables have the .exe suffix" >&5
+echo $ECHO_N "checking if executables have the .exe suffix... $ECHO_C" >&6
+if test "$config_BUILD_EXEEXT" = ".exe"; then
+  CYGWIN=yes
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+  echo "$as_me:$LINENO: result: unknown" >&5
+echo "${ECHO_T}unknown" >&6
+fi
+if test "$CYGWIN" != "yes"; then
+
+case $host_os in
+  *cygwin* ) CYGWIN=yes;;
+	 * ) CYGWIN=no;;
+esac
+
+fi
+if test "$CYGWIN" = "yes"; then
+  BUILD_EXEEXT=.exe
+else
+  BUILD_EXEEXT=$EXEEXT
+fi
+if test x"$cross_compiling" = xno; then
+  TARGET_EXEEXT=$BUILD_EXEEXT
+else
+  TARGET_EXEEXT=$config_TARGET_EXEEXT
+fi
+if test "$TARGET_EXEEXT" = ".exe"; then
+  if test $OS2_SHELL ; then
+    OS_UNIX=0
+    OS_WIN=0
+    OS_OS2=1
+    TARGET_CFLAGS="$TARGET_CFLAGS -DOS_OS2=1"
+    if test "$ac_compiler_gnu" == "yes" ; then
+      TARGET_CFLAGS="$TARGET_CFLAGS -Zomf -Zexe -Zmap"
+      BUILD_CFLAGS="$BUILD_CFLAGS -Zomf -Zexe"
+    fi
+  else
+    OS_UNIX=0
+    OS_WIN=1
+    OS_OS2=0
+    tclsubdir=win
+    TARGET_CFLAGS="$TARGET_CFLAGS -DOS_WIN=1"
+  fi
+else
+  OS_UNIX=1
+  OS_WIN=0
+  OS_OS2=0
+  tclsubdir=unix
+  TARGET_CFLAGS="$TARGET_CFLAGS -DOS_UNIX=1"
+fi
+
+
+
+
+
+
+
+##########
+# Figure out all the parameters needed to compile against Tcl.
+#
+# This code is derived from the SC_PATH_TCLCONFIG and SC_LOAD_TCLCONFIG
+# macros in the in the tcl.m4 file of the standard TCL distribution.
+# Those macros could not be used directly since we have to make some
+# minor changes to accomodate systems that do not have TCL installed.
+#
+# Check whether --enable-tcl or --disable-tcl was given.
+if test "${enable_tcl+set}" = set; then
+  enableval="$enable_tcl"
+  use_tcl=$enableval
+else
+  use_tcl=yes
+fi;
+if test "${use_tcl}" = "yes" ; then
+
+# Check whether --with-tcl or --without-tcl was given.
+if test "${with_tcl+set}" = set; then
+  withval="$with_tcl"
+  with_tclconfig=${withval}
+fi;
+  echo "$as_me:$LINENO: checking for Tcl configuration" >&5
+echo $ECHO_N "checking for Tcl configuration... $ECHO_C" >&6
+  if test "${ac_cv_c_tclconfig+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+
+    # First check to see if --with-tcl was specified.
+    if test x"${with_tclconfig}" != x ; then
+      if test -f "${with_tclconfig}/tclConfig.sh" ; then
+        ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
+      else
+        { { echo "$as_me:$LINENO: error: ${with_tclconfig} directory doesn't contain tclConfig.sh" >&5
+echo "$as_me: error: ${with_tclconfig} directory doesn't contain tclConfig.sh" >&2;}
+   { (exit 1); exit 1; }; }
+      fi
+    fi
+    # then check for a private Tcl installation
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+            ../tcl \
+            `ls -dr ../tcl[8-9].[0-9].[0-9]* 2>/dev/null` \
+            `ls -dr ../tcl[8-9].[0-9] 2>/dev/null` \
+            `ls -dr ../tcl[8-9].[0-9]* 2>/dev/null` \
+            ../../tcl \
+            `ls -dr ../../tcl[8-9].[0-9].[0-9]* 2>/dev/null` \
+            `ls -dr ../../tcl[8-9].[0-9] 2>/dev/null` \
+            `ls -dr ../../tcl[8-9].[0-9]* 2>/dev/null` \
+            ../../../tcl \
+            `ls -dr ../../../tcl[8-9].[0-9].[0-9]* 2>/dev/null` \
+            `ls -dr ../../../tcl[8-9].[0-9] 2>/dev/null` \
+            `ls -dr ../../../tcl[8-9].[0-9]* 2>/dev/null`
+      do
+        if test -f "$i/unix/tclConfig.sh" ; then
+          ac_cv_c_tclconfig=`(cd $i/unix; pwd)`
+          break
+        fi
+      done
+    fi
+
+    # check in a few common install locations
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+            `ls -d ${libdir} 2>/dev/null` \
+            `ls -d /usr/local/lib 2>/dev/null` \
+            `ls -d /usr/contrib/lib 2>/dev/null` \
+            `ls -d /usr/lib 2>/dev/null`
+      do
+        if test -f "$i/tclConfig.sh" ; then
+           ac_cv_c_tclconfig=`(cd $i; pwd)`
+           break
+        fi
+      done
+    fi
+
+    # check in a few other private locations
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+         ${srcdir}/../tcl \
+         `ls -dr ${srcdir}/../tcl[8-9].[0-9].[0-9]* 2>/dev/null` \
+         `ls -dr ${srcdir}/../tcl[8-9].[0-9] 2>/dev/null` \
+         `ls -dr ${srcdir}/../tcl[8-9].[0-9]* 2>/dev/null`
+      do
+        if test -f "$i/unix/tclConfig.sh" ; then
+          ac_cv_c_tclconfig=`(cd $i/unix; pwd)`
+          break
+        fi
+      done
+    fi
+
+fi
+
+
+  if test x"${ac_cv_c_tclconfig}" = x ; then
+    use_tcl=no
+    { echo "$as_me:$LINENO: WARNING: Can't find Tcl configuration definitions" >&5
+echo "$as_me: WARNING: Can't find Tcl configuration definitions" >&2;}
+    { echo "$as_me:$LINENO: WARNING: *** Without Tcl the regression tests cannot be executed ***" >&5
+echo "$as_me: WARNING: *** Without Tcl the regression tests cannot be executed ***" >&2;}
+    { echo "$as_me:$LINENO: WARNING: *** Consider using --with-tcl=... to define location of Tcl ***" >&5
+echo "$as_me: WARNING: *** Consider using --with-tcl=... to define location of Tcl ***" >&2;}
+  else
+    TCL_BIN_DIR=${ac_cv_c_tclconfig}
+    echo "$as_me:$LINENO: result: found $TCL_BIN_DIR/tclConfig.sh" >&5
+echo "${ECHO_T}found $TCL_BIN_DIR/tclConfig.sh" >&6
+
+    echo "$as_me:$LINENO: checking for existence of $TCL_BIN_DIR/tclConfig.sh" >&5
+echo $ECHO_N "checking for existence of $TCL_BIN_DIR/tclConfig.sh... $ECHO_C" >&6
+    if test -f "$TCL_BIN_DIR/tclConfig.sh" ; then
+      echo "$as_me:$LINENO: result: loading" >&5
+echo "${ECHO_T}loading" >&6
+      . $TCL_BIN_DIR/tclConfig.sh
+    else
+      echo "$as_me:$LINENO: result: file not found" >&5
+echo "${ECHO_T}file not found" >&6
+    fi
+
+    #
+    # If the TCL_BIN_DIR is the build directory (not the install directory),
+    # then set the common variable name to the value of the build variables.
+    # For example, the variable TCL_LIB_SPEC will be set to the value
+    # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
+    # instead of TCL_BUILD_LIB_SPEC since it will work with both an
+    # installed and uninstalled version of Tcl.
+    #
+
+   if test -f $TCL_BIN_DIR/Makefile ; then
+      TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC}
+      TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC}
+      TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH}
+    fi
+
+    #
+    # eval is required to do the TCL_DBGX substitution
+    #
+
+    eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\""
+    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
+    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
+
+    eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\""
+    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
+    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  fi
+fi
+if test "${use_tcl}" = "no" ; then
+  HAVE_TCL=""
+else
+  HAVE_TCL=1
+fi
+
+
+##########
+# Figure out what C libraries are required to compile programs
+# that use "readline()" library.
+#
+TARGET_READLINE_LIBS=""
+TARGET_READLINE_INC=""
+TARGET_HAVE_READLINE=0
+# Check whether --enable-readline or --disable-readline was given.
+if test "${enable_readline+set}" = set; then
+  enableval="$enable_readline"
+  with_readline=$enableval
+else
+  with_readline=auto
+fi;
+
+if test x"$with_readline" != xno; then
+	found="yes"
+
+
+# Check whether --with-readline-lib or --without-readline-lib was given.
+if test "${with_readline_lib+set}" = set; then
+  withval="$with_readline_lib"
+  with_readline_lib=$withval
+else
+  with_readline_lib="auto"
+fi;
+	if test "x$with_readline_lib" = xauto; then
+		save_LIBS="$LIBS"
+		LIBS=""
+		echo "$as_me:$LINENO: checking for library containing tgetent" >&5
+echo $ECHO_N "checking for library containing tgetent... $ECHO_C" >&6
+if test "${ac_cv_search_tgetent+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_func_search_save_LIBS=$LIBS
+ac_cv_search_tgetent=no
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char tgetent ();
+int
+main ()
+{
+tgetent ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_search_tgetent="none required"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test "$ac_cv_search_tgetent" = no; then
+  for ac_lib in readline ncurses curses termcap; do
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+    cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char tgetent ();
+int
+main ()
+{
+tgetent ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_search_tgetent="-l$ac_lib"
+break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+  done
+fi
+LIBS=$ac_func_search_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_search_tgetent" >&5
+echo "${ECHO_T}$ac_cv_search_tgetent" >&6
+if test "$ac_cv_search_tgetent" != no; then
+  test "$ac_cv_search_tgetent" = "none required" || LIBS="$ac_cv_search_tgetent $LIBS"
+  term_LIBS="$LIBS"
+else
+  term_LIBS=""
+fi
+
+		echo "$as_me:$LINENO: checking for readline in -lreadline" >&5
+echo $ECHO_N "checking for readline in -lreadline... $ECHO_C" >&6
+if test "${ac_cv_lib_readline_readline+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lreadline  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char readline ();
+int
+main ()
+{
+readline ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_readline_readline=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_readline_readline=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_readline_readline" >&5
+echo "${ECHO_T}$ac_cv_lib_readline_readline" >&6
+if test $ac_cv_lib_readline_readline = yes; then
+  TARGET_READLINE_LIBS="-lreadline"
+else
+  found="no"
+fi
+
+		TARGET_READLINE_LIBS="$TARGET_READLINE_LIBS $term_LIBS"
+		LIBS="$save_LIBS"
+	else
+		TARGET_READLINE_LIBS="$with_readline_lib"
+	fi
+
+
+# Check whether --with-readline-inc or --without-readline-inc was given.
+if test "${with_readline_inc+set}" = set; then
+  withval="$with_readline_inc"
+  with_readline_inc=$withval
+else
+  with_readline_inc="auto"
+fi;
+	if test "x$with_readline_inc" = xauto; then
+		if test "${ac_cv_header_readline_h+set}" = set; then
+  echo "$as_me:$LINENO: checking for readline.h" >&5
+echo $ECHO_N "checking for readline.h... $ECHO_C" >&6
+if test "${ac_cv_header_readline_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_readline_h" >&5
+echo "${ECHO_T}$ac_cv_header_readline_h" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking readline.h usability" >&5
+echo $ECHO_N "checking readline.h usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <readline.h>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking readline.h presence" >&5
+echo $ECHO_N "checking readline.h presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <readline.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: readline.h: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: readline.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: readline.h: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: readline.h: present but cannot be compiled" >&5
+echo "$as_me: WARNING: readline.h: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: readline.h:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: readline.h: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: readline.h:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: readline.h: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: readline.h: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: readline.h: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ------------------------------------------ ##
+## Report this to the AC_PACKAGE_NAME lists.  ##
+## ------------------------------------------ ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for readline.h" >&5
+echo $ECHO_N "checking for readline.h... $ECHO_C" >&6
+if test "${ac_cv_header_readline_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_header_readline_h=$ac_header_preproc
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_readline_h" >&5
+echo "${ECHO_T}$ac_cv_header_readline_h" >&6
+
+fi
+if test $ac_cv_header_readline_h = yes; then
+  found="yes"
+else
+
+			found="no"
+			if test "$cross_compiling" != yes; then
+				for dir in /usr /usr/local /usr/local/readline /usr/contrib /mingw; do
+					for subdir in include include/readline; do
+						as_ac_File=`echo "ac_cv_file_$dir/$subdir/readline.h" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $dir/$subdir/readline.h" >&5
+echo $ECHO_N "checking for $dir/$subdir/readline.h... $ECHO_C" >&6
+if eval "test \"\${$as_ac_File+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  test "$cross_compiling" = yes &&
+  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
+echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
+   { (exit 1); exit 1; }; }
+if test -r "$dir/$subdir/readline.h"; then
+  eval "$as_ac_File=yes"
+else
+  eval "$as_ac_File=no"
+fi
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_File'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_File'}'`" >&6
+if test `eval echo '${'$as_ac_File'}'` = yes; then
+  found=yes
+fi
+
+						if test "$found" = "yes"; then
+							TARGET_READLINE_INC="-I$dir/$subdir"
+							break
+						fi
+					done
+					test "$found" = "yes" && break
+				done
+			fi
+
+fi
+
+
+	else
+		TARGET_READLINE_INC="$with_readline_inc"
+	fi
+
+	if test x"$found" = xno; then
+		TARGET_READLINE_LIBS=""
+		TARGET_READLINE_INC=""
+		TARGET_HAVE_READLINE=0
+	else
+		TARGET_HAVE_READLINE=1
+	fi
+fi
+
+
+
+
+
+##########
+# Figure out what C libraries are required to compile programs
+# that use "fdatasync()" function.
+#
+echo "$as_me:$LINENO: checking for library containing fdatasync" >&5
+echo $ECHO_N "checking for library containing fdatasync... $ECHO_C" >&6
+if test "${ac_cv_search_fdatasync+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_func_search_save_LIBS=$LIBS
+ac_cv_search_fdatasync=no
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char fdatasync ();
+int
+main ()
+{
+fdatasync ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_search_fdatasync="none required"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+if test "$ac_cv_search_fdatasync" = no; then
+  for ac_lib in rt; do
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+    cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char fdatasync ();
+int
+main ()
+{
+fdatasync ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_search_fdatasync="-l$ac_lib"
+break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+  done
+fi
+LIBS=$ac_func_search_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_search_fdatasync" >&5
+echo "${ECHO_T}$ac_cv_search_fdatasync" >&6
+if test "$ac_cv_search_fdatasync" != no; then
+  test "$ac_cv_search_fdatasync" = "none required" || LIBS="$ac_cv_search_fdatasync $LIBS"
+
+fi
+
+
+#########
+# check for debug enabled
+# Check whether --enable-debug or --disable-debug was given.
+if test "${enable_debug+set}" = set; then
+  enableval="$enable_debug"
+  use_debug=$enableval
+else
+  use_debug=no
+fi;
+if test "${use_debug}" = "yes" ; then
+  TARGET_DEBUG="-DSQLITE_DEBUG=1"
+else
+  TARGET_DEBUG="-DNDEBUG"
+fi
+
+
+#########
+# Figure out whether or not we have a "usleep()" function.
+#
+echo "$as_me:$LINENO: checking for usleep" >&5
+echo $ECHO_N "checking for usleep... $ECHO_C" >&6
+if test "${ac_cv_func_usleep+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define usleep to an innocuous variant, in case <limits.h> declares usleep.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define usleep innocuous_usleep
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char usleep (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef usleep
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char usleep ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_usleep) || defined (__stub___usleep)
+choke me
+#else
+char (*f) () = usleep;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != usleep;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_func_usleep=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_func_usleep=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_func_usleep" >&5
+echo "${ECHO_T}$ac_cv_func_usleep" >&6
+if test $ac_cv_func_usleep = yes; then
+  TARGET_CFLAGS="$TARGET_CFLAGS -DHAVE_USLEEP=1"
+fi
+
+
+#--------------------------------------------------------------------
+# Redefine fdatasync as fsync on systems that lack fdatasync
+#--------------------------------------------------------------------
+
+echo "$as_me:$LINENO: checking for fdatasync" >&5
+echo $ECHO_N "checking for fdatasync... $ECHO_C" >&6
+if test "${ac_cv_func_fdatasync+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define fdatasync to an innocuous variant, in case <limits.h> declares fdatasync.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define fdatasync innocuous_fdatasync
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char fdatasync (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef fdatasync
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char fdatasync ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_fdatasync) || defined (__stub___fdatasync)
+choke me
+#else
+char (*f) () = fdatasync;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != fdatasync;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_func_fdatasync=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_func_fdatasync=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_func_fdatasync" >&5
+echo "${ECHO_T}$ac_cv_func_fdatasync" >&6
+if test $ac_cv_func_fdatasync = yes; then
+  TARGET_CFLAGS="$TARGET_CFLAGS -DHAVE_FDATASYNC=1"
+fi
+
+
+#########
+# Generate the output files.
+#
+                    ac_config_files="$ac_config_files Makefile sqlite3.pc"
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+{
+  (set) 2>&1 |
+    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+    *ac_space=\ *)
+      # `set' does not quote correctly, so add quotes (double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \).
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;;
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n \
+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      ;;
+    esac;
+} |
+  sed '
+     t clear
+     : clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     : end' >>confcache
+if diff $cache_file confcache >/dev/null 2>&1; then :; else
+  if test -w $cache_file; then
+    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
+    cat confcache >$cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
+s/:*\$(srcdir):*/:/;
+s/:*\${srcdir}:*/:/;
+s/:*@srcdir@:*/:/;
+s/^\([^=]*=[	 ]*\):*/\1/;
+s/:*$//;
+s/^[^=]*=[	 ]*$//;
+}'
+fi
+
+# Transform confdefs.h into DEFS.
+# Protect against shell expansion while executing Makefile rules.
+# Protect against Makefile macro expansion.
+#
+# If the first sed substitution is executed (which looks for macros that
+# take arguments), then we branch to the quote section.  Otherwise,
+# look for a macro that doesn't take arguments.
+cat >confdef2opt.sed <<\_ACEOF
+t clear
+: clear
+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\),-D\1=\2,g
+t quote
+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\),-D\1=\2,g
+t quote
+d
+: quote
+s,[	 `~#$^&*(){}\\|;'"<>?],\\&,g
+s,\[,\\&,g
+s,\],\\&,g
+s,\$,$$,g
+p
+_ACEOF
+# We use echo to avoid assuming a particular line-breaking character.
+# The extra dot is to prevent the shell from consuming trailing
+# line-breaks from the sub-command output.  A line-break within
+# single-quotes doesn't work because, if this script is created in a
+# platform that uses two characters for line-breaks (e.g., DOS), tr
+# would break.
+ac_LF_and_DOT=`echo; echo .`
+DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
+rm -f confdef2opt.sed
+
+
+ac_libobjs=
+ac_ltlibobjs=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_i=`echo "$ac_i" |
+	 sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+  # 2. Add them.
+  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: ${CONFIG_STATUS=./config.status}
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
+echo "$as_me: creating $CONFIG_STATUS" >&6;}
+cat >$CONFIG_STATUS <<_ACEOF
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+SHELL=\${CONFIG_SHELL-$SHELL}
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+  set -o posix
+fi
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  # We could just check for DJGPP; but this test a) works b) is more generic
+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+  if test -f conf$$.exe; then
+    # Don't use ln at all; we don't have any links
+    as_ln_s='cp -p'
+  else
+    as_ln_s='ln -s'
+  fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" 	$as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+exec 6>&1
+
+# Open the log real soon, to keep \$[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.  Logging --version etc. is OK.
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+} >&5
+cat >&5 <<_CSEOF
+
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+_CSEOF
+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+echo >&5
+_ACEOF
+
+# Files that config.status was made for.
+if test -n "$ac_config_files"; then
+  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_headers"; then
+  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_links"; then
+  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_commands"; then
+  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+ac_cs_usage="\
+\`$as_me' instantiates files from templates according to the
+current configuration.
+
+Usage: $0 [OPTIONS] [FILE]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number, then exit
+  -q, --quiet      do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+  --file=FILE[:TEMPLATE]
+		   instantiate the configuration file FILE
+
+Configuration files:
+$config_files
+
+Report bugs to <bug-autoconf@gnu.org>."
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+ac_cs_version="\\
+config.status
+configured by $0, generated by GNU Autoconf 2.59,
+  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
+
+Copyright (C) 2003 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+srcdir=$srcdir
+INSTALL="$INSTALL"
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+# If no file are specified by the user, then we need to provide default
+# value.  By we need to know if files were specified by the user.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=*)
+    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  -*)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  *) # This is not an option, so the user has probably given explicit
+     # arguments.
+     ac_option=$1
+     ac_need_defaults=false;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --vers* | -V )
+    echo "$ac_cs_version"; exit 0 ;;
+  --he | --h)
+    # Conflict between --help and --header
+    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; };;
+  --help | --hel | -h )
+    echo "$ac_cs_usage"; exit 0 ;;
+  --debug | --d* | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+    ac_need_defaults=false;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; } ;;
+
+  *) ac_config_targets="$ac_config_targets $1" ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+if \$ac_cs_recheck; then
+  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+fi
+
+_ACEOF
+
+
+
+
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_config_target in $ac_config_targets
+do
+  case "$ac_config_target" in
+  # Handling of arguments.
+  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+  "sqlite3.pc" ) CONFIG_FILES="$CONFIG_FILES sqlite3.pc" ;;
+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason to put it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Create a temporary directory, and hook for its removal unless debugging.
+$debug ||
+{
+  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
+  trap '{ (exit 1); exit 1; }' 1 2 13 15
+}
+
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
+  test -n "$tmp" && test -d "$tmp"
+}  ||
+{
+  tmp=./confstat$$-$RANDOM
+  (umask 077 && mkdir $tmp)
+} ||
+{
+   echo "$me: cannot create a temporary directory in ." >&2
+   { (exit 1); exit 1; }
+}
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+
+#
+# CONFIG_FILES section.
+#
+
+# No need to generate the scripts if there are no CONFIG_FILES.
+# This happens for instance when ./config.status config.h
+if test -n "\$CONFIG_FILES"; then
+  # Protect against being on the right side of a sed subst in config.status.
+  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+s,@SHELL@,$SHELL,;t t
+s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+s,@exec_prefix@,$exec_prefix,;t t
+s,@prefix@,$prefix,;t t
+s,@program_transform_name@,$program_transform_name,;t t
+s,@bindir@,$bindir,;t t
+s,@sbindir@,$sbindir,;t t
+s,@libexecdir@,$libexecdir,;t t
+s,@datadir@,$datadir,;t t
+s,@sysconfdir@,$sysconfdir,;t t
+s,@sharedstatedir@,$sharedstatedir,;t t
+s,@localstatedir@,$localstatedir,;t t
+s,@libdir@,$libdir,;t t
+s,@includedir@,$includedir,;t t
+s,@oldincludedir@,$oldincludedir,;t t
+s,@infodir@,$infodir,;t t
+s,@mandir@,$mandir,;t t
+s,@build_alias@,$build_alias,;t t
+s,@host_alias@,$host_alias,;t t
+s,@target_alias@,$target_alias,;t t
+s,@DEFS@,$DEFS,;t t
+s,@ECHO_C@,$ECHO_C,;t t
+s,@ECHO_N@,$ECHO_N,;t t
+s,@ECHO_T@,$ECHO_T,;t t
+s,@LIBS@,$LIBS,;t t
+s,@build@,$build,;t t
+s,@build_cpu@,$build_cpu,;t t
+s,@build_vendor@,$build_vendor,;t t
+s,@build_os@,$build_os,;t t
+s,@host@,$host,;t t
+s,@host_cpu@,$host_cpu,;t t
+s,@host_vendor@,$host_vendor,;t t
+s,@host_os@,$host_os,;t t
+s,@CC@,$CC,;t t
+s,@CFLAGS@,$CFLAGS,;t t
+s,@LDFLAGS@,$LDFLAGS,;t t
+s,@CPPFLAGS@,$CPPFLAGS,;t t
+s,@ac_ct_CC@,$ac_ct_CC,;t t
+s,@EXEEXT@,$EXEEXT,;t t
+s,@OBJEXT@,$OBJEXT,;t t
+s,@EGREP@,$EGREP,;t t
+s,@LN_S@,$LN_S,;t t
+s,@ECHO@,$ECHO,;t t
+s,@AR@,$AR,;t t
+s,@ac_ct_AR@,$ac_ct_AR,;t t
+s,@RANLIB@,$RANLIB,;t t
+s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+s,@STRIP@,$STRIP,;t t
+s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
+s,@CPP@,$CPP,;t t
+s,@CXX@,$CXX,;t t
+s,@CXXFLAGS@,$CXXFLAGS,;t t
+s,@ac_ct_CXX@,$ac_ct_CXX,;t t
+s,@CXXCPP@,$CXXCPP,;t t
+s,@F77@,$F77,;t t
+s,@FFLAGS@,$FFLAGS,;t t
+s,@ac_ct_F77@,$ac_ct_F77,;t t
+s,@LIBTOOL@,$LIBTOOL,;t t
+s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+s,@AWK@,$AWK,;t t
+s,@program_prefix@,$program_prefix,;t t
+s,@VERSION@,$VERSION,;t t
+s,@RELEASE@,$RELEASE,;t t
+s,@VERSION_NUMBER@,$VERSION_NUMBER,;t t
+s,@BUILD_CC@,$BUILD_CC,;t t
+s,@BUILD_CFLAGS@,$BUILD_CFLAGS,;t t
+s,@SQLITE_THREADSAFE@,$SQLITE_THREADSAFE,;t t
+s,@TARGET_THREAD_LIB@,$TARGET_THREAD_LIB,;t t
+s,@XTHREADCONNECT@,$XTHREADCONNECT,;t t
+s,@THREADSOVERRIDELOCKS@,$THREADSOVERRIDELOCKS,;t t
+s,@ALLOWRELEASE@,$ALLOWRELEASE,;t t
+s,@TEMP_STORE@,$TEMP_STORE,;t t
+s,@BUILD_EXEEXT@,$BUILD_EXEEXT,;t t
+s,@OS_UNIX@,$OS_UNIX,;t t
+s,@OS_WIN@,$OS_WIN,;t t
+s,@OS_OS2@,$OS_OS2,;t t
+s,@TARGET_EXEEXT@,$TARGET_EXEEXT,;t t
+s,@TCL_VERSION@,$TCL_VERSION,;t t
+s,@TCL_BIN_DIR@,$TCL_BIN_DIR,;t t
+s,@TCL_SRC_DIR@,$TCL_SRC_DIR,;t t
+s,@TCL_LIBS@,$TCL_LIBS,;t t
+s,@TCL_INCLUDE_SPEC@,$TCL_INCLUDE_SPEC,;t t
+s,@TCL_LIB_FILE@,$TCL_LIB_FILE,;t t
+s,@TCL_LIB_FLAG@,$TCL_LIB_FLAG,;t t
+s,@TCL_LIB_SPEC@,$TCL_LIB_SPEC,;t t
+s,@TCL_STUB_LIB_FILE@,$TCL_STUB_LIB_FILE,;t t
+s,@TCL_STUB_LIB_FLAG@,$TCL_STUB_LIB_FLAG,;t t
+s,@TCL_STUB_LIB_SPEC@,$TCL_STUB_LIB_SPEC,;t t
+s,@HAVE_TCL@,$HAVE_TCL,;t t
+s,@TARGET_READLINE_LIBS@,$TARGET_READLINE_LIBS,;t t
+s,@TARGET_READLINE_INC@,$TARGET_READLINE_INC,;t t
+s,@TARGET_HAVE_READLINE@,$TARGET_HAVE_READLINE,;t t
+s,@TARGET_DEBUG@,$TARGET_DEBUG,;t t
+s,@LIBOBJS@,$LIBOBJS,;t t
+s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+CEOF
+
+_ACEOF
+
+  cat >>$CONFIG_STATUS <<\_ACEOF
+  # Split the substitutions into bite-sized pieces for seds with
+  # small command number limits, like on Digital OSF/1 and HP-UX.
+  ac_max_sed_lines=48
+  ac_sed_frag=1 # Number of current file.
+  ac_beg=1 # First line for current file.
+  ac_end=$ac_max_sed_lines # Line after last line for current file.
+  ac_more_lines=:
+  ac_sed_cmds=
+  while $ac_more_lines; do
+    if test $ac_beg -gt 1; then
+      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    else
+      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    fi
+    if test ! -s $tmp/subs.frag; then
+      ac_more_lines=false
+    else
+      # The purpose of the label and of the branching condition is to
+      # speed up the sed processing (if there are no `@' at all, there
+      # is no need to browse any of the substitutions).
+      # These are the two extra sed commands mentioned above.
+      (echo ':t
+  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+      if test -z "$ac_sed_cmds"; then
+	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+      else
+	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+      fi
+      ac_sed_frag=`expr $ac_sed_frag + 1`
+      ac_beg=$ac_end
+      ac_end=`expr $ac_end + $ac_max_sed_lines`
+    fi
+  done
+  if test -z "$ac_sed_cmds"; then
+    ac_sed_cmds=cat
+  fi
+fi # test -n "$CONFIG_FILES"
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case $ac_file in
+  - | *:- | *:-:* ) # input from stdin
+	cat >$tmp/stdin
+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  * )   ac_file_in=$ac_file.in ;;
+  esac
+
+  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  { if $as_mkdir_p; then
+    mkdir -p "$ac_dir"
+  else
+    as_dir="$ac_dir"
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+  ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
+  esac
+
+  if test x"$ac_file" != x-; then
+    { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+    rm -f "$ac_file"
+  fi
+  # Let's still pretend it is `configure' which instantiates (i.e., don't
+  # use $as_me), people would be surprised to read:
+  #    /* config.h.  Generated by config.status.  */
+  if test x"$ac_file" = x-; then
+    configure_input=
+  else
+    configure_input="$ac_file.  "
+  fi
+  configure_input=$configure_input"Generated from `echo $ac_file_in |
+				     sed 's,.*/,,'` by configure."
+
+  # First look for the input files in the build tree, otherwise in the
+  # src tree.
+  ac_file_inputs=`IFS=:
+    for f in $ac_file_in; do
+      case $f in
+      -) echo $tmp/stdin ;;
+      [\\/$]*)
+	 # Absolute (can't be DOS-style, as IFS=:)
+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 echo "$f";;
+      *) # Relative
+	 if test -f "$f"; then
+	   # Build tree
+	   echo "$f"
+	 elif test -f "$srcdir/$f"; then
+	   # Source tree
+	   echo "$srcdir/$f"
+	 else
+	   # /dev/null tree
+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 fi;;
+      esac
+    done` || { (exit 1); exit 1; }
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+  sed "$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s,@configure_input@,$configure_input,;t t
+s,@srcdir@,$ac_srcdir,;t t
+s,@abs_srcdir@,$ac_abs_srcdir,;t t
+s,@top_srcdir@,$ac_top_srcdir,;t t
+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+s,@builddir@,$ac_builddir,;t t
+s,@abs_builddir@,$ac_abs_builddir,;t t
+s,@top_builddir@,$ac_top_builddir,;t t
+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+s,@INSTALL@,$ac_INSTALL,;t t
+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+  rm -f $tmp/stdin
+  if test x"$ac_file" != x-; then
+    mv $tmp/out $ac_file
+  else
+    cat $tmp/out
+    rm -f $tmp/out
+  fi
+
+done
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+{ (exit 0); exit 0; }
+_ACEOF
+chmod +x $CONFIG_STATUS
+ac_clean_files=$ac_clean_files_save
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || { (exit 1); exit 1; }
+fi
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/configure.ac b/client/src/thirdparty/sqlite-3.4.2/configure.ac
new file mode 100644
index 0000000..1bb2169
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/configure.ac
@@ -0,0 +1,582 @@
+#
+# The build process allows for using a cross-compiler.  But the default
+# action is to target the same platform that we are running on.  The
+# configure script needs to discover the following properties of the 
+# build and target systems:
+#
+#    srcdir
+#
+#        The is the name of the directory that contains the
+#        "configure" shell script.  All source files are
+#        located relative to this directory.
+#
+#    bindir
+#
+#        The name of the directory where executables should be
+#        written by the "install" target of the makefile.
+#
+#    program_prefix
+#
+#        Add this prefix to the names of all executables that run
+#        on the target machine.  Default: ""
+#
+#    ENABLE_SHARED
+#
+#        True if shared libraries should be generated.
+#
+#    BUILD_CC
+#
+#        The name of a command that is used to convert C
+#        source files into executables that run on the build
+#        platform.
+#
+#    BUILD_CFLAGS
+#
+#        Switches that the build compiler needs in order to construct
+#        command-line programs.
+#
+#    BUILD_LIBS
+#
+#        Libraries that the build compiler needs in order to construct
+#        command-line programs.
+#
+#    BUILD_EXEEXT
+#
+#        The filename extension for executables on the build
+#        platform.  "" for Unix and ".exe" for Windows.
+#
+#    TCL_*
+#
+#        Lots of values are read in from the tclConfig.sh script,
+#        if that script is available.  This values are used for
+#        constructing and installing the TCL extension.
+#
+#    TARGET_READLINE_LIBS
+#
+#        This is the library directives passed to the target linker
+#        that cause the executable to link against the readline library.
+#        This might be a switch like "-lreadline" or pathnames of library
+#        file like "../../src/libreadline.a".
+#
+#    TARGET_READLINE_INC
+#
+#        This variables define the directory that contain header
+#        files for the readline library.  If the compiler is able 
+#        to find <readline.h> on its own, then this can be blank.
+#
+#    TARGET_EXEEXT
+#
+#        The filename extension for executables on the
+#        target platform.  "" for Unix and ".exe" for windows.
+#
+# The generated configure script will make an attempt to guess
+# at all of the above parameters.  You can override any of
+# the guesses by setting the environment variable named
+# "config_AAAA" where "AAAA" is the name of the parameter
+# described above.  (Exception: srcdir cannot be set this way.)
+# If you have a file that sets one or more of these environment
+# variables, you can invoke configure as follows:
+#
+#           configure --with-hints=FILE
+#
+# where FILE is the name of the file that sets the environment
+# variables.  FILE should be an absolute pathname.
+#
+# This configure.in file is easy to reuse on other projects.  Just
+# change the argument to AC_INIT().  And disable any features that
+# you don't need (for example BLT) by erasing or commenting out
+# the corresponding code.
+#
+AC_INIT(src/sqlite.h.in)
+
+dnl Put the RCS revision string after AC_INIT so that it will also
+dnl show in in configure.
+# The following RCS revision string applies to configure.in
+# $Revision: 1.31 $
+
+#########
+# Programs needed
+#
+AC_PROG_LIBTOOL
+AC_PROG_INSTALL
+AC_PROG_AWK
+
+#########
+# Set up an appropriate program prefix
+#
+if test "$program_prefix" = "NONE"; then
+  program_prefix=""
+fi
+AC_SUBST(program_prefix)
+
+VERSION=[`cat $srcdir/VERSION | sed 's/^\([0-9]*\.*[0-9]*\).*/\1/'`]
+echo "Version set to $VERSION"
+AC_SUBST(VERSION)
+RELEASE=`cat $srcdir/VERSION`
+echo "Release set to $RELEASE"
+AC_SUBST(RELEASE)
+VERSION_NUMBER=[`cat $srcdir/VERSION  \
+                           | sed 's/[^0-9]/ /g' \
+                | awk '{printf "%d%03d%03d",$1,$2,$3}'`]
+echo "Version number set to $VERSION_NUMBER"
+AC_SUBST(VERSION_NUMBER)
+
+#########
+# Check to see if the --with-hints=FILE option is used.  If there is none,
+# then check for a files named "$host.hints" and ../$hosts.hints where
+# $host is the hostname of the build system.  If still no hints are
+# found, try looking in $system.hints and ../$system.hints where
+# $system is the result of uname -s.
+#
+AC_ARG_WITH(hints,
+  AC_HELP_STRING([--with-hints=FILE],[Read configuration options from FILE]),
+  hints=$withval)
+if test "$hints" = ""; then
+  host=`hostname | sed 's/\..*//'`
+  if test -r $host.hints; then
+    hints=$host.hints
+  else
+     if test -r ../$host.hints; then
+       hints=../$host.hints
+     fi
+  fi
+fi
+if test "$hints" = ""; then
+  sys=`uname -s`
+  if test -r $sys.hints; then
+    hints=$sys.hints
+  else
+     if test -r ../$sys.hints; then
+       hints=../$sys.hints
+     fi
+  fi
+fi
+if test "$hints" != ""; then
+  AC_MSG_RESULT(reading hints from $hints)
+  . $hints
+fi
+
+#########
+# Locate a compiler for the build machine.  This compiler should
+# generate command-line programs that run on the build machine.
+#
+if test x"$cross_compiling" = xno; then
+	BUILD_CC=$CC
+	BUILD_CFLAGS=$CFLAGS
+else
+	if test "${BUILD_CC+set}" != set; then
+		AC_CHECK_PROGS(BUILD_CC, gcc cc cl)
+	fi
+	if test "${BUILD_CFLAGS+set}" != set; then
+		BUILD_CFLAGS="-g"
+	fi
+fi
+AC_SUBST(BUILD_CC)
+AC_SUBST(BUILD_CFLAGS)
+
+##########
+# Do we want to support multithreaded use of sqlite
+#
+AC_ARG_ENABLE(threadsafe, 
+AC_HELP_STRING([--enable-threadsafe],[Support threadsafe operation]),,enable_threadsafe=yes)
+AC_MSG_CHECKING([whether to support threadsafe operation])
+if test "$enable_threadsafe" = "no"; then
+  SQLITE_THREADSAFE=0
+  AC_MSG_RESULT([no])
+else
+  SQLITE_THREADSAFE=1
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(SQLITE_THREADSAFE)
+
+if test "$SQLITE_THREADSAFE" = "1"; then
+  LIBS=""
+  AC_CHECK_LIB(pthread, pthread_create)
+  TARGET_THREAD_LIB="$LIBS"
+  LIBS=""
+else
+  TARGET_THREAD_LIB=""
+fi
+AC_SUBST(TARGET_THREAD_LIB)
+
+##########
+# Do we want to allow a connection created in one thread to be used
+# in another thread.  This does not work on many Linux systems (ex: RedHat 9)
+# due to bugs in the threading implementations.  This is thus off by default.
+#
+AC_ARG_ENABLE(cross-thread-connections, 
+AC_HELP_STRING([--enable-cross-thread-connections],[Allow connection sharing across threads]),,enable_xthreadconnect=no)
+AC_MSG_CHECKING([whether to allow connections to be shared across threads])
+if test "$enable_xthreadconnect" = "no"; then
+  XTHREADCONNECT=''
+  AC_MSG_RESULT([no])
+else
+  XTHREADCONNECT='-DSQLITE_ALLOW_XTHREAD_CONNECT=1'
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(XTHREADCONNECT)
+
+##########
+# Do we want to set threadsOverrideEachOthersLocks variable to be 1 (true) by
+# default. Normally, a test at runtime is performed to determine the
+# appropriate value of this variable. Use this option only if you're sure that
+# threads can safely override each others locks in all runtime situations.
+#
+AC_ARG_ENABLE(threads-override-locks, 
+AC_HELP_STRING([--enable-threads-override-locks],[Threads can override each others locks]),,enable_threads_override_locks=no)
+AC_MSG_CHECKING([whether threads can override each others locks])
+if test "$enable_threads_override_locks" = "no"; then
+  THREADSOVERRIDELOCKS='-1'
+  AC_MSG_RESULT([no])
+else
+  THREADSOVERRIDELOCKS='1'
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(THREADSOVERRIDELOCKS)
+
+##########
+# Do we want to support release
+#
+AC_ARG_ENABLE(releasemode, 
+AC_HELP_STRING([--enable-releasemode],[Support libtool link to release mode]),,enable_releasemode=no)
+AC_MSG_CHECKING([whether to support shared library linked as release mode or not])
+if test "$enable_releasemode" = "no"; then
+  ALLOWRELEASE=""
+  AC_MSG_RESULT([no])
+else
+  ALLOWRELEASE="-release `cat $srcdir/VERSION`"
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(ALLOWRELEASE)
+
+##########
+# Do we want temporary databases in memory
+#
+AC_ARG_ENABLE(tempstore, 
+AC_HELP_STRING([--enable-tempstore],[Use an in-ram database for temporary tables (never,no,yes,always)]),,enable_tempstore=no)
+AC_MSG_CHECKING([whether to use an in-ram database for temporary tables])
+case "$enable_tempstore" in
+  never ) 
+    TEMP_STORE=0
+    AC_MSG_RESULT([never])
+  ;;
+  no ) 
+    TEMP_STORE=1
+    AC_MSG_RESULT([no])
+  ;;
+  always ) 
+     TEMP_STORE=3
+    AC_MSG_RESULT([always])
+  ;;
+  yes ) 
+     TEMP_STORE=3
+    AC_MSG_RESULT([always])
+  ;;
+  * ) 
+    TEMP_STORE=1
+    AC_MSG_RESULT([yes])
+  ;;
+esac
+
+AC_SUBST(TEMP_STORE)
+
+###########
+# Lots of things are different if we are compiling for Windows using
+# the CYGWIN environment.  So check for that special case and handle
+# things accordingly.
+#
+AC_MSG_CHECKING([if executables have the .exe suffix])
+if test "$config_BUILD_EXEEXT" = ".exe"; then
+  CYGWIN=yes
+  AC_MSG_RESULT(yes)
+else
+  AC_MSG_RESULT(unknown)
+fi
+if test "$CYGWIN" != "yes"; then
+  AC_CYGWIN
+fi
+if test "$CYGWIN" = "yes"; then
+  BUILD_EXEEXT=.exe
+else
+  BUILD_EXEEXT=$EXEEXT
+fi
+if test x"$cross_compiling" = xno; then
+  TARGET_EXEEXT=$BUILD_EXEEXT
+else
+  TARGET_EXEEXT=$config_TARGET_EXEEXT
+fi
+if test "$TARGET_EXEEXT" = ".exe"; then
+  if test $OS2_SHELL ; then
+    OS_UNIX=0
+    OS_WIN=0
+    OS_OS2=1
+    TARGET_CFLAGS="$TARGET_CFLAGS -DOS_OS2=1"
+    if test "$ac_compiler_gnu" == "yes" ; then
+      TARGET_CFLAGS="$TARGET_CFLAGS -Zomf -Zexe -Zmap"
+      BUILD_CFLAGS="$BUILD_CFLAGS -Zomf -Zexe"
+    fi
+  else
+    OS_UNIX=0
+    OS_WIN=1
+    OS_OS2=0
+    tclsubdir=win
+    TARGET_CFLAGS="$TARGET_CFLAGS -DOS_WIN=1"
+  fi
+else
+  OS_UNIX=1
+  OS_WIN=0
+  OS_OS2=0
+  tclsubdir=unix
+  TARGET_CFLAGS="$TARGET_CFLAGS -DOS_UNIX=1"
+fi
+
+AC_SUBST(BUILD_EXEEXT)
+AC_SUBST(OS_UNIX)
+AC_SUBST(OS_WIN)
+AC_SUBST(OS_OS2)
+AC_SUBST(TARGET_EXEEXT)
+
+##########
+# Figure out all the parameters needed to compile against Tcl.
+#
+# This code is derived from the SC_PATH_TCLCONFIG and SC_LOAD_TCLCONFIG
+# macros in the in the tcl.m4 file of the standard TCL distribution.
+# Those macros could not be used directly since we have to make some
+# minor changes to accomodate systems that do not have TCL installed.
+#
+AC_ARG_ENABLE(tcl, AC_HELP_STRING([--disable-tcl],[do not build TCL extension]),
+      [use_tcl=$enableval],[use_tcl=yes])
+if test "${use_tcl}" = "yes" ; then
+  AC_ARG_WITH(tcl, AC_HELP_STRING([--with-tcl=DIR],[directory containing tcl configuration (tclConfig.sh)]), with_tclconfig=${withval})
+  AC_MSG_CHECKING([for Tcl configuration])
+  AC_CACHE_VAL(ac_cv_c_tclconfig,[
+    # First check to see if --with-tcl was specified.
+    if test x"${with_tclconfig}" != x ; then
+      if test -f "${with_tclconfig}/tclConfig.sh" ; then
+        ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
+      else
+        AC_MSG_ERROR([${with_tclconfig} directory doesn't contain tclConfig.sh])
+      fi
+    fi
+    # then check for a private Tcl installation
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+            ../tcl \
+            `ls -dr ../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
+            `ls -dr ../tcl[[8-9]].[[0-9]] 2>/dev/null` \
+            `ls -dr ../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
+            ../../tcl \
+            `ls -dr ../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
+            `ls -dr ../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
+            `ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
+            ../../../tcl \
+            `ls -dr ../../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
+            `ls -dr ../../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
+            `ls -dr ../../../tcl[[8-9]].[[0-9]]* 2>/dev/null`
+      do
+        if test -f "$i/unix/tclConfig.sh" ; then
+          ac_cv_c_tclconfig=`(cd $i/unix; pwd)`
+          break
+        fi
+      done
+    fi
+
+    # check in a few common install locations
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+            `ls -d ${libdir} 2>/dev/null` \
+            `ls -d /usr/local/lib 2>/dev/null` \
+            `ls -d /usr/contrib/lib 2>/dev/null` \
+            `ls -d /usr/lib 2>/dev/null`
+      do
+        if test -f "$i/tclConfig.sh" ; then
+           ac_cv_c_tclconfig=`(cd $i; pwd)`
+           break
+        fi
+      done
+    fi
+
+    # check in a few other private locations
+    if test x"${ac_cv_c_tclconfig}" = x ; then
+      for i in \
+         ${srcdir}/../tcl \
+         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
+         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]] 2>/dev/null` \
+         `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]]* 2>/dev/null`
+      do
+        if test -f "$i/unix/tclConfig.sh" ; then
+          ac_cv_c_tclconfig=`(cd $i/unix; pwd)`
+          break
+        fi
+      done
+    fi
+  ])
+
+  if test x"${ac_cv_c_tclconfig}" = x ; then
+    use_tcl=no
+    AC_MSG_WARN(Can't find Tcl configuration definitions)
+    AC_MSG_WARN(*** Without Tcl the regression tests cannot be executed ***)
+    AC_MSG_WARN(*** Consider using --with-tcl=... to define location of Tcl ***)
+  else
+    TCL_BIN_DIR=${ac_cv_c_tclconfig}
+    AC_MSG_RESULT(found $TCL_BIN_DIR/tclConfig.sh)
+
+    AC_MSG_CHECKING([for existence of $TCL_BIN_DIR/tclConfig.sh])
+    if test -f "$TCL_BIN_DIR/tclConfig.sh" ; then
+      AC_MSG_RESULT([loading])
+      . $TCL_BIN_DIR/tclConfig.sh
+    else
+      AC_MSG_RESULT([file not found])
+    fi
+    
+    #
+    # If the TCL_BIN_DIR is the build directory (not the install directory),
+    # then set the common variable name to the value of the build variables.
+    # For example, the variable TCL_LIB_SPEC will be set to the value
+    # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
+    # instead of TCL_BUILD_LIB_SPEC since it will work with both an
+    # installed and uninstalled version of Tcl.
+    #
+    
+   if test -f $TCL_BIN_DIR/Makefile ; then
+      TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC}
+      TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC}
+      TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH}
+    fi
+    
+    #
+    # eval is required to do the TCL_DBGX substitution
+    #
+    
+    eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\""
+    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
+    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
+    
+    eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\""
+    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
+    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""
+    
+    AC_SUBST(TCL_VERSION)
+    AC_SUBST(TCL_BIN_DIR)
+    AC_SUBST(TCL_SRC_DIR)
+    AC_SUBST(TCL_LIBS)
+    AC_SUBST(TCL_INCLUDE_SPEC)
+    
+    AC_SUBST(TCL_LIB_FILE)
+    AC_SUBST(TCL_LIB_FLAG)
+    AC_SUBST(TCL_LIB_SPEC)
+    
+    AC_SUBST(TCL_STUB_LIB_FILE)
+    AC_SUBST(TCL_STUB_LIB_FLAG)
+    AC_SUBST(TCL_STUB_LIB_SPEC)
+  fi
+fi
+if test "${use_tcl}" = "no" ; then
+  HAVE_TCL=""
+else
+  HAVE_TCL=1
+fi
+AC_SUBST(HAVE_TCL)
+
+##########
+# Figure out what C libraries are required to compile programs
+# that use "readline()" library.
+#
+TARGET_READLINE_LIBS=""
+TARGET_READLINE_INC=""
+TARGET_HAVE_READLINE=0
+AC_ARG_ENABLE([readline],
+	[AC_HELP_STRING([--disable-readline],[disable readline support [default=detect]])],
+	[with_readline=$enableval],
+	[with_readline=auto])
+
+if test x"$with_readline" != xno; then
+	found="yes"
+
+	AC_ARG_WITH([readline-lib],
+		[AC_HELP_STRING([--with-readline-lib],[specify readline library])],
+		[with_readline_lib=$withval],
+		[with_readline_lib="auto"])
+	if test "x$with_readline_lib" = xauto; then
+		save_LIBS="$LIBS"
+		LIBS=""
+		AC_SEARCH_LIBS(tgetent, [readline ncurses curses termcap], [term_LIBS="$LIBS"], [term_LIBS=""])
+		AC_CHECK_LIB([readline], [readline], [TARGET_READLINE_LIBS="-lreadline"], [found="no"])
+		TARGET_READLINE_LIBS="$TARGET_READLINE_LIBS $term_LIBS"
+		LIBS="$save_LIBS"
+	else
+		TARGET_READLINE_LIBS="$with_readline_lib"
+	fi
+
+	AC_ARG_WITH([readline-inc],
+		[AC_HELP_STRING([--with-readline-inc],[specify readline include paths])],
+		[with_readline_inc=$withval],
+		[with_readline_inc="auto"])
+	if test "x$with_readline_inc" = xauto; then
+		AC_CHECK_HEADER(readline.h, [found="yes"], [
+			found="no"
+			if test "$cross_compiling" != yes; then
+				for dir in /usr /usr/local /usr/local/readline /usr/contrib /mingw; do
+					for subdir in include include/readline; do
+						AC_CHECK_FILE($dir/$subdir/readline.h, found=yes)
+						if test "$found" = "yes"; then
+							TARGET_READLINE_INC="-I$dir/$subdir"
+							break
+						fi
+					done
+					test "$found" = "yes" && break
+				done
+			fi
+		])
+	else
+		TARGET_READLINE_INC="$with_readline_inc"
+	fi
+
+	if test x"$found" = xno; then
+		TARGET_READLINE_LIBS=""
+		TARGET_READLINE_INC=""
+		TARGET_HAVE_READLINE=0
+	else
+		TARGET_HAVE_READLINE=1
+	fi
+fi
+
+AC_SUBST(TARGET_READLINE_LIBS)
+AC_SUBST(TARGET_READLINE_INC)
+AC_SUBST(TARGET_HAVE_READLINE)
+
+##########
+# Figure out what C libraries are required to compile programs
+# that use "fdatasync()" function.
+#
+AC_SEARCH_LIBS(fdatasync, [rt])
+
+#########
+# check for debug enabled
+AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],[enable debugging & verbose explain]),
+      [use_debug=$enableval],[use_debug=no])
+if test "${use_debug}" = "yes" ; then
+  TARGET_DEBUG="-DSQLITE_DEBUG=1"
+else
+  TARGET_DEBUG="-DNDEBUG"
+fi
+AC_SUBST(TARGET_DEBUG)
+
+#########
+# Figure out whether or not we have a "usleep()" function.
+#
+AC_CHECK_FUNC(usleep, [TARGET_CFLAGS="$TARGET_CFLAGS -DHAVE_USLEEP=1"])
+
+#--------------------------------------------------------------------
+# Redefine fdatasync as fsync on systems that lack fdatasync
+#--------------------------------------------------------------------
+
+AC_CHECK_FUNC(fdatasync, [TARGET_CFLAGS="$TARGET_CFLAGS -DHAVE_FDATASYNC=1"])
+
+#########
+# Generate the output files.
+#
+AC_OUTPUT([
+Makefile
+sqlite3.pc
+])
diff --git a/client/src/thirdparty/sqlite-3.4.2/contrib/sqlitecon.tcl b/client/src/thirdparty/sqlite-3.4.2/contrib/sqlitecon.tcl
new file mode 100644
index 0000000..b5dbcaf
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/contrib/sqlitecon.tcl
@@ -0,0 +1,679 @@
+# A Tk console widget for SQLite.  Invoke sqlitecon::create with a window name,
+# a prompt string, a title to set a new top-level window, and the SQLite
+# database handle.  For example:
+#
+#     sqlitecon::create .sqlcon {sql:- } {SQL Console} db
+#
+# A toplevel window is created that allows you to type in SQL commands to
+# be processed on the spot.
+#
+# A limited set of dot-commands are supported:
+#
+#     .table
+#     .schema ?TABLE?
+#     .mode list|column|multicolumn|line
+#     .exit
+#
+# In addition, a new SQL function named "edit()" is created.  This function
+# takes a single text argument and returns a text result.  Whenever the
+# the function is called, it pops up a new toplevel window containing a
+# text editor screen initialized to the argument.  When the "OK" button
+# is pressed, whatever revised text is in the text editor is returned as
+# the result of the edit() function.  This allows text fields of SQL tables
+# to be edited quickly and easily as follows:
+#
+#    UPDATE table1 SET dscr = edit(dscr) WHERE rowid=15;
+#
+
+
+# Create a namespace to work in
+#
+namespace eval ::sqlitecon {
+  # do nothing
+}
+
+# Create a console widget named $w.  The prompt string is $prompt.
+# The title at the top of the window is $title.  The database connection
+# object is $db
+#
+proc sqlitecon::create {w prompt title db} {
+  upvar #0 $w.t v
+  if {[winfo exists $w]} {destroy $w}
+  if {[info exists v]} {unset v}
+  toplevel $w
+  wm title $w $title
+  wm iconname $w $title
+  frame $w.mb -bd 2 -relief raised
+  pack $w.mb -side top -fill x
+  menubutton $w.mb.file -text File -menu $w.mb.file.m
+  menubutton $w.mb.edit -text Edit -menu $w.mb.edit.m
+  pack $w.mb.file $w.mb.edit -side left -padx 8 -pady 1
+  set m [menu $w.mb.file.m -tearoff 0]
+  $m add command -label {Close} -command "destroy $w"
+  sqlitecon::create_child $w $prompt $w.mb.edit.m
+  set v(db) $db
+  $db function edit ::sqlitecon::_edit
+}
+
+# This routine creates a console as a child window within a larger
+# window.  It also creates an edit menu named "$editmenu" if $editmenu!="".
+# The calling function is responsible for posting the edit menu.
+#
+proc sqlitecon::create_child {w prompt editmenu} {
+  upvar #0 $w.t v
+  if {$editmenu!=""} {
+    set m [menu $editmenu -tearoff 0]
+    $m add command -label Cut -command "sqlitecon::Cut $w.t"
+    $m add command -label Copy -command "sqlitecon::Copy $w.t"
+    $m add command -label Paste -command "sqlitecon::Paste $w.t"
+    $m add command -label {Clear Screen} -command "sqlitecon::Clear $w.t"
+    $m add separator
+    $m add command -label {Save As...} -command "sqlitecon::SaveFile $w.t"
+    catch {$editmenu config -postcommand "sqlitecon::EnableEditMenu $w"}
+  }
+  scrollbar $w.sb -orient vertical -command "$w.t yview"
+  pack $w.sb -side right -fill y
+  text $w.t -font fixed -yscrollcommand "$w.sb set"
+  pack $w.t -side right -fill both -expand 1
+  bindtags $w.t Sqlitecon
+  set v(editmenu) $editmenu
+  set v(history) 0
+  set v(historycnt) 0
+  set v(current) -1
+  set v(prompt) $prompt
+  set v(prior) {}
+  set v(plength) [string length $v(prompt)]
+  set v(x) 0
+  set v(y) 0
+  set v(mode) column
+  set v(header) on
+  $w.t mark set insert end
+  $w.t tag config ok -foreground blue
+  $w.t tag config err -foreground red
+  $w.t insert end $v(prompt)
+  $w.t mark set out 1.0
+  after idle "focus $w.t"
+}
+
+bind Sqlitecon <1> {sqlitecon::Button1 %W %x %y}
+bind Sqlitecon <B1-Motion> {sqlitecon::B1Motion %W %x %y}
+bind Sqlitecon <B1-Leave> {sqlitecon::B1Leave %W %x %y}
+bind Sqlitecon <B1-Enter> {sqlitecon::cancelMotor %W}
+bind Sqlitecon <ButtonRelease-1> {sqlitecon::cancelMotor %W}
+bind Sqlitecon <KeyPress> {sqlitecon::Insert %W %A}
+bind Sqlitecon <Left> {sqlitecon::Left %W}
+bind Sqlitecon <Control-b> {sqlitecon::Left %W}
+bind Sqlitecon <Right> {sqlitecon::Right %W}
+bind Sqlitecon <Control-f> {sqlitecon::Right %W}
+bind Sqlitecon <BackSpace> {sqlitecon::Backspace %W}
+bind Sqlitecon <Control-h> {sqlitecon::Backspace %W}
+bind Sqlitecon <Delete> {sqlitecon::Delete %W}
+bind Sqlitecon <Control-d> {sqlitecon::Delete %W}
+bind Sqlitecon <Home> {sqlitecon::Home %W}
+bind Sqlitecon <Control-a> {sqlitecon::Home %W}
+bind Sqlitecon <End> {sqlitecon::End %W}
+bind Sqlitecon <Control-e> {sqlitecon::End %W}
+bind Sqlitecon <Return> {sqlitecon::Enter %W}
+bind Sqlitecon <KP_Enter> {sqlitecon::Enter %W}
+bind Sqlitecon <Up> {sqlitecon::Prior %W}
+bind Sqlitecon <Control-p> {sqlitecon::Prior %W}
+bind Sqlitecon <Down> {sqlitecon::Next %W}
+bind Sqlitecon <Control-n> {sqlitecon::Next %W}
+bind Sqlitecon <Control-k> {sqlitecon::EraseEOL %W}
+bind Sqlitecon <<Cut>> {sqlitecon::Cut %W}
+bind Sqlitecon <<Copy>> {sqlitecon::Copy %W}
+bind Sqlitecon <<Paste>> {sqlitecon::Paste %W}
+bind Sqlitecon <<Clear>> {sqlitecon::Clear %W}
+
+# Insert a single character at the insertion cursor
+#
+proc sqlitecon::Insert {w a} {
+  $w insert insert $a
+  $w yview insert
+}
+
+# Move the cursor one character to the left
+#
+proc sqlitecon::Left {w} {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  if {$col>$v(plength)} {
+    $w mark set insert "insert -1c"
+  }
+}
+
+# Erase the character to the left of the cursor
+#
+proc sqlitecon::Backspace {w} {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  if {$col>$v(plength)} {
+    $w delete {insert -1c}
+  }
+}
+
+# Erase to the end of the line
+#
+proc sqlitecon::EraseEOL {w} {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  if {$col>=$v(plength)} {
+    $w delete insert {insert lineend}
+  }
+}
+
+# Move the cursor one character to the right
+#
+proc sqlitecon::Right {w} {
+  $w mark set insert "insert +1c"
+}
+
+# Erase the character to the right of the cursor
+#
+proc sqlitecon::Delete w {
+  $w delete insert
+}
+
+# Move the cursor to the beginning of the current line
+#
+proc sqlitecon::Home w {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  $w mark set insert $row.$v(plength)
+}
+
+# Move the cursor to the end of the current line
+#
+proc sqlitecon::End w {
+  $w mark set insert {insert lineend}
+}
+
+# Add a line to the history
+#
+proc sqlitecon::addHistory {w line} {
+  upvar #0 $w v
+  if {$v(historycnt)>0} {
+    set last [lindex $v(history) [expr $v(historycnt)-1]]
+    if {[string compare $last $line]} {
+      lappend v(history) $line
+      incr v(historycnt)
+    }
+  } else {
+    set v(history) [list $line]
+    set v(historycnt) 1
+  }
+  set v(current) $v(historycnt)
+}
+
+# Called when "Enter" is pressed.  Do something with the line
+# of text that was entered.
+#
+proc sqlitecon::Enter w {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  set start $row.$v(plength)
+  set line [$w get $start "$start lineend"]
+  $w insert end \n
+  $w mark set out end
+  if {$v(prior)==""} {
+    set cmd $line
+  } else {
+    set cmd $v(prior)\n$line
+  }
+  if {[string index $cmd 0]=="." || [$v(db) complete $cmd]} {
+    regsub -all {\n} [string trim $cmd] { } cmd2
+    addHistory $w $cmd2
+    set rc [catch {DoCommand $w $cmd} res]
+    if {![winfo exists $w]} return
+    if {$rc} {
+      $w insert end $res\n err
+    } elseif {[string length $res]>0} {
+      $w insert end $res\n ok
+    }
+    set v(prior) {}
+    $w insert end $v(prompt)
+  } else {
+    set v(prior) $cmd
+    regsub -all {[^ ]} $v(prompt) . x
+    $w insert end $x
+  }
+  $w mark set insert end
+  $w mark set out {insert linestart}
+  $w yview insert
+}
+
+# Execute a single SQL command.  Pay special attention to control
+# directives that begin with "."
+#
+# The return value is the text output from the command, properly
+# formatted.
+#
+proc sqlitecon::DoCommand {w cmd} {
+  upvar #0 $w v
+  set mode $v(mode)
+  set header $v(header)
+  if {[regexp {^(\.[a-z]+)} $cmd all word]} {
+    if {$word==".mode"} {
+      regexp {^.[a-z]+ +([a-z]+)} $cmd all v(mode)
+      return {}
+    } elseif {$word==".exit"} {
+      destroy [winfo toplevel $w]
+      return {}
+    } elseif {$word==".header"} {
+      regexp {^.[a-z]+ +([a-z]+)} $cmd all v(header)
+      return {}
+    } elseif {$word==".tables"} {
+      set mode multicolumn
+      set cmd {SELECT name FROM sqlite_master WHERE type='table'
+               UNION ALL
+               SELECT name FROM sqlite_temp_master WHERE type='table'}
+      $v(db) eval {PRAGMA database_list} {
+         if {$name!="temp" && $name!="main"} {
+            append cmd "UNION ALL SELECT name FROM $name.sqlite_master\
+                        WHERE type='table'"
+         }
+      }
+      append cmd  { ORDER BY 1}
+    } elseif {$word==".fullschema"} {
+      set pattern %
+      regexp {^.[a-z]+ +([^ ]+)} $cmd all pattern
+      set mode list
+      set header 0
+      set cmd "SELECT sql FROM sqlite_master WHERE tbl_name LIKE '$pattern'
+               AND sql NOT NULL UNION ALL SELECT sql FROM sqlite_temp_master
+               WHERE tbl_name LIKE '$pattern' AND sql NOT NULL"
+      $v(db) eval {PRAGMA database_list} {
+         if {$name!="temp" && $name!="main"} {
+            append cmd " UNION ALL SELECT sql FROM $name.sqlite_master\
+                        WHERE tbl_name LIKE '$pattern' AND sql NOT NULL"
+         }
+      }
+    } elseif {$word==".schema"} {
+      set pattern %
+      regexp {^.[a-z]+ +([^ ]+)} $cmd all pattern
+      set mode list
+      set header 0
+      set cmd "SELECT sql FROM sqlite_master WHERE name LIKE '$pattern'
+               AND sql NOT NULL UNION ALL SELECT sql FROM sqlite_temp_master
+               WHERE name LIKE '$pattern' AND sql NOT NULL"
+      $v(db) eval {PRAGMA database_list} {
+         if {$name!="temp" && $name!="main"} {
+            append cmd " UNION ALL SELECT sql FROM $name.sqlite_master\
+                        WHERE name LIKE '$pattern' AND sql NOT NULL"
+         }
+      }
+    } else {
+      return \
+        ".exit\n.mode line|list|column\n.schema ?TABLENAME?\n.tables"
+    }
+  }
+  set res {}
+  if {$mode=="list"} {
+    $v(db) eval $cmd x {
+      set sep {}
+      foreach col $x(*) {
+        append res $sep$x($col)
+        set sep |
+      }
+      append res \n
+    }
+    if {[info exists x(*)] && $header} {
+      set sep {}
+      set hdr {}
+      foreach col $x(*) {
+        append hdr $sep$col
+        set sep |
+      }
+      set res $hdr\n$res
+    }
+  } elseif {[string range $mode 0 2]=="col"} {
+    set y {}
+    $v(db) eval $cmd x {
+      foreach col $x(*) {
+        if {![info exists cw($col)] || $cw($col)<[string length $x($col)]} {
+           set cw($col) [string length $x($col)]
+        }
+        lappend y $x($col)
+      }
+    }
+    if {[info exists x(*)] && $header} {
+      set hdr {}
+      set ln {}
+      set dash ---------------------------------------------------------------
+      append dash ------------------------------------------------------------
+      foreach col $x(*) {
+        if {![info exists cw($col)] || $cw($col)<[string length $col]} {
+           set cw($col) [string length $col]
+        }
+        lappend hdr $col
+        lappend ln [string range $dash 1 $cw($col)]
+      }
+      set y [concat $hdr $ln $y]
+    }
+    if {[info exists x(*)]} {
+      set format {}
+      set arglist {}
+      set arglist2 {}
+      set i 0
+      foreach col $x(*) {
+        lappend arglist x$i
+        append arglist2 " \$x$i"
+        incr i
+        append format "  %-$cw($col)s"
+      }
+      set format [string trimleft $format]\n
+      if {[llength $arglist]>0} {
+        foreach $arglist $y "append res \[format [list $format] $arglist2\]"
+      }
+    }
+  } elseif {$mode=="multicolumn"} {
+    set y [$v(db) eval $cmd]
+    set max 0
+    foreach e $y {
+      if {$max<[string length $e]} {set max [string length $e]}
+    }
+    set ncol [expr {int(80/($max+2))}]
+    if {$ncol<1} {set ncol 1}
+    set nelem [llength $y]
+    set nrow [expr {($nelem+$ncol-1)/$ncol}]
+    set format "%-${max}s"
+    for {set i 0} {$i<$nrow} {incr i} {
+      set j $i
+      while 1 {
+        append res [format $format [lindex $y $j]]
+        incr j $nrow
+        if {$j>=$nelem} break
+        append res {  }
+      }
+      append res \n
+    }
+  } else {
+    $v(db) eval $cmd x {
+      foreach col $x(*) {append res "$col = $x($col)\n"}
+      append res \n
+    }
+  }
+  return [string trimright $res]
+}
+
+# Change the line to the previous line
+#
+proc sqlitecon::Prior w {
+  upvar #0 $w v
+  if {$v(current)<=0} return
+  incr v(current) -1
+  set line [lindex $v(history) $v(current)]
+  sqlitecon::SetLine $w $line
+}
+
+# Change the line to the next line
+#
+proc sqlitecon::Next w {
+  upvar #0 $w v
+  if {$v(current)>=$v(historycnt)} return
+  incr v(current) 1
+  set line [lindex $v(history) $v(current)]
+  sqlitecon::SetLine $w $line
+}
+
+# Change the contents of the entry line
+#
+proc sqlitecon::SetLine {w line} {
+  upvar #0 $w v
+  scan [$w index insert] %d.%d row col
+  set start $row.$v(plength)
+  $w delete $start end
+  $w insert end $line
+  $w mark set insert end
+  $w yview insert
+}
+
+# Called when the mouse button is pressed at position $x,$y on
+# the console widget.
+#
+proc sqlitecon::Button1 {w x y} {
+  global tkPriv
+  upvar #0 $w v
+  set v(mouseMoved) 0
+  set v(pressX) $x
+  set p [sqlitecon::nearestBoundry $w $x $y]
+  scan [$w index insert] %d.%d ix iy
+  scan $p %d.%d px py
+  if {$px==$ix} {
+    $w mark set insert $p
+  }
+  $w mark set anchor $p
+  focus $w
+}
+
+# Find the boundry between characters that is nearest
+# to $x,$y
+#
+proc sqlitecon::nearestBoundry {w x y} {
+  set p [$w index @$x,$y]
+  set bb [$w bbox $p]
+  if {![string compare $bb ""]} {return $p}
+  if {($x-[lindex $bb 0])<([lindex $bb 2]/2)} {return $p}
+  $w index "$p + 1 char"
+}
+
+# This routine extends the selection to the point specified by $x,$y
+#
+proc sqlitecon::SelectTo {w x y} {
+  upvar #0 $w v
+  set cur [sqlitecon::nearestBoundry $w $x $y]
+  if {[catch {$w index anchor}]} {
+    $w mark set anchor $cur
+  }
+  set anchor [$w index anchor]
+  if {[$w compare $cur != $anchor] || (abs($v(pressX) - $x) >= 3)} {
+    if {$v(mouseMoved)==0} {
+      $w tag remove sel 0.0 end
+    }
+    set v(mouseMoved) 1
+  }
+  if {[$w compare $cur < anchor]} {
+    set first $cur
+    set last anchor
+  } else {
+    set first anchor
+    set last $cur
+  }
+  if {$v(mouseMoved)} {
+    $w tag remove sel 0.0 $first
+    $w tag add sel $first $last
+    $w tag remove sel $last end
+    update idletasks
+  }
+}
+
+# Called whenever the mouse moves while button-1 is held down.
+#
+proc sqlitecon::B1Motion {w x y} {
+  upvar #0 $w v
+  set v(y) $y
+  set v(x) $x
+  sqlitecon::SelectTo $w $x $y
+}
+
+# Called whenever the mouse leaves the boundries of the widget
+# while button 1 is held down.
+#
+proc sqlitecon::B1Leave {w x y} {
+  upvar #0 $w v
+  set v(y) $y
+  set v(x) $x
+  sqlitecon::motor $w
+}
+
+# This routine is called to automatically scroll the window when
+# the mouse drags offscreen.
+#
+proc sqlitecon::motor w {
+  upvar #0 $w v
+  if {![winfo exists $w]} return
+  if {$v(y)>=[winfo height $w]} {
+    $w yview scroll 1 units
+  } elseif {$v(y)<0} {
+    $w yview scroll -1 units
+  } else {
+    return
+  }
+  sqlitecon::SelectTo $w $v(x) $v(y)
+  set v(timer) [after 50 sqlitecon::motor $w]
+}
+
+# This routine cancels the scrolling motor if it is active
+#
+proc sqlitecon::cancelMotor w {
+  upvar #0 $w v
+  catch {after cancel $v(timer)}
+  catch {unset v(timer)}
+}
+
+# Do a Copy operation on the stuff currently selected.
+#
+proc sqlitecon::Copy w {
+  if {![catch {set text [$w get sel.first sel.last]}]} {
+     clipboard clear -displayof $w
+     clipboard append -displayof $w $text
+  }
+}
+
+# Return 1 if the selection exists and is contained
+# entirely on the input line.  Return 2 if the selection
+# exists but is not entirely on the input line.  Return 0
+# if the selection does not exist.
+#
+proc sqlitecon::canCut w {
+  set r [catch {
+    scan [$w index sel.first] %d.%d s1x s1y
+    scan [$w index sel.last] %d.%d s2x s2y
+    scan [$w index insert] %d.%d ix iy
+  }]
+  if {$r==1} {return 0}
+  if {$s1x==$ix && $s2x==$ix} {return 1}
+  return 2
+}
+
+# Do a Cut operation if possible.  Cuts are only allowed
+# if the current selection is entirely contained on the
+# current input line.
+#
+proc sqlitecon::Cut w {
+  if {[sqlitecon::canCut $w]==1} {
+    sqlitecon::Copy $w
+    $w delete sel.first sel.last
+  }
+}
+
+# Do a paste opeation.
+#
+proc sqlitecon::Paste w {
+  if {[sqlitecon::canCut $w]==1} {
+    $w delete sel.first sel.last
+  }
+  if {[catch {selection get -displayof $w -selection CLIPBOARD} topaste]
+    && [catch {selection get -displayof $w -selection PRIMARY} topaste]} {
+    return
+  }
+  if {[info exists ::$w]} {
+    set prior 0
+    foreach line [split $topaste \n] {
+      if {$prior} {
+        sqlitecon::Enter $w
+        update
+      }
+      set prior 1
+      $w insert insert $line
+    }
+  } else {
+    $w insert insert $topaste
+  }
+}
+
+# Enable or disable entries in the Edit menu
+#
+proc sqlitecon::EnableEditMenu w {
+  upvar #0 $w.t v
+  set m $v(editmenu)
+  if {$m=="" || ![winfo exists $m]} return
+  switch [sqlitecon::canCut $w.t] {
+    0 {
+      $m entryconf Copy -state disabled
+      $m entryconf Cut -state disabled
+    }
+    1 {
+      $m entryconf Copy -state normal
+      $m entryconf Cut -state normal
+    }
+    2 {
+      $m entryconf Copy -state normal
+      $m entryconf Cut -state disabled
+    }
+  }
+}
+
+# Prompt the user for the name of a writable file.  Then write the
+# entire contents of the console screen to that file.
+#
+proc sqlitecon::SaveFile w {
+  set types {
+    {{Text Files}  {.txt}}
+    {{All Files}    *}
+  }
+  set f [tk_getSaveFile -filetypes $types -title "Write Screen To..."]
+  if {$f!=""} {
+    if {[catch {open $f w} fd]} {
+      tk_messageBox -type ok -icon error -message $fd
+    } else {
+      puts $fd [string trimright [$w get 1.0 end] \n]
+      close $fd
+    }
+  }
+}
+
+# Erase everything from the console above the insertion line.
+#
+proc sqlitecon::Clear w {
+  $w delete 1.0 {insert linestart}
+}
+
+# An in-line editor for SQL
+#
+proc sqlitecon::_edit {origtxt {title {}}} {
+  for {set i 0} {[winfo exists .ed$i]} {incr i} continue
+  set w .ed$i
+  toplevel $w
+  wm protocol $w WM_DELETE_WINDOW "$w.b.can invoke"
+  wm title $w {Inline SQL Editor}
+  frame $w.b
+  pack $w.b -side bottom -fill x
+  button $w.b.can -text Cancel -width 6 -command [list set ::$w 0]
+  button $w.b.ok -text OK -width 6 -command [list set ::$w 1]
+  button $w.b.cut -text Cut -width 6 -command [list ::sqlitecon::Cut $w.t]
+  button $w.b.copy -text Copy -width 6 -command [list ::sqlitecon::Copy $w.t]
+  button $w.b.paste -text Paste -width 6 -command [list ::sqlitecon::Paste $w.t]
+  set ::$w {}
+  pack $w.b.cut $w.b.copy $w.b.paste $w.b.can $w.b.ok\
+     -side left -padx 5 -pady 5 -expand 1
+  if {$title!=""} {
+    label $w.title -text $title
+    pack $w.title -side top -padx 5 -pady 5
+  }
+  text $w.t -bg white -fg black -yscrollcommand [list $w.sb set]
+  pack $w.t -side left -fill both -expand 1
+  scrollbar $w.sb -orient vertical -command [list $w.t yview]
+  pack $w.sb -side left -fill y
+  $w.t insert end $origtxt
+
+  vwait ::$w
+
+  if {[set ::$w]} {
+    set txt [string trimright [$w.t get 1.0 end]]
+  } else {
+    set txt $origtxt
+  }
+  destroy $w
+  return $txt
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/doc/lemon.html b/client/src/thirdparty/sqlite-3.4.2/doc/lemon.html
new file mode 100644
index 0000000..6a4d6db
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/doc/lemon.html
@@ -0,0 +1,892 @@
+<html>
+<head>
+<title>The Lemon Parser Generator</title>
+</head>
+<body bgcolor=white>
+<h1 align=center>The Lemon Parser Generator</h1>
+
+<p>Lemon is an LALR(1) parser generator for C or C++.  
+It does the same job as ``bison'' and ``yacc''.
+But lemon is not another bison or yacc clone.  It
+uses a different grammar syntax which is designed to
+reduce the number of coding errors.  Lemon also uses a more
+sophisticated parsing engine that is faster than yacc and
+bison and which is both reentrant and thread-safe.
+Furthermore, Lemon implements features that can be used
+to eliminate resource leaks, making is suitable for use
+in long-running programs such as graphical user interfaces
+or embedded controllers.</p>
+
+<p>This document is an introduction to the Lemon
+parser generator.</p>
+
+<h2>Theory of Operation</h2>
+
+<p>The main goal of Lemon is to translate a context free grammar (CFG)
+for a particular language into C code that implements a parser for
+that language.
+The program has two inputs:
+<ul>
+<li>The grammar specification.
+<li>A parser template file.
+</ul>
+Typically, only the grammar specification is supplied by the programmer.
+Lemon comes with a default parser template which works fine for most
+applications.  But the user is free to substitute a different parser
+template if desired.</p>
+
+<p>Depending on command-line options, Lemon will generate between
+one and three files of outputs.
+<ul>
+<li>C code to implement the parser.
+<li>A header file defining an integer ID for each terminal symbol.
+<li>An information file that describes the states of the generated parser
+    automaton.
+</ul>
+By default, all three of these output files are generated.
+The header file is suppressed if the ``-m'' command-line option is
+used and the report file is omitted when ``-q'' is selected.</p>
+
+<p>The grammar specification file uses a ``.y'' suffix, by convention.
+In the examples used in this document, we'll assume the name of the
+grammar file is ``gram.y''.  A typical use of Lemon would be the
+following command:
+<pre>
+   lemon gram.y
+</pre>
+This command will generate three output files named ``gram.c'',
+``gram.h'' and ``gram.out''.
+The first is C code to implement the parser.  The second
+is the header file that defines numerical values for all
+terminal symbols, and the last is the report that explains
+the states used by the parser automaton.</p>
+
+<h3>Command Line Options</h3>
+
+<p>The behavior of Lemon can be modified using command-line options.
+You can obtain a list of the available command-line options together
+with a brief explanation of what each does by typing
+<pre>
+   lemon -?
+</pre>
+As of this writing, the following command-line options are supported:
+<ul>
+<li><tt>-b</tt>
+<li><tt>-c</tt>
+<li><tt>-g</tt>
+<li><tt>-m</tt>
+<li><tt>-q</tt>
+<li><tt>-s</tt>
+<li><tt>-x</tt>
+</ul>
+The ``-b'' option reduces the amount of text in the report file by
+printing only the basis of each parser state, rather than the full
+configuration.
+The ``-c'' option suppresses action table compression.  Using -c
+will make the parser a little larger and slower but it will detect
+syntax errors sooner.
+The ``-g'' option causes no output files to be generated at all.
+Instead, the input grammar file is printed on standard output but
+with all comments, actions and other extraneous text deleted.  This
+is a useful way to get a quick summary of a grammar.
+The ``-m'' option causes the output C source file to be compatible
+with the ``makeheaders'' program.
+Makeheaders is a program that automatically generates header files
+from C source code.  When the ``-m'' option is used, the header
+file is not output since the makeheaders program will take care
+of generated all header files automatically.
+The ``-q'' option suppresses the report file.
+Using ``-s'' causes a brief summary of parser statistics to be
+printed.  Like this:
+<pre>
+   Parser statistics: 74 terminals, 70 nonterminals, 179 rules
+                      340 states, 2026 parser table entries, 0 conflicts
+</pre>
+Finally, the ``-x'' option causes Lemon to print its version number
+and then stops without attempting to read the grammar or generate a parser.</p>
+
+<h3>The Parser Interface</h3>
+
+<p>Lemon doesn't generate a complete, working program.  It only generates
+a few subroutines that implement a parser.  This section describes
+the interface to those subroutines.  It is up to the programmer to
+call these subroutines in an appropriate way in order to produce a
+complete system.</p>
+
+<p>Before a program begins using a Lemon-generated parser, the program
+must first create the parser.
+A new parser is created as follows:
+<pre>
+   void *pParser = ParseAlloc( malloc );
+</pre>
+The ParseAlloc() routine allocates and initializes a new parser and
+returns a pointer to it.
+The actual data structure used to represent a parser is opaque --
+its internal structure is not visible or usable by the calling routine.
+For this reason, the ParseAlloc() routine returns a pointer to void
+rather than a pointer to some particular structure.
+The sole argument to the ParseAlloc() routine is a pointer to the
+subroutine used to allocate memory.  Typically this means ``malloc()''.</p>
+
+<p>After a program is finished using a parser, it can reclaim all
+memory allocated by that parser by calling
+<pre>
+   ParseFree(pParser, free);
+</pre>
+The first argument is the same pointer returned by ParseAlloc().  The
+second argument is a pointer to the function used to release bulk
+memory back to the system.</p>
+
+<p>After a parser has been allocated using ParseAlloc(), the programmer
+must supply the parser with a sequence of tokens (terminal symbols) to
+be parsed.  This is accomplished by calling the following function
+once for each token:
+<pre>
+   Parse(pParser, hTokenID, sTokenData, pArg);
+</pre>
+The first argument to the Parse() routine is the pointer returned by
+ParseAlloc().
+The second argument is a small positive integer that tells the parse the
+type of the next token in the data stream.
+There is one token type for each terminal symbol in the grammar.
+The gram.h file generated by Lemon contains #define statements that
+map symbolic terminal symbol names into appropriate integer values.
+(A value of 0 for the second argument is a special flag to the
+parser to indicate that the end of input has been reached.)
+The third argument is the value of the given token.  By default,
+the type of the third argument is integer, but the grammar will
+usually redefine this type to be some kind of structure.
+Typically the second argument will be a broad category of tokens
+such as ``identifier'' or ``number'' and the third argument will
+be the name of the identifier or the value of the number.</p>
+
+<p>The Parse() function may have either three or four arguments,
+depending on the grammar.  If the grammar specification file request
+it, the Parse() function will have a fourth parameter that can be
+of any type chosen by the programmer.  The parser doesn't do anything
+with this argument except to pass it through to action routines.
+This is a convenient mechanism for passing state information down
+to the action routines without having to use global variables.</p>
+
+<p>A typical use of a Lemon parser might look something like the
+following:
+<pre>
+   01 ParseTree *ParseFile(const char *zFilename){
+   02    Tokenizer *pTokenizer;
+   03    void *pParser;
+   04    Token sToken;
+   05    int hTokenId;
+   06    ParserState sState;
+   07
+   08    pTokenizer = TokenizerCreate(zFilename);
+   09    pParser = ParseAlloc( malloc );
+   10    InitParserState(&sState);
+   11    while( GetNextToken(pTokenizer, &hTokenId, &sToken) ){
+   12       Parse(pParser, hTokenId, sToken, &sState);
+   13    }
+   14    Parse(pParser, 0, sToken, &sState);
+   15    ParseFree(pParser, free );
+   16    TokenizerFree(pTokenizer);
+   17    return sState.treeRoot;
+   18 }
+</pre>
+This example shows a user-written routine that parses a file of
+text and returns a pointer to the parse tree.
+(We've omitted all error-handling from this example to keep it
+simple.)
+We assume the existence of some kind of tokenizer which is created
+using TokenizerCreate() on line 8 and deleted by TokenizerFree()
+on line 16.  The GetNextToken() function on line 11 retrieves the
+next token from the input file and puts its type in the 
+integer variable hTokenId.  The sToken variable is assumed to be
+some kind of structure that contains details about each token,
+such as its complete text, what line it occurs on, etc. </p>
+
+<p>This example also assumes the existence of structure of type
+ParserState that holds state information about a particular parse.
+An instance of such a structure is created on line 6 and initialized
+on line 10.  A pointer to this structure is passed into the Parse()
+routine as the optional 4th argument.
+The action routine specified by the grammar for the parser can use
+the ParserState structure to hold whatever information is useful and
+appropriate.  In the example, we note that the treeRoot field of
+the ParserState structure is left pointing to the root of the parse
+tree.</p>
+
+<p>The core of this example as it relates to Lemon is as follows:
+<pre>
+   ParseFile(){
+      pParser = ParseAlloc( malloc );
+      while( GetNextToken(pTokenizer,&hTokenId, &sToken) ){
+         Parse(pParser, hTokenId, sToken);
+      }
+      Parse(pParser, 0, sToken);
+      ParseFree(pParser, free );
+   }
+</pre>
+Basically, what a program has to do to use a Lemon-generated parser
+is first create the parser, then send it lots of tokens obtained by
+tokenizing an input source.  When the end of input is reached, the
+Parse() routine should be called one last time with a token type
+of 0.  This step is necessary to inform the parser that the end of
+input has been reached.  Finally, we reclaim memory used by the
+parser by calling ParseFree().</p>
+
+<p>There is one other interface routine that should be mentioned
+before we move on.
+The ParseTrace() function can be used to generate debugging output
+from the parser.  A prototype for this routine is as follows:
+<pre>
+   ParseTrace(FILE *stream, char *zPrefix);
+</pre>
+After this routine is called, a short (one-line) message is written
+to the designated output stream every time the parser changes states
+or calls an action routine.  Each such message is prefaced using
+the text given by zPrefix.  This debugging output can be turned off
+by calling ParseTrace() again with a first argument of NULL (0).</p>
+
+<h3>Differences With YACC and BISON</h3>
+
+<p>Programmers who have previously used the yacc or bison parser
+generator will notice several important differences between yacc and/or
+bison and Lemon.
+<ul>
+<li>In yacc and bison, the parser calls the tokenizer.  In Lemon,
+    the tokenizer calls the parser.
+<li>Lemon uses no global variables.  Yacc and bison use global variables
+    to pass information between the tokenizer and parser.
+<li>Lemon allows multiple parsers to be running simultaneously.  Yacc
+    and bison do not.
+</ul>
+These differences may cause some initial confusion for programmers
+with prior yacc and bison experience.
+But after years of experience using Lemon, I firmly
+believe that the Lemon way of doing things is better.</p>
+
+<h2>Input File Syntax</h2>
+
+<p>The main purpose of the grammar specification file for Lemon is
+to define the grammar for the parser.  But the input file also
+specifies additional information Lemon requires to do its job.
+Most of the work in using Lemon is in writing an appropriate
+grammar file.</p>
+
+<p>The grammar file for lemon is, for the most part, free format.
+It does not have sections or divisions like yacc or bison.  Any
+declaration can occur at any point in the file.
+Lemon ignores whitespace (except where it is needed to separate
+tokens) and it honors the same commenting conventions as C and C++.</p>
+
+<h3>Terminals and Nonterminals</h3>
+
+<p>A terminal symbol (token) is any string of alphanumeric
+and underscore characters
+that begins with an upper case letter.
+A terminal can contain lower class letters after the first character,
+but the usual convention is to make terminals all upper case.
+A nonterminal, on the other hand, is any string of alphanumeric
+and underscore characters than begins with a lower case letter.
+Again, the usual convention is to make nonterminals use all lower
+case letters.</p>
+
+<p>In Lemon, terminal and nonterminal symbols do not need to 
+be declared or identified in a separate section of the grammar file.
+Lemon is able to generate a list of all terminals and nonterminals
+by examining the grammar rules, and it can always distinguish a
+terminal from a nonterminal by checking the case of the first
+character of the name.</p>
+
+<p>Yacc and bison allow terminal symbols to have either alphanumeric
+names or to be individual characters included in single quotes, like
+this: ')' or '$'.  Lemon does not allow this alternative form for
+terminal symbols.  With Lemon, all symbols, terminals and nonterminals,
+must have alphanumeric names.</p>
+
+<h3>Grammar Rules</h3>
+
+<p>The main component of a Lemon grammar file is a sequence of grammar
+rules.
+Each grammar rule consists of a nonterminal symbol followed by
+the special symbol ``::='' and then a list of terminals and/or nonterminals.
+The rule is terminated by a period.
+The list of terminals and nonterminals on the right-hand side of the
+rule can be empty.
+Rules can occur in any order, except that the left-hand side of the
+first rule is assumed to be the start symbol for the grammar (unless
+specified otherwise using the <tt>%start</tt> directive described below.)
+A typical sequence of grammar rules might look something like this:
+<pre>
+  expr ::= expr PLUS expr.
+  expr ::= expr TIMES expr.
+  expr ::= LPAREN expr RPAREN.
+  expr ::= VALUE.
+</pre>
+</p>
+
+<p>There is one non-terminal in this example, ``expr'', and five
+terminal symbols or tokens: ``PLUS'', ``TIMES'', ``LPAREN'',
+``RPAREN'' and ``VALUE''.</p>
+
+<p>Like yacc and bison, Lemon allows the grammar to specify a block
+of C code that will be executed whenever a grammar rule is reduced
+by the parser.
+In Lemon, this action is specified by putting the C code (contained
+within curly braces <tt>{...}</tt>) immediately after the
+period that closes the rule.
+For example:
+<pre>
+  expr ::= expr PLUS expr.   { printf("Doing an addition...\n"); }
+</pre>
+</p>
+
+<p>In order to be useful, grammar actions must normally be linked to
+their associated grammar rules.
+In yacc and bison, this is accomplished by embedding a ``$$'' in the
+action to stand for the value of the left-hand side of the rule and
+symbols ``$1'', ``$2'', and so forth to stand for the value of
+the terminal or nonterminal at position 1, 2 and so forth on the
+right-hand side of the rule.
+This idea is very powerful, but it is also very error-prone.  The
+single most common source of errors in a yacc or bison grammar is
+to miscount the number of symbols on the right-hand side of a grammar
+rule and say ``$7'' when you really mean ``$8''.</p>
+
+<p>Lemon avoids the need to count grammar symbols by assigning symbolic
+names to each symbol in a grammar rule and then using those symbolic
+names in the action.
+In yacc or bison, one would write this:
+<pre>
+  expr -> expr PLUS expr  { $$ = $1 + $3; };
+</pre>
+But in Lemon, the same rule becomes the following:
+<pre>
+  expr(A) ::= expr(B) PLUS expr(C).  { A = B+C; }
+</pre>
+In the Lemon rule, any symbol in parentheses after a grammar rule
+symbol becomes a place holder for that symbol in the grammar rule.
+This place holder can then be used in the associated C action to
+stand for the value of that symbol.<p>
+
+<p>The Lemon notation for linking a grammar rule with its reduce
+action is superior to yacc/bison on several counts.
+First, as mentioned above, the Lemon method avoids the need to
+count grammar symbols.
+Secondly, if a terminal or nonterminal in a Lemon grammar rule
+includes a linking symbol in parentheses but that linking symbol
+is not actually used in the reduce action, then an error message
+is generated.
+For example, the rule
+<pre>
+  expr(A) ::= expr(B) PLUS expr(C).  { A = B; }
+</pre>
+will generate an error because the linking symbol ``C'' is used
+in the grammar rule but not in the reduce action.</p>
+
+<p>The Lemon notation for linking grammar rules to reduce actions
+also facilitates the use of destructors for reclaiming memory
+allocated by the values of terminals and nonterminals on the
+right-hand side of a rule.</p>
+
+<h3>Precedence Rules</h3>
+
+<p>Lemon resolves parsing ambiguities in exactly the same way as
+yacc and bison.  A shift-reduce conflict is resolved in favor
+of the shift, and a reduce-reduce conflict is resolved by reducing
+whichever rule comes first in the grammar file.</p>
+
+<p>Just like in
+yacc and bison, Lemon allows a measure of control 
+over the resolution of paring conflicts using precedence rules.
+A precedence value can be assigned to any terminal symbol
+using the %left, %right or %nonassoc directives.  Terminal symbols
+mentioned in earlier directives have a lower precedence that
+terminal symbols mentioned in later directives.  For example:</p>
+
+<p><pre>
+   %left AND.
+   %left OR.
+   %nonassoc EQ NE GT GE LT LE.
+   %left PLUS MINUS.
+   %left TIMES DIVIDE MOD.
+   %right EXP NOT.
+</pre></p>
+
+<p>In the preceding sequence of directives, the AND operator is
+defined to have the lowest precedence.  The OR operator is one
+precedence level higher.  And so forth.  Hence, the grammar would
+attempt to group the ambiguous expression
+<pre>
+     a AND b OR c
+</pre>
+like this
+<pre>
+     a AND (b OR c).
+</pre>
+The associativity (left, right or nonassoc) is used to determine
+the grouping when the precedence is the same.  AND is left-associative
+in our example, so
+<pre>
+     a AND b AND c
+</pre>
+is parsed like this
+<pre>
+     (a AND b) AND c.
+</pre>
+The EXP operator is right-associative, though, so
+<pre>
+     a EXP b EXP c
+</pre>
+is parsed like this
+<pre>
+     a EXP (b EXP c).
+</pre>
+The nonassoc precedence is used for non-associative operators.
+So
+<pre>
+     a EQ b EQ c
+</pre>
+is an error.</p>
+
+<p>The precedence of non-terminals is transferred to rules as follows:
+The precedence of a grammar rule is equal to the precedence of the
+left-most terminal symbol in the rule for which a precedence is
+defined.  This is normally what you want, but in those cases where
+you want to precedence of a grammar rule to be something different,
+you can specify an alternative precedence symbol by putting the
+symbol in square braces after the period at the end of the rule and
+before any C-code.  For example:</p>
+
+<p><pre>
+   expr = MINUS expr.  [NOT]
+</pre></p>
+
+<p>This rule has a precedence equal to that of the NOT symbol, not the
+MINUS symbol as would have been the case by default.</p>
+
+<p>With the knowledge of how precedence is assigned to terminal
+symbols and individual
+grammar rules, we can now explain precisely how parsing conflicts
+are resolved in Lemon.  Shift-reduce conflicts are resolved
+as follows:
+<ul>
+<li> If either the token to be shifted or the rule to be reduced
+     lacks precedence information, then resolve in favor of the
+     shift, but report a parsing conflict.
+<li> If the precedence of the token to be shifted is greater than
+     the precedence of the rule to reduce, then resolve in favor
+     of the shift.  No parsing conflict is reported.
+<li> If the precedence of the token it be shifted is less than the
+     precedence of the rule to reduce, then resolve in favor of the
+     reduce action.  No parsing conflict is reported.
+<li> If the precedences are the same and the shift token is
+     right-associative, then resolve in favor of the shift.
+     No parsing conflict is reported.
+<li> If the precedences are the same the the shift token is
+     left-associative, then resolve in favor of the reduce.
+     No parsing conflict is reported.
+<li> Otherwise, resolve the conflict by doing the shift and
+     report the parsing conflict.
+</ul>
+Reduce-reduce conflicts are resolved this way:
+<ul>
+<li> If either reduce rule 
+     lacks precedence information, then resolve in favor of the
+     rule that appears first in the grammar and report a parsing
+     conflict.
+<li> If both rules have precedence and the precedence is different
+     then resolve the dispute in favor of the rule with the highest
+     precedence and do not report a conflict.
+<li> Otherwise, resolve the conflict by reducing by the rule that
+     appears first in the grammar and report a parsing conflict.
+</ul>
+
+<h3>Special Directives</h3>
+
+<p>The input grammar to Lemon consists of grammar rules and special
+directives.  We've described all the grammar rules, so now we'll
+talk about the special directives.</p>
+
+<p>Directives in lemon can occur in any order.  You can put them before
+the grammar rules, or after the grammar rules, or in the mist of the
+grammar rules.  It doesn't matter.  The relative order of
+directives used to assign precedence to terminals is important, but
+other than that, the order of directives in Lemon is arbitrary.</p>
+
+<p>Lemon supports the following special directives:
+<ul>
+<li><tt>%code</tt>
+<li><tt>%default_destructor</tt>
+<li><tt>%default_type</tt>
+<li><tt>%destructor</tt>
+<li><tt>%extra_argument</tt>
+<li><tt>%include</tt>
+<li><tt>%left</tt>
+<li><tt>%name</tt>
+<li><tt>%nonassoc</tt>
+<li><tt>%parse_accept</tt>
+<li><tt>%parse_failure </tt>
+<li><tt>%right</tt>
+<li><tt>%stack_overflow</tt>
+<li><tt>%stack_size</tt>
+<li><tt>%start_symbol</tt>
+<li><tt>%syntax_error</tt>
+<li><tt>%token_destructor</tt>
+<li><tt>%token_prefix</tt>
+<li><tt>%token_type</tt>
+<li><tt>%type</tt>
+</ul>
+Each of these directives will be described separately in the
+following sections:</p>
+
+<h4>The <tt>%code</tt> directive</h4>
+
+<p>The %code directive is used to specify addition C/C++ code that
+is added to the end of the main output file.  This is similar to
+the %include directive except that %include is inserted at the
+beginning of the main output file.</p>
+
+<p>%code is typically used to include some action routines or perhaps
+a tokenizer as part of the output file.</p>
+
+<h4>The <tt>%default_destructor</tt> directive</h4>
+
+<p>The %default_destructor directive specifies a destructor to 
+use for non-terminals that do not have their own destructor
+specified by a separate %destructor directive.  See the documentation
+on the %destructor directive below for additional information.</p>
+
+<p>In some grammers, many different non-terminal symbols have the
+same datatype and hence the same destructor.  This directive is
+a convenience way to specify the same destructor for all those
+non-terminals using a single statement.</p>
+
+<h4>The <tt>%default_type</tt> directive</h4>
+
+<p>The %default_type directive specifies the datatype of non-terminal
+symbols that do no have their own datatype defined using a separate
+%type directive.  See the documentation on %type below for addition
+information.</p>
+
+<h4>The <tt>%destructor</tt> directive</h4>
+
+<p>The %destructor directive is used to specify a destructor for
+a non-terminal symbol.
+(See also the %token_destructor directive which is used to
+specify a destructor for terminal symbols.)</p>
+
+<p>A non-terminal's destructor is called to dispose of the
+non-terminal's value whenever the non-terminal is popped from
+the stack.  This includes all of the following circumstances:
+<ul>
+<li> When a rule reduces and the value of a non-terminal on
+     the right-hand side is not linked to C code.
+<li> When the stack is popped during error processing.
+<li> When the ParseFree() function runs.
+</ul>
+The destructor can do whatever it wants with the value of
+the non-terminal, but its design is to deallocate memory
+or other resources held by that non-terminal.</p>
+
+<p>Consider an example:
+<pre>
+   %type nt {void*}
+   %destructor nt { free($$); }
+   nt(A) ::= ID NUM.   { A = malloc( 100 ); }
+</pre>
+This example is a bit contrived but it serves to illustrate how
+destructors work.  The example shows a non-terminal named
+``nt'' that holds values of type ``void*''.  When the rule for
+an ``nt'' reduces, it sets the value of the non-terminal to
+space obtained from malloc().  Later, when the nt non-terminal
+is popped from the stack, the destructor will fire and call
+free() on this malloced space, thus avoiding a memory leak.
+(Note that the symbol ``$$'' in the destructor code is replaced
+by the value of the non-terminal.)</p>
+
+<p>It is important to note that the value of a non-terminal is passed
+to the destructor whenever the non-terminal is removed from the
+stack, unless the non-terminal is used in a C-code action.  If
+the non-terminal is used by C-code, then it is assumed that the
+C-code will take care of destroying it if it should really
+be destroyed.  More commonly, the value is used to build some
+larger structure and we don't want to destroy it, which is why
+the destructor is not called in this circumstance.</p>
+
+<p>By appropriate use of destructors, it is possible to
+build a parser using Lemon that can be used within a long-running
+program, such as a GUI, that will not leak memory or other resources.
+To do the same using yacc or bison is much more difficult.</p>
+
+<h4>The <tt>%extra_argument</tt> directive</h4>
+
+The %extra_argument directive instructs Lemon to add a 4th parameter
+to the parameter list of the Parse() function it generates.  Lemon
+doesn't do anything itself with this extra argument, but it does
+make the argument available to C-code action routines, destructors,
+and so forth.  For example, if the grammar file contains:</p>
+
+<p><pre>
+    %extra_argument { MyStruct *pAbc }
+</pre></p>
+
+<p>Then the Parse() function generated will have an 4th parameter
+of type ``MyStruct*'' and all action routines will have access to
+a variable named ``pAbc'' that is the value of the 4th parameter
+in the most recent call to Parse().</p>
+
+<h4>The <tt>%include</tt> directive</h4>
+
+<p>The %include directive specifies C code that is included at the
+top of the generated parser.  You can include any text you want --
+the Lemon parser generator copies it blindly.  If you have multiple
+%include directives in your grammar file the value of the last
+%include directive overwrites all the others.</p.
+
+<p>The %include directive is very handy for getting some extra #include
+preprocessor statements at the beginning of the generated parser.
+For example:</p>
+
+<p><pre>
+   %include {#include &lt;unistd.h&gt;}
+</pre></p>
+
+<p>This might be needed, for example, if some of the C actions in the
+grammar call functions that are prototyed in unistd.h.</p>
+
+<h4>The <tt>%left</tt> directive</h4>
+
+The %left directive is used (along with the %right and
+%nonassoc directives) to declare precedences of terminal
+symbols.  Every terminal symbol whose name appears after
+a %left directive but before the next period (``.'') is
+given the same left-associative precedence value.  Subsequent
+%left directives have higher precedence.  For example:</p>
+
+<p><pre>
+   %left AND.
+   %left OR.
+   %nonassoc EQ NE GT GE LT LE.
+   %left PLUS MINUS.
+   %left TIMES DIVIDE MOD.
+   %right EXP NOT.
+</pre></p>
+
+<p>Note the period that terminates each %left, %right or %nonassoc
+directive.</p>
+
+<p>LALR(1) grammars can get into a situation where they require
+a large amount of stack space if you make heavy use or right-associative
+operators.  For this reason, it is recommended that you use %left
+rather than %right whenever possible.</p>
+
+<h4>The <tt>%name</tt> directive</h4>
+
+<p>By default, the functions generated by Lemon all begin with the
+five-character string ``Parse''.  You can change this string to something
+different using the %name directive.  For instance:</p>
+
+<p><pre>
+   %name Abcde
+</pre></p>
+
+<p>Putting this directive in the grammar file will cause Lemon to generate
+functions named
+<ul>
+<li> AbcdeAlloc(),
+<li> AbcdeFree(),
+<li> AbcdeTrace(), and
+<li> Abcde().
+</ul>
+The %name directive allows you to generator two or more different
+parsers and link them all into the same executable.
+</p>
+
+<h4>The <tt>%nonassoc</tt> directive</h4>
+
+<p>This directive is used to assign non-associative precedence to
+one or more terminal symbols.  See the section on precedence rules
+or on the %left directive for additional information.</p>
+
+<h4>The <tt>%parse_accept</tt> directive</h4>
+
+<p>The %parse_accept directive specifies a block of C code that is
+executed whenever the parser accepts its input string.  To ``accept''
+an input string means that the parser was able to process all tokens
+without error.</p>
+
+<p>For example:</p>
+
+<p><pre>
+   %parse_accept {
+      printf("parsing complete!\n");
+   }
+</pre></p>
+
+
+<h4>The <tt>%parse_failure</tt> directive</h4>
+
+<p>The %parse_failure directive specifies a block of C code that
+is executed whenever the parser fails complete.  This code is not
+executed until the parser has tried and failed to resolve an input
+error using is usual error recovery strategy.  The routine is
+only invoked when parsing is unable to continue.</p>
+
+<p><pre>
+   %parse_failure {
+     fprintf(stderr,"Giving up.  Parser is hopelessly lost...\n");
+   }
+</pre></p>
+
+<h4>The <tt>%right</tt> directive</h4>
+
+<p>This directive is used to assign right-associative precedence to
+one or more terminal symbols.  See the section on precedence rules
+or on the %left directive for additional information.</p>
+
+<h4>The <tt>%stack_overflow</tt> directive</h4>
+
+<p>The %stack_overflow directive specifies a block of C code that
+is executed if the parser's internal stack ever overflows.  Typically
+this just prints an error message.  After a stack overflow, the parser
+will be unable to continue and must be reset.</p>
+
+<p><pre>
+   %stack_overflow {
+     fprintf(stderr,"Giving up.  Parser stack overflow\n");
+   }
+</pre></p>
+
+<p>You can help prevent parser stack overflows by avoiding the use
+of right recursion and right-precedence operators in your grammar.
+Use left recursion and and left-precedence operators instead, to
+encourage rules to reduce sooner and keep the stack size down.
+For example, do rules like this:
+<pre>
+   list ::= list element.      // left-recursion.  Good!
+   list ::= .
+</pre>
+Not like this:
+<pre>
+   list ::= element list.      // right-recursion.  Bad!
+   list ::= .
+</pre>
+
+<h4>The <tt>%stack_size</tt> directive</h4>
+
+<p>If stack overflow is a problem and you can't resolve the trouble
+by using left-recursion, then you might want to increase the size
+of the parser's stack using this directive.  Put an positive integer
+after the %stack_size directive and Lemon will generate a parse
+with a stack of the requested size.  The default value is 100.</p>
+
+<p><pre>
+   %stack_size 2000
+</pre></p>
+
+<h4>The <tt>%start_symbol</tt> directive</h4>
+
+<p>By default, the start-symbol for the grammar that Lemon generates
+is the first non-terminal that appears in the grammar file.  But you
+can choose a different start-symbol using the %start_symbol directive.</p>
+
+<p><pre>
+   %start_symbol  prog
+</pre></p>
+
+<h4>The <tt>%token_destructor</tt> directive</h4>
+
+<p>The %destructor directive assigns a destructor to a non-terminal
+symbol.  (See the description of the %destructor directive above.)
+This directive does the same thing for all terminal symbols.</p>
+
+<p>Unlike non-terminal symbols which may each have a different data type
+for their values, terminals all use the same data type (defined by
+the %token_type directive) and so they use a common destructor.  Other
+than that, the token destructor works just like the non-terminal
+destructors.</p>
+
+<h4>The <tt>%token_prefix</tt> directive</h4>
+
+<p>Lemon generates #defines that assign small integer constants
+to each terminal symbol in the grammar.  If desired, Lemon will
+add a prefix specified by this directive
+to each of the #defines it generates.
+So if the default output of Lemon looked like this:
+<pre>
+    #define AND              1
+    #define MINUS            2
+    #define OR               3
+    #define PLUS             4
+</pre>
+You can insert a statement into the grammar like this:
+<pre>
+    %token_prefix    TOKEN_
+</pre>
+to cause Lemon to produce these symbols instead:
+<pre>
+    #define TOKEN_AND        1
+    #define TOKEN_MINUS      2
+    #define TOKEN_OR         3
+    #define TOKEN_PLUS       4
+</pre>
+
+<h4>The <tt>%token_type</tt> and <tt>%type</tt> directives</h4>
+
+<p>These directives are used to specify the data types for values
+on the parser's stack associated with terminal and non-terminal
+symbols.  The values of all terminal symbols must be of the same
+type.  This turns out to be the same data type as the 3rd parameter
+to the Parse() function generated by Lemon.  Typically, you will
+make the value of a terminal symbol by a pointer to some kind of
+token structure.  Like this:</p>
+
+<p><pre>
+   %token_type    {Token*}
+</pre></p>
+
+<p>If the data type of terminals is not specified, the default value
+is ``int''.</p>
+
+<p>Non-terminal symbols can each have their own data types.  Typically
+the data type  of a non-terminal is a pointer to the root of a parse-tree
+structure that contains all information about that non-terminal.
+For example:</p>
+
+<p><pre>
+   %type   expr  {Expr*}
+</pre></p>
+
+<p>Each entry on the parser's stack is actually a union containing
+instances of all data types for every non-terminal and terminal symbol.
+Lemon will automatically use the correct element of this union depending
+on what the corresponding non-terminal or terminal symbol is.  But
+the grammar designer should keep in mind that the size of the union
+will be the size of its largest element.  So if you have a single
+non-terminal whose data type requires 1K of storage, then your 100
+entry parser stack will require 100K of heap space.  If you are willing
+and able to pay that price, fine.  You just need to know.</p>
+
+<h3>Error Processing</h3>
+
+<p>After extensive experimentation over several years, it has been
+discovered that the error recovery strategy used by yacc is about
+as good as it gets.  And so that is what Lemon uses.</p>
+
+<p>When a Lemon-generated parser encounters a syntax error, it
+first invokes the code specified by the %syntax_error directive, if
+any.  It then enters its error recovery strategy.  The error recovery
+strategy is to begin popping the parsers stack until it enters a
+state where it is permitted to shift a special non-terminal symbol
+named ``error''.  It then shifts this non-terminal and continues
+parsing.  But the %syntax_error routine will not be called again
+until at least three new tokens have been successfully shifted.</p>
+
+<p>If the parser pops its stack until the stack is empty, and it still
+is unable to shift the error symbol, then the %parse_failed routine
+is invoked and the parser resets itself to its start state, ready
+to begin parsing a new file.  This is what will happen at the very
+first syntax error, of course, if there are no instances of the 
+``error'' non-terminal in your grammar.</p>
+
+</body>
+</html>
diff --git a/client/src/thirdparty/sqlite-3.4.2/doc/report1.txt b/client/src/thirdparty/sqlite-3.4.2/doc/report1.txt
new file mode 100644
index 0000000..a236e7c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/doc/report1.txt
@@ -0,0 +1,121 @@
+An SQLite (version 1.0) database was used in a large military application
+where the database contained 105 tables and indices.  The following is
+a breakdown on the sizes of keys and data within these tables and indices:
+
+Entries:      967089
+Size:         45896104
+Avg Size:     48
+Key Size:     11112265
+Avg Key Size: 12
+Max Key Size: 99
+
+    0..8            263    0%
+    9..12          5560    0%
+   13..16         71394    7%
+   17..24        180717   26%
+   25..32        215442   48%
+   33..40        151118   64%
+   41..48         77479   72%
+   49..56         13983   74%
+   57..64         14481   75%
+   65..80         41342   79%
+   81..96        127098   92%
+   97..112        38054   96%
+  113..128        14197   98%
+  129..144         8208   99%
+  145..160         3326   99%
+  161..176         1242   99%
+  177..192          604   99%
+  193..208          222   99%
+  209..224          213   99%
+  225..240          132   99%
+  241..256           58   99%
+  257..288          515   99%
+  289..320           64   99%
+  321..352           39   99%
+  353..384           44   99%
+  385..416           25   99%
+  417..448           24   99%
+  449..480           26   99%
+  481..512           27   99%
+  513..1024         470   99%
+ 1025..2048         396   99%
+ 2049..4096         187   99%
+ 4097..8192          78   99%
+ 8193..16384         35   99%
+16385..32768         17   99%
+32769..65536          6   99%
+65537..65541          3  100%
+
+If the indices are omitted, the statistics for the 49 tables
+become the following:
+
+Entries:      451103
+Size:         30930282
+Avg Size:     69
+Key Size:     1804412
+Avg Key Size: 4
+Max Key Size: 4
+
+    0..24            89    0%
+   25..32          9417    2%
+   33..40        119162   28%
+   41..48         68710   43%
+   49..56          9539   45%
+   57..64         12435   48%
+   65..80         38650   57%
+   81..96        126877   85%
+   97..112        38030   93%
+  113..128        14183   96%
+  129..144         7668   98%
+  145..160         3302   99%
+  161..176         1238   99%
+  177..192          597   99%
+  193..208          217   99%
+  209..224          211   99%
+  225..240          130   99%
+  241..256           57   99%
+  257..288          100   99%
+  289..320           62   99%
+  321..352           34   99%
+  353..384           43   99%
+  385..416           24   99%
+  417..448           24   99%
+  449..480           25   99%
+  481..512           27   99%
+  513..1024         153   99%
+ 1025..2048          92   99%
+ 2049..4096           7  100%
+
+The 56 indices have these statistics:
+
+Entries:      512422
+Size:         14879828
+Avg Size:     30
+Key Size:     9253204
+Avg Key Size: 19
+Max Key Size: 99
+
+    0..8            246    0%
+    9..12          5486    1%
+   13..16         70717   14%
+   17..24        178246   49%
+   25..32        205722   89%
+   33..40         31951   96%
+   41..48          8768   97%
+   49..56          4444   98%
+   57..64          2046   99%
+   65..80          2691   99%
+   81..96           202   99%
+   97..112           11   99%
+  113..144          527   99%
+  145..160           20   99%
+  161..288          406   99%
+  289..1024         316   99%
+ 1025..2048         304   99%
+ 2049..4096         180   99%
+ 4097..8192          78   99%
+ 8193..16384         35   99%
+16385..32768         17   99%
+32769..65536          6   99%
+65537..65541          3  100%
diff --git a/client/src/thirdparty/sqlite-3.4.2/ex1 b/client/src/thirdparty/sqlite-3.4.2/ex1
new file mode 100644
index 0000000000000000000000000000000000000000..c952bee528e3274722b652b987bef22b9095d15b
GIT binary patch
literal 2048
zcmWFz^vNtqRY=P(%1ta$FlJz3U}R))P*7lCU|<GfWWWgIfG`XovteRbX<ncxBl9i>
zAQ}auAut*OR0#nWMmBL#QO4Yo#H5_mlB66%5N2`?a&-)GRS0o(@^MuFiD=~Kr7Dyq
z7A0pS7HJq7XzD1Gl;<lH=O*UlWagD<g7PL4^9u&%uRvlHjE2By2n@>*;AUc$W=zk|
VPf4mw72#xL7H7;z&B@8<0svdrB)b3r

literal 0
HcmV?d00001

diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/c1.bat b/client/src/thirdparty/sqlite-3.4.2/examples/c1.bat
new file mode 100644
index 0000000..a95e307
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/c1.bat
@@ -0,0 +1,4 @@
+cls
+gpp example1.cpp libsqlite3.a -o example1.exe
+pause
+example1.exe
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/c2.bat b/client/src/thirdparty/sqlite-3.4.2/examples/c2.bat
new file mode 100644
index 0000000..fd228c4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/c2.bat
@@ -0,0 +1,4 @@
+cls
+gpp example2.cpp libsqlite3.a -o example2.exe
+pause
+example2.exe
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/c3.bat b/client/src/thirdparty/sqlite-3.4.2/examples/c3.bat
new file mode 100644
index 0000000..394a863
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/c3.bat
@@ -0,0 +1,4 @@
+cls
+gcc example3.c libsqlite3.a -o example3.exe
+pause
+example3.exe
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/example1.cpp b/client/src/thirdparty/sqlite-3.4.2/examples/example1.cpp
new file mode 100644
index 0000000..691b597
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/example1.cpp
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <stdlib.h>
+#include "sqlite3.h"
+ 
+sqlite3 *database;       
+ 
+using namespace std;
+ 
+int Callback( void *Pointer, int argc, char **argv, char **columnNames)
+// (pointer to database,number of columns retrieved,
+// array of pointers to the strings in the fields,column name)
+{
+  cout<< *argv <<endl;       // prints all entries in column "entry" 
+  return 0;
+}
+ 
+ 
+int main(int argc, char *argv[])
+{
+  // open database
+  int resultcode = sqlite3_open( "mydatabase" , &database);
+
+  //create table and insert entries
+  sqlite3_exec( database , "create table test(number integer , entry varchar(50) , primary key(number));" , NULL , NULL , NULL);
+  sqlite3_exec( database , "insert into test (number , entry) values (1 , 'Testentry 0');" , NULL , NULL , NULL);
+  sqlite3_exec( database , "insert into test (number , entry) values (2 , 'Testentry 1');" , NULL , NULL , NULL);
+  sqlite3_exec( database , "insert into test (number , entry) values (3 , 'Testentry 2');" , NULL , NULL , NULL);
+ 
+  // query database: retrieve all fields in column "entry":
+  sqlite3_exec( database , "select entry from test;" , Callback , NULL , NULL);
+ 
+  // close database again
+  sqlite3_close(database);
+ 
+  return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/example2.cpp b/client/src/thirdparty/sqlite-3.4.2/examples/example2.cpp
new file mode 100644
index 0000000..a1b7936
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/example2.cpp
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include "sqlite3.h" 
+
+// This is the callback function to display the select data in the table 
+static int callback(void *NotUsed, int argc, char **argv, char **azColName)
+{
+	int i;
+	for(i=0; i<argc; i++)
+	{
+		printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+	}
+	printf("\n");
+	return 0;
+}
+
+
+int main(int argc, char* argv[])
+{
+	sqlite3 *db; // sqlite3 db struct
+	char *zErrMsg = 0;
+	int rc;
+
+	// Open the test.db file
+	rc = sqlite3_open("ex2.db", &db);
+
+	if( rc ){
+		// failed
+		fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
+	} 
+	else
+	{
+		// success
+		fprintf(stderr, "Opened database successfully\n\n");
+	}
+
+	const char *pSQL[6];
+
+	// Create a new myTable in database
+	pSQL[0] = "create table myTable (FirstName varchar(30), LastName varchar(30), Age smallint)";
+
+	// Insert first data item into myTable
+	pSQL[1] = "insert into myTable (FirstName, LastName, Age) values ('Washington', 'George', 22)";
+	
+	// Insert second data item into myTable
+	pSQL[2] = "insert into myTable (FirstName, LastName, Age) values ('Lincoln', 'Abraham', 33)";
+
+	// Select all data in myTable
+	pSQL[3] = "select * from myTable";
+	
+	// Remove all data in myTable
+	pSQL[4] = "delete from myTable"; 
+
+	// Drop the table from database
+	pSQL[5] = "drop table myTable";
+
+	// execute all the sql statement
+	for(int i = 0; i < 6; i++)
+	{
+		rc = sqlite3_exec(db, pSQL[i], callback, 0, &zErrMsg);
+		if( rc!=SQLITE_OK ){
+			fprintf(stderr, "SQL error: %s\n", zErrMsg);
+			sqlite3_free(zErrMsg);
+			break;
+		}
+	}
+
+	sqlite3_close(db);
+
+	return 0;
+}
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/example3.c b/client/src/thirdparty/sqlite-3.4.2/examples/example3.c
new file mode 100644
index 0000000..1d4a491
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/example3.c
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "sqlite3.h" 
+
+     
+int main(void) {
+    sqlite3 *db;
+    sqlite3_stmt *res;
+    int rc = 0;
+    int rec_count = 0;
+    const char *errMSG;
+    const char *tail;
+	
+
+    rc = sqlite3_open("ex3.db", &db);
+    if (rc) {
+            puts("Can not open database");
+            exit(0);
+    }
+
+    // Create a new table called people in database     
+    rc = sqlite3_exec(db,"create table people (id integer, firstname varchar(20), \
+		     lastname varchar(20), phonenumber char(10))", 0, 0, 0);
+
+    //rc = sqlite3_exec(db,"delete from people", 0, 0, 0); //erase previous inserts
+
+    rc = sqlite3_exec(db,"insert into people (id, firstname, lastname, phonenumber) \
+		     values (1, 'Fred', 'Flintstone', '5055551234');", NULL , NULL , NULL);
+
+    rc = sqlite3_exec(db,"insert into people (id, firstname, lastname, phonenumber) \
+		     values (2, 'Wilma', 'Flintstone', '5055551234');" , NULL , NULL , NULL);
+
+    rc = sqlite3_exec(db,"insert into people (id, firstname, lastname, phonenumber) \
+		     values (3, 'Barny', 'Rubble', '5055554321');" , NULL , NULL , NULL);
+
+    rc = sqlite3_exec(db,"update people set phonenumber=\'5055559999\' where id=3", 0, 0, 0);
+    
+    rc = sqlite3_prepare_v2(db,"select lastname,firstname,phonenumber,id from people order by id", 
+                      1000, &res, &tail);
+    
+    if (rc != SQLITE_OK) {
+                      puts("We did not get any data!");
+                      exit(0);
+    }
+    puts("==========================");
+    
+    while (sqlite3_step(res) == SQLITE_ROW) {
+                      printf("%s|", sqlite3_column_text(res, 0));
+                      printf("%s|", sqlite3_column_text(res, 1));
+                      printf("%s|", sqlite3_column_text(res, 2));
+                      printf("%u\n", sqlite3_column_int(res, 3));
+    
+                      rec_count++;
+    }
+    
+    puts("==========================");
+    printf("We received %d records.\n", rec_count);
+    
+    sqlite3_finalize(res);
+    
+    sqlite3_close(db);
+    
+    return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/libsqlite3.a b/client/src/thirdparty/sqlite-3.4.2/examples/libsqlite3.a
new file mode 100644
index 0000000000000000000000000000000000000000..958880909454f56a008ebf25cc49ab670d4825d4
GIT binary patch
literal 1839418
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%0ANM%VsYc`fla3*g
z7#?@%><=k^`$Fq2ESOi$0}f|uzc)1X0KdGqW%61wSiKU;vh$|)O7i1Efs&ONISQtf
zSA~W1R)}?HC#Q&R%bEYe&<<odj<D;T)#DKJUy+MD5+FW$JPkF0<6AeFDuh!M`k17I
zvz(Qo3V14cRi+c;;HEC~b;?7(kzp~qfvGYK6vC<0I1F&SPgLFe;Z%p-lav_ba3y!X
zN4zTZiA0BD#!{56)=nd~)`SwFrO5$K3yHO%Arb?r1(At?2Sa0MsYF3)&EZjz&P|#I
z;wrNo4diC+hLnPe!wX-WTSB+XFpyGeGT_`AdPrg*qm(8poSIOhL_tVRE?i!MVCyx5
z5K(GazD*+_ob-IhsnsY*Cr=L+&IXN~O18@isC&svlbpIxU#a@fpn{;JZ6q{WqGo9+
zaxaP~LH_9&8@Cci{Vw4ZG<5W%@5#T90TWMA5bLs5V_kNvSeKQkB+?rULaziu@M71B
zbzd+9tPe>5Y>UCdprnHlf>(FE5Ev~5V#1KIY7*!LY=68|n)5uY8rG%gmGY7vprj%m
z>pGH=G!v@Egpv>gfNG$mDl$~8Gnrz79<aY-yjXWCt0pmz=qHA#y)%*IP2xBqLwaAp
zALBdz_LOt91j9^%=ALyD>%MMcWZkJ`wMae}hz`|JUipOf4-=`pohj(N6nYpGF-wr1
zv%~bUa*T63r4I#Lb(K7n)!C&nK7Yx)!pfCb6%|$C;8$n24i>;1C}0kSk|u*LDSKBx
z1)Sf9{$Y}BG|56vL)qNpCH(Ih*Y`sOoY$m?^ygJBU#0u{>n65xOecl&2NPSYdkNA+
zyODpHeyqCy!ZDr#$>t%l!q>Y5h~5%T^d-FyN1y8p*G|EFzDoGc<5&(^)hEBaV(pcM
zYlZK8g|UFChJNo$R&w0!Qyi|Mj_gZOh(MnrdEc>b&<be`2!cTPQY)k*q>gX$_4x~u
z>x(3CrrD@V;njym2;m#8!iYW<m4&N})9r(KY@YCqVH3bu)2BjmG*&r-eae(mr5_T#
zdE-^UcLC$_xV=z$!d;BkAbf*WLN3aMIgfS8gnOp*!7!gO^CQ=esVXkV4sKKRoa*%A
z9a?Ts8iIQ99xXTCS`AJSU1vJpspTeEKSWZ!c(0ZlvOZz5wok<>Bg2U*ZV!tswVMS|
z?WS3<1q)d4(74@n>uNZt9CAuI$|{13<8y_a+m6<T0SuzNmrJ-~v=Jkq1q8`E^nT=;
zvGwvUe{$zqH^CkB+{4^Aojb5+#9vTSi4jLlDc^FGkx8Jd6lS9=O3IdF02S^#+Qaf!
zMPc9b^z0a3wB$B9w-1t4=r7Y@^*G@+YeG4&!@%^R!>gd|<Pg;dIh446)+C7@N?k1E
zex&gj)1hBiudFW3!#oP6ER7%FO~H>j-<NSF`O8!RexfN-6hg=Msm2Z#z05>?p7leN
zM9_05x)0d_Y=@8&1NUKRxL`dLvRWRoRS~)V@Y)K@!XMRcA1pGM5(@V*X@fvR##n~M
z8TZHb@D%2iV|F3({u7%j8}cq0;4tduSZ5(QrcY<0d#n9xlYEUyUK;3xyWVzWe9+V8
zNe*t)6aoJ_=0Lc$8WHrDm51kGrXk!7noDR;RauoKE7_;qI*sfRa{_(Uz1>zqpeJZ%
zloS+T!sBk#B)vp08aZ>Von#bXU-vd^CKN$cMzxkwywFxB!;rDT8X@g&E{u5Ej8dl!
zk^z5JUQuCq?UK^MRV<C$H9nR`A2hT(bSp<`QG1iPjne9c5{sEgJ|kAHj6G5G(#KP~
z^Q{HoC8(VR?hma?uw}(xm0w)AG7n!NmtS9ks=7ya7~u~uE0v<rz1N}*h+_kENQJsj
zqx$-Jwy?teNaKc~vB{#lUn4U7xRdGzX*_zsqVdR1p692ba7j^lB{WHa>y1@=S)iKF
zR_(k-nTfYq??6V_$qW7Yd0=*l6t?a|n$bo60u=fq7PS^Td8z2di?xKiz?z2K1*K!E
zJJ4MVSqn3>aFbl!eN}~?C#^GfvZc~G-&JYZ%B&~cWLKGaU4O-_!XogR;;N<<fK9Sw
zIpnOt1VIAZgm4GBs*i{K>eNE_LifBRa+m0@s>nl&8LZs{Ft*Ck)=iZYLTJ%)a5hfZ
zkv&=D4t4L5eRr6@1UTUi(?QbwC6bXV%F&QiY{RwJm>8bd;Er%Fm%U*e?6x%FrMapW
zU}&CEsPZschsY4!K4Sa1#;QYs#Ssp<IqusmJs6i+vbma6#B3queC<T*$ix&Gq7Q|y
zahSIVcZnOkfSC`9UaDOzv_3?1LFpLaPIjKg&Mkk%w94|8!kywM)_|abt&mflD@|`M
z7jCAbXIzSA9#GRX1$r~Ow{WLx0Tz;$M&VxRY?3ix8dQag6tRrJ1%O#vVE6S`OFJ<p
z7Dd9Ht+D<51-MBqT&S>fG`2swD-WMn*sC=5Y~&3C67OhqueEj}LqX4-<X&svj&)&(
zW}3?v*&oWrEc_)|m4!vPO+dJdwE(f@l+2T`?sXdNsHV9@JJAv;M5Xn`UFr!^X|Hkf
z><O}eQ8LH@a+yuFl7k3le=umc`5J+F4`v5>rBqzp0{at8$}sm)lB&@DTsjAcUiwNy
zcae1$@(|R{pnHS+2J?jKt#+r$>O}@|#-_W<YYwV)toB+0qM|;E%vvAFn4~Ms{fToB
zi|i`h$92UbDlO*SpX!Rl0+M&{p8JGD8wv-Hyb{c)GTG&R=G-kS7=2LpfhToKLMJT4
zOxS%&$CT(VFH^Q6_vfbmxrn6s`-Q1~juexMP@_+4z6Pj5{-tw?Oe;x=+GiXkYE%4q
z9MR=OUAVt;HcO(x{yaV6JnL}&WaE~qUY>P*sdW^Y4{B$~U1?v6-2}$`;Fj6i{GiIG
z+@_vSL9E7s3RC%<(z-Y3K@%NK-vQ|6TeA>hP&;S1!+dSnmVk8$C8&n`l%P_QafHts
zwb4mvWW~f$xFa<d^MEQCbjwR&&=qc)#`=Mk(kNXcVyG2WWmXiU$VX{h0QyrEm)=%;
zRt$Hv_KH<fc#LliWQm>J4MPQvLUqUbvM!_>)j7Yokc)U1`IOiVDK+Y1&3U4~Vn*I7
zXkfw}rz!gSD@-z%XtDuZ1HpovaL4<UEKE{$IYB#9v@~Byn}$14V<CQLm2hI=UaBJ>
zhRD@S$h}OXAb&N{<vyijkMWmyL>_9KKd+#ml4eU)G#S2JnZb#utIB*;8wJ)^sGOkZ
zPIG_YUX0BoP!w4tce+||sE&1)c48SsxDUG-GB#KA(yhP9%0$qha%H(E?emhnUiP(7
zmXxggMz18Gi%Hq}FMG6XxdBKhIgWp;2~ZijkDRhq5Agby@cNb-Z!AZZG1O67&0Jf1
zqZYh-KwQVkRGkQtU#8+}5uPG7G}-Tby5FH1<a&Z|V;t2Apkoxk{#5D}b2ptrnjhw(
zf~(3(p}7ThM@DV1Jr<%t#%t7Ae{o)iiq~CZFY;fH*`FK(5;W>!xx74+LOP^T;}BhL
zNoBYiXZpH5HS!W5y+!C=8aH0{W8o$`SIeAE)MhZZw?nIlot)t>Q$1e}44&nEDg;Ip
z`YbIqW+-9PPYat_sA+j3vRiD8MAZhBE8y;M%HZ^`6YfsuewnW5SFjd3$1aDL7`xU$
z$d7(-?^f=ClqaIwF#*37);ffZBRtFv`Ny1xh^R94@awrF%!2u{e0pjOBoS*=xV`+U
zIs>W&^!BS35cK17-{r6yxM%s#L);vQydK@xuj&&0m5PPx1O5C;BB7~xL(kd%@v?F2
z9y`EaB%SE7v#{`v6+w-_WW}_u>#eC^KIplJxo`OTVPN!2tC#zx&(p-iN?&?QBV3u?
zw~g2eS1t*o*}UTkE6F>`?p@vW(Ie0ZF(1Ji=zBiJCZ=mxNzs+l>{Gc;RJHfMPYo69
z2zkpq#r%NACi$x{M5|32?m?f<rjk=FK2^Shg)Q%#5&qN*kfB87uwq?iFHx@O!$FNI
z*5%9<+c~OAmX{S4BuNuZtjqaGtduLBxyD?|9CSaixZvzB;WXw`GZ82&Ts=<?p?}vX
zS1!p4x80ksi2ecBZ*y<Q*(FsoaaDO`WpxEC#OSb6cASkl7Ic;ZtZ4^qnv1~#XK%6Y
z0J(ND1|fUO%>`<1uFYAWNi??-bf6P{hgOV$0brHQkIUT3pdag|0PZOl^E)Q_Y5_)?
z+qgQ5u;V2am-ZEvG<dR!OHvRll>}Vj?@GYcKoG2lmr9-M@n=j+Ca5#=Fo*^)!yf`T
zXBBc_flcaM(#VGh=`ny~Ap3-*U^1Mbsbn}kj!LFuQBpG$3x5=fEK_P`Fy~<4k9FCH
zW2O2Y>r&AQdN*bV+!<0Q_LnFfd#0A45FK(9xI)Wb+K1-L$f+E}x)dU@?!&;u(?a8!
zN-%#c#eDaDXE5d{vUOwgkJ075S<XS7h^uBfE!v5ZhMH3$w)-eM$06+z^p|k8$NfON
zAw1L^<ggwG5<3_uqP`n)|0eA#9$l-Z14~LDZgZ4^jM<8e`Qr{2I#iycUh>E(=Z&%M
zPh<%&Z?SGEEkvHgQkQxM-D~6|$4hpho+E0#_FB0QfO;EdN1lSXNY6u&d8I)u)`(bt
zL3tT8p6j%`8`69bDQo3hr5JE4rQWR+!z!Hsx-Jb-VNVA~$evKndwI8!yX#$cA5X<l
zQ4MqNb}732>o}!YmWRCr?hm~PRs8pu46K`ky||Ee_i7Ag!H{Iay-!amgG&DYNY6N>
zDW$xE_9#k&`*oHQ{VOn8RkooAG_JS5#G5`osQITR2Wh)imnNiUPL)*kwn>KV<Rm|u
z9R-VUA982OX-Eq4%<0yEMQ~DyG@Xf>?*R643Ra1=LCew7=APjtVG)ze*4-N-e^|_g
zS%YCa4X<2+vnWK&U_Ag5fio&ZOsYb-M97mXVumP8K$38?a?DVL2}(>k0u57$5E1g+
zi<sdGlSs^J8EAyU^p!LcGg4s&5K~fBfFUm?O`($dEW!A+WF4DJOu8D=QWS3a%5XWR
zE-|AN<zR8v&mml_3D+W5eF+Y;CiYH64lA#iDy&P@5}xRDjj%3LAp(778#vepG#Vf3
zQ!K2@6-{EFl?DdG>x7k|JO=c^%?y)Nq)C0Sd|Og*&1}RmS!wx$6>7%pY++4Ns8od_
zGgB32h{DWUD6C9{87j`r#{ro*AVh{N!i@?uk%fU3yj6lw5@?spF)9h^D+pE0nmn%}
zud=F;YxlCWtnWxNYa2qHe-TUOI~3K)i0V6xDWz(8nXnp|o0PH{mBRY20%rp&K`}^1
zc+J|iYiF;VS|GrSit%3veSwV8vKS?~Q+y_&aBamMidI9&uZGGBmwPbsS&Cy(P-IJx
z(<Ll|^@!yBAu77{GPB}BT^KC0w=n+`;-~Vj5chy^Fw%XCS(yrtR3!bjteP7FsYqPI
z!Bhm*a42PxhEpbcz=CuGjna@9qEnUiIm@!1Mw;)~LM%fvXAi~INJw{<Wbntp3<K-4
zWuEOV#n`v59mA1?Lcc<yDV~c&U`crm%k&_k$&12Av%vBZ)>_Lt3>J9W??;GlgJxr`
zWaDfwID$?6?;zO?66;25<Pf+ofk&E$OdkWxEMU?v18_Y6{6;}@om#TIB#hRSD|4|Q
z;cs*CbuS2}4ijRutm#}<^k0D*Gd2&|pI?KpqmkNJw0vPLV8Jh?bB?gCp@ZiajHMW{
z7Sj2FbmpxQ*0prTA&s$I3_`IiB7zr$j8%7tET-jSKHd3PcCoIb_i8vV!d-4lqPVTj
z2a{ryY@;)ZXRpjg4t^?g!0YZe_;LLlLM0COa`02;U?{xUY<|jS^K&@HqN_i_B>qeX
z`nq&<2VyMZlaBFptc2@l?Cq6sU3?WnpF#lsti4~Nlt!)q>I?XdO9C$a7Pzhi3+WL6
z*AciAz$O5wknwntzp<6s`FYr<Wc`*A|3-RVf^BB%bRj+Ov+6C2-n`M52Qjqb{S#!0
zjj&$U{xD#Np=7^fQ3}{wGKQ`79L|=_w+=@kHdv(?5H1Jd_#FuUF`mtcV>mLUjN#ev
z65}%PXL!Xtl){r1(<mku(q$b2D`9})v+$})xj)EC*W%zLC@=Ui2(3{T*K?I<7;Qwu
z7|G>?B#4-aGAmwWm;#m*m0+#JdPhg~@(6T)P7R6jM9Vued=d-<*1Jl!pjEx6AcSp_
zaVD)3R<m4vNLu&5h<g+8D62Dm^jl`a7ZPAdf})@d1`siZ1W*tX2umQWh5%s^gpf=^
zLP%m3Hf523l8&}S(V`+?ORH^htG0Ek;tDQpaYI_EMMVut)vC3)RPOJ0&iUS%fW80w
z+~+>e9r$v7=RNP)-m~vxn#!r6V>ylZ6D~!;`bK-5vylW8+0LrhZsqKuel^Pe6gBe{
zZiFPKI+SFXO_M!M^Nk3DzD(gTs2ZWMWwrepoKTJJIo73^R)UBud#kSULY{uP@+wGj
zel~XJD>>clP)=`xmiq_F?H1+kf2e<h`ky*n4L=ihM<SKCIn1nhWapwv%f3yq4u#Q0
zi1F<X$G^qUWvu45ZOh*7RKuH~%bTP|-Gh`F0mDUf^k>eO1CdYP1MNqk4SW;e*90#C
zybUmlEyV<Y&14^HA0hjG(0Ir2z{df?0K@JFA^TP6Zh<cQFu>;o9{`L&KF$6N;6?ys
z^j=s~nSn3+6L|4=MayGuxfh-s0)zcaXJ9&n*Bc9A1J3}601WHTDvHm&H$#^_4B)C{
zfH44bI{{1qxC3BxF@W3p>vdz;AiV{NeTdKgkIg5?2c9{=vetEmC&MoQ?{a)MgFJc(
z?AQzPXd?%-mGH~{-d5Z<k=q(R51#R|r02n&y$bAifu2bV2SI%opM9pIEWD~LjNJk^
zf)ILk3z$CuZS+<ExAnx@?41A!2$b^g0RT27_8e`!AM}tqU7iA4yvE<Y#z}`u%Jtzi
zR;E9N=@FV9vq$@;+~r{nI{|9;J@BLk+U!37T%#OC#^lI_SwUq?*XqRFH^4thrUnXj
zSKL31&L9tY-U4e^4MK&l@@I<6{D~YlPG!$jJyvK9j8nNY&1LR%T0K@eXSggXZtMN)
zE<&k1(`DcL0~j-}c31X(iGW;G<?E`u>YRI)8hag9y79}9anDx!E=Rz6hAzN8Tn5N(
z-M)4#AH!M<%|$iiSR@xHcj*&rx+_cw)~_3u2fpwMR2~t<fgH$F?iY54P1JNVUDl%?
zz?vzyQ8=l@Q)&$;L#bsKSxe>x$L3i$jxyC2?ZLieUQ{JlB=eFgjgBvwmsPnnlKHc$
zL{J@P6~mbq@tKGnaCF2DuSJSr-_kPd>%#Fp?ekr(%@cM!rOJ~}v&84S+oy?HH1K`?
zwVx)|fLJX4?$|ut_c%t$*TAh4;?~>kWATsnu{aVRi+5Eln7+gKW|E1*Q4@ui*XFU?
zF%-Vk!PI`=QQeML;M=gxAgC@!66R=Bm*YYJ{&b{ud~a}Vo-X7W&&e>(AL2{;$L-_$
zllFOVODw)jIqlYGj?I&e#TW!N!>vcet$($T@8|8~`$c?w|1GI@2AsJJpNaB++ND~|
z)7xB|#~@eZ+Xqh*F7_jEd;17%Zy$j>ViAzDpE?!~J2ua1K7;Qh94r$DA88+pN888Z
zvG`d0(T|0d@4xC+ge`ZNd*hm#8Y9p%?wLcuXmjlY@Qo)$$9BUMIy!tKvEU54T5xW)
za0AUp?t2J`8Y<f#n|TvUulL!<b<{BS*DG@NKV7{d=UEx*Tm=01#61(v23?+nW!-Q>
z*|`edSv`LRmuafXVh5`e1JINEXU+$hU={R1E$5~5gvPd2y*5hIpN3^GZHS_`V=ACY
zVuCiYE<&%&vHl9u|9ChqGJIfJRYhIhz{Qm{12Z!RR#z?_SW#MPh(j_j9y}21MAc1Y
z5ldMA7Xh5rmDp*GgoB_n(PzP9OO0iiA<kTaQ2ZZWrNfl{67a#!;zsOx(2xZh2%Xtd
zPA6n8!D@(LOkE>lRuE33vV0W-vI@8BqXQ>bv`+M180b|@o;=|rH?kqOVvKv-a?mT;
zSW(f`<aTbH>^78pU*I{r$pfA9QoUTD+<_x<o4t!ByFI+doo>yXovUX!>8aj5k3IfH
zLvHTud%O$tZkzwYM7JZJwOezrzq>NiP2AwF$Z?Z%MhwiYaO-n$nsrphl7VmZTJEJ+
z^cXaLp|>fw_qjiHSM48p?!|7+2KO1u3vbE3G~0V&w%cotTec(D?Yd*@@F}^umrijf
z=6LTn?V9Qi+R=LBh=K0JJqz%(-av1^JAKYpyt!B5z2K&Np6i^~E!Umz&2jr|@X{xH
z^UfLAu(LVivV26|o0C54rnx)4vk{}M8BLStx*;#@*5yDs*!o!0s0$Iu#2kb;H*Ye2
zb1U2#jZOTy&5jeXpPb?Kac^C-!JYQ#{aNln=Th7Km*a&maDTUUzx$Py<Gz9KcWZY5
zm%9h8M}e`aV&{mtKWQ4#JCZx`zPavGw)1Dleld48CG+mpM;Yq#M`lc(?4?#z>~t$1
z&2{f^c6cMlxU1*P9X@jMn{Q5@{Gm76Jz;r!hRt{1Sv$uWkm^*YH8)Le&YkTHOGVg@
zuk|t~Pj+v#C%Fp`dS7|Vo15KD>vAT$-{2v|>()(jzqKZ1WVyezoqo3WmV4W}#t+=?
zpGW3;&5u2j_5Q{iZ`|tMvex_D{e_d`zO`l!oO;*V;x#pc6Vmwrj@-Vke6o8K;I*}l
z-fH(<=W}<*nmNt)xYLfdx_@*Yb))Mt-G5s-U%W74;QP%L5u`y{L4}ukkNcao8=BmM
z2-$De&T-#>x?x?T+oRFFe%%K6^EsTnWWW0->rwBEX75nO`;*;@M!aTt$J)=ECcA&P
zxBMLWuJ;#SZ_w^pgBKI~Ztz;)bnkN>ZFYvHdKF71F3A`<*U3&r%0Il$%W2-}j(XJn
zh3(|nkB;6rJj)rF>RgaI*S*O3*s<NA2Xmc_G<VOsqi$lkyEyFj_Hr(N%x#>r)Lpv8
z?N;tK?r@XK?`*}Bia8Kr%A;=07B^*wTerh2_Igk4?Phu@?r3j=H?4I<g`4ahbTgbk
z*|t;PDN-@QyC*U*;(d)1Na?oQFv;8LR(s`0UH5En&s?w7T{Oqd*y1ko4ti${8&o>E
zscBxs$xHn+9(U~OmE-);P&?{YA%Wb;7WaH_L(>TFO?RQU;U4$eb<P0$-r*y?DNWA&
zG%pQO^yXB&*$bJ=+wu7Dk?tl6=6lEKYdcw~FkioB!|EAsBA$#~G0A(=$xMa#mS0ry
zV)4L++&90tDEGE&-JJpNAf0#@PH3l5($n0Z*<K3CcdXsB5gtx%^3HRA>3BJF+|)hJ
z`CZ+#4bD>zDoJ$M)Rh5v{PSuLFGFrdeU!oa#r!x2qh5v_*C{x@Ie2a0I@h^IJtMhq
zw0=|)gKWdg4sTzde@v&KdWCXH-20Q@!w^ROj-V2218Vo`q;o`Gn;d5NI79JUpD!*9
z*T;one9|PN(@$IG8M~Yt;1gE9A13?@GBf7H*&dzbTpMRSKgqc{v%7khgwAj%&PPd<
z8xuMO$0!NhhKDsVM!Brx^P^*8usA;Cj|0I1bU%H6CmOje%FM$s#+jZOa-X*2LQs&j
z5afTw1!8p474YGzOv{~U14J^dE1`_bv{pjd1m@Q>Lo;BCCn-WT7ztoh!9V!1lmBB3
zE>H1$Jp4>`;`|()>P$#-*2Ae^!f2M08J-BIuY|rXlX(LDDfMI5_)Z|-y@KYzweDq^
zp=scppP4l+Gc?6dGdPL1+}LBs7XQUw5i<+)ImVow)jhskkynh2;4+*I)7kcc%}e5#
zFy=lxl0W3WA8vLI%fbHx;V#kcw+ps}oBg{VayQF_o87gsaqg--uH}Kh?PcMY3wF51
z$JtRYtS-w8Pxpgh+=e*NZD<ToML&j^4_{h8QMk#Yx<%8~!^<q2@vo@D$bwhsQWR35
zaoqEkES(Q18;t>~4{GdDeOKWokLr7xj^pHdCN$m$y74wX_~07@(qH~AMfzWf4-bY?
z;WVmawJy<y7}i4nj-oXNsJ^GMM|B^HIX$AvdC&OwHEHh?eDH}1pF_j*p1!M`@jQi;
z3661!tB?vON#nyYANm$UqxvAexaT)n<GiAb8v|6|(Ac9|g)GcqQms?CF+g>Vp;KLJ
z=u|nk8ZSS({f=_4RjJu9hqR~+#phb}>vj_GsWi~3G-&9%2C5(Pw~b>6JKbCgM%QW$
z?DScc#%E^Nu{%D;%GybF06t_6dX}T%6;L?M3aak{nSBR7fEWK(L0_&^I_Ox-v1vp*
z+yOWt@#J}N-Z!ih+s9(I19WAHwp~Y63#oOH@6)F-UN4TfF^;#)=jF?E#;uic=91?a
zI%9ryocVm;ek?(<c2bBG4e}WkiUrwb&OE4;4amNTNT#SLa*&rpVI%;3ciHr`;$uFh
zdXvT;)mId5@~FP5=>e*jtFcRyM|F|HjRC5hK90{sbbALrct>Twf-~sC8yZsS1dGTR
z??QQBLn>b@SlAIRo{J9*ytkWk)PPiGDOgCQ9-nK~t=mb!Fq{&-N0nzqR1PROn?abT
ze3(5SincS`7YW0uquaWq4VXb=v1C9PiufWL$6NM!jJGU~x9kVpUGzbWcTp(j?xNMe
zT8y!5MlsT#j@Aye*ZRlsF>LWPhLirr(-_|Ir_iV`z-L<v>Yz|+wskp`<(j$%$~pxl
z`<;MaU6sU&so(+^CIp4IR6{D}_24@Ix#JSaK;@8zzC>Wnk3<9}40K#287I&A^n^Y@
z-t&KISc!e>alCWlc<1~o#yiL7WtM3#htEdE<e(zYSVIoJ4fdy6@u`9Vb(_W>)$7o2
zVMeFAS>eV2RW60JD*)jA6~4F(nI%?Qt9`HD1`Ag|P!E2G={Nnm6pV}T#o1+dtt&nT
ziE66G9@V?ijic98?^n1nK=m0+SCdYax9rm{Ro)L7A5^-{S$TLzg~kZZQ3+1WyeQ86
z$PbuLk2B|NqW<lKqc7s)%iGPE<K`;}ap~R$qe~N&_pJ!^t@scUDt9V4gNN^4!xtwG
z`m+(H$P?DDpz0{K`aY`Y&|7#zW4<{6$Sr_r%Apx&Vxl((UtBnRH&xtyN81U4YZ3o<
zzS4ZA_LYhbKrx+q5Fc_smHir0>8XNMOoay@5f&;su*D24KUg~{;Vx#lxrz~2l<18K
z)qF~f{;{llYJ4E3n{<qr5}-50zH`J}7%_5`au(<IoH)1Vd=qnfPMq6w;@qAS=bn_s
zIQM48xi`~7_$UU1V`iLtGvnNw8Ry<iKcQn{p3P`$fzI}&$PC9=?^j}+9TVeh#+&Zh
zmQ?+5K`V$0T0vZJ3gUuOFe)al0zWuk#F9cKBj2|`lvL?6;#V2ah+hTa)T~Q4OmX;u
zj34tMdnZGteaPO)a(xs_L5wohV+v>Oq{_7>(pm08DidVyq{>Ae_MWKz#?YzikY?><
zZ1>@#U8)QY`Kf+t=v2QnbgJJPI@RqV%}<q!E_8>gj(yfnCO|(`7iI0FI!fW}om90{
zVm&*?yE7^Y`cJi+!r42|f;s>nx||Ofaj+O6)+P8*dfV0#JckeT-#`KfRP9svF_iB#
zq(T{>Ofkx5;6qj83t#mw5$Z&I;3$Jqry=8Yr-oD*HQ1x_TTOi#${`II*I%g&S3C~U
zn}RQ{2(xxHMfm?w-is>=1*hgc#CgwJW{q5YN<%>51gzEv*X{Jhq>Pwtm_3w+`Qv$C
zL+}bdNR0|#bOEHo?4kH6ET*~A5Lha%g;X*WoIz=A)R59*%EJ`~|7RL9-7iqWD5OH!
z=wK2t6M)^1VJxq;`Xs9mVbl3LM*AHS`*A<@37%1@UqprFA#QjQD=IPTjMfEyv<R3J
z;(~E2w0jh(kjnk|Ab~b%?zpT<D=hf_kJ*c|BW*JTp^HY$JXY*tG-j9I<BMzdC`wvy
z=O1TNuEEFVoochj9@V?CV57PQP=BRxV}R=Y8n2|v<<|J_z)P@q1Rwj77)Glf^+)j~
zSj9I5X5SR}5ctbDJui8G44-fQ1TZgx_w^qFe-x+x3i#_deFD~9&d2BT{}K2^oPHNJ
zS3iO;K1|<2&#?P;d|CV9XTfE-d4vNpq{1Krmci$Gd`Q$kKzUffLMm@**an5c1@C{L
zFr<JT5TJ|j0p>y}$45V|hPp<PXHfaEhBrZBEZ_%~zbRPgo?%&x3#fjS=mew2=)~nR
zKa5D~jcapZJKj6`p$r}a(7qJqVr7~4p<`(LC=_0qjvD4OC|q+!m?w3|`XN5Fc^UAF
zcelq?LG<rVd~kOCTE>#jD$P-V&+)+tDh#)x`+-&(hCYbI0239ai=z99vK^BDwU#~=
z`i98HMe@5f%$H@#pBYq)|KF`q0CEGrFFrW^-5OtjpvMK}yET5kh!f^#i1t}J+?&^u
z`5Al=6cw_=z0Fd7Pe5E<U;$;dkSdq!;|2$uY|O^T;zo6_#vauJ3O9LFxmHgess^w0
zrNN2EcZ@mJ_cZpX{#)TDk1AK)>4tBQ6Ovu=kw!IDV~^@?g_}I8ztHpmRfAVj<;r_}
zQRh1Oe0&fUl{@gE_Pu}IPBM=NGYqKEo;L79@(mbzDuzNTWPlJK79rBsYM)5(OMG#?
zEl!O-g^w|z`i#aN)i)Gw@~CnhK3)QxGX0mKQT;+=kLoN;C^B|bx#muLR1FsCbNaNz
zm{Tp)*rVE{aFa)sOX%@_b6WKpL!;WPu}Af3g_}I8&uDsps=?wnr&(Vy=2TzP*rVF*
zTpfO@T>FmqoA&;ucw>E{!AJ~DEaF#zC1<Y7o6DR2_tH9<IsXu|HVKqdE-PIRl7AEF
zPk@c97Ef|$Z0_^pbrXhQ?(XA#YKGnL@FqB)!t>`AFXL-R;0<y<p)z*$9#5(GWPJxG
z@BH#9%W?53FJ6n+^NJbKmsB@J)Tqj*;1E?KZ~MrO<2v=)s?s>K<=B^R@%kL!fl76^
zOJz-Yt;LIRd@}hKmg+;;yywKHFVojq@wTN?NW3J)Cuv6!HvhsH-ks9k(7)4#_o=iu
ziCHt(wLJO5!R2LJzD*S^-WC;4@WanL2h_y^yq$y~zdEwa;w2@#+=Mr`C{tdeBBs22
zl~<8)`xCDr;aPrOIl}gq*NyN93vL(Twk2K<Qh=-9sw4FluNR5e^Mr?g?4F0Ha4bb#
zR>|Wv=7<Up^Wc;ePg9v=Ts*6z4yW+Mh<`l9;=y@!zL7_=xUGao#Cbl!oNi-ntPfT4
zbPhImHX&Q`=#DwE%R>wPflwX>#bFCD^bP~5<9{_oIDuCYsaNN_dEUoA^~NJ%`g|BK
zq(EqS|APtbVwf4J%lWSzaph}oTyS|t*@TQ&a2N^vG)^!)YpO%WqeA`>BcAeCap!?=
z9m#<b@VmfhWUS5(@obH+FXvGnUc}-j0<UsVvgJ7#U$*-63a=^fDHadAXu)bjo>@17
z=IIds7z~ew7@=xDp1bv>%mdR#_&h`C3v=};g65uKZa%@W5$*uSnGx>w^EVJ#JZB*q
z$W^VE>6%VjP|LrendaOv&Dp~+Cg3<*%86`FO8US5lX+*%(RIbgxw>+EoZwr4&;M~o
ziPH-HYy(G599?j7jw3Yx$9bb03?C<V{E3SHw|v~r`Vc;Um`Fbv1`hBT27lD|D8j%h
z!=Fg-Cl{W8-2?di-~ZR{<scm6@D<>jg3tdwV8YGtas>74DdFJA>T!He;d>6B|MN#z
z{>aLwbD!$%`0m8_D}4Tsa^b+!A7lFTi707B`26l9pCDp4`56=icB1FQjNNem=hJ<D
zpU!R-`%-?FE1u4N*8fww)Uok(wO@sxeZ}1l_>1<)H&+cTkCa8MI#cQRMy5IPwQN8A
z%N>Lk*OIB5K*U|Y?X1yv75Nr)v+Ns6(Zk-dQmb6uEWU7IS=B<dOKf3dE$$*f#Shcv
zR%LOdUfq~2)ku7WT2fxlOSV_FYar?-)YmrE;f6+BY*Wpv2v<+z?Wu7-XfJV@5!%w)
zRn~;DV~2<PPnb6Af-ttsWezr}fb_Ib&0*M>DQJYC@q%6x<X{x6ZSX=?jb;eiC}@|U
z_XQ=R{?Ru0YPLqB1x*mNN>B%^@M*q5f~E*cM3t3=kR@2@f)Y?=X<Bzdj|+N9P&ZU@
z+U3DO+D4wxN`+P>w5J4pFX&8EaN3n~1YHc2jZmdo=b*@H)1yFx6s-g1=LV}V_YgD%
zNb~W{WQ}GDnj>hwphbep1T7I%EvQaVqo9?7t`@Xj&_+R<1zj&_i=eH7wh7uUXqTYf
zg6<ZyN6`I(9uoAhpvML674)p2{eoT=bU@JSf({8fEa-@!qk`H59T)VOpf3fT5cHiO
z%*B{=3kdQAB?}4(N)yywP)|W&L45@E7nC6=OVAKOd_+X&p&UVZg2o9d5Hv+lp`e+9
z<_MZEXpx{YK}!Tx3#t>;C}^dis|BqW6a~^H<#8ZgE(f4l)-f6_XtSX0f}Ruf9?%d~
z-X@}VukE%7`j?;-G`QOIE+B2=1t9J3AwfrhE>`XhMboKm<N{%+iE>^pv<C$}0yI>a
z{sm~5LdSu$AHC3EYd>ZJY4_d`bWBik$Tv*^(!NE6c9)>X1^r3T+k!q76hLFIeY*hY
zQWdI;frcw|7P<l2^d=yk3Mn9H8eam{sHdQ?pgw~73(63bC1{ACVS;i5<p~-ms6fyZ
zL4|^53YsHmzMw^d$^<PD#9<cxqy4B8)F^1BAdUp^AAIWtZ4|Uw(Dj102-+%Wo1pE2
zb_v=o=x#xK1l=#_AwdrddR)+6LC*@>FX&}K2L!z?=#Zepf{q9}DyU7+aY3I6`clvd
zLEi~NVX>frBm;sxLCJzbg3<(a7t~WwSWq89{RL$R$`Uk0&@e$cg7O576I38*il9P4
zGX>2NG+)pnK^(@jXO&>x29yJoW*q{`Rp?E0q(>^md%LxSLW0r+br;lAP*_kOLHz|~
z2+9&PM9?rnIfC*8jT2NLXo{dhK{Ew$fUiS8U(g~!WrCInsuolys8P^LL01b}FKDBn
z&4R8Mv_;TXLE8jv7qm;zZb5eo+9T+GK@SOfSkU8w_6mAd(0)NL3wl-1I1Hz>)M^E-
z5OlMkJAg*1T=EMb-5$LvrhgODZ-mwdgEsAQ29UOUF_5;qR7?*D>Wm?Qws8iKwh<MY
zgZYd+6@q(!G~e%lG~Y8oI%luPz)qWP2GXXt0BO?)#q@hY12F5MZ4AO(h(^PKwA}(A
zZTELTqg4pr6~0de{acWW8KE(XkB6GHdwly(qpJmN6tr2;7C~DDZ5Oml(A|Re2zp4+
z!-Dn-dREZOf-sn{AYjxCBk@;<k0IA+JP;xU(|_Rag$libQH(}^7t{mJXc|Wy8eJf0
zpde1eXww2g*9h7oD4gW;We6%0R43>mL3;%~g#OiqDx`Y_{X@{lf=&p!9Q`Y8V?O#S
z8oegyE%Z<{?E^sx5Ray@hhl69;_{iM^+(OB(T#%sBxpFwpf*iFnbD|JP`#k91x-Ln
z(R`}~T`Op}piU?YnlD?>3PDc``cx3hhql2f5skW_RA`hb=$N3hkukLCVnIESuQY9z
zpg#yo3HzqCg02$uh@iCIKHmXB9nbS=|LEhReSLk@zn_mb3wlJ*^!~o-d_hYu@M(V(
zlr_N5_d^5?141BB0wxN&TTJ%|x?fD67WAQ@fe;F^2V5B}Xef|zSx}Lf77JP|rWHb4
zDyUIR*9f{rOm7pkLrm`i!heM20io>`^cO*g1$`{&8$n4Ke&~A$8X#yCkdE&hLGuMI
z623|xIEk<{2yMNf8wA}Z=q^FO6Z8a-_U&mPBq!W^MNAJ0?H@vG6Z9`ZCxEmo-wEn`
zksr&8fV640po_(Hf}lD<O~SWIP*hA?fpkdk6xz!`S{jE0y_f0x`=OwZfppIK5=h%P
zDYU>qpVkFP^Q8%`m(Yd_DiAauNXIfFs1itrbd~UJ5EK=(6-e9N2BdA=Ev63$`n{Mw
zDYX59UJ>*+LGJ)*m){rkiI{#ZwEqHWe-pF(n5PIj6G)qeg?53UL4rmInhK=-oi3<E
zOe=)8RM0v>%|P0>p8)ApxJ68F6LgoD-Y>L=1nm{meL&j1*M;_hpihBxNWT!ilVaL2
z+c)hDq+K}|NQbJwm}ZD+j+l-S+GL^46x0l){k=|5R7|%5>D>8qLBADrNccVw^ravN
z6977Vse&#5(xD$IwCO@C1=3-u5Y!}mcL?oHLB9~wdx3OF|0w8XL2W?V<>P|R9PHD2
z2<io7WD2C+8!BkLpi-bzRZCR}S_-7?HUeq8&4O+ebRUqG!3#jC%9TF}?XN)EmA8fV
zq0l}P)M1EkH%U+zAZ@ohkPgB5g0P%yXfuFPmA|tET@Iw}mI+^jpbdg{0BO5F6SQB@
z%YqI7Y4`pLq{GrC=s$wa!caoHcaEUmK-%sAAZ_<jK?Q=MK-%t41l<Ir?LH`cUy7-7
ziEr8;NV}XTXsV!jf<Azpv>)i2S-q6h(19|v0-;S2TBFcb3T?a4b_wl}&<+c&r|tU@
z2Gaf(3T>v)UKZK`q4jjcE|9i6Q)s;3L(>|Cwo+&h3GHE_y)LvvLQBTliIzb~R#7s9
zmL;@BLMszm0%D1dDO&a)LLresrdoJ|7QgRLVn2>urY~F2B>DRzgCGFqBJKbJ;(^5&
z<xWtJAoMZH1EBB>Sd8*GC_EYzqr5;00;wsuvrsJp^5jO0=Wlce{o)vfIc0rHJmpJJ
zxWg^R!__bDSBp{j)--pb#VE`J+|d=IoDayoS}{sCAa`EHC^>-KQx&632ISaPQ!>?l
z9RvtJQe2yh_wxwlmkB|a7#)NL9x)P-xwxUh*FcOv$V2lv#x4X4p2x^~+OOR3U=Ru(
z?z>7q&BuB}VV-gAY_OijVy!hK?iO(E&G0J>)czMWJV-?F{G?lZQ?0wj@FXgpq4;YE
zam>Foq>hT`Ba?697yy57c#;%P7=J0v_P^&0Pcq1^z3X%a(DkK=INGOpMxGX!Ok8ES
zEP{LV@awF2x)PrD;{jgod7}fyqd5OG<cg~Q)9{?rDA}h`^4n4HUUhvn9+dHajzvl-
z-pBEOn!Tu<Et)MpjnZ%$<=WFI+fSqX`ZUUur%?`{Mmc^O<@?hpXUFAWZJ6DT!gI%&
zWs${A6$?uiFXq!%MyK`^7|hFKe0q63SKNJr+EO3ZH7(}-+YNDgUJN68ydjInwnf`s
z2XR~2jil}voit7$@4EEK=2A{8?zY8+@z*RaJoS#kh3fLT%!{*z4N>V?E_YBZWW^lQ
zopRgN!c$Dt1xU(@My0f^Vf#yx7V2w-GB3teGQJf4|CXuQrSZQvgDyO6??g<H5Zjg2
zc)xfs9;(Mq%7v;bj<?`%=kWPPH`b09OEVhlC-RLc-*93B9>!dZ%^yAi`xPVg6l{r*
zE^EM5#Pz5eW@3kzP#2ct+M$>Z&ulkUH=5A+Av8o>fL@Ec<7;ad<8plQNIyRx(>K)M
zmH3**@))I^^_tpc*zqW~jagZ36Sn~RWc@y-$_M(nn#|gPVg1V<d`b4;VM7O9GAtY(
zGKe(&_mUw)6vN=Gtc$Z0TGVlh%^J|MuCBtZ$qM1BjJP(Bq&if#<4}0}T%j1OxlqFR
z;@drKa{Avq^2N1%r*mk^dME?YyN&-XgP#xS;Kj(G4a^=E(*r$+erj)2;X6t+`2ZF2
z4bIX8^S2VT560t|Y^5f!URQiWFt~~P9fHAS6LDnE@Tnlsy^G;d-0uoBX6H|iBM_4B
z5;VzizkR@)W?@SqWXzxVJFLCGSD}@jQjA0Nr}ACeKE7eNvF~!6*Ef9dQu~{oJ($q{
zZ2|ZYeC>V=U-lq2((?N$0<>bjXf*&|d^<^E8otgZ4`?R*1>dafy)Ez0E}qeRyk~Sx
za(VM8Ywe^P76!7v`q<lYLt{Uy`I(GpYILes6dfBVtg@!Jy>#;A$$8Pq$<tf%kG4Gl
zO*H>#^RuCrvB{hEHg<>>_8ikv*t5%%XO6%0^L0<(5c%@*D;6$z1{=ewBjLUc;bkSO
z!gyC8yf_lZhB983T4rr2EvX?*5mu3Faip{a1w35Y7_MvxmxPyBMpjri{GQ>S)$)Gx
zaW6V68DUz#dI&BLiP~S~b@CdAM#tnJ1c^~Anl}XCqU^oRYeLwM-;7D;#xo0}PT`V`
zaA0~{A_9#NKg^_j;hFWTQmv+ElySK-{^<L7WB6yJvmh-x%ZoN8N7sa+Q@gLf>Qeaa
z$FKQ#a?7m4EmMyawfzRx=SHU<Y5v-Sgt~0q8%^zt9=%mm7##~24j0ZYYP(K(0o~Er
z(aCAk!CgGPsO?HnA?4<0!!7w~kZMa)XkUJE3GBAy`#v3;0wyhq8=iy-<)OkiB$}_J
z(&R-~CP(v=qeY=;UZ7>xk(T_!d4(<c2a4Oe()|U8Tk;P@r-tl9Aih4ms^9Fkum21B
zti$kk)2nN%qq7dRtT~$fR?C|o54vHwg_waGAssurczTsn)b<j%o1g6&%|9}sINEfy
zu(<6JMG0NH;PBcDnJ{C#=#XtNzqBs7X>T<Db#TodTUgbhctYEcg>~H<(KSbv;|Jhl
zbV1sT=|xpDXSY==j_!y-;q11BN&|@>h&F-8LrmKygBHy{<V)U<e}Be*K{7-h%@4sx
zM7ub;CatX}*)I<<hvpyI^j71<Cz$LX+v7K#MAn(|hwnDM(3lyWbtF0!77rH{&Y0fz
zE6OSVFo;Dr1QH675>+FjdC7%s2fky}!_mvbo8D@A0x@iXoRLnk)VUWNH$2pj33J2a
z=TnJ=kC_KK2PvBzorgGepN=e3g|t0dT$M4St-&~sY?Ob5ep<zaMQ!IGuWmZo<>tLA
z4;2<yK>`ysCnAtazVD;MW>=k@(KbktLk!jeWW8h~p<`!*USGSSA*`F4GE<P+h3}f<
z+Zp6Fhau#B`9~S>efdYIL?`D(2XA_zDPjHEbFIeyNU_;%`@cPTat>;X*=<h%T@hUn
zn$h+U5QOX}3nEzrVYc0&$u0T2Q6!(PvZ_i!+^mR5t6kCj-O;JLqO*2K^B|7=?L{-%
zdgy3u+S_y!=!J#RNmHg5x6Oi;=rlxY+q@eBc{c=}iXx)Bi>j=sRalicqwQklWO&ow
zE}Q1EPMWoQ`gAyUuJ)efF{-NCMYtdJUUbH|efigecCuyGR_5CLtu14E!d_lW{^pjk
z<Dz3i2ytq3*4E~yooHUT<&`lA(pN2$$K5b%59-V}AK{4Ui{CIcr-o*?EZ8%<CI5bu
z;@^COEU*Tp3HG~edYO4?*7i-WcDecKYu;r&&@yWabeq0M-x<Q3(RLO1Rqosl{*Bwg
zzy7LJtINhOz!1&f2JsXXPM^^>6Kv60yTG|GpVgQJM>ZaZ8f`v|zmJxZw71cX7N$j~
zZg07{3^6M#teQ8y?QGbb*OI?Jn!mlUtrIkJ5ul=${Ecmv@;dnjWPQcovZ+o9X(Q@+
zWc%Gk(OK6QRh=xXvYBu*T5ebb<F*&SW`O&{7rOp9bn{v^RV$0|V2?6Qjw)W?*_AMb
zo6)Ho;p%j8)=|#3t!n4sQs|;n*SBnHgrzz25LO7aSg|0<w@|2w5Y4{)^@y?c)%fJ~
zT{dyDCYrC(_FE8<Ae&z3vgtFz{N3wUUTSsO^qygEERCuJ*f<CcHtQcs<v%A>Dn+Mm
zZQkn?POoYxYC8%N%lg#q(fsvQc41Zj>1_uT+g6BXdr?(+VcTBC(-YPh%Bo&PZTBjQ
z3FpQljFeRXH$I0<t&(-qV?fc{nPi*Z>ayt`=&J0KP3x;>oow3PRtxL%=8~|ztrU1)
zpbzrH$tAp&2(q$BpRBwHAFGE|)X&ke<682sN2c9+>=IUWV+#<eyyz@6$OR}Z$ey&w
zqL`vBwmi*zHiW@o;oAoB*k|pX-h71dnBKg%Bcfb5U1y-SxBo*aBu8h#A;kHT!nT(c
zC8SeUOaGs!QQ>J(+x;*@GMKFY9TJ5Cp1OT{+buMiwT1b7)76L(Gw-uZv{}1Y7<lV*
z^ky2U9KXG&uxkGFwi4|Xa;i%Ara^vUZu|?Zwmcop%WJubi98+QtNKbO3$yC-!nVH3
zE|PB-b3zr}p9N<S2dipcVOs)>=S5Xe&{iY9ZC`%nhmZjpubKdpbuOi*Ftq8_#v#$E
zn_HT8w=CGzvSwS$pIcswuGx-O9o2HL*=@h23zvt-Gx~2ewMCnDM;GjhuGxkv1RkSx
z>s8qHWAMQI*at`|gm-t;n?8F++e$+{&f4lY8k!12_>Q&S*aGCPJR~Q&UsahXxa->{
z7;}#)&Z;h2)V-*<ElZJ;A({N6g+((=8lJ7GNZlLq4@|F0ENt1N%CTeUs^~`*jah~N
zV7cwRe>13QI-!f&URT=Cv5m|)v$mszR@u|5`WLl5rVTXTu`d~-n^&ro^o4yZI3R46
zXCv(EjAKhESyT$Mwigznl-Gfb97*R@(x4>HFKU~onA4aI#uns(ojH5c5|deGsp1If
zW)!w%Df{S+hLPwSha%BW{*HVno3>UBVA<)S{bjC1j-GmbR5^qC2sxl?Nm1LUUoy_B
z(5tGD5=R|(2;@1@8(7Dg`sjJZ7&=zU=;m*YPTgJQv6jBq(EF%_xn8GxO<~(Dpd+E6
zk4_4pRz-MA3ftBz?(ngLkf|yu+f*H~RX6s?H_Rf_S$2P~v-7bGx=RV|o=&%l(u%4U
z6t)f1zS45zO6DqN)-D^bLGIDHHQKbT<uznkWY=PLII9-SZgUx=%fmXi9+TX9Y%*+V
zu_5wxl-ggvpj1M~o<nLOm{rMzC!4lGrZd|9VIuGl8>jr;Ro|b?s)Dq)xBb#ssfAlx
z+WqXVc3&?w$@O}8UF{S*ggH*9kCl`(5+uwDo?*G(@T3t*yed49YP()i5Za&(ZLpIz
z3r<YscI^acJJU>SJ9L2~xILK)EhoYyV~kV(aH(@rlJ8QIa#*y<{nX9mox0iQCr?bJ
zS9mRhZggQsE|dy~axjYSN^_c~m_Wj3tS`XWqj8!znnb2<CbS3)Lwkk^jtbkE5*)?a
zJr=Q~q)ti6Nwjd*nRYC|XU90Oo`9EWR49A)Mkog&(&uE_qms4U7z4^RFM)wLH>iaG
zUmdvF3tA&xYQsZfrbvd~(E6s(o)_<E%*k{i2iyDA$M^-Q(DA;;FQe^e9H$nJV};I7
z9cue0*}RPHf_S%MUJi&07+k)vqsa$dQNS~jkfBm+M)o2)LXfFxNV}&n=0{V3U%<vW
zp72<6kjKs(*iet_u+>w+xY8PzU@u!$S6^GvFi_74T{IX6e)L4ZVx%p9j-8-h<8#fd
zk>&o1eXfA7onkwGwNufl2-X$jY?Sjiy9zx-ysjRs!6{DXE&FPi;W@Ej3AKmq?=GO$
zOW=Zu^LJyK9IVA_qvO@lC+BTL3<WVWHMSO)bvyqsq%@MImNYE2oFj(RJ;?WP$6|II
zPoFyP*gwazjFa9o*ce$>hbigWdRTwgP|peKS*`IUI8a??Iqw<zxj{Z*GaBwJFDbR0
zqjs4JWUrukquP1jcoq(-H`{r})^a|uuTX4#g4KB25s&*;!pRTqNh$#SgP1O>t)CWI
zVGP=gK^DSLQ3+p;88?RoYsN0&Jg?<^WJo#ixVEvR+NXbP=y^eXa?CkyI|CTaaY3H<
z!u7KDIu(?HAl|)hjMS(jV$SEr+RR`{9Q6zPzAm&o2MJcT7`}dKd&;r-!4gdCE{~8p
z7Ap<Tzm5Gx!IgOQy%elp*}W8NSrAWYf-)MfL_7bnn^h7o39c-xuT?90&Ix;jVyq70
zEn7uXtX~_}x**=7WQr;3H-_36T&byJ@&4}Ol2WAdxAt`9&dOk25rj^nvhtm=a&>T}
zPmfvpul;#P)T!y~?O@$3^;ovD^S!d;rf;-^D>XT0<)pm={<!IzVaC**7KxNGhgc5Z
zr*hM;Z%5C*1jWL6M44=XCovn!BgdgY-1Mz5%CE1t9M|~|=HuM-ZFa)j%=Q5%su;H0
z!PQ`x+E76kgNC}x4mM?5PNMS?($r1g4X=?kap`=L)26)K19wSLo^>*w-48a1x&kw=
zD1{-1a&yxk0;^9|>|G7}!*;O7H@K`0Hc}iGR5$%`J6K{4P&?h6Z$hN)g)7B4Gi^C%
zIIC2kUI$k(vH)HkaL#llsMsBXlRmAxaqTep)O@dVwsGqSD3sTX$d#7U!w|o;gNx(N
zxH~<adr^vz9FC%MX1lftIr1Fi>{f@>$&AL5MwX;=oljI`w>iNwyqz<pwsa|Cfb4pn
z!`i@2$H3QAU*>WJ_xbagWxZf^ZB0d3{lVO}Fqumk+<j9OSBDr^6N;94p)`(tu<z&#
ztOlI`$|Rn>3wQx0vKN?w6i>{-ANM?m*F1J44!G&glh6d~rbZf<)Rr|^ZXf3pv<0X*
ztt5YfKJHeBA#S5GPdI}vH7Pl;l3h8rx)zTh;yUv#SQ2GDyRrzc3R~_9XNV$r!IiV?
zu^?f&D;=J<#yiz4&N#Ks)2_JCoG%*TsoUVn8LM!T-Cgb6q6le0yt!T-nZY;L-K(5G
zC}Q{EN=nyquQpsgQIu-1iUiUcLkc5IOCqI9iy~O6!28?U!der)KHAx_xKyGZuW-8S
z9KN39r1yvaIGkEruRUCE*fWASmb$#MG=i!S6%L-g;9K9N5Z5(^BMTz_5`s&nI6J8t
zD-kYs<{ucfsx<f-4BCuBQD&W4Mmsalcdo!6uy%uyW|}KZ3dJ)mgi#kSFkE;kKJB1!
zh6mcUGZdsYq6_fh8Zml6jEG=F%U)o+Fi<KnyDG3S|0Af0kHLbw%Q*%dBDND3l9J+n
z3ra`g0youVE37k1noIAQSsGSf*1$xy+-`;z2rgS$Skkyey*2EfVW?ihCv@>l<p>`(
zUxF@&+uf~$o6IV8qwDI%aSh5n%hh#1atq%Jx7@ScUnnNzlyRz?VYxls=M)KfWprsN
zt0(syLqcAe5NVu=rdkK!T=#v&%3RV^T^$QqFSlbylTF4|YoEeyUqxaTsYWe|2h-i&
z?r25JB5lU1WhirQiJ}Z4#gvtFccr2YLs`MC8nw&t%m)jg@jM4vu{si|v)sP!O^PuO
zSvqcw&F$wtq3Gj~B%ea)USK(boy?N1Q+_A3otXliDYCe9qygBOAYR}qXf!_s6vuC}
z%WuS-Qqkr#>dcA-_Focn3g;C2KGVmFiK#?!#h73}1VUGv5<A^(^fnPTTBH25xhgS?
z5bRD+b}7f08ORmN8Usnm#hiuFS~0p;jEG?L5ERD?nAJirz&lJ+{7O)*qgt+;_%~2f
z`4Fz1xDD3a<iz8kgote~a00li9l)?a7nVeZ(=82!K<P-F>~`o{2o0)SeRGNHb>(SC
z)m7!w?`~pO2AogdvXyo_cBP!rSG5u^puQ|LpKcLnxQ~Sj(LqMnEp`Kq`^S*BZ?T1w
zi)q|vLVs7@1cEh})t5!;aTMQu*06fP5~1x6y{Gt+<E_tXC_&HA{d4G;G7AOqXfD=-
zE%z_Rg)~yIZfv;+LOQ(N(VLBw&8!`d72t`+>=nb^GpKIG8N;XJ8=97(i{rj(jKV>j
z|F2wzR-tTcZ37y^*Fq{?((y_yXI|Y%Xg;FckvQO<*_Cg(p<93@E>sO&r=knMwkvTW
zS<6G$k(Id6T^8yDLtPiu7|+;n)kjndR2!P1?4spDplWzSfm?5AXuQTCRQf&^w<*-9
zIMION{o_)fd3oqZiX2MV#A<4V(MpxHGW38lN0nqMfK{P=ih>#m)gc-cG<%`{DiUg>
zX}s;oz1r}gD$1`#=2&C&XsFPA!87WXyEc@rdeW$YbSK|k7aFN3sDE@1({k5`N)-te
z&=|bj1Z&rr0HXTQP3{ImK*eLmF>bRVq2}@Xx0bun5XUjtHD&Bq@!==S-4yzr@}q!_
zzphDJLI)ISim72PLF_uKKdKa~Y9xm=_T4&fLPke9oT>hf0VSEm+zT*Oy#Nc97hodl
z+Ny?DXw;bqMl4odV6HGQJro0|tA+XtpW2xSM!dWcmXTAuz!qU+(sZT~sDBXZzkI50
zvQ@RJB0&RivV-jfo<$|#1^y(q&VdY+Tb&i61(+XETrSLXe3)jM%QVIph!N9HM^!xQ
zY?#Ig(+%yJRM-@a11<P>6BJZx_}f*Dy<&msY(md8@dB0L&>>>lX>Uz+`xpqZZea~C
zFhTyu7N8P#Hj~{aLZeVWBrJu0?vql+YSD)6RVM5hHZ`dGnB1ofB^a!n8L3}po+ovm
zHr70hZ9M7cs<HnmKKmDIdG2$epNO~5i?_HP3?0dRzQ_MN;O6!%&wWW%k--vNabn8)
z%i>xs2lnot#5FH)5W+ydfzMum{(FIc<8Lx6Bv;+D73h|Ltrcksrv<_*py{?WvT7{G
z>39yj_Y_D8byc_0+PYPfBde^yd75H_(gbk^(wW#0S+^yP4eb90`e=gJt-P`xRb!xU
z2Q|n~27?v2pp(*sEOyPUz!@9h9nOFu0D(cg53Cy}7p%ZwZO7_X#~ow7HqcFN<_Qd8
z7C>9mtxkpLVy#W?R-?7r|B#i&`^3CJKf2|I_Izy!{SxE`E6`ti6aXJ%?gbbKC!j|$
zlCaD-7^}$G$8kC|EWwNK;dUG;yrIm&^dCZ(!duFmPWCW`2M@BG&UOu>9_Y~C4sS7Y
zy4XWtmcpCNoREDB`JABkfnKNJYBQ&+&0L#UgKFE!vL6LcN8)5B+ve?O>;z&+;taC8
zV0w$~be$T*4mN{-G^o4@&2omAi3-mYAF{{#_mBWxOYtx0a*FJ}U`X=y8P2ON4}AyA
zD(lhu=%M3luAWG;P;4SIAQ!ylj>gn--Y^Dsupy56rr)1VC}Ly|xj)Nbh`nHqv1{54
z=dXrQHS(B5ddIz6afaBHP|b?-u3<^@N&502=RHG5`;LBe(=t9(k4~?1)X;nSL+#`4
zy~@pSutp2;pN6B4CK&fVG1UH6;@!xt&J3G}+dC3_&hLUtph@_K2EPxo7J~c}&Sd2N
z5Zs+fZNN&Af&5H+CD@aEeVTKpbBy*maBzO6CN`LU5hmx))u@~`5;r?q&TgX*VzvfD
zM$7qynxmlfR&q0(^Gj#ah4hf^egrbR%i;VE1|li|Y>J&(_6g%ZwQ0^e=az21_v^)b
zHF;+_*EnJ2ULd%7rV7CZ!{G&2GX|E^YzWCgY|xp8k%;ANG@(Qftf8>Jav95|v&j&<
zCX8Z4uXS`qk^-KB%Ca&Hh@8!aCDlsd1Zc5+CjyoP*xlJ+4?vZnWz=lz&KvUh7!=Hn
z_NWUOMNTG|X_if9veFASl$1vrS1qiLET=TCHS|PI3L%4DXG#a8#U7xdZB{d4kXXV8
zOwbm)LAjo0rI_2UoZ0rJ2uqUDmN`GQ&qf^<Y$#n4SyqC!rgmv1l4_eNXjZUsakZ*m
zom*|r5vh=tt<<F345@pt5x4zm+U<sxflR7Ix7`r(g1DFJN;SE3ht0_)Cw*p+lZXq;
zYwOV)wVWL$f^&5C*=e+M^%U|hdoAmh^m)P35(IXks<53qO+e=d%OLch+wA!`>5Hrs
z-kW7PbL{gGyCkI<=kyB9?2fpiwRFM(Q|xtu_ExhucqvZ%bzVUG<>)Ct##&DS2ZD7|
zBIO8cpMcI<9_A}6D^OPpB^fN3yRe+T0bMtQf{p4{MCbg#b$uARv|vMB335z-qwk6K
zS+&^C1!}<Pr1wz`ylDF;T)<p+Vc;QE+%tlesM0Ja!*FK>D^(aK)gljRhb}TkLlPFz
zW@cc%DhR_8)-hXT1+@Gz{ag^yp&x84<XMR?kY%pD2%_pp9CBs_?xWmlv`mW)tCjE&
zIcFO!a&SHd&!{XRc0<Fc$8r`1`s3UrO0|`ubHqIRaX6QxG(DX$F0T>@){U>PU1m9B
zT^%$K*ge<8aqbc+$F-J|@0#(N=9vl7c*B8mjDl@B6HJvCQge`&Guh?&T8bVAKO*H=
zT;Qbd6jQ}_4>qaUV+>2mEoZ8so)y&VCz?9VP|rp|Mdj6~sh1gQ55x^k81K<^F1K$-
zgpz!H*ty&(!SN7O=JiOl`Oc42HnxJ5h4qp0d{&eTOx5A20i9pBI#(F7t25<7qeUKM
z^{M7%oJD>Ws%CPW5@(JoS*#OOle*Ypr&Le-HDap6DK!L)nlQE~sb;swDRVk1@pRX9
zRKy7>ZBHx3TvX}Ix9bpxB%@7st_<v9oRGXtfyF9$5y6R&>2g0i=-jcw&k1mfy;(%o
zepI=nbXm?_?jL&ib>rP8Vc`^npz8ZynS{i$l7AbY^J|y0D{MAODls0*XJPw|`=AOk
zN}nkLdrVG3@vFf&+PTNLloqV5(X&X-y^{W1S~B6gPm-T)#OQLQ==~;KJ++V@aCr>e
zNe}Bv_P4ICWcvh5*auL<e9L*zy+<+i50;p=<{_7(FDE_2O7Z927unAv@<~P;a+W#W
zd$KI}<~5F)xX|fR>*)3wIY8C+b&~iT5Ia|z<}%qzY+%VOvHQTaj>LVOjzOL_(hYl(
zY1rYDf5E7e9Q?Iz?6H)g>#t5h>DzGD#OWN={ZEuJ$PXPqqemI5#?6JQN(u#awVD=O
zQqrI(T@9rhN}if7#tMWXoq?6ZNF5hEQjJsHbw!sJ)D@kPcemj4DrjLVrLd$Pli<!`
z`+GztN$XBHR|anlLu_mT>Vvuku!8j{SPjNqJ<;Pd2BqTAD`HK-p#zyD$-&av>S;Wo
zF(ZP^wA=&`eKpWHnm`y=7-H8TTA$LTetWvokW)~0@me!Vz$!yY4XPs;Ca<kFRCM+@
z4T?htmUES%b<?zoH7M5>X8g4b&j^+X=bB)y3MjgSn8~b&DC=uY?1rKK7vefYMBT1Z
zX}!_ssWndYiHv?+u!d7?&IY5$ilT~pv(ZlpmM$Gr!tiV~l)~T&t}p0S*-gR4sv4UK
z$+63zsn;6n97CN@+lb2fI^)26LoHTUPdl4~Q&pT6sgPAi)cS$*BgO2dW4WzFm1Iqh
z1{Z)?Ew$B0D$G)AtKr>d2NkgvX?LTcVactgxCGhsCPTn#8wt7%+iHkdbMuL&vwX8L
zxf}l13I8p@Qsq5X<RUBUsyX~}eyY;RO~-;<14ON_K6bVR*~qH}xd!GaL%!9JvFg?^
z1*^!0e48OZiv_|NSEAv%U3J0T^p`=HiPdY%*={HYur`NPW>dS}5tQ{gMb)=0qYoA2
z#T0Hj*67$L!^#;~S9b<^U4WZ@*w!8WUB*qU(KV=6>1QS!M{P8ErPU?%5jEfE{M^Lx
zI2Q&h>l>R&s&#toHvWGG0s4K2yNu}YT5F2Ag48Ls??%x~GTH(sBRJ+f)^MhdxyaNp
zx>J^Eaz45e4Vd`DPz-Z~&Ok%OG)4o~nrf@D)`UKcp(cQ;Dw=FV=)i$oLw?;7WbQ$R
z=3&U!plT_964n`Pj1qMRa7a-1=sT(^(Q+;})nRhN99E^51a)^Wq=$V&O|a8~bp<8M
zF=DiwVTPl7uulBA)UfsB+AKB+SkCaE?udnTOESV}`<PzjGS0_3IfmMwJxR6OA=fyb
z0msYB8(2q;G$eHX4AUqjekXlMu+nGpNyCCAWo7kTPSJA73%;ys)Ep#KeW|YQ%j_bg
zOp>q9a&8K2VN%tAf_KORrrV;M^_z_r%d;5v1uoZ3hm~S-XSuzDZfRYi^NrJlGNIeB
zZ)K3CdurdA6;3qpXl^a%zfPfQH$C)^)cE0h!+@6Ew9qFV-TwM5JLYgz!<wc$ySA%k
z%({~8mSc>2Cj6MKr0cSTp!G(VQ+W_DeaAj(P^cRGplR@t0;bLC;OY#3VNF>X0_sb+
zqj5Y7HBd>}Wi{0pEGC;C1QLSzkhN?lL%NvlqKqm#8|o#&rI@r*ozE_YG*s<&naJK@
z$dFLYH<&VrHq;O=1#zs|6O(Fa!&L{ua?;!y71JCud+&5}IhpIEqb<-q3|031#lUgs
zsl<`bG~JZ~-OD-4^m3+HiM?1ND(q{JrXgZG#nfg??3+PL(mKz1(tRD;;A+d+>pr4F
zVs$TDg_`pzm(xiByBEe)-JyS4>w6(+0V{D3Q>oHE0=pfF`#2*Kw)92*QDc{!1b=`~
z6Ir1qYH|~F@&|&o)n$q@(oirf6Ip@8(v8!o1l?p|4^lOgP*d{^HI&eS{*E?QF;J+e
z!JeW?O`Mn*W2oJA78;wNvykbZj7wnciX3GnzDm(l+1nA^j>H*GD50<)gupRpSL2GM
zy-G1!^yYZCGkQVBSx@KVZV5UcCkGo#>ML00&rD$3!qL5|l)5MAJc%lYt(q>zXC>%f
z8|oat@7^O}mhM04N~dQ+tqLwG9kxW+Y+(rfQGWe)WU0Lf!A|n^8O|%gi_d3mfF{jy
zUNs#lOb_Vs=4*z4G(bdOmuj~W=M9nl-|#EjVBPE`oGdwLYA+OOqy&2U*k1BxPzO`@
zx=fb(t7@1qaMQW)Z$aJHM(j|z_<gXq3^g1?53FuswHkgO4w`7{SpQu$jM#r*B^EHD
ztL@Q<Pe<Y<&PRbapwXS<j{|zv%Sz}>zT*MEUtBqpar>t~pb26;QiCQ6uV^@*7-Dj;
zat!JLw78!d3L-N_Pv3lIC~4?dOyr&9&c6cpt8~H6Hp}@u@O!1{X(g_vzsu}*7(U`D
z&NG1l7}f<V^>FxE<C3Mvh0hr+T20lXd*0|#gL1BdvjUd0&k$LQa&~inz^_9&_keM`
z<-A~6koCc$NG}>v_u%4sMCv7@?HR1WM7Q&@(T35l<0SK+jJ^*hJRqq*8*P7;C;nn|
z8NoX2dGd8x!MZ^)-4OIyv03PVVI77MC4&Bn(dGn8Ce}=;rPFT&b|_)xVG@nYhK$j{
z02isaRgN*#5<YBb1(vJdoCsbp6oO3E8Z0JLtgadhB%CvyCJMuVa}r*FQ=`}yX|@8X
zB@)=d{2A7<*ua^kYk909+4-l<&0N7s%=<Z?$Rrx7p_ytB`l%rW)OIJ!`OM65dDdB;
zli+aA<k^)C6Y&sBeSK4%8cuXj?cdp$pTy{(46^eaF4rOmocZ(ufA7G*418C$X;06G
zbD#)v=K&;hi(ZV}xfqo%%=&_=SE0CtOfRN;fziqaH_62&*7fEFI@y`)1F$<=adFF>
z=28oetcDdU7}h8T?wmW7fje!$umeWgckXrjLBEuTCL&LQsRtwcJwVS?#K1<xIBTI6
z+29}zdax76N>Opp8%}O&Z#cCa=S^(Gj|osen0o<EW_xOG0}FX!VpiXtngGKxB}eQ2
zOCp|Apk|f)VmZ-t1<>N5PP3dzrW3*S8QurysVPS<z_!l|JPArNS4I5g3Cz7#W3Kpb
z?l?^H>9+1InGEwM2oD=S0(ye*??#KF&Z&n8cG2o-ledilDkN1W{KM$6rAH5dj+p*T
zTFn1)P8fxp57m-}&(~)7&}G*XO2=G1!{paCAH{+Y>#~3Bdyj~6$`uQ?N&t)+_Fr*P
z#&5CoTPMlRTs2GRdppleubNKd<pDi#52&>mGs809OyMH(dIYe*5E6rBwYZbPxx(l>
z!p}$HvzfipK6*~Qnz+)v(gx!JN-pb?MpNZ5=`u09mEu3r;#?D8>G6BX+NliZmH?Zs
zARm?}S*!-lKlL5d?r)O_tR7umS%TK?RzvZ0Qr~8#WRrE<f4iBmRf`a{bzA}Bpl7>@
zQChGHwYpwaxx>&f!QxN9?l8gUSOgX5P9sb-nzI_zU}cvIFZ;mAbgWh^=gz<qHI3H?
zQRZ}IkCo6aMXXFwN-}k?=e(*a--OHAO1)-$LPwysZZyUiX#C@3NBdrY6Hi`%<3415
z)X_cI*m6ooN-1Z(da(L9>{A^p@mzW^H`oSJN8)5>o|>)+M)-h*<y>w$6_y^s%{N*b
z1Ba4&bUGH8@sOWWuP}NK!N^B-sXXKqgbGFnt>-L*(kFq7qZUsI&kL|Ci&`HYyK`()
z?VF(znxv&ob(Y;-t!khGvdZ}fKi-CSE|=2m?y67GYW3oT8?>rV(HaP|OKYFS9_=uo
z-j$YpHpNgwP2EInZMW<mbY&X|@SbTR-cQ76*bF)B4ArjO52i4@dlBl?EZ^@8<M+AB
zvkcXJZVmL}ne)q*T6Tu&J-2$+d49Y&PDG~w+XwA2Hr;y&-`V)~!_8iZ=~&-I<^g-0
zb|BD;jh>xvoYTII*S;n9s;w*KPF;I~HV*Y(ZrKw#`NpGbxFX1ibV8&iQjff@MtU5b
z+3(saYJ0)9*TJbcs6Wfbpg@WBJ==t&uj<v<M{U)sX$|yIAv3%ATfM%R9=Z(sitP_{
z``en_5B|5=48Wh@V!tZO*4y;Ih3<SMsE<@~_JyDQU|UUv*?NCIubb$nMz8j9<z6WW
z{SghTA8QX=Z^z#NB945V8Z%5?smPg4llHT=&3F~Lc-9YU{vbbY&-rodqk{9iUNiHf
zw$DVw>swM3Q47}gep^k8BW}n>FDmo1;A%fDnwOMlCXi5{ZP_m?^9Zy*7(_pGyKI}+
ze(`+fMtnylba%E7-Ot*G?&lIZPSE4HguUBPlKbkd7xpg<A=Hmk6PA6K((i{SOq#n@
z(tHSAEL-X@sV=aM<PG44p=4~1fcnJ6eqNvN=S=q9?FFWoojV8a*jK30Qme<Tw}>e}
z7glu%EMYd?0d4Qq%)^V>>3D+LNDabX$~=3BS{+oS$5|s)Udw3s7&UdXRj1RAFgSlv
z6n0GQa^}f@LLXL{vVs<-Ccr`&yjsGZQ!R7@(5=w#@7a}E>~^-!>}|%gb``C>sF<dW
zwd|#=F5TAM>w2paS54FN(5vdbEV7K}IqYSmj3I?H2Dn<nt|R49QaCG!ci9>iMpkl|
zWM4^>cNMSNwl=yP-3Wi!XE)IFY#dzcU724~*50g<W+lo@*&GwWLT*H?HqrQQ-|8ub
z%W3#23<n^N?D;HQ#=}1L3N=J;oqwTTdc);5waXTkR!2%|Si^3z2O<?Ro`T(bAdPg$
zIm}VJ{SuwK1c}zWQcXGAFOx741nVMJtRumx5^s=Ye?y~6WmE_w-YwYA&!s6U6Y?pV
zi|SyuT$!nbHq?Z)_ZIDCK7xS1jjx~H6=~12nPL7*Gb{5cC__3TW_&x*vX8Jyb6N{}
zWB!yW@eT*|c`#>v&LOoGL9utN#Xz?GZRbw-Ya>n;<E4&qS(X+?CK?X^eLRd1GM7*b
z4t)&~wD@6mX^A#i+=x8^8ZO5<AC1sQfoI4(XWG3l+K}f>_IkgNJ0f>-t(&;PDLSjX
z;;(M<=NCNo{<ZFvnM>aX(M`(S^1(89^@b1XM|!Q^Jg>RI{i*Avw2mC@uF4rREN@s|
z?mZ)Nz24q+(Z2V%tIPYjs}Ig?ZN4&nLi#$`_bOiSM!J*tY<Y6%=pLizMsgo}%x&<(
zIB@9JPr_gCoK=rCxJ6#(mZd}UhK(*6-5SY#!OLy(vRWJ5d)IgekGkD+mM<SM(2Y7f
zT6ezae!FJFV<U14-K0HkQ%<hiF~?nAuKtGc_pcueAJwbE`?FW=jy~v)Y8=}-qRIXB
zx<>b)RsPbU+=7w4a@}HYlAGnFY;GNqyJ_bK?yc*}-4CtCX2f7%uiP7pN6vku!s(NC
z=-ef(?^Sp&9vZ&nBlpMa_PFcqMmKSXlb%|2pZBJh`-L~f{m$CsoR|9kWA5E+v2nm{
zvySEs>octC{SgDNb<R(PgG08ui3cAqTjF-yaG!gow`au*b1U2=Z_9&Ts+aEV^ji0M
zqul*#J-F=6anJWsaz{*#<hqUf;RINkyf@vUUb*{{<sI~L-5K7N54=V0%A8S`4ZYbL
z^`<x9`=eLkmU>&<dav;du<mzvuX6_2-rSqKL(jX<S#bEibujMeZE?;*whAHTabESL
zZP{0Q$$`LT<R5g4<yQ_gy0f>*8P_Q|zBzbp;5s*w8LEF~^z)<ljeZUmVBW`Y-w%~V
zMDdU56kL}Xn%0p#qm!<{-{<lSUl@LDjpH-!&g~d;b#&6C%urcocx8-~hccrt_ouoS
zZZNO=ei=7PGDFVz%y1EushQ!anW0572S%rYKZ};}WBYm|)Klyi!{XAImAuU4{8VR%
zvVn^j(ezw<x}AlYVOq;O)ta@^*i+3Css`V$iCT^o2wl4<JGGhN*_k1Crk$BJ4K9vV
ziW{~w!_G43AIS_agmF6bmqEKbGmPjiQg)mTnc*uyTa_7}n;A0xQbc?Xmn!NhVvlM>
z;U<qN(>MOfT(msu@=iXmje)I|jt|dMqta8aDFDs`<ef@*>3KdB_4{F4#Xf7?i`hPB
zg4G&GNDqh~F0K{d>GLa%@Amxw58z`csXnN&N0m81J<SZ26{LzS)Lw>8HEif)=a2f{
zhDMcFQBpEg^A&FLsE*h40M+{pohm!N@e*4I{bGC&4Ha!16U|=Gp29~fRG-n<qsluA
z8GNdH6>bbrHTY^BU~~e(`w70F)oLZAClmGn8(xN{vPRjA`Pcz^-s#9BoB;JQe0Y+&
z9tv3jeRtn6?%Gxn-PGQ;vSXxv{|4<Fe25tpV_fJP9|i4wZA`@&&-9HMggoV6F%`bw
z2N@`JjK%?~<2Cl?K)oDa2dlvv)ThomkD79PahYc?v`^tvvV{7K#vawFD4difRd$@o
zL)Bm@i~j`g31u&PC)Ka<xz=)f=U^}o$EP%YB*=XUh!7f;NgBqR(hUfRiuNidKh_r|
z_!tzbr5bxw-%+^9qspE%d8isJ!Mz2vTk*jQD%v>a#Y)hw$7gZ|;oJBSTq=g!4=$Eh
zV1$pJQFS%;s1_^S<WZfi=>e+jPpcwkT;Ze(PckAvRCp*2Z<udg_ZNWG=;kQR7JzN|
zz(j>^D7qh#N;td%AIzy3^X(kesNVx1{tlmq_N3t4<zB*hzR7abqigZOCKco3muqLB
z_cSj_dGqC3zWMfBU(*eq57Ytpa;@(SCBc3p%LrrnEuun9^`wp+74|3*@bA_Vn5cfY
zmVnWv1**S5Kol2&3DI|J3GT#4E~<MFLd8XJA3j8Zii!Mp61MZfJX%@I-sy+;3wZNA
zKG>nsTS=hEH|>F-_Sd1NGE~C>#vPPyIyW63@&%QJ8omh;eTEMVR4fRIl>?Mc1{x1=
zHH07g>s3OVFkdeT*4M}r5wsF0&_yb+#S~SJ@~xQ4VtioPzK+6aQ(hNSVHznq0UeJk
z^nOygR^myORzZYDX$VZBY+Oh1JU(SYz?9L&VjQ6f@<s`=pT{6lW;J8JMa+GF{VehV
zvH&qv<LimjvVuwd6Dsw8gGkZ_)u(jKPpl>2P=E$hjlU-(`G1VSY{eHu-p|V1Nl2a!
zEMy5F_=$dM_|}4vj#9k_AL2#DxW7%}Rf+J|<AXUBlf^%a&*Go0rNm5JK3jVyf^3}m
zOoF)sc6VxLs2FFC$2)U8-kIa^&KwtKQec-)tRgg2j5BTV&a}ll(-!Ycn>aHWcBg4)
zs2FFC#yfK~-kGEE&KwnIUPF$0A0JADFXoS+<v<+)q+(o-B^RHs9*Pg<REFV0^{P~!
z6J}LQb%e$q)lnKFQT6XI^hVfQ)-g|*x@*h2xVkHrF@Fz^F(@=BFh|zLaU79o@G0s)
zt16<9%3ts?OjKXdI6(C^jXkPwXe?oR18IH;AEHHtXHesW@(cow1`j`8W!i*!lOLS^
z{4!<`H!;asNW&hRRpd0{|C;aP+}<f>r_7jfhU|0>GhxLEDq|QoUBtkzK!V1i!JdoZ
zv$&+Cu{qz*b1#NqE(qYEZNqMOc--8la1*;~C)*L8jN^zq-~V@H0H04^^6_aLg|ANY
zbhpnzJ<qy{UTvM@xi+7|rB`+A2)V?kEypT^#j|=op;8?rQ@2+06rN8e-@;P8XPbwr
zeEKqdZk9(oPaz%b5+i9x;lF=6jR&=Ser;IGW3Y=?Sv<Ve-XvztoDJiV+x9FfxS=?*
ziWZNi`h4->=ivl(0)a=N2=c2jd(IP4JW0i4V#<_fw#1Y-xbWN)mvngMiIY!FIPb*G
z|2*5oEl)hx#Qm5!#>A^Ccn+xmXUVH^eud|l;`LnD!d5gj3&<%vUfnU)Bo9}Tu{fu0
z!{8dDS*YWR=D5Wcmz2$B1}<2tB|5H~`HN&0_us4CN?e!rcb0RR#_aLnW^6UBY;lRw
zY#-({A-5p<Vc<H9-ZFb@82;hZKDO75L3hjF^Tjo7J@L<#4~5ijKkhow`!To*VrKaC
z)<Q0b2m$-cxmxN^0djT=+db+rn~&`dT=Y>oy&r-r?|K=YYcXosod;$h44zLh!r)~$
zCb4CWy)>@qa-+R34eq2i5$6#hBVe9Z^5xDwX*zmbj`f#uc@{y5mfO;`3~!eBa@o=(
zsal`q0;aE5>!mzk=BGK2ny94XVxymQdWn#SDSV2>6-AwH+K@ZzO*(Q7&R=WfVvk7~
z&By(Deo}E|&8*0ApGcfwNBdeOb?yL<&jWYIQl1l&Iuoe%G_JG7X}Q5#XBHk7i_gm3
z80050H#)^9|B+Mk2NKJIOQz}#P^*6IWB9+YgGC5@yi&Uf-x7S)_&AuYz?Xw>621ZW
zM&R>*pQH7k)j{|8`J}V|^E)(td+9f`zWFavef|ocZ_Z9S8(IG+^+S9;V^tPo)|{uX
zW97m(*Oi^BuY8hf6MT)SPr3K0KH_KSg{<5CGY#=c#GOqsrp8zm?K_9MQ&su#iBhAt
zFZ(RIWsw{gpG4*&BCF1nF?G(yDpyx>t&VrHwjLgpTMUlcT2`mCLtGxI^K-tq&)vo)
z<>kDrYE@j>ubWU`+f;}95V%AQpLNx<nz3$IgT`fJoB%|-Qo9QNn>}e0#*Q5x?vHEE
zE-<&8sr1UmUt~fnO}&(ftO@i_{AE5#u)e@wln2m~F>Rq~DL|Sw9jL!DZ304F13tbf
zGC-k^fl!b^b72t`0T5ry(57R7P(VSe5z{SVdIu276HFffLe~iB2oQQcKp7aXYxi1!
zw0jQ<?M0wLif;(Y%MgV|0&!k0%_;!8M4?8Yp$gpvG)$p=K$j}?HqdZ|rlTV=LZNGb
zbbRjy%2Bj;fpQi46lkPE-vNzMXb_56o<ey*ny(N@n>LGStC;>0Xt1&oMA6iI-GOv`
zGX&)bng%pl*|<Syw*rk(v|j*0a7arY#~-U`9|4V1=v;JVwaZyR+Lb9l`O35$NXO`Q
z;d>KkyfXbtXkMaaO;EH+K-#?;Ano2ppaNxjGtfkZeg~xaUIv<^Xzv0|R_Gg`DGHs{
z5si{U{eh+_G#W_TEfv%Rq@{K}kPgew#PnsL0m|+_h1My_r}Y8S?p*?;U6}@SnX*w1
zq~mcl(1nWjte~$2;dq`gEe6v0kMAyN8`F>{S<=$1cY(AYNN7yjFlF-aSEmtEMI%ZK
z4#9Lc{-T8gx*c{kx)C`{qaA_{3wj&rt4*2G8hs|{J3)!?UYm{)G+od;kd-#2)HDhr
zz8ZBEG+NMfK??*;M<le31%j>?v{}&2g7|{1w(&K3%No_8cdF4!bU-y~7IYsvlA89I
zpsQ1TS~l8WZJH}+lAyVQek3Rn9Vu<2LD0Q|dZ2%$O+OUG*QPaXhM>O*IwmL`{TR(R
zNYE@nC4$xoYC{)I+en6@QIViK1idKeN_6BjA76~t=p#Xi=uK$aS%Ufs8YJjdLGK6}
zfcKKL-N9iW<@fecnV<$ij|pl#&*!^WP$=D}4HQ(~$EPh9v_a4tg5DAIiJ+-{eY^F7
zt`XEK=ng>-3pym|Ye8B4eD{tE>UX|RyF}0!L6-@-LeN1$?+Riwq9ysa3w`vhp!YI-
z+Bh_kns2wD=LEej=xQ{Un(yy|jtT0322`8g1f=Vip9;Di2*ryvjqp7s=p`{dB<Pr+
zE@+Uod#Qr>BB^#S45a<d6jTbNZBz*2OQRtbg7rY!#&$u^i0MZ_+U_TUJ{Qw(fwbMT
zQPpZR4k)BtE)q0bOcx7nxuEL=T@Qp}2)S$*+Vem<1TPBuvzWdKr2XaFpBnvJP#BGZ
z4okM6JV9kZ+T|sJs>PHqeroqN3c5+qE5i2=LEi#t_f86O(eUUHBm-&p&KA^P&`9AM
zE3~OXn=gp3dusQt60}*+ZGwI+i0^!Ae;*OrK0(I?bsXZm+*44dpaMbVf;I@cQ_vHF
z{sp9^@s*%&1i9!M>QHq8(lI($P#++j5BT1uHXS9jVxe6wv@3<S0!aINm7p8MbgR&|
z33^yeYmxV~UHaZx<wR7)hE^c7DMG6gTBFb&657K;`%-8pgx25o{m1~){w@+)nb6p4
zL3aS9;)f8WqwW5{i<KC)G)AxsM}C=cZ&ASmy!ppr?OZV@h<}HQF1utr<rn`36}m`2
z$U`eXGWG(Bhr{L5f7=Wx2-USYWqaT>rrm}@3AlD8+&Mi^_ZyxLiifXGF$LTI{%Ex5
za>1P|DAv<{`wazMV({$4-_!j%WO(R+YhQ(+pU%@}c+fEePZ)nskN$r^<qwGfo-GQW
z`X^|d{=cYu`}nAe>wo+{>?RwsvP(!bXoS@S1r0&~C6TCk+7KQBn=DCqFkm1FBtjCC
zU7j=$Orp8D4aHW}wpz8dt!-&bt!?qCMxX?$wTM_zP@_e?YqZ6O;$zM4ea_6?1hC)l
z@B4ZE{`mfA<K8)Q=FFKhXU?2CGxyFpjC1!{6%D^vidw9zqs}D3X|F6vKZ27>@JLb{
zf@I;*hrc1nTs-!k1|iMtl|3Nnv;%Sj)Brz{@_qD(P9K7hXKw!!rS_c#p+2+!37p7T
zkk8M8#0yj|C?3b21)){2{ZBm7&c6LmJYIhmghD&^Kk>NjEXadrL3W=7`RiGbx6Xpl
zPQU$6JbGwg$$tWJ@mY|}vmmtYvHyuu)HC)!0lE1s$em|FcAW*;dluxCvmhUy1#!{P
zm;XfV7n}u|dKP5%S&-|`f~-9Y(smZ)duKstW7YmA`1#9OkmF}T{&f~4hRl`xC+H-d
z1-a}rNFh>J{9kc5=l>mC*jF#g0I_^2!G;dolCwcW`*Akpti$(bW}LAT_YK){8_v!d
zwg+c}u%UqS{TxG$UKc6QPKV)(3XSx^^e7U(AI!T1HX%mm?Fkz~*?0$KLDRHop(to-
z6a+f_Sq=UYzg<-97U1(eRk%GfipskIcp;p_nL)aSRmN9K;R@h2pR?)M#PM~HZ^9i0
zCeHA!YkbQiKv%GeL%al}H;#)aPHY2*#bg6``OyZ;jy^-;6!JX-B;%(oem?LWExwXI
z__a`e^~Q#BUG#aAXf<?d8LbimqJV8nG>htzA7nT^gO7vr$H<{%c%6fy=5`Iy9+`3)
zsJQCJnt4?#@SU^ah=>-`g{S;tkqxJdBA|$NRM-Yb>1Lcp0pB#iS9HPs5Zi<aFkl>i
zwh3_TS$w(mG!V|cpGJ{2?DQ^^LO7lO;oTO-2V`ubRDC{uep2-Q5MMH|j)U$ts(|o&
z>ZgM!HclI2XJDR@JVOtn13tH*8k&u7t+yyO=)$49S$#hHcGelVnf04)XU&?CIrS<Z
z{TsTSbt+!r`8M0`vu|fTIR}wi7<BI>;b^>zA0Kdsd&Sc1pY@YNc>lxOS#vSNOfNoz
zB=|V<c2>HnG+ct~YjOmCkI;-ucxT+sx)bhV_OGyVs1bPlU&1@%cGe@nvmQsBRO0b5
z4Z=I)cGlW}qC82iF~9yKJUg!UjN4gvqa7EIQI!#A;+=6j>lK&{U%gOO63@i@hTB=`
z^y^rO2i8P;&$yj+7u@~{z&q_9wd0K2SuX<Y=w)Z)4fmpnMk4+`r-j+@e<)kliQ8Gr
zgQ1H}SLeaaDdr+~#z9=icna5?uFIJ@b+cwn&28W7&T?&uEL~Q)ce}th{vI^;hF0<I
zaCD1d9BxXR83W`PGe7x^bov?TDW|7(<0ET5&cx%EGd!*3rxZM`q$j=y^Ioo4UV3TY
zc9~-Q%_uvOaTvrVn#pF9yYtwV_<^z8=XM_3d~y4JxA8e{6g6Wk1j6XnLhEsAI&Kv;
z4)Jxdc*-~|pXFtzPa?K9bem=h?kC-k8gSz(ijS$N2$T#S#vN5gACl)U@Z7(5>pup8
zkLxInqfAneF$-O0aX;$*ooeku6L6*DakCJ2)Dg`3p@96wEW|yX3`u85=+^^(h~7RM
zq+4K%-RAl2U+N)$x0>A$a<5CyzB81+t|a^J_2>7o&ahj)v~q9ud7*!1=Y-<2M}^+W
z=mo%>ote>#J4gQ^@OEi{oyyhJaNof1YPaLg+Ap>6lLLR2^2}}u{U)P#pl|z-d~s8+
z*LX2ty@{*9a95x!V7-hdy2h(FG{PKhc+H^02sq5juMR>V?AvRNy~f{gf!(y8aDO0B
zUTXbVmKhAE8y^`*tshf=hFul)pWx23a@_pY8nm`Bjt?>v5)56UyyowJrT?|c{(-+l
z<-xblri1?9xrWJsKo8wMXXQq@nv9!DFTs^`pB|;#S&LmIf%+?g)<q&eO8pPizrY%J
zt+ceF+|r`O=k}Bx4FpQdjj|)w`*c&<K3qq81T;r{T6wg+?6~qN?zBB>y~%gUxytK5
zMhi;Ng4Ce(6r)F5P`jOPesdY08%Il_#IMtZW<z(DV!V_YFVJ|S)|krUy@jw=6Tyh_
zAwQe>UTf3vWTF*6Jeh1=kEEHOBJr&c=(4<gA9^Mh)!h#nLkBQUjZ^mRt59>k&)Dzk
z_O^e~5FTyjWM&+uJB;0?!l2Lx?O%)wIlFVzgL~V1aSfj9VB~Gw(Z;tk+x?qJSIf4#
z%5ej(=_#@PjC>jm`=Q^X(dKgNcYq8H2Hb-ip^H5$tRDzWaCp?nchqj3t10ThUx)ZJ
z-iE$8GLGRMN#I-#)`}d&R(W_XlsIAFJU|vn$W&Z=2vg%ir4i#<+{as58Vp!jb`7`+
znJ=;Z^yo!<4cz8S`bkYYIB>*xmL7gR@GROx`VA%Nu5_1JuZa%o=nb9QaV(UOy<&^+
zkri!UuGliB>kt#@dghT8u2(`I_9P}F-F4{T-bYr-2U|WoUiN}5+`dRE5_Hp8IUGv#
z{HZq>grat#TS%vfAv2hXtP7A;f*VkA@2lHP4qCOtFgkj}FYQ{v$gD3cAG8(xTHAn^
zT@|{3ty%VpkQ=Oe?ziuKJ+uTvz3s~?&z+}1&a`jkLAp{F*Em;tPvz)pI31l8b1ENC
z=Ygkkt4_!Sy>W3*&1a-dxHDQlZ8vl5M?u!WjmTl#9Zh(V$tXE+&S|&t+4|$7(QE9*
zU4zy}G{VSE!%(%BL7SIA7K>5s3a%FSCZ4GO3RnM@(nZF&WOP58UV&of&A1JCK5l94
zE=z9TmmK%^t?!WiEjO3amCQkF8r|yZKVgsd;r5I!Zl>$J$$*V9$Dp~R&GYf!b57+s
z)X+J7ITRFCAUnwWRIWn}e_$+1F&8^t7|_R<BPKp;27KzV_P5lySB-!VXzQw)>*(!l
zAHFEEqNdrmHr&GZjjyN)t*@zR@LiYT!vQtlb>pj*P-7!*ByZU03zp3D+2vXkRAi4&
zX+P5ileknGRtR(PVWaptPsg9gV&x?pd)nXny8R2y({T=_G1w;D%V?AxYP<S6Psh1{
zykMEdxYYTCX*`4iG-Vz1Y@=8uE}6#gxo0OH2jW>@^JbRyw>F!O??M(In?=blL}nJB
z2uJ90>ZZi3gSZI$<DYu&_8;?n=b6mnV_{sKeZ<U3GxE~p{D6wgn{ql&g)iCq*aIL-
zZwPNbAGe6pbv;IL^cL}laGxaI?r!%7uKzZRkC?YonH+<EjNCNy)`yYq2@HZO&$doH
zo5jzyZ5*qF@3sq2i_Gs(3k>(I0HQE~A}!D&h|xxS0I(stkun-kxHA1vPQV%iR!}$D
z;lLm&-TDQ+s<FNpMQ1W2o^6+qO7e5$0z9ITJq5}Lv-LS+D=}F5OurT|w-OVuXa{kv
zDaw-hyOltZB2gr`nuM`>dMu9r8~y{<gM9rduIfE7aOZG)hw%p^8up&bhpH_w&xJk6
zGUq$!V)i$`Ztqv)4!}?b%t8mo=nEF+C949I+U7b`L#IZFF)90_kNjmwna3&QLG#b(
zQfs`Zd*DG~?=V?oV7Y3|eC^?!a7z1uoKyM9YORs4g%at~_{y)?>i>(bHzh08lb=|E
z8PS?gEz3`&rqbo-Umc7*2NY>go~D}1G7j1v0B){_UW}wk;6QXfN3A6#_3l#ZyW(b4
z;~6L(JR%1s6C)S@ci;l<LI-sAnSLF@T|+G3ZhP`J3^i14E_1-6`z5@w;uA)n@zH=2
zgWSwCNAyg8jp|oFRi6iikr+O>?Yuu=T}}jWDSd1{$P(kT99c^oTMk0Qhd6_jN-R}y
zlyNXJ8_gW@f7st}V@3+&4s{or6i)?(leZm>DXOsK?X1RLH0G`DLT6XLv$WKV0slKO
z91R^F-;%{hJr7sS$allt<K%C^u#xXI3lllnM!1lEVKOK0;M`=hFolyVI5(xc(9xCe
zFbjPQtOTb<zRxU7=j1Xjl5Q4G;p74&`|_s)2S`)83uC(SW4a4tyYgfE@-qp#Ki{S7
z&yNGr1fb$4o1lI9IpU{)eptn#?X~SU{9)M8&cmXAg)nG*V<Lr@91PYMlvumOovb7k
zSn<%`AEUrMI_>Wt|HPb=h}rz200c_*tn367yQIR}j1p~glT}Co)uK>eKHK8*ax#Z=
zh;&K7;>&*Fisu95UIvX?j;nlmeLz6B*-X><@<rt(bb?aBsDX^>Uhfm;rc5|`6UBUH
z<Yx}`<M8pw{heapMqlj4UG(v$zaPk~#o(m0wB8%AUie7(Jbqdcybfvf<+w<SG?i+k
za(NB|zwU|(Q|oc$kj*H!?v;fwjrDh)GMe0;j{B$#=A-k?O<1*TzBA)kpZ^3A8YryY
z4qcu%4j1^k(8L>1c7MUx5sFbT*3n%s&ec^g)`j0V{Kk>I{3oz9!_C|$XhJVLk>&Ml
z%SR8IiQ~YuQFa_R)Ca7qW%C_lsauYR?lb44pfB!f-;>hbn?iS`yD-wLg%cIIg*1R}
zi2lci+*&D?$N;ENe-G&cy!q&OhxJ*G>67#!=J6?LN^NKFX3srEJ&A2SjzCXhC&9oC
z>MFGiL77)ld(4<xBevF<rPa1yt8D&VR2C$Mu~H6;P{3R`)@2lob1Ys&{SmMV07Kek
z7L3JEL;vH3?I{B0?k*TRrmJAw804h@Ck5$bq?3{Ml0_&ON1i~e8A!=90x7uLdg0ha
zLG^1$0ojSb#CQ`_zkrJkm=FA<kycU9#0b1J;7vg3bmUJ!Zx{>5rRTKoO-GNQ9?#P;
zGyNw#-_C$YN%Mq|q8`CY@!36JU4w6Yi!$6_fj`V03Xd@nj5@NsTU<-YJ%N0UN-rkc
zn>>oLXlZ5S+LKYkHRMl}lSA6)r#)K5taO?A@R!lroSe?yEi=q~a<k)+n(6;!vu^l5
z=?Q;=Wd~LdAN~ts&d<ctc_3^0Kf#sYIcNv3C;Xob?34XZ?z7+3Q}$J#|0}A)vZ$b+
zrVU!(ye;e}na;sbz&y`f4zscOvW!#gf6)A-7oz`Aa4{B=rO;q&JqVzptQlMSfen<P
zRSl5Q>H<`b!$>J0wcG7cd8WK7U2y1{Pv!g6@O3n|h38XEb6q9Yt283=-MEwe5S~z{
zx6~@f(;{<jW{LIHKT%I5)x*=<2S`%EU`na=COz-NG@Y!59w8v^VYi+Wz<~#Ce~70`
zbj*<ax&3Jn5$5>%0<$$SU{)qu-xUQrdp#X@QOA_IjV4!@*Vq6vG6n1mg8!-JXmhT^
zC`vX0iO@`=$cJj7Ot@`c4B}x9uB;!Cnq!dj*q#au<(~4C(g5(S7%{a0{nRY@_2-`|
z)YZ`M%yO*1im?8|>V4oRViq?mhQW@C>dLL3qB^+f)(@lA4%{yA(ZB8QvpemlHO?3)
zQwmDajqVs4_1BbIUvL>8)?TcySTUXEFW9S5Q(>3mIbb)`R5kl99>4J7t9>mS8$wkZ
zeE9etKGrMsEvip6A<uHRZ5fSsK?3EgI}&j0-kSLVCNM`DDI%8SO8xcbxS+L8@L=qv
zaVICMM=v3qjAP(90*)yJq111o#cYv{jjZR9WyZj3{Kxy;`$m4+z~jWo8U33={R^k6
zHL>%U>GgD&pbZahroK6;b1<BPu7~50HB^0juU67CUFmV$#=c~}8&ez1ZmXyT#v667
z!enN&IMAKFrf$x4_e{^pG4!74zwM)Q0!m+@L;UcpQ&Lh<YF&%s27D>M*N72AMYdMV
z$<Xu^*$go!dpZ|E)2NAM$m=D`mXc-_;Wy(L%17oQS1Q&}dtpvwYoX0bz&bd<k^#e0
z_bYb_V#Xq`iF@Z0NO4JhNq3=%pIB?eyaH>&jwQuM01jG5qVR!tPScOax0BxkB}?up
z{scmXAp=0MR-z%G0&Nl<Y4i6D_~a5>(+I!plY_XYeuoGPu>CCi27HRASvuht1OMRZ
z_#7|5N|buLTgxsFRc7B3%E~Sa#b)#hU)lc&E#>pD{Qn!ohqc;1F9L9fLvMmzM5OfH
z#Q(sHqLn2jK`h=%t&aDk5bfHS7R~=bbBQZxbx=Ran8EVW1r@UkmMi?DESOzz`uedv
zSPC;=y859cygy=H4#Iz;8c`Z?5)YOJ#z`{aqW(Z&^-jjqZ3aTGm6xx6gkk@R*i6Yt
z3KibJ)HsRa4UN8*@XFObF>NVTYgg2*3O9yZB*51|uM*%hn+m=sq||O-Ti1fGfcqM2
zeYoKQJ9X8*s#Ul#c@?%EX}TNVay5Rg;QtRL<P#5kyMN_;ve5AFg2{Nc)bJk)ScPD8
znOS^jx#52_SYpjUlGYRcqh|Qfq9yS8#uKFM5M*HZ_qA;rt9UwhVGtn(fNsn<WmN9&
z%T0rb2mAa_LRLzjzgPSmpdaH?v+_XaF~pNRoyQ?dvv@buqT>a64DasqGm^Q^VT6x#
zp7L}o0-W3z&$jt^YTxhZ^B-q2;r@YfwCb(whg0BrS~V*Bv9!!JijQack9&H2M9<$3
zJ`ukT2F>~N;9A^haUU3aP5)60v5VkXLbqtzpisYAc9fkuzraEV-`}%b?Zg!JTsX;W
z1uZYg7_GhLtYoA3NvzvxWw{x#eb2UsVLpuT30m0f8#vFNzx*fivlcl#+h~-v_a!2B
zOD6H{ccmtTUpK=i%+>?5dK^D6%Uwq60o0PU%xx}6?s42|wtCHg+gN~F=Ak-I2OWum
z?K755ped(2C!woQ^>kd$oFDN#t?^R-xaZq+poSvgSYbbF6!$_ZkWen<BW3fg6R^o-
zcF|xACHUiyk_a|3`2!I8oxSaYpu8SqUG!DwY?MGpnTyF2h&PLmQkNy5%>de6R(Zgj
z?d!x^ayRvDM;eNBppUNuR(tCKHI%(O6DP9qsDz!nC-UQ?il@WE=1ytpV0hnP_~>Bx
z(ZK5U$Qlgqvi|fAiOGj({a`LM%iG@CtC({qgyN0o+xIITV>A(lwe>$5u)YJ_<!1P3
zxz&XybktHTa7wJ19G&p?<%+dLE;%Zf60Fj@U*FM}?<P$`xqanUfNMh~2heglz|WS&
z_K3vzHe*OmKSdc^Rn8Zspi7IOh-UZ*>tYOK9ciRsGGJu{LtmhS2)u~Et^MtN>8EBT
zIXoQ?5Vdf>i75D|`R#p+3_P^<8{u9QiCj*|#gCG(o9WU2C|1H{hXOs0rC8CUiRuBG
zH12%cHZ2`<ffjiia}M`!CDcL}BZTTc4me4y^$=#~!BTUU%gjma&RNWXU970*F&!T!
zy~r;>XM6jzgAtSJUGJlzIEoZxzJt{LWvGVHO6uOaZ(u}z)-ou$3AID;-;6OGM+25(
z^Avv5#4b(i2?};0_RyDJ$n85$@_=%pm42`#_3TZ|TxNKe`9m7xFcKY;Y2@7O81!^h
zl2-EwT|FNfV%>kjZggiJXL;cwnDKCVF)%5hQF+{~JV7)DNW{e_W|@oUnI$fBw!^4=
zk{a<M;NXSFtnu=|sO@m+#CZJ!a)!q1m3B=$UNKhTWso_*h<!ypMB_DpmFJV+I6CQA
z7zdQ0axcEs{yEh7xaZzpjC&Tk(UNVBDT;eFZjUhv;|T3gBCmbH1E*uF>@CvHW&~h)
z&hd1FNm^xCgD`eq-UPC=`}5T5$U`UyzILgRYgnR3Nb2E!G!a@LHR=_@fz_)#(!NJ%
zrH;r>WDmgYH@gNydoYM#rdF4dh_nA8YYqPrb_Z)6qcF|X+xNomlXxTdvQ?l8WKZ5q
z)JMZB*meRPnQ<_q7fND0Z@g;su|DRx&FiNi<`lZnEZ%37?F<A;g4W;P;#$nIoiw^`
zg9v6}k1^}&Er-B=gts_ak7ADbBk2ZQ1+6XfVo&GK$;Wx$4ZC6O5Ck%MBgG`L&#znO
ze2iYr%IHOWwzc=vGd?m%JNCTz){Fgdv(n-!CPelTEx%h%P=+5ytQRFPRq^x_c?kK&
z8^()R+nANRO~;hBn-i7rh*LS5=IJDT!k*<|_>grq79J1{O@(`T9pDz5FcfuzHnw_C
z&GM<9&JR%ne&nf~WF%goM5|W>a9&3nKK@D2df`n>y408hcrg9D2b&y&;U@>fUb2Lb
z0!EgQ0uj3hbKDudS!K|;<)RU0j?XM|=g#!+Hj3Qg4<Uv^AsaEsF#+buac&gv6hpn#
zsuCp0zb)PwS%N`MgFTxDJLU;=XeAHLUwk$=SX!}qku=Gdqtqhe@?tLT<$cn~%cMN$
zil#(sgn&m<ppyhzpJIL5Pt1EGUqM;g(UGBXqT68Z1FJhE;lqsNi+Df^^aHE6$&ANj
z=~J`=5#Bwxj>Hlqq1-QWXjbra@b+PAZ~GQ66y*r1<t(?6pB*`f$J*`qy11_jud6pU
z<36xzU#QVX?i0P?Oow;KSyG1kR8e2b#_)~5;<A<r6BXM{v*9R-3}yTJ=EjCq_J##{
zWzDN_DRo1rg{rcVZ6a95w}e;R6s~Emt7-8yH8-xVTY-y*swq~HU*yl9>%)tw@}mQw
z-Bi^K=MP`4{C|OK#|P4%AVWf7urM||LX&FEJk7lJVMjQ%{eYv^$kX6!H-x6G8<*YY
z>4*T;bGrj2uw7l5acpQ=wLSYhG23}=zZFQ?qhQMOGI^2rsyW{c8{4+|T*!MOY#eq>
zO3E>X#Jxf4OA#81X&%ZdbccRj+dfD04g9QjySc>OHWM^0ve$DFtaM?63A>{0&m^|*
zO+;j-)YwyQd=_N(tz}}J9k~%IA?Dxg98bq4q_P)zI)nH%^Aa<TwPjxF>6nF7ptOBY
zB8r#7?i{v!D9v=h%21PlPAqqv2mI2~)dfCU<(9oJG*lzfcZOWq_jo!#AsxztmF-8%
zv6?=PDc)(i5K1>=%_ZQ~WmKLpi(KZC<QE3a*@@k=7uPFW-=tkL5(PGx2E+Z(Q-l{z
zy+-7HkOpFewDI&1HNOb7`D8d|qC1}vB{47%HAHz7uScavuoqrGuEKisbPA!wB2ULP
zAhKV(o|_n<MK;2YBic46qH!wGCkNNl`7HP$@8L20?$_>O?EQsF>i$B!3tUKRnAw<=
zaX2N<s63hhhy4T);q)CJ7y&&M7-=wqk2m?yun$c~W_zF8nht?sRh@^0F#0;n-@oN0
zv+^iSwNJx<fVL{w`YoB0IWFqkXA)tT&Ig-lT`;&h8RROg<Hv~(EhL~<k;i}yfdy9|
z8b_H=BXh8jOe@&PI2H*YiP}&;0PzG@Ta5KRBC(9H@*!Je8RFcBA|nX3>_lmB^-e|#
z5mKR-;%x@gau7o0kw9>D7b64-VLnmGMR{YsH}W9$KcWbH8etHNz}SE_30QVVdOAu#
zBjX@C5z<y7xxn8}M+R$J=rwvDeV^1<M+TtLhYP1x)%Yf?t=dqxHoVqXO}E1N##c|o
z{!TBQSD=_5ZCa6Uy~aG(oSS3bN&!aoz%>^9tSyZOCyfug3zN7by8NG_6BQhr_ysW@
zV+M1~E-Eqc1+(01@FT*4&f505nyYPdk`hXx-Kq8i8tqCw?6Q}|a%Zcp^;3M?htz_w
z2Ht>dQSIuJsqp8l%ws$_fXWUr$19`fAELWcm2`fALP)f)oZNYA!#r{rzXg`sHfO10
zdP%eU4?|ztd#98JOJFGaUnROJ!SV|0B|Op!Xc<Qe%TDw-+S@iH)P%0Iz3<(ZfDnRl
zZb_^k!SxXcU>aqKMlqZbw?vGXpu}(tE;nAP#NHk6Genw^QM=u!Oypdw-UtC^D~eD8
z1bN<O>-%(+%N`0GiIQdj(J0zuxSP50bkMQDZaw30*PeFE+p|e+|5RO&o$0wvY_+;@
zkftJl1@u*5#4JnfgfHTS7qa!OL6kER(<%b>Ipx;TS6Hbyo(J`YnK>V!@$QnOwl8AW
zdvIQ?($)1sURN;5D8NxH-X8g1AlMQU_L3+2!L-hAk^Cm&+i>Im|MU0A1n3U_i05}M
z6~DdsrN5^C@&}2R2gpT4Xu8z;6W+~j-{&^=_xSq*kSWX<_Awp?bP3{rW)MNAMC=xO
zg8@XspoYJORm1R(P<&I!kIzC;$)zszV*^T3XfJ>e$i+tm?i?}`Ev}xY4&i}4x*m=K
zVpA^Y-S5Bmn*E$CGW-vjrS6{2L>LXj|1j+wjM&eqLWWauV}}p9J!L1#jh<>el^UHl
z;3r^orr;-N{WBT$7bhBGZYuNk`0u5o8-7<{e<zjSVv+ksEqD~a>~Dt?5tJz}p|<kI
z&IM$UTj{t_MLEmKP5Ujf)Momn(?<T6!Azg&Pi#MlvvRIL1w4O9?rYS~<`4ThkOIk&
z_iOflH8{9*5rlFM%E5$2t^^^W&wR=RJ5$(PYy}<b2`1r<j0VQAAeQZL!Jk@4;kVM<
z*+Kt=i8$P`(btGe$9yYl$YZPat*;BMhMQCc^UB}(o&@)475pPb^q25|w!Tk`N29X<
zQo|7-1f*UxdNPqPI&<(}IhJJ@iK0MQuXNPLU@U7qlEnbc?lN9p=QV#%1u?29%!ge#
zdqnkPG}Uf@8}Fa>;%^U9|EGURSN)%tIkS#kcz5(n*#9ccpEkf-oP?8u-?r)a#qJ^f
z_5PPX!nMo&?|upQq6~a25`Qck{0`?Q33Uul|4*O)r!sdzUibi(as&QOro+Zh#urra
z`#<I5%yI#2kvl+d7yb_6kJ4s-8XU2%E=UoB%Vb3~pCUy>Tst@cV<Q^_;}NX0VBBeV
z361*$@D-j6?jt?!4)T0}^TWd@130Bv1!63jJ&eSYhUfNTKrnG|!6Eb^B^KD`%@fR<
z0_xY1u|OB&#|);^SUBJ&wx^g&e9!bd)T3sTD?<CU@Za;(&EOQX$=j1y+Lo#GB>vsg
zc`sgT#36ymQDB%YX^}(poA0Hz{+?Qi*a$+)JF@XuZgi&O$9nrPz;kJ`H##YLVf4_c
z3iz)@=I`mL=c$GGudt^6ewfl71ckVGNMnEc#AtZ4orJW-=-fahII-V<Pl4fo0Cdf#
zsG`n6&$c&QnB)ETm`@P{#(in@-%i>R?CT^5N!h%Q_>9mJ$Bc!c2J1m9mw4<UL~{qp
z7AJK}N{#*2D~KM#Z81B^E{Lpvxxn4tmkdk#emqEUlgM#j612X2fv}UygVu+5GJB}X
z_GdI|IX??XRu6IO*)|Eh3JJh@>TIG4&NFrp50TaQ59Hs1jW16}EQws0w@e(FQO=0t
zndd^Ol5qxv_EamZ^;|Qx!8})VfSH>KMKf5cS$jO+PKpD)l5ArKb%xGhqa<5Mec~Y_
zH`C-CQDsSKdBDm?L(z!#r>J98&$jEq(W!i`&C^LAWThk7t`bq+<SxgYY5nUEIJl1r
zaL0289rJAa9*SmQhpdl#h5Ezbz8c6tdxgOEx^soN+Bs*O=i9+p)WSNI#q4^v<r1Wj
zwzo}pa*35-M;}9@*=_A+N(ldOE!aeSNHErh&kl#~K~NPeKgBX~B!kzzM+BFBk&Prb
z(b=rdI4YS|Q9q{K@=<g0aaz**g4O;RWUvL{=z!V7I=?hASU-sUZ|qs|sFw3c<npfo
z-~ld_j`m5LuwQp3o(?=(f9+r`<7un3Uah|(VEr7ZaBA44X>o}$4)r?hr4E64q3Qz_
zCDv9V$;GkR!2}TSt)CFERx^QQa|dAtORYs`)_psIM{@rH{!c%e#BynI;Rw);q8f6k
zj?3YQ6S)|XrO1#@)qTV>HjUfRm2j<CPvKn!UXrqq7A`W5qE|szx7JhC(e}COxor=o
zU@@Y)^OCT0&_Q2gE$Yfk;z`#G-I^?#S8jy+A-5|^tb3nl64I!0P1a`^pi9iBh>42w
zK>Y$?h03ia!X0K|BlmxCcHt*bm=4AEN46q&yVQ8>Dq=&|a}@a0;clD=W%@k8>XiyG
zv&gO{?#ya3L5PhZcV#d!<6yby4{I}N5OHK{$2k%;m}s&PGY$qN>c?kx(pw0JiSzJ6
z;aZZ-rHLh$`Pae07ybzr+y99$tyYc$+#3KQ&0t-?p>gA6z4DATuC!<Rlo!4(uWydz
zK~na9l`ty1IQR}j^A0+o{pJbSrSLoLzM(zVgi=d|uV+g`$^jEfMg8dd@sX2oM%n*^
z`oJG&`zc)V%kj=Rn34K}*ecIafuNOujKzXS*q4e(AxL2S!*68mGuT*TS}}i5CKNBy
zm@`>9p_4D;r6kboDLZa-l65H+6=DPbDda?FMu@osbK5bjZ0B^9Bnc<a4Be58&cXXE
zY)n>@&Vpm6BUQJ)$l5`3fgfj5edf({z~_9ycK6(*w$EeNyRiWLOK#U(EYQ9S4W+??
z(GjFUm`x0@fs*6F_&i|jm4v}3wWYq$x)Su;_a#a*!@fZvSYCe({N-mU2b(XUwCKpl
zj$Kd3_PL_2Jvm*uNd{UW*N^?ex<vLsk;#4%H!w0-y&QsJ7Gk9LMM(8nBf9+W3LTU7
zWj5ECf}S&fPlaLcTyX81;S!J*3HxI7)#sI1V}UA7%zm2&%vr#4G7ULe>z9;RpZo=w
zTvT+?q9y3JHvmMZ2%C;Qw_l-WqK%~CUxW4eHw=ID`@8jOpuAqKs9#uOgpXT0m=fei
zCJn7MgK4Gp8v|A=!+kJ-JY2;PtsktYpHOa9A#aK3=*7YvgV~=4;NoSGej59{erlOO
zGx7Umsd#q40fGwa6b!xDG6B3t4htK0ngLpmW0#__qyumnP8|e*$9d#(oE)abnD7F5
zv>`ZV70}sEsNw#gbr8r9G>+}J_f8Z>x;#*7Ju*b&T?97m@yh-T*0tmZ&WE_{hEmU!
zR^Wu>5(t$H3_B&FouxDxuZYr<3UddjZpT63&$@YvHrXX<+lbjQm59@~3}o^8ugJNf
z|HW5W=QF!Lp$4LmsH@z3Y6_T;GXD|_)r$JWa_hYV)I6yg(8^bl79#{)lJA)n^=5^y
zkhM6|)00L(VVig~nLXsG2+oZ_rcsnlCj0qMh!!>7Y%VG^nu{VAVH$1Qpemk@b;u(t
z%z`h$lDib|S_JB~$ZNE(z{AA6359Mdirhu+us8-IGjfZ10;=$i1g|QbqN2z<)S0Ih
zy&lA}TRk03h#ygHY{hXR<uM8o1|tsWm6-Qgd^JJqSYMO`&&TFgGQD_nfZl*wQffUx
z`NJoz_ei<mt1NN{BR`<}g;cy0r;Kj%h&>(vgco=-g5<D<ji5ztA3J1yY~oOt(#NVn
zPZ_;KK3L>S61m`?2W}7yHI-PGF%fU%m&m3TGS~1-FbSrWT5irwH1=ak#JWe0tNQc`
z>!bam-`UlM`G9Zy20%-Uy^H0r4Oq_ufH{B$@iOrHG#Bwku0tn!Iv$38W*igB87ZYc
z7CnuZe9|H-Bsah3IabQMJo5BsKw~S`zBi>JxcWjYPs^=UpnKZ1d)G&Bgo3LxksHW3
zWzCZH#-5}aGkQgx!$i{$hNAHXyl;RL%9UQ@6*_cy(%Sg1!NIJfIQU<VgPEaof`R(j
zQtOjHQ|syF0y;s47d@qZ+50s(A1&hU*x;+A<FgY?FCvWymm-RrV!Vtg_go6#EC}R_
z_nr3hTTp{r-a*7L8uA-DAL?VCu+NXsxw`_JwLzS3fXu*y(bqO}ODNSWFUm8@i?9t{
zitXP(eL}gl08C<Mm~et=`}HlfUKFQl&pOY&TF@`IE)Wgl)5cfz`FD{TVIANLUD>VE
zX3a^YvD35^?@v~kWxF5|XsYSoRRk0C#y%;Oq4yKbyV&zM9DYXf7ck21DXovg`WVP2
zJ;MpEupZ)~KAc(_xSI~u`X4n5i*k&@qEdR<upUwCTLtm9nGN;<ndAHYNA*%@G0Inq
zT%4>R9nMV;SPAe>F-IStBM&;>Vva1adH^)b9>sF6r}(Imm(HUWh7U_1>mtDdY-8uu
zq>XsBD1SmEnS>0IbTsx23<k`uG;0<X;G`qjkn(~+ePe}nVlU=>71NaAzqho{zmLRL
zUnTdREBgG02+-$0B7UAD>tXFe8MKwWf!@%~B|SKfMdcw9>`Z(YnN*Sgp6;@D>y@su
zR|K!{%y5{~3UM|HdOCaHSOI8KY~ezFE%`i{LM+h{&vTWOTUl(-5mP_X<KJf%-&_9$
zy-F~R33wx!R60m!Q{QZBeOC!P_WR#m0WYn4ep1IlSX31Abp9Rea)0<AMVI6l{+;;2
zA^uXDrnZqv7~zME$_I?rhw<Lp-hnbY)`B2o>qB!Zte<0Wp(Q<K?_yut^gmp$;=s$J
zCHSdd7_ff1hjM*p>rS)y0ch02=IpeR`c<XYcR0g~EvRh<D!};xsGE5$82u6Yqr%eQ
zuF?$C8~zUKpIQ8Hy@r_P5>Za7ZlsyIvY1pQhAePXg_R``B8OmNw)f<sM|XA=Cc!HB
zceb_eRLp|glA(T~+Me960T(M3hV6{R5wX^XO{_KPfK}+c?s6H_$2Q=jU5E0z%9D(F
zx8c>towRlKEyz}2cy4dQGfqGj?;OI4tRdMK7DaxE-!tq-HpP>%`EqlCS&la#duHLC
zj{=-ZpW{PN<${tDED&>9uHMHnkJFxqd^`KoJclxf!&b+!lM30qWag27`+RMCrW!tA
z7U8uL48<I8`-WsCyxY_W{9Do%S6kMO@Xy*er7PhF+c!;7!ar!=<W<5ua5w~RjQ_Zq
zI|1hfgGSktI2dC6yO)J;&}qCU=?H*XjELB6-~{h|ufs0RlR@hlvdTdB9{>;795qf-
z$uEU{$zBnC>k>ur4xbTz?#8mCi8`I;@fy!(<|W{S2Ma&raGd`L9Er{cF={AS@;#c1
zTaUm8xE)XY2Kmv9!&xq|J7uo(4ZL9HLre1!qdy_)4g>~ong^i}2U*~K$>IRog#BFW
za&8F@ot&tTqx1zxQvy~ANyGo76~`C|yZ6?+OF*L{Xq|eRnxBl;;gnmy^)4s9d??7+
zoHo=MWH^eCL+#Mb>4Q_uT>I2U*^^>MFR^~fWqlwu(|^Fzc`a&hZ}lpn#P-b&oGiHl
z>9)<uXlojtqRl!~S_%zlMA^kSu(@b(T^bm(mLqLEvuFug2}b*^1xRD$;Z%!g+jU4&
zVyJDC7$b$+_9+f&pzjhZ>QSKI8qGOAoX)7IuOfg30KLy4n*7P1SOFe~Gpa-k(&O-R
zks6FB{8C^28=y!T(*NcCR?LdnK=5|wBP<Y_Q`D6&2O17IgxZshqsE7pYGK|z87jb1
zDe<geX~<0OLwtx_VYhghM*4RxMVPe<L7=4wG@g2wXoR0MX4rV&$j{dIv!O}RDVxqN
zpT0k6q9#(kcKk;72WeyQ767nE#hW%*nqLS3(;0VcMW41Y2&W;g+<N*c5*iNu{C~A4
zSi7Co2>XHe=Ha^=etfqAzyE*vJ6WJ8KgA#M>y^Jp^YMKS{I&g;Kd~Q(9o)GtW5+%y
z8Qyn$7;1*@9oiMdtIs9YcK}^NJ7YNFi+!!7t_m#AsRZv0mKv{G+r`wwW*AG*6SOdf
zT2=_cK`Q_XbOKt|0~g`zC%6M6^p2Q}um2Br3bC#JUv>)N?40<fox%!hAB?>jws#6E
zz1S(lJ|3b$CH79?RF;A-@<aNiJ--q#`we@3@AV5MER%bFOJSmDFZ3hSz-Ph7a3j4u
zdbdZn7IC(Rw+5djM*N8wyO`fwXc)r~{eh<<U*uwz7>Rt?4&g?w&>L|gbLjgQ(c=+`
z7~kIR(HXs&=Y}q_J>RU4Vf~R{^&URHYt7AC?X;V<_IJJE!*D#|;o#6_sr3*B9=}Rp
zd<G9;H|4mIgBNMLPs{lsPE!D3g*n%YiFCWEVTv$5!>PoXS>and2RAQ_o|qZ9fa3*t
z(YxH6iz6~P8-;<JrEShYS<uf#SUR(WrWZ$Mz#{7`ypg}+RLqrR2FR)MbY4b}o9PoH
zgPzU{3G3!e#nU;OG19Wi(>$HA^nCM#tj!ZVonJz;cByUG?trI_N3$G<3_Klg)8pL4
zDZO;?=O`tXCY$S$GhT0h=W9=A9{?{5ln1e0QTdo;!=5}Nzd$B6<c#+N=CS?7yJg)T
zydi-1w{X(7?en`rH?@6!cW6@E=R2@qnU$Gw3cf><8BESIg2@;$4NnrM$qS5|lWCF@
z8>syD1n@raJWb!kdB<FyHgi#mr(-Lb#wG{8mf~vPpPscWIn<n!b>Nnd8Gop_*^-P`
zf4*bRNi&<_+<3Opi@XS1lpPsJK)lO;1m}0tJlkdg+P>e*r;!8J?@7tY`J)$0k7O+Y
z!q-4BmQOJ%(z$|x`$W8Fj@N9)krKRkusPc}V3a+Vad5zuoAqJq<?X%6ILROW*sPe4
z6>x<I%(CZDcz^8O#)2tl@>up98=juLWW1bqq$e*iP_Ne~<EX(QGu|lMS7M#`BP3G>
z_ZsKq&<Z2ZyWx?Zl-WHgN6lH;M&%K_<Lo~I$ry`pRQWk``2=GTj+-4I0>V`RSp&h)
zJQt3zLmvi>o8i8R&lQ+c5FEhlvn`G!17`_`$sWboX6n|Qto@#C1CTThNt>hFuHF&;
zz$|`l=A5+f+h*~BnR6zDUjt>FfP#OD*QFxo6X`u>lMio$m@1ui<AZL&uHqv-#V1O7
z=1jm}8eR?GhX#7FFBC5uR!I#r^6)l*r)vjv%6J_Vo_WWCptG3^XX{$TPmDrWxBm!_
zS#tp`IQYXlnyKQQ(c&XmWd-n>1&Yx|)-1f{7ssOe`5&k+>4^HNSsD&|?F%IkbGZdZ
zAzs$aEr?u#>iP;<Dtz8dw1%3MhZCW|$#X~YfCK%Bj7R%~W$t+zQc=qIJ2B!VI-L6O
zyYcoqT6EU>7b|NwUL>1n&Y<@%Pi^+e_b<WuXj-Qi1|VST*Psry!;6>i+Lr2Ue*$)r
zcRTRul{^S0uc&fwH0D`p7TlW5FIEkWNB+D>8NGCx*gZ$apO1Ato7*)9@#pU+%NJRP
z@DZQDc^G`~Xh~+)v#lO;Ns;=BF{h{}U!_2VnU_8BSz}3N&veyj&K`P^X{bD!0|T8E
z$ZU;6q>W-6f$Yk?8OruouvDhS#PAQ2sH4>JuF>(j>jKv(H9_@a`#?)m;^VIc2;Z7L
zSJ7Qp$IpzPjqO{<XjON`JCSs%NIK6EdCu9RGqE8UgXBoc6UkT)h~PQ~`k}&cpd_>L
z(K1jP86R&`if6*nr27(uN}Q9VUh1AbnySJTkOc8u0_MG=K`0xs?NO9Zxe1a<)T}6@
zk?o@F#3<2tLQ0a{f*IoWT*(gec3zYnMok`SSbY3B@$PskFy=gUh~e{xFmM^JstPVs
zE&`X6(dY}WfS{;xm%4pSajY{cDqIhYL{t*U$N7ut!?G`yh2yF5qIjw-&djFC;+z;S
zOLF3pE7a@UcExttONV%|K@*1Ki5eyjVUZT(#E{4?8{%4n1TG)qTZ5LQ$3u1K=9)=E
z+!OqY3)PI#l(Q&)F?OIPJC%&l1fMdD8j=~q(WthmLoCeZ@`8zJpf06FRHhGO0z6$g
ztZpQ)x<b}1%Hk?g)D3uMyjq6BS<@viS4SnlQXXpZOi3Q{q;lCq;-$*3kxh`f*GkqX
ziQMakB~dnKcs~x+kUOjf6v`V`0}ADnR7$}tga<_`i1G<l8lvH+=8((^hvyHM+APTn
z4+(tSJt{)fF?(1YJdo!M2jIpSl3EICpEp9P<tX%WvFL89b^ef)F&_6W6-EX2LB&-_
zzI=HXl6uADmgbd{`FoBlm71$3uiZ!|zgi}XFN;o^cEy!f;5-%notVQvil)Y_TwT?y
z=<?g6ivIH|<T&i)JXL!|9R;0oHkIS1D(zKuH8#k!RK?kVOWL$!>L%oAsSalqC6B8M
zCQ#B9b1sNzugP4uv$3hBp^z_^(q5N9uM;m=(`P&t?F|V^BoKe-QtOwXWG7xoXv}Y1
zyB6QM)ZSDdOd$Fx&QQ(TrsXZ6MtmVvdrLwubgr#hv!-!nVHK`otX8ytNcdQ11MWt|
zmpB{ORjpLC6Y3vvE>cS!=WGxko7LWymHC`a1+{DFo1kkH?H%>EjF#qHQ`Hi}w?^wg
z@?Euv8JOT~YOZT+o?o+GW>_*~3V2vmhgu?%W~Q?tpFi-bXzxi-HY#omRjsk%0}`I&
z6c=`B@2h1j#sVjOb5_wlR1Y&NMa~BQhEPodUqGgPB#SL{Rt<xGto{n$WzbR=p~LWv
zQAPViUCP9+cUIvwj&(Ks<<SOE{kJTCgLA{e=BkxIJ*74?YPA#BZ2^+oyh_nNRq4Vg
zEp@eXL!h~lZ#2_BQ@1hV8fTM)G3w_MwaM8edW@l8NNC8pK|u4-ODn4Iby@98^&zIS
z!P!&_p%ajcd?kzA;@n`vhYI~iJ&6&er?#oirn07Lyv)mGzUDG|YKQ9FAizUK2Gzfy
z9zC@SdDOe}Yig=VLlkX*;omw9j=LT;RdZvXLr>j~N`^{sMVdwe(Nph47QRocXu9@q
zY|HDZ_oy*5Flsf2W-!9Ns#9LGMiiYA`he;TXDC{nHkPY?2vyTZVihf3o5@w~1YLq~
zW#`Dsb^#5d#@ov+7=>Pq<ff-S3RD})=%Xb1Zq?afXDnz!i3E)Xs-F6!>a3FYBWg+7
zXI_H!f=W4tf})+PJqJb8Q;z_v94gR&lILlDZrxFkv|-7T+Hv3&;`Ja!J73c32ZZDm
zthq_iE|9=aROgCeH)d)n+D?ojbce?9g>`Fd8pF`Y3nke*H8Ll-S~5f<X{?sZa=Axy
zR%3M1$DYvwsO!ZVSpz-wfM%O7c`d8He>|zI%ejW$H{$=)LF1*3TQ0A2)%##|ffYN1
z6~@q7)xhr<MbW3(L=Tb~)EpR-Atlz~a!@C`9Aro1=-a3I#o7-589~nuJym-O31?Gr
z4PK|JZc+3!?R`u=Fq}%fw5`jB-3L2e4{?6XE|Am1EC({O8}ipQw$v#4I_;cTD(%34
zsHv(}^!3_Q2DqFX_!G;DzCl~Y5H}5H^a;j=qHokTGSKVX5Zs7<(l=>$G9b~pp%7Lw
zh!?#S{bud=3`}-z;7@7mw@9oM45bEG)EgDORf2rri9QXDuN~JkudAsR1vX3m(gaz$
zYqYs>jiPVSUSi4<P(SV&ZEO}5wn_AKCocF~hi?$W6vE)(?X9{N^f|<}Rbotmi0Ot$
zH;MBcwpg*CIFkN@tZ#E4d<q1SM?&Geku*j}lFpB;!GC}{8d(CVB8tRM!;vbH<#9Ra
zPG^Bj;u8cVnd)d32~uPc1=O%5n)RD#7Cj-03cDQNk0Ov%hRQOt$bSORxYa12KcKyf
zXD>agaSstBLH`_(5%gT7kJf1x7Rr*SQ}v`QEt?j!P^T(-l7u;&Yc~X{LaX_^2>Q7a
z>WUeG6^VWx6VX!LF|Y!Po~+YlcUr0!)~Bhdpej_Q=wozY`=KrL-DpKWU;i;9K~v;+
zrS%kjFN2^fxhwHCX>{I&5(Hh5pF$T5jMe|asH7#~HEV`A8>hQq(zR5mNx>RXlTS}&
z5UI!-m|1*^MZZYDj$u;>7TmZNV@_Yrkm&@GV<lBz$FNL{6?_7*acu)Ll_o3ChAOV9
z!6mi&c>NAW%z;XaPmGf#QuIsoCmCLVF8KgLcR4~}+dT(T5=wC&k|U`HMv};e^&@2f
zojSzj*ocI{Cjkw^m+JEKXg*0r<Wts2GAt;6Fq%)oIitLd6k#OlB@)*V63UMRV3bM{
zJDc`IK+oX`ljJAzdBjkIP}a|7NsdE#0M~FaVv-~`L>5`MM6>83Rgpzc$a(}nn#)n$
z7{>Q1k-i)01ltI%<GZYNJ?<!=ql<A{vl{m<is|mS_W<$Iv+8o3!t*FqgNG~zOWYp9
zS?L`K$Ow9N>#?KgzC)N?ac{Nm8ubAbn_bn?np#DV8%2!6hVm?}j~GRAhOer`Wf84v
z?-HU#&*}OT-uYP0!gY(jVyfs*c}01JW;pxJQ$^qFJ;v2IoDB=;qHEl5s_&DiE@xE~
zcEI~4<GF_yFKek<1&w>&`!45sopse4@TGc1|C^+cND#VoKtJRa{3gSjt*KtvSco_0
zX3M-6BzB6E@7m7WNDSiDT1*s&WtPv0uf^A`#jH@B-`IlL?L{y5OKO@D_cBdiHQps?
z@(6l%=;w{vNbPSb55X<alSj>k3qW&M+}}u4wcbubrRRXY)*FvZVT&4MWi)X$*YFI~
z=q=&0n7P1I16?+)H%k~MuRQ*SeRa(S%zEBt#>50xP}j23MqcObVz4*nB4TsBOh!%8
z2Jde;A0|l}fQ{ZiGXxe1<`9z#rakYM41z_PPxqwjw@4hAB7Y;4qgAG1f#AM`*TU9q
z_FlxEG%S#C^7Sp=Y=*%82oF=y+q_i_f&mh@2IyNQgD^j0%Dq(rV0h#@MsJrOSRUKI
zRrC%CEFiWUs>!e7I}`Ly@9(&dBAWb#B{jUyGiaW)Fw@bxk^G;bdGBh1k?%IL9g2=|
zSIYm*0mMzi+~uHNbvbBIxg6Aq!dk7NB9t|fo{&Yu%H^ntB2a%Y0-zhB&>!2-k@SSD
zpW_FGp(!rMwkR5P%}B}u^!HKdzig<Ove~S%Eu;)!l7sDX?12$*Ii8J{x&Sg@S|j<1
z3LyV=#!`_d+CzONu;gTXX*7%aPBb-I*+_|$7ez8pM`GR>Mhh*}cL#o8)bQU?y!IMm
zW~Ahv`o!f}1q{Iv^_{3zn%l<!7;+06FdT5tc+|wW^*?#9fqjUf?|SM_N5>eh0nvLo
zhaAIj3w;h)(VvkJr?YNhP4n6XwY4oZQ20Hvm<wwgSJcntwf`A4vk6(TQE};i_Vz@p
z-5;&Cx~2t=WS?E}e`kC-Sb}wP>Cdu>bXGO5TE~~EDEf0zYK^q8*Z&%&=5ic?FrYW6
z+2x@6U5=0OUpE;foi62897&E*h&A$aqQe(PBI(AOjrmxow<wN_=Ac(#tCChWHf@|+
zvr%zeEFdZ%xNt*pqzXIkNLn3gA^+ErCIGIa+PY?#M#p$3FY?_$P#hEEIpI~#b(3j4
zw++>uM~{h)sYj`53N9#)X`+mhgjbu_MU##stWT>H$8=Hw%r!|(%+Zx1=}u}8Nm0L7
zNnDN^U5-nLmd)*@A`|J=Rdo%DV}hv20X%BC%Rx+N4zY@fb}TJYuvUq#eKak$1>bcD
z`A)+~sJm*qqPaQ1lMtrobJVNAX+jvUe`zDtHPm!R?CE8~w3_v(Q<0ZYN6%jMPQufi
zq6VruA)Kjbqg2w`xIK`SHbvbHoDuZw)-u$8BM~!=I%=vq0^u$6SIl*UH%+emF`MRL
z$*5@4Wt74t#|~i+IrnHjkxH<yAlFJ&9}wd0bh>s}zdR8$S#@1ArXI0wd{GxsBn4xp
zCJ3R_HLSu+s%S6C4At2(4EnO|Ovlj8a@tY-tILRCm$N~Zl@o^cibUiY9ucHBb?tJ(
z^pYRJbBgwsL`k$k;=*?A9}<qq9Zqz3ZFo%;7E6d#NqCCA&VFBaF-@PdK`gvKkQiwK
zAnE;6LMJE*(bf1ubtWVcZ>JNr2eq95u=lV1h@%taEY;9*{>QwuCbJUS*o39_Lo)3|
z$OY>@Mf(W{8b}Ho^4B&g+E2CnCQ@5z^2YT&+Rro!(xC0k0L`abnfipRpOT5%7Oesw
zd=u5TMXTosoT6>jT9}^0xoIJDaI3^{#jK!SXqQR16CW*^kHv(dbx0oJM70E(>(<iH
z(mEw@RE!sE9_=<w*n$M$6xCH%V@;!VNtDq_0>v=P)fHeX9*@b|t?EFO#dcNrU+{|Z
zFt$3>?_5d^q<Daglyu5?qs!S+Ra+C<xO`2`I+De05*|l!9jMvuQpX`Ha^e`)#X&8|
zD`pJwX{h^|dZLmLTuE0nDO!d41@R@5)!N<aF$7tiEu4+%qVdK$bksd^xG2uhiZyH@
zweP7E=3!2&Hwe)8B`DcRF9-|R4<sxds>Y(bR|0aJO^D`jeCR%v;zL^MLMO!mm)ABn
z!=Y5PAIb(U63TPGOfD8t;0M%OFhsS~CC-&qV0Jm%T<t;0==IKO2>r(@IWJo34N3xi
z9753+sTNun&xrzUoWqGXq7g+_G@nBbUeTc!aR5e3RYhGFJ49Vt%w1$nQXL|O>xfxK
z$ux&hDpyQ8>5!dt$D~klyh99ZuQSwmBPqtEj)Q4LB+=Q@RE6{enNEqhm#9tTb)J@*
z#`AJCIU(kCqIS7sBoEYdXB~`@qNPjhDbBjmx>c(~a~h#HJY#E<WY+YU{}A0P9KT`J
z&x~=BDok+*nP<n8Q|>g0oTJ38qx52R6ht$Ep1oR`;|7vbgOFjlL{$(T0cM3vLSy|{
z@501E%o2u$ilQxdv@y$WB|&Jw5_K)e#d9J>%hR**X1}wku(@%qqUGy?Eda=)7Qh1i
ziRh?pR5ZUXmskR4AwY!^1LGEkNYQ3VL*?bLp`y*zzhDYj_q5<5HtYvboOYfx%*oC$
z2Yj)Ts8zIL2_56C=1W-xbiRb1kAVqOg=jwEE|Aa*&^9>MAgyRi)p=-8yq)%GOEoVp
z(1i)6xcBv17ptw}tP3>P)cVORR!UQ$@fyswq}nnG)`b!-mq~{(mK;jaZm<m|2Vb-*
z?Uy`~++r47p^+C!Qw0`#h)rlKB>>ADEC%rTO86;SwN}Z(Nft)4MqA0r6eVGH^*lt*
zz_dCJEr^#%w|0|bDYXcl8+JU-or~tphD6ud${=)Oy{!izMeZk>s@5?jPEFB%rZ30m
zIYhk=%WefJh=6VT&t*4aAE?fT{X(a32u%@Hbyz_8iN9a!=kny~#twr}{+&{fFzRrV
zg`)jRQc83-Hi)o~_UmZx(_WC|?>EuT--HTrJ)ffOl6<8I5&u^IIg7_9OzI=LFsW%V
zTWH+;PFI+d3C=1a09AZcr*)E+nyw_k{>^Tvg}N?R8`11|JDsSt>t6xDHmgGyHcL*K
zosuD%5LPy`1-(szFl$1C>Nd=7@!u4#LRGiRj2KMXbv5`_sn#W%?GoG>k~`r_phUMG
z!|Y-{wZr!}sPV8{@iOVv)@qeVN8=w_gC^r2qSqQVT5QlXAZDSas6x`ZTDwV3*lr~*
ziPBYS9jJ|<=QM4EbJB(A{cbWN@y@-lp5(B_Qqt`_$Vo>G-Kndc<BWPo6m-!>I)(d+
z@y>fC9+}2?$5!2XHjQ4VFzJcT)m1GF86_b}umT)y#s-E2or{e}`Y@29jh3X6g~3g9
z3WF<qKgszw=F6uf1ge@5L)TWQGtr26k@`%#$$88td$QSS_hd5$d5feg;zU}=88u>J
zLoMvQZW0N=?OZ7?4{X6bf*4VfL3n%k5E(5-z~g!e9OcB!xAI1NF5e)*39utAh{!0~
zMhO}1#D~mUYNY0Gl2Evde9I(mj?`|Jup|MS-2jJ7(Qc8@bDdRD%vPtL8HH1cK<KKP
zQYyY#wk{L%P!zaD0<km6z0@YtIlM&*Z%n2OoDCGA({7dNBKW}6_I8<`=UjPX9zL`S
z_eeql&h^dsYMa>9?R4J2CUqesNA8M%-X@`oBy?6|2qW)yN#J@3E$29)*5xeYHr>FS
zt*PPd2d$ftdAF{L?TP@K&Ke-|P947bD|c$|khu4#P6jrD|L;f`cI+C;u^X;^R|2qE
zM*uOO-YJ3Dva^BG-QFQ{9>(rhQxyL$=Z#!FHuP#XG_9f4n|3$%lb(wGycURhq3|^B
zagwLO`*|(%p*<4(JqgC9UCTUdLQC-XC3qk97lSv!IQ+m#Lt9UM4uFN&{8qGkCFBsc
z_OMAUZS8$dnzMO(kD>7WR*^IRL+9^dDfLur@sU4>jW^nyz2A8gvyV-_O|&10iIi_T
z*B+3>vDeqaQ{|5&Lnl<s#4GU`uNsaUYCo2ZeV;ZM>zYHbeWGI?l8l^Gg;Vo0DL;Jw
zH$hx?i5XCR592dlCX2LmXUD~`L2P9vNh>2<!Yici!}7Kua){*|f{fZ^2}K;FMPAK`
zaW+LlV*q7SlOX}Iv>0shH?4+xPn9qimW?fJr|c-MHce*53HNila}F87)DiHJ$#z^R
zts&;Oiq&*|t9F%B_?%v`dYmCSPjogFRjtFqQ_(UdMzXUhT1}QjOQHQ;95hh0tDV9t
z^ohxBrc9<`=bYThwG`9UvLzJ96Xw<NiHU0@@pKRuks$3_34$jok*;I$YpK(nbvBX>
z%5+v$S2xp^j1WzZ^CdQ`+32X|mBQ($R_{d5#M|j9+IJm?0f22Fk=*H!ew6SucE}{Q
zcopqOj^ByNLrIV-TC4UGEs+XnUub{Czz`GIm(ew%a2>yryQJ_rFo7%Df3zR-eD8w8
z#?$ZD5&@kdorXb8xCFMdfxs|N`H8~wR&^m`GMF@ZX)-${<}vDJU8iB9rTX9la|I6R
z%%(Y`K8RELAm{-(amDIF0kE#Bt_GvFghxo?Q(%Uwsu$q%O_)rjUx1DvRU}h;js#sv
zlVfyQJ5oZga^8r*7kjuK37WwtW@eMS>Xjha`W89<Fp)}N7J&A-n$Z$=HG2<=mZ(3&
zEzOoY09ukx0bwl_6N2zJc--3?iUshYhJnwMj#QCwyv9h!Yn~EE*W7EX)V=6aFFmUX
z(xk0cUj{5*q+Ht5`nltwK${e;S5INTM@g>U2=n=jP9Z6WIu3qJGSYiQdK_4DC~@<s
zm+I7uQFa79r)e`|UP3}Fq_Sh|6$`!)&+(pXVnp{locLZmL#~w&1b1rIqqD>ebzO{@
zw{VVW4RxV_=18a)n=UK43vy*?EM8VM;Aj$E;;d+S5}GWuC_hGMk@QmvV#vxusg$@o
zi2Zu?O=6#((=~6*J(oZZwC)`xsURh5OOOyabaV|e93n~CCA2vyMrgA;hA#Wj&WjPN
zS?uph)07+|G!ur0CO9#e$HWK+4wlDWR9q1AD;}lN^rXbBXO3ZdXi~zl4GBQ7i5TH2
z<wo^ka2{``)3q0zt(be*H&V32(x*a{LaYK_lmPSu+Il2ve?!g7Ll^`v*;bc%N5B7F
z+As`l^aqw8IH>ZnQ?Mx<FsWFt@YIAgywJs0onjGy*1^Qs?$|L2^*P~;H7#GmOR3{d
z*-T+@U*kCvThxl4M<1<JoD;jzpwS|M9ZG7R&K_dSg%42<KO=)y%`OK;A#vDFo-g6J
zyURh*B^Mh@I|fhpIrGxPt$m=<2_a`41*QHO4eLNJ7xF^sUlQctGc<~J(vChUV_aH{
zMhEfEuWOl&IlH+z+{8|1EE~l05ix_$SdBwSE{*m8!2(6%T#jS0^j~6r6rThWaaQsz
z0ImYTQGD)e2t0BjMkDezAWv*<(77bBL+f(f$tCFI)lk4z?3feDk#w8}Wq-j~bPh{k
z@h%pPOGX94Ax5C%SZ5;8@eLq+2n10(9iaNgy0}8wkOUxIKn*UzL&_+$Kt;o7Wz9P`
zAV?V((8NyTgE6QY3b%=BDAYNunxRu9lA(>rcR47y>f-e`%KGS;2D6JpG%g1%BjaI!
zVN9A7msZ4a4`-c-qs*3b156+=6m5>2RVe7+$HZyHbO8moXgwWek&L6uaWOz{3ccH5
za6|{!Ae#BA{vdLMF+666Z$vEXxUA42Vp*@rB&Je|ao6CSrda2{E;HOQ5E>3{%A_}j
zE=<w-<y4nARC6tz4)bd7a?o60SrQ9NRT09D=pq*45JcY_s(i?s8?Y-z`zRLZa$JhG
zxE$0Xmjmb1MXZo)*mA5l)?$}oF^986ol9ioPr4FI`S2F4g(=X_UKe5~GO~z93)iqx
z0^*$2jSX<+mdW%8)R>51iVU-e`dnHwM_7cf(jqIs@THA~kR5G7$=gseA+Ij9wyFhA
z_ErZCA=`Hnq|&v!9AwIzn<#X&g4a`b+XMyud!h~4luK8eDBAZV#3lOo`!Z_i7IVQ5
zWK5A`<Bd(Uy+EtZdu59fo%IMuictT35{9+69VPssWS=}#7~lJ)FkwW?TG)ksfcYiQ
z2%1K=MbRE~^m4o@jk*VsqzeuqNs)u7vQkLF<shft<)FyL1vKd2wlOp%?jzEv#m)}_
z8bQx)Z3!>EoiznmH7nXuIV+%3HDF#ZlPdhbs%Fd@mC~)1dbLa@U8wIKj2y0yR+G$8
ztVq*>k<;<OBHz=+jdeN5A#pj#n{YYWf#jyy^upCO<a{rv<prYpyr!yuK;GCU1<zzW
z#%+Za!80EWx^N|qE#mmz8b!T2R#h*)0+{RQnc@j!H_;QBsId+7M8X)`z<1Tq!D$;b
zj>etL_FW_n&#2eLk{Q2fQ@NsE8%xm&a7J~J@u%5X4WPR3%jyEr>H^W~0@3P3T_P>&
z63@Pi>J&A|XwhmH$I@YFu6Bv6R=IcuqLs~XN!KEdQ4_dQQ6J)YNqrC1r?Q`s0T{_f
zq^8PL+B%ZdL)7f?Rfy)PKOqyRT%yW@LIEM-WL2fIYTjfBx0{NLQAw-D!f#N|=P7X<
z#ro9?7;hZ16g5RW4-ou9wH4A<E`>9W^&d^O(zdD3jNsyGCrFRQrUU>q7mdZ@0ii&o
zD858u*fWB-98QAmnEIk5u-_)|;%Nk4j1o8^2t?Z^56Mw{M(vCjTznF3U}rova7Yq1
zHbrj~^)87&bBZmHyBL2gmM|c9S3L1bT;I)4$^=`WrHGlsv~aXYkor-)s?sHiLasj&
zWa^mAkGQa;DH7jIiR%0o=+I|U1)XmVr}Hhr#HH)2*4!vo_M%(!bkS-hg9MK5<(1gD
zY1DgpdJ>@HXnPpXv~w<}VFHV3m{bDel1fh;J|x+tRbSFj6mP}QfAH^nz`6`|yrhw*
zs|GIL3LsK6Ml<o4j$Z{`txST{US^l69H}e1pf_*<6dZ$6)K|30KSw%@=gIfup$iZA
z7p+}}E!5XE6_QXMmVcqCcqs>Uzoz{LEcXK{YJZJu{}|~EswN)~0sN_NXc|gzRrEp#
zSCvMsVYDC~ZXmRNZK92qX`{`JqOAl<6QRAS1#GnCHd-^Gaobw(&_-x)iMHKlqtK@z
z6lE&)S#+JCP7^)03pqOSe}%tyW#gvtWKVlpmvaYB;|?SneK~jHH15R7NRx!8^US^o
zscGFPqF$-fE>sWFLsc#$hg(e(ReFI%m`?zu7!_Pjz6UZ%2?hZZm8Nl}6Lh=MG_G_O
z(vuLCP{(tvwMZ&cYq0p4Pv#Qt7!KW3;rxPny{L;wyFl~%K>R7{n$8WlUL1?PLz&K1
zUoRY*I~-Rw%~#Y)vF&jO2v>)jGFNO2)wC$;WwE?{OhUL0e<K}=@^8?a0{ed%8{|?z
zrXWIyBuxS}NM1>Y;?>L9w5kE+Dw<kyh#CB~BfoGuG~ytDeMn4x5f3Nn;axoF7$q~l
zz=L)N>$H*;3;UZ6XjT#)=FuQhuA&*}0T5e@)-4C<7ep`<z&<1<=i%W?dML-kWJGUf
z)Z&2%!v9jTT98-?Xu1=n3-On=8IX2Bvc83fyYWDEkRfP7F5QIm3&38dI$i_tEhHv?
zj0Xi?{ET<;5To}ND$4!J)wYQuZNttEy#%unJ*>_FazE%?fM!lasR>sq%1qJw)cIg7
zo2G&BWb)|X_UV)msfMY?<eSOUfe%F1<L_=D-baLZHpwJg3qpcyrXcIMrir4mC`pLg
z9j<FvfVi4PQ!Sm-zK%AV)vL)JM?c}@ZrT}DQ@!*?ggTdBDr!Tu)K!<daN7JTyXv{8
zRXtZ$eJ#_TN3?GQdL~&YZsmMx<=X%at4mJ1Lo&O8Wkz-3Ejwi-6l*Qj$1=M?%Iq3U
zx0r=*An9s%II@w%6kSEhTTwvCS;>=mT}xxb5aFAda1MyxhreF}?~fpy%Y<(x!sAAO
zPmog7TZmE+$)WDxaGXtS!HtS~C!7BVK<Xd(yC29YGi*NZwE2W9y&M#!I^0QQCBKTg
zgHr!Gt&+Uqo=CI@{=hwO619{-0ndrYw{EDWZWLGlX!ihn5W8g$%w!+pF_ChK{&<4=
zqX&gaI@L8&?uz<1ZpRIvd=!6sfN&c+ESIStBI+@2B$@mRL@<q#O#d(?^N_rzv5813
z>WkFDP{nKN8qgm{M9P5_I!mTp*WfT7Y{W|<(>-$?HRJCh<sIJy_v<JnvMGp*NsFFu
zKplBa(-rkq*4NT}atzml+W?h)ZN`g8YIk@i{~5n6z@7X@Jluwd%nd-udL60nA%%Yh
z!^dfmj!3BURka_a==%9XKzbF87dCP}k2$nvIyZj4Dn^oHdO8T9m>gKA)6B&kA**Ps
z1xKP+kRN-is<wgjDyW<997VY|3*=e0x3UvR<XHo6m9;shvCr4e<ZnTVN#xgc@L`jO
zkn}%*+HVIHnuzY_zWXy_p(P@90;%*<sB#Jh+N37GqW*|U>myN6$?U~{sOTMB^dbgE
zrNR-Yd>lel)c>ez6L{{&-*rIx2sK_tocu=|d$|Mt2o6UeDW!6mIAjq8xQ66XP;*nb
zF;pYmro#|7XikUT{{VDnTrKGy9-^zLhizdfg?5LD$X-Dh#xkI(wARc4i8!dM?t$9c
zWC9xRixPW;NO%}<)1D%0SHj8VKqmo|vYXV3ROV60WZGi<N3GQ8$idG5oc3cXvW(Mz
zMj8`_&5Cf8n3ZZx{mn!~hQY=-D9=BDIA*47QT1?Es@Z#rvQopzY2M*vNj^;UJ+WZ$
zf#9e3yB=5#HqrNni|IXEOrm`QoZNX9QF1AnaIB`1|EQ3LK=v;Ib9}bsHg-6-vFv9?
zxpi@J%qZL6iPOm6$)q$(Nu;ZgCc%zi!G@5^bU}ubXx~os{dv5=yr1xz7Obfr4txf{
z;UX3rHO%!?O{M+%Dd3py@20b(eKyxqhjTqu<9&U*yQgt-LW1CGI&)Qm)I|+>aB$$Y
zF(lIm9%pgqXKO@v7B}e{ex63hnbd3f6+=3uMIJi^1)>9nnn2>^jgxsb4Xd!rukO~=
z?O=2d{vJS~yld<s|ClDN^>o@2R3Epce3{(UQlDU!Fk4@?X~BwmdhtMgQft6)(e7}c
zUMW0-B3{TV>W7+o2vwz{H&3FvBdCs)|3h&c@eZY^oGSZBl3p{Ly!E$HfZT5NV{I4k
zXVAhxzhlk)?5$59jfS#+{V~uq&{aPX{`C^%FiIn#oH-&$7&cR1YiwVppl~t%ZUcVm
zwSuv)<xr4}4NAsBr#Fz5md{AxT^d~tfXHtA{RxCxL1;RnFO<QN|2tUk;@CePi4dmn
z%15wQJ_+g5Da*IO)V)~pfubM!v<gVSlkDx4gKF5^FBCPx83CYQ1~LB;MbfXs+($<7
zJ!y0>5i06{n9Ce9dD?hiPQqeJ{y?PMGug=hlh*Z^xUOaMbdvI7lZMNcD$Z@FR@59}
z5~iTyYWz(B)~%?VEpm=+62v@}V;coAPuWSAauvlhnoyc90B-|@UQn13GnrUWW+d>h
zW5$L2>zXl<f88^#<X`VlUt@6%g|86@4AgYN80q<Vbj@y%y*J0!_w?u#$IVT*=ZZ;K
zLQGOAg!C2guY}C5V5ZgJY~u0HAQm9y%urW@)?{K~?74U#o~F_RF<D3t#Pt$-pk_4U
zL777oPJzN|qA*>R4RFk*!pdAKsm!HfTkNI}(_?!$<88tk68pD=!JLAYC7{3CQ9(nl
z-MSuoG+)lTxQ$2i8$b~g`nToyb6qAq@$H(JD&0Jze}^sCRp()4)6lqlEyBO*ue484
zQSoa0=ezg|qNYhziuwb#w&lR2N&a3QE_FyL>30L`ulN)C{!_-gg>r^^i&{jX9)2xH
zy+O__XiEqFz75=0qwTpN+FRV78+fk3959_b?*`l75pzuyci0<LS#(~cx`r=EyXAru
zH9dmA{{Z>YJYfU6<@!@8YM^d1dFX0)tod)m<~Q=`Qv`<u&0f%ZAAeUSE6UB1=3S@L
zy!(GgbHOmd{6vsF36d#LNjgJ%Sd#t8>12QU-^fNIm%kOXe4s;Di~j_)vhqc<e{0ja
z3`cI(gfR*IRxZ6A>3P6y!XFKer?`@H#+=rbvs=V*AoV#Z10d5~%aefCL=_+$`<yOj
z3yhOBIIk3zs`tJq@c^)I8wUf55-%1a%+QSr)DLu;mHrCYl%|3eViQvRr%uZH0R#DD
zgM|N!;R>STm&t8RnQ@XcU`eJl&Ckc|qtjWoiNF)1;Un2{*Q8AaFqoh4?ob!9C*k-H
z0RLvdqYS{pM^R5P;0*%6r}&fw5|0h2N%eMWC8btU<l{5W-6hjZ?{fxy4o&9K_5~k&
zTsqbsD_`m~)wd!&sj0Xsv=X!SR}A{||HImwfLB#rVZ-O<T*85%L_twO4TBSsn=r_f
z+>kH^5+Ed)gh3%dCIk|aTnLB(!2##Qp<1g1g;v`JMa8Os6=zVZI25S!09LED2#&SZ
z|9$s5d)))t@BjYi`7i9e?_O)|wa2s1KC=-`tudAO(Nv;+3R3YF_t1aMZ2{vE&zIKa
zZF95COz~-W4%+G{@hlwn95#wEt1!%4(c}Zop1-5HZ~G7(W1;SZlEPfMB=^ML=usH%
z9YaIr*x6hYDS{%E7ga;a=Ca0{jI;Tj&~f1n*lV2J3n?8WxR@!oz(uHsxwujdg){Mf
zY<W*1{93gq8!hjFafYTK-M~34M&B?;&pnW)`j<&U=bFnTZ$mV+3U;YD@Xa=5=+PS~
zkn37VXQ5)L=88T}-OH_5q4UGMNuUr`Qj=m+ldBO=t>yi;=7xk&NtomCV@QW?rh96f
zP`SzBRGgCVYgu7xISzuMyJ04!U0_Pv03m)u4>I}k9Gthh#nkODG){Ku!mJ{1H5Wxf
zXHYPi_a1~q(ial^#_+V;R@Q^>zrghm<9s5O{bIQ4vkrmN?+2!6OH3kM7sY;N00)78
zw-zd2j=fpec4qNYn}XweRPAP1H|AnXFlXYrwlhys+2cOksgDlCG>bEF*lzrLKwB`U
zBkRzK=FZiFa4;qt1)MRCrQnS|q2HKGLua1JvX?^DMwP!wI-!hq+<a$4i+(ZpD}*wQ
z=xQV4P>Py3Z+RGqv4>TzDabo?IFx6<2AaLVRC8C?fU~6b=bKC~G_jgl^|85Cv&_}f
zP_a=oQDMHAI}6wQXW`*FbVrF%t)r^CepVSCEC`hv(T7Ilgr=ET`q?nR&C=KsryD^z
z1-$V)G{eOC`j*t?jL$ST^L@m4E$@mCUC@qKV>_cAQ~4-RNG_YzA%4`}$?qnf8AHil
zkZwxBNa3wKm&5*pTuyB4h!^E%T-!}A*=|a$FT*P&@capH#S6V`iuPCLbi^^iD4Y(#
zMGuT--fJFO&_47&a=0J;7{&qERpXHhrul{DG%8O4n2mi=dvmuB_PBg%GE`$OUEyG0
z5TD%$)%wv+edYSbVn3cdW-WTF9xhY4`dntjmmwEt=)F)FVS^FgO5u^^9A7cEYyob5
z4V}_4v>By46*c(-%))sXu2;hv3VY0APE(xH(I2jT<uuMI=DH9IxkRjG@!N@evF;tY
z#QOs7Od)z0(`p<(<&I{BPW6+{%$>;SX@0acwGQWwPB*bFFix$*EGp4Y5be*)Jp(aH
zryzu`?pQMctG@>!<8`yN-%-ioY|N&@q>g6Sbo`Yy8)waC&}`zz7&!bE<v*Z5uiP%T
zYdiAJ3Ag3umANmoY>WN)?xx&ctY)1bzqZMwDRn~izGUYmPCtI%lHcS^orjW7Fcqm`
zX3hZr!XOt)93fM&h2UP~&<*WnzCfBchv6h0jB^X@?)irH?0`=Z<f_39?b!nz(6Z;=
z$+FyF`gR#sy=?PlGo&^$#?jDXl+Q3)EmzlWG?F1`C+UToOgy2bRC?iNKRVU)!Yw8?
zwLg-x7bJTA05nzIKpPDeo3_qI0WU-djp>k(?{~?MurytgJP;){W@Rv8{X%0qoMX+-
zfYz7|quH1p7`0=dOZBf}PV{&cbCS{RgRU03f$y^Fcekge5gLC#v7tR5U)*3!55jcN
zM5wTT&M%vTr`ke4c^sWj(w<Mij^b?!A*Ta{KNul9#tDUtq|YFjVd;@zVzUvGeYe|z
z$DCJFTgHP_9HV0G9`3+XBI_VMuLiTQxs>dL+I5g|)V%V%xqOfe10~THz0{Oii)i}}
z?9I37t#+z8G3psfH%#BonB=hIWKBZOW-c!EnDYW?Qsr@}&@@w_rznw`aJt8tFn2J|
za+s;p82Hns$G!W0=u&a-Uwwn@fiEx?;USQsvKN}z#f<T|c9zEj+s6^@X(ra$9<Oi@
zH0SrrJf4g_X(-+l#|yt#VT|RXxS?wAIFvZ8H%3@1lxf{SI$=}~t%Y`2I${eE!wCjn
z{v86>bqJvrFKsE}e}gJ*KFAj&7lOFMX*@9-^fw3>z;~*g8XjrNdJ^?xZiDYHsG5(t
zqtz$|Ly<ZkqgJBxO%$V6q8m*Vr<5hi^M|SPaqd~7?;|=e87qp=dJhwW(*dX7Qp?R#
zouRvo_j!;^;8pYfX#5?l_jWJs?})F10tMO!(eTOeVom~_>9Lpp4AmG9gY9%EQn7WO
z<8d$TU?nQP24F)=hdz`pzD82xOq`9)XfwhRCd1z3WwTYzfie|K{#VS!x0s2ITu_5v
z+ifntt!3gdxp3FLz?S1RQ;rvDTbn<g_Z)>@_c(An<0OzQ1KuzuV-Yvo>llnoeoHj;
zf%i9LZ)Vynp)}j;?I6y0PRK7~^O?<(zvJ<wyfM4qn!Q3Z(^zX@)=0B`Qo;SyIQ{s+
z)C!JEbMfULrh4Hl#2ad6aTXIv8YD;U&pC-Yp?Mw5^!Yx93`fKHuzL`Nkp0)Z4oB?2
z=9#UFN40mt8IsEW%CpmBxe;8)td2OYWlo$OxWzl68zsjS<hBrDJ<LZ;u{qwPIrd-{
zH=FqaIm&c>i^*UgQpi#Jt!Corj#Dw*{%$kcVT_@pCAJu`pBDzFg+_5o!Nn>mOf3rX
zJi?7I|C<(Og%-x_zE>Ps{S{h$>^d&#z}@v8Qxe%%G#T~xko3D9o*zfR2824THi}-^
zC|G<w!6qt-&8f$P$P<^>CWdw+!8FwLJQxn2YTM`9#3Op-TDhgSC7g<@&J8){s?T-i
zKH<xejQh0f6Irl>h)o=hO^BP`+(M|#Ns~K`>8u=-WK1)L*1OQ0$9vyGiS2pQQ#+Sm
zeo4jiz}Nw_Z+}0w!#WtBC(9SFJ@4L1Xeo&Bw9$R={4_%7#P;T-Q!5P3NvB6hc<Sgy
z5}rMJkAx?kz5?M=3t7vI@!Les7~V+afg9cBMx5Uz@=-*$W&28h?z+d6dIXHd>_Ez6
z(Kzh>H;s4!#4_W*W$tW#jB#_L!P|-4SihieE|T6c=5B1u%JaB;w$ZkgWA?%6l|`)g
z7$`n5P27DH$~B&IRv4Szcd!V3ocLQ9nR)91)qaZU;iN=p4<tTqwU<z9CIk=tc_u>W
z`^0}x%ca+y(3%P1L7GK4A<%?fANqHqF?rUSyh#(M-*ja1ID+2~&m{W&Ap6*7O}+nV
zOyffzPnFIazet{o2z5_18~tqL(Vtx~8n+}C+acE74za%6$9A_Ptnb2DeZ$D|^A}Yw
z=DC;drundT<y_pu+<HC}ZtO&Vs!=beq}rTQIL!z`W6<5%XdknOOi$z<au{S-uHe4O
zQ2#_euQ45hfo6*vU^2g+26Ava(0KVB1sL0d%-DVwv5EI!JL{Q^)0pQYt=Y^njp=?U
z&#RUVBPvBG^e;@9#{<4IzIjMD!e~2>MRN=-WeIBw%NOHPWg_>~5r`$(RFiBP;xgf$
zZ$@mRA2-*kXVu_9zu36D2J(JQC|4gevz&#vz$pGmho+ntn)oinZ8>KdNvJT@ygVc{
zJCXMtyaNONem1f4hA!NyC-Yb~vUw8WM_50jJz8|+JXU1qvA(Dxj>C#Nm<M-TJhNR)
zHPch5*eqJlH<5|s{INe7u4@x9FsF7{5AQ>`&&Cm$jM{oAuR#b+>tIIhMMz}^b`wZo
zs^gwud<EWFh*7kqLufaWj6g5k2&=48I|#QNS>!ERWSM%lm~!cnlZ~1qr-x-KhC8#0
z|C2GDf@4!zvp?b|^^cq$^`mm+^q7e~2xC)yiGGZz*?h-g?kGnH9n<mmCI04n>Uh7F
z{XxX63MN<3?AVUGt=SlBHjQQz`K1niwWALz96xe8>@RQak<(Xx+#Wf7?Z@LsPT%+v
z9y!q;zXoECoOYOsEM#U!4;g=XeTUq=n2n}?7^CGHnEnc->06tF^W^@4Dq<t!u`p-Z
zJIx{4-|2Wj*`l%q%a)hpV7|`WxQfYAobtY&jWFT1F@HMx)SSHeq~j4MZ$7a{!*u(p
zal0J$aw_K^9nIss_EgSi=0N&YsO6mB=N);@?-1kfq9mbzntLtt^RP=;kMY?adCH{!
zbw{47d=84CJE8Cob-wM$L!B--78?2;rPyA7l0!|1CN`kIpF?<U8dNxAdc3)b@z+ps
zT_Lfj8LP#B2z5!~fyF;foG)N<LS2)%qj7Nf)b9@8mARFmTM`$t!yw0sjyJS^k1={u
zdlcVGN?U;Va;VbEK&}HBnhwpd<%r#FQXtXLT!^GzLzDPkn3tjHw+ne(jmDPKH#tc>
z%4m<}`~=?Ex);h?W-&4;Z4=^WLXmbi$S{zh&CFsOVv`Uvzavh><Q&z%^-gF}QfM>s
zdLCgp(riaV%PF5lNq&dPDeFb1u2{ImmpI(+;~r%#*q9XB4OhpZBOipjb7oj~jq0uk
z$`xufjSP2E`(>tu|A7=7JIhV~oG=-NgSm%JfwwUTgCH3Pk2*~a=FYVMni#@m&@QBw
zr#&!<4dKq11s=>JvQ@Bn2w^*{?w}Qq#AwAsGgz5pu}%fZauN^4cEFTx{*OR1ghyU9
z<)Ii%hw#`8Qx)zCJqE;?%?gEnIQAI)4TTuNfAb=5%r0o72u{M`oYdk4c&-80MItz<
z2gm*^y$2$SAD#`Y62%-ooFsI~yg5F@$}NFr?i=kwJyY}2TihiR@?z&*F|B86McOpC
zHZw2gc8<6;#N>#(h<IGYT}V7W($d=MHfFjVC%7*<TbpN8dQorU^J#9imw98q%knBS
z(k8e56SAIef3JDMf@N-JFQwA$Q0i7@y4|*>yUQ|j&dIAB=+4P>JFNS{?KZ(}YrnN2
z?QrZaw_`<f{-kZO7O(10Zs$YIRTI6mZEh!A-q<t!>jPdi=3Vp~Z=(C&(zc$d6Y{nl
zz%RDc-M4Ii&(zXr+O*;6b!jtaM*Gh1;U2T@rePya9kC`OZOV=A(sg;Qv8bEm9Un{0
znwT0*`y)cjknwJZ$brAPjjQX@-OdfMjA-TNiRZeVOWh?61Ns(bxpfWhv5_4OgIZeM
z4*T6@r7`cqsd@dchT*jQ;)3mS{_OVfBBeJ~-`%pzZEP6r##XyYna|9h;~wW_Heck9
zU%km4y4B6~Qrw{tH}{Y`JkuSU=?;lhzu<oEc##P=eKminyR4!z>Me86PM92O-k#ns
z>mu(2_joTQEhCz6PS;qgx5ho;kT-38-Hq<T)!sC>gO_rnTbyuK$lGwBJbJ|e_k^}3
z!>f7^`>R{w9q)dMchZDPD=RC#E?$@MY1wa7xsB`GsfQXWFOQDT>mSXCo<8mT?ZdO8
z<K1r@@A%&5t{&kgPjDCS*_Dx&7tN^j@=DSMcvXFurltKj;@mz%vxi>gE?L*&cJz+F
zv0s&Y@&vc4trez~yV&#xDi0jkRzIS0-qO6h7=BUrv!=Ei`(=sC!x?F@O))PzJ~}_<
z^~{JK@c(C_A0juqr|xm*we8A?=4UL)X!W8Q(^8}Jqp4B1lXv{r=jW|)>sEW~ne0tB
z<~6strz1_@Y*T_gUh6iLq2-gq<MR%C(KTz<<YnaLEx~}pKeuM9dt9blGr{fZmAYTx
zr97dAmdjVIAMOtDB5Ufi+?knqZl4BsMkey;lew!k=1yyHQ=6;GW7F3*kC=G4q-SMu
zR`J~}mGv?A{!0!uMDr>ux3#vmR^kz?(gWVh?uMpAHxAG0mvveedZR6xksgiZV}u{S
zt<tUCpO@$Le4;9&@}3ODO1G_XpLh0DROV0g@@odV#d|8(obDdu9cr%3s&s31qMs*V
z({j5<+-2yz1r_dz7%THL-4i1dw`D}#eF-~TGOAM37P?6d?lEod{B_aOQN_EWBl7lo
z(QR&r)$W{i=sEY4Hso~wC0@hQVIx`_M-CgFwW+G5(v4MYb2o;)%wEOQQ9Ez2!D-Rc
zTiv8m<+B?q-L8Am+@+=7Xtyzf?Ym*;BQxFOSG)DdbieoQH00U%ffs%5rJ)1xO6yBP
z&7<695o{UmvXoJkB~fe++sdPNM=@z&s>r~`Q&;OA*X&)ERadpfP4-r!S-#C0p0#~=
zdTbxYZ=|)dJerZ6kk-YUm|GRi9y)Bqun}2R+s9W{y9?1ET{7L$Qul29&2-OB;os++
zLvE_q>>l6j_V)I>uQ#o8H-$2RnZSs_ZJ}l~N7dn0??Jai1qM;Yw$@#(t<j8FuNF6X
z=XCd$Ce$%0AuV)Gj@!BI8@I}va7jYOac(y+GofE+H)-_)-d-=irMxFP?!rvBS0?5G
zZ*#&KU8>TCWkpBdH{$f+*~7CC_j-PmmX6wtue_)@>knDQS#D#q+jXnAFC!LnE4I2N
z4elH-<w|68UYob=Mr_CKjMZ*sv-_p9+G~w@2i^2TUTl-wW8JhF?z$##kGni`IcC#Z
zcSGn9HqdW3m8ao}g<ZR_ond;dxXD|D);f3F@Vty@fA@=~hJ^l|-6HgSv-@vn^?{b%
zUaH&Ai&T31++N;lucz1IcE_9iLpM*IKPfjo&+XXYUK8?~)7-C`+T6nq2G~iNZdD|&
z>hA4s=L&amWQ}|0%I4^;8Ck=l(X7^zY3}qr-?^8geSc_*{0ejUPtNK)(c!I#qjyrb
zM(d+)hvxLG;loFqKfmvMY;>o%3o_lV4V%49yOu@oe&>NTBZ~8531@bBK3d}Sb{}5p
zl}0l%+_xOI%+3Rt<K2mw?zs)#ba$yY;jlYnoqI~dS8lDBg3Y&n5BE0*oP=noSHFg;
zd~ekJep$uQyd^ITugaTVxw*Br(p|95JCVa=VW!)q)V<2x*?eH)<&_y|yw>}?$(%Xz
z++((K{B|gPsn%WAz!}GlHMkqvRXkpok==;ujKZLIkEw9$Gu>kv+^5iz-mc5tH3^v?
zyZ^alzq^{`N03KW?s2=}QQ8pZqBP8^H@@lh+~yv)df&W3Lnh)&Tel8PTQYQh<=FY%
zFFLKNYIxQ2v1#t8tzMp&cljp#jkUap!aTklua?@1U0|lWB(kPDwk-eh{NYvo(%rg<
z`zN=;-M3<$o1E}q822k&kZ?xG{h|F<ub2DC#arFy!<pWV?qe6D+dhNQ?ICY<^a^)3
zdLr7A5v_{4(bA}UZ$jya>!Ybvr&mrZuWa?YprCp6)#Z8BZ)81M<>k+8`3bx9MlUit
z=5@hzp3tYu-`s6Y`=e{uj=AWuY3@UbZSL-673YFfkhq%@E7r8MxUVd0!=7w{cawM1
z+?%}VcW{fH=A|EY_hQs~YvAjlmDsw6v|-5QX1YTw+#fK+EAg*OIhxA--pM@dzH&*X
z`#?g4yQ2w>f`Ua8&gkl1voh2D+Np3)FU@k_P22<9KP=l>AH{CKd%@itYQs+Nol7db
zt{Kr(_v-}I{ckJq=bSe8kh347?dp|n*n#fnUdg?C<<9G)(Rt|@yldRO3E2I4Id@CS
zzh8pw!Q=^_UP|_y$`Ny;>D$UH-TT|^!BBf``JRL`Pjol8%XD8^j#9SEM5Dj5e5=><
zOEjRnsh!vCWw~n_G4r$}?DQ^NGB3;P=2hOAwuaS1B`aIpSKA#z>HoBRr-wy>w;grQ
zbBnibayP6*;wVhrO)FO)$e5OaNqkvmbR>))Nbn|X@*2IE`}Y-@?yu4PdzvbKw{4BL
zJ|VU1VfUs)?|3h7oBPkD74D5*MHG8Ux3$qrX?5RkkJj$WZQQ-+kbBoMFXeK#Il-$y
z{EZa}XNKH=gxcJ>ThXb1oaW8KZZos5`(kLnd;Lmu7fRse-H^8C^t8S1D6ay0p@@6e
z%0q4+@TZ%+Hg}!dc3Hpa?ki2J-PsX0CF0JkaIZvBOXqLj^rCyVcl<3i^Cw|8tGu*l
z&(ljbxTSlVtA}GJxMX<x^w?o+dn4R6%e_c*6_$UwSWYc;|AWaU_Ko{p)7IA5F84FX
zE5$-_M@HV?+^ZY*yWb{Z43|f}yDCw@Qa5>j#<rWzA931}eoIc<8=H=Wq1S&N_Ojmn
z(^`9GVET_7cF$jpZM8Dr-H7ez?IoqaifZ@WB^U+Aq5^fz?y)JA-Y!fetKUUqpJ$c>
zr*6&2bHDez%)jQ<r+GU*{?My(uZ`jLfX&rdtYL2z!F-hF{>5q7c7c1}%5_*!w4if)
z4H!D2@=16Z<#suQXQ4AkV#9i&*d5pA4vS=YEnm9xO4nB&&WK)i*z4u>_fB&MmX2^Q
zT$eDoi+9uAEvHBK?xW&nuj`N4<xOzkZRfQ$yAOpcV(!ZqH@gppGl3IY+(*I_w!1H0
zytUeG3-5Pdx;WF_0@X_wrvM|2$MOcbdmS%6Z|$vgUvSzmTa9p6xtOGWTCv~#iL=!z
z%vSfWT<4x@W~&%ytAt)%*LqldxySAKKh0O$R<4%0>LxR9VF<qxYHqH&+&y`<TfW-u
zUh0-(ky7ebZQbRycrCHm-h{qgyiH5*$8cYPxzvm9!nm$%o8j(qyoToL0e!PFM!5fS
z_G6hJ!}>gLojay9f5{`!CB^Q0PAON|1?!e&M7_h_B=>~oXw?1V%B>hd$oR}d(J1zu
zrS5x8JKYW()R~#?HjIyFoy>Gh@oC#yz8)TnUXhxW(7Q{Tm(O+KX!mAJ(w{piKpatc
zTe17dbZ-Rz!pU5dKD=stTIFTKvBZp~em!hN3pVm1%qFKHq<fh?OQuzx?snMIJR<M#
zr9DrNmNa@7Wk#1S>3egJN!un=Zr}b^Y1Oi5Nw(WKA**De*Cn%ZTC^&GM`p=5e8Pw7
zehT3lf!8S<UW<dUK0K!Ke>g^Ta*p*bPZ)hnyOC?cSGeU*=RBA5EG*-8IPP;A19mxA
zxTDsD6BbxYTpBXJ&G?Jc!QyY^G3~~#X?I2VN_Tlj8a{8F<|O4x1Q|R_zx*YmOv{0$
z9PxC8k>nYHq~ntEA~@DJDezr7q|q`VP0kwkA{evaIZ2bjm_bfbp)#bi_2xxAtvAw+
zUgM66B+p~or*pa_IJQ37u)~Rgqsuipl3WmRrbbfo1Em|2ghO(_Z0nKkFF#K=C6c@#
zkYZfY@*}*kz@w5TMw0X6Efg;^@5ZULK5btmTwuFE>-IkEG6Hth9i>UeNtZgd%~R07
zIH`AZ-H`nSfimWF31ug#?^Q@s8%Tq8yEu|O)8z2<$RzC>KDU*3q}{kka+%nnfwPmQ
zbbMO+C)XfsZNFyY9PtH5rX3qeo)bu0X46ivY0ri|f9sKU6wr<%l&=bvkp?J`A%XK-
z=64XbWdU0=_Afxsn%etqW;hEvGHIOhaY++wt7k`atjxywx8Qj6$Nu<8^2L#q8QQ7F
z@v+F)mic|8!-XF$GsbZxvZCGSq&ZS%ocS|9K11|(jC)%@KaYeLP1$4v8=o{f5X(tQ
zSRP5X<C)L$1pCj_xh9g#jYPKj+@uMHv(BTFY@hI1onRT!uI17pV~`t*`gBebdbrSZ
z2pR=HTV_6>vkP%M$M|KQ7%1eJq})hy!qvWnS?9#Z5}&H+{PQ|Xk)_Hblg1$Z$MLPk
zmYWaH?6rBv=M~Nlc0L+|NhLYq-gw%6EIfZW$JOuW`JNw0i@7Y4Z1duiDLFs4KQga5
z$m@rAUUm%dL6HH-()KIbw+Q*LVaFt4HXyOKe9B{Hz;+Dh>;##KXoseAc&d><K6r5|
z(E6Q51H^6L@Og@=fZp$$3nR%jfoh^Z$0d!9HyQjQ4S#%c;&Pz%k8)3sBrlW^fn;Mi
zDCRTMr!@^9op>{l#?KRTYC>>KVB#5<)Q6ei$0r^*hHX9<MpDL`OvWaSg7ar>efeBN
z*MMEVUtc@^`G7*Oynfy#k>v9uDYD_qh{{c>ilA<`op|g2hXKESI__`mILb*XMh)!f
zV4=_vw$D;fsCj|(XeW%i75<jfB^2zlX4v+!w&RXzXZy_7kvF|_jGDIi1wHRx|0Vq(
zq~VWuq+bTKZOK0K3z9SeRmhRqbyQN3%&s=w4y3CNq%(5|YEfbufek$_sp08S&zb!$
z><SS0<L%}jd-44Iw#$zsyK567DGQM0Q9GQmNeS;oQW9v<>PAwQz+ze?Wg0ppUtBu1
zDR^=N`#D<&-)F+eK!=P>szbs%e2H{OLOuMx7I6|d-`pQbv2{zqKzjtfjX&&LWt);^
z3u~5>G&7Psg`G`5vi-3r?<3tSHeGyvsf(nbVJ-|5CMT&p5Hni__JBHg#wC@+Bk*U(
z9dE|uGw!yY<7GXSfSn39fdtMGcKnS?O87C7TpLN5jdr@1g~PA*99*`-I6gXkaPrJa
za!b$;3G;nteoL)H>n{pHJ{4pj4M3(woYF{2dBj0;R76rPg6j9MSr$pIgh6>Ed1A!D
z1dy;LlF|T}9&xbbnG<o)8f@-_Y$UjdPBCAj0t>l~*=>Y3?r<)(Wi{gq^W`Mg(cg~k
z+{{~UaK%V%{r;aHNiL4J2=vyTcg6g|S_kXP#<+dXu}&`1@W)$L@FwG<{bMpq$PKhP
zRx+cL60VP=G(mBVX^(_;GEyC<R9rc{H{n&R2W`FlvX(`XgWZSybSuW?YB(AdNx@`T
zd_;H5iKMK6YGxz_4H{T0<v7lz$mb~E{@%b&WoC`|yxlJC*y82tnm`@x*cvHgYf_+|
zqmo=Vgtjt+%cke`*4WSYchdvua+0hU4yxQF%(L-%ftObI|GZri#vb9|;v<@YgUYU;
zWt^5pQc!<8H}Z;JH`^YV8z&q!Zg`0f)jqnt=3&(r9|zE5vo=3ofWs!J_JwAm%t@Lc
z(}0sAX68~{&<<<3S+duT?<;vBZeYNd8Q;@P^<;{f%p!<mTOVGHJ2{Z%e7`=-7EO<9
za1CK%JK?;m(Ba}M!HIdqG?9k^`a1<IWFE;dYEY}{0D_$dQm41F1<pkXIk<^TewfF7
zk*1*NEQAE7-XK$eHvr5p9e?{Hu$)BR=Lqf*?=d{)5jkJc24H?nhr5%Idw~d~8AVh`
z_?^+>)(!cM0&GMGIY)@rLWJ^Q)X9&>rbn4k<eQ!3TRC%oZbp%BW+xTY`DflJ^37NW
z^V^KS4<N9D#D|1?#BU6bdBkr;9yW+xWhe3lK(68O#-Ts%bOMb-(GDXjBuI*unV{wu
zPcelFzeWf-CCrDHZ9$C{{yc|3iv%1c5MM<IIYoqj3T2|7gyOIH?ZRI_Q72mNLvWoX
zomy#&<Pst0kB9nvBM@7I*hRQU9B+8cBNm7}Oypf}Yz^@sKDabT3lPQ`T08+@?vIO)
z0cIwKg#_^vZ<n}wN<eKVZf5|J3`RgUgdv8OFq<Ng5+p}$!DfhB5Li9pO~O6m4#Q&}
z@kx<~iLd%{;%mN~c)*tvKlbHBzSrl7=0N;7BSVt{aRP(+<GdPfL^3?)5&8ZemW$}~
zMr~5aPD2O`DxM?}Q6V8}v_&>SHljHQbVwW}+#_CNc+4X<i#$x^`+tH3r;n)!$dtf`
z$S~Tj1<(>SnAuDt(y51OMKpy_YqTZtwAv%{prJUyX(_d8a_f5`bgNA20xMdN=v^jB
zLzuWhxJUfd@R&zDDDp6IB6g*$8?nIfhA?q~FDG&-$My>5^AOUa{)CSWE&2yw0xVJg
zNq}mh!8Ct1hJ}Q`8(PdX1B_uY)65t8^E6YK<`a{qglY1PVF}Y*B-EyP0a{w1sb&(t
z_PN#fggKKzukDtG_(<bMMLcV@*qAkhi80~0s(_n}4Ugf{B978Uu1&*qmmr{N2yYmw
z<AK`MMpQ_+!q6#%zZ$AL0iF!|0D-MeJRsa7@>N#sF=A)K8^XjBeL0aYYzp?+KauWR
z1nxC`bzld|Q))f^6hyq*nW;TuvEea~SR(Q;(dR3OON~4}&(UADk)^j1M<bv?2vZF$
zW~zB2CD1`&7q|-1OA%NDBHz8m@(|xOJmwMK7kQY-Q+L5_ls;}Tvh-Hs-3V9|5bp8C
z#0L$p4L=Ng%$IKi@(BnGWWqZ_3GW$NK=`{z3CudM-nbRfjYd@XdjP$mt(is)bt+)=
zO9WPvcv!ecJRM6SR)?5kcte=z^G0HSBaeB+0fsk(iNk$4k#C`*e>?p7p0e%;=nlFt
z&ucgZOf^iT)-W5<90VpNjuP$>YYdNh#9EPui9T;6witQLBi?9uLzsAnFDLR%R>8tC
zPrfM)g(L6{Y3KubyG$q@{6?rPXCb1MMpRG*SSgfnIRd;JG+z`!O|FLQHZdWv0LaYx
zT94>m2rLtEgK&?y+who2d{yLO;)lMR_>nKS{vJg9F9^tjrtb;0+JlIGiNM^5hlP8@
zK8cjaJmMLKH-w21UrtQ-<-}pWoS5y)iTS>q$k%TLTe}<L^oi1)4d`do^<g4kJ_qqY
z08<5;Xf~o{2y{f`3+cc;;$FjJ9&w+@!$hCkdOP&71OaXd&lsw6WL#TF?cGMJ6JuOE
zh1y>mt?n})MD!&i(mq}Kb1RCDa=RL$>m(sHzeVt{mTXDBIn=Y2v8_h3#FyBrybtLI
z2y6}FN5VZ~C!F(U7ZQ^VZwM24|19N1zP2maB|J}lsV^h05$+L7u#99n;%vhk!o*5n
zPOS3fM830&_O`5d!^cd-5}lTCV(+f4*2c!I-5szy2X?O0;v|xYqn6Ru;4d)v41tGR
zUjq5IuE5TO>JN;lfFPFfwJYP2qJZC5KNA@QhS%Q_{Xs;zDF1~B0WB{BEH>4`P8nD)
z+#^0}c+4a25P6vRk}oIj_T@xg8VEKI;~)5XqWN$-1~#!1E(Oq*c%0!_umVr;<-`+x
zIWf(b6ZxvJU>EbULXIyZjuGw=XBZyyh_gi=CVuV9iQo8gBHtettV11S%Mj3HgqsYV
zV*719qI_*J`;GXBQ5U@hI3(0s#<e9+LGzW-#y2uVC2jFDpofiCH&9;oIL?#{Z3OHh
z+#^N|$00s2UF2cnX`Q4VM81eD*j^)`AB%uG5xPT-eFA}&fx*FRCOr|DnAlsmN6auh
z<`J_+9wvU{%ZYqhSuo@C5nqIWEC`1UEh5k|kTEZ~gb<jR=nD6UJq^b#0>EA(4-@$U
zvtZAi2U#ux+!90`U+Y&xwm{T`>kTdL3MaG-tejS=R=dlJ*zM0jy~`vnAiROVb+YaE
zj}do_!vaDQLOW*(&KLBu7JFfF0HK|;G$`gZr2YtO0^&g79x>1Gm`5xSd6-z+S(<>z
zH=_mHeg*Wa5zrij8mMu!PoQO>?JtM+HUw6#6sikFO%R{)%6$v7BvBKNLufCR>z!<?
z$Lm=w2rLWnCgC3OkA}xQ;%1SDiI4koB43&otjBJ|U-f0g*M)n;Gm$HY0P!rt8^XkX
zzTB3HFFQLHvUZ%0dwbTzk6Nq4u%ZgH_JY=+FrE~nR(`y?*5BlU-U1F3?h*41k9kDC
z`Yc!*UUi$|%ZNq7J>u^Tk9ow+A`cTE@#RFm0WIjS9Px{cEWPzA;7tgDv24{+(@wO!
z%vcl=n83v;yFf}^Lh$n5lL*X=__T13c<gb~?8GjHH-w3!eL0aYRSOoBm;R>sGGdW%
zkNBwJ*zW)z6M2}pL--0J-?$ds+808`_XuJj)AVmbkA>CA2!Y|v>xcbKV)PVnpm2{k
z-SC)4<eOYrVB%a~PUPFxf)(L)#>KvjSTEcot~5O65&4d_U^-rZ<Wnt_5jP0;h@Ti9
z^N0sU9wzdIYQaiB2-!0Tes_Kf+8!o>+Vah5?;&twwqy1GtIT!0nZJ;@#rku2NwmKy
z8k!V1P`F2|G(6@J`5rS?m$=856ZiUZBHyYOtRj8q8+}Wdcp(CIR&?>YPy$n;)`U+H
zFad{&e0v(igpTlwbhgZ6A)-68B4e_T5CSW%HHhA7L<Kep-*6}*-7)_bqBo3{ig<aq
zr>O&WnZVw{J>nw6V;-?a<Y8j1@D)V9g)LbBA&AdKKs9K3u~1v4W<*;M*s8?agnPsX
z43Bw4zHKcy_;}&?Nnb|XDcmD|V0g?U@{MZ2bO#at(w7mx6Ydd@!$o11oXA(E1=I0D
zb5CDJ>@D0Q<`^FHh<xQ4(-E)p<-}%RPTb(jiF}<}FrO&m;-h83Oz`<e-?G5A7cX2t
zX=IqifKLneh@Tpcvw6USA`cVKK2hpL<lEJP`SF7GUA~OCLAXcUg{w7e58?}kH-w41
zg|8s;-D|<#roa0T(Axy6F+%TMY0FRjV@6;2bI}xPzB1Y(zMbmN2!SEbwB5Qfzm_oZ
zyOWIb%_~VlC=AZG5ct|MWV(4J3H_Leb;#6o>=$kG5k-3nS#YKy?lc7{Ao#XzN7%mN
z+Y(<FTY|Jmi*9u+^?n4pC9>pb9fI$6ySmMVund8=wZNr@w@f9jLO=yCMO|+~KsBZk
z?_k}XDMN52YzzXL>(uVJw1p7ZYkq*V-y2`)tzjfcHi?QtND!7px8f?@eF)6?YhWj|
z5cx3RD1^Xum3TL#x3U&z7{@KyL{<PrIJzDzI|`gV+AlCU3(k%sw;hO%+Om>eI0*rM
z2<$}K5TEk-Nq%i9zZv{9RF|AM+|;6fD{-3PE!o6+UruCgY0nzxnwqv`6Zu*+WNY7!
zMw9rkNpIz_NjpuF5+@tpzjX!hVV@I^J6&vulM&#O;E#;#;J{}CvYm<SakMkx1)+qm
z3@swC$xx=z#H|Q0CVV86jmSoVlv^n~7nHz(!E{767sLb(5{ij8AV5s`4T9?|UD-;q
zN#q1+*p^Zv8xiJ&B?$0RdI?ZQP|IlIegv2hIG~u39as=^eEBUulX!(``I4hsTUxkf
zX1s-4O4-8CnbvL@P4ruPX1ujaYzuF}_Qp9S%qb|5%<qF-Yr&CvJ_4@sg<DCu`QhwG
zeq!%%tKIBaz4*3PbPO89Z@Zb+4|6)YFEN@QUCG{j*JOYQ3AaT$B#uLu87mTQ*;Lpq
z+$e0eRIuCG!A4;>2NPj`bDJ=cz{XK(d)z1jeO}7)v&W2r#NQ-JiR?3@2y|X4JCEIC
z6i4?Hw+5q#Zx-pgSr|p2*Gk!I{@nNI%3urn+qc=vR7e+xiPZ?0GYLzDazOZfsi(1z
z?gPKsw`jAYlV39JKT+C!%Sw`J1k9iWzje2mJqMc$Mc=ZL<RJtY5oG&-oa9~vY~BRF
zaki{Hx^eufZqcf~fvjYsEsAdvMYbWbF)%n1F@GCC-=g>P*~k7ClmBP*gTHCyvnBjZ
zAm6&+AePyr_$ttE#T&t&LT1w2VFY9nm?37`@d9yRw9E_)kePN*0h7S+m>KBbnZaUI
zn!Jl{2i$3B0pVGZvJ?kRDT<i$8q>(y5Pyde%begW@rc}mVd}6uFw9Y1TUq#H5KM$c
z+kgNgg3LxsaOO~cuOX)c2=M2uK$<H|b_E1hmSX$k>qWPk>~ufQeb;OR+)mJmD8r^O
zJ~#@WfRmlZr><>YMD%0hdua->qZuy6Y|kr9LA4FhoVE!;Z8=^?nomsn^wv*-hY&E_
zn0}Q>Ut|+;Ct_2LLoQ2YU=mg#n4@Ag$loLxK{oUH+9T3k0%Q6jG9mAPA^Nlb%)pdC
zlm6aDpgoZeVP6}Vt!LUY(MQDSTc!qlOnuK!hgt=aO|{9mjoojGk>0umxB~&E)&r=u
zyv4V~F_1MhgTk7ch&BEU#{WfNXA;|^6iCPtTxlklLc*^Ruvj*DyYMh^op5gxknJBh
z?CORslUpeY#*OqTp@g>#E#chvnMqS(3-bjuKN@WTfg3iG(}>%3po%X-djKKPsq2)u
z#OXy}Zy0MGrKe+j=a?<3fQeI$gMz_;u|jR8T;r@nz@$dtoCRvNwJA6!fWSiqV!d#W
z_-Dgo9&v}r!^D=Jw8zCg;Ejgk;vVo{y+!W$zw2T9FaqXQC-Di8W*A|UrR@VasmM(n
zNtg`OPvm?6!_N@>GX<o_noL?|c7<hcV?Bj1009%Gj=TuWq9%(XLXJt*;2Z-prVO<2
zxxN|=5!Y&)oDD5~VMjz5B9uUv7y~RdJq9<$E>N9e)J6RPgAfwXd&Kh)+F^7h_U=SF
zRHC>H(}|8cO3?`PiS0Lj3hyPDc0fzPQ!<hEsPR<RTw1$DH=w`5*4LK?^repfi|f-{
z<NEkqLVdc)E4`I?m*Fi1v>j*iO>dn7e8TXS0-}`RfBVRT547<WzB|yMw_m}-oyJ>w
z>o0j@2_844NN*)RjetHOJa1^>M}RMc+G^$_I^Bp076O`tu0S@|ARxIl{08-%ZL~!+
zWEn9+Z23T0+4&|-5tH90lm%Wd)Rs9gu;|q9u&#j)n;CEL_;Brr90!|R3kYm0*QuS?
zO2VqQ=i;=({$8fHvQ3r+wgXhhGCU=^*8#FE9Z^RXBe21z^uhTJ1a9!eGlYA@-x(hB
zi1&y*Ox)wkiF<vyZN?dhmm|pLdIITsW71N?q>uRAn!k_u2S$c#rofMcd&F^PuvjsV
zm}_`Lm{{w}i7{VJyvmmon|(R)55Anp*A@p)gYdhery~Rg!Uc#n94Xq2=mQ8$Nqk7S
zM_hKMl#;m0@P;svuOAMcAmO)5J3#KwW2EOIV4uGnP=A)8gi8^8qphHyiiR-dY}Kp)
zU4ww+gq!0UzOk2i2Nn~|`miZ-dMhzx@-1P$|1#c7=<YTI%)3ngxX>Q}#~N2U8+SyS
zvrO`WE0L7n;6~FCSXSiu8sHs~+CJvjUim6l7!ukL(2xc<2@ew=5boJzd@(ZLcpRM4
z12Svo*f%4?PA9j3Ozl{y9j0Oh1XeDvo8dzSi%pkd#|NwzZr&jJs^Kw@_?pPW#9#H3
zE+*b;cte=T7as?^p1%1;ZZrUaYU~5IH`$_5|B%ra5_TF|#2kjh8>SOFeNyPlfVNa4
zB}|GKUw1T-{D=VS=hIL-1ke-Gv2`PWMgf&V9|QbbXwUvQaf<+hy8xdF^#<Ue76H<M
zfDuA31k?!qJ>aZ?#vltYLuk_=-2Ql;k!}P0B=m&Autk6~!ZZZ4QzPM<QqdH5G+j0X
zLwl$(>H;`fXfa@>&^dssg}w{uhBk!5@qj5p7XYpmO85f;vYFRP!T{@Fd*5RkdCF7T
z-c#7@e%EZ)uDJ!m2aIU}!Ph^k`W+BTe-*O7!lsi738xua!me8{^bdfC3@s!?O)r+P
z;~GuJ6|&>rGaXmR-WqGVsF1+d1!J(X<K7S{VWsJ<5_a51LkkIyi1Z1-iy|ewCsOuo
zSJQ`ugf9&(`2mn*`mm62fuSXYDv`2hZ$Q9ehw!|iCG6zCnNBV|0Qf{GfqjeevRCgx
z0R0fa?gV95&NsA>uvVn;{wra3J!-nFknp6TCARn2CDP<m>?VRCw7H4f%FU*EiwSIa
zY;c6%A{Y}A_5$W90$*BZ<Rsj%a8%$CKeGywgGN!8OgwBAB;OfDeIFtl-MAuQ(<2MQ
z`)CX!Ct)MuFzIY!I~n<#n@BpC<|-g?Ye8B<e*}}3WU!GJ5TtR72|pXJ?_eZx7$M#I
zrbQSdO=h?hyb0iEKhYwD9#X<n(7UIa9xfnoQ%2q~z-o~aE<$I+U0c(eARm~XFCfU4
zUUEN*u@%AO$oF5f(~UiQ{xJk}IeVVnZj5dRxetNMWp2yuq<;yC2;9jMJ>ed)gYZt=
z-e)2hKO7f+1FY8#@(a|igQ;Bsp(6r!HpC?1VPa?DUL#QEzk&$rDlJg32J~@h0m7dV
z=!E#3@G$WO;oga8jZ>vz2y8ISHWlb)X`^D>ENFc@iaA=#5RMXYxT13LeFJSM<TBr;
zwX!1&Ii+wPfdST!$Z?F#bqyNnHiW>T>g&+Rpsw%7&T2J%R6t;t(SgnBL*EpsY55yt
zS!lIqVFnvxX0ZZ-zb{(f#F5EiVS4Ea^e}tbL~P2}V7^CE5(b+2&x~m95ika=;fc_m
zf`F+!Ig!NAWMeRsjZJ|}HtJAV2J;6HIL>+^2gzj$ODDNZvAO(!YSKBXo@`~E5vQyj
zbMD<KkoT5g-dlosZ_&I{k#dH3^oV}3+k#2kf=Syn=@OW;=s0)Xyt0+-YK@VxN*FbS
z@u(Hr_1-2DW|4q9acupJ!q%n;%C*LzKAFfl0?o```dV6?TPi1MNV&DLMM1g2ab^a!
zn;WS0I>YyBdS?S7Z<{QZ81$#1wx+-g(bmLlUXo!%V2&tgTT@_$XlvqBVP}ZICg0X%
z%V3h&QrwD6Z%06*5K?6N+t@^sW$IZ#@XNE&l!sd+oNP4Z@e8prScr{HcAA1)mW2&s
zQrIRj5f<oK(>?_Re>#ef!MP}q-|k(xv*Qv5qpYhfJ6n*2;}|8@Ai(jxO}E8Md~dJ?
z@6{4BiETA<HW~{_ZX1o<wi&t2);0}g1%9?TD6~BVYODOeJlKk1lx}ZIWEK0u52pI~
zIMP`kQr5j0LCkIOps=L_wS}YWquT`Pr~DQ{f5gjK@-jy60W*RNY|boluwj_@FEvah
zI!wlPfh|R_jsAZe&$hnk+5a(ynVCO8w+Fj>yXo%dFj~<k1b?h<502ICO@R!y2RD-V
zeq;+W*ouIeoZ#oRKA6|~rq__cK9g4=!Ov@bFt7E&yw(TvitmH%moQ9qZLbD|zi1gR
z>Xq1qUx$E>Cdk^i$olyQ_O1ub9=3om8GBjGNZfI4HYG3S&gOfBz&v#lj7~O&1q7~J
zP1)=U#YC8n?RZ3~>F6iptbj1wZ0b7yos4LT5fu=aIxvp8^Ji9A3-p2JTrnhwp;n2j
zSuSO<kDtYLfxo|>#hP=;Px%JawN0u`pkIn@4ajW;$Zc!=3bwaNGJ;?8EloBZD!Zl0
zCNvS7vOjWQ4ItdE=7Cj2AFQ0_npIT2$AQA5H_U7v(K9Vp$c?Mf)Vh$sr3fu-4qy4H
z5+UO~=r*P6)OBsOX-&kYwwBhz0Dtvn%E&^{WuT0g;JBvM9O7t~twNMXuYtqCwTS-8
zhzba|A#k-vyhC`Hc(-tmxKVf~Tad|E3GyJA)g%5E0ppM0FQ2zGahJod(Lhe{m&x%Z
z1Jj9*+D^n5jgKP2y9n6Fc500;B#Ug;7eL3OG-Pe?4R8!X0+T`9i8$O0f|9s{66=7U
zMUf?|Hj)*YcC~i&_=EA-GL`5e9Url^KkEI;#<yjzq*WNtTvuL0Fm*=}u&ooag%Tzr
z;QVKa?z60E2jrRCC-=<W=d@Zoq_(AaAA{@zGth8C5%`gCkJxQEOC0lv{JIK{G;F$W
zp-+M=;3@^tp1v8ew{VZR!0?zy<Y!ZYu9z;@$XYyN5dwxAp~Q$AJYp#VI(20$$sB~h
zkQ|BV3?nKgh_=|4m0CJR_k<HkrXZlt3F38WDBx9l`e*6r7qf+4G2t5~78@B(f&uG=
zd&K7qk9oxBMII*l+?LI`3bGpz{8N~uViM2h7RWXupsfkd8d^f2WuOP{LR1V3t^eH+
zy^6pFC%!J+Bc7W<dCVjBGrS>8Oc&lr<cB<h=jQ0|2je5XmDmS1XxDpJGT|JP5KAi{
zKh=Vw5zdPGHYC5Z5t4@yxP~AyC*#Q${U3f-@WPyqF%C<ZPgHyp_#qK=<zE5x4oaXu
z_*%cxWB|vICjj^b6C<AjV!lxlUq<D?+eG778*e_M3yr9N@HGNbw;8YevXP0{;@;<5
zBs%7^GrApGd2p@tf0E%Q+!eo&xW(pU8bZ3OWmX9F?r55zfFSMJGK+<io{R6=`anNf
zObLDy-MrG;qB1wHw3!?O2gwMya%NE4wt&zd0h=CS5dt>JP%8-?LT;NmuywwT?C1=8
zn(lxz5HQUqGh<pq9PbWodnS-v3+a6Yf_cAy^=~4!xHL>hKsOTxAaIvN94tJ1DeyYO
zml%}d>bB1B;`puSd<yQjp3T7d%5O4k{*G-ia{J@RVl9ps5>^;kTAdlU+o-K=g#o)e
zkl!B=0$VrVDN}~PO_?}XxJTq?sJNLD?-F^Kn3^qeV#M%<FtLA*$Q}O|gY6Xv=nE$6
zIKoh?WzN)c2;Ts_)$jqWM4J1l8j*@7#M{Ng-GF<95;`JlS`d30-oLdEkVS%%e*#W6
zB^%gEWGNwb{9hfiVliZ@98KD4axY;a`WYW3wssf_Hr@BovPS3|Cy_*IA3s6F0{<3)
zOAvq*xR{=Lm=YBC1n?U;fex}xagPD7OefmRe)2Oz#|5&|{q1q^-_vAOK=4aaYE$1w
zHS!JaWgda-IfQn+o1u5IHT?@jZy+Eef}d)tRi6jhP*D?DCpgWv%|mWYGoXtaeQh#v
zG(zB#=NLp68Ijh44d#2y4|vSC9yh@EMg)|Nu-Q;u#9WT3baP9t<Nt1f>{kd#L7*Dl
z6~E(`p9ac7;NT~Y67CUiGd$)I*NZ$%+~LcKPx^8{JEsQmUn3yDhkP}t)z(AwE2Gs#
z1Vu~`+~{{B{;H8-=L&pXxJSHhByD3JvDxs3Fp(b%3hq$9hHWp%{rx}bXatP3>j7&<
z8A`Yn!8h6m+GVuS5H3dWHNOM>Ml^&lGP90BnRj3aGwTk>gj*!Bo5{D3`7$$XdCcfv
zLOa6UImUA#Gr3RbzX1Og+6&IlHW}y!+Z&#;jne{tCv3g(R6w9(l;j}6B-f_D52ELd
zwt%n`fm1ngm+&z072$et#E%>Ct3|;LCm^#O>r}<<bfXK%)b0V4YKxSNz<LH|6ut&4
z2f>U+;3(l9vBL0}N30ZinAqsciK~1$@!_%b6MxkB9mqa6`t;Txf$gCWY>hh*ebOYs
zgAKr^g?q%~$B8Rq7sK&*7I2C$Cl>m0;@7^M_>C_o^5aLrBK3f5u+gWt60;DnwTuAd
z3Y`U5gutQH09<9nMe6{66#5J{b$;t7urAnxB8Q+g^D>F#8=n;3_6=kRo2m>l-U<lJ
z+Sjl$%pQeecJIbDtWI}i>l@nsJ<@XzHj>n&Fz%|59$5p7seHP94gnhlA)Z5zBXj6s
z>&ZlSpdI}>>D0)!Wa)9N7H%bBgLdGasW)zE3Y+#FX7o$?wUT5ZU{kS;jdf4IR$Gn7
zpkr}(gVXcCml5Fjq*fN{dm9;w`e#ei6V5lZfWX4CpqHVbEG+rYeW$lt-x!CiIXwr4
z<T7}<#&}9^W#{p;QRoRe<(HiT^C~UZ7|U9N%pY}&Tk3SnuUOIYmlJoQidkYb*&NLQ
zzx8Aywk9-`G8L`^{SyL@{)vwvpi7zTN>kKA0!vK``(u4MhyrU7E5g{#O|*7w8@4=}
zapvi;_nUVn-TTcu)7r+jn7Wh(q~R8WzD;hm1IR?WA|+D?X6?7&_+3+&DFkYR-A46S
zMy=DZ6&+Dl4tJRgT4t^T=KyE9zl;0SvTjBm514##KM(Lx;U4iR!($$i-__!jXzREe
z@mGBr@pa)IF?j-QV;+$o&<dtI0R4{$=v_hr)acNLR+0_~fjNYxpV0;rPh73Ti0|_2
zi9qkf-oicNd4|V4;$V@7iP^rK$PaM^OICpR6kkRx67CTj43Bxln8>vyRv~_=FC(rI
z?h)4;j<q}RE|G_c5BhTAL%!U$?45|y2Aju5UoA5n4jJUP1L7wUSbE~q!ad?X!($$i
z-~9^Ka0|+uU|c*u0|N~wtpZ;z&#9;|--vY1#+lB5yvTg-eu1;$Nb#te1q+JG7dxE?
ztF`}qY<2WVTxGuQX%&+%a(WEWR3obwmDMft(^{`r;H+t|47Fv8oHvh@<<!?#S1u|p
ztD6*CIH$bMxdUgd{3KIrE-GI%s-||Cb0{txUA{P0(_p^#>kPp;2j6!5Jbv$Obgb5S
zDlWuVW%03F3Qxw7f1n@~Ejm(Ulb?a^@hyw$=341r;!^va;ZarPb1%v-UsTyp<&4DP
zXuv(%I=8&KvZ}#(Bd(CbFtxAijl+;YB9j#g+)(aZa-?RoNFO><>h!}3Kad`u9ClX6
zMFq^s*%24uOPu^3dYzHqk$ps3=ABbpi*K<zi?HGhcpV#CG`FF;2Hkd~e0=>Vex<x@
zQG;_9)@y+jam}Qfh6y#*i=2!9m%-#Zb^qGYHux}Ic_qffFsved@8jzWYnE2ea~d)K
z1u`rwudi9Kq<m7@!t#3OgClkP>hU-;@?#4ZIags83M3p~F}7?$eYum1m2E(5K3o0Z
z&t<mb&BvsVve)lD^V`n8?#M4L565AjuLyoAmtVy_%9r`xD!;87ko%uA&BB5>Ahlnz
z=NB*o;`lcZ<*S+X<|~T7Xuys)A4T-FXe(yVueOfE+~P|MF#yZz%dKW%Tx0Fa7FCv;
z&lvtf3Zvt6)wf-6-r~N`w|0($M)<7iMGb=oIfLVZm`KW1GSIiVAt0%!UQlk{oaK9*
zWdx50EUIf}Ei7-Ss+m{syw%?3HgML$SVMWE^Ur`}NkzTGH}_aij6c;e5HDMR56iwA
zkj$;YSZ!=@67c>OP1R5~$C(rm;OofcjVO6VjWem!k#@7@#_H;8>YQZ(`NEocF;waD
zpNrn;98WDyk$-(dT^ZWRnUs9AvZiicdEK04&UHW2#FNd6)t90FrvGwrj}3^Iuv*gt
zg`&Wg|2t%nTUKA?#Eug(W<mKvXCET7FcpS<p|dKe%{?BEAECpi0%JhF;UR`QG*=LD
zm)KhBfqW}NY^c))7#XWymRq)H-U7@Hj~*3I?t-Jf%1ZNH?{mB2sL$WMwF&1WP;vqe
z-{&}=0gCX2_Jw86TPI=_!P&CiNkYt4!3U$p=9MpVGEWA<G&s7v!bv^_mpaX^#+gCN
zPIdV8a2T3Q{{ucz`tE`rxPt|g5++JBJW@}^3u4OZFyXwFg1oU!&24Zl>jf(N8Rs?d
zsbzD}?YyVlu>6|27dg8a<G#@0z1>smsw*)u7B!SX#rvRDP+sfYcBaOiOU^=D@#CEi
zZ&xnHw>zCVQulwy>&}~-{V_X!QFVi<Ls?+U%nwvP2^I3|wk_VC8G&YgUu*FEIq-|t
zpIBDwEVM0I6KJSvZN9x)y|emi@6DQ9v%tA45U)TFI4Obd{lxZK*K^~&HVdCLUFaMa
z?8hshmM#<J>G3Yy0oBOrhJ|JI7dgAZ{f-d3n*%*leN<QeBi?}r`q{o5U5>f*%Oj&1
z+UNHMdgg<pdaYM5&Ti!oS^BFyEcg81{t1?0jhlcY3xs9_zLwSg_{P!?5ei&9wt&Ew
zppFIFUo+hCZIJIH@C}Xj$G65^kMJl0-v-Bb%{`2;9)a(Sv%mjayJs<nrhB;kvjZjr
z1ip`L2ZH^*70~e&Z1%@jZ#{<a0m6O+zQ2pJ?LLGz5q2Q_6~X?RkAXb`U-rZ|M%f=<
zn=}D)<wS%j2=>SK4IM<_+l2Zd*dO1-@+QJN2z*P6{e1)OVcaDl9D`tg>D}=1WehYv
zXvgQ%_+T6#8Rn}b_}JXn(D6C;g9wKa?9V>XYM*wrPoDBYNIr$g^n9fGI;3evxC-G~
z1ipCS3ZVU2KlV9SrsE@|_ICzsY5z<4@aa<fP^^8%`sn<uA3nFq@>oACC)3*>pU~tJ
zmG+TG)`4~6!}PSZziW=NJ6iu5^dBHtKOgz_HhnVMbSMI!6b!bv)!X*BdModYcF99v
z8os)~{@zN#5pGX;B#jR**&k&E2z=6vkE_|=6TZwo=w#(#Y`obB_8A>Mx3e0-{`h=P
zH9{={b@sOzGsSKM-b2FM!|jhU-pk6nDR@td{qde`eBH|2_r=>=c*Eyr1pA|o_dwYj
zzj#LuZ#l8IKJI`o-cZ6cyluh$u0pyS5Uif}ZS6$hJ&1QA*x&!H9dGg3fnaaJVIAmu
z)ga(`)*G&?fb&)-tG60Hzrp+eS$4J!%ghHTMh<YC*$8}!gO707pN(64-Y^riw|2a<
zrU1d-RAc4Y1Ep;CRt_tF8S+;VcoWDW1pDLtAG{0ZXnS5p=jCT!qTG#Oe?b{9S=!&*
znQ_~o++HZ<<y88zS8;7RUItA<;3ZIAy?ht=A%gvV3cp_<P(~Y;g*LoA%Cz?PCDQiH
zmJ55laAtqJ=EVy~5$J;Q$*`G)@Oy+dgx?|DgTTu;8xZCoR3O+N&!Ub(;F&s}S>x$A
ze)N7b@N)$F>kXcU@W1SaL6;S<x9N|zxBi$<FXVF;LSF>?`(JXFk!RZMnP8TYzNbOP
zyzFl;<ogi*ix7gIr|f<}u)qH|{i2)&3u@*%wRW|)oNGg;VnJDDy;EyeoO5e%<Yi79
z_|V8@r(K@m*g=mVbjioXLhYpTrQ^BmS<cn2n#+;R{Mf?U@fDL|P}DB+PdwDhDpZ|d
z-Pll8S6SYmX?e_3U0hyQ&m;d@-!QJ_L4ZBb@efpL?W)_#?LkrPxVoBH?Z{<L^+Xi0
zc8sYhj}pwmL2!NC$OTkg%`$auj^UP%sjHh<U+L85)Kxk-o*jz?ZGTG!I9jLt@`{GQ
znz>rePndPR$+E1drmkT!4~Cpt(^|D=$zN;QtXh`cwUZajGrDR>d91J;a??$0<0B3{
z*jFY?Ti@V;P_3-i{nJle7S{U9{aQF=hv8_k%$}&L^$$bFjT$vP<?L~j&Oaw*P~<#5
zyJ3Fav3|P{tgCYd*et`Qfz3AT60kDEwt>wt>@BdlhW#6Co?*!@R)dC(0Fx9=V8=t2
z=v=Mr*UIiywpG~>tQRYdm+@d#hLwR;8}>BVe8cX;dQtM&1;+JkS7*FubNdKvp^**j
zfQv$g6@p1wW`Hd)vfqN$7`7Koa;wJ5Puiea*{fiSjolAmVmCO++U0k$tO-o~or|@i
zc$uy24lwa@^0C%SJ($>S1QYF}%3f0TC#)x>^p|5rDJ8f~nR6WW7N&gN!9<&`tQxG|
zXt%+IczF^aZE$iI+g2;V8jRha!K4@72dg)-fj9~ib|aX0c}m$KWsNxWlTq>_nAp7v
z7BgNBtL%G~wa0Om*c}5Vc7Fns5<IJHud<eISp6A)kAO*vZdi#5OFr59>#l6DvMeyE
z`Ft>Gs|ICl%02`We^pqY3fl~})a3ggm6c)@DW$&vOzfUlwylTN?f?_*nWtJ-2__{t
z_cY4}Da!?GG`al-O!D0Y=C>)B)Z<Ms@p4F6yVI?#7nr2z3nnQtR5nUw7l27_hg0w{
zjmh_}o;K}0V3Ibmmwd6ctCI_Mv9Ws*O!7FTw`D0{l46L;qAI&UWph=wT4ifhwn1gT
zSJ^9I%T2yh``Fz6tn3*u$+rjA!Yhp3SzwnK*5^zsTMH&-zE)YYvYVChgooJOp=`af
zjmmiVEp~0nHY?kr>``UgmF-aWjIy1|UQ)JO*&E9CDSKPl`^xq!`$XC2$_^^~O4)bH
z{-ew}%hoNd%v07$S+cUO%1%<&Ls^QlKFZEk)=ycwvO&s*D$7)st!%WiTxI#n3Y1M%
zR;p~Kvf0Y!DXUVpK-rsMbIrJV<ZL`zY}miRRvGr@Ikwf_SGHf-C(1roc2L<@%Dz+f
zA7xHo>p85<Q`SjYva+tqPEyuGS&Fhg%Fb5SPg%OMLCS_I%T$)FY_zgmW%<eqlucDu
zs%)mR*~;cAt5UW=S*@}LWsS;KC|jlMGG%L(U8}5F+0DvsQ+9{4^~yFXyH{D8vdzl2
zD0@`dc4a%1J)>-=vX_+YR`!OneahZe_P(<H%05x{xw3=GzEbv`vi~UK*WhHX3oG-K
zbyAkBjHgf~#YxI~C`(b+N7>oR`YB6SHb~h}Wtqydm5o-Gt1MqxfwHN}N|nu2He1;|
zWmU=+D63W0psZ2Z3T3O5U8ZcUvTKz!E4x|QZOZOYwqDsrW%nv;Q?^;z7G;kr+pcVf
zvS*a-RQ8gx-OAojwolpH%HCJDU)d+hK38^7*;mTGQ}!QaPCq-Ex~1BAcbl?M#Lmh|
zU@{k94kl}cV{iuRQZqll4JNZUKT*8e$j$~6S&_1f!J3TrW|eIOTVrIi``Z-Pg2{U0
zFqj;jEFNHwtu6z*%%sQ}WbGaTliYZZh2-(A%DnUBo5fw7Q^6#+N-*)f5=?UY4VZY@
ztagcmt-pa_6(-*aD!UzQm63f2CjO2eVp%V+i;T7>&WefW9A(#mNlU(_vV&k!mX5<L
zI~DA5<0S$nrH?AR0ZitDTfk(!wn=3VtIQj2OR!1V2Vhqi&!=Ws&lA9;{Yt^4%*(;9
zG<LVC>;W*z_bsrsMtf4GO`8uUX{*5`?OHIg+XW`0WD3r5Nvq8VlN5J@U1j_|t+Mtb
zY)PL6TVk}Yf?aLc2Vhd>!(ieiF&p=^8SM#RYYdwLCaeGJz^*m2JHf=?CNS~$IGFf*
z1x);X3MM7}x5~U6>p42o_SS7+(k^!>Td!=RvU`=aDch`Ui?T<RZCAEK*)z&^Dtk%U
zZe?#M+o$YpW$!E7uj~_LpDR14>?>v8Df^EyXOwM&urg0sCuPaXx+*(KSr26?%K9if
zTUkG4>B<Hv8>%c*S+=s#%5s(ED=SboRavRBnaXA>o2RTw*#c#?${Lh4DqErKzhHA6
zo{9P6Xge!^1h&e^TF2swlVK<2;yR#VUn(maZ)cSU!DJ-9J;AbWVLOMFdUm!rrX#L+
z7%%C{{@mGW|B!5te>>ysN0qT#jH5s)-_>BUrTh_Wh0!MB?@0)WP8R-32{1H#hQgcc
zrHRhnV0{r19iGV&*4)lAew0mQZz_Acy_J2U><eZ8R@NSMleF2&CM$cdqt$+<%uTYg
z&dT_?AMr9-*$icqJ6Y`vWy_Uaq3kAQ-zfVQtt*}vp>>5VLF)>;RM{ppp2!|k_MEc6
zDqD(kOJX;%t7R`K`%&4T6RfsI+1twQJ<)30b+fFivfj!DD9ce+pp4f(r7SlnTc>QF
zGQMV4?7mT!h+!kL<CUc=`}N6I`?#`~l<|71q|H~hOj$~It4&jurR;5GX+5mnBxM&W
zo3CuCGQLn(^1Ve_=ToihG-W(PC3Y{SSoVXm%X(Vb!^(bC_NQJ}dr(<nZ!24@?A|_B
z_NX$R#gTlwVG9-3TUolYN0dFMY>%=Jm8G0%y`(8?RK~LllE)%tQ3ynquWW|0HOg*O
z#v?iW$IQTEFk$`9wJbv!*X^R^idNXE{VeOJ>|<qzlqF-8D=E^I{Xy9e$||wm6}vZ-
zwNJCM)0FWABw{yM*(b_Q!YWs^vy|PV>=R{QDeI4wFE((r!FkGtfnmr%HVI7pO;g#0
zYBxt&t!kI4>=I>HsrE)?n^gONvWHdsyt0?Tqy&3a_CA=DdB3u+RQsc{_5-Y4lCth#
zQnx<JBB~vrjMtXME>GF{s-32+T(ygoU9H;dmEEY?jmr3n2C3T?l|81iXH@o@vc0PP
zP-Q=Y9dCLoG|;kkU{d;H!6c89Rd$-n&QTdJE{WYRmE|g{29rD%DqF1D<zSNbDrJwU
z9bYacX`cj>QoXM1LuLO~yZ<Unz_FF2=&bA{Wj&Qez|J;pFhph9%JRUZ1e28&sdl!q
zYGrlGR)UG=wJN&~O#HPdyIr+>iHVf?e%120QBpjj+GmvgMcF>J`$5@H%3K^Risw#X
z(&D{UHX2Ow$W@lF+VjCA#av~VD!WGQnpO4$nD~2I+4E|*TkYOe_PMfe)b0l`X+OUB
zPfDK#CZ2h$D~vC`5G~(#AtkL+*;=)`R#~%Ze+?!nHmK}DWqZLSkGGV)r`k`zByG1L
zwgfp~l46Xq@v1EZlN7U+EmF2Z*%e??BffM_{B2Oidt5}zH~NUbttxv$WxG`NvdZ|{
zB1y|vh)UW_Fp*6Glibb+leVu??P6t1RJ&4TcYsOS^~yG?b`zN7wq4na%6<Tow0wz>
zFc;?qq*R^2ByD$PeU+W3cB7T?ZY3%G43$+YTLdO~)G51EwQIp7?XOh!klH<>Y@2HN
zS`_iuSy>k_DSe^Jij_@QZ4;Q(jqe4K6t^n715C=oH+_g*n`$3W*>;t^114qRnG<0L
zRNEoLdg%%#xeWjlyTQtatM)=L$+uc%*QnhM%5GBaBVdx^DV061ve#6$S7jfn?4UB<
z=Oi`fYc8aurz^_=lQNG{HeR(0!K4I@D!W42uffFgI<@1A7bL}>lsyS1`SSiJ$?cG`
zZ&dpen4~=x=YoV?046EQl$C>tzl+uGdez<tCZ+nL+VOrZ@$#6mXI1;MvTs!TZ)N{g
zZC4!PN~uPGiN8_G#(_zx3e>JjWeZi-sIptY#LKUh-KpB0Dtk%UZq*(Jld^<x7ED-Y
zWv41T3rtGIcM(W#<CRTR?L08?Qm^bvwYx^y4PfH$U6p;P>|@pb3rzg|SJ{c#Hto4!
zQkFC@>8%l}%~du<*>q)dl`RAlFN?v%%XXFRQ1%R1io=!kU%;ePZ!7ydSc*gK=PElf
z$I8wClRWw=izv%hyGhEXs<u?w1z?hImD*ja+Gb@ptM*PXNx^&igl$vyg0jDYN$LL$
zCMEr^vV@UVdlHy<nFJ<wh02Q6Zh_kUR<*xZwn^=tR=Y1%`?a#~)vo6#o7)-627*bM
z3sqLEY`SVMQ`uT&*Q)jwFsadcl|8KNFUr1F_HQsr(RH*f!5PX1D;uq>P}v-1F=dx2
zy9!J^->kBGlx<b^gxbBJvJb$dKmM)kComb$-Wcn-3z)RpNh<5DGQK`SQuJ4CrfTz*
zU7&0Zn54J}OiI5*wJX4+RD98bu&dPWX0^K=OuV$J_7AFkT-j4<w_9cVRQ8R^egKoQ
zB#yQ9?V+qEnB+D<Wuuhks&*oncqvuwY}MAPET*z6RCb%P^{VBICZz4Rfk|sTq3kcJ
zJ*={CmHnXF@HktlF3S2V%LJ1=a=@gP#VVVrGCuJxc2_F9RoNY2QuBLMwh2u9J*e8p
zRr{i{{mOn)c6_eQEk#*>WjV^GD4V0KPTB2X(rSE*fUvt&yA@2z{I<#*J)a#`=7CAg
zPXm(_smd~y%>X;w;f%frOj0zcY>mq929vV<PT3z+`w*Dq!RPaZeW2`nweu#}JdObq
zyB^B;guIksw6cj{k}scw7gna)`O5e-yl5MhtyOJ{vRhUA8)c7z^)+p<Q`u*#{g<-;
zf=T&$=h@uOQg$wwXa|AyHU37ZY_!TIt8A*uW~pqUvK7j%S9TMac)nZNHr2kM?0qn4
zjs42LQtgk*+UHxlBxT*fq#k{g^#zkrlC83_Dw_-@rJAnVi<B)^yQ@{!s_X$}Pbhl^
zO#Ho~vIELaooLIKrtCa0DPI<tq#du?8OjzYTdQoHvNmPgl)VHd{`RWueK5au!6e_W
zRQsc{gh^JL1SV~IBABE-McJ9EO;a{h*$A~8rL0u77lKI%7OQNPvKy4GQ?^OjgJ4p(
z$5r-<vVCAu(zn4Rk55$lFO_`<CSKghww4~4q&P)oeZa)u*{U6++6>i>P&P%ivy?4X
zwiHbASOq2}xJI?>lx<M$eJXndOv<uN*^8=uL)p8k{SZuYJEYnll(j3c{yKn(-3egQ
z=RH)LqAXptBbCijZH2P=s;vi;TCP^c&l-ztliIxjCUx7V>}}N^0FxA7DRZY-*|A_!
z<}NBbO=bO*4OdnMCb^X>t5$6tnB;b;vSwxXs@+y)Pk@QPr<Lsl6ECl;-B+spPT7A{
z`~ML4=J8P#S^w}|lN%C}CTaF95Cp=Kh0Oo~!xCf*WFY|rj3MceKuFr88v?Qf5|mC)
zX2OW0vnV*CqmDW_`p!7uXb^`*8AU{46vwEjji7^qh|9?PJymt9yNS>5_kP}gp3bM!
zRo^;w>eP0s>QvpjX1*Q6DP5!C;(41QT{GZ{S7`K`EnT<D&@#AqU9Oj*ei^z)VvkDK
zvoiGW(sf9>UYD-Z()B)EJdLw(@m&5#hB^yunR~*;>4r-z4K5yIqQtT!Hb-LBaPhcX
zCH6D8;#tmHW$11h`nU{zN`}55LyySNW72g-hJGwv|B<1Wr0bdtwHDZUi-U{Hk|13}
z;o^B4E$J4@&?VAUEJG{c;xQhP*mKf#RJvY+i<icG68l2BF2TjQ{3x-wLR-?l(lrn+
zF7sgNN`;HZognGvOY9bjt&}b|TwInd61x*F&Si(h9+a-XN!JT-aS2|Mt`jo!6kMFk
zhZ56^?0h7{#p8~Yu5=kX0WKbQmUL~Fq1)l&aeoFEm;PaiJtkfM4_v&zy&zp@WN5o|
zot2@V!^PA6LArV`w6W1}aeh;!>t-2RBwaN!bdz-51s9juFI~Ttp?jq3DH-}_>3T_q
zzA9aB$k4Z>>npgp^x7iZbpu>H-DK&?fQ#p2iNuPft5k;4YtuO0UK#qVbUi0S55UFK
zJuY1V8Ty07A{X2IV&LL2x=XB&#D++01YEp+$I8$w8JaCaizK#0VwDoBhKrX$t#mcX
z&|gZ|@1^Tm>G~U7JnrA6>zE8ZC9!wm;*x$ULoZ6#*D~}+iCMSUF*?J=OQQ!|yu|y$
z#nT-iUFkA(g2X1n#nYWFLkpy9kqj-7SPNX7^A72{M}|HL7nkLX3~iULvy$!yNf*7u
zj?oP+F8v_sN`Z@~HcGn2$<VnH%ayJLGPG7=You$v482#n9+aUEOV?vEbhTnj&;zc1
z_(rf(PF$)iiNS~?B(0EGmBe;SY>&iFO6;`69IBm$6E2=chQu-@=9ZX8VlPYVh{P^P
z?4rb+nw>@uxOf^fB{o-LZi#s$_JqXtN-Q9;3lekcG7Y$R8f6lzkl61ewp(IHBz8<<
zmSOXYflHLV#HLGZgTxvn_PoT}Bz9F|KS*qhX{V6^mylUv6%yMmu{{zyCb8oZyDG6C
zB-SIsPNNT8JdH&XTPm@iNvu_3Z4!G~VgZR=keC%|rx62}C@YCgmso?unk4pw#P&+;
zn8c1t?1IEDN-V~*({;eb)15A{nG)L|u?C49m)J>(B}Uo&2EirDN@7bT_MF6?m)KQ_
z{UEVDoos%O!o~R=m)J>(DbY5a0T-uBlh_!EZID=l#7;}>jKrKVHoqQlaefOVwn$<-
zC3c_00us9*F{`u9F9t5oFGFIP5~HVTxxOlsSd+xIOYAv`Juk7xr`Vj)tdw5(M&Pfb
z%ON#a3VTo-UVMJMh9^^17jAP(DdkA;f3t8x9Wjo0<{z#!e1pgn@a+vl_Q6NGF-UU+
zNNX5!hG?LHf;683$qGZh1+qH~i3PbEdL|faFr0LIa1bF4oP|CdMCQVI8ww<dEQWJ;
zw@}0d#GM$5tR*Bl6!|$2I>U<}ltv1>q6$uY2+>u#Yv@yQ%1=sJiKj&PkP*<xAn8b1
zURP&(khPzrq44`eT&O_MOrf6+pGO1@vJV=%>+;XUGVJqbK|?J>SD!#D>L}C;0)n~#
z4c!y8DU1hsUKKP@0iYopLPtJt3kcmBG|xfijx?VL2wfU9DWc}!3He+RH0Y+FNyL9D
z&G3&YAap&@kVfqINf0#15NHN;V3LAM3Rb&tD;z$tjHU}YJAC>fX1i#IoXKeXB#QiT
z<YxTPxJIILWC?!g{-_{Q2V}R%F{kkpO&Ibhkap2}InCejL*qe^&s#v;DC8jWDa8sy
zz6X+pLJrb&Mh+Y((jd~GT8n5AAjfAkkTeuUkY)yuL=<umDFV_O7mCyZIUa^=Cq7U>
z!B`Ih$qhrE1JV|Tyh=2vf?%xE#0P3Lhy;MR!;mXLc84L+DD||2&{zY3BsxP8x~ZWx
z44DU{Eexpwaxn~PAwFG0`8-6i!jNZ(W>6^2F(B<>$R|Md-VjRj9T3{Z4(2ot?SgLS
z4<ZAB(94d3$Y>z+?x7$u7YM!UB8c2Ze8Onf0C9&QzW|bz9UAK)AarMPkk0`ibQ^LI
zIRhk7Xh`0E{sV;W7Y@=ype;9qA-#dLg&|`|If)PFGpz%%ume)o0im1M><{O&y#w;w
z4#?gP$cr72lO2%HIv`g&Ah97@iOZAJ0m%qMic35-m39{J%VW(7qoLrE4oF=Gq_G3C
zvjg&22jqng2+b_*50|IC19GJU(uoEN@!_$0cR<oRATv53^u&z);e1wgK(=&1c6LA>
z?|>ZafV6i&zV3i@f|j*ET%JB1kkk&yO&yS;4v4D*vZ({Ivjg%-2V{Q-<X9N;A$%!i
zuI1hp#U;y^*Sgl&K6dx22&t;9cG-A&EnUQ92jGe(;dFbKSF<~XgMQCCH|`h~{*qd{
z*;abPeYnX8x1O>~py!v%n}a1Ht^+DwTT-<u7;5_#(50QlG>M&u`-_7YDl5fhUU$aw
zbsnUO3o^@G`L2?xl+vo2YFA1cN5r+s0!&v}3OqGRN8qEB;*#o;s&(sKxVDL35=_xo
zyGv>->uRd)8@@TqX$*%zRW&uMyl!?MQZbc`xOf>?k>UoaVsQ}?r9w9!FW@&y6_adZ
zM~zRDrS`vECm~`6vl#-~_oRpChhLIzW1>Vl#AnyR+9<9^x9NZKZge}43ao%GMh^w9
zzZKmM3towCBcb=9+gR{2bQ=*@QQ_Ki8=++BVl27}-Nr&LJhvet3nj6mh2DN1N*lcT
z+(v_qPh3A{2iUB{_2!}QPe4*gibi*x+w}aRbK8fTtAn?k+n}A2xZ*q%mKTtRf}uSw
zq-g|U`)2c>judjOc{qXSoKkfALi13nu-nW-1E^C4uQCq}vF|Yt#aI`_P2MssDg$wg
z`1N#QG!)S;FBuSeW4Rrh2n)Q+>-as!HcC+`L|%v<9zYrfnk1x9J6=}))1mAVH#^9_
zb{yA~+t77)l-saP$u1$c!BE<;0J<c3`f|y0`tqC-y0kC9WUa)ecxq-y57AF4E1T~g
zBOxS+YQ_bXc4Cqy2+gSU)Xl0MHwJePLy?QZ0AsocTYAOya0@WxNRV{zjM|#j{C+u`
zw78s&7lIG2j4tuu(&_6|7QL<DdXPk$RzW3@J65KF`}S(sje9ox>C0)DK{23RhbA<A
zd4Z>PUZ`>qx=6BO6rlt{4WY^4EeApVyp(To)z*Z7B2kGTv02kX8Z^H(Z$XW?gInaD
zTI%)LoZ|IVfLl;ya4|$rlL=7N4(fp7GF>OhWPOg75Wg)D_k)*st2`2wgcyZ|bOhy;
zta8mQS?;O|LxnKc1$au9&tK!Jt*R;MC|OA51zQb)vvK9)Ojk%Zo9U`wP&2ivCfKm0
zXlYUiv|B=@->#}UH0R1-rZ_CAf<i2)nO9R2R5uh*Sm&za7m(ZepO05e;08q8aBd^4
z_HcPRo1EDowX3kYo>E&|vX0%KiKeZvVos?^O%$K>(c{ubXWTgI#xaSBV@46k|Bo93
zfP6QO8Ot1rw{@DUlC=a+mBR{vB`ZFL8fyC@<Tfnt`e5?wAma-@Wamu8H`M+G?@xZR
zfQH(@h$xZ%UH55#KXptv_$j;_u-Xs%K#tV(j4;Rtno_K%Ul#K9rck0Aofby-TlmOY
zeu8J2ty&q~m{DPL0r>91O5lv3V{D1v*s)=BOHnR0A#-gONOa@Ih0#3>->aQ)5j`25
z@If>#Uq*Pk!vVWtvAOkny7A%pO$6O<L02K@kR<1qo<5qK_9qLD{h$l`fH>3+Mqw~{
zDBu4CU7_#e0)MvUFO2aobF>%@2imok?G(Y+O8*<bx^{@(T>$@L<M0%=bUN@^|HD&Q
zc`e!A3S*D5>|hICUi$nHA_G6LTLw;kgI?sI9BiSB=5W!%PlOY@pA2ttHZ&f&cHl#;
zVIL)+cq05;>37*d&L84Z65E~INVbD5p23oTdYkX#g+&Ga9IM6Y1BVvI!RFK5{~O}d
z@@M+L?cGg|IX(s~xwRO%02_Z_Dk*<a%(SUK=JXZCG;CHCPo#f_mF1gZwZ!-ie4w>#
zAqM_jW415X*mmMMs_xDE4sBu5o`1Ske$+1N4OT+5ZuPdhsPU=;1_f=95*<Am5G<J8
z6y2H-J<*&6)0UB->Q;0#ywNJWW@jE2Ju4vt4J#rAp%gYGCXt0lj*;QG6gfq`DaH<`
zgt8)tN0cdPH1OyYN;NAXNEh8#O;5;I3nLaqFGeGYiG~wq#4$>G0>z6})maI|FK&P`
zD<KsWj$q<Mpln0;WK9&R1-H2-P7~L;swt^;wWX<CdzC7#38|~sxoc}y)TQ##VdQAs
z`pSD!5$iHwqehfgl+-GkWnz)HB9Z;0_k3tpWDxLH(<_u*Wr-}rFgbxyR^ug2tErYG
z;LHpjSE3?XkhvCFSApAd6R)F)4EJj$r=sXO-p!$PQGbE#LuMfkOU;-;gW{~}m3Z3)
z-f`kohtSrEi5qsk)t<7NwbhC`l+5v3l44fpyWFl4kD?}X#4xL;x~h>kMIFWw%dDPJ
zQdy;_!?{1kbXBwQL>+ONF>#p7MU0Ug=%Pf}Qv)_Ss~%OQO@qi%h^=~wjbf>xBzRv(
zdF2X49mgtR1`*&BjVg`8%ZJo)Eae?aR5ey9CF>+$L`m@liKTQ3V@#5JYq54$r>n#y
z7vJUhlC~rJI%7Xwu)i)YFNYw99LB+om|O9sU!Tn(=chU3;_XhA)yP*7i`t4Pd+~h~
z-<R#EMRwHi60s{`l}a)Gfp0s$(P-yP<W(Y8lwB7BFs{o3vlFPBSn|igfLeJEd}(){
zG1?>;MN<=@JvaKOcf};)r!(yanL24Cd}3+u%!7DwyP4ln!kU?)rVuj|UwrPxS5rpg
zzp8#8+Zq2=;)yTsinz6gngliq0r3_vtJ;%N!3Qk91EY^sXID<N22FBLS~GENzlyfZ
zoBB^!`<eJZ`KIyvSL(4TnUg2=-=#bDB@JIR*~+=3clPM6Rz1F4ug=ut6ZPsuxF@Yx
zW2L4SrfN|T!~r?3;iD?*1}nxewnKtMVD^Vv-IQ2sn>MwxIi*owfAHpifQnyoLo~Vg
z(zL{;na+dR@em4k|6jse5uS*z9e?R{@%JJOR(}~TlBb*9*ylL@--$1aKfSX#t<k*G
zxJ!3;IymLfl*3bqTedyIB5SAyk3qjwF>qV-o6X!_dh$r2{D!{bE*JhhfzfXPcU$y}
zvtpq2TJ*b|<0u*aapUK9e2EwR)^WE*ziXM>Ytb)tn$YxG;ol)J`n{XGE&BZvb9*iN
z-OF*A9{HaZ82vuO-4^}sV{WfSztm?!(>o6T8v>)>x47G)-)IyR<&S=;6Hq+*rS1~?
z%GU>39Q;#gLP$F8C$t!;tx#BM5K=gy0oN%Q(k7w7w)P-Z5sC}dK)N6lW?h{`qlplr
z;6p-^O2$Y*oi}_~Ac8*la#C5mEYB21A1Z@x`1Zzk0KPr(?S-%X`M-t#<o)W@$Z6^o
zq0lUvy9P;DmUJzXu8q?5pmaShU2W3!k#wDtuCJu)s&vsVI!`xVy824jc<GuiT@i>&
z6O9N3kGv{WSP{xJ>AD#%nkYvouOJ2weNDPfz(tB9LP<th^U#sfl@1pVT_v#^>7xBz
z9{PyH9+$4CWat@*wM*Ao8F~ZS0Z%tsx<<mqIo~X?IdJu2lIBa-GPrnIHAz<%XgI$f
za5-2EYDyf-lvtL;mP+h4iEWTrgT#I(vE34TUSe$$qxzufJwK;%y^AE`vUEJBVvj!{
z5uai)kdYTzWMBKXHX8|DucA7!_fM*U$}ji{U8|z#K@$wKU7_n#mX=B-*zw~N5amKw
zKkY~W<X(ZAjE4F;Ta|{<J|uipUb;%F(~d%slBG{1zPcK~e=5)L57hyEs3qtstx7w7
z4hx8utGfCy{&yrhC1|KG>FV&Gq_J~LgPE=-;y;yU_~(l7lBBwt6&?s*==!rWqv_It
zh5$A~;+G`lsnF~wHw;Mu;toS*18EIIih=A6L+XGWm&i8w>^-dih25B9%)C>^WQ@A;
ze^rRk(MrttZSxZwn&dzkhF&*HhK1QfWEd#M$1scyj-BX*b|FTrL}|quXWOsBtyp6-
zGBR#tW-PK|aZ|`K%ok|ROl>DrD=;Vt?>R&>+DlCVpAyu1B7Q?P1K|#Qr{9449bX_H
zZ+%(#4b={W|J0`e;PqCl1|60k@C*Auj_a*h6KCVyN<(q$u1NO>$VbiodMnl-sEfEd
zMOk`+b0jiGcbyfB&TNiehdI5Vn`_fuXT`c3<x;Q}RwtTk;X|5+@w?87bvxispg8sj
zI+^ZuR;>PzZ{Z_&ciZ)JKVijM^90_nC+Lt>p6+#4tm8=NSD*{~u<}EX3Hi_&t@5Wr
z0CEBg)iwmtis{#)4UnIGKnLqlQGxI6#tVIX2Yor0^8@Fx9=T=lN@b<GQp+tW2)qk_
z<I9QuoXgwVJo@&TMvLp}l3QUK;zlgQhi$3xLZ&bKZ1WV=SJ=Ki`$b<)TXUY4{_gg|
z7q)zeqnJwb6x~;NW_$Ll&4n+fw+T#b@t*Z%pY#<T_isF#TeMPH7^r56Iedq=wZ%2<
zK@n_w*Bd{6<H@)tDv$9SkH<C5VU9DNA_PS~qmJKbdD>dC+x>;@dATc<{J?O|qG98!
ziYKY@+UCu%&1_WSiTX}8UfsMoy19Y!e*=j&{&3v33;0cc_na3|{Ttg`3fpt@Nt*T_
zDeFR-BcSmYp3Q@t`GG?`<Z$-OK$XU;x5hOkK(52tr@4PwT+=}o0LNxHP;_^spYSa^
z=6myee{k^~9Dmregz}spSkHMiUR~x{0J_}9t0TQ<K-1i*;oD`Nw_uWcqv@#UpFH6l
zPCWkb=5FKP-w+S7^mmae(pJvzW!5@E&Ohw?-bR1pUv|u2`11I|(;f?@x~&x)(%V{G
zmzjaDHMHn1{+H#Ks8)jN{An058?P<PkK5VCimJ$$ecGRWcBPUV_y;FF*NciQyS*Vp
z0TGxoI&M1T?ZcnLsx~ihH;;iLBVo_IfdtSP{L4<-71Qz;;0pNXqgZkSrJR2JX;0$#
ztKOmhoc3JEiYm?v%(Uh7zHu%c0*wFOd*uATd3@hNW_jH9Zd_9j3R-5xHBCo~$g;P+
zIs1k2r{kEa@o%(RS$So*^YkwLU}wJReaJ@b$2)8ML2tzQMAV9t(uZ7mfmb;lLITuC
zp9XE?g&2QM8(JWQUl{nzX5@K@iE@rg{Q6ec`2FV1G0imjQMP=<n&D~BUZnE`wPV&S
zN;w;f_)%zcJ?%Yx{!U2a_qO?$S<R~NmGgRYmfF<j$sswi&(8FHSrBm9LU?aP^)y>8
zxzsfqzI}1co6XvbZAf;&Vc#2#ha0>vPDMbo<~y+E1A-e5G<ZJuy>b3gQLFdxsz3KC
z%De!AUGts|9QmFVmG5AB8<q231fg(IqUWAMR?A!G&YF{*SW}yL^W6DU6Wt{qyl%WY
z(Nj~CNM}o`@Ty$2tL%blQ*yHtUDzmg;oa{w)rqUUb)LlKuEdhWIvA*`T!~~jEGb1~
zCDfWN^i76;qr)GW8_0w#xBBNBdA@^zG`Mf^9U}M!F5;wIbi>U{(oZyQjL|)HP#JM{
z%NP1<+ZE5}RBjtBU*XAxfzQ7~doDcbJK%E;@}2g573c#-{z7Z<lHB~jaRfpi*c^EK
zDYWudUaMGuS#f^gPvHb4Hu1jM$_?z~LC})aYSyA@E?l_sT5ezi$7gza!aiRBPW9lF
z7jSX-+&mDrpiAV6ewQQIymT&&Le`M}hW2&%vmIy+eh2g)r)d06+0biK7azc7KO8;R
z6)2N;lJd%LCaw(t_hn;)13}+?%NPZBBN{JQkOd>awF)!{2y+?~$oEm&)IfTT7o3zF
z(s~gAGZBLFy=ttD^gFlFtADZEL6P%w1G_>Z2KmeJCO@!=6QJQoieY8jl}%rx%zW9G
z3j((x)SrEs6*(VsSo&<d$-w4}e{@kGlXGaiYQ{B9LqDhTj?N3*z+osXD(+z-AR#{x
zV+XXONvLs6eMHbSBR6pIDsR`>$0*X*$a}M+=|o%;4b@Pp(Nv$!j%iINJSkZX-@Ulz
zQnSPNhU_-pPbfSq4D(zBwf96z=KWNXD3}&!|G>BCB)&tG#4iE1WM=rYkNGwphYs~r
z`wkq=K0~xVFZ4Ld+ZXddOP<;={>3$e(%Ue=-q41?#<m7;SFZ1-0@ZBL^X2yALyv4X
z`cG?^pu{z0B5&x*&!g@5FhXuTw(XiH1_e|Qh~PQ(qt`AwO_hDEs30$J@tcnA8{&YA
zvL9azZ^s`;{T|LfMm{R(jn=}zJ{}7r`J<|59Q4<=6Pr?@Zf*U4JpF_}v(fK8-Rx9-
zZ;U^2>5;g5v(Lu;@<2w;S&u7gV)mI0?_9|~sl_$jf+h{MgOd6Ad~y~ZFK<n6OF!Bi
zqm9pL-;e}xlV3x@fEQ*A>W^SM{wQO2lCeAKNoVZ-$+8-^tqYi(W1~R!nN7c=SUK(L
z+sSYEyr+FR?dS3k+&Vt{Ox({uK#ib~DB<Je%sGqj^G&{GXZ*{~o=X6o?@F-!vi8@9
z_6Ijwey?NOiMXHpMR`Qz2L5=36(Sm>r=E(aUqRqLK#Tp|d<XLbEj)DFyPhR2Zq;`c
z8ivLT-%IEMvwVdZD+}@i6(GXMj&|SN2}6Hk%T(3(rYO(27mhajs7AI&`wli+Sxra1
z7g#q%hg%p(;p}Y<#rvy}cbP5kyKz6?D&&pL3w-~zl(&ZD?Uo-10P>IX9b8ltc#nrd
z-h5l$36K}kPK7GVD=Nqh>?7)+v^|-$|7S7p;#{SeY~*iw5kirEVe(c`|IUVzdd@#_
zVW5adKr2SdLr6??{V4z!`wNVGU-t8XF*XHi(PN@7c`chgkyH2X0+M2Xoki1_fML@=
z3;MT+WQkP}_~J71vg~<ZcH1<6_H({>0y%sf@nxR@*;D?U=ZEK@?VOC;z7Tcb&u;VQ
zoK8OC`?v3~FB>D~Y2UIV2Y&27^T4(KKJT&g6Y1~zHa_9Y-gCZ-Kj+M}?M9cW<CmR`
z``L5ICw0A?v+BQ_BPOWc5BwWXkH6-79o*2If0=za?%o3vat?cs`n`|(H$I_yk9661
zta0NpWy6R~14!2F=W+v6N!E>L&`Nw8?Yy2F32@8CBiD{X$-nLQ9znXk!rcoO7Uc!v
z5k$n$JpRJnp3N<W1GAQe{*BM(5lL>~%S&LGy+=KWV1!IlUm<eu8IrkWE;<3}H{ZW}
z$Nk>tk#O?A)vLZs$cOqR#V^Rq4g85XAo9jDEzX2PMt63nKeGB<{=%ZbFA<1^L};y0
zHtt}lvTS5q=f)rz>he@}=kE;}-<F|vazW}d1_fr)?=p*|6JyvoAY32X;~~)}3i=)$
z=p%lT{^D1he}H~%{=PzttQaQW1Q^zza717u#;LPtsN1e>8lQdz1H>9-M&m(a{5PA1
zQ7!4Yf%_2)a*{Uq*sqhgq>E*BZ6c;(Dn74p?p&qSZvTDI`2EWmf2f#uHzg25bl16(
z;ToIE!E1xI9fL)wm7bovEslS8!!$tVfwRESJ24;|70qzx2Rd;McCy45YU}cs)H%i#
zVH$M~PS#Lb7AVG+?`Xmh_X}EfLH0l<Mh;q@dA4Gt9-e-p*+^)+YBaXTH8<?V*sy*2
zLM`qEBOw&fr;h*1d+N~iwb~H;)0IP!iw@na4uNW2d2Qvjg$03nB#1VQG=)&-%7O6u
z6xl8mG99F0(?BC>R<>uKZi43`Iuo@Q-|IN%@OE>~>GM`rbBqqXnb7d<5bveNLu%tG
z49f(0Klgprcu0qzhJcM{e239f)$G$<(2X{pQPx(rEO6*sHlAj4q@|SI91L!Jto{WC
zhC|AbW}On<hD2Km)W4A;J|BhI^P5vK0Y?vyozgIIi1&*_M(mI&=RZYz@JINu%JtH0
z%g&tdB6ZxeA-#4j5TV~&u!eq#q8~E4QN=Oco?Db3C;$yg=v*Y^*ry}ib4yVS`!u+o
zqkmkMf7tD3sI5QSX*$#mk!fa(78wnv?;w@6p`i6nB2}@u5-DNiof=q%0R)vh7X#9}
zn?|Bk-*1lTw*A${58~R+8;u{uHTzgC&&^evf6H8ba;J{}&ihV_Gxv}ty8A{9(CrIz
zivqj<!$h`Qn!Vl%ZU3OKGcHfVU{LXU(fA$yc?<GLzmwPtIInGO-p;lGg0B~KyKrfS
zcy1&y<im;NC&oYYCodERR<P8oz)1EVYGc`_G5`Al@?KSod$#%eHD0_%b0&~yEhvEc
z54=f%yeA)S#O!0!qV#L~ss1T;%maCWKL-gO@n@gGlpUzw`9gl+J{~eUyS-lXy+3XI
zva_3CIq<3GHzqTMa5|(wR)aMC+WE7g^9?eu^k~Vxn7h&n<RILiebHZd8B3HmAy3?%
zS5@D?)uU0bdE*afQ)j^Zj5gS?;!Qu1myfjzRxaJR1Yso?KHm1ADLqOZv-)$Nvz+?S
z*EV%y>xE5D6tdlXUqLX-xbGd`#lQ%RDoh{r%*{nteiDJK$reE4?`Djo#%J|!x6hfV
z4FBYXfej+D?2}kR#5IjYQx+O&xd>rhJ`E+^>=5=9F-68ad<x1cve|JnoWp-|O5S??
zd>o|Sw|w9FHl9B4ZGT_R8A@!Eu`qD?0`hSH1xoN?-%E$H+er%?&OS?JNz2E$rT~Q4
zb~JALLHtI&?ulr8>009(*Jvb1dw9Fc>k~JgiEH^UBR`3}klCKp1r$}>J#D^2V0%33
zh{x-@2whR*d)xPV<DqNK*{2&%T|3{SS@(Sj&2rC6QQyYha{vKAn_lruo0j?FnvW3p
z(v}a~i1SMg-nXZP`8^lUzwBSup8O82yRPM9Mm7|Ap$;wv7T+mI;JZqCi*^q&369P=
z%U4TWcBJNe2kH5i!9sExvS?hEgQ2p#>iNx7CQGQP!29;paMJ-~*&H>|dphpUt2B|O
ziTau3w|l<s^S1joo^9NSa@iK3knFRVBA`sNPh-M_=?~@^jo$!1<J;JVzK1o5FZ<<{
z(33CIWa>v!)?h|OeR{x;MfrJwX)siVWRmI;Q|*yJG1boZ9S#iS1k{W%N+3<lwo&U>
z`=d9XGvU_@PbcJ@L52Fp!>1OucgZ=6dB@Rn!{8-;Yb;;RF<<uaqQKjqA$oQ@HIJ+P
z{RE!H>g3#iVEITtajp^cH>3<JC%XpPcTqw5l`R*@2n!vCmZN!A5;rKZUw{pG&}?8X
zLA?tC8vwQ3{{tAkS9tNgK7)!XW_E>Ty5cfwDp1VmS>G=R<TDQ}O_%+J7g5)FSYS`)
z4DEi6`5CdDW8?(}@eoSt1Hzz20}hV)4mDowx4AP)8JQVy=v*<zkr(=*ah)rK3+K38
zD_pgSH8^oxURASJ>7bvPKJ7vM7sdrl9sYJs<Vy8Sq4Y*ldgF=$4+8(!7s&5>=iYC>
z@^ZFU`&T=rRqrj6BjILH0I@ZTn;0Q3)Pjri+;(DJcQleyaeKZ|ec!5AqQ3O>`{s1x
z3FVu25D(fDvokyPC`2i51$;Q$fqYy$oE_7p8-{7#3(h4V*sdR{7o-Dqhf4V_AjH=_
zH*Ov{bHgAC!kGCXa6Y!MX2yn>*NFD2;Xz}B)C}5B5Msc#u$Obf_&KTBk^U~zchF3o
zr;%z}+k=b=-b+4A>SW|ih;hA!I)6-5r>!rc{$Z(sO{E|(kEcMb6seeghkvG#o0ne@
z7|R1_rh4%D@z0Kr8F4Jg{5dhm5W2-tZ#>p@k&U|ASYV*7B5HXnh5<?r!@!51igGbw
zar~fFGy}A6@arSwd4bbFmLdL`PJgbW@mpm>pH2OJg%`1z@c!zHXEMMI&AK3PHz#Gu
zz&N$$%K3L_J;C|e`Ky-vy1z$FnZ;Zj60`MRUtn4lzFxHRhw@30@dr27JCzNIn+hB1
zdnn%V4fQ=0Z}&WZZcM&E%gQYX7$HmnW0Ii&{o)gr=a6E|g%ymNQ9<BDNLXXNLs@h1
z{6pn5Uk^$DDNcj(7~D`FuXxiNK<Mp{oa6?6i7>HJM@mhMGLfZ(HcP+f+`w#i8Qdcj
z#y_mTZDcF-87wwaB-OdOE1d;_F&rUn=UL*PX&uVyqHa6t>D_ou^As>U^ozgiiRnKL
z(w2ygdPZ0K?qhD9IGi8&51c+MYN%^DSgU8d1m{ixx7C0cRH%^@L8m;AApbnWcX&}=
zU@zQ=b^bS0vDev4#$X}>m9er<e!xdjCd0h2FtCZoKr<Xcnqx@gGzS_Z-dgS%@}5pf
z#J;!ebY5T~$j)S+J~XYT3jXi)wnsMfXCi{G84C(1Xjo9*U)_F2Z=TZwgq`N}e6P3n
z1eW~%J7UyBT~7JD#}9nh-?#B3jVZ@{KLRG#m)l?R{TTJtfI~RjJ>ZqbFRu-FE$XZ7
z1(*^YCtL6|%U2L{-p^azb?yHw%Q4FQ#`4DcJ_=1Rd0p;72wN{_U(U-zeeZ;y+cIs6
ztw7M<SdZ;kUPGDj1Cw%xzeho!h^IqkbSs9={QQ;Ea|2U2NXrw?OqRSSj|?#=k@XAm
z0|Qxb%(k|Lm{p{=6>L9Vw7sw$BUiveNOK{LW>83Jn7qI)7<XO$V(xdD$uHCuZwRk_
zgkpXP$K5?g&wpH1xyq%ipa)9A>l^*SfRcfVz}VVErZKEOm5RMEY*+aD!-t*4iiv%w
zPi+D}*aSL+>mvNt>%({0@v~U`$t2HdaQGXoi1rZ}7{)LTP%5lzbp^=uX)vi4n-v%3
z(udcHBEoG^-n>5iI#HfM`1PXfVi;SQ?USN31I(GSVA@PpY-mq>eFA$&JhkV8F<ZXB
z4}*VP6CJo|zPsxHT6kLx-(B+<>22GO`~5wDq@Rd;VZRfOl_2THe*Mol@SBI3Q!dOc
zu<4u)^ye}+?C*{c#q$uFMp2*>z{R&Pn?U};T(B<64P5zvWu9hAcVOs*5QnmKRS2?;
zb}Oh=ZM4eM-(46u3gTOlOkUtc7R_-!y78c6%lEC6hTGqG1O@BA`xyS`=R(St;Ye@u
zKhuWa=Ei?eAnh*Xu2jh?wSlMHu>TMO6whCnh${e+h#&(Mt$qtR8Cv>Iq{W4!^t`Pk
zST;6TMuP$lH0p->eu}3DnqLw2s|o@uF}DJ0>x_kHd~5pRKuthpJfTD*p(6^dLsR>y
z=Z~U3Fn@a&i$uTI*^sf*6N}N<cbay*S^L2lx9x=IeB%Vo`$=9N$+uGT=k|ExvwVLp
zwnZ#V${uSMh3R?uN|vE|UhwBy&#2}8PUXJX=6r2?kp@^p&yL%PS^YKS!sj^u>l=!(
zAzh3k?l&z_R##Rlt4r#YI`3-5Q{ySAQcBjWP)g~nyt1OU#_PsY+SPcz597l<C^j4)
zR$6h;Dh=OXlOG41ZU6l&95x{wqHDv!t_MT>4e<XV#82--{3HDIY448vM(`!S8sdLi
z_;+J4$-<ZXWPY&y^lW@hxl-k-Ug4=g2A0z!@FmOZ6o`$-b-ivk_VX~U#Q)Nok}6kS
zsY|KAmSAOhwYRED!Q=B~HLJzXa?&jXSC)%orNx+((q^G@ySE09fK`>$d5SBm>s+;-
z;@X<EIG2w-L-sU2E45<VSL<?Dl^~%iPi-Zbv;XYhdOU2%QjzOzD$i>u!FGqDkef=A
z{!_VLL%|YGZdS<n$xWp4QI#}0{~_ELF<-b9ZVfoy;zDj+xLr0qXexy}7c+ix6Fs?W
z1WtF|cx`&P?|>V!DQU3dk(<{HcaseCX-ees&`mYl;Ra8Y=zjq>#odiVXTK6ObXf2~
zK|_x%JqkC)rblxA3O8$4i2HZKaY&tR(Rp3CkH;v=DdFA?_s4Kk9$RsY?sK@Q4bq(>
z<kp1y65$%h$*l?Zw}j(pBGHpu6Yd`g$6uSND2a;7`d?c5sL^A_j=M2q{FJHFrf1`6
zO}1Q7YVmNY!fvmUt%m8>wt<Rr1mAz+djj86_{v9-;CK}N(9i$3r<3pm5)NCjr;|*2
zSc#qlvY$@ElS}OBBs{DX%O7MSZ)6-Eal&Cm`k}~Cc+N=#;}|bE#j@v|7^i6Y*c0={
z48|iyDEzMKkQn~ZQLM?3xWSOzkpM=SsDUmNPJ+aTK0=isd9g>NoZ*j9brnL2C#t$h
zIT&$wAtMvGhlq*nMMrmzj)|sR^+e(pCEm+^9;&zfJXD|VYVgUezQJU1C0sC3Md>fd
zSWXjzX(-Bo;NxAh5)zp}xEhER8WSi<gquTRf{$$t5|4L5N)4^)1`$Dc2a9L4$P4L*
z1UZC0`ZY9!2dI)mB7x;Fctyog3d8w>VIx8kLY$G&Xh-oX)kX?;;zV08KS6oZL_Fk(
zBuW=)kr&KI1*3!ti2IQ2VjwD98_Az@<B`UaM3gcfBex}06ucu*#z8_EAql}dp4A$<
z*#v>3gcN0BkO2voDW8=KEAmMRyrNkRP7b9BmHDOtXsdWVqb<ZuG1P3P1XJLEa^q~$
zS@iko$L8p`<p24pxyzzQ+fU8u;*6)FKUP9)ZSP!F`<MD7CZ(pksJu?m-cbvoV>NmJ
zZTfOWdskh7^3akDvxK~7)H%b*Yeis6sc7$s&=|7@4>QlGDp>&z{}!Obbk(x!4;1Zv
z0XYfEDXCkfXzc>(VU~D3HMm4%H6E<iK2YyPiEBxHOb_mBD6Yd(a(HO(LxJ{<_?S}t
zNO=31)vkIE9!jrSQ&OsEXVqttDQ<sLJXWoJEYe6c-P6mfJoG5MqJ5$!GO|Gtw-B>W
z)yXWyp{BdGvZi*PYi&LoLbZShNHbTLtf&P4bAnq&1f4L~J`>(dBuA5zX>80@wDSVb
zGFN+{i52aFn#am)I-W(OJbtOZ#srvYR%h3HTzFm)Bf0jKh_=8i2|+KZ4`D>ok`|$M
z=z(<YvbvBlTWaD=P~{pId*+;;f&5y;zs;;)fb&8iy`ok#(lXP{kSVn*6zv<en$>58
zS)W^5!|saIuBy$9u*!4`jFEmTNZqEJR}VwK6R5|m=jb$Chp@b)6jl1Yx|{K-H{JOt
zY64l5A4HT5X1$FEBmGzX3<H9m)S#N~LN_i|bg?);vN(EDlWNv;I2h%cdI;(0N!t-d
zbvn=GDsz>gzi6K_{AXc!`Z$cdnl+qav?7sU43?0lQGw`5I}wE29u!U2&STP`C*7w;
z%%gfXG`d1fPx_r|t_ML*-3sDp3Us$>deapxO6$dv-h-s+mIOtM)^21;J^{Xju*5ox
z#P)&=MUC5ra6zQz(5T$>q-Q~Dql~<ZAb(CZtL=dKZp4V!s8{Mq&#PuhPEDDYo^0)^
zeSt}hp40{|MYvZ$(Yk3z(9raxlb|X>6R1Ya?%G6_yVGE4V?6}7GoYh89~7;Z;MER<
z%B#S2yQ1|L;APcZ?yXxl6LZum%wM%W+V9bWP#qe>7gVlx)p*e&`wF%@HPRggo)QoB
zqJG*WRxbBxW*Pb<F6dZ=96<ho8g+d=>4>HXU4=QVhqU*hcxtlOKlN)9c?H#Bx-IyB
zeiYc&e>T&jr1LcXd~l>;8C1!ZF&io&Y6_}dAE<2y(uv%Lo}@hvkLk{Fc`9nk>J)vD
z_Ad-M(2`2DP^86`HN~q%@EG00!XtKqo$h7jKpM4vT2)P*OVQV8-?7*RIs{$Cp|92Y
z<K#8es#(9Vwh~i%y<VHckQnODs1v&CL0_kpGtgny7py})>Fc#E3~-wDGb*cG1(oYT
zb%*wQ2KF%PsdN>6gP`hzu2hYyO8{*YP$Fca%TRFRhO2gstBgn3B;*^!+2V-+Pi;+=
zqHoq-Vw{H}ef9)1Pq0Cdk1*?}yVg{e(lsjl$RchZsw_ouZ4ne{DB|~#^%yG7&P-!n
zhBub}A!q}ugR}7PFe(%l7E66JmfC!5KK_A}PO5Vvx=5K5F;^(jYy`zw#to8|ijUI@
zHhD6L3X%sA2c%FXgMKH2$b}$^Y#Db+0xFeYTqZ2S9|am!h6ws@?Ihd|a;s6>35nM~
z0n&-wGxY?WhFsoQoH`{>jiqk={5q;sMeiyw!(3gTTjHsp>&9?HfIzJX9Ww>JJ7c0H
z#YA99rRY8MCE%$gIiP*q?&)+_t=?1Tx*x5D?jBL}UV1AdLQ4^sOzC~}y$nKInNnIx
z>Phb_AhZ>6fe;s<pMIQ?QY*pgG$>hr{c9G0W-`5sr<ABWI*~ZkM5>@g@$kDoKp(-d
zG{Oqjtwx{I=Q3mrA)>D&>7@+IKwn|2;%X+;Adz?`nqrj;SFY(d=$jZ}7MirTwiZ{t
zk|t90!TMtipN=Yd2Ze4KC6F#=HcE*%pk{busRm-H$U^Fo0zgg`Vj1P|aC$1B5PH#E
zekH@HRCqWA#gbw{{J+R>DxB-$+eB|OBB~`St{@TOe~+LpDwSAA-raz9W&<Xb9}g!c
zEJKJp3TPLV$}t!QIG;r$A*tkoY!Or`gMKZ8$c3O?_|Yu;LIulcf<N9?f@?~uyeM-$
z>K{N8a$KvG=|=r67~q{=#n`Yioi%M|tzv9sY?3Tz*>c6$Gz?=B+NyKCVr-`J(vqCc
zYQ<<E*|ek{U1_puY^mi_Lnj$m6k{u&DfV-^pb3pe?(6TQmaG^}G^x;%5}oS{=<)`|
z*tVUeJxGZ<2wr+jR5=K`k$aKx`YUjEMbl7><IZG?r*x&0s>U0=n9p$5DaMH{Ln*{^
zVh~uZ7;g?{L35pzb-XznC%Le>U4KVI##?-nxgc0HWiHr&ymaqFG0T9yzcUGG85i-t
zi~0lpbIlR;2a>SVVPR#^iQF-IWS8miM9iW9tIJ0i=Sf50iiL7TkLtn`HrRAU@6?4C
zpru5OBl0pwF7YAv2z|d}I*b=)H8eVeDZ$98=zn+c_zDg6LHMBK4VDb9otR%+=Bk~#
zPSIZ$q?TDCu_KOCj4mcLdSPA33N(Y)9PhC(hgn%xKMz(s{dK{?NeFH>QuN~vE^iM^
z=3QkAYUoz2St9HWLEXo!;UbWL-qo1v=_f=`qKRUyT#exoH(k{sJ8wF8%R)`lh26T#
zk&7&MBDbM;?@~kgcNgI<Dd@;9Q&_u$ntqmws@!o0k&-)CU+qv4$dz)nNQ_2sSXgK%
zu5sMV;$jGgP}LX>6}?tq7{#YTDt;H2?sZf!N{r;wE9**a;x&#<40c3hkeF+QSL)_^
z$HOcfx>;z#b&mZEfojIMKo11y>m6S*2&#D=mO>cn1r2m^Htdi3M&XAl#yrlu8cKhY
zqdQwtKo#?qj=tG3iXl+Me5$SJ4UUBjf+n7dO9T;Zix3ccn9n`73IG~dtlsoS0YL@Z
z6MaQ*65w<aJLFO^eVgMkmc~q)1@R%p=XjYxbA_rUy%5X(F?B`_H8zbfn#9Js;UzW3
z{*MC^Lkiq7s8%h5I+SHlC33aBoT5-rEV&RwUCJ_YBmvb2BLG@0(O=tWEV&T03qOdA
zmIB=;$*5{#DG2BvCHk?A^0^BeUsxt60F<=Su#7)JS6apa8LJD*fboiDE{cF~(xR5}
zjijPF<5Xf+(iZ^FD%Bm&s!S|a5M@Xrx{@e_h{?t<T5%$!yYOQfE%@JsEkc9B#0u%D
zPAp>?D0s3|cbp?JL(rc91n0-qWv+U%*xQ;XMt{LE8u}rEuB6vrlzj{rr|E4hgv<`!
zI(DUven23mS-HSfyLx_kd7TRl{v{F3!Xodwt9`CZnW>QF>l91>hoey@dq^e={frs)
zVLRdfS@2?r1np+&uQC;Bmej6TBl`L=$*qRW8TvmZH_Lbhg@Ja1lr4kOw~TZ6A43XB
zpIK5@p_pC21CYSnPBU>8%+k(Pu65I3-mg>40kcu0(E85O8uvQf5vP~~Iidog9T78$
zDjP-Stnk#)Lckov0n1rlSqs%@-tawGVulC;#Y`sK7{*+syNTjAyRAW3H*z}7QLj<b
zWLr_p(L9dg!~;req}On=w;z~es0pw^kx4X`dt;o{+{@E<C<(<#(J}`UFI(CnJP`g0
zj6;e!lqY1MTqx(3K|*N8|F7Gb;_2>4Eryx3;=SbVtR_LycrUJ^)MC};lyxKg2B&y0
zE$iddp$LnwB)3CtCc4m@o#Oe;PSk3n-bGnyY3fs;=|t`rEnWQr9-0l)8hVsU_w&#=
z?PiPl(ZUKs_c&qstY~9|#l{ldhsc8q9h3lZi^rYBv#QH$6fIxv34&<bKSDd955g{q
zSyow#(TA_0-_-duNI|!86=33nN60XkD%x8jKsD<^&{OupBH~SIT&MLPMv%m~S4zYc
zV}|xGLC6Mq*w8-EwUI>Wps55KR<sWViPMJI4TUh)2^`})78Ksq-YQ&s4y(agf%ma(
z4i|Kb@l3?6R;&O&7ZigyAozVD(4k7av`j2e$DkylZNF1{P<t2vTM22uXO<eO2bw5q
z4>2<XX%;pM)Ak6z3G)-yz>4-TGrF*~INh+RJ)-@3IOUbbZ%i$<KWKbz>0koTkg64`
z&x-WP>(n-D`B;SU<Qru2%m%4wTeKR+&oI|7poy%uRZv*wddh*KH3}fctgi9Qqy0dw
zNl1yAR9!B1@2G!i+XUDpq9;~>+MOC#2=SnqSy@(w6`r<TkR&MaWWFs@mqD;-ID2SY
z)la05jVhmnp{-7Z<)%rUFo?2D))8Sh+9qtSmRVO)?((cFu5zuR(zsLLQDo&pL%U0~
za+DU$<QTS{nfTCJA_kJ2KJ_IwcXlfA{Mu4QTd00batUvlcCY$2HeJoS(hAq=5{wx&
zt13}Y_lXXpn4aZTOigOPR>|naBrU7w&~F6P!^Ga^3Xc6&U?b4jSke7X09mFRwk>8Y
zyI&=1nU=J`B&%p~c}*>5m5TO&$lxO0e0B-%Vr~H6t@1_5EoNy6ge_)@S9?$hy41w#
zMtex*%bVMjc)Ac+(H5y6A$QTtGhOR%II)2Y1G=Im8lwC13LU`AQCgD9(;8^-w6q9X
zVIa?ZiD8)Txvp|ZI>_J+%Yyl}as@Q5L}EY!Q;eeBVDKL9Fg-P^sC^7EP7EMkPP2|~
z-PVQ*e;<spY~0n7+4@&Y8pMWa>4mx6)<oKHBbN2t5oRSYMH?Zaq?wgWkl8h8Mx5J7
z5i};^d&)zK@kiDdGGL-6i)EU@>i{-&aX+>;TExgwqP9|$#cCpos}s2$TA@)xWmnD1
zwMdZS?io^N3xyZ0I2#rLC_WUuz_5Z*v|^)y$sMD_^Hy<-x&iE>nWv97RiA^?0;Zep
z7*@1tIu{K9O|>~VUH_}>%TUqTx>$R0ngxJn2nzINbZ$kvS*R}uGps7w9Q_L8fCW(<
z?#y+;Z~;s9T%oRem|kWQ#}cDl(Q*XZ(=20`26J?tKzpIH(h&fT&KGEJ<PF*stQBpE
zx&#@Dw*86P5-kB|C7_sTXJDze3F8gv$;#YXS9vxm%Vk1+Xc32~>~9rboj1s0;YAB1
z)ya%Z+HJP_WM(O?MB^)J(g#edFV|>dNka$Lf3VwVr2=q9)KaaLX^UBb^x*2#r4=)8
zA0?h&<PJgAfsi^{cw@BNjaw-fs8Fx5k5wqLGz+D;#%=(-J*>6s9;|3CitMRXj1%*v
zX@Ag{!_dIfeN<E>SfSpSmVZoC9k#-7VI#*L*U3mkgGEUtR#Vy3$^NLvvtbmyPPF<b
zMB72PtHvr=ds1+6nl;tjdZ0ZeYn-;jgnWOJ6;2}q?$TGZy+W=&ym+71A7;gq$W`l~
zb*@?mMfj<{p3#3`p+n6QF|<6Z)1nD>I3*r>kWVa%)mmgb+V(rOM*SK9rn{PSuDitG
zxlIT}14C&o)1-F_2;(POO=bP8y6oG%IE0|xB?2Nad{?@vP#@bxwk<B5Pe{in6^PNS
zYpmcfvf7&(x2dr>q!cZ@4sErz6n<t1(W*6J2;ntWqtU8^h5|kkxn)D71-5p(7`D;b
z#kI{^sk(}o3-3&AglY9hzTMeeS&lThvgEos#pJpfS+B!79y2Q}`L$GmVpUQH8+uI@
zZ0Jy90*wI5G-A2{B57V$m+h`VBN!zx3p2Pn?4i}HwQVZeXb}{}$AK{>AJ{u#u&PC`
z9BaOuLODePTUbGNTWjM?uKFE(B6p*Z+-bUJmaL(BF0~9n(Zh7hWX21!KD6zGy-!7(
zU~+w&$XnM$;T<GKl+|Qm(J}>!Az*GL+qIn}n2!K+zAn=y3kYL?AiBxqGyXAVrA=f*
z8D>dYSuI(LdC_E<udobeqONL7d2N)bJy1E(wm(g~+bE*is%Ay9(-6vwclCRO7duai
z_Iu-5#?4To=)yP6r7lOrPULoKiy{KVW&P9=Y|LnjBkXz5`USN7(QXj{ChfGT0Ua74
z7F9f<rNSG-cczy`@J8aGdgd3oLu(4K3kKbqskls4D;7w+5-&7Fxq5|i$9=ilcNz`L
zyj_1UCy;yu`9W+aK@G7H<-gi4*2yjCZPp`y6a;7<LXTY2xR$W>k7DZ|J_@TkuXRk(
z$)c!fA{gyr0j5xR3_{U#{b{afFdnj03^A|`VzXAJn@pjb&@kAhlA=ZGyj^16RYo__
z+ZEqQq>yI9oK`l!x(c(|7@;rFKB$Ml$f|V~&{(sgBslGj73er~6;{V=WQ-HgjqEVN
zEE>8T0?GipqRLti(@F6H91qYwa*!af3E1ANLFaYqe`h((6lOxLt4>xUEh)>a=6Z+?
zm-hC{bm-O)xVuoWGr2<UDHQTt)HI)QRjBQ#+Gy^xv={aMIH+N+SF|?02h)B^kFs@`
zi5<{sm1?N{q0xH4{}T82Ck>}WZJ?oYr8*pOJCS>Y=7{*17|}Gci)fVa)t0jIi5CcT
zBh{#)B}DM*w0H~X8o^sYjOl?j19laydjy{tV*g0!m>v<lE}=nay2X2C&j_v~(Nyf=
zxp%}<th)&v(kG&wd7(q*;+!J3g#~~GoNQgI)UP3YwCx|Ey<xtBy;YN01+^2V-77tO
z7Wt+C43^!KQjvOKT1T^a%T}LEc9h-QLK&e)@PQi};ipV4CYG?+P7{^$FH=m1dF{Pp
z^5K*^LdkM_vGT4!6U{nIV2Z2Q%=(NevdJ~)dnPa6p^DBg{f|gKg$(uN9<{q0$|qvj
zXMh~!RJ$h<Fyeav-N>01F=iN+V9x3sc7`NktZgkR5$wiMFg1l<v{a*S??|+lPB0r#
z$?5F0NMzr+2r!sCS2g;onb^aiaoy-A)+8A1Fxgw982#0ExRPY@OD{|T^WBP(C>AuB
z#m;y0g}5<5V3^4g$w2k;D3S>4fBxPEBS{cItuREy8zf*X`~~3+DxX9pnkCFsVhmQl
zW4s126*mv{qZmU}zT+|!nwU@KjiG`Qw2OOM9X6GcRb@2EkcP7jP}asUK`;jAAILvk
z@W6Ppo&h6NJ{`(5YgRE}q=<pTJM7Spks^TU==`+rlPdf(aqxotX@cckh=oC%9fUE`
z1yL?v6;8uGhcQZE3ry_l!k%M{Ru{5NE;7+a>BuHdNR+NxfDUZfmZ7q+py@6*4we{W
z1*3|vK*boR#<0v+nQrWd-6*KsCT0vqhVXezZ*}GEUe`3(3ytyI4wh6;hq7vFr{Fvh
z4k8&71nmY|{NoT7HvkwD8O+Y<)Ve(0+G-}QVq~iENR}Pc;kXcUlAsUZpb2J1yx%Ft
zWC35m$&&RU_)V-P^rVaY)QyqFEE0MW4x6|^hMTDipq7j&thn{0tE%a$$7yC*4vnd7
zNv<dTpqj8H;@mTGHy`*kf&UjtEr-<$Gc#klz<y-$VL1bqEwF2<i4*7S`~~g1&)^0C
zV}=NB&`=<>al{XSD8|hqV2j2Mgc&nM)|y~3gc{}B&&DivjEtX-@xUU&PQMwm1#K&4
zD7=dsbJUB}ag%Udrn=yE>|xFoG%suBdIsc(GC86_@40ZtJ*oi5<mjcQMxG!(rYYUm
zL4iaj-Hg88jhqhSZ?t#GH#ql+4Nhk@nP!arT(1~T^gQyv_)0o;AWPAybw>`OZQMRa
z<mgzKM*3DNkz<IyuUm;^rry5mmB?|VoBO(F!O9wWBO^n7Vg4VPLHou1Xje6IJSEzX
zwp1f0^dcu2Fd`?C{h}}1PL0f@&fS;q%SBG2@wVSE4K$NS0EbSaGkTUm>v78<C1x39
z`?L(om}StiErGNg6p=G>I2{9Y*0@XQSW)B%VN!9r$1sCm<Vb!>P-UCSktsY_bGpYW
zk*VCHJKgC@WSU(x?omo)I`?4rceD~YihE+fQi;6jXAptx=+|BKZyBG!q-7a2y|i~C
z=;bkN%@w14uF`=qvy!ZGU$DBPm3Osk?E<z!{EvVPcBD$tF0!^p71Q6+A~ZULnOKR}
zCSez_*6XIGtwpkFUm{F~Sd5q9Oq!+9PAEhmW29vqK~-1=4G3M>!9Z?m7CSY|z_1HD
z1{j26XQR*&#e*=u!9&N?_#U-ow6Yj<5HD!6<_9Q<Wh|YpLfl6f6&=gtRBSJgiqAfp
zaEuYq>AdR+=rj*Fd=3JhI-RHc$+TF4A|tUN>O~pOfrAZ+Dl$eU1-5?$h7{0iHh9x?
zhEY&5WN+ljkhM1?nc$%!A&?j0mO=Jqiy0m)gO;S0LDMgb*`q9j*3Z$T^KweuilxnD
zMjo@08;xd($uDMopis2gV%khw9|sw8YKFb2caR}Lib(T8%jgFvhBhGVodB3et6<K3
zNB=!S*hB@VcBQe(HshTUi5lFD_nz=#(Lknt7tZN&gT}u_K#W;Q8bEtr_#F|yLZ8*z
z#f07&Oun4VIu7kqwt2v*0)k43pgPpf>0Iex>CAY37EC<2l0I)Ij69M-)G}bCz<<h>
zWkk`|hdu2q#tFIA*l$_P>~}oLTZHjbESi?E^L%6sp#2WE;)UTzm{*Z$zARrRfGD#J
zZ)Q}qTZNxyQBGKrgpG-(XKA&}yu?>!bs_<DVcK8u*rq1Lyc03w@iw#7?40u!gSwHu
zZsn{-XumRO_Gzvso7r-<^t{(*$obzVGq8S2Rb>e#tiKir%)6M3D%x*^tu%&D;eRVk
zsceU!#!cHSq!oTAvg9;Z!V1f`Jnk1*SG;&c*hL=@@{@T06Xso_G%@ilq-zKjZ8sAb
zCu%V3s3HZUXb&1~%-S{xc_uqzujBBNWkR-CGN<&S-cEB%hH9YAf(o(>TK4E{;y4No
zU7uQmR%{HRhMgdUavK@B7>%56d%icGyik))(wfEuu7!=Rbd1}W$WL)wY}=BbYcMi7
zhGRu|zKKTqNf+51w}-Qqj(E?iD=MkN!&1g%4)=7HcxJGjQsX9$^m1Yu&rh8RmRUTY
zx09a70)`n0NBRU47F?(DfWA(5oy%KRgF3@mK4Th3`#H;mu{Q@d40tddoX!LK<3N!h
z&E`lV5WbE#W^iPHb9v1QFF<aBGj8U?)<EZK#!I|x)R@V$KgdaYI>s!%r8B}=&Fr+s
zY+ih6PJTGhn8VjtW1N+=yf^0Z$Qe%95JWOL+?bfvl}2V`9*xXe(sZY=?iuqr!<o)H
z*X`5Tj<k`>nap*vf!(ggJUS+UeU`4XsN(Xu5pR*Rlr~UkM&re4tHqqzQm4CQ9lh|4
z9W*s=;plD761H<@EGc3QqRd$$3=76mj#M~HSmi9^B3Gfky^qP2WfY+=>b4-oKcG4E
zv5a+eHVm^HV?D{+*G<N9;||hUe4w}w!L0T6R}wHwV&!KU&(l=N$)`<!=NsP&JAFp4
z^D|!fESfTj^%=!}$L63Y-8)mR10MtFM$R6_xhYr&II9b)YEVs|@hqZ^^Mk;~c@7xP
zN_JG(xWN5ZS331+d`@v`OTUCi|KeumcOa{jW-rPREi*)y)cMlmn^Hgt%pGG~eFz?B
zbvDlUqTau?(|3!m@EuRVaPsB5@jdrjwEM}HEs7DTJ_8ome&zlihQ-!`?D+~KN<2oP
z@JVtfF|oluB9|pvEQ4Yo@+YVd%b=;CWkigo|4Wex%ODAv9vKLbWu=D_UCQ6Y%jQ#t
zx<g%yu!!GdkWzmsCQC{Ly<0=QTX@xo?&RGmyqIR!Oe58+-Xjnl=0@-8X`XsTeaN^I
z?4pIYkGjXW0KZuaKv5s&XCP^(g!vy~(^J|6D8*D<{e$p2OnG^T`lwL3c-qD7uB|}|
zj|rrw5_Ja6K>ggfiWEAL+fu(U62>4oyz1#cf*BqJ6K5=O2A6hHFkrJ|`D%amJc~LN
z5eCxzKx%(FHKZifxjb|6X!?A&hn~w()Bqjsz%x$t51+?CKM1A(;4~?l4(J9<o5)X7
zspW7EDn~?UGs37@GyogSdWU+>r0${SDnrD@wy>tLx0$L(RaV1Upv}h|@NWDb8w=if
zaHy}S<o*wwgVy8pAB`;Ps|=%>8U$T~m9ctEJq4<fK!(zp9QB{-hwy7Vlw^2bXY6wj
zn2c5|yo1pfk}Iq6SS-r_IHP!zpgI>eIn_59&{@Y*Ypg+>VD;TVe%4;zWc~-q&sxYy
z=Km}F$#xTYi$SLeqJuEmb)_ZPx>w(3oUa1Lyp4syj9v^WO*R>yjsl?edjjIekdn5H
z_sB`jIEG3zi7pRd`(o-GO{J>={tom`{O%eDqaLfyxf<0cazCORnO1YSb$5p`VikGk
zX>=G%+hHZIpMv_($c7jJ9?9#c+TLvPq9B>Xc`W)b0F5;856{pkjYuk46#Z(A5<U)8
zNx2RGNu1>M$gZN6GTvWM5b{A;NV1<B<~iu3t8EC4fMvWVzWR-J4x;t29K`UMo}Giv
zx}5`5Rh&*5%S*=fB=L|lXWp!_SLBUE$o=@{OXmLY;`v#4@wC{*qomT@r>2~9o2Jr(
z%H{aJh3{ivmd46@x)3yt6?Hb#g*%KiR?;(snCa^kbtZL@o;0}~C5$)1*stQDE0lp7
zT%W`@10??i_tA{|72>`V(3t9}cx}0&UZDj34uE)mLjy296`&-cXRPLemg_1#4m<?O
zeT$%e=)JsEtOzgDitsY6lx4bp7D{y$GcC`us4i(6gG?!E6$9@ju$qWgGZrtwKMboE
zMXhH3*+@CLQc-J|&r80NxzwrLItlYf1~8_Idb>Ud&{2Z;Zi!mUVtoZ<Bv}H^;`@09
zf|1>AEcw};kkr^j{EI}?WIQjgsJ~&6{zxIiK`hWm7<!aYG(VarVl9L?N$e?lURqu8
zkT=qL58pE&d>X;Lw7RNcEwC%=wwm1nyQ+2zT%WF}-I$fdiQzkWJrqoLmFjvFc~J~K
zSj=4VK~nB3gHK6fkMwgf==pfWp@Z>F2+NpYi=l>#!8N56Lk$x{V`4l{DUldD6XSLA
zLJWh6@j3Y*2KT8kB!+m#p9|7oSLs3Y`w=n#-;#;8Ac^6vX8<c(DagQJ>!Bms>L6BC
z4}!xmrp0ey{x<lNVZw7O>R<+3VZeMm`lSwGjf3Vl$*>cG#ZZ>QHU{895iB?%cQOP2
z%s|Fx7z5s80OK>9se}Il7+i%H>hhgLbp#`e+VSk>h#k2ReRffajAYoHSfsep_HBW0
zcrHpMdHsCsKdU#h4d<7DqM*XBMo_n@Dm}md3ceqL;D9WuJMB6fik%Tfy(_%wY?pOL
zLuoU!st<-jR+6|W60bL`S5>+t;5&TBBcykxT?y;LIj;}rd`B4Pjg0d~#<}Bl59%sh
zEr3EAiEk@tHp?`s!qZqCo<?<88g7=xNtOn`hl01FRDN{=U7PwT0^gO)(`@E^WD-_y
zyH|~p%uzkuqJ1Nqn6OJLIO{!{+6uOGOG6RDUY%r@&7N?rz9(F(@3FP|*!xh_cOX_W
z->+4lW}Btoffoiqx;I1pGdmWL27QrS&5>sqvw1*<??rTKJ<l_!3J|~}0(_N$eu{}E
z#eM%|d@x1PXjMNbp3<T1K=q$&bo4MlQD0+X+z%gG0`B$TxjnC`l+&${?hORpG1<=T
zh49>d9-iAT?A(&17g^XyBu+h_`{t6*%`^8UlcRx<^?22_qJG6hd5i(J?|JxA20)Cd
zR8Sb(f7D2!z781j@~cL;$akQEK=UTPR}uP_6nR6q$Q#2&-eikBjx4=ugGR<IB^Bm%
z+~>kM4`z3W+>2yqIu&KfP4*BxBy0#C8a4zc+e0u4VmO8DLDY0+XHiFx|8??L(!&?f
z0R(&j;6^4x3Og<5T?!S+9wXyYWTD$bgv<E$?279?AO;^Xri8ccso@=Gnrz$9ZQ1Oc
z@iIiWdGo5sMW;kH(`n}05jY^r=A9SLJ3pLvf#i(}E@WZ<MD%3n*&>xjyz`V&D!)^P
z=i)(??pL836LFu0au5me>CErL%JQMGvfN{rCC1`MXx4Z;qNdYO^9S;sBOe=%AEjsu
zy2I;EWA-EUF+z4S1mor7G-G>)`4E};`u89S*;O}O!1q<U(1k9LD@D+_DYk&`hY9$8
zn1Juw0-_k&DdZ1`nvU}RfXv#L;K^7&)myHp9}+)($K^ZtYW-&T#?xNtB~?kql{;L5
zJJd9!{yDypJr(5zDZw3K65J6c!5u<^u>oY~4~UXp%T`0bAOY?M8_fDupp^{WOy%%2
zp-L*h_lKvvP`!v$e~SV-hrnS|?Yu7vOPL!y?78MGcHUVHEG4NbvG*~YwuWi0xPq$a
z0U$KckgWwz*1(p9L;vazhDsL}y@~G$5UfIayhZ<Dhy<x6{nwy?Zm`;68bwQ6&W4@H
zQ@=J;y7y=(iZ~e*$0UodZ5CYNf6a}Cw!;6~5K>bDS6Bk;D1jv0+7y)UjG@v6OB?Wg
z5~0!4Z28XE%qjYN1_k_=%SS7FK3)ged}OF}Z_~5*_QrHIU$Xfql+9VjW)%pq9`>#d
zMt|K<=^CiXs1YARcgX0khekinqDR5JuOzVxr(ohJB_p9-*g2+3w?EO9f|Ee?o@A3_
z%ED%+-my?KDfDUL1v3;3qoEvmxu=;b-5*tmYI_HCEz|9yNw>N2av#M{QrYD`+O*3Z
zo7z~ck7Wz^skq8C*)0+u#}cn1Xng_A*luJrPY{5uazx5tJl|pfqu@XQ04q8!;a?1u
zZqOQrdWk?5^0I9S|6&&#m+&v)E#ohtE#t4OP^koxxjK1{5pM>N(k7TEuTj(&ndRe`
z1b-yp!Iik4gPB}j;%1Q@GbhwR1s!A@Ce%Uyyv&@*b)yyaAI$kU7*HNC_T*sfkySU)
zROzCyZTP+ol3&TJ473Y7nKqskJUBv6Y0XX)OfZ1)vM^1RZWp5q?dlLXafV$Mrp<tt
zg&AI3rmQV?)<KOh$=>xYIA92816L$N`VK&UpNamSOjn?(v5d<yfXStJDnX57{+;ko
zWW$@or14E%i2G^m*KFtG!M!@nw8;uYs))Atk)N+kH5W3|<!^sS^hY80P@24c&Fnz1
zGYl<-Rjh#SC7}yOC_rdM+emQ5BqKrRfhds<iB0w5(Zovj1cykk#8exQmIH-67Eu~z
ziu6kC^d`lq%gseMqe($e!p<O1`>=D#YMIG5Y>kLpQ5vdC9PTkq7ah@K>xOcHMMNAT
zk`=-mDb5_L6(&D(Y$=1;1s5oVO0yM$m^xh+ILV>@);uW%_}z5^+#fE$1GWG>v0ZlB
z;ykmu+fIy~XI39H`FZ9Tq>ZznNc#8Y!z^jK36Q3APqOk|hq4*#hWIxk5FM8$m3vJx
zCj1&9!&u&*W@$YE|8ROo_Ao4`6?Gpo#r*&f40Z#q2r@Xr7{nzZ!gDghF%}^iAiCC<
z=-^Z}gK<nmeTzu~tDe&90-6Pt5VN)pP-3XsdaXtok?ah#l$d+qo@_U_S#_ZeO;KYa
z*xZGf({-1bNN?mUQTH(s>{u~uTC}SOQg*a#hcVPWt8QKmwLb!zqnKrDXvspz7Q;_s
z?ubd|7Rb&KWPxm;T(I5T4Dh~5$%@i27ub{ykE+H{dcA07TgU>ZP#I}kBTIScZ2V+>
z1;|Pur>bWC5yDtb?ioy1dUAW@!zx+rOr5T}984BFg6H9Qh@w6!g6Nh^88oE|)6YMO
z5Xw6f@ZU&-6<nM$7)ye($`zF!w1%D96$F?%y+$DBH4=$u!I~|zV9VW`LsIT2GeqvF
z2<}l5VK35@2avD-;YIJR38`f(SGe7&IKo`zEpy?wsuH&<z#s-Kk%F?eUtf*$1^fl@
zDXGHv3@<)waMVJE;b>+Br&><uTey=bxT}<ud`bn*;bQW~-8iC1T*N!&KaEx&NV6Ju
zP1f7jzTKLYk(DuZ@(4XGQ_m~cQ}I7jAD*c%&eVsb=!?tsAzSrDnbr<{$dR3T;-Wbt
zmt5LmrC#2q-{QG6F}3k%M!jE;^6a#h+_XyfKCs_fvFp^xOLJ4(^q8;4=<`~w&-Ca_
z-J7UKZ)N{8^+YRW$Hc|@l6_z5^Y>X3tVwgUVci!t-D7RQ)1<o&*EixSmn8L)mC$(9
z8lij2_tsfEv>ToJ8Y^Z0#I%w6c}2TjZOv+2n7XX@XuaM_)MHch&gJ=f{n<I^tWWgv
zBUXamGgGhGw}0ZK#!Hs7N#CPd`__)Xsc~1<jQiJC%+$Z#basU`NB`>`iz=)Gpnh20
z_dx23diNYFN&mulpjGdbY2EZBVm~!u^263nYrx3GT5^}A)}(EdCQh;zPtryt+^+Y1
zyVCo2Yq382$eM*~^ll!cHb<}U=)GGPyCzxv^r-S(`qHmZh>NwMj%wZg)#6DLQ%6qH
zJGJWTTleZ0)>}{P%vfpddU9fFrT5gF{d(O#J$B#Wwb*A`EJ8-6uJ!I0A&XeZFAOWQ
zRqx!|h{T>Mn!I@8Bz<_RUbOXj=AQHXgvkSUO`J6EobK7G$E4_Si*#3}-n(4CJyG{$
zPMfdCW$M+7CJdapLmS*}f8&0=YpY)C(bq2el{H{u>N;!gLVb0)o{*TTSC#8Mtaxkx
z<O!4KSgHE$Tled?zpWqIaKtldg_ST%zx|0Y$D~>M)UB=0Td7v+UiVV{oc4C>q=_r$
z=r>s@`joBKC)NNxGgHsm`sA$CC3s`auDL6$)E}2FUOZ{eDZPKWUgCM?Pvg@Ywebns
zux`5=C+Tw@(8p%pJ$&(;#d_WYdd3s_OpiWzkse>JS9{uSoij&wTb@VsZdQEjJ&pZS
zcYU*e&aO$R6Ia~-^SdTlx9GJ;^w@IB*!Im<$}RmWtja@8W%{FcSc$El>9Mo*x~<j?
z$@-<}a{ZT{a{Y_wMEqtRJ!(y|9{<(;I(_{jy+u3H^rSZ2`LW)~O4*r_)i^OV$2(oG
z_Y~gx<eVLs^|nn%TBoBDeudg=vb<;?gS%WgHL?E9hqlkDu+n$w1y-w`a(1MJhSN3u
z8@>LBKHplTkFpj4!sSDQ)h93O(GO^|oO&S@%HoNsdKb&HqH%>@->P@jl2yI)*~KHv
zr&L*~Pog<ZI%=)Z*F0fO+CMRM@nL=EW>B<N=<(L<CoipZlf<1e^)(*dv*=0hl{I=S
zRcno&V8!dJJ^JFUi_pofd3y8{x;Il#DA()JA{OZhi?WvM-bGJdo-?3fUNyiX<Tg>i
zGisk_a-;R6?zIxvJn2epTywi#W}PK$lJ(2Nz2xw^^vbW`__(6dN-D6r>+7DddZHca
z-~YeNy?K09)%7=gZtevS5KNG$QBi}SLdB2>C}Gfq5GIM<BqRX@!xV;;$>d%L$Pi3o
zy&R&UO0_K(RBEk5rL9!!2o3~?D&oYi&=wW#O|caxq-xFc{qA+nx+jFbpZ9s*Ki=nj
zva`N>?X}lldpzgtd-mSeFTjq1eFv->6<j%?48=AfIIFpN(-&KZWlbD@_0`kMuX`Hh
zHt*@`r_oN4qu^I-?71xEO9w`ust+cQum{#$h9>sNBexA4_{y-Wh7TMtf8ZtAXom+Z
zdj$0_zjEBI_61jtTNa%9dGoyM-g|lYK&;?OiUhw}JtF8NjUavG{3+)T96xf3y)wA+
zrkm$iPYV7yVDDKr?8+b6PuU-#O^$qe+)ooQcxcVx=HNjq609Ea^t{H2Nm*%6KV)C<
z2-{K5Cl}-_2zEUjtR2x{j~`e$@5`qj`Z9{<5KKnL=>FuF!Rnj#*9QkTUw6s;;2D#H
zRqrmp&fdB=um7`l@1%cr#(e?PITjBGz_y~R?Br00PZM~f)GG%l?^L@nX;k-4qv}I9
z2d~ad4QFPQy^yy%?<L6R^-QvIU1`$O@QalvKc>FZ&7mI!lSXHz1{VjqGD?eyG^$%t
zsq2M`m&RfCdZMd?zkGFv4JYUrlbO2ArvRyr?Y7*fVobNmK3_pMYp|=2zeC{xM)i%Z
z501}FE$d3#U&zf&F6fz5(5=YzL5?qoyi#%R<Qtl2M>sQeJf$)ih>O1(;n7#ap>%;)
z9$wn~?PsJ<#+2VUl%FxxmCo%pl?B6c7)r&s_&d*X+!(#I-Eu@3B>g_qN~+IHoz=c9
zkl!qcYVlW(M}SX=Tb`MEL#9;>4Pz43;Kkuj6x;q=9AtcLB8oN5O^3fGbnj^6#LU!{
z?QP5Lb|Y;5d1h*{kDr@q6?7|uH5*(ev!91%VD)qLa|-?kKATW)Xhu`riej}TWI3t+
z|5nyaj(5;Iy`A0>t_|EKc&bm<t%u6Y)M+Q?Wwft|tW|D&PH5+LEF<K*$QM7a+lqFD
zuo%TPDKqt2p9qTU>Taz5T7>!I7Id576Pws=awhvTW(&;4Ddyh+ozNCgM+=~*Ff(<c
zFEY9mv?a2EG`)7rdEb1W9@CD|mJ;oFY`2Mw$x=kTT$4Js%tpM&eevA#EBB|`Z7i}?
z=i`{Bkr;zGCp*cfqkv-&iz44kFs~<u3(d2cXZ6XuX`*|!uQRrw+-~DDt!pz=rzCQ%
zwsRVFf5*B*%E1}_p$x^A+b!vRHv`g)vyeV7&UEeq^~&Fr8+zi>%nTI%3=@Y%hVE<4
zF)=W%;LZ0LUz~*f-f$;{EcTB*vEX3e()PTu-AaAgGiAx7I1~AhFCAkWT1J&xWhz2i
zh#0B5nM)I@cLDqWLZ!Gk<A_N*%`^Hf;#E?^3#=)xe{)(9?~EtN&5&^!f}>C-o-Ahx
zd4KTAQFJa>*<7D2rvlk-+sn>WSq?JZILmpzH63J^scddH+@+XVl%asUZeCnY_Hit1
zpN>E7SkYq&YOKk>*DpD>x5F3Ltz(pa(!zF?$4VaCZM2V<$Nu8AFHXR{(oqlEdXm3k
zpfvNl<wA}ZXSzy3+uJ?Wv(+x>85qqpFj~9S3<Heyi9W{3E`Qtc*}ueZE4xOAQ6Fi0
z;|eFAF7n;$QLl3|GcfpBrDD$n3~1sv#(3q&Nu*|9JU9KMlFW?K%+yJl8H-Q?g~n5y
znK28^&u>*XZC9L-Sm7%R(+5h7EOR`j+pNqC1oJHz@2QaxX;83D%C?Y%b5%+CoJ1K?
z7uN#nl?H^(>`D085U@%#2tY!MNv<%VWgSC{JXS719vqV+<<JallYS2yX%Z=bks+OI
zaMUK9;qpoOVHV{fZLVDWzZMRrl1T7IHgt34;{SDU0jrqA4W0~Wu3Y?YgbP?jBn%E(
z8=qJUY_2=;e-9kAlYC}iIY}z)4OrzQXBZg15F|$+$yWxJbJKl(?g$Me`39Dgj1ewL
zxp1d|tP)7F-oWtPAP)$95#&9ABsZZ>Q7^ZEJST7fGC&9JNRX=x43jWxzB+sdS@_Q6
zhClVWxd{&gTxIMI-wg6Qfxicl+=S0Xsuzm^!$BlBVcI=gxQjp}3t@h=c8M`7JOm^x
za2`mtKpZ4$Z5DVp$U_3RgZx1t>@yb&nP1H%Sy@|1X$-3A>9sV6HW-grdP!FH7Jtm?
zZcI{UF3H*$CVke$q^}vAy@iz8DMRI1a7>kS5FBceglSSFkz|%8$+3!UDapDa;A>Nl
zYn$=}LTqSwaF%NZh#M`*7wr!kZAn5P=n24ve2I=FAsU{wh2cBlP~j}Q8{hy*K9bCh
zX0t3c87g5WZW4$n=3=B8Bbl{@MfGDiDEI(`3IM&5XW^Wz6!=#3TR3)k(%%cVNsk*G
zwMqXi{1B<t$;j7|4l_7vljaIPM0%aeC!OK)N%^s#e^_`6`rd&<g^?UHu#Bm2tL1=I
zHXLM%z-b_i53ZYk>s1K8Vd8{IJ~Oa{(fb?05=NgakkOk2-UlL@bg*PW{1c7^MJlR_
zsft@eV_c%DC*UYSDhk4$DLuhD7Y;cg;a*@Et-MgGqyn^rX-h!sO>mfmddT)fcf!BR
z@FF477X;g+9~&ICNskCWM0!+kEolI4l|@X-4<%W(p6+)L{tvj$R`~W%@$DuqWjwzp
zmkM4FH!f*U!8YjtgQGSnzm@ds&w@YO<&h2&Y?D?R9JNXLStR3;x>#>&)KOx>v$l}V
zfJ5<nrY(i{1``|!k=6*dNpCYaYLhk#KSb){TGEFNKWdZm`$@m~OW|J!hdLx_GO&cP
z9u(*|LIjIRZZ)B06nsdaCwLRQTMSDZ%652v3&(^>e=pc3JsbB+)*b0N21i1q8G>s`
z`Jtx23%!qcU%<g=lAcC%W0=vVxcFw!k6ipUXd4`Q5s7HqsMei<AAAPDK^qA_r$pl%
z-3y7jqNBaMaf9)$B1+<lPA2`kuu1*_$L3Ay+BTWC4Kp@`Nqzwbk;$a@3Y(;h$>_$(
zq)eY$e0J!=0TcX>q%v_L;)O*8i5tzE1G37&lS0YbvJRL9gPeK^vup1Ki)972m(lf5
z&P4DW;iV7gg|0vd_vuCi5)mv*2<l+P&r?~ZOl1)06>u1$XM!*VK$5%RDDfVs=qjPE
z3*aC@;?~0?&j9M>SHLiUq(~si5`hV|8%I<9{f1pcvdh3?5=pE$VYqg=#V8Jz7J4B|
zMp}=C{tB!YOsI}_oGZ$PV-qJGB-kcBXmHdf<yW-+{&x%f8{m)=k~<C5gciYDEukd8
zHc$ufyIdB_&MTQ3@YWi!Fv&Y`L2KDs4d?vS`*5^@^h3cmX+7ql*v&}!nXTW>%i%A8
z^R<y)@SZCyl5zvpxG^rvZ(JYn1{$$2$tt*Z#&IHSBODVZy<M<P`hmewoAg8Bhe%yq
zOZqxqNSOiBw+xPiNNX{vMLy{YgCikQe!}Y?SGGgPvv9~Hi3D%dUbhdt0}{;CS_P8K
zGl^}ScDpJ~+}x57)&mYoNvISLg%9h~Q-3h8l5mn1ICT3-wEGJell}(|Do6%E1;#QG
z$<4+|q-za3OhP*#;WJ0OP7BO^RV*iAeqhdHYndb0w#U@AufhBl4hfUE*$n&i>WGmJ
z!+MF0B(AE&`^s5hR+#V-5?59365v`mWI6Xi(7~{rm>FU+#H2rm!(iYw^Gj7l))r3%
zg8M*<8UPbECOXH-V-=sPv5KbxE;0&=Pp04?l4Y^8f_xTg;c}*xUv#qplinxTCVk1^
zs7=ZbqA5e_Vtp9c4&LK%D045joRobNj!{V85^R%xWpLCc<=4=ZA$75;Jp|t0;e2X2
ze;a^f6w;tzo3x+7QJa(>KvRa)#i}+HJTAWTspV8}HXNgn4iapWt~NMolino!5NXWi
zlk$^j#`SVfeT9aXwWSDjGMw*$m@~s0O)v%x(Ax#uq%Rm8wMkzTeu&h<$LOZxg9Z#n
z34m^L`J`K2K52D|$dfKNI1(b|PSw;y%1^{;HYsO|{R0biUvBheZ6VEtLy3{xVPHAQ
zPvOwAynI`y!GDGc4wI}lP`f}ccn3--$?XQ}op%_#RL|kJ5_EwH)*H(c@V@N^zXN*E
z1c&1w=fHN@mIX4}WFu?K4p7NbqAw-Fv$s%=JAUKozX;?yfh5xf#y~a+<bK}|8yJ2L
zMARl;i#@}-nnxrl3K~iSJ7Yu(mERuvJMfo2Kh2{qe;lt6w?pnpIOK?gmSS-5GUOXk
zE=0&>CNxYUhL_QB3ZuPw*7}+rjeir4)lT}BV4JimRhj_l4-JllNS6w(C0%VWdIKoG
zU-!3qZYR%=$ytH<pcCMH?*v~XiT}VMUnG=7W=KS^oN28Tu2&ZSgy5$VheYC(QSe41
zsEwy5ycLEO_TrKy5tP*zELzsdT4q&S7kEb6;_cFQfftv*d2EDZ_DF9RY?J=c;HXWy
zQ}`j$*Ihp8TQ1+z$KOKUcX^~A3bsjuJ*3!4Lk34eq_?_!(%W4=DL<9>_tYWqk21XM
zEj6Gw!trhbBBF_=dLDSaO>me*f)h^*{lF7VSzD@sMN@e~Q=%{NhnaieSU{xr3ARbU
zFgR+H@`HNHkh*x4S15l_-p2VJk3Zl9;24KADA*>=HaKdNUM~C)sf%k#s|-JClk$Um
z>hW~<f`14c8X!fl66l4Ffp>ziNER5V?+^Sz=mt3IBdrl^lYY>Xd_3oYerRwcMC#&N
z(iTkaQigPo!I2Otzt#6w=6%rj0vv24xd%~Emn1s`lI#{p@+uq#;K@uQ4f-HV!ntI!
zNnaH9hamqnFigUPA?)S;Atd&yq)YO?KoSd@VU3p<I&{2!T9+E7#UyzGNtiNZ^N`F*
zl49OCOzZ}I#iUjKnWk0#KZyGm6F*Gyt$|t<>mhiTi4!J~65Ke^%Sk${%Yy4{Vd|vl
z_RuKcTYP>Rwi?b055U3{IL}X<4(A`5>F@88@zP>CEEs<cc*VXPX%N$T#wX4Jb?wzh
zbpA|OWWpmM(h|Wo>8l1uZPLBM50P>Kg}>EM$6OPhwT1L0I1Ku)fqdn%N&jQmVUi?h
zfW#>vRE7%n^3;S-MuffEEBUizHXK_&=^(*2=_-SxHt9Oyhe%yqOX?VY)Fy2<7!Mtw
zFS~rwy)K_L?(#{wRKwqkE8w3A7qG5d0#YZ?v;ODsJ_hH_mHiR;Pd@+az|`o4d-0Bf
z_Zb{hBK<<JO?v5><VS7N%M6Z$NON62X@ScpUG4HoZ*uvhKXdt{Tn6IL)eQJ6;m{>X
zZWKte4i0q@q6V(D@palTymJjJOhQRiBn9gQk}xG-^=^gt9ylgWdY@pMbf3Xdo0RKD
zC`0OE9k_o7-t%xiwTIw+AC6H-KNM_}c26fiYLlL7a3n;UDtHws*O>TQ^f!q2JsgrC
zNk%X-&R9JS43jXDuQ>QaaW))nARQ#wCXE;zwMnDG50Scf6)BgZ_-z;k|3Wy};060~
z%%7UqnHZ4}X}w^Z^fv}aZPG`DA0pi@coivEtoT#=G5q(#Aqk2y*q0iAtlkC3ypg^j
z*d`60C7MV>2IB!DfmacqW%yB>G{fLXh;)d{C%xR|lX5|f-@1KB=PNjvM0MTZ0M7=Y
z7C<kO&*of&<iXKq(tN=-X}!UixB+bteu&h?t4JNg$EX3?Y%oR*&^ui|DOcQ3zt@k8
z;a>y?GpOP=fs92-pK)8^y$6nwN$(SEllH|g>&!f9e}f|-(k#KXq*oXmwMmBxKSat!
zJN|;}27f9Xk|yb6U^z)YICgB$^f!_6Kj0uq(%VRukhqd2oqWR%lQ1b?^Zyi)zBTd7
z$0KBd2$G0kxtCB6u&B~k8jSn3i5m`U1idBjOM{tkEGyF4f^E{L4UXER&j>$6$`w42
zUq#AgLjE$j5xiA!Fo5Kb29_`uC4E`C39LI!sM_)>yx+o|IDmIT%q}K&8OiAe7LibA
z$hyJG&>2O31(6NM{E!Y3Y?GE79JNWO2|q+SL+~n6u4ZF?Nb7_jB5iQ_q+Cx#{a&Gu
zg8w==<eBPzC~yr3C4E)F&nq^<F*51xf^E_>dr88i=>|taq%N){z0~k=w*tM)VBD=h
zxjxBX3EQCW*Kn9hvpW-{K>%e>9o+Z<kR%(9t<+QDtDP4S=`V0Fo}`P3RL1z12qbai
z8&hb4?_Kl@MEY9dlQ2F~nnne^T<oPvzE_gRHLb8G3JW|*UrF)<lOm%CPgbBMf^E`|
z4aRSDphtxtBE110m#~ybxiZRMg_Q_D0@v9JaxupiV#>hJWgptS_<_ngH!f+tV4L(P
zmf280DVN+(zqj<pUpv&%Wa4FQ$%EV&Bb#{t;`+fuaK7wP{B}6o!dacC_r|Xg^lkAt
zUC8+*eCbe?kfE=i$1yTqId^qKd`T36RqqMEggomD^F!e7g7XRU`<fnb%pz$|!8Yj+
z4365QS;7yIvRwVeP!9hpIG@@@un#}5;~G8zZj84^Wzfl&xp7&WyJp1`=&&^H!Eq{c
z!r~<+a}It%OC(qfj;qh&-j;&h!-V_bS6i3io<__QVqI}phG*M)93C)Z@p$2O44#SW
zF?@#!bKg#nEhmce6jP703}?1;(-^;>=gFzx9LUMD<2;VLVU6{Qk9XqPl;8QnmSKlN
zi)ZC|3Kp1y+!k=FCZ2-lu_;$ETlN#=p=KU`k(^J>qZLnJy@FW~k0nZBTa9}z<!H<j
zv=8(SaI5bSl8EM>%@#hnxja$R(`m95_8H~3pN9&WlY=;yKv1v{J5KUMGM;3{W7<sU
zGJhzSfAiciZVbUQ$GFuT&l}^RJv>`%4Z}gX4^(uhbuS3d0rQU0<~d@1KX<(JPT1jI
zx88nV+<4U8tdrZEj-F+4pILWra_(Yk&cfjin%;Jq))IKkrv2PMmn%WJ!Cg-br|y>R
zJU&Hs801E}*#6Hfd*dFava!9z4Nl!tGPtFqcLoF3@M3otS!2w7Ze`=beHd|MKXvZ$
z=<exm*35E?RBw-W?ouv$nR92pQ4x1jKJI~R*k)Jcyz1(iD=hAcej<;XNSb}kxf?Kn
zS!}-!9&RzpEhWjs{*pZK3Wdb;rQAY#9f58u&<%NK`nop{$?-~wr;oUWz$3ogg6C;t
zUVR+Xd~@$sZ_ihrBV>xa+E=1HY(~nNM*v6>^%<bmY&LS`cBgK&S8zF=#Y5k`cEGnP
zsoqNy)hk<y@^M@%oI8+8-AW+O%W><PTXuSTlkNp}>r&)+!iHD5JQ~HVbMDRWRU1zn
z@K-61($F@*{rgbl+@;d&=gIvQ-FoFlelFym(ySzIjOcBr$jz#?7I`$U*G;|Ain|$d
z!@w|)Ui`@KDZflYENlm7M6CM&^4-k{fA7QG``EOZ3kKm~RyM3NO`RJIU|BhL{^PcP
zF66cdW+O}TxjCPDczZy-y0-^?*0a7u;dmE6|KeA0Gm>yCgUf*9CvV<0!<H``_@ljr
zpR~P;A6LBN^7wIuca1=yjE3`m%sU5T8Gl6NFUV(u{sNT0$a+6nP6D0`HwNw+IPc;Q
zJh#GmKOA{{{tR<6K7Ul2fjM~oaKv8`_+!#)IPaQ-junOT=7BtZGkDL#d2>0O>v<o}
zyUs&f?hVJ;63%aM24y*%H{0UL?L*sr2hMxY<Fj7|+<x#<SqbjdjP~k1`1HaPiFbMY
ze<Iw^=abcVI6m9_(I@Zmn@`{`mg5VSnsG*3;!1Nk0ryF)@tSPu(xsKvla@?evK;58
zc+J>%&*Uj1QQZGmdi!8;KPTB<){~aod}6Z#e~0sAc;jDCR#{!cP5YN>-_c;+wLOn}
z3--KTpISN=TeK`4wIb257vTtlC9}uO#Pi7<tD<5~RfSoyTM>aAa+SCh;%L0t^RLC8
z$p&ygxf2IyFA*G?h+F!S6>5xm_*sc#uL^7CS==WMJN8@HTWb;zLj;}8f6Eeg1kIWb
zZ!@`Nwe0C^jv}#ms>ebx1+~=PaI-y}<sI0?Gp4<fTZb+GZPzO!|I+}D2wcbmp3T8;
znh$q-LTl#SxeKtb`wDBRdw*H#-9g9Z=MT&1H};y+{uzTahh$;|F;@@#FN908a2K$y
zG3ZwOzt*5P6@3K6_utOeaYel_qKMq(if&T$sG?+yG$MC}q6Lb6s^~FAU4mYWY(<NK
z#DX=7eyX9rQr=(;fs)!zpdwhCX1%89J)mO4OTiOvi9rK^CK)sqC=;l&RR~mSc=Lfo
zOC3;|;cZm8J5}ycAh*<j%8lH4cx<0)^z{Y0&hSP8O*80PAW3byhOPmcZbCN$U2o7%
zAc^rFkl1n*Nb-@42X5gV1FA4Fk}+mWYW;w+!0T)c1d`N70ZGn_Fs6&<IY6Ri36N;M
z189cPw*zRV(ee@y)97ry4kT#=a1RwNX+Waod?3*>3P`j}1Da*xE(8)SQ6SNBKaj+I
z3P|GaQQi^d9ar9|xRZ$7lR%T9InClu$FmLUhWn7DTd1f4NYbqWl62PrNjX0ZB<1oL
z&>W-Xpz;m_RT^G$cTX-2Xs+Q^07)5aSJVO|CH|VCy^7vev|rIdMTZo9qUduVvDrQq
zkMAbko<LFt+-^`(o2IA%NMig7NJ{sf6t4_^4J4r-1Bt%RfJ9$5UWi2Ba7EVuN%>6!
zlDH25RY|$@@XDn>kd(#*MRR~e?ops0niwAg&69kbhIwv-t_70NNkDFDK#NRh9gt}L
z8Bmeo**(3uZv%-{f5elj#Nak;#YXPWK$6Rg@XRc!EdmmKbwG=a+>e1I=XV1wF}w$X
zmKyXd&<zId2a>p-0ExbQJXHwqIv~+^Cy<N>e*qHBNqD*txwC=9zKKARqu&74m^4~|
zq=f#Zyt6R}E^)5}61fFHV%4q6yH9zqEAKdv=sOh;=@O$akXZEtpi-0WH9(@d3MgWD
ze07uhs0EU8{sWNMvIj_F903x2Ujju<+$6lmNZz^wNq%#cH&J;tK%!+0&@vPEmq1dI
zEkNalcjY;r+<c(<hIc=Z*z%Ny{u!vmgnkJm?XRkrXWtS<wTjjNtuQgxEAKW%cPaXX
z$~~yOM-@Gx=vkHflk)zm=qp9vC<@}~P|A<HeTglnEAMPYeH8Uqxgp9MrYK+0c$J&1
zyakHxQS^I7Pb+#+(QAtS0wnf*th~>G3QhTS##8Gx1`PsQY0yZZ8x1M}l3Y$vG)qyH
zqNR%JfF!k;@-_iUYQF-K)LsT!WzzUc<-P@4E$N=`$#Kskv0#s)*A(qlv|rIdMTZn|
zu0gbXqUfli<BGmhWMz0UY(>e6QWd2u>ZK?{Q9nfk6lEzIs%V6wTt(v)O;p6qrz9Wg
zih3#PrzlI&U`4r##wnVpXp*AIie@O9qiCU`rHX15ty0vW=oUrIitbRfS<zNS4=8$A
z(PN69Q1qgry^8iLI;iNdqPU`?ioR6zog&UxOF7$$k`<*XN>`MjsIQ^{in0_9RWw4;
zXhq``g%wRwG)>VAMe`LcR1{HEtEf&<gQ5+JnibupXtSbiiVi6{tSGMN6GcZA{T<KQ
zlPx~=CE;m!ib33zy27B{cwU=i5ch%>)W5rT_ge!bca5K%>cyzRvybo^fkg8fJlzO-
z14u$|>*1lx@C+iMt8r()!KAhUsM?@cfaG4w4NT>}nu)u(*pde%a%+^g;Vkc2^e!OL
zd?D_6au1!1JJ@ogd8MLE+%;+q5C7bDg~BikoI6`rDsPmcF+fA%I$QVRKYg98^niyd
z75zfd%|S18HA-A!#1yqCdifMD^c_V96mf}<#QjpyrMAZ#p(q74D00^+;%D!|t5LL0
z(bJ0fnZL+&L7fXaL(vdL1&WFk6`(~(41O&wXsM!AiukRyg!0K;&_B^O1o0_X&_c8g
zLCY20*VE%Ys%UAN#~X9HhxqN3#2tv1BdAKzdy4Ku%aKqk-9ssg&Qo-Uq7M|Ejus|y
zdn>w1(MGg73EisbMMYmJ3ZW&6+_j2UDe8mPDWRM(6O^auZ;H;xGlPU?Dk@ZD<K8Wy
zIf~XP8ixC-gz|?vL9-Rzr|5TzI%jxt^A){-@mb<>v=ziLR#26qmlUn*<Apw@=#Zi#
ziat~HouV82dU3zI$U~1_?4gnUJTy+xBt<VPdRx)o6b1Wxapx$yZh*(TUC|#E?NKz~
zQcrHUqRooFQ*<eAUv3Ev^w8Z|9{NbpfozZWv7$bgdAyety{%~IATM;RqB2GQRP=8}
zR}A)IlmW?ob*iH4fkv1S?gmB6fW-QB%G;!97m#RqNzuz1x(`U={zZA8DGCnpQp->@
zP|+wwC5k2kiN4v&o3FeY<<%;$UU@%J^oXM00gX2K-L1T@fFwu%R`eeY?R>ds!Rd<n
zDjEqS<u_4Lg`zn?qItfeH5%HWyjv9gR6`$E-cyR6)6hLYQZDZ)`dHETDwlSJXF<B6
zUO-~=g+QWZu%diLGl9hVN<|BRByP3J)hW7F(KeNP4oI}Tpr}Pd_X3Fpe^%ZRMaLC!
zPZ!aWqNpd3*wPC~wD1TLLBkYHQn>|+Rw!DdaxvxIsptVkPbvD7qJ2PO)w_z~8u~9F
zX=_P2o~1UB@Y0o+10-5TD$3K)2|$vgDT?MRTBmZ&ihiN!VMRNEB#jpp?a|OTfh3JX
ziau3j5A&=)Q_+Qr1}Pd3Bxw{XD$>xYK$6A+MYW1<SGl{Ccc1beQ}mLecNHB`^qr#a
z!#$g?P*k930+7_gb;^qXiS@OLR%vJ>kXV18qNg?Vbs&kmPtm&?`Zpkn`yWMTpy5i}
zy$nR+Uan}EhUNoF+?k42YUpi168CmRcWUTXAc^~^qGuJot8)JU5-tBy^tpz93nW^)
zj`Yx3iuwUbNnQyAQ9LV$70psKPvxS@Tcy19%DYR^{fZt}^pc|eKw|SjMTa!B6-aD8
zuILmz>I?6DAhGmPMOP^bE4p6MY#>Q(o}#FRI?B6E(d`<#8A#H7NYRsuURHD%NYaQa
z`UFTU{YvG6S9$t+D7qL(<gQROPEn!C{SZjfSfZ##<yNVjqv&Ufey4IRK%(VUMQ>>6
zejv&3-xVEGbZV|=X)i@tK%#H3qM;g^2PFEgRWw~ujmoW4)U4=UMcWlUtLRN2N%tK^
z|D&NF07<$>6@9NLEziqGZ$%|QqOV-hbs9PcNc2@Js#A0;ko2Q_fut@UP~H>D`xB6)
z@us48H1w}PlEx>BzEO1AC{Od5K$2Qt<&6Xq&3TFnH1rxE(L7gqbt>1O=oSs#2qZDK
zDtc5=i^}~4NYZ^@(MKBkFCfv<Ip4FsFObCOr)YqN4gr!Fh02?)a`P1ZP(vd?5@Un%
z9#pyCDEgg-J_RH(_ABqW%6+GZg)DX11xR9~E4o<GD3vQ!G*{7bMYkyW8IY90FBILY
zp$`E`YELS9S<(9{_qn34fkfZ8in<hd)}IO_p{FUDprMt@TcBu>hAsmVTQ(~1ewBMr
z(Qh>LaUhAYThTj;j;dS|grsy&0fO1M_nfJ`ixmw3!XHAf2a$ZtQZyGxwA`oYbq(F8
z=v@sx282K8JAJH&hALVBBxx*H-cJ<$QqfC_4g*Py&w<32uYn{-$>Tg;4<Jdmm-2c8
ziQGjRnysNjHMCH9#mXxO5`D8YbODgqvPjV@ie6W=4@fL+1rja&#(TURAmNoMTA*l|
zqD?@O+IB^+DEeH{cR-@=)CnHytteB`L#P$emkxx7LDW$%<-t&wH&J;Tl-I1hgUUOk
zytIH9motHq#$e?QRo-OfO;cX8^6pR`cU=?v_9~Abs0l9w<ffs#p~|~Md3Pyqr}AD@
z-Y3dCs=V}|mqsrjNn^6|rYVnSr;05Hm6s9nczuD~xXPQRyv@qnsyu#Q;^tR*X`MV?
zI*_YRdE8@6cpH@0th_IkcU*ZBJA3-VKoU2iyjtaLRo*t`y{5dq$~&&S@02(A6fX_#
z4<u<URbE7SPblwc<$a>Oqsq&&J$-|LL|?7)Rw-}0@*Y#(apirdyu@!J{VwqI{ZY}Y
zivFVLQ$@Y{crlP&3sVT_Jtsq$%5^QxG+&3oi|hL~%;g985iHK6IN@6F`q9*lMy#>~
z%7sgC9)yoO$0azAfx{i#5}fD3Nrg!X&Kuxlwc{KBhrg60WIhIGX*-#(z}eo81LMt=
zg#T#pxVk~XgYERN=W{!zgyueg-1sQL$pqwXLkZ4sKyKe6oC^1#N$$LokeNW(-Org0
zPF6e40&tq!aU$SsR|_lLgA4i9C)FW)xYjZjDlEZq0J+gYf^#PzcM3>w?jt<S&*8Uf
zTwR}#c?ys#nuSy09^IC8hR0#*yAgP_9cLdnT-++LDDyrb*QF*np8#@|XoB-^K(6FW
zaBNf*S6e1Hr-PGwmY?$jaJDL^0w;>`v-TNh`(?PLCl{I}^jr-NS9c{i+^UpIUJ{%+
z;P7~v1ZOcgTwavm@GIif-hNID9R8v%GMN#ahr|NFMNTmA<pubLj8L!4IWr?OT^}Mt
z1|7smtB933tER^DvE>HaY4Aeu1u+%iqK06gP8zx4B>vs!%AnIhhAVfz>!9sXSBC8?
z7~ofX9Yn0BTp0{=kjX#~;T^aAwa1mg&;^;>`{1a*_5$#|<;p+-WNyI!j%j`9%AnIh
z=KPb|^MxyeAHQf1{<{ny?@Dq@1RWDHyeoISQe7EzL&$Jj)b>{<K2u**x!6?esYV9f
z>Lk}W(8G0aOhlCAfWy^f3C>h-Qr*^)WL4m+T%IoIT@vdC*B)|(!(Sr3OE`CS;5^)c
zv$F%|oerFM2hMjLIH$33xtFAVQ3uZO4xGsyI5%|Q+|+?{X9vzh9XL;Q;PC5K??S0A
zs$4XC=?ahGmf=V3WEjY;OTA0-)tz0$y@YdK2hNZVoG~3ZGdpmWci?cRRqv9t?&-jJ
ztOJL?I(wJI`f~@)ryV$*<hEfVN~|+GaM<U)OJs(3;DkGHe%OI?QwPpZJ8*V%;P6S!
zyCn5P9XQ;))4N2bt8Z`-&IKJfquX&R;LDs-IV(C3_qJKpmCHPzSxV=I@FXseKeu}3
zBK6?Ae2>30I%_dPYJ7ektfl^$IN^3)!rR`5ZjZiS8R21V*Dj5W!O{h*VyPU-oiA%*
ztO_1-W)?bBtgNhFG7Bf6iO>D!T|7*4$y~wtCFPUy$7K#4Vqq22V%~@f%~ArZBI2E8
zUomqf77Sz#8H_b?6&QJ3Pc}SUDj|9jr>Ix>Pcp{>gviW=-lGm;V95m5Rn}BiM=Gk9
zEMI`d3ceGoD-tJ6^BKlHX|2L{u5pF$B;pF+dB83<=lA0FJ`05<b|ucTrRnn`^M&31
z>{VnPN3oifZWaDBPsMsYdXmo#3D3#S6|L|wMcoOfSGx8~n0F!_kDaT~Q|n9}a&?nA
zsIEfJJ<J?3gjHk?A_N|Ch1Z1se{YaCEL;$&{4Z;HE8ImH|8*g+Cvd_lUXP8!p2Pa$
zfs|<bl2mDA?$F}OnP@p4!@q9FV^%EV`q>KeWOV{>)`|%Fm@=bij1}hTN?FyFHPMA^
zr>GZiU5U%9tgc?deweTY3t_4!;(qM$+>{X+Ye|*qkB(-wWYz-o-V=0tT{aQmEmb*D
z@?_a!uTI321wjdayYv??!QCzqHW#P=VeO57)sQT{Y0s0DL_Sm8fx^qh30>V|yRSKk
z<W4dMc(RFtKS|k{8cnE?3g!@}JS<Msk<e9HY|aeFA&I^kmzXE3-FDjCik!0~I%}b?
zWNQ{Ltw!9rnrdET$r$xu^fPVe#8@tyLs>$0=Dc~;mGfpsD!s8+gS;h9=m86A=67J{
zp~){!^Z?h=#nDBT)eB}<v}*}mg@tk{#!4uj&goU3%g$edXC9B2UtI}XWPo&w4?~lT
z@Ny=sCz%(C%$#k8()N6>qmPE3NedSFPOtT1RxClAUbtlD9J5H)bnLF?Aj%~JGrTK%
z(B;{KhF)>m6+<&J246<5{J(tgU?Y+}C~I(zK{L8e4Djh1Urb+$tt$))1^n+*WaZ)+
zU^H&^=@%IR3$J}v2Auz$N<upR&!wF2y{e;xaOyw?;_DXw#rKE?zSQ_H*fB7BsGnmU
z!%NN0cp>R^v9NC;q1>RXc5+|gm0%U#vlk8!Hs278+~CXF$qhi<8}J^z%$37yx5y2_
zr!2mU>yz%rTXDOK>0ZtmpTxBqa8@6zL_ity(sYNmPj?K$xF&qsiE=sZ^P2&=3;SX<
zkSm8I#lGxpe5;hWYLQR@<l0@dFZ;49{5+=n%!PgqFy#F2U<^%z3%YH9ese*tG<#?4
zqp}hwn%sD7&3R6#-8A^JlxNRwN`8qFqq6@edr!{i(SKfubNAL>cm4DiN@E|DmzC6i
zlI#>DJJapPoohyB@5?^6KGd@*ne$23g>8(tzD{xWuI$&H!sPyMHom-ef9$By)KvN9
zb=Ox+e_?JjG?m1cLwo&;sj-6O#+_@oXYV}nx7e|!r%j6}eS#&<M4@ANVOsR`oR^)|
zsSb8*yg%j6ohd(lzTe)IXLnLrb5rCZ3-;B2V$-<7)ZqnbkyA|kmtTk#q{a%9Uv5oC
zQcZuLaZS(hzn7oBvG<(GcC6rV<AIbdJ546SRaX2j-$Oj~A4<kTedDjgJ9SEx72A!l
zUGTu_#$zcBROpl*c1EQ(?u;ZOPvQ7|66zEjZYelq;xA2&)!KDKgDDMny5dulTSoCk
z+iE-zS$1t~^}!<-IJKczFm_`Iw6QI+Aa=epEH*hbHa0aB8`k)8BpiD+9CmI@EqAU?
zE@~@1<dhzS3BC6^-I~&NJEKC4JEPAys}DP4lVd@c5=2~Q7;G5Zl5bw#8efi0PL2(O
zy66s5US3TgQmi8R$VM2;j@LS!<s{{4>bqC=f!G_3`=Tj`5ZiAm&%{Tqv=kiPiYOz3
zO=+(<Q$x;WkztL;BK@S4k+VNJh4wW?<xWXzv6G)1ZYw>^Qrj8X;hfWWEc#a{gl<te
zw;9UzLfMgLnjSN)74_p3*iLEkEvYTJrmUP&Ad{I}!hx1tGsd*!Vk!>{B423s>ND9{
zZ98LAoeDImma!(HTQOb#W2&uXtclVx)+lH^5IyBcR?{*o_JuR34%3B^p0HIb^WE=E
z9Mf1|5e(DcY8h+n@XF9%UhEv`RA{PD-IaOVX$sA`Iu+IU=@T@!Zg?;<u(-IqtZlDz
zwLKmM)O$~CH5y?u3TS;W_L-}=bvaw1l*bdSog=R#`Ul&4GRg<-9R*cX9FDJWd(-pT
zI~(^!g3c%#%|Fqfn6lf6d(p_%skEaU6<JnRUIbHW*bT0MzxVFRQ(;tD`TAh|ODVO+
zohc13LxEG6=7eqJ<RYNhIJ@q~fEDeGII(fbusXKaWESNq_TFonb4o)!quQ|)hf#yE
z6(Ka`romqi9}|kqbxs{0JGJrUHAO~OCUO-kJrs^#_ibC7lOIBfjB`p4#q!a_*WPU^
zqKDhVN)H{`z%p2x94k18IA!sR5eE?<?-U$7vZG~;siq_Mvwp7$9oYmEu1;=cIW@!l
z?0t<dr!<UVseO`Ml@@RP#>9^8c1qKj-vJ20fP$_y6(lw$*(nJ*`Sz&T8nohANhrE9
zw*N`CqWGi6Rt$>KIc|SrULq;9?waJH_-&#Y-m-YTV5HIdDl%dOw;}`?D38x|O&Ehz
z-BK$}E-FXmPLz<=S{hXn%GtYW1j^+wMgWv#sKp6~Q0GIP38B~-$SNobIxm(Ts}4Eo
z$ZLLVX(*PSy)Sl+-8zY_D$R=RkADrN$kCA<PDyg?3^p3byQLPZNj~x-|2=KYe(m30
z(YB@`esiEl;6l4+x1fEF-6L>XAhk2@K7Flj-L3=+cbpVJOtzAY?}@#P*{3^SWD#RK
z&!9c5+i(+L_Y4H>Zr$h&AgoJwD|o7e4aJORS9o1fdb=T}8;ac)5%bhU%<h>`#F!T+
zXBbtdcG9@mI~5*{nL5}P(&O~N#mVD)GI5;FL;HFrG>z{my3!DX(K|8xbT_*3oWb8o
z&U9mR^3ui+dd3(da+aI6@to~f&VtMB%%smr*q4Ni_VRgAu;(TWPJ$OxZC<I+d%n+$
zxEYBQ68d|)89<pc$^|}!h|=fWKz7gKKxya6-KLnb>)Xl7Hi8#+0~aUY`2}!n$Y3|P
zUnU|ZQo%_{hz5l}FaiLV_#$GmZ9rz=s${R467eqWhSqc%3Nll}QIz9-ng_ahL>W?l
zmRmlqH#<=y%-v-^FN6oVd8aT!2m4K8*$-hJ2`*;{4M8!$*ee17X%|C#qw(e>v|N=u
zg7=lr@g#`{DO{ldwoS;$clS*Q;QaaO*#pf3{%i~9*DqSJw0g<B8uwKCO9x?h1$oxI
z3g+-i3UtN`W3`oJcUrh)@w^Q4kFRP;_9+QQbaBmsd5bIOWSEdpCz4<&6xsj{okF48
zK{`*MHaq0Lh$RJZEW8`ZByft^2rB7xJ^|SVrzK@vf`adY?*y$Rep6s2^|89n#v2m$
zg|Lz?5KaIbOco)GkHtxSLS5%aY8I@lM3)za-F5DQ>KX`K_(y0<>XQrsE2;l;#*@m9
z3+@@*1tOU+E$Oliz+D&fH=v|J636Pgl+%o!H`LY4Pb3X)FiF~7`jQS2Uvd}xGytEZ
zo@&|L>B>&Jh?+cGFP1>~=g(ZQ*h=ar$%L#>h*?I#;eS#{N?6OuE!;#EB%M+-A3Jzt
zoFH*Zdw)_VkuuQ(o&AO0U8erHDHnem2|O1F@aM8qmyWXnJBjd%CEhP~v9M0Xt{uy*
z!1FXUb?G?H_yk_02j>1B|9b?OsoN3hw3`7=qc4H1p6)(DI)4=Sb>L|Tn|~=IAsqNM
zqd;2(?4ENm*W}tYcEPgB#imIFz6~(Nz*xM=86&?VN@4K_{=-yLSoVSMsp!=CR-la_
zjlc8+0w(6^(pUmX#@N$qz3GWS(AaSXUrBJb7z%<Q6e@)J&WYU3gV&!YcBDjxZVNOa
z-29Ua-R5Sf80<5vD;MEiyJMElglQi@Af1JtZp!~GWARzW;&f!=Y-6q1)=O+Vd)5NC
zNS2vEn#;#9Uc*8dwN05UW0@pvw0fChSw?gC>US=5E~jTYJu9t1Z4<yMIO}Z8)Jjp$
zF?y+!uLeJd`?2bs(@yUks`?uoRaH_I520ita~Z;}Wzk+O>@`O9R<K`%n~Cr*p!z)S
z_mXV|)=>FR!8~s<eN^!XeGI<L4c-OD`HSgeaMH$PW4I=;*d(wQL0`hX1K}c!n&-O-
zEOxCwpZXVzf{+P>LO0Mh+TFlpE2FxSb!`O>;G}ol1kpk-gv;toyT*ad&Ju+?Z*k@F
z3N!u$4p1|{2s)QM3<80JY*zmOhldAPfxoaV_e9nA=Fc1Ay&m2RYNZDL%I1_5ozaKQ
zZZ>3j1wQ3bczxG_bqkzzVFv!OtUqINo58xMA5!3#P2<1_e9?Cjy!;ul?|6V#fD3C8
zaPbWIyk7<TJr7R?+)v@gp)T%4#`^vXo^9~-|2F_yQU4GkCv6N}+#U2o1YCR;0KX9W
z!Nm-T&bjabYUVGdrQlw|!5|-Q4-M%O=(`=b1_8JR1l$=dW|h0gS%HkeR)oI+$1Q5U
zh6U%#kdwi}Mf&HAM8rUbS7F|rz~k8MmF8oDt=bA)7TAl}6JgTJ&{~3$KA#nKnX6N3
z!VL2Pq<HCR5WE~ts$>Lfh+Ey@{_i)K6XER1R^Un*SHg($INS=zevUK-GL0+EI0eJA
z`qJ<#12==9{IX1MywbGMq>XkqD(@=ec?Yp&w8}Mo|1!5B<jKGizJv{d2bIRDZ*;)4
zg80eJvjR9vwE=Rh`oF{RcQ&31XG{yXH!a-Ww6JH|Ak$8Zj4{`+k+v&^@#c3Uba_eW
zC=%gg!$JtYhzAgpP^B5rv<xcSCsgSrG|=2op@|lwJ7>?Yo{5{yTob+>3Ry_=jE}2w
z#jg3ru59Efn?0=3RLBCutOV05y(+i#2D9`&gJTa4EDG?PHdBK25VnS7fV&Z_>?I55
z$nOt<h%x7v2)_Jw#G8jEZ=n$dmIeC03jd!G(3fZ3@^i1gj{)>X{7XHti}_3a5O8o^
z!an&1;tplnTLY$3UQYwqDOUkpI2j?PQ~pe%TyZbry#YMb%IOanyy+C4Bo_#DX5o6Q
zqY0Mv88jrBZ$ATpZ%^$G(EvCmx8}LevN(oi&L+nolqou-`RQc*;z*|PB8RXD$$e!7
z`dl*Ms`0~eKfEJ2Z^G?4SB<^aeskJygDZdWQSc1=wBF?tMozJ>4lZh*J8x>uyz_%c
zEc>+PU~*<KG9s8f!tVXi_<_qFv8M!oyLLqI4J$G-_%Oh`R&#K&J$LxPk-;v_!4;YL
zy@v<S%bXW1{XBTdh=Bux#Un-*)z=QV^4wtWNN`5xl>>w4j#v>ay(w69Q}B@WdGL(p
zU{z+YYi6+fgka=w@ONuREDi3nGDlK-CbVb1H@vrf)enk?4-DS7wmEoY&F3SonqG5d
z^;Oa6sOC|_uDmq*UNriX{sUir+F2D1eiL}Ic~env#V>*f)<h-+9}Y~OZ%?fbzP0Ab
z;EurO^X;C)2W|}ZcsTgSH5tK{z~q~PJJ!q%z7v@I<6&3!9zO8B-wYpFIB#CC|J>m5
z)q8?B1tO1BU47-e>!uVgcxvSE-Utk?uuroe|3h%aWElVO%UgyId}P&vk;Biw^3st5
zpNdB3eY`Qa@Zot+4Ig>4Jv!KB#I^H+zg#nS<V2LtkMo0X1TuraT{8j&v^S7>=}0R1
z-I~KwqS4^W$-$=slQ-g+xj-Nlb%potHr$t1**JFl7F20pR-k+F25wF(AKkr^IiY(l
z&$H(N-H8VV%FOfRMs@Gxod}-iJNP@l+vrTD<>}rEe2EulEOg%-`cd%u-FYppZclEn
z8^=2_eUdqw90#$B3Hs2&rpQg%JUQ0}oJgMZvCj;g#-7`41a$J^9gClcoDk<4pZu6^
z)tRZ2T?UV2&*#LxiH%Rt5Fe|6HU1A>n+CYyymRoW=mh<fVN*Fv(aUSDE6=;YNy<^q
zL>J+_ZphIzpMklV)<l?OWw<&xTwe_ArFkumWT#nq_+7=zH%HoQVVjXb*}G*`47<kr
zRFCeK^hu^Q1KhhZtsk1&Got|p2|0}&;}Nk<%5vb&(WGn-lmXETZ>!*K43Y9l^c3LE
zIPqzVCqX3);ITA)Kv{^sZKo5#8?8ieF@(&;B(vd|Ea@P@HmSMc!!*)5;fF~1T<YKK
znmY0gZ)0c;=xr`0-2?|~NF-X~+<>dV8w-crS&Zg}1Id*L$KfzwErY`@><Q7tuHst}
zbPpVJLHdAToAecfqc$lYd;JBx75=9UZzKN8wH3tWX+`*WxaG*j4)!J-^^v|M*e3nE
z!BLwuF8mPbr!JqAPsn~-kT(n~!XxEZiwL(#PeG$&iIeg>PsSs4@hVb28~ba8`uIM8
z(kGGNjnj~-T;N?`f{RJ`4J?kGCE+7%&{`hYLhvnIXB@%UxldpVQ%QyM{KQo2JFb?u
z*(>3YC<$+As4~wy-yZsF5&EDJEFqCY=8H()67B~e{}xC>JCd-=muG`-JAaz##((*w
zl0{yYJ%f|Xwrs-Xt3eCgDc~WSXK$hB4LDyPN~BQo8bW9b(*J)nr8ps2oDkG*M~&Mh
z5fYl8WL1ZluH>}Z)GrP8*^vQnZ#Y&zX&=Eh=`e$FRyt^|@I$0cE}yj7<&*M_!{1yo
z;LnD`!Ga_?2A1<<V7^I!OR_<@w}LRfui}g0oeIZXkghSoB_ux*n21#3)d$~@%HR;m
zP)0lj*o<$CdJ~*Ewl)#D%!|x{m=SPTS0Ypkn5rc-oCpnjaknD$9yk^x>3xE2($@{f
z$+n<;DWZ%QZ!i3Bx;)ai1ly!n<L1BuCFN_6Ki&rj{|c@XhPuvuk_q`PhekxgcOP^O
zlCy<-DG1+&AV4zGK+U-?P8ve`!?A0So*>B^W048QNfMwXf^E_z21jkurNR%9Zgcsh
z+g&~>U$guT=11^1!};1LUy=B^Eso}}I{zAgag4_+z@1?1f@9&3z985p{n%g}Z2`&`
zC(4kz*i&I~`ORP9kT3~@eWx`Zg_kcIj7@r6uuaMZIm`m-41*&fQocR;vz89t`EW>q
zWI7xV^56@Gh$e>7^S~>CL;W$hQQ%h~n6M}J1&|lvFuttaI1S?qJ$xlL0}dJV@D;^Z
zkOL53w1%nmr$%eI1!TX#!ysq0kHhqSAS@CZ>KktZh|mMh)CMy|z3r-IBp6H+gQJ~D
zv^bGyF%xZr^OZIQeR-BpZKw$~C)zH8+8-%M79Rz?i)tm~WwhZ>aL5mBVCnj@#<FWO
z8815(nZBfb#uK68M5rdb&y9;rhZx+$L@p+w9<n`q_`r*Pi;Lf>aH8hKnG{Z)_;@lA
z!kG^rQ)e(ZTX6#4OcVHc?t4Cy90iw1{P*ygsVYud6PP&>&Rui5>p3r!6Mz~Drg{Dr
zEt)ISP8i0Eb6r(%yzTJDz7%)`oOkiA^)Q@wL*t7tZ_d1ZeG2DY|4okfM9Mu6_tO6d
z`CQn>TZ4BWYXs(9#=Cf{n&=Dn?lWFE$0<(adBd8==Xh}pj$;CwB;VD#B#O$q0+?Nd
zVVscgF1E2x;JgO*DezbS8{ta}7DuXASp4ZjW>d_RidNlX{_es#RIkCb+oAo3l`Hb`
zDPfIu(%rhJz{dV?ovlXv{{dW@bv}xoZwYCbR>HiALBo|d1t`<-<^u6?x3kp~g(+x^
zB2F?2?{grDaS;kn&}E8hfkf`Niau8~6GbVZ_W()UcNFzRAr3UQECQ0y6^eeMq1%D7
zj2vf%MeZp4d{It={iqr^+1pN18wJ0hF+iu8&_CgShCu_6b3s=qVrLNE8buS3bK(6~
z(Wi>OQFJQuD{{jW-K1!zqIVS~N{9_oEd2)P42$^)qJ%^r$8<sG07+;+MMD%#01_?N
zC@R*_>wrYd0!1|%TBoQ<(Jz5S->(%tqM^?#+N<b&MV(Pw61S@&{50=cKTUZv6wT4l
zWs24-+N_AHKqMazDUWSKcuy+tEg-SrJ)rX}mg&bD%C0QDe=Cna6HAQFKoZKkgp~N%
ziq6;2e##pHByn>TaYuKFJ3-NGMGF;iVp~$XNqG*C=(|lrf3BgAYv@yop3~6xfTT3K
z;|3&JdMG*_NUXX9NaThnZ<xwmsVHCN3RUg~4UH;Vp`pz{qIrv=$2F8|gC+DJkl1$!
zNXmfgg~dMZRxhEciqe2w>w!eeFh%1PO;Wii5dKj6D-^BP&^v%c%YBMo*U*EC-q+Ai
zlo!A=g4l945ZFlLJRr$OriKnyUZL{JfF#CLMRPTjd+m$nT1Bf>Zk?j_8u}CEaf(|k
zxL-pbRrHvKKBK(7KvD)DDjJX6h<)imoO_Zz1%#KYywO0yiztsjfeCN3^0q4PMdj^L
z-f`u9r#wzGNV+3{L?7qzg~xpcgvUu);ql=}czg&E-d^P$Ro<7%Lr1Yv;bg`4iHLsD
z*Kx)7e3|Wsgm+bVzZ!#q1fY|v7kPuvQVwO;!)=8V835}iaC?=5uj;AX2qa|gMR*48
zHNx?K^-WGNz*hl&>z%m#Uwk8?nQKaf3i5yLjT_HNWhl9m|8QY=hYY{<?s&cKvM`)N
zhR@HpbP)Qp%VD_(1N_FD*0;YtcD)z|Aj9vw*%R7dU$|b@PB6f4yE|UryDSC<&97S>
z(>m2<bu}_$@V}$Xc`l0+$-zJd{<AdOUzfTv$zTTqwH=j!&!;b5-Qj`(rq%xPf5FWs
znP8wtdjZ!s270!-EkP_P2Zys3Oh7nXH6KPTB{+PZ;WJ2ra~mLEq!XNb3Ek_zt-XD`
zoeYKdbl@E9!12F0h=u=YC)067YIlhJU$PF-_jLt(wD%!I#mT;+$()TZh$=I)|8KFq
z-J2#p1n`!oa9EOeS3gHzTu)@Si|4+wdNS=^R6Hiu^jtGOf6-EnIA$hRnT@Jkj8EB=
zC#x@~V)3T3Dr9|@Yj%aZva4&=l4$kfnF}+$g)`o&nW0(UdYSgCW`^Wko*@@k&2S{a
zsu;95_D{UkbyziH*eCqUfZsoco)E0wT+00)u9{&d;Co2B3oZY|RWt3vJrCthST*AX
zwWI7wvlA=y8OD2~H)g3U<WBy6iTE9MJn?E|wnp!GPtqU-{_<pU{N3Zk%U_llo=z&m
zIDF6LCHJI`iu`$&dr8OfbSUEgZ;dkU5>)xLPn%<gwnr@5I@v0&A%g~INsCOZ;`;6d
zIh6!C=+GXIUM#D)mOf~*Xa?yFV{2k(3^$|$$)()?VS9WN1wPm-SWh$C*$Jz-3h=vK
zC%l3$eN2Rwv-l}@LVG-j8~ubuxPv3Fyi6@o?u1ob$w>F2h-GECa(q`e`c7EIHL^cG
zJz35`-$i{Vtm5KtdrP)j*4rnhd%`L%e(!t9J(y}fQSKzGxEk)q?|iNtk`((+Sj81b
z2Dd@3-9`IOSjF`x$ZdF_os`k%Z?g<#Kb_*W0Z$zIyj3sh*=^3a(C`VNNcZ{|(__cI
zRT%51rVpK*9z8M_zkFed#fMnx<W$?S>4##`gL4t*oSgHbuRGQKoXP!S(W9~HpR7M;
z=y}nnov8zy+5xe`IF@+rjQ!7%{<%2?@imt@(L+sXjZEI@b+Z#anA7X#=o!xRPn_t{
z^}T{adv%W5&fqh12KR`(k=@o>gAXS7gPYa507zB^dG_{dz{(5$WXu&3ld*(jbW?Ki
zuJ?mgwlg$%t?i6YbH-09DlQAh&qmz(7kgn<&)D*+Q6=%N@RyfWrI%o>O8h@&B}h8f
zK@^w7kHUj>Y!hN>eXEj+t0tAiN)N{m7>P7Uloyv(%`b_+B2lXBlK685CYM#6UlRYl
z!KvPgp60|VB(n-?Kz3WK@L(NY7gHMeJn3Y?Uf1?DwlV*WSm9x3+_+fbq1YSsyMpyC
zNiq8NJB5d<l6@H(FBX-=b0vA?1B+Fh!b4S7o`bb&dyA{AqAIIua!LF=Bas2)>z}t_
zehsqpcH9OxHllBpRaTW$692}m&q>2lFQ;&C{mxU$!$np3CGigpJDu6w59k!^50_P4
zR1$wx#LKG!Cic_Dixl2Qs#Q}<;tv_&!}U9pAV0Sx{&NvvVko61<6|kgP0XuLta?hu
z(mW@>7nV+)U1f!<+REY;DlN@1a*?U-8&k{TqY*R(Ym7qm&nIDV%Mg)_ndonT-MDYf
z(CmFjf>4MRQcm*5rsUYJ_mj{x){j5!mgLk?IVGXBA0V`8LST0&br#U>kZpk+x#^E=
zbBO$Rtorfn!-A(|r=}m4r=5#MY0OPqQT#bs(B;)RS8=gQ3+!-w8-ifQ^`k0a-JK#A
z+l{>Kb8f`?yfqhOzl^msDDxZb^`lcx!y>x+U1_(3&K!l{ocGqoQ60NOL#<eTzazKJ
zUa~N{XmL%3B_PAfm|0z!v3LnTDPM3yw9?90P}9!4XyyvzpH-Q0P3gpmnBoi<k1xzC
zo|18O!IX?e(V9pGg51ahGO%hQ)4H(6N~}U#_X*#boq`N!HR=Ovy;3&G%ErdFSR)rg
zmUs+j2fe*_#|(`>!gWksQkIs-WmLtXSYs-}W1DRLZwldm<Gz$zo1i_`lm=gRTlRrg
zegxt67bn`c{`*cT4QDa^O_XqqhN9xCQQ`PCvOFvHeEs*Kl!j*96H;#b9sbvUA6PZZ
zX<|}ku}z22zN>m-Js{LtRTmb;&qTDzSYkG{%9{Un5Q_6K%nWTRI9xXWBYL|Oh2vkC
z<x%V^l3-O^aaCJ5eo$6TIYz0QLRoQ9{6&vX6Z1#ax1`04wK;b)rzy8Sgru?ND`#?Y
z<NyjJcHEg@2llKVm%8r#HU!09$Lgx*>sR-kozmC^5$gX95CrI$=c!2PS>7g)>lag7
z&!EuK5E|m!&L(EqG38iRR5hwNo+(zvo=0Y#9W*Um#>`F}8sZYau#`>w6wi2;RO>}l
zf@QC{1JFEEFaSD9$8x)8q%>?s$vTC-S{gYp!T{U=QW~BDrS|E4>%X17KJSW@h8UiS
z>c2&ueT)Yvv>7ZsYkYt_bOkK-D@}E4u*xc~8W4`JH|xMMV!P|VMIHVcf+@G%$2$Br
zkg|b5O1Zr1`}zE_w#q80>d8thmUszkL~Sw0_{$OItj<9BVCicw=kDV$*sH7()W0k}
zWBX>~tTroexwOwIOmEuM3;CDE=wPYurneavc5h<C&h7tZtWnzTVepS!>^x)Iq^afl
zmQcR4EF)%EF~j1L-hZ-5H5xGsCHklGa%W5keJD4K@$Wd4UlW3%Sh;F?5^k!KV=YJe
zd+p!!5vke0p7Q)~)hWee<7J43I62pc)?DI@;i6V2bXU%(<mg_k0+ezn&o8bzB|J8M
ziHfd$$1y25tJ4B6lsI>@v6NSxQWCczGDVt=^NeXiJ&IvsZdl~QRg=o&hrecu=@P4~
zBtFSBnPldq$rKFQNw}yu{xsyWcfz*yW71=d-=U1S?(khu)3_UISQw>!W1AS{n3lu=
zzWy2dQU5<gxOlL-`B78}Tg@6IV(hw`NtLq+<Q2t>j7exvcC7Ie#4e6s1&-t(9Bcg2
zB*0oinU%-;80lVaHqH3scI?lcvz#VMm*6g0T-7@q|N0m+n-Ob_gR7?TH@}qIW}@o}
z3(b?BCmx~6YeIoFou1%V59Q&eMmC}F{5|Lz@rR(xZBuVLJ?eLbnr>?Q{`>FiKX2>3
z_rf|{k=9rfzXknuT^$x9B=3r+*6&IZmbKGqV)LuNn*u?Us$)?9S7U}cjpR$aK~1cC
z#^^z+DL+cVc$v+zzqJ#`)*b8tNAl-3i*03r{qwt^aKlf~#{T=qhT}ol>1?7Hl3Di*
z3;Ndx!%Fa!AMHoBa*n6mdH_^p(BoM#qim<hc0x}yh3a-4N($_CvdZF5eq~f(%rUiv
z4miv)8Fb5Kei9N6>~VQwz#bWh!u2mC#aBvv8DX2!dd5u0i)~`w)_ucA)|8ts2bP?a
zBPX4FIdM!*p(q&7h9Z=T6csY{<V!Gr+?q~L?f{k8Ma7QM3(HN}x#e*@9RKo5<|4VN
ziB;*`&DM#hC~1Z|1ifK|GLB5=a2Za;ovbk#w-*2X---5f2Od5S6~!7k#KwPOBBn|n
zTX%3c!cDI6VSv^m_AJvKFogbvRqza3xAeSlxV$7j8L_82rg2Vjn|paYAIvGvCbr}2
zFt+0<BU=(_ox+>saokUu@YvB}`Xp~3t!v<AC87(P>ULA8vdXLSO5$I9fzTJz@Ngr&
zt0?|HIL;>1p}gM3PRU^={*saI<qmUqo4(h?akA=j_pUUwyo8UTy^G^NHL_msf&tGM
z@#(3&jg;b9s=NdPNsUO!@Qx;IwNk3tDedQu^DIxSVm4x_t?wa_nK9#6d3*@iH2nn*
zjg5TFh~<Ux?CMkxD8u+Kx@AQAj740~xBfUrpJjZ?Fe<{l$&|<c`8i7=wG8`OnDMeC
zen2>_UvOOIUG7}OG5a&NmarcGYk}TtBKixo8Jz!Cpb;b8%f0=#FVJC9q*|ckjI3Lr
zz6zd&iqAf9%L}+Mr!-c<UNLh4&=aNw^kCaI9j5hfXbiD;Tlc$dq9AP?ZWGQ9Rxoz2
zD6bk_7JvUUmIadGAkmr$EzWeeaieO{xZ}?miPXd`xph9JaK}ggSdE%34wuJ&<`*&*
zn{R~L*K0(iT5m#HC);IXDB3umqxi0qik0rMg133=;}h!PSn2*)!5-XYoPvJkvC_Rx
zG(A@ETD&(@a^Zgq$5FGt#+BIzjwHq2a&j}8N&;AG|D{v#b}p9wAL)E`{kLtA^PSKy
zaC7=1>=Yaf?7uo(HLpB=@Th4J2#&tbx}JWxB)$hcDh~C<O8<iWSSp`eWNw;|8ezOm
z9x5)6KhGvvuosCp?yNo2#Ko)J-V!{i%`cBP7|{$o=4T(MtL=#!LH+7IfwK<OfB1d<
z3!R+O*SMCx{#BdtkVN6zVTm`<q<t9mQnwPZdO8J%s=jwp@vK@N&oVkw*L`T7FtHuP
zbnd9YSEts~5hS~u;H^XUVKHwstFiw=juqiH6YkCnMMX~j#ISQktn^@6{I8#)m5k`i
zH|4hgr?AMQ*lpzy>@F?|mzBq#2HUwV74|&Kx^2Y6?!ib-QBg^G{2l~hNW~L%)z@Kc
z;DN4?hN9)>3QeKTWBBy2#>B>RTL$*Jc%`Wf1(q7vowIy&%57Eb!^=k}44c~=nTai>
zGA=C1z^_^v7tYD>-iu~MBlMaLs%kQ@xn5;P4Yu7{xS(>5mEg}^QtgXm;oYvCzQs#i
zeHq+ra83r^hp^RN4c1C?+dXLV&p)jD<TYeA`xtk@2s$NbLyuvHli78(=ULI|9D-Kb
zxDS>T6=7E4Xa6!SC|0l?Z7a99*vXyftbPm~V;usfIE9bJ3La<*<vOdk?>ZF3?G^VX
zy!~3vRpnKumBgo+*cq`FM9zoJY!9oG%j2WL$HpDk6~%`EVS9<Ra6AjB!kM0462Ay2
zHn?y6JW#zm{Q)N9iFZ5tZe>wPJc%*|Tb+XKrjoWgx#_X*V+D7CQH&?m5C3V*Mladm
zM7PHpN25N<F_jU21p&?`deO9FEwOj;(9u{)FSelgz9jyjM2r<|MnJ<v1k~Nw6SE#%
z^yrj6;1q1d8|CV>qT-ZI&#(J{O|`Mjdz<X?JPK?96Nqkw_LhQM5WNlWI@md5bZl>|
z^p@OM{%Ab4^G#$96|UaSWd9At>&FfaV@C=H*>a+3w5_q$L{4cqfCmPra5FM)hAkTj
zOpUcT1)Ib1?>=d3yB=Xhv4Xnzr||G0AbK!d)wL{E&>a7ZaM12eWGE<ug)QJ_A7iUU
z)~hgLVI0WMrDr-kPQhbr2q}$WcvxR}rHpQlZJG#c%Hj^<B0W5?&WB$NT5fo0PQWQe
zwlf;{IaaJ-LrOyxesM&`nZv!YO{*Z!?3cvHLO#~3Z>(Tjd<5Xs*zPG#0X8Jr94?Aq
zLWWbYE$kF-a7>!WC*GbXh2yCRf_kTknw-+j7*W!T<KG;C$73NP+6`ua<`>7`M*zhO
zq~OjB$KRl6!M3SW&^}%Oo;n5X;Yl(JH(x)wyeR$~Vq>U@Ra~_s9RC@3R8zRwS-rv8
z!L%{`HnS+cj>4sNkTg?A;rLP`neIHpl0lJ`m&K<W7Va<+usFb=!n2Rnt;Lvi3ErvK
znyD1*CzJiM`~JjH(Q8e4f!+1br{(-R`VVJyI*J4B?2g8zP=t5yUUkn9akrk*?Re;o
zJ>UQH;iVf=8Xv(6Da0Y$@Hc_ZwV~mK2w6#QbOT=TZheWcG~G$c-q$jEFCRDBM&-N`
z{i3B{8#`G`K?7MW1$WQ~lVf+!f#1A;mUC+AhU{aw74<-W&adB{mQxX0GZl^631ILo
zx1GXmPTFO~P6*RT)BnN3!yP30F4HUAmQ#`JB*muLp~wtI>*q|r1KfP4AU!tyj{04=
zN8S;GR5+A!>pI-?9qUMwF%&{<ii7R4co$D+O2cRPDcUJSjD{nBKyWzz&sLLOYYCnU
zsH(K#$X#gsc+zdyNLJx?C(pF{did&A<e-(W0IFZzYj#S*+tgOjYh3;DK+2D1QG9i;
zm?>rqPfj>_ZvC)8O5=FSuS`SCtB7h-frc2=3+NJq7~0#Q0YGOOlmXNosIImXP!Pzm
z>W4z%aXj`oxyg=IH}r=ojsJkJtvb|JjmM9Y__>mwSiv0}j9y1rPQmt+hL-^9YH9sb
zK=rlhK)(e-RXMq#oUx&l#(U{4y~8O^&M8k$X}ld?%vBvjYl*Gi=B(Z}d}S!5DH%Tl
zIt6#czQ*iMu+|QI7At&s{n*on=AD+(IFky-Cu2h`4pwiWY-qyO;Kt18S&oU;`06;4
zXZ@z!ArovevQn})<BziIR%NAHkshceOyn3(N<(J^wH0hb(`l_{yDEGF1srP{4E#q7
z8F-{6{Nf?pAY#*>VDk6l=LtTSofa$Iz^T#L^lfN@c%Vx?(q(M@?&O@+8`fmt-jttA
zWuYvX_QBs>(;|P(KGxcRXI*Fdww8isHt7~Kco|esCyZ4{k(YE;@>;{JBh&Jof(_X3
z?KH2?bzwQLO^&T@a8_?cPiy?t^ry#K8re-4_t>c9x|GI0m>zc*dfcX6?z~ykWJoYa
z;}Mp9%<E!id_bu+@@wz<)o4Er`ykL3t>XyW7Tp~0iR?_NXp1(}(^>M?(m2gcuca~U
zBBx{=T6xo`B-{|3ypXfHu4!~q66!pbKaLGP(zX8iU~a6GelxglE{;F`u_>xp<0L3K
zR<IR~@&VfM42?z8`X7v3P%8a}Us~0#Zm?2rnL_joM>fb@V%RjChyJ!jw>bq3!N!RQ
z#B>I2E|x^f5mYsbj65)=wC&(c4!pML9aZVE76$Y)lIf7#9PedtG9&e+KUuW6^;rK5
zV_R#^paP?*>XNpa<oL%QnGDI$h+@4pjyk~*61#gL<nvkz?qVgiG|pgbT>NokTWrTT
zc=320-4^&h=f>oehBS;oZk?wz@)L0kQ|Mo@f`_wrI;9VzA)dp*scX)P5L$TY!$(eO
z&RMl96zP<k^ZeScV$bjT$N4FZzcGckfpvZ#VQD%ZjWM&BK0FUSkROjbn^=Z?8|SC!
zc*>;g7R)3{`IWf^*u%|K;ay`f*N&aRVug2Mmg6>-v14p^O!m+?d4s{+Bsxv(siVkW
zan&*WpwYHG7Y!<06{uRqqTF?ug_MEY{jprO)}EZiT)owbT#CoHDywY=TSHs47oKFJ
zx3opKS0#a6SrU(#cv)<%nV5trFZU!j#}}KRRBaS>uz;;O(wiEq&SbI^AX729Z3l0X
z^bhmmNMmc*&8{wwMf>?!bnQ^7Sz|AZ#c*TnZTKzbOU$EL<F7ac^VC7sWJ=@D;He6<
z?U)1gRi#W}|A&}9p9&uEYrrj`zId`}o8JpRgPWX!{}}ivjMiz0jXCFh+=%XSn%G*L
zNNNc0;I|ur)YjFAT83ClscntRoX^K5#3{V1Zk5f4MH}6x%`~t2J#DR@<JX;{>|<@w
z4fA>OMoD~(8}DCVVm_i6e3W=wG<p8R49z|kzsR-bb%djnmWA8Qb4OJY6Yb&#egUoS
zow}8K#X*q4|M-A8!As7zoPxTPriE+-xXDKAoavj7q||+LUgX*_Iniw?w_b~oa2QWO
zPe_dQsde8ZNB@d4A0AGQ9^kz)Y!5F=i=64?@ebbYNXy)2ynEtF{@LN-G`xLIzoYeB
zPQ&2|q&PPxoEp9V$dUh@5w@jZ1M95y?@;1eKLEDi*^=X$o97y4>U3jb8evyAe`dsM
z?JgO|{LlMtw(pX`smM1tHE{0GByd+-w83AN&zM*l$Sa!h4WW|w!(g!W@$s9ZL;c#2
zm2&GZV5K`e6g0OqvRTk@+<@?^e%u`*qUSkfA?`f5=5*&&3<=RLN0N0s*t_a0yasf^
zet#)V{LV%De8V?T1lyd#W_j`~!aF9OD3ikR4A(emhNaEu^`m0qDcn9bR@#h2*49ba
zhlY~)r-v|p;jJF82HV?~hT3*82UU|;YHuS5?b{vFqp9IAdNczLNK=&3!H|1P)qJwI
z8ToX~-u(<{>Xf$VT_y3`08!a^#o!Z)(Owc?X(W?PN9r(S1i;3SQD$T~WHkJWbB4z-
zwIT1LPH8hHHA}IBUoK{3oe9a9X|?cp-q*xPZEZu(DngpL@wwe`l-(AwQBz5-1UD*m
zZX8`@m&aD$flT4|Uc8m#{b)*4h^wkB<n*!l+kcbhfuAr_8kQq@+_rCRJdTH=ea_Y6
z@?uwyizPRY%K0YxS?dyTo&0flRT;;DFcZZQGdK45ZK9;LA0*geZ>d_$vZ@8!Epf1B
zl2vIWGg|+SS^U`XOH5O0J%X&C?3Ud+4*J*x@YwB@;MaS1#m~pj$YmI@aceaB$}m-x
zg%Jh!=p^iKS#XP~wq`S4`z3ES@32{|8UKs8cLA@exZa2N<(#lXA{-z{RD=Tw3JBq<
z0wKyRTm&Q#NVtd)l9Lb&Nz4TTN`iz~V$?#l)>b8;wqB`NtF>Sim7jpM)mjx)YN<jE
zN?R0Ev?|~Gu9-dOK+N~QJm2$t2X^M2HEU+p+}2$7>=~@ho_?A`16}D0Dcs%<q(q;V
zMh5${uv6dP2)1QC$?+>ts11wY-{{i5bh%YrLP!6Kv|P6fwKg;>#~qt^dhqF|*(zE}
zw0jQRQEY2hbC5ca!63ixRH07>54Fpx5QmPKsGI|Lj@GLmAJ_N}CR*~ceP&CTe0AZ8
z!d3loQ}yFVKVq<$49$_*fEt^%gJvBbQVR52QLi8W4Wf)6!xY?#y0AwkP3T&!qr;$3
zvryfx%Ulm-dAB<bl4rO44*aat)px6r$wTxH%V|~kds^-i1~nqNCCV%#lGS1l9etML
z-Gz7JC{gB9fuindV5TBw3^uAXI(mw0g;drU^qirM28pNe(F0VfncF$Suey{&AKl$_
z)Pbr&?9uPRrbdY6jPkRCOhxGEBCSo&7+I0w4PgjFLqh>sM_&LRT7w?AADxV>L8MxL
zH~zh;9IqLxhODhkwyN4`Kb%m^$GNT@*MEw|i^lgFkGI@_Ksgk6ldBmE!k>PKl5PBN
z(^$TYJrA!A*W8(PdgXwY*-ALJK97rLnaHTq<<m|NYZ(O>E(XYIN6P@%plw9<#y#0B
z-C^h2$(#pSV=^Bchj9$%09-}E*kJ644N!LnT5^yv=+!+WOVrxK=u#Uq*Jro<?R`lU
zHD664hOECu%A+Mwzh<LVmByNL>$1w+mhE6xCmb)EpWAXjY<Pp1liMgI*YXpwhfr|K
zP;_^ifopb4jktsv&VvkRDeRIW4slxM`?ectn+BVxP;}56>sM1IZl{5cdT`lAxh(_9
zoVj)`)SVJ*KyJ%<pkV`$d7s?)%IT*$_g5?a|9wx3+47m75WBzHE;3PAuSUZMl!I#E
zjHrKZ%WlxFC6lyzW&jp-pHN{fOUP|`5D>Ki+3~^Y!CaiZL)^lmjvicAnA@_B9CNnM
zyXC48sKzJ_ltT}u4&^k3EgQ3P>5A76W`CD?XVYBNoT`P5??KPCOn`5UDQ2+B9EF$q
zRhT70!)(+Ukt)$4lhz)cfV8S<_N?#GcVys?@ZGvBIk)B8cbR<Q>&`rpGU$o-zo4re
zgk`@lC1>Zf{7FzE7Iby_Rbou>;4&;oKBah&l$@4_6j#%n^<=Dm_;dxhZbc8%a+|nB
zi+T<0eilBsEH1b4<(6f_l0>!15~oM3!_QV8ZyRq*Q6vAxfiibK)|p2FG)-UMGzII(
z%(SDgAcZq$su6N-%lX2G6gQs8X*ma$dDlYWN!Zyf-yMia^Kn>E(@nAuiQSCG*RRFG
z3A<^&DB2CTx${pyO{J9E@{A7V)@8`8M^rFJ7ju1UMfm8K|3#hr@6nmCVpo%>#FhpX
z^wF20L$Yv?veKsyx|2ko7QuB9HO{pF^C!<kk}>~NUZ?@60N0Kv$GjQf6)QPLyI}1|
z=5&o&0UWN}Sd(}(8E=a=n&1E8)ZN&Vbpvv;Zjh(e@^I6jK1vs-pz<i)IDOErwzgB}
z^?Lq!z47{_T{z=VGjr0egp^>8>=kRGI@R}_=sCLhypP^GUWAq%>VlJVd0eWTvr9ob
zYau1*E^zkfoMZx(18BRRdGPPKu?PQlGvWwqax`HH3FjmvCNO#Db+e;K1D_ua3}-g#
zgySS!GIrODl9UUhLE+OW|M=IQy^x$iSO5w~Pu5k(0{7C#(8@{1y`#tQ;;@bcH2PE=
z8EXzY?i2MqMV~5sktWGmw<^SoqvzaO7EaeyrwE^U7H+>N4?k4wuVX=e(t636NAeEv
zPx2k;pUs=*AGV8|8`L4cgZ<NbhnVAcaf)*Ec;2DWl=1Lgo~Nsm#R!MPs*hHtD{lRY
zwc<(>V+Hf&CI%!r8p8<fiD^I>BV$qs>nI(DP9aW;rcc(T(OMMkFT+2{_lg)F2;fR}
zit(7($YW0z9vh7wU*AXl;y9FO1lWij>t6|vyBgZ7+z56;iBF6@L6`zgI{UEU$*~-0
zA7ihS{k}jyc!;pxU;h7ojPO4%hIjn@V}xD()r93fk`Hpgw@$O2cWr)U9W2i&thAi>
zY`&qudB4HZ2}>;JefvhZ;c(wz9<2xM$NSOh#eK!F|E66NgJrmeg%@!lgby?^6vP!l
z<I4&nmh*Q_N+M}`UgdR`b4ZhtgL&0eW%z7nIX*yf{$W3W-Q7+~_h40Ic{x6)DXW0@
z4>k3|p!(!vVqS3x-rhMMX?l+!Kb#+na8~5yTh3uSPK4|kES=5Qi<WalM-~p2Pbe&@
z8efLHXPkf9m3<jkYLNHv%#u5}oR96RM1a0Q+-*}<frEFoLyLA83>k`w5zA2>=7?bF
z_@%t9%yK@_q|u0&w|)8aPc?l^aCtQ@EV7(q_HRVO2{^Br$^Oh9B=*U{(#)Ew2##mQ
zHBZjx+S}}4UJUhw{X|EKJr@Or8*MD-r2VXTz9yK5`=M4uNFC2}nZMBf7YA!*SLEe`
z^-KG8VJ!%j3uSCYk>z}4*GmyE4c25;l*zXo&MEs-VJr!jYnrfrty#;1<*LMl`i-Vm
z1$nA3%5gmILt2uTk5c}xZTF|JHNo;($aE6L%eUIgjlmk99`*E{{W;pFo3hppmd`22
z`IHgy^S$_SQ`XzT8bywJIc;Bzc-)i?aAWCS9f=gMhFH#Iq2GE2eaK~K7EZCaY(ykc
z9}<z{FhkswJK>aBffKl0=PP`3=ce3k$9=$RA8?w4;a)qq8Vu7bix^^1Q@7Z`>LHdB
z@7#babW<Kg)To+EEhoXbTcUg%;gTYeoueb$4mM;pu0g^<4o=8nzPTyC1*=aL_D-7p
zSvy$jJIpADkIoJos+;nh9n70vR#44q-_`jBb3Zp_7edKFQ^0B4PCpUqEpX+a3Y5ZU
zH)oQh?f`=HX~{aYgW!{Ekeu^%ScgDieq~3lx10+!@uVGGQeC-fGOm~^i6FzeJHJLN
zLUA}k=LJY*)u@pd>R|75s7|u0@~YU9dN`XUv3EPc0<_L)W%<`31(3hDLv7%u>~$=y
zzIYQEdyiMpCt9seM)#SjHP@c$!le%LmczTxIG@{BiGHB_s0JN%hI+ez7hoZKfoUl5
z_+j|t_IB<Ar9E-LO>tg;C0IT^Qnj?Kpwe<voqwY*gW|Lj{14QM%kb%<avtthiF;f(
z^ayUX<O7v#&G?eC%82Eza601M2K8)>T<PYnba<^cG;OdZw*nW-S#FK9SSX2X&bSK>
z?ZR?bIX4I~6s*Z!Rhn<PtDU=qkQA($2rZe-1KHgh9DZN#q$CGxn7fvHqvq<4rc{c1
z89`d3NnyyeG?IVatOzzqtcVmS54BppR2A%a+>lsNR${qz&VC8GFXE5nLtU!~*J}0w
z!I}w?6~*}xs6wb9T%lE5i84oa-K04NBa2TW;}V&j=ZMCNM~EHx2TnYY*b96O2Ia;~
z5w{L(qa9f1I~3s$n0R!7Vwz`|1jRD(2Fs3KfCm{UUS^*PPzO_JoS2cyi6J0{n~c+w
z#)$|{^y~%hH4My^s9zBl?tcI^p1ZBxEzVKk5V0M<n3T@$e?e(aJlXByvKLmBCCO#<
ztSptQXH>FKEw`(t1%k_Kvhu2ya(|2Eo~x-|95=+d-6Rm4yC2uUN|)@GBTOeH1npB^
zj*H3iEcZND>3-Cf8R)?+_k8!4!i1VK0cX&#igkDS2{rrVnz8x$R8Q`OnuNMCDN;2X
zU9}RRhkHa=Sxa!gTU4^1Zu|BO1Jz_giHa%g_7M`RNC~tkE)#TnxnqSkn6&Iw%hBfC
zJfRFHMYoj{w?=3q&{m?C+PSGZ^3kY@C6P$E<@Ry!5XLd6($y6eIB1`m2sdB3&kKD5
ziiEEzy}$~HoyeB1Dn&D_9asV#m}N2LNC&X9K)k>Wuqb|JPz=AWE{_>^=8AHsQwJ&*
z`2VAEXXc#c-)H(%m{>~8t|$}yhd}6LGsjwoeF>=NNQcS%Q|{7Ym>~F_Bz~EXQ8$o_
z#2bZV&P9WTQ>}6OwQ(YX({Eu!FPQKGKZm`uuLRX)g{~X_9;jV#0Us*-gYf1i#vcPE
zL~MJ3Q^1|<0A^IGvBXnOH$M~tr9E+?+pbd<EKs?sdvm=`|3UXAL)BT4Ld%WsM8Tm$
zrI&WwcVa$6gIe)nhE)){hG7v8aCe5XFu}yot*jJZZR0A4D$D&tNcp$e!$rw2hyEtf
z1cIeADheVM<5pSjZq4ci^9*fo=p*4vjP*XJG7lp|_s^lD;uZ=P7t~x`jf(xc4k3vY
zd=PE9Z-kV*$r#N>3TBs0#ATFIwA)`aclThK5`hBZlEVVaeN#JygAu6K<>(a(#+TvN
z4fn4hDVLN~D}E!>9|>K9B)2CHxZOJ4!1R~rV8a|#L#OE&0<iCjpGnrj(2vMUoaHVL
zodZXui%NB5?6~BPM9VD;Ws6_*To9@hoq*+5Xc{`Nagb_CX#qyPZgr?iIMIPkD6Y)+
znOB5v5ppQ*DXOWJ+G<o%P3TE+hf2~4U{z?3P@s{Z4$-Ng+Y5asBxt0oF&97&r+J`?
zGRsgo)@VC45QZ=K_R4Z=Ln$(nh6YlDe77!ig;1b>)CkjZ*M{<i1O+rMQiLl*+?%w3
zP(P~6U8f09JbE7E)@u?pk3YV(-1V9`fnvwp=jt|uo|ZT!v-4M)v@!ICkfv!3a~V?C
zLH<Phz0ss`?AD<H6&>wxw)`CjN+O%N7htJ+0X8Zxz(Q2os+3;n)PV?2Y*t=io?&2l
z2m`3A4fU5kwF42H9)khTs3~4xqhVvwbf6QczcbX&e5&fQMXic1qysoP!1e;Wp#;3Z
zpNy{ykp~i12SM}z_d~*k+oW`QSZ0b#cgFpU6U$B|)kM}oGfgl|x1Gr(vI&h7EyQ;R
z3@A1H?Id%rs4yM0^ehuEPz(;0!z?=$tyZ@?L5L0u*&KM$sjqnw-RDDBLO;au<7M{+
z)5glshwTy<4h*X+Wiso&s42l<@$5*&@)?DNxC`5IU(((@%x%uP;peQFMTIO`WqI!Z
zgnn$IeZ@pu5UIpKa*rQz+k!8GNYHMc`$tic!Muv16}qjzW<o3D#NPdr3C#<<gUmp^
zLCju&@q2+U@HdeP$>q@#R-kJfwjm@5P6~uq!qU|oau?_|4Y>qeg&Sqmg+zhgiel?K
zW&$Znj|aNy3yA`$ir{rs7ZL^fw3A7GA{eYdzjMSAQYXm-&RvJ-x*-ZHDKPXsM$N?q
zD=<v?vAW8IM7}l9Rqjs+3}+QUU(;1i=?h${tchLa<i5bAD*lj_Bv%pzE@D`|v==K!
z*yT#1KwlM60Qtg{djSgZe|aTQ=VHv3oJ3jR>0C{Gj*WFSt8+E3Fn2oGrA&I@%xjA}
zS93Po(H;)B&c(zb`!4duUT4&~dW7Y4vRP~6mqKkjgY6yQX-}N!46(m~g@Zs$Nt~f}
zN343WpDvd<>@Yp~M~6BNvqsAqt`{mi-F(O%9p57d7+UACMMb;}+;V2weZY|5+Xpyr
zx&x9BT|sdLdLK1){Hv=Lk}NcvNH(r&DlRQTXKFcbYX>`68AILgkEi3Rn3x0Zk^z+1
z3zllXy3cUl)r``~V-e{e?o#0l#r31d54Cd=M;7d5#+G1qg_SBzN8gSyboKJ;l03|n
zuvDe#-Ti6yF}GC03kOS8=KV`^q$+|A@86o**XnF0<FoD2$b|&op5$zGwt*mnf9HN#
zoM0J5SR@a~%$iz7u1Izs)b=1&TrlmkoL|a1gG@hpP>b^`=bQe_5%%2?r28R<Yc!Zl
zhyd(PojLY%I(}M{oH}QIS3ml-CVE+bvz(ipHzd43aP@3n*X^v+9A0oWQ(!sunvfX8
zSJ7AVwrFR)mJ*|=%B+gw<vbA6Y0$(@af?_2H#<rhbOz7l;(`K9YMc$4rHj>>i<mif
z1cD_1COhlwe;Xm|Z8ZQxJspR|iuLwA7c+@m5YS5{4SK=R3s&Y8MyggVDv7LMZrrTt
z@m$zJCHs-C;m9qH;)J$AR<)30aZ{+j8ts&R3_Z!}oSnZkvOLdna_#RZm$nu-KeIo;
z;a0&)aYlbpc3m+t>TcawtYFoW5>b)P&uy;rh@=JT;u_}{nv@)@swgf}Z1-r|08}=~
zx_dQYOt2iwIkG@>pUnj#CuMe!3xSL9fdxjCma|zWaIUI8&DuIoEdy_{YpEYn<_Gg}
z8Fob7!sKk#f?g9WK&C%nbM)e*EVepl)|8`$&9y&8>Jr2<!RZ-DPDWbM<2m7gZn~;K
zd&vrnlVYp5dIwZoj#{>3s?{=XAXq*vQV3a71FC9ySaU2cf`&JgM6h7}0T<E*RQnDE
ztIDop4Y@e*W-6si3Rafq!QNNfyQ7a)OUV6X(udVz>7*Us+Ba@2YuzP*DrvR@g2hlv
zmNP(e4-OWK3|Ez*4yk|!YNz3GYv?mAka!7W9ue2XYB4yV@*hjclOsy{VcNqOD}D%l
z%(GLGRqcsG&YVCc^Q~0nX^v*K;(p7(a<vsTI1>|KC_H4lreWq{Ig0`<B6gzHS=EU7
z_F4p&AeQdVIClmv#SWHFtSDP<IpbX=8VDR>E8+w<S;S{MhHB1q^_)xbkTg+qpdF)O
zTh1h{x<ay!XgO2eTnPaap~?x7LcAd0!tFGzrjvu!vI2~$MWN+P*VOZZ1+qAys8?(1
z`Dm#8ut!m6XzB$>8@eF`Z8;0<MMzMBZx1^QoIW@g4@$WLg?5c|i&SGPSe#W6Da@pz
zT&PutBa<>;w>sBqva2fPB5g$-r23S#6=$)pLS;3^$#aV2bpv&Rbc;(I4lKDIgZUqp
zE1Y~yz|05pgS-;COR>P&A&N3t>G6oOORU|k&Ql6hWxmE9jx;1_Yoc>~pqyz!@m2?V
z4`d8T;1uNP3cot2+Og8F2?$CiXwE{rRzecnVCNxs=>@(5e^?i+rTV!?bRpukP%$z^
z^#7wSS4Y@o<P~E+mC1(om|H1@i<YOW|KqwAq3M-k9_(z>AtlA}b7$w*rrh~jNXzwv
zU+i(Y<k_xe>8>*NNjFa72rI?<8&@gT)VP1L4Ls#86xY7NJl(PU*5!1`Nf}^uh89#q
zibZw}lA7S#lbm`t*d3Wj&9&ZDnoD<`4O$p>3;7kIM{m|7^q#0U#WhnZGq11CLtX!o
zc8EjgT^uPv8EnwW^^|mtS~@kHfR9_;d=VG@s=tcA*iM2d3ECQRmOF(M&0hv_N*%on
zqH0K)!#M{#1JxImn`+4EwR64hxD&1TI_6KFU4hWr6Q?@ugXtHd#7B`aA$Um|!$C~h
z75S>FB?gBGEfDu0S<VTXVG<W$oDM-XltojQ_a+^+9Zem>pp~K-LqVn8lY&e0DuvQX
zQ@TO{$jUQbW@ys6cnKLP=ev_GI;do&Z<B&b-|8yRHF&wm6}CEO<yBxk-C1H!K}r&o
z?UZwUuqCXEvm)phX9e1Kr4CoE897x!qrcS4wd&x*5^`cNzpUhHtg=>SW3uI}&;o{n
zoUZfqZOFJ%6FUXb3Fcqtck4Bp+!-pQl3yJ<t2Cucu$<DW#ZPCoref^K71dc0sH7V-
zt*fF<DTR8m@bW<A;km&)!?`B-YY`M9Oe~5PMZ|lpPTdG}LxxzViRfaal-6qd7<pZa
zp_#T%2$piS&RM7JcsVI)uh;fz!TjsS<x!sXnvxY<$yXKX1#d%eiD=W=$T^N&6!m6J
zovW#n%Bs*u{746Iji%=0mEZ^*XG8FLNz-DHtRy0@BAi=<*-gQlyF5`Uirf_ZGno0-
zE-uW<xk<C#Z3inNMYGDvP;5WZG`zSg&Eeg;cW46M*^!`n(K|H}Z|;1e9(Mm!yF84j
z%MJfs!M7x4yw{7=l$Xf8vOkj|a#QeHuM)XDTMaYr4sw_wuk|WfnKb$5nv8dMmDBJp
zT9bdF$-D8IG5dNbhkJr-+HT5gAk4-)aLc(@Q{KQEKD?{eI`+PxdCMnMi~x%`sNWpy
z4CUgc;7uP#g?RtQceKsH_e6ZW>s!s&lITA1k{Y?SMF);oewETe-me8ZY@`3pFTsgL
zvV7<~pc8wH?-`3Ls-XK+nLMZkIgXt4hcgf9Jj6M>owL!4W4+MHx4%O3OwiWJ&Vb;i
z-q1s$WCm&_qXvg*y6QvwR$>tm(>nSeq^VdEsl<D$vJ$+v!dOaE<3JTnGei^GaZ*^B
zS-uptd#I*)m_AmDn(`NPonhK3UJXQt2i44?y(mQ7Gpv;%`nKGq5$;pCET~4FAvKG<
zTuYu5ET5dW0uxZn8KF6ngXJcgk(#YLU-e?of#r+}sxe_$b#Uq0nyLr1%elPkjMmh?
z9MsC@i3}b100gcUg`6ui3FA=Bbfsj!lQKM5>@)eK5y8BIf(pK!QCTx4m?6z?Gz!Y^
z0SfG`D47J`KG?Y<@OKcP8mLY04CoP*8e#lYTk*Ena_$dYAfW}U&bpcw+W%r$%9iDP
z<LpA?P@UL+&3sV}8o$*qOflY&LF9K1Pxj|nqc}^t;O{j93PTSXPCIH?;14vgBrM&2
zk{Wm0uF7NTOZHukcJ3axo7%&5*;JgAFh;);K|l{<Q`HzGsK+44ecflZb5-GEc2!US
zA^qHKuLB+oHI!E{qqGEb)<iunKq0UiQp=vBNtd!;G?Uv7ntECAI$ZJ~W8jXObh&Jt
znZiM8NRy!ED|P!rAF7EXK^(8Q*L2aeQ8Ie4oFuo0q;j-=5#V%nxi0Lapf6D44QcoO
zd&LPDL&cE0>4DT_HSju554@&X*eHlVitN`=o*`npvsP(K?L(j?D4XZJ;P&i;%Cp*X
zcDbuW5-Yi273N<rx?GtG*gY|hNrwF;W$y{m0#^K0ETLli68LRToa&^<y$_3;LXD2o
z^OU&nC`Lw{D)&GT*Ne&$&=s13)t$&nl$7e3u8dRt74|Zfu>2HtjHZV0;w4}5f2{V6
z`AShKwkKUx&GnISnwqSt&-gf1ef0QbLL5~rYLgZJCS_V?e@xkl2RNa)trsB^IQ8wM
zLxD}l)>%_9nwt%kje(F3*;CcHYn-aaiNUJ8iXsk8y2YufEMD_!wUivEY9^EpJ2*9z
zJ1<U+-Jo^+iNpnQU6qtd?R1YjBvz;$c1qa2p$S-YqAb#-TxUNC;S+rO0Ov2ko3Uyl
z!y?OhQxB)GR-q=pf7JvO29o=h(Y;j_i>lBF-u5-F$c}P<N9!*%YZM8l8Q8C~Kd8i1
zV=rB?-j%Ki6L?h@-wUcq08$6_;*Z4M*VJ$j<FN8YC9)Q9FsPHMQvEmSBk`u%a>rF+
z?ZyiBy8{X8qAYk($>g~*IE=e+8(jq3=Z-;P#-+RfN{G;QIe3ao<y+750&&CgF!?*b
z*oqs@+IW7s6(>u?=dZTnF5{5%{PHPSosGL(*f93P>>+LhU$35DF0;kBk(@oAFI&D8
zVbpRVAX~ti&NYzpu^9zXj$WlWk>yrg2HW%bT$GlHPTUoBaKwr#ce!~1PVe#h7BYJQ
zE}?pX{}If2UlP+bquff0yM){6x|Wsab5l;-0KGcXwS2g&9mWk*yY1`?xFs+yO*uPV
z%P+O!1}Tf%wS0&bH(0mBuH{3mxFO1d_3~j>+)!mnM37e8m2W@<E-Yf_VkMeb1c!oP
z^N7lG$P+iY0ZH%zT(|S2^YLGA@G@&jWuo&ho13qK#a!<Dw^=YlbDu4f&i`mqK(;4Y
z&T)TT&+6_uaSr!5URYd-n|UJ@71iZ3W^X4Q%!OEs#1Omy`@1}cuU8=gS2?}F-`epn
zD?}&RWT)1z_3NMK5nw0TQWqt6$Uzan%iC~MZ;iO+OTGN|0-uQwZfc7zgsaU646*}v
zD#33%xOcL-#Z7T>W)pqE28Mycz@2VqGjL}N7_Nqsik*AYelRYHP$#4eOg)(3Ujy{)
zf)v;gfGZU8QVapop$7*_)H%YzXt<E6qTw=fOf=CAI$EH2;EsHh%E)yLFVGU^U+PFt
z7Q4Ivr{)Rh)S#owaTV2MSwRXGs}-p!y1zxY0uIZ$O83-!pOT6`#*^j69&9jNn=m4>
z!|?)jASLpxhW~m2>#ikOCw|WjV5LlTFz=g%Fn@9IppG-376<>Ptr(r~^+5!?VAT@I
z2ihSqSS(YkziT^mwVHYy(u0VkX#9m-EDAXv%PR?=uSN4=a;_GWj=E}f3FBf3`ID#!
z(P8qZe)LEvms`ESddUzb4g06~QpN8e7GWN@9B*>w$qJz#?R>qosz+%H0&2D#kasCE
zpv5YhUcN=*)u?-+Cd3B|aQeOFT&wNv5$9^etXHm7jGj{=i&knFSg9jGOXj<qDt`eB
zKK~7$oyQedEtlQIHwD<5{9&mIYJhWBfIUTUHP_>o$V~NTet;_cyG;UCk1Z+AL+A2y
zP4QGw|3WXvCaT`{9=%vAFCfaw`4)#0jeB*9l7h>y&a2+2+^1<+)$o^IH*4`Z_($K?
ztTPjR)SOD09c&SKIp{>Cqnfdtt%1I>gqMmWbE&e&2w1r=W9lteY_LxbBWW+dg`pl)
zrqg{6$BHjOV|3;P=YiCoIMJCeiyFbm1guA3QB-%jmYU{VqpdcE)_E1^lo#q5gI~3-
z)pidNZiT*+2su#~k=iLc=i*{d02jygo}|_baKPsUI9dy<6~25~{IvJjcF#e$+>~oi
z_8z9N_wvYcEL+-pn4n&q(<^8^W|qSBP20ZR`1`B)qt>_I5?@V7ul+X1gMMi5ke-st
zLb2?3X-QpS+3#_cC$*d&->3FZT{gtB57HI;uC$zL`v<O&C)o}T_J!RVjr4vx^^!;*
zV5F%!3BM#gg%Ldzjp$*CND1-?8B#g@vg}8RapHLm*1|DxFUKZXY+{EBL2cu{a62og
zL>LDVE?x~mvt*)v@#>*IwEA$aQHh}sHVfM2iv3lv_l5}N6rp!9X8#pcV<pCN#@Ji3
zO`u9axul@jvac86iY2=%h*MI_(GlBK3=vpOxa^gjZ>7qru3e+jfRgTtZ0LJtQZ#==
zC4*^wlz;FWGz2GEmP@s?BSD5Y0n~n6fV4DW2?+fmRH4+uwXj*2u;Oe7-~~VostLgi
z7zW~punf2Y;0u6(vjLn<R@#fOWPx?i5)eFsQh>e$D*+|}3|<Fd&qCO&T#G?j>sVF<
z<|hpMVG!?wWx!Ja+W`jc19%xAjn})Z0Pmpvpq!%9A%JeAd<t+G!B+sh^%h^t+j^Uv
z<jL5=LVgdhirc~L6q`|A=;A<8n3174+a86NBFmARtf3gS*T5=s+)aVB?V5KO>c>E4
z{_jB;E;TWY<!I*)D?sHQ#1R7Tr;CYNYRMT<PqV{__CY+n%;z6E>S;RaOC{844Anu*
zS(^1SuFczX*dt5?X&A~Vhk_K)!nku8cRg(Q;>S<+q)2I`0!kE9TfG@(JeN)@E&G&f
zhXR&$C;Z$6KeI2jtP!FczINH(P>v%+j&D?FyeTl^ImZ8A)x~Y{Mu@`rR$CKCJVw{=
z)GLZjp%K5J^?U7_G-4lwvQKMk^2o9k82A+z=#^R9Qi^+1_mOJKrz)tesbN+}S1i1^
zwm(WK5MW+i4Eg)Z`h^`7=Sd)p;%g2&PVBrzvOhIVJF%`tZuMV=My#y6#X8KlE{=oe
zpU|_~f7%TLxc*9e#EbXKNl?|IeSr01DhZX52o^Z7Dv9qu>;z$akaVmv%wAb0``(b-
ziQ-V{;Uc0xLMVI}X8mF~KBZcXZyPLofa(-+=WPZ{FCAskA8V>o1J{esJK&R~S(e=(
zg!e$m7z5^1GB302-wL@Z9=1}XSXnoV6)9HMf5UnOzp${M4zR%8O?TE_xfu5TGL*A-
zh#ZOSL9wn}OFD-I_N@~1G(~=vWUS-OxX!Z2i^D_WAY;-31S-AKo@f=MiseS<De~@6
z6l_bt-hz7fX-CUC0nb0b%&&V#183B|Pt@qZuX~?LbdF#5j%ll|d;bc^>oLFX{ad^0
zy7wP#O&-BT3;VdXb|0Bnj`g^LaU7i3pJ}SpxD#TzJORl?jXNndZVqjD*N05`LY(VJ
zP<7%<sS}R~q4>H*h4QhM{gtro0rd*0Tc^Yxw<(L)y^m^Qb^BUKJXXva<F{Kb5-Pn>
zS^(9B4gL@>MJe>-$hJpA*k+$-S=V0fXI-j#o#Z#$KC&_l{h^xeMQTj3$s37v0sCTY
zOJvLHCzeGBtiSY7{l#8OyGqz4(ox(;0y1KNjBR$pcI5$91=){f4-azQ`yQyeW1Ufs
zy|Trtb&tAP_o(|vSk_q4GR-3H#kw!rBGQiK3wwL3th<htW_-WMaxvsmD&YaKkK?+v
z{YzQa9k2SXUr7LBk<xicWF9ZUpFx<yVYmHokdll?>K~C1$0G*m10U5^u{`FxaTsT7
z8^;i6Uymy{+R(hT4R4jIR#DQ~;$xfQ5h?;y#9u2Sa`Fku$?+-!w@U_&3ovC*DwYBS
zf{i6}<h}w)#Bao5oK&Qz6c#P4Fa`r0yiV}zkZN$~GHiP=cDV6_#ZKq=)g{N)Eo~$h
zaAe8K&b8(3<EFq!wT;7`Ys(rI8l05OJX_YnHYJYKi$#__-<Gu^G&(7-1!~^EDXBj@
zq=m92We(yT)r5LsUn_fGR>IyNuUEjZNHzpL2*UW)6JTF#a~jM_nI{4Lj;zpa%EoQb
zN+BtG4%z{0<Pw{m!7|!Zh0V9Aoo@kQ6gQ381rpf9WGK~Jmh6bo($S1YNxxPo_I}8x
z{<0D*^GUl%s25`D(;rG=M&YzFHlL+J?T+bOf4t}58$xNSmR&3k_tT*g<;^566VmmV
zZlf>3iyzCrPAE&ek}?j%Na#^Tnt?fd|6=uyMnzO2te0W4Bs`Zy@=B`_`*I<k5~3>N
zao7TfP)fyNM>3KmI<8FYH)07&HEcCZeG7K93y5~Td~4cYDL{T(YS|Uy<s`kJv*CPS
zzcR9`#pM~ykVZ)zT_N^9SjUoXsSNA9)lA(=p}(f-kk7(}d>p1cjH%NosjaKTJ^|Az
z)!nWZ`+nFZs7OBc&sz2kLM`e6E*V<fXj8op>&et$5k9igveybrhcHNd-G=qj%0-bH
zE;`ybiPL3p$}E<CXHmYNe-F6ZQOX&|Q6rCyMi<OxX4yw<PU)OYv-@)>{7>;-%8-k>
z>Lp*<YU-_^PUO@e0TOS*W82P)2x!1s(00LbKsCUJ1o;4gUI6m}E&@pN{S0aXWilv(
z?gXd>xH4qJwiUL=$T%MXug5cJ8z^s)aVNm%0Q{wGMIGCYN~L;`cv(B^)Z5QtWgh}N
zM%(NnQc$%x{<i;Y_qzh}JOSDaI1hLLpqAig0FM$h0=!MI1^~MgtScwO<DeH{OM`9D
z9|6V_8~`XMXaU$k@HIf!RDgC+uKfu*0ZbzZ1C$U91lUNB4zQhI3P9&R0J#8z36=va
zBUlIUGlE+Io+kJ?z+VY|32=hod4K^}yBhQ=z&wCSoH-VBv#g~|aQnCb6MPwHo8UO$
z5`aAb*5rSpygMQUzU8oI#0}^&$g+-*B@W;lvY?i%MHu4|!05`W$6NMAvNOcpw7t$s
ze-e%4dpwKbDr3xK8Qpe-mbE4_Y&u?u_F|{HKcWZ>e;`~X{Ccuw+>Ov5qW|Jq5xgzt
zx7hY263n~ez8CJ_!(FwT?NZ8<(9g1+V7`jB^`y{#2AZk~zY+Ux*wcog5V>k0!tE0J
zhoED485hP440tZN60T}AvtHbJk2$q(gV=h&W~EV5b{(T-N*eESPHJbt<v<+jhqVOA
zw*TAV9Q?H*u7$@=8wB-dS*qowp*>+K@cI(0cwxmiZ7Hqb5W+B6@xx$wsd8AtcLEBo
z!1}mCSYvX?<{oZu|8$_6w9YNt>xS03l~+yOnO^MOGh|7TTRqxMsCwev`c>{bD?Y!g
z@$&R>wL`sLC-&|0rg~kr{nLH6?(?7a8@FYVTQfQ%BmKJi^o$}eV^eyDx6PZk-z(a-
z?}*psgxA&mXYJ;VMQ*pM{chzB@El3cn7-ee@`tI<xXC*<PH;O{d0pJ{9nbAcA9VHp
z`!dp>nC3RObFR1D_B+;(I@!aUzaV3VyLvPxGS_*39(#wkVB`>Q>_^r0PHK`@<R)x%
z7kFWBXM;C&>Xy5lJ{?!OUA)as?=EiqJ8oxho%_4G(e6HLbA3i6qh!+)UUT{&??!Kn
zy9MNbS(}eEyYb%R?l7;jJH62TqPEa|-X85%7P_z3Zgii-r1JIJG?<0%{B_R7=l<cu
zO+`ol-Y2uqnt2)N8T0N*nUqqu*lTuDk<OKa(l^z6!<zT~$=eqxDyl3x;tWWJ+$G*8
zc*o;R>XPnlauc14ZMVvs>n4WXszUhNl<p1M*6j4_l0NSzUbD9|y}oFiGbG9B)5YCb
zH`l$%e#hNky8}Ke-*Gp<(r+&^f2upq+qlV%KkUck_IEC|z30-K-PMI&hWmN#x+Cd>
z(>Lwg_XqC^x2sq96L+_@*)Z3D*?p?+@bpdY^385Cl7Ft#--f@tkSCv5o847&y}<};
z?p*g#+v#g>L>5)KD@VKWJKU9FH+~~Z05_a%bh~XVs&<RQZnwF;pIx{!GVqE~y_;Wc
z_KGtGE_<%}3NK@)H+W~I+i~+n?&`F4C2pwDy?(RTB|T$)#TEO!UO#b{BiFl(c9)NK
zL!(pbUf+MEySc{MXxnahhr2k<?K^r<dd9DsQKP1}^c;C*MtZ$_d%$~qXLECNz5B%t
z@1WXr80}URx(i3UDQU#<Uf7+8XH=m(ajrWmZG$^zw7bhnD@xC(M<#c5x78K8f3>Qn
zx(Pen_K&;mQ4%W(-S&kWj`SR~DK}%@eHjbf+v`9*VWqjZ)jdwrTa})Xj*a|9Tio_w
zU&p`g3p3JpBGh?32kl3(&GYKLUOVsF>16<PL6#nNpQs(}{>4r!@}~a2*T5QQP_o;}
z+vxSW3AM=E=WQ!WFB<NynCm7Wf87sio!+*4kB#g&7`N_;_wL{7UGv4(tq*Lyf9ux4
zccLQiPtRz$^Zu<Ldks6iC)_=?g$)hvQ#L#`xU0O)?$(;ey_-i~dBUqlbw!o0*j#y^
z`v<$q-Br8U{gLBcb>gQ_x!<fA?cVHccJBx6u<ea@zh1M>U53i-RK3@H#QpP{&)sJo
zZ}b)ENY<2$jG~O58RK@Q7rC!noA<qjVnt)xxc{R;^*i0iZ(!~FM*!LM*p1F*w!7b*
zd$$|E*X!lwUgPvjI<U<x@UC(%@;={J<c7V+Ut8)7JpaU(Mf<%WZsK0A(Yd$_a?8EH
z4%t)&rUtKT#BHiw=kBNtyRX=3``uORAUbkmmz}o2ZE)7Px7T_*+$}fm*p{B*h9G<S
z+~%KnDd`ytyk38HKehM9r1vFzGaB}eZ9R)lAo6vnJzMrc_Q&@}il7yq*!0;oukLrN
z5nLyykG%=nVA0N#UPkjaZ@OFJjIy27b5Ki=wP@g*dJaN$9n{c#A1ZG3O+{|a-Xrcy
zHgf#Q8~3`$Tx4|u8*~`oi+J-+ATb-=Ie1>Oyu+^^arfSUB>X<G@ojhi8ZRw<r+YVa
z$;Wn@H#oz6KW?3S)9S<Ub>E<QJKgtc5$LP6@3_xE`XlyX_dM_OP3~WBL|y)|y94Pc
z^tQR%13TOo;I<Xb^zYWj>Y^3<PcL>uNXC)$qIowBDq5PJ-YY#L<HTnfMQ+E>A+wuM
zxNqQ~=G>y2y`mG~!T(4`Gt~0$2c2}ksoK2By)D5@^SXFbx8YA0RNr~cZ@ZOq?{M>w
zwhIp<uh;F{*X-S~)4Suu?+498MepS<-w2h`dH+7QaYdT@ReajceJ4)r-0$99hcbU`
z)nWI~mUk5xr+QahS&@-Zkdfhd=*dFpY<P~AZP_<^iGjcdbXfz~1L@zRFvoWA8k}+G
z1Si%9Zw~y(&1(Ph*jL8x8T&tApTN01mUra09e*Fja~A*7v~X5hs4OjfO<HJf)GO8i
z#FttW4I|#O{5ez7!c)>hOVYwQX`!pr!b{RZ*QAAKriDsk0`X;Ci*ED2)^TU2g{H-b
zo0;JAb6Ilz{|5h!T1KuQuEz?FFXI%I7ZqtCXGdB%H!bAOveUxOYz>fLr#>w_3&v!S
zr-6JB?$^Y~GPa8|Az=;}9*FWyhxO5@wJ|L;M#s-pq^Yg*=z4glNDIT?wJP?Q3?7q~
znAwG+2|o-jr|f`T(lEi4=d4(v5+Evad_h_$KP_CWG8*OlKZoFtKhCe8!5I6je2Aol
zYSY4VQOq%cO-gVlAkjBM#v7y%=SkAshk|Kg=Ewp#)}#$aT+G8f7|Vs*9S8@MvvX@&
z7ztdE7M_<D%1sMj1=57H!N_wr$xa)LoDDhuNDG(4*pL=poEEA>9?VIzia=PI7G9nf
zs*$Sa%t#9_1#Mhfcq)v=X%={$>qUt9!ci=OF@4BljP<HG^RrMzh&`H^(*aj|G{b_c
z0yNn^NQYs5n6V(7EX--F0tJl|fO4Hh*CpaQ%Xj6Nm4igb8r)nAa}yqfvjqmD0mNVV
zv86qUhmz8KN@0(tY;1=_H2E5XJRr-D{*K@|D=0-Wa=fa!T&sMyu=5p%ZRJQ1_~W}f
zR(T@5D(CF8ofEAJYjO{4v%ncoy_<d4#Rw};i$ybEVUK1VYAZ97=32o~(dq9QJTan2
zNk(*%_&SAINR#hRY%7;Wt%5Wdc1$?+U}Vrt4^8FCr02&V$wHJhlLlQK3oF?AM`!wy
z+=_ZPx%CR%_TfQ<G|u);S$G!%i-~5v!XC}X1Xp`B`C5iNH2Eqgw$i-~+97ct+)VQ$
zJhnCKYZw8r0w%#wz6P6;cn;353a6=8)QY_%@TvgK6ooySQw3LJl#3Eq^nm}yCRUhI
zxUI#5^wQwFpP0H+p<P)(n}F{TXH$OHz`9gOMkZ?BPI#Djnq3t3Xii1<!?<Zq6I>Ob
z$<NTiUqh4cePZRSfWJlwV{r4tpk-Zy$F{P0B1<D43ic?>-{1lHZ5Z5;1Lzlcp$-5E
zWH=1pwKi?2_1#O1`>YuEwZ@&qJMh@nOd5Pkf(%*(F*b@QGif}H$FYVs(|lIQInTk^
zFXT&`$6`u42@hnTktHzu4j4NXoCS@v91j?148@8Pggm+CGUNz5ZKQ`8l`Sx*2FA?_
z(zpYUaPJ5Bk8dF;$GW#;UE16X^Eo`i^(Bc|z(lL)J_hC+f`>NK{1^{ps6i&(ga?p@
zDw9oArt<q8@}NcXA!{2_$V7vai9MtsjZ*?=QS4$o3>AhF+tii?Nd7TA5bXGxok;mE
zl?gPMcF+&6p&uqqEayS`9(WKQ4V|jPYX(Acrba?q22iGwLW3z2&z}*f3UGK$Ux0xs
zku;cQ@$9Ga2FSHdiYJT4A%QuaQ8bt1LHsndkcUJ_76j-tw7iGbun2Bd^3q^QAeKXG
z2p&;%8af?^Oga$Gi&}KR7{S2;NyjL`X;ARkCX0e$oke|(sn6f8@sq{u9*ic!mgCdD
z)HDP$9!?)f`f_Nz-(Kg6U(vwAv{7C_zy1Kmh<MyYMs2_<&d6x$vTj*Jp!2T9)N*pM
zzA!FgKTc#=%NpkDZHQGY1k6Fl8WLN%Th>r63Pta}aN>h?fFjZ%M%0!ytPh2F=s=U%
z$zW-!iXY9Vt4-eK#N_RIqbq!^gc752(g|E&%Y^6>USAs{*818QQKG^88MXf{)evaB
zjR)#c%>4=nXdY15qj^x_M4CF<W3dhA*qQ;znW1<f8x1Yau{CRuDfM_jr=i=*u{AN0
z9W&+08);ZAm|5S!?1k!q4%_Di^s5v($pOtp<7QQlkQD$w7GK#kUR99B>v&wNa!qXU
zMDt`STo(v)7L5jhrX!+EN|u~4aLL4j;enX12&YufuOyi{-@^D_L0?*y)@D4&1R7iL
zcvht~G<5|AL$p1jD0Pam6ShB|!9&|yXYlwzzk$qtSLHj6o)U33jW8aTE6r4e1607w
zO=O#20b}|yPAj%b{j3Vmd_ZB3=07oAV8=<5FR<AG)6}@em&XI`96Sg%6~+Jseb>VX
z=@UH22pUJkHJ648hl5=8Bj@LMSQTiV#Dk&BH!yI1Frm-MfOyOc!W2VXO&7q|VRzwS
zo1?i!oU>`XtDqmw7+A*(DT~Hofo9;w>C$I-m~NV1DD2S;g-EaVXm%2e!3oSqG@T~j
zT+^=~+XUEigf^tP0VWSDftvH3`@%XvNLe(L@8~dd5@_^=T&D3W1%1z#!#YYxSv0ig
zxxVuv&`OjujdDDcjOGmrdo*uU7?n!>IN2M5hrBe0DeTcaD!AICd0f#0G`WHvJKUNA
zS_BVtrWHp(23Q`i^J6Iiu^JCblg2hYaDTY&69CQpuwkADVhx@c#jq1^hxXxNz4<%L
zf8s%3H3;t=$KoORDwvgcP>22m<0FCDC-CaTO;#KMn2C50?f@8r6kH6WP~a@S;K;_q
z;J$>}1uy=<yts#Dt;0j|H!!`PLN;kbOl$Da`6igRtC%T3i-M&H>&H4=ns?zrPW%kU
zJqptJNWs|{G4TPzJun`@<67~jn?D5jQqgaN5Y1X3n!myW_J?3RrXY>|3eq@$2L&wV
zdkP0=zOS%H^Y02L?m+7PC@IW34CADNkA*Qk!GmaS?1fnz9zZ_}o`v;IJZz3W?V8S(
z#a+^1qoGUr&N|=ydGLQE!Q|37p`h=2PZuaHJn-$m9Ylp$U&q&k?a!6kv%c;E0KN<q
z7r&%o@#0wId^;&F1YPkUEE;^vDfE2+slBy@FPN@O(UwxwUoG%@BQRSED=y2K^|p0=
z%we@0DrKHSAt@iZDI=>Hacmu9seg_K(j2HIV1*M4D?qiBJY2Q{sA>QU!Q*(KRbGPe
zwt}o2r}2nqrk81BbS$iU@rVNx%XHG=c9_p<%ycu!r27SMc4}YI^3&A9+*(J#sOd3A
zgj?$<i!TDrxUh(DYaKyHJoG`cn>bYN7H|P9Xm2!fg}&+5I)VrA&;w1@6C~!=Is!j2
zG?^fAh)o$&s7v+My4YmKl<=*sN?6((i?{@3DVCi8yTr2T+gbv)Zp8L&tzXW<<`=YB
ze8nPc)G&2;#6qC+@LMTR=AHP7$;5AK{Y(@W=Ausfx3zvjic3u5zpeEXFD@~u|F+go
zy|~0A|Jzzi|7PJG?=^VPPH1QeU#pD~>b2Sc)I=g4FwxKj`&uo_W;-4v@U_}~09x4B
zYGdSktu{ua*J@*=c+E(0cEw}!XW{#5fI22d3mh{gK&BXtaIDrZ4LYzev_d#m8{0sb
zuUZKlGx<s%F=8Jx*-D3)BpfrjN{5)_9BVT<Pw3>(d=?J|ue${>O~|~HwK0i1*;e9C
zO5#33=f;R>GJ#UGF)2MMDW$$67fq&CxMGrhvaMvFY%AF(+e-GyHj~{66^cU8)D>&5
zsrqz?sbqVl=AYJL(`2PXg`=S>+}>IORyul)seF5DSqoVK=@3&9_tv(dG4{5V%)M<T
zbMOC2GT&+|nQuul-`B~c`3W8*lZH;_TWuxtt+tZ+R$Iw@tF2_d)mAd!YBQOMx)RgG
z^&AwMhOWY=Vyp0}wyN-{R_#-F%%^JonkprT%+T%gRI7@rRr{&7QgEux6x8Vy(A=O>
zKtreCP;3egwUvTHZKdE)TPZlyRtgTam4ZWUrl5yT0nOej1vGRDHpGsUHq`mO6mv92
zM{cM)TSw|L*ihF-8EmNY`yK{G9jVJ;LtEYJhPJ!c?HCt|HX`^fo**X>DH90wAaAV^
zT^K359+<5);ogj%x)BeX4h-$S#kil{qi`=1rKdSgjkq?{am1w+(}uRjH5+7H^8-o;
zxqX(>>8*w-8|q>PU>ju2G8ls`#!i!Y$Nr4wOBX9TO(r3BEM10zt-`~15;S!o?~bje
zyK7?#c6Tki0bQ88Yh$$iZt0J8q3w?Cf_JxB)&7C<pvW}8!h?*ap^NBvTkYexw2$4o
zlcM=59(bmq+w}3aTEy|TTEy`-#oUS{Q_QDf>Y_Z@mhwGlMpyK~{Lv%MgS7<L>i&b~
zDm>_z57rXI7QP<g9BfPD9&AhF9&9UZ2Tj^8MBNPIL2l8|$vG7}7CR+lv57s%luJYR
z8K+{$Vy9xqVyC3+BWSenK|_z3PsI+)PD!2MMmaF~`{j`Ss4hKAwo#Bz+zB#7=2<kf
z%=gyCbnW-n#q{C#)-gBPa^U^mx|qKD-ny94*S&QyBd&YvVn$i_nkMeY*Ny@4V+21=
zL-6A@1V3&=@Z&cGUj{?)<uC+a7DKS~kHehFcrd!#D}b5dF%#qBzwd3Ni&7{a%h0t}
z);9Zv8FluBjZ%DRqZEqELX{x=(v3R%!bd5To&_u({F073`)P?)pPc`Gj0dw%s@m8|
zp_)15FrmzRHY<Mu<2NxbqQEB&uA!jRchz#aL08;eGT0e{`almf*%Z+NXfOvzW_4lO
z5zY^d=Ro$SK;)*LV={^T<buW0zs}HNUGW65>^nHEnUJa%#ksLA4g{YsHVc?;8;lH+
zW&jUlq@jDByG^wm30*xE58P=K3pBC+7hb+szG;-nnpQ3+Csf>MeSS&+eMx**<lVz{
zzPng{fMZK6N3=hT3FDMeQ3xa2!ecn@j142Ydea>e4#p$i2rd(mb7&~(r5w0rHzvP*
zU&s&o(f!lCu~9_ZG&wGnP_rh(SgIhmk*f&I>Jwcml`D-K74-9CF|6dk(!NJiInVN)
zUqG3>tcr++?pdQ!>;dtQ%ALklQb?u<IecQrhHThkMn+=sYo1vA$b5G6<4MtR)TSh#
zne-pvP4s!Owi&}})^Pn`5!b^;3M`NMyh8thaHSKb+CaQA7Ew)Qlh0~BkK}!b2LUAF
z-JALy1tCdw<TP~hqsuE`jxMQGp#g5hgC%VmKT+`4eURyRK&A0N3i7r;Zfgg15n5p}
z9zZ|Zh49La`KV5twI9UvZ7qHM6^~d54oDC)X)qX}6D*PNa%eD}G1c;Ilgx^MY4iM0
zMW^jvGqy!w(W>z}r1`5zltn{F79F2_0%Cls8PyVMo@f|ff#*93V-^kV9$j>t4NnX4
zpvBO*USQ5UF!n1d4dw?V!{`8jX9a<~J(AC?0c4*3R6!ale@wo9fdB%^4-NT%AgUpY
z;ksPKM1%1oren1Pj7cnC0%*yj3m;p-@k=}qfQDv1R2#z_o!oqYw0|VokVS)m#VEaD
zkb0U*0KbW-P|&X!7b5iDDk2(Mkm$0O-#VzU{f6ZC4XjkeG+8N-oalVz3552P3YdmY
z!O7SZL>D~%0FE~mGY!qWp^nLQmB2K#bkRr(P|d3FIM&KUn(Oc&%h+@$-~ps@H6C*K
zY0fj8(#YwI_U^m-AA+2bniyg<Z{ENdWj`K7LxVG-n0$|!Al(}~K{{(l$F7;(GNMzX
zI6e8fH+J$9t@1IU9<Pm=b{&r$+#Zh|#2%MHtPb^fZOoJ^+Suk|`J7AWXx0pqXIlW$
zD3Z}gm6%Hv4$v%7*yB1oM=fCYM~#4fq5%E)0R0^9f+5T}8O>zTh*PQGD8p7NROF{W
zdPJ^lltJrisnl6C)Tj$|KRo{x6a2-DjyBYBn4|+gQ0p_F3*vcrz)XW9sF*_I$gfz5
zK!an17+0>Xr{IBK8o2^<E&Uq_>v%kD5?8}i&Ze(?7Hke4yeq#_oo&$8c?3LwK)cD;
zgs}$(@Pq*E*5(KO{PbG$wEp6nUs!9$ANsQRZzGH|zSzSF&m!@hV65!3LDNB4JRM14
zeYG2}JkSJvHyrQl((IatH;wreo_%idvbQq`yrIk|#9Zyhjb=Vs-S7CH7|IG<s`=lu
z?7Zg0_o1#w;*};o1;@<E`J249#iy;P!pEB27v~d-<qnZz-iN>oSbQ@17Uip>zImU9
zPhYOCOyaFRXOZ5)dvTwn0!94(#UxpwvmNp6W26FihwwFcTi*1wAiQnqOcoJ06hoF|
zT@xczto+{~3VdI@)Z#4|1eqoHHky}V@DdH)5F)O;uEV(USTkOE!P9_v-35>I<5d?t
zGoII4@OVmIX~A>JaD&CKVekqH|KdVkVG(QRkw`c>R1Ov6`Di?Zg%=<4cq(8Xd(FeJ
z@U<#WBg@X0bNqSMm7M0pBbNO0lq??8E+<Ly%r&0b!~@BBqK`g(k7r%UAs`kHU-Qpv
z<4ITg;Abj6o*B!pba^~0&;3!y8@GfJw>n9cqjP-9E#FJ?Tuy1K7SG=iB&V{nGgGJL
z@hl#Fa-TX2mdElK0*)l#ivG<%+VAFzkvDQ8-c}$v^o|F|5y%l#JUNa>Pw{j%eRLep
ze$kLOE+CtD!GX>u-gv63hdH<{Kc*4$q;@}_lA_tbJ0^72^STSaM0k>@N-WR#^3Mia
z>t{Mo_xAIYXPm2?=2?^~CwLB)E@(OMizj0F_Cg-O#T!Tbn!tMtq=0#Pm0!T>%qgDC
z?^7%uQKd>(Ir5lxUD`a<$v?b`AI0l3Q+!)v3Xz9%$Cmn6(X!?T!K&Eh@PT<}TBn%m
z@nlRPau5?+z#JPIJ5K}V4^iq)As}}C;Y8T~+3hf)#^di`^S8C-g2qi}ePMEIVHi(u
zJRv+i@%TUAKexA%pYG?zxE})jOFZ1k#f^tw0dw=1|Jw-OW;}1;Ie>?ou3pE(&A+eW
z`6Zrhc(&l-SttIFd)>G{)ZbCXO;+6Y=l{6PXBD2+c-G<Ze@CGeIE!TC;+l&;m-gNL
zY3-HBa!zFZpFd3XCvE;v^?%o$1IfGa&_Bn6{*QAQzI|p~T<7$E{(#9J-8>Lhqd0#I
z<d4jJet!Xt!(@(MIKE*T{h!gQz7`jC9aSVgIi@f2Nz#ED)ljaRyzi=eBj3s{GNvN?
z7Yf8yd!At6Yl}s(orE8T-)ZU#cYLzykBckyZEmKjL$~Rhd#yYk(WlO?lY1>JbutRh
zisYFV_>viCV&hb|e5;JdrQ>+!;v9U)&vRnnrtXc?cl|_Lez{W2<-W!+@v@2WEE|lT
ztUP_%(-}QZ`J{@n>T+B$h#OhtZ0yy{28k+?PebmOsNiMQ<Co$@>GDj`^?9?@aXh%3
z2Yq+hDr*UjyW<gOa%wD3YMnHG{HSo>NmtM57apE=Y1%Md$REN)(OXH@=lBcN4RjiR
z`w2?4@xisAUO>>1a2;w;1`t#nXj6ccU*0jG!sD?O&}?x100_zn2xorlkR8Vl?>vK2
zfmC=yfRqGdjO$E8%QL9Vp!<LZNgU4t4HmQqXo#Q;*LR%@q+BCF%5?_R+)&~BHIPcj
z5g;YOXFx%?#)+X&JPhVwk`)G0@p6o*^6Gvd70RCt`T}UU_^3cYDktw#K_cWwfm9B?
z0;EDYVo+H-ESrhnUjZqp{$kKcgOWWz<S{@PQbWGS4DAm<mkaG(AQeh5-j8<}5JZG5
zR~R%CXoUFq#L&Jrv~kePBgHizNcmj{q<rvfR7Lxvp&c}|!v=ZK|H{WeAe9G&K>Z}-
z2Z8zv`n^Ga1R5o@c<A#>1YH26(sntJ@|zE&!fOOd7ryPrbq~;Jp&bFr5Y!R<f%4l6
z=nA3D2U2mA0I4`O7{1>EsW>j^;PYhwsZf>xVOE7w*kEYy1F5<e#=u+g4F^&oPX|)5
z)flwhpx1x~Nq9ZbJB<<44@iYK2Iyj;EdUxTs1_(q&=QQ2#|gRtXpEpOK;s2H3p7E{
zOF)@|UIUsa=pCR*f<6G6Ea)4cDT2=Hj5Sn2LxH9Wngyh!x&vsM&`tuW^zvi6fkHb6
zNR>iQpy@)p6zFO}*BjRcAm#UIAeC3U4EhU@Dy?HcD*qhx*UHBQK#Dfd&_)8OIyBCp
ztASKqTVnWbFz8l;nt@bo%^1wi5J^t}WeMttvEfWXe+QZ+sIHsOcRqUUY@r<mQu2KX
zq{7R@h*#ytqd>}aCs1GU!Gm#BIt~FTNsk-Xb1}A5K0Y-l9fMv~`jtSlC6wENRBXQi
zQa)ZXv{VfJ6m2lj9Pu$4NVVk2KsiDy1{yA?7D)NnZup)7$`#i?8`?XDb^=JHqcg@X
zsvhvLow?%U4WQA2J_b@De{T5Vd-$b)C6Edw3rK0lgNAkv7En|z=?kRz<{GpFNR|F_
zgVq5ljrl7el~)IV=7}ud0IBr$4g0;uav&w&dV_vu(C}Wq>ja=HENX!qLn}9EBajOD
zw}y7mppL!$yzdI6@-!1j`IrNw>P8`ulBEJj)s1z=^=?D^6OhUc&X<&rgcKhQ08*|G
z1I-tiUjiB<=nWv%rVjxv5L(YvU+3@?9TnbugO&j)S=JlAJB{o8K&p&*%#K2@8`qD3
zw4^|){@H!}`kVlyLQVxz@s2QPI*=}NpaCLjF_6-os}0`)gRG1EP?8PmW6&U=u@cG@
zAl0Jg7+RU3)d4A4eqzwWKuVS!hW0X$lKw-3{sW}y<Y|Kvq0Uu!-3=OH&_o~=O17b`
zH0Y;5s+Md9QmyP!Al1q~Mo*&hB@XFIz!N8>927JGe-)yx2P<43#9uT+Ab$I)&`-dm
z&}M@U8uURs-}MuNjvMr?LGhl?H_o7$2K}SG@A@x;f)H56+sUA@2F)~Rp+PefeIE-A
zy3wEw2L05aQwDvF3{bK0!wZG@ErUY!20elPP0@B5bR+sBMPt9E5c?U0{$$YQ=sy&#
z!l1t!^cZ>)<?40wQ8$A&8??=!j}7|Lp!3krs8ISCG~S@c(UT}wzCcijeTqVP2HkGZ
zeFpKv3dMImdJ={D88pJ6Nd_G;Xasr#<s;W1F7GQ^r9o>AdcdFy!KC;G7*uW080c)}
z>Or3>w8@~C3~CQes9aw*=sSZJLDwnQT7xzl^dxkXa(&UDKN%G6<GT(pXrw`t4f=yY
zuNidEpcaEJf@V;$-DFV4#XgN~U%5VQ&@O|1*VlLb#U(!4Y0v`$d|CjiLWNRbP=i5t
z8gw<(pyHcvP>n&~8k7X3tN4Z+bd^Dm81#ZcHx2fE{0k^3I_EQkz5qf~f*wj3;-l^c
z^*3lZkn%gipwY&4ib1msT4eb04Jt9N)dtlXw9)Y0Y0%xq^_K?y+MwSV^c;|qZ<j&)
zjO&{Qy>HNAgW91RR(=x<>IkIr1*_fK^>TwI7}qI4syr4M+B(B`vq85Q*JdE)W1De(
z(x7LI>n<QA!JiCz-=KEGe5n!)>IkHKBm=29E;i^ggE9@8ZBV{J6$bqtsEgE%Jq8^x
z=x;zOjuu1v%Ah!OmR-beSA)(6Qa<_^8r~^rzDWixGN{I&H9)G2ZZhZ|ASgc6-QO6#
zmkru$T;DUaqXwNa=sO@K)j1gUs_=RMDe3zd+NFjz+R&~xw0a;V-;WGxGOl+5sW=`m
z=r;zvXwVx5{oSB{8}yw)mtbhE<Qr+wRR%3E=z4=z04WI?4Z72~J`bd%f61U%jO*(_
z%I^mT{mY;(m;17$7&P3VaRyBSQn@?V&}xBH$afp`ph3F~`o##J?*)VYXwYXsO8PGh
z`Wi^((D#OK=tw`5*#<2KQhXJLw#LwIH|Sx5o-ybZgWfXeh(VtKskD7zXz`=`*g60y
z*YgZ*kU^OSU2D+w2GtvMmqEWa=w*Wr8uSk!727dG`_`bI>AqAW4Y~qI`Ius8c?MM(
zw94?UH?&4WyVKAfHRuWBy2H@^WKfGir-4+d21ffe=VBmLS{VjS1X6rg88qLx<{MOE
zP_;p;ft24`gMMUOHyZR)pbJFPY&Nt9fRx{d4BBp7e{axB#`P70{s^RU_Z`FczM=io
z&^`lFaeM)!BnW2sdC<Y2ZU%)7>Ss_Ikn(%Ep^Y(Uib1msT3}FtLCXzVVNjhx8w}cH
z&@T*nz@WzsdfK4p4ccSS8wR~=(1$=OH~tBvQuL*9J#A1tmIoByIR>2vq-suYgZcxh
zP$n3@$p$Sjd=Wz{HfWV`U1!h+AQj&IhW4<bJqdK7)S>5$>l+5WZCno-+7Td?j-v*h
zGOni$&Arm+O9oP@yvU#d#&xhkWspOKoD9@Sr0Q;HlMQW}p{+Hv^@g_F(DoYINkcnj
zXsNazM_(Wn?}LW+u%WdW+A%{L;P`$A11Z0pW1oX34*y!Ckcl@<-kQOR-}k4n&B-<=
z)GDI>dy6&^sf38Pp+MX5L@7_fwis4LNs}D|AmK-fYs>pwLi0;2$g9fJHi!-$<77bE
zlFCZof@Odo<e~dM%@h!xzmT=nZ@;E6k6fGEk5;yd@gvQ{d~@xCFj}!#|Is|{geMVk
zb=H)q@vVkfRzNrzTvTcGYo~*bhl^`Jhrg}k>ZVCpiU7|%h~Ap#Vok#019-yt%iKKk
zcbVqFA_I6>k6QmGXew)tYyYVgPg*`M^^D+5bNo6858FlS-wgO%3lSKAl4L1h82J>X
z+yodxVMQtT1M--WD24Cyc(_KCasZI~=%bX63H49K^>r&sVoY`@*s~R7cq_`JR+MX6
zQL0)|e$<L`Zz~FqY4d*y?rKGOqZQ@DR+JO1C~^eh8M(pJ+5DekAASa95nkSwL`r=Y
zU0%FS$Nwo`3tLfEwxZnDin65@<@c>92U=17-HPI}S?iyY=e$;wOIlIJwxY~!MOog8
zvaS_nV=Kz9T2X%Ait<(~%JEi|c2q@Yr0d*Pl#5zXE^9@Z(TbAaigIHs${npJkG7(`
z*oyLIE6U+kl<!(mI#HpTl=g=$tst_bx@b|}k|h<96~0aO>uHyg;?jsuFRb961mB@7
z--qSZOG@EV8Dr;Vc*dSr!At0k^-LS8zP0FwE(%+u?_b0HV`=#%xI!>(h~?AdPBu*)
z>PP$kcOvxW6WL=HyG?eHc90!3KjhHn=2_oo>z%W{%MWdv_1*NIS>I|{EuX@TI=BgL
z25xC>MH+eriI*Ku=3VEl_=cT98o!h!optG%#OjI)bXaodTr2;>&tz5p&m>M*Vt6Jj
zna;b~^XEq@$_#N*q>3pq_UuSic2xy$R`g@z);zf@!zaKC??;(MX${vb?7YGDnbr<I
zcO)9(qRP^8L{U}vgT7-J{j$Z5p$Q1TDjFSSo}PDIWLn;mNQnuCqE0ECT~U1|qrTn#
zOx~EVrP7@hf!cjFyG(6*^ph?&?1_{{?i2MsL|pH39qw}Rsn`LvRPJRn6wP;5ME=gl
zv&jD5t}{}tHbS1oxu}pgF8k5yT~n2ra%YN9ol=S0k<~rwK8e?@plsB(Q0|wiG+~H>
z$gRNL4yg9HX^#80d~d#7mAEyyxaur&)LK<BWjwC<_I)9K?!Gd17N1-$qw0J#YHYT}
z&30;2s_&UOq>J!OIaw<au1@k9fukB<UA-KMiw4a&K?Y5Bhndj1KaDrG`2_MIV`fC9
z_glc&(t`1M*sp9@l>=^@jA`5y3Y*=E3s>n4d?jUh1=xF>RyHUszahge8!~Lf<wHkY
z77h;|N|O3}+3?}we(6X!$Zv7`X*Ngb*k^(fA;-O#9oez-5+VJ-pD<{#bCVxn5z-j)
z#mrCI;#&)cL0ChL{c(^wAZDa0ZW!7O8iK{R|J9Ft!|+<-fAs@j?3kVGNq7eSK)h}3
z)@waO^h+e)#2%Zc4EhJ>asMCA_4@0WIh=CsvlDY>n$;Yw^*n{S{C_k8(OvxVyy8+*
z8BxzneH`J}#53#T@DZ0@3Mc$nA31BnJM_nK%Cw+BtNOV1eAHKz+p!-DgY^lFFrNS0
z`pEg`*}t_QoLwJ#ATxJ!fg|?!1NE^KYbqaxF?aj9Vr*dc|3H0gMtE6^umkL2#V4gi
zzTtR56Z0Dl0sn)lG)?neOE>cIWkSsFgKpT>P=dpKA5%mV-ep*3kNFiK-uU$h0(s1z
z;Tv&gynDg7d;|2t*?c3<Y=2>dap`T?Ew1?>nv!qGkYR-WuLWQZ_|Et-9Ycm<jXwJ0
z1xFdTN9}^Z_e1UUZCwWpH~8i>9;rX(HDx9?&GBxVur_#GVC`**YlrN5@gMHUTapm?
z8fV|jGiNRxGp?i6<YcwHhC3VTcZZ&3KJ0tBy7aozvX!ObNNIjq0f#9Y=alls-f&e}
zxIo4TgRoN?+Bcl<U;Z1ej9gz0{z$l>TKMwvtBO}d!j)C%YPcFuY2Ee=CA{qg{)K$G
zIoXXbH}0)J^i}<_(T(pkzTTL5xc*e2<N7fW;;R==LZYf3Gnb+wS<CF~mi|h@+af1L
z$OYFfTKICG({OCeJXC)yF{dRS3{7(m?FpnZf~=fb*)3mw&s2pQUuxLZaeX7GO=A)X
z*{YhRE^gRY)gx<Z7A(tx*)98oIm8G!Es+QiaO0c<*)7}P)->n9kX^{5TgC+-b9(0C
z>QNH!Ch?b;bz41`>~gYN)~bNO-?(u1ZIegeGCwe4ZlJ2Jepk}Sz15#JE!<tWQGDit
z5#ln>vzjsw<z!{IOc1}}hFw)Xo8}}oX0iMlv%ID`p~kFG<2UsmdQEE%$A7aSE0D9y
zT4rUpbWxE(>LI&CWR=T%G7qr|?#Vn%<LLX~YML8rTzIhI{i+KQ`RQ`6G4m~?t#SGr
zr~isnHBEm50yky8wP#Esd{{@XMt0t|!n*A_ys4M+%E_MDv@ofuI<fJ<$P=|r<MFJf
zImu0#p;=iiw|^(Kr(suhpz(OW1Ghy^Ex2~!%dN}1{#bxPWF|JgH}Yi!@lsQDsPQi&
z-)vfweBxIff0B8k<Ii5~KmA0<=Ra%svU*O_bPpwTRpX2O{?f3o_PnMwp(*zMwWB+R
ztKvURm_kq;XxLZxMZ>=8K8^4COvzL1Z`O`(?=!VGOjUu#SNeUhpz*k5)2HWbjQ!1d
zw$r(&N=JOD=RAA$djn(bLw3=z@ylp_G-Y}Vo3aKpjp_Sx;YQSFv5y)3^2Xb$E@J&w
z_AxKVv>i+mD@_BbF2$Y7c_qcTO}%w1nZx+dLh6roZ(8V~(7K_}vRnFmd-`<aOKhlJ
zQ78>>R(mLTNl$JrYeSIk-BVk>`!CA7@)|HUd|B0F*3w(CRKhxb1auJ3sN+pjk&Crs
zhP*lC%ck*O<9>Tj)1&|@U?0TTIOkwi%XZ~y4=)ME_ZZ*XO>+)bwc9g^V+3nr{Y%Ls
zD+6`AXU?Pm>lyLRW8_2Jr>lnE_S=id)-=gO?MV2vyS6tTN9axEiCHbPROl%1Pn)i6
zI9>gA(@tt*_`L$2pc5Kjsoymkjl5}M2vQ}|Uye8H^c#qv{*|Qk>O<8~b%{;W56^6g
zW9(N-%+)V}sG4L}%fG(?{i)ZqR9{y0+t^g=HBEvpP~qkJ;T=oNZF!N*mobnps}D#Z
zyWlaa<q^<tt3L$X7)Wio2e$g%iK-FaPA~O$!-?Khpjj<7!V*HJB9uMjM+{zd>C;W+
z19Dmx!2$MR14lQru(A~2kX=Uyp_!^yqx56_vDBt&Z<)Q!YPp0_Tpd98Xw!(uLYZX^
zd4GuJZ<^>eO-N?34Mk*GE#H2vTO<l9^Ds3GIN;JWJ2^0`<pa3VzB}~F1nkY9RR41F
z$l5^N4lv}jya>ldbD6M~XH+O(PD~6{U)pr@T1LC8Dy3=8VN|`iwb)`?eQs0Ejg9DI
zR5d((NSCi)EhWS<1T$~JGApMgq5}N%DbvHqhbw45L*8sW^6VC@_uMkatN$jlvRzZ)
zr-zbpAc1aAY!7G+&>w6KsZCuP-mL1;G!+`6rdw9lOjP2Tr{7e$-=!(r8`qfaH7)#h
z-^*H_J>xy-v(t)X+9y@)Mi03|{koCgl<Zj>VrJpDaLBHg&(eR)zl9z&V0O#Br~Lfw
z-tc8@FQ~!Br?@iTSpQr6ZOTk)tbZ0jYr?{fdxQ>(wWpqZ{Ou7IB41%buo(R^ClM;7
z;mz9A#*OT;_pGI){57s^Eo#(tkGPUAnwTNGe8m<GAGsMqa<W_A_{vX9`#tp!!XKlN
zoLZ7s5XQU<^VTYSS!5wQ+8PJoI@gMU{2r0>*tUlNvHH{3Zi%SkO>0sc-tV~nUyOKq
z_lA8P*DD>+vEe<EGSMM+Y<OK@XiUahfQ~=fg}*3~?3R#{zwyNk4hK5^_#ry1Ny11%
zTKt-%V8`{$uv;>d^nl@TQ|94Wvry>Etj6hwvS!W9&S`n|OXh-%6`H0Ws_HOg*Dd3m
z^vtA=>$f00<H1(k_xjw=a^`@#IQ5lr0jqH}I>hdc<3f<QaU43j<i>FrgoO$l9W)5t
zK}-M8G$)KE)O+UAi5S=}vvXReN`Ptr<~JT_!~G4XJ2tdK%{}@Rbc62B_hcqXuYMW3
zXr*5}z5rQ69UEq|l22UBLC%d3Z06Fr3_qCD^63{+$TGC~bn`~U4@q;82gw+Egk~Wd
zmf2azhI|=MNPbr{tm)z0ra9ebA}LMN(bX?=m{(UQCgc;#WjgpE8M+vZH+VCQb@W~`
zp!=A9D5vFm6*HKRJ_EARZ_=7GQxO9O65SC2h8Nzfrs+wrA_Eg=&cb-;EsQK07eZ5o
z8!?tegFf0D!AXBB^=B}Ihc|Q+Y;))&C};PkIjN1A2NA}y(@kr_S&ehv%5I!~pygwX
zDVyfJ)inJ8(tS9$Y0bfzkSe$F6^W`?1~I9PdvaQy2V>)!M2VQ4C41PTkB}JC|4aPI
z&<2P<r={utVeicYqpHp~;CtuZOm0XZ0|^inVIb^cSVe?@fdm9(2??7EhL9aX5|bGS
zxFJh5Mk=Yc+G+*2R;{+yYHO`+Q52<{TNSMvRolj;ty`^Ht>5#!XPKGA{=R>|KfZyR
z^PcCt=RNP)mwV2+lzma;?6c5tx@$^Tmv?Ui0=>~-4uYV^=gY9l2s;;!Y+~z?S}@=R
zKK_Q@8$RB7N{uI01)WQ?Iu=(W;XCKmcPy^&G5*l*jpE+YvAE@{-P^@I*0DJDmF`zu
z4h_h%b2o^NEBJTaA&y^^{3~{7_jwm~EWU8vp_!X&HaE9!n`wsgN#jEd*gDrm_Pm5<
zHT#=~E`5X5kr@&n^6}ihk(jsZw;|M&l8+yCW7#0mcFc6pi@f>yj^Bk)SWx;_lyw(>
zC~44f2*ZW`$kVd2($49tyC(>Yy!fQ!1&%FuY&$U&|LKEgBT?V^QFA;NZLW<f#hiVO
z4I5f3Ten4VUNMGu1JNoh$YPA8xy(GJhyD-z9io!Em<iIh-1h<1VV^#H*9Ex)V<!Mr
zJ$-5Sb=IxFw3ZKi4iQ4t?wkCK>deY>*_j>Fo!L7__v!kI^j%&4tMf7DMCn0?HWzY#
zH5}IR?zvX%1PO9<QjnvRTgPE2G^DJIC8)c<!k9D|+Uou?HGI>VLK4ebDXPU!I9gfV
z{m1tizueAFT32*GCe}#D;dgE}9l6e5Y3GvDXFP<JcV7b!$pg|@jxg@HU?{$3&{>?<
zS)M!mDM^#DP4ULYaZXcnv@Kp$AH~tynbA>g&b&p-=9Zo1l&vgVwA5L)ym)T;e20rC
z4rYxlPOthl786Ab37@QAf(E^NkX9FkC42Y%h{5AUC1~$p<gx5MUL=cOj~7jY1vX!%
zL`5^g+h)CY>6uwYJJ9p)$b+E6#Y5bV;^1)curD!<I|gPXlULgP)AyJ<dKjsoTMTs2
za_s|j7HUgb_t(TR(%~U{Rz7$KmT^{eyzp}bz?!}fp(DFON@sAKgE8Q~0b9?MguGsw
z)JVtUyFN+J-n|ljI)<)TfkA!uWC%4q0tN)y6JvY^xH>Ni*3^F+A#sizR^h*M_da=l
zTGsJ`D3J(!k77XG+VyiLMya@WypZ6iG91}^)}dX0@Sd-Tgxftk!F4LQRJjV*Gse{8
z;(s#Tq8-H}spdd%NFq?5pOVF?FI9>0FEDl%k33wI=IVL-#&Er`K*|gy1u5l&A=Gg}
zq_p(XCpj?SkoursiWdCMdY-l4=&V6|D-#K}w{tKRLErJoKV+CKN&IN!t#7J6seJNF
z-8ZT#^VYX*fAskL;2Y5FEt%+F5MXd{h7S?<Lqx|Jxt$jTY}m`YZ-af;<9URj0*22;
z8Q$a0FX0n*l)6Vi9WEN~viu{XuKnJ)1KE3qAe2&8)$;Bd%EOR<oi=Zi79Y(^_MVT?
z{UE!^bvi?V#%};J?ZwaeVpK2cU^yTQ3IlMCy!ARnNPofgo>drgpx20CL=K)KZ#@Rb
z(z3Z{ES+oDa-y@NV^*zPaPs8oV>qBoj0Y3_*+s$Q3=O(;-}iT<p;}Sd7+SOO%hHZR
z-3Nf}dNl9X9QiP}_lcct<ZKiKrRWFnyHG{0<8c(X{LV1kx$?j$q5x!KFHC9oD)AZ>
zmJw19ih-c()zL#Lm>zRHS<(0oD(ij?rB7)H_jjJq^KFbL(EVVzg%LpRMhxk*N;_Ua
z2OsIaiZVHfh?qgdEAN_tNFx5$|B%k5c}Pj^8$*Sx?xnpXTu%up<8?{DD0@<+#43zF
zFaRp+yePLEZB};!d{BkM7;{WMh<W)43_=jdMyIUfgEif6!?|M`#x2LXPgk5+5`xxH
z*(AXjhN;GTYJEYbEmtBNSRi)nW1ivHvF{rE?KOX4$>21HY{E~E{Cy?=SFd+mQ8Yw`
z&>SCNMv)SKJ)c0vU-Awb#IyJ2UcWc@8~Fe5>mJsKHUfO`*`*sI9S@^F`1jine>&{Q
z!=Hu6{ifq7wSKbeqAd5ggJ?%bv5GJ3n3pHB78_qlUyKta7D$>^9N;0Ju!zN0<~xW9
zmj61p`xr8RorB+wi{9*P4JN<T@%TF##k&sY&06>7MRjFmYdXWF-7mi_nSqk|7c?TL
z{pX@(@VnPP=iy^s=h=b#LT3@@(x;)oVf_QVobunU{B&|v3afK3bj%MrFj8Iha>pv0
zMZ3Wx$&$QGiE4(tocvN}yZ_ELcKj>rv%%g~S-U<7#ZJGt->y%**di=|#_}g0JaTAZ
z{8JeU&yTDq?d-Fn`y>@OohY9*0q8)59yvt&s;shZKN-Nf?niG)JdYfjimMf-C;C&T
z(P?lt;ES4-c(yrF{B3sP_-spq)8y2^UImv%{Ht-QVN-52Yhh~xdOo;oz*~jCxOTAz
z$7Z0Lfl)SYyK9a`E3ula=lbO<mP8wy>l&&Q5^ZjcZf<C6!#Z=6Z-00}gi~2nRnyiM
z#hX!a;+(RksiCHtO%}&<8*pDmw3SQFZLyl_C`=6aDmUQ549CcbHnbs_s!i}@AxOt6
zcEVv_WsKvD7#Fs;@?C7S5>hLxo0}T9C6vKibm$&$K}b$@L))h4qKV6OY^-F#8#Y(g
ziTKTxjkV3Ko0Ee^EEP{%v=$>FCvI2Nn_FrSJstC?Y_(K+^6C%_h1#MRG|@c~kG3ja
z=oGE5Y>QUOhJ<RTcAwf(z~r2_Wcj>kO?y>MO*Imytzmmjw6S3`-Xte((2CYp;wmwf
zG~5cqEZAHbtEzYQZK`Q)s%eZiB8icLm92;pmBP5KrG*KMT`%>`tqt4dopn;aRL0vI
z8XGwBPDBQYP#M!{wV|O2qwv-!-WlM2swiwV?PgRiJ8lpM2?+UvHwmrVnBepPyA&ZS
z*V(rhL**OraK-2#%$M=}2Twn||KUh}EX<{N&caiVhkP9{Z`Sm$VLp%NBRqq#%rp)U
zhwp_j&&3nNa}Ayc@X+u7|NP%+!2IB2*3{kp?x-Lq(+f@r`nv<%2$C=~$nk=inX@t%
zVPmzI?PS80Bt{pRnR8&ld-ojI3o_Hdl;*-E+*kQXTa+^c8(Y(1?MF9d#dqQ|v6VH0
z2Ib(2c;k$d!;sW3Gt)@Q62aEmceFzv{RX;YvKHkqsO&UBBBRk<_0NHzLKKDpbf;^M
zRvjVZ)i|63IuEo$Gs!eaYYSzl?O?5r=$2>I5!T}p5zEZ%o0*kK562I76AGV@;J~$4
zuB)^>aX7S`h)54DKteGssee>t4ogc)-e`e)dX{jcB{+s_4vEDGSaf3Imd0r|p>bQj
zmMuP+c|~DHZ&bo}2-=QLc%gMnk`;M9Hi;S5af!e}u#Qi%!tY7&t5u=vgiLo8jFXe2
zm{6lYOGdIXT)dw)g^GSBCAq>n`9ybeP8r0l%{)sIX-b+iIfsl>lU;Biy};4wB`K<c
z!y8?jj7cyPV|peE_yCvWsaks~1i>?u3vQrE_M6auW&u=6SZ9esh)CfyY6fDq_17Z<
z<|I2LB%IEe(26)pttm<da6bS;7=ki0k0Ib*6$uEMmh{n?-rvQ|DmDR<LdDyiWLSlX
z8&}XKIt!UgjQ^rU{7=tfwOE`CFh*x4^62y|0?tOf)aCROmEXn1Ptjt1^OIXJv8}ag
zqHLbPz+&da&D&a9o9o&ps{M&4t3eF?wPXJSf1!$sx~6zl#g@tnyh)2Wp|R_MdVWR4
zhIm6GmVc~EJ8<6(qq}T%LYBRDF@@;ukB)c8jj*N}>k`+0(M4f(!Y!+D6PW)e_fqV^
z59K@IChYk0UvjxKHk9v&D`|b%{pAQ+gLJ;p^<UAhSz-3?3mPlyAmLRFM#30S$bLWn
zH4WtwT3Xq*$?=bAC@;(nrr27^uG{~!`wZqxq5L6X4q31vyBQmz{MR*lVi;o%40jf&
zZry)F<3qzu*cXL;a?M*Rs~rDLHzG<73pc6#U;bZoV9{_(No^x{ZZ$goU)?^!HZt5;
z*%njV%KX2%dqjb;VQegHZe3QhRXcQRhe^-@!#c-*OUs-QZc=;C9RF<%6(Zo~SY@NZ
z-_dwcSlx)`zw7d}dnmso+`zqW{`+o`*cXPI=C{Xcn&g5r{{!u9Ww<g4{m^|on|{|K
z!?3~3@jr5pi05;|YCD2#iNnbR|6khw`f&To*2*fde(W9-*6J{BCId3Jwa)SX?S4nH
zxITR#^Yjz<bKz+Wx0JRvbF3m<pK7j_aEr<;K|j-IEZnZpVm)qk{QtNE@~LNgxTOr~
z&B3gA`CNOsFx+nNgr_guaj3;!{th?XqHc{7KmQd!UjA-3+^*n+moMEJ2*=C6+)cld
z`a7Ys#D1ll{=8I&&~~x!bJMS<JrrVez5Hts#QfG)$M-^0kf2`vb#B<)O6U8bn}z8H
zi{aW*KTV?t+%Qh0`x&7tky2j%t<Z{_G#x)Pbccj>7i1F=<@@RY?{U+|Q^81x3FGD8
z2PUL&T`ML5!q{IkKH!F%jKlI4)TjX=RzffTAvav9?<4gGhEBmwE-(Keq^w3Ucl<%2
znWD}g!L=IM+XSD3Lp!lr<K@2qkp|1t(q0Ci+#Tv4uVozr!n(mrR{aw+_>mjlkaS6_
zKP2=DY6#LhB>2jP%{5qccKj2y*lR*;DsZD|jJ0HF=tmOS>q6mb)I99U+=LjQD2@oR
zrhEBMgiO<<ZvyrX&p~AUAPt+%>oB>&AIwcGlfFUNd%Rk>(i2>9RGYdcjHZ*=ry8M0
z*u?pM8r=dv!)Nwp_-rrxtiT^{MCd*snWTL$KlD5-;g+Q}m;_X}Io`-n8Ww`kC^}iX
z-K<Euf_R!26ZiDtloXeAU<2A-%&icPw<R=MeETTzn0Gne*3g*(1mSks9P4=Pp{;^s
zv8v(?BlZ(H-nP&;1dN2+%eUbQL~ncOZUJ(`?F&#Z%Q5G1ybD5q5HK&?&eV0h3pLje
z)RiVq4ju0z4Mm|-eNELSY=W(6-BMGnJY1~x8>z(dird!aM#sA(^be6d7U9=ap($1Y
z?$GQL!np5nOG8x+nmIHkm_DL&YN$eTU8*@IA&D~~qA!!PpR`82l{A}w;B>p>K?D}%
z#zYafY}U|hmig?9@dvCEEK`eR5-OQ#3!EYu{tC;><WmB*n2W3v6H+-*0z$aXIz3^X
zNWqDoGyI=e2Bu2FuP6(5et5diNATbs2;tK-PJhyFpR0%r@CE?MB)!nf@z}$v!jkJT
zcovqn?aSMksg5^LV}5vZdue5?o`*UdZ;(cV^r2`(yul(Ql%JKpg4R6mGU>G=Xm?s#
zN;r@9j`LKzj?%(I2ab2V_mD85r0AXB-VpC)flyZF%4&q;ov0y{6}{tLDKOOgTv%C3
zFt<-=Hq0B2@lGfo#iXQBg%tG)1!56tL?erPJH6rFTEQj}E8n&mb<S%SWEv4&SMt59
z1e<}nQrT49ytxUjBPyT{ybwjPu?F{tdZWBMg|P@lTAgfQOXPT?z2^ikL6(G(=o$WA
zsNI(}U6rz*!kWz-$Yzoy<s%)y&J4-$zX6NlX96Yh>*Df=b!Vz5cRFRWVS)eGtveH^
zhkwJwabiE|+L&AkCiou%0K;7iC(E8^y)pfiH>oj<5d5AeewmI5H^3K*Hwt3PDJLD9
zZ(66vtP?5t`YjAU@T;5SSXF}k9@ukCBdD%V_q>evf#&l5X}8Z|c=NI{JoMxJNxPQ2
znzy6I*^pFlHOBFN(U-k_hR@mF0CyJts>;+Smolm%X8_40o#mzX?}P<Svbsv$3;K^o
z_b0>DGF;{DW%OrMI8HTvxYwsY^8#a4rw{j6dexC@DUb97?-!9y4C66$OI)|^{W79t
zIP3-OE$rT*NS*}chnwW0T3iq7J*ruQaHYkbhzu3JtYq)2+OS&Ycz=kD6t_sYp}HOC
z2^{Z9Eg_c(R<#`Osff}y52M+d>Xpq4a2f-b;ELPRntMoCu7IDnjS9xO_U1jKouXkR
zFBa#po>bh7S%UX$gn1XrAL;ZN&-m9wu0@nHN&DX5{y$~>TUKKg4$Vh@-jT`vtxqFa
zYa@@4m2|1MIkFIrs=aE`fw6PL8X|kC=E&E@FM2m9)r5}1@me*84sIT_Qb%9Bc;rXI
ziB7Jhp{>d=Z;3o6a3p;fo3gFiYMZV0$h+c>W=l5`+ae(u0;APJlZlQ8U1Ma1Kxnm=
zVJ?7PQ1hU<n%|59a*?*9mBJ8*cgK4dN6r&JXr<I3-@7ETO%SwE`p#l+N90C<&`8N?
z7W8gfK{QdSTi&SwG){UR<L%NAS|>Beb-djgETP&>)f{`ti5PEBghzWr`3pHfP_1o8
zBr`&2iEf3?M-pVqpG4odl^Dl&**B<0=PKk^hJO)|zHACIeCBF~&x)1dGZR&d#y6PR
zbjl_LCswTt{~F7{{1679_gnOsL9<E0>8~*086^eHgk@vaWYY=g2Ns=RP}QwV)63eH
zO$Tst2%h2dzVQqni(XpOwbqwV^Z@sN3)dXW#XOS`vvr4EZJn5RDylXx!*q#ddLorc
zbQ6pdErj<680g>ecYw^jvaK>kd*(@oe=9gt3N!Ciu)0b97*2_yBNv5n(Y<YAvb<kK
zc<p)moe0nSwXI{#=;scK3mdk08yEH+?_rIkg&S7l)xq-G+O`@L_(!z204o529Sc`+
zDWFHl(u8c-<^<kjk>A*058GhTPGhk7xCywY_k`m5Qxk#rTWKQ0m92GKbY1_QmDbFO
zz4v=7EyM4RFi~#gFT>C9d5*m=8>EnYR3dHQTmS=w&P|Kn3(KHQHQS0YPj7S5hO;k6
zTQ#Vvxn&!U&^c)%6ygGjV|<^Mui9~cP<@Q=1)Q{z3J3<(HngH?OdB;%Ciz)laMH#t
z6idVzjB4Pd4f-X5%OjbaHiciX8^py0CvB?o;|yxy8C_%b2gyr|v}tOr6%1+-jZRV4
ztU*o6s=|*r1NrfcAZ;{d8EwZXN7(DRCnRmG3dl#gFy<LPmGFHv)3F)Li45j5c7EiC
z(%bOHA{I^I$l>QW{481E$>AqC{J!pT6jq2!<>Ti${A{-wLFMoh9e%`pjKPM|lvD<n
zgKu{D{au#SK5Nia`;*+az>`Tj%b)Cy#!4AS%#J_Bodp_sl#Vqx$DgXF{OCdXeGkW<
zrdK8cU0=wZ81y5`6qRG{Z}-dG6|iR+`vm_P?_3NE!qp9}=x)?}@>x%<966{bHM~?F
zuiAKpy#JhbaKmj$=utDsPA_6iUht|%QQ;umr2Xnn!hcaSO0SMpqd$8ag)_pjgY+Z*
z>zXCkKy$fB<@j%C9346a*YVBq#!8HRus)^nA!h#luGb<mqv0ksA^*GP7^wg)?;jc+
z>*Uy3`bxJEDUoIDx&BR|R{+SYz`t46D>z8Pt0u?4MW)<rN@V!u->U6tSZl$2(D84R
z1qh}>JI`GD-wS1qWU8>k#^G51`yr0kLirI<fPJXH%6(UdPiwA!N$3jf+E>Bvu))i!
zo8w;^`ZI<YGDus=0ieHAa|B^t%a0ItX&@_%mto8J3en%KwZzb=t+cgaGb@z8M}z&-
zH!}Oa7E&$10PrkqsK#ql$G=>&<TyE8xm@jj6N+Vl%=34;L-86%DY?s4qb`hv=AlOI
zcK<zGso2n@*HHH8RmLFPR#{sU+g8z7vxTYgHH~L*tp^3|GF{4%S{%9wcDbx)A;r?G
zSrIziX|lGK>*VM&o&Fm4WayHmt=0auE?@73)yq$G63v?$kWkm@3gd)h8yclu^uO(L
z0f>o-0i=SyqoKSo4qn$O?0St&Kw*=lyFmj*VSMD^d|5gAuFI99Q2xp=m-{OCR<{yq
zaifmlT2*}ZYwKBR?e~CtH!6Q9|LkxTkFr)sOY7gH6+JgxjYPl2<&Y(mzuw8=30KEo
z>z;tvWr?N4ALcK~LtN3#`B7h2UzMT5Woagq@2apy_$sVW`gu&od|$2H`r(!(HMP)m
zq^}BAfVIYkIyA8s$pQ=4%>7Zms^O7vta%g5#~A<ZVbm=*+}2VF`&exsf^JnhT7R6(
z1u=k@e%V^FG;CTT|0I8l)Z7W-24IdqL3^1LZV*Kl<J%Ql+R55!S~|bi;1~G(&R!^g
z29{#EdN;{ed4RR!g*7S;Q?-vGr%#Ap&T`ixxiU#d{8j$<nRZw&X1cD{tWG+&m-}n9
z6=h>SX2)pwkn|eEl*REY{I^B#EGI{minHDOATCQRL;QK(uHzuQWkGB6X2&n~lxhGt
zwpL(?H%|1&gllE9<Inf>WJ~c7TA(>lmr=PL{|w!HMP!lD@z3<?MFM6(ZTK7$-V9(m
z<1f+8bzV5$g07VxT&i{ar5Zghtd8a>beTqv$1*xUOs3G~8a)AV!w{Qadh*Y4uSSHj
zj6Ld~6Izb9D`=Rx0)B4j=TelNa6@TpP3?R(mg{u$5t7-MX<z;GH0-H@S)r|dIuAVf
z>rDeHi!^>^$d`JRrFz8;A&w;37+gT+Ds9C?2h#x@lEO&EuMYiIn#erWI@N@p7V8iv
zM}ND>Ki54EnrCTimVdtg9mWKi8uv$zrhG(e5mIuCDFmuaY&H20Q5=9Gitg<qNo<q+
z?|Zl5J~9>V?K(Rl3Q?Dq{tlgecoSs45#!(KanXbwMr8x0Q1e;Qe&EF<TT%0L$-hgN
zA5^_2Onv>kwWQpz`KXKkL!0Y-8>IF7k<E1T(H8$6t=ABhz(4i|OIT6Wyx!}n=5=H^
z>9aEaPrN2!8XK<Ez07?cCrqLI2~Lh#PG9fdhsbAXYsB9i3J+loFz!tuz22bGr#Zxd
zJsV%u_P5xK=N#5QUw4$KUiw2aew8~A0<*Mrp+6z*Ufl17R}iXsIyp@>PpUO6NK>sL
z>TesS${5RFR_#yJC<gwxg`usv5i7WkKS`rupwb3S)<8N(LT&R~>XGDAG!|gY)W&yc
zTg|eCKUF(rsFrtHT0077D8CQ7hgQ^sQ_>2?(2nd}Q_s6c{OM_`v5lyq)2UkX+;Gdn
z$}K!d>(9^}dEpit%xRi!2w!^O&6?xSOj9jjRORI?Z5<g_ZTMy`V)%s`MWee!cK7(R
zweSfLuBJZz91Wq>)l8?SsX_I$aD!no(2Q_pb#*J(DOJ)GrA?Cv79y|ox7++`_Yq`H
zma$LrulAjxY%U~8uJLtqp(@rlwH5C@9RFs2s7Ujj99{Zr-G1<zrEI1CXCZbwsucal
z4v<s}`MG{|fGQ>}<`<#<QgQ>dOVW4$S2G|pbRGFJq-ubvTaKw)s+Vy+mBtu?a+%Bz
zX=mhux$MICJS-6*hoflkB@|yb+#_XF#*ZcWX}aDa8{`Fo<EMM76kuFYjRmJhlgxc|
z2$RCxW40W7%rO7Z6&bm~@`z<ZzpsW)3D;L9hIRckIz7Az(>-bVvo&<8yeD47ra7Xa
z84$O+p*0q-MDH>{gQo#BZ<BL0HdE@c<L7!4C8mXX-OC^7aTz3(UleXq6<xXmv(#RK
z1|ta`tXqwRs<AmvH#SR<(`rOf?|y=;%~H0&|Fw5&6lG?+;~(_4OSsN))!Q)Ac-Z?c
zr&jJTv>(U8{)n;<gCf4uXBr!jjczggW|E%ZN5WrF5Qj<q!+Nrab-*e~p8*;{OT-*?
z{G71L&OnubfnikwvcfS;&#_S84-Tt=58f5%8l4wbd5QYU;e=|D(ACNi0Y$}hJtu_o
zq;TsRJ0x5pR@B%fc!Q2tfEvIA#g?v3Zr|Zd6zIkeVNLL#PJ10dSeCi`XVT2*JEq25
z&uYMz=>E|*TQRH|qu4xW8Y|HqY4^OY`lu1AqrywiqiIS_OwsV_L}$*6X?nP)a_>)R
zs;gi{sN7%%<1cA68pe*x7PZ^Le>qJ@Q?*mCq^a~B>x9$?8N=iLi3sH?i;Jay+T_(d
zEF4E=_?)d`Uxt1^DQhyJQY;L&I_bkEV2F^bEa2zFBtse-vuI;K&zR-^-Q^4Ca0BNv
z|FAOxd@F6G^sE2WkS{N09sfNuadD0h{BVdnH%@41Ta>iX(@&QM<pfN&FaxZ{JMAFE
zMPsPIX<UZS&s$~qUm!*UWb1&Mr0YekCn0cv>=sDC*<C2w@bXu<skJb^>{iSA89v4)
z@WJ=>iP^q-4I_(gd`AnvdBVlF_=-!GJz4IB6%2EPfv@#@GVq-s82H@)z1C@&tbn8d
zbwqZ6X$T|yYY-<cLkwJ~$$^+G^+6yVhOlE~MG+1L!<m|1@I(Dhic;d$q*mx}@Rs3o
zW}YF#HN2a`XaFf2<zJ5EGklJ|vdp(L1An2%;c>V@4YwERW)<y;bPbDjgUnT;Q^1!Y
z^QR1-ElY;K14v)4)0j0A`K)H1|0geuIxR&WTYK!V-b{F2)`9qH!t;u@qWj^ZNDVgg
zsG;Di+9504z;{0WYub($MNLPJ>CPcHp+GH$;+VGlO%_@VU$^FiN^0TbEl-V@G4K(|
zZzohpjDy}W!6T-eKxX)RBn23^41X?{icB-6KIxg|pC$7h6YSY~x~RM1b7VIF2XkB@
zk`W8$1bRY>$g5%1It^rmv2z;3p!2l755l|<A?p#j3Ni3oWiYP#`8FK@a+51kF*7iS
z&-dUn$9#*_ztm^-G2;#;YJ&eQpY2(AJ74R{#&Q2zBT&h|&PHJSTx?E86Zmb7U_y-M
z&GEmZXO~&3Q@CDFK4nd%xrGZ;97^7xqm&!oh<U48B>Jw#28J8VO!7vpKZkc{g7@px
zL{qwo8{8fLfGErnMOAYn8y3gE$saFslaYusXI?{Q!pf1QtxOya4`C%`Yb$67yzD}U
zV!&G7g6&Fejyql2I5!5KVcTJ44Ib76f<B$7Yu-$9%Sr`yjaN6Kk#)Da%G<BtZ8#Pt
z+;&-*7~U?+k?uBGt{lO&N_V@g;v^*D?KR)PVJoD|u-x}40s~_J3^E@|3=kJ*qzW7J
z&B}OVjFRmpCHFL?00NM&QPHd$i~Xi86g^Wd9CbOP)cUnMOEu(O{%GpDS}me<Ib-m8
zPxjilYlNYcVn$ZUdpJ~0WFqfZbI<X_^#B|fgd912J8vAet5Vjv9vjn_;WUo>2HbVB
zZ{QS=W4T1=o+nl73fM=r6vx^fw?b_q=yJxt2~X~NPgVrG{86$Z=vI2NBG?t2#Dy8R
z%HzV!Yw$h>;-)xmwaCkX8WZ5|<jeLV$Gt-M#%y%lPGOir2GnFHzr}I)iX$v1H{lL9
zd`MG8t*K6$2zR}TJACZM!x;Vnu`5`nx-iGBl%@ABr+`cElO1;hvnkZ&7jR{sb~eeO
zu0Y(OVwG~w5_j5_dt@SVriN}8BM9eYZ0x5ZN{4x(0}ng$PFdb+d*^uQ&{A2=J&=xD
z+(U;Ft-~a(LkYw9BfJ?U=4&N{0ZPm#LpK;EvZ$Rw*UxD~_KIZ`f}Ok=Me#|Xlc1lw
z<T7Y5Wh0;&aGO#Iq7sBNm0TZzi>1X~DjeGl$1UV=rrBD9Q^i~K=T+SkrBqJ>$4opA
z;rS}Q3XD89u!;?pBq;*hVmu$Eu*d2-7vSot;|^2V2lq92CivKZoCqGHNNm{RQcgvy
zT=VC)$g7L>U~R%v4fc&EA=y}#TV!pqD_H<WR&vEDDm;^{1zs+|a|68HWV~(d?JdU5
znibab#o~DfJa*#Y-L<b8&lmUhTqT>l+&$vyAUr&XkhAdo2t{5L-J?BCY;fGK@#RiE
zTqmONUq&VWj%WIG1k!+K5&TSSDM9S+ruRHHNz-}f?)`YSilZul53-*;3C^c-JCG~Z
z^}_uaI6uR44Y*I0TKNbo<rQ?C5k+99GjuL&IPM=fAL8dv*>Q4x{4|pn=B+heJ)q5V
z55f<RhaAC^d9sez`$_TofKi#84#{TS-2ISHDIjMi+ueKM^|yE~1TqOCX1xS3)a4ZN
zGIY1pnQekz)U*ZjDYl;rP5WJ^n$M@;eF(hYhi3;wj6!Qs=aPb)F{~-|k_$fe{UAcz
zr#O>61^1gRz%v5)eGK|KfbcTw7BT%<KNd4^<`^9+xFwq#GZTHt6|T$3+>hsM$cYvp
zd=|q_(>#xA;$}_vN>Kp~&Uo(jboZ)luw4P~`E}f{>$W~C5nt@$Mqg#y_S;lk4<ei#
zgmWjJhfP?w*|0Vvq}xnLr!$hz!o%P3xVO94gMSL+^cg%)VI=#Z>zcw?j|Slsk^lX4
z3|Zms-s#RIuQQj7Hf_*R*~GwD0IRb&8|Jw8x^5Jnc%#Qmi2B56cCXPa5ihktL>1Rx
zt4JMyx9?znaWT9eov0J=pz%8XQl`+u((WMrM#<u=`-qNZpn9l7V*L{YjDLvikLm=C
zp!tLKF;~`DyK={KjnzG@t$E|Cm>G}Dpgz<!WDH8q5tnu7Ge{cKw2XV~+~0_7oEbnx
z!Jl1tq*T2wIITFkU{ghPycM-(8;6@4621fAdlk=3c=n=gmQpe>q$`Vx<RG<vXd^jT
zE$nm!qof;FTXaKRSuEklskOx}9mC_*vayNb3EHY-I7F=<cMTcM>M&HqCReVC9$Mp7
zuRB)heGK}p!TY@zVe)faqW8E|y~l@IP;3&Jb5cU@m3TE!hMjrt1dWOEC#Nc3kgEK|
zROKfb<t5dph@2Cl(U|QlMKc_Csw|jsTUb&)G^5MnMVv`Fu|&maJs5w5rv}ffCPqtb
zjAR6~tVd2PH!(7WVub+rLqtB4v`nl?!N+84y;~cSf_M;oNAWy?hhO`WM65MIj?x?P
z!7Ur{(MU+EP^(iZ7~QhG5$$rF*web4aDIJKP-v9+f)3+Z71%KZ@^3u6(e)=LuyzyJ
zcy8x+w}p<th0T$Kw7o}27bZe#!JL=8Y91>Sa&8qsLrU36<zCKeRMg|uBw9PA2{jmu
zX9k|xQ+2fWT21bS829V4@7-#0RS!+N5}L%4LQ`*nbZ9rK(4q*1H~6*SxyyvMKQ*)i
zAuco6&~8eER)$3|_ZG2-nZmo>q~NgeS&k~`0Pj%&GB94layy<O({%KHoEqT0YR%sy
z^iO&Ocz+^#7be1!MWY4SJdN9C9QUXywu~0fcOJv@iV5w75J_}e<1(48FG{f;*%!KS
zgU#aRcq?8ZIqsiK@g3DvEH@0hFKHxeEUqI_M|9km1zS$vEqLwCYoFa$LfsNT?wAcR
z&GwqGZ3mlF$YWyt5v(W^Z-BY)RYLNOd7^lrr`X(vF>r>b29RLC4$ljC&N)RVU4~3U
z*lA<>)JNtZ)A}J#IZoK2J-7os86rq6$eqxFpytVUQ+fx+Ml9;NY?=<h_dJLy!}GZb
zE^2}sjgtz?Yq7F04-p>iWlhI^AFl;VZliHB7;j4mpX3b}I0~5RP4g)CTSh$x#2`HG
z>E0BMV4ed#;c_TfOy#&!5kFZfqI8+Z4srTY6#*$*z-3O~{-9IR4HuC@fu(BxRtizP
zuH#EQ72uSXWT}aXGm<B+?23SUhw}6kn2%svz^QoA7@Ue(o)nflC50~oHWr)1F=qLJ
zN5}607{_y5?p?A1{Uq$8w(}I2d$-z8jtt@u=SLFi@ey4P?vXj$`LL>4-;ZU&_AKlr
zRH}MI1rLO{^ZmOZ5JiPOUm~7laom-@^p#IR*MH#oD?G1)O5;V}RX$rE6c3b6s=L~!
zx~R)N#8hm-ROuWg={-o{eH+|^dkEa4*iy<OvwLn2aqEn@@e=v-)N%&;UKRHW&7M3&
zqtYy8^(wGQ2<Tlrs}Wf745M~~uR2Gg_C^y9`Y){v`mjb3|2_B|)3TaXcC*jTk3T2C
z4yH-ec^%fI*y>&z%PD4-e}#@Vw8+PbR|(7~p^21|PDyg4-+1ZbuGA6o)!<^Ujjx*G
zf8AHJ)hso|zsgrr{D_Pox`g?wMi5pP$%XIggn=qGcrJ%JO{ZyfZcJ5Yf2ukMdZ=?#
zsya6tb@YnEExuZD$QAW&`+rxD*><net_7OCi060EuK!G}-A_`ryDwF{`+I2j(^Tz#
zX0(&6`?)Yj5W<-498n^-AC!f-nShdW(_~`>cY0%a%>A8G@EG{Qx%f^rOn$*na`X3A
z!RsN#{e#xPAJ5}%?vp+j%CVmDf5>MNysAQoK>Bn%`w+sjCWO~gLpWwbc%A|N+2=|-
zLzr*JzIBbw8!%<Y_B)Qg9QS=Cy$F(dW$F`<o~ZG7>m*+csZxhL-Tx})QZTN^<KQWp
zr6c=aql&Y@2Bww|Dyr~Zh$eg&!Ocx`>8}RQ3_OW|+T>`6dqtYGEiG{SAs(6sDW7wu
zE7Xf&G;DI*)$L5<QIPw<A~|@aI6n?+l2{CE(W=!{Bf4!^*~3~ocE~#Jw^cCrfcXfX
z_wnQv>S%mBO%L}+H8(Zm1uB?18%}M)WV03C;>l?%_ZB7YDTw(FX5!=U@Y8-$1a7h7
zwwG*BbCp}tR2%7!!h1n@R^s(6^OiJSr6p3gisK##9K%;f?rmbf4fY8K5YaJa1n{FY
z_T*0ze?V~kR_e!TROEH~uSHqCH;wb@f5D1hhCd9Gs6-aTu-%_qn^l}1Q*k-~US2&M
z;CW>>dLgR(m}qeT&>3SYVLzO<1M+?cyD0s*IKKw#!l!_Dz}uJx))c|d9t>*}HYHYK
z*z|jWngqfO1jiCkO9a~q%$a@+!T$r#_l%5J#PM6=_#Pa-#B<0vJ}ZuQ(s721;IpX_
zLw-RVenSV<m;W7Jq%X(43T>#1-o>8*aoxU*<6<K2kp6S<H_c=01wPX(P|NvdwSiT}
zev|kj6r5PO!8m*&yvcj2GaTy!Cl2*oV@#crN=>l69~S3&_zOALfpXpd^y`biF2Z-H
zgPb?#LG$X3buBFuv5+~jpkN}F`X<&@RcUZq!6{R*a#Ph9#|T93rYk^K<T!1yYP>Zr
zsE2F^a?WqW^)XXn#ZOuAHW5~E;x&G~qBd|msmK<-<5VO@T9AQ6`bEgC^@h~$Kl$F1
z{<7QK?T4yeug^|z%i2P(&*ItF>^kZd6nbTaUcp+gbgh@MGq`)!#9(6l1#d*5cV3}4
zVy(A+?IXcNZ$+@roBH6_yzPZv*1q8GcwJrHZ|<HwYofR0uDCb+!TrHQ-ZR^RwPy{h
z3(k%&_09<j_SNqScAXjbHZArBF7`GRdIO{0rUGwZP;jQVaj`dOvA40%8x-|67I=e#
zf@RCRg+cAkT|0NJ^`3U_Dx5R4elGsZ*~CAg>4Qg&+gY^q=o;@B7Ci5|WT%&L<DUI5
zdXGAV-b0rZ!d&YWt-U)Qe`r>Gm$yCU_1Sk*Feex>Yj$;O(|)gbr+3h)jlaImYkv?<
ze?2-o{!r(&e>-~Qh?n)C*Is+!H@58hWM5HN)z+hTf4JpCZ~I+d#=fo}ek-V}Z~cbX
zzO&2g8$3T^!X$5KQ0PsMjhIk7C&=mAy7m5TkXAUStLrAO@AGHPs{75Evuo<F^S1BX
zzyIc7Y+>D*-s;-@bzZ@ZUg_ff`(XxyW3!JO@CJk`+<o5+Chop_(GQ>V`rUN^DX=)G
zLuzKioHKLsnx#u;*45Y511Y+({iru<r&qM|OfUP1xR)0c{NnBxz1q8ihwcup4wia3
z4??X6+n*^4W?y}VmmS*|+)_UGNO1DRu2~c7u0G!z{QSPUn%R?sqMOcN<@FElDlDp-
zIp=h*Z!e+`kgl2a4PKuD65tsT#MaJUGy5tpqqc62*MITR`XjR@o*4}EHt+L}3zfPf
zR@cs18m#-vHZQ)`%UtVyc0tVB>j!UogVuT**LnjBm(E@jO#REOiOYXD+xz_m&wF?I
z!P?+#FDo?C9aUaCI~cxZ*_wu3-iuDC*xk2%|E!6-E{GqEx1V3PXpWb$ILHYm1(Sh#
znTtasj`QAhV!_6V`@PF9**Pm7>}m?WyCwMU5BY!A>{%?kH^qaq;>%`FtO@qS_s6{_
zot<Z%>|J?DP~eSuFc=<8EAh4!E^64nY*D=F?#q#C1$g!iU$b`hfuR@H&6?dc%<B^x
z@9x`N7k_->S>UbM6%TS}PTC)!pqGB*NSn89?cH9^o3Wyxj!7LvLG2>-!M<;H&OKr7
zS+gddI`vGbo!fA}*YCl?Ip3JIzro9VzVP&}nFktPWeLi>YxeA6yS&`!Z0}#r6S32`
z1wWj5_RzD}%?a{<yf0X`CzPKPEQN?=-`L&tj<+p#t+(-mnUlN|?y5a~_J6&h1zvT*
zydcNhT1a|Z?cMXd=7L{%kwPz4aJQFP7<wx}V}#+ogBudRbRGA?Aj|hJM~i`_XZvFl
zHn(4}Cp52bT4kTdz%e&-aY1Amh{x7yt^+W?2Y-gIcvsrj{L4^-BP;qGntOQe<8zh2
zih}6o1V#ySGea!}(eoisGZK_lq_J8yuWFnI+Q^=_%m13Uwji>Sf+-emhL^8>x{`Po
zC_O^E6G}Kkv|PSE!E&0Cdq&?hBg?oK{lB=E!X2Hh@?X;1|9ZG%c4hT0(YhM>d;`J-
zA``Ek?mPa6JNkS19fbR5Ce0DPj_a8Pku@o4z9lJP=OVxo;~$;cG0-M_?f;B|Na)ri
z0YwGDyd3w8%#tK*Ze~eA#KeOy4^A+0pvNj5&j~slz8P4O<X*DNI|sQZCF#(@%rg%$
z$Kh_|aRf8k@T1JF*Ya2f_$!4wIzp?rlm`^ZMp2N=#hDwJ-&(FI%Ln1FJjvfC(V#f9
zvIig6(38W5zKHGF6ntndUY9a1{BgnDra$yFWo;f3a6v&dRGXCU3o=U+#h#K-?AyRo
zRuHjujce1%bq(RJFNl^&xJ3mR@u*-Ot_5!e-6P*n*Ul@5BKOM@Wxc4tpU)y_{c_dy
zyxxA1=Vb-avy*bTs32>8PN)cKM@_zP`IG}J6K***gWb4u#q<Aicd%skf4N8D9!-*e
zZV&lf=)>*=8~$qTJ^>hiT$;NGrqNHzMX0zSy2dmv^e{Km@K3^WRK4Lx{YQEu^%_;V
zoSV6*j}*+}%t;iEAD6FghM6LNRYBxpTkaNQ))hpTBTFS7^uvXsdB%?oV<QzgR73{+
zxGwZ5+ASkjm!l;pM*m345fr_m%+U7=q74O+btpPT49BEB*J_4BmdHRjD|)0IS72-%
zMOig@XW9ZTnmlCuC(80N)YF0}itYs{hy{_=N$QvavVdyX_V+!=nVKXAX^IpwWmpwP
z(^gN)!Rz5vUgT6NuSt8Z4m2e3>NGm5AaY5s(r(g(6ZYhKY}ygy9>Hwx|8nPq8BK;t
z)30dXOX1GAn|$lpesdm-Cf2%}{>8LMEpYEq-{%)ZRM}XFcE;#=5BRWC(aJIHYY{O1
zo`U;tU>ZG4JA|AGtxCx;XAw)a?T$+_okEd-vW;2R`AIU?NiCS0iNbtl9~9Qd=4UP!
zb8cp-HkT8ocXUCRg2a59=#ogw_k9`95N_e7IZEL^O-#T9r^)!!FAVvi3QPG3qZbe7
zUxQkqeg|OOgonH|Z&7qW^Djcj1DbzTxKDEd6k_-^c~dq0()?88Gyw`uliO9u4^(~!
z@b^wUu2V|mbs@_sxfniOr<}rMoyRGsaU&kj>3ZlAb_(290~Q*TD>!`0?*RTjhsSlw
zXuKihY6|{Xp)^V$#C29PjMo*J5L;%%f&r}ZJAl7W;BlQ5G~N_)O+x4j3Y{;K)==mx
zicAPykr28Dtn$kS)A7PsN`oKghSKz2rbvGJ`duMQjh~-^P_Zkep;EQ$T;se0+)S;I
zGikrUIKo?jhdD&ET+so|T|#3350jgUl1ob~>=)oc4qc?3K^mzt7SukvU|y~0fMyg0
zm3d8*+k}#((%(;n7t3n;mxQs(%kLm~2E#8h;W!vW6-k2<lN9+r82^h0NoV|WYtT`F
zR?v7|ku*L~WHKZDraN6hxYZe9(~R4Oxa|n}O(R``TtQ=?B8>zxY6+1P2^{}U#>2SN
z<lZFE0nO8djt4Zk#V9#_ieR6sF`5e%9nf4PbUdKRy++CYI9^_%F`BCs9nf4YbUdKR
zy+_IZ*27+@F`8A14rta19S>-76H>B2j<3(x7|k|C2Q>LnaOOWv?m|lTw*&S|HAZun
zq63<j2^|k;asyJbzk{$ptTCF8DLSC}p3w1t=KBiwX^uzBM?Glr!{C%hllzpC+oGMo
zI`F7=@m-hn&+xd;8X6BPk_NXJDXtwM(w{3Q8hH>34>WLDr{?;dOPag8QI7e=?zxJj
zalIl<Nupxh48^Lu5oRkMc=|1jXEkhCXIp36mf)C<^KD_<8qmBM4}8<OTgcKM!r)#i
zphiv-<L#O;gn=GC^x#Zru{EGJ9&`^miFPL+cHF)RY)e3MAs!@#3FsiK4~uimr+G-x
z0nM#pl^Ha*2_5rk?ojlFG%phx1q0^g3ioLq(6|ZbImmlkWKY^(0JrIQdZ=NX2f*oM
z@!oYVO|mA(i1V%=3l{Tf-mmC@=5K_K2Q;~{E4iF<KK8W6Xg;UtfM$RJ56d0Rh|n>g
z<_Q|7$z5K_@;-(?9~fG^4DFoM_;EHjT>GGzujqhgvC#2=Cij3POXVzYg~n)>D>|UL
zS7>~D4(2|E`!u=tjM~%WUa(|&oc%qlF`9=I9nh4k)ZmXMw_ed7O<oK}c{I7-D_I`5
zbSYl0H>jV%!Vapo<Jh*^;K)7A={THa4%aei;wmJ{4`}k!3JjMfcXKgZnwoAmLO27x
zNxRd$MbQDx@9-@xWY9bybj+vusK#kNrg56w`bGX^*}oL`uB?Q67YAtan+3NLJjiMq
zr9zf9z-Uq^jq4Tq7K~iTM+eA_T3=VBk@PQwIav9jF-*u6&%>ZU$R7s&(c-6+2JhoS
zuV=i^hP7O|Zh*l6l8PTE)!gjGB&2zZq63=TOvNbE<fgFX?Byi;&l;oohN1(SWtiyF
zA5Ct`qCc9NHi|igz_{Q7b!e;*at#f|iFfAuR{(6fIG55W71B0>oU~WsVK_9a6dlmq
zFLXShd8@*GnwoB>$!%82S-Tzfui;5bCeH027B)10Fb^p@p!vMe@qp%0g<Hir=l`?D
zXuhH7fab?S#{-)GR=D-YwE!0nqeRnFbU<^E(D8sK_bnx73)cvSYm8>Tq63<z3mp$=
za;+fQAMJBBMzdJa0nM|7#$qr`ZX`<f$2EoXHAb^d(E-iZgpLO^k15=z$?ZYO$xRtI
z2-fA(d<YL}LV`6>4#;}9VvXEmSxb{x?dX%N9l|<kKh5j#V8TJ;5k(qbKutNL%Mo!c
zrSXblq(SDS^1!u`$#|F+G-oI}pxGvLJfIm<xKHyUjnm{tA^J5NhLY2x9&XKe5ZuKu
zE>omYk*h2>;h}Guw<tQG`I*r1fF_q#C8xN;B6OndItKTD;6Vs9J`i&Ce_*786DW<*
zLar`?LH|jSC*w(g(qs~f*|qv{XA$8fPA>1Pz(Yl7u2pnEvrFiBK$ClgL|HA0OFmC)
zjOMe74ro4)4JS-4nn#6>`7|}%PLtb+l9QD3-ogXbXej5z*eBs!MrYoZg)x>9lr-E*
zFs>jY_XuHdLdJI$`6Y~3Q3iq1_!v*fX^ZgueIcHtk<35gzd$^d(l{h!IgMu(NvS7_
zpK=<*@gRwu5isRAKL(jJ8JDCI{2+WOS*0|d6Ir4mRSP+j_x~F@rHiN1!7wNn$wGtT
zprKKg%v8EWahPm=0{)-Jla$R|U3(f2vykQsiVkSLC3HNX$=y=P+00e9_cccILq!KP
z!&oU}7SiP2sAPX!jhn17no|`W(0p3xctG=ch5Ix$-A<F+pOTA53+$KSNs7`ruvRFD
z#vg<%H=dIcoVx7A6LL=7PxETwETwUekZWk%r%)PCDU`-@crfM>{f-G-N`vYpm6Z2j
zeIE}~faZsa4rmU=8XjXplUu3CLsQcx&m68L@^X2))10d4faZFk;{i?Xe<BY}O<NgU
zV?1BG(`-|8K=Y46#{-(&r9>GtHJu{kr{X?oKh1-9km`?X)}#!$0nkm#mBuqd+Ag1K
zmw(2?aA>}v=zyk&7Kv#>lN*xAV-$$M-d|%ha}*uWoGNrYpvi4U$^N+3Iagye=PNp(
zxj<;Fqrv0`qGW%iu&>Y<&2mKtG}j0n4`^~NG}#~Rl^Ua2rRacWwb1c^Cif8~`)h&y
ze2vj;Q*=P{dqT$pn%rANe>631N6nW4`zD^G%=j*>H{(fnTAV)J-U<6@xlMrc6<`wh
z9)Lf_L*X=kqUeC;6GF!Wn%s4itoT!~KdmvE&nh~gxpg3Uu^0h!htM&f=9L<!xliLX
zxdkb?dQ<j=f=%AP*Sb%((~png9ufCR`}@N@4i9R00gO3{G_fm&b-6&L1}cShO)9h&
z)(cW0t{>lohf$_^i=qRX2ZfFYG#^&DPxB>>(>$hen*Y=|&G$4;(;1|r4U?OH7#7Wl
z#%XddPja#!fWKdgj4lcL5lz1gQ}K40h&p!xdlXO7G9A7D8V^@IXi{wy8ybJoFilDW
zOyeC5)1=aXX?(6>n$#IEjVw`j(tes$2e46xn*33GwHipYQ&?hUGQpRan^BRsd-$am
zA8U-}e}qm9J*iHnsFMh9J=ztl9^%)8g?b*NG&`h{4kJGEm9RZ~cv8Ys(ow^4Nie_g
zkb1I^#|TYG=H%Z^Nm%NcKpp_J+;ZUW{s|UIJ}bw=ahg$|9OhX!jr2a*_O*ngItFHr
zEc2L}39#2$G@d;(jwy%79!_#d9NOX`EzO>ECX45<jF29Og5=oJ|8T=zQXUR6uDuW6
z@Su%xRr}R=4#ptn2+Na6nA#VrPF(Qth~Z5>`oUu!22VYs!Sfi}CFL~5KN5I_K9g|H
zDV9}3h|TEfDWL4Z?{{hfll|)4n{I+9z&+30WuA;d7WaZ1sMnTlZqNQ-j+Dp!(*MgH
zvbkZ|I``Z_%+138%MpIL)7Lon*t+XrXRLKf-Kfh=xyGr-9^8f`C$;OAJ8TW}S8tf*
z=2*j#vi0@dB!`s!qhI3no$+DLB@aR?VXz*1D7k6UIN8mTY*`*nX=4@x>G4IK9e~W|
za;^fcrO1-CqV;zqcpypx`a=}_IDiebDTXUn`B?*lFrE&-ERh26a|i}V`i=xITQRWu
zP)r!hRtCZ89a$_)w)4JZYp-mK*EqZz*&y78i>z=mG80(OJJ@+QwBg@^>m?lC1#N%^
zxv03IskYhSEzbrfUqzL=R*;wW8ho?5o1F^)Js{rrYak^Qy5TZ-+;<yucoA@_qq(4%
zmjkD|B)sXnhp+u=b-B6A_>^ez>hom4=+8Se<)TbpwM$}tBW^U|jk~<5cdl{eoxs+W
zUkKv8x?M1Nr!McN<o&t46^wW1^6oZVmCNJD$)}ikS8lR>F2>pBB1v8l#Onq4<rUr%
z1Dcoa@lG1-*yg1``idf6IU{$h@ZuA5%ZbAaWaREHUN^+ElDzbg*KFvUn|MQ@x-g8F
z%&0r99Ns{qucPDL8|Jbz?(x8#At<-JFiG8>bZQioy1}U&7b7`eB<v2aJ5oo;xD#A$
z8Rt=Q=*^o=wch-`kxqYmq0x;=HI3IZ8pU}NpVpC=%j&e?J+~%_c%z!qk$2yiJ9Bu0
zrKAF{HB`~%g<L8Md%&nuTQ0*1k4o5igx6V-lpVaJR8pB2yO>l~*Rk*lPJ=kSy+tLl
za^%g7I>~w6iMiK>cb(|uReZc%&ZIZ51=QKl7fER@$|_DIu_QUtN_K0gu@V|I{WBj4
zqqP?Aybs{X0TbVen;+kWU;7m}-w;2G=S4j4;&~nqUlp4lU+aE?hp%?~<8{M-VDd$<
z`EliKCmt@Z@r<ASVO=JKhf82w(K5d&C>AYv%p}C%XZ#QR4&Y|Q%rUU};R7Vdu$H;4
zb%{!uT)CZw)%q5TWYko7gC(_Y29oBQ7l}1GExO<uC*8Q=a||f|avqttt;ksn!@?F?
zJTH?|Jyg%!l-X{tf|0A1d2Y{C2RSXlW}4q6XjER&i11SaEtR-$u}R(jYywdogDrvf
zWSP@ms!s>YC9O`ae2k5t++$$Mm8joxMr(7t1>dp24Zw~3V1t}iN@<+bm84E(Z7si0
zw#_PQx?x=Zg7&+4Te8;98O6mjqhs;0yK(wkcPhgs!6?U*D_e-rK{;XP8T?%-*oXML
zN~kc3=xU)(0;Tw-f>M0TL9G$jO`w#I3qh?F>^6%%07^-D3zYKPghG3k@J&H6R+5i`
zI$N-RgE~j3FF~CvR5ogu;u{P~Nm&AFow&AxQa<hkb)H}!TdE(r_X@%A<wNaSZm~*B
zHGxu+cY|6lKE4Y|$-B!^PlKuyS0tRXL8zgis)U*aO6j}+l;Yb9N~P7cpp>RR1*Ky2
zn5EWZ#8E9$UIe9FCt%E>uy;YJbe@8jWHrLK-comfQa*kRO2s1sfWrF2P*^7@rOQBc
z%5@@T4k#7N^FgUFc7al1+ySZ{d|~J3=(QWf$5Ws-3iUToDvT*;aul@?l*-F$P@9A=
zZe4d->Km5&o~7=$)Gt6ODMvvyij;Ri)e7aIAyc6Zu+&&ko5l51P|8O=C?(~upqj*W
z0oIM1g*wYpjh5O1szqFPgHmB!ZK>aaQX2fjVjqLjDUKnM@)5DrI7>~j)FMl*wbT|%
zT?|UqnQvR{fTbR?)T5Tq$ACy_Fcp;2;0#dbOFY(CYO{6SYN=~MDZl$cwTcf8uoSis
z!=yIB&IP4Xw-HoKu$w@s(7q2UE*QsM>xH@+eYh%NzXYX9*hRS}b-w|sT==2`G2Rzy
z38<|?tpwFB)YG803-vcp7YOwUs0)SSA-0QzI)<Tu(&bG{bzACPOTA~Qk1X|xr9QV5
zcVH@czNG?7Wmzg>sa#9tS!#%-qLvzIsj-%tV5v!#nr5jPmMXMVk)=v3wa`*aELCc$
zm6lp-sdFv0-cr?;s<%|5rCKZ%vsAmKF0|AROYOGQ<(9hAQu{1*jis)$)D4z8V5wUz
zb-ShRveZ46y3bM%Sn4559kkS=mU_Zczq8a+minWmUa-{5mO5ssH!am|sdp{)o~1sr
z)F+nu+)~{6uFIdL0!w9CDq^WzOXXQ=h^3;I8fmGqmYQIxNtT*ssTr0kv{aF$N-VX|
zQcEmVYN?f$T5G9uEw$cK)t0KaRHLO@EETiVpO8?hRW3(wrKkgz;tWt>!_W>Xs?t)=
zS*jha$~I|B!uX5E6@A_u{8hOy&r%COq49$2Yxp}tC~hBB6gL|xirWVjb+x5(F)mTq
z9T-O_>V8XoXsLf;1fX19^!tiRw-mP~DU6$n6m^!R>MivNR9CJ(QbSSPqoSyVmb%hX
z*IDXH^z4d{I}8-{GfN$^6vqO}bt-yiMNLEEDe4E7`U(0Jh5gD>uOep@_O_+|ZK*JF
zM!DW@sf&^D3j4xRb;vh`-E1kI6IR$umYOlxU}sorwWWS%spHWHD8EZBb(W>JT8cGZ
z@%__M|Fu+KluqT!I;bet8AWwk>H$ktoM2p=EcJq={%xsyF-KKW-muh3n8PaUO-l_O
zYOo!adI?i-#Wy2rs1i%<wA3q>`u1?c_pGIUInrRajWSetw4rJ(b*-iD9b;T`$C?_I
zXQ?5ekgTXt8!WZMy6(2r<<|9jOC12EV)O%x{lZdDS=WDB>ND$_InIO|0fi_-g9#R!
zY_an|sa9ZvrD`qT5lg*pUH@vSx2@~&@g}r+mMXQ>I!o1p>La>r1f{gvW?gq$>Pk?3
zgl``x#dp1Rz132OLG=;7-&pDo*7aW&`_xijSl1IzGJc0!Y7{7yTT3ifYN?ghb(h61
zvs9;bJ!r8<E%k(T{g=f)wbU2Z^@IsVgRz!68B`yM<z!2hSl7iCTV|;$>sk*=m7!LP
zwOhUmEw#t;U1j;cX<ff<sXMIe?=AMUrJl2{A6hDWvWZayl!`~LrShz6xy9C4>KyBO
zfu%aF>s6Mz+PXe#v7?rH$-0ILOltJE)ajs<R>hV&1C%NUEf$MeYPWUWYpHKp>VW0D
z)lx57>J>}<8I%emccRfC&r(A`Dc7l>R1U7Q*anN8Z>b%Yy2?`D2c@L^+)}>+rQ-XD
zrJlB~pIYn-OSzMblsr&MmvT#Ou+;gM`Y|XK#{HK1IVh#eQ<g6>*~lAasRB!#0ZREe
z+futgDan^vs?)mO3`*(u2aA1d`98DMf3547DaHq`5!RCHEVT)g(qO0M>$23}E#Lc=
z`WGnWBWtRWe1fIU0j0FBuv8T&<zu_$>#)@CEZ<X>`Xeai;~mTQnWbh<GhxiJ)I3ni
z$626M3RPR|W=kEh)C-nMKgGz)v{W`IC2yjoW?0ukODzYbTJJ3u+it0gK`AMBSnQys
z{$O2?TI?lD{mr_*3rdCYFN+mTH#(PCY9S~UTHIpWEOn7}{Te8hLR}WS*;3!PuJ>B(
zX-gfm)L$&$dlvIfHCm0b)Hq9>3`*%Y9hB0b*}Aq_YOCeD)$+Y;U5{DnP0ROp%Qtj}
z31gzA=2)s0lq#JYE!AXQ_kdDb{lrrLvV5Of>I+bL(p%-8W_--E)YYI=7}r|rdQi&8
zy_WBor9QQ;Su+jaG*C*)3`-SS*K$xw(+!sTmgW17rEUbJ!oA<}J!+|sEZ--V`W%$<
zF?^QMV3eiCfl{vPELLf$8tZzg#r9aL!@AyOsb5&C+w#3@srRhwsf9+DS(Z8-l+tA@
zD3u!fEOx+Bw}Dc%=K+iT(qd0p>@`be&NiWCTPg>X3T?Edrdw*hr51xyp{=u6i=}p3
z>IzUQf4^?2o2={iE%pOT{mQyNYOyCQb=1241C&Y)PJk8F7nBO^R8ak->{eOoHrSOb
zV>n1$hghu0VkH*4!D0t2_JqZLXR(hg_KC%ET@ywgC>1Wh&ZEMeVX>7KTWhhH#o8@)
zjm56B*nJjzz+xX+>=TO>hD^9cpp-7>T5P?=uCy4BmMXrxEOw8@-n1BRoL78VSU*s4
zi-6McwHS|YDr~pKF1OfS7Q4q{-4=V-Vk5CKp~4soO35p+*g}g{Tddw<yDfIP#cs9O
z?G}5~VozA?Ba3}vv5{B@(Yk<Ax~#R>xfZ+7VmmB$&|;5T?3l&gv>2v(It(9_3S*(g
zmRKxiv383cu-L5@`=iBPu-Hcy`@~|oSlLl=%LAptoo2Ba7F%htwHAw6tleTaSnPns
z9<ta$i#dS_mlv|DaF5F{6x4GD;0ZHXdQlNu^9tmpEUftb_e-qryPL6X1lN=G_+6px
zs3sy2n`=QGz>`3J3R@}4cmnw?5Y~<a@&b@!Xi^f$8$eo+fC+>xL^K8Q;K-8=il;#K
z-GB){BA(lRJhn@U-TW!Q*DWix1qy)2xFpPi4Q*}4hH3*IB;;58`fI-^&fpnJqt|bk
z=0R};4>w!x=@la1yYj~z@!b88(~HG9RYS;T@DxI!^XMhz$BPB{qqd&=>fo=E!}q!T
zp+JC#b-Z_26&hmM@m$v6-aO43$`qa`{xUUFe-~?>EWn=Io$9D<+$6zYUp$`6Ryp-o
zz-@{(*sp{i`y$WnpUR+Z+-NZgnMDCglOKRoJ8uobD-DWLc#Z-oO+nrPvOWa~LtIM=
zG8o8?6r=#i!4zaR5o9{VX?=M80T1>jko7=#WH*6q2NFdVClJ;W9+*uacLHH;Pap^B
z3z?okxV_{+3i4MX$j}7Omq3oCAjcyH>ye=eo>PDvOhHP397{oX$lpO0Cwy%L5=}ua
z0aBELd<#fR3i1OWJe-!0^9vw6G?qYq52RGrcc_owt3Y^&C&9y>j>mHn$QM8+q0vhq
zeNm=)I3<CM0m7pu38VxF4~`@dZkp!tjRdkCNF+BI`4*6(6ohBrOH+`;K-Q-quL5aF
zLH-Wpo)m;1H+d=r83Ba**c1B9U^9asBJ8O2SqucCl8_CWhkS~sH3g}_4intrOlSEi
zo*gMXbhxG$!uK2Ir+gjmg&ggL@Lh=cDPP%a2=z}PBYPpI_Cn_OLe}&`8hRlY^+K-c
zh1}T-IoJ!~5qtAfI{&2?!sGPjr+E6YIoCghM0+7Kdm+nuA=SMQjvLHRN$%{0a71B#
zisy&Dkb}LDKlegD=!M9qV6^Cv!xB}sxy1yfOC68io1Y4OR4?SzUdYm3NM$c%OE2Wg
z6y$c;3aV>1#Oo?5H*9FF*<x(6=T^HkHsEt}nyzi-hf0h?bCn@m;v0C^d0Ud5pKr7F
z%2xGZB<(ZRhD1Ti$lb1A_3<+O$q?>NQ(qXX_^R)6RV05PtD?Ak&C2411ygZYAaUh>
z!6}m`o$6GWtM+M~0e5VtxA)j<{r<m^7*p{9Q2RYBoj_A7%nmpUB$&*B6zi098pUG0
zkD^#7a}LD<sfSQ3tUftqtjWhu45rVX7;Eo?C&nf9)QLrV9XYWsDd$ZrnmBA?prn%~
z2I~3k8B^${_H@AZN9(8e0Tb(_PM27#Ia*?Y<Z~q!Og>a%!PFBa22MFnVnB12q=!9O
zWt=vVQzVu}j*z6-c-|ugNcP|B<cQ_$>5?L*r(=ppQ+dse^9hkXT#|kDI4WZO^tjO7
z;yn(DSX`YDvDU9X9%7wS&W2bt<zR?K?J*CF^f(h@@a1jgayh)Qqk=TsR&VM8>;*P^
z%PmKHOG9f-X=@F4;Z~Q&@QF+g|J!W7@jL)MTA)1Ex@=J~x)&p&9ACVPZIcgXmp4>x
zTHd;RlXb%f+-qXEJ-deAZP9y;jlb16U}0*t^&q9OSk9gqzKU9Yxy9J1PciPuPeco!
zmx$LaNak4}pQfy7YN%_n{zUL1d>42nx`jma1n#9pQk0S+!(`x|Z217C(PwT;!~FJ!
zm<?xDtakGBSTmY@y_XrSQe|U9Z;ul4a(*Vna0*gh6D#H?ZOR+ACn8+|5%HP|nQt5J
zBrK^kOJYC<a>>eFiZ6>cSDjtc+H4`FB2Oq-paR>vE3gYXDW9Rl=E^f_5<F!!bq#IE
z%6ajI##lp>Ns2^bO5n?CwpytI@RL~<si<kMsj@bSu{um)q9wKkJWyni<!!VU>)ZAX
zDtQdB7GDET!AkKJ1Ad=11zb?s&=|*u4N}p0QberVW=W@l=7~}Dn>=;;<f$`GopRcg
zXmlDL^LP5RX~HmN^5hwcTHj}h%h@t^PcBhcaq>&p$?GF@+kt6935H%H=hLRHaE-!D
zULzs?Rlg#D$?GIv#Y1cdo{7^)C4OfjOs?6b{D4iIJR=1<WrF%vUY`XD-c5siQ}N0)
z=~s>kPzl1Aa;5?~9}>Q4c>S34Yk}Wu@m8!*^Kso;_)Y<s^y9Z7(^FMZeAA~Vaq-KX
z_~a&5&{raj`Lp59NDY_wnT<UiD>gm(PD>3W3K_2yV;8pOgSsl*$&;s&G(RkpIbVP;
z<tOPk1@E>JzfVC9EJ@gf0$=i)3NcJ7oqoCu2oL{&Z&k-%)*ad#8}00UXbd6PcfA{Q
z&JXq+Y|rm_xZ{zBKOL6wL@aMb*+$tp?sWeKmyPdwG;-vvhe7Pyh`r<d*ZmU%-w9&x
z7AtS^L59%raYFv;@?Gy{b>g<b?n{)PjzfD6#`>17-sqHfH!5gv%_ki%oO9l~L(m88
ze&@QNb5+)!mtw;wAKY=lP$!-X8D-sb6!)HkasP1fP`7j4=SL28tO{tpH3Dw6``~|d
zd3k3%t8-~kzIsLXUCBX~A;{A1PyZ_svO(_UT4sv=S_1|gOOrr4S4BGKXRTOKR@(ib
z@(vyTLLJ_DE!Ds1pVzrAOS}YS<)z)X8?Ci4M5SZ?N9ElukkmQ<BP6bbv5(mT{nto>
zO@0YUw&&y6IB>7-o)6Z&?QTcm$nKdcd`ZNt6>C<Pc8^ua-kOh?h7~>Y*UGynK)USt
zGBye#_bzZtyZ`xxq=blyl&)S=-u()Y!~RqUIwgry3G{1SUXVIaIIFz7)Wj>EiJVIB
zTooLiXEG%z|0Vk+J<4o;BlUXuNs0fEU$N#P%{wnb(Tqj+uFDm7s9xHADztPDcNTvR
zHFq8IA*>sCXZDKj6XDV^ZDjXA9kat7>F_=CF!J{zDh)lygSEW-qt6+2<ine#<*U2@
z3R}k~ovYq-pWpSk-<b!wdtQn^e>m(Q6(mXb?Y(cb#Qy;-oI5=VX@(ThKApvR!=I9@
zEJYPbFYmqzVo^qznh$b5{mv`<@UiPrK~AO@oDlTK=dL4IJ_rqRykKVLtjtANhw`$W
zOt_NtM}nLK3+^_`alIfj4NPe+T*7^okF-TOGqBp14r@QUDQiFxSPiB@Iej2sJLA#-
zNa~lFX(VNdU~BC=+M$nr1KlxMi*guLHonLLBf`k{&w-%AEWBc%J6&_M>IfN44x9rz
z541uv$uvl73uUP7V6BemmS@!w*5eWp%gpSXnUzTo#}9TB3ZIbRz$rf0Ra%}n99m99
zq=y!`r)R0uWDKGr6<1~^5;$6bq-1K3$zlc+g{k831V;!Vj!2f0;L1<pLcWchX2phJ
z9hI=+x~c+qa!$hMm^9pXL&;;4B`-?i7?<!(zVYl2PRevwLGXmH@&jjXm6PrS!vLHV
zix%snV(K$B6ZJ@=ir=f*yp7Y)HvQR|lcyG(QlPp$F5>bR>T!%aG<E|}&#%C&Rt91i
z31SZ4h68TEeK(8=cB>OIV5pYeTS$*a9q*0<u%;R764!sxU5O4jEMJQ9|KvW5R~4ar
zC)|Xit^P~yvv3RL`{7DjUv`g<pfyOpmqERvU9-ZR`>D?<`mbs*62=U%nBV&IU(--7
zp{12=n;id`hVsId@mMoX0pjzHj{j%(1FRB<@`r?Fg42c%M#B5+8a*+r(v1T)d``@N
zL*qlkO&DU%g`6#wRgV9rd%7q&EZn3{&-#DSfkneDCAEz)Ir-@S)jdtvMuxdoQ6?Ya
z_W$PICJKxVx3o4iw_+@-9lEu{B<N7rfKcAjGG~OFisgIUj{mlX3K1~BwQcZsG+q=|
z#~S^2-B%>&k}!`QI{y3a*<xQ9Zko@paJBIZ_x=ak+sbfd68fRr2X75S`D>A3)f<pH
zAGvRc=X1mOz-Ggi8luH`f#d&6`(Gc{-(&SZc0Uu=>TnBYK~*(8yXpVi{gY&Ieb}C@
z^gnS2<uj1Ra0`xBa;hq<pK8{YFb;q+#{~UMqp>hga{{%eK>h!?6GTpXxW&w|#LMT}
z%Z1@~gC{(F;VwdJ;pOje!!4^?@cvK*{$KIq<?nXG?FvqK`O+;zI9~qca7&yo#X@|j
zP4FvIa7>qcH*}4->_Z?4AEI0+#02s3uYnUL(2nng%CZSu=Z3cfSlWhE^Fyx-(+w7*
z)HIDAaKrJ*j-L_w9@5*(zZJowc-A|9X6TRvdlzIAkpTPZ0Pg`Cl3Sf*^&=ssotJ+f
zSPd%d{WbdoZn()f@SEKJfDkLIm;aC(uGA;X{ehuXcsJwaAB2?Es1A-lD6~?P`Xjhj
ztI4oGICL|nFJAr&5NWVHE$wCS$w_4YcrEJ~5VMZppP<2y+%Ol-%*V|AA)zl&laM7L
z!B;kHuHpAG{S&p=YeH;NxZuFrG&FQXB70pZT#XvKq`7JnVt~>;BE%NK%YPzdnlODw
zg?E_Wm-mCT#^$EFsQlqI3%Z@F(Dzn&kAGdb(i2>9RIj?Gn(Am0`&1+J2%AFFR$3vy
z*+wCL8hr$QhR>|e@Y&k-nSwvwh|otsGD-VherOOnhH%T$npk~vb(`aj49&*?15K)v
zrCZ&Kr0X!Ic`<QMA4ExUNgX!7?P?Lk+Y+i3-#)5JO=Y#?Z4L3w0@~nk`<hmKsLb)&
zLq8KFixnN~6R0tcw=MLHfRS)}`L?Di$J-v_chf`pxnZ1oZdB_F-UXq47{Y||^TO>+
zbH}?-a}7ZyYr?7lpo=sVg--P~Rhzh`)4HXmT6wrw>o-z~HPdwOl2Cz29*gjC_`11O
z7BsvantehTXREg~RMnu7L{o%S1$1ByRY<N&HOC|*@tM%LFO##Mv}NmI&E_9CbxR)b
zRjqPkqKI2IYi~AdLN@Ox0c)dWy2mmJmCW>0I7Kr2F3Zd0Qv$V^Us@+7q;jGJgz$oO
z3J_`KL<&yyoZ)|H8JH>wzoIPMbAk4`9v-{{p(4=zNxOYk6B*!@0m&r2(97}IKdZu$
z>oIs1mbUF`k;L%^YRnIBZZEBj)$@Ic;|<bikp6W_94taY`B~|2)0*c!E`5FkZ4y33
z%MBaeah~cGP+DY-$~)fsT$oT&@Ik^F7O^4T5DbUdTer`xs;a>z4(~(_p{!u#Xl2dj
z7Nx*Yk9Q4+@>xpajg1M-hIy6ZfMQb8s6vW*7Yf88(unpJE12GJ?>fOI5i8%e8FkKk
zK#*xfbY02!o)l~b>Plr(b@S#XQEH?PybwiEmPfr&-rK@hgd!bpZN-8o+b72x?eX+>
zD8B?*!YiUP{NE$eeOc30Df<}KZ00~VlPoD8=>T?SNQVCmEQ+5Al*F%#3rCU4ovEVS
z>6Fce1^!1^cP35`|AuLvFfo^yTnQ%luLCf^Ws3Edz0-PQ`YCs*F^mxW-Y9;VjtMuw
zzY=d$k|~!E3#aF-QyLOaIgx@B=Q@7iS2xFb(@KW_9$0fsBPeT{j^|}e23IaVSB(OH
zF}!(M8O1>QlXf%w<)8<+=islZEPbe_R~4xPl1VztOYi>!SkUCEt9iVj|6+7{GKek1
z6)|2$e=5#Vtm(hKKK+^2Xhoeq!ziyh@-xaKJ;D1$<Oi54VPKcIzQ_AzM9KJn*n1oJ
zs){pz{G5AEE+@$aE+ilzNO%!YF(kYwC};wN7X=A~1W*wINk}jxF}atw6+{Ep>y;WR
zt+v&I)ppyeEmpT>)vX{_wA$9Utyrz%+cp-vi`H6OyY>J5J~L<Txi>+&zyE*t-~H{L
z&z(EZJoC&mbLM@Xne&XrvCnAraSlZ%OH^*SX+diZWTTrb=W$Kyg{uwj$>;?_7YPQh
zY{Siwmh-bH6{m(qM8gd=8!w5Ya{pX&$R~!PT<6)SO78&7b!%%DH&fm{SNlDusRxHe
zrO@<EOkjK+rpV6o+N&T8MHUU~Ffw2V04oLOg(%Ag4bsY4%lEI1@*Bil!me{lpI`9(
zTPUGN_t58Cm>h8Y%9%~ly6BrEC0y>Ti&7JS>W`XqWE{L&aX%?utvUK#35(GSiE5%2
z4yRS)Fn~=*s^&J;)NaJc7yY?VVi23z(6-tqULSo&(9s^p8TSV5G~Lq1XasXJ8NhTW
zuqirRFzA&q&S7A|&=*}QDD+B~P#Eo8t!dC5l{KS+Y|(D?LYUZ4Cy}!?x>drU7g9?A
z=bGr31%p0F%|9(?Tl7bQLMJpG!f^z<Rwoc$kQ#Qc(+G4vdX?j}YZQ7PfA(uR+ck0~
zlO5P+aCStg^B^>04krMrH%&y(64X51i%>CgZ~04&eYX<FSzYf}QPI)%cFF%8!1QEO
z$H)XQ+hxPbc3Ft3M|z4u=+&DLyx6p|-3JW;%R>l&<+boCn1y^$!3e=C3=4r#Q?lJ-
zhKxnin_j^7g{1<|^Ra5!mabL$LwbOc)9-BeR7uDf6KbOgB@hFE>Rh3^!ceiyB*xx)
zK&JKy6)nq7rP)O06YViXo#{l9Ho<WjhWMziBHR5C|9xd;*4reew@y9FB-?%5aAeu3
zXmyv{ABfb{kj;VGa&TTj6o*BeA4R_ciXN*FpYy0`W4K+|IUqjl*y3%X%*r{aF<Ie;
z#kH;L7Sz>Y1I}_D)4@Efd^|G)7C}Kq%)VAK&-romHzwLAOtes~hRNh%KjIT7T&phg
zoTsIW3|F_VS+CprGlp9;m;KI94YzE!7;&QB$Uo!HcFWN@_GE_?;;xmI)vp?eegfxb
z6+90||0`=Z&A=+Y&B_|au^N3<|JBVcn=Y>1WMvIk7#o;4=I>b}R6p+auaC8Hk1cDY
zLU{e_8d}jcW}UtYD-KMKKwxE^Q7?|D+_z_C_5T&3qx{Fp&l*1oUi~S0u(BqoFjoH-
z9&hoTZhtxbnl+JC0Ao%67D>@0<&5-iQce|r)aplNY+lwV^72zVT6w}<kJ?~mjZqP~
z$QQnOw#!7gu3F!ig5^R5>lL#qazj1Z>YH0*1!)v{RPW|SMEsLS6>n}&Tdj0@q|;ID
zo7>yI8Byg?^_v^D-(j?&EX9@4<v|ym+s9^2&G{+v$1Sq6A-&5b9C3>w48(|{R9d;?
z?JMBo_$=D3+zDD7fI*b1<1BZg7F~F{rII`~ug6=HTb{30&Rt~3;Ewq2vF`KEHP~bc
ztBa@ALh=PiiIyxhmD&pA1@;IrfLiW9YY#iz7Qnvb&!c<1%$GUhY&~6yFx;fW>T$w-
zSrf{@-Utzvvt1~ooIc1<;=ZX#@_m%jb>+UL@fg!Fe~zz<<Kz)0yYAZ>KiFS*zvtX2
zJPX3I>1w&Z)f6KYLi77qjU8j<ndSLn`)1@s#CPYrcZMt+VU&r#`*jglupDZ!LUiwv
zwKjVbo~p9kyR|zDau_W6EcY8Cd61<i4*<B|44pnwnhM73TD<$;hbXzhL`D+8Vbra(
zdm}o=PiMY+P3S%o{WcT5h~+Hz+R!JMWym~jv83QSP2q(%^9?MwT_YmlrsmisSV>s!
zcAZMhp4!S=8`iN+xjQtnPmjl0eAkCmC(su(a~f)Du<7pJph@zqJc>4}?EOqAzya=c
zb}3flDv#Q2HSt1SosLGe-5w<(G#8>fEj-zw#gJaOO-@3rXslh&+_+xjvnlF9Mf;qt
z<(T1c_9nO+MAn5I>v18|nXoSr?)g@pJ}lubvCEN`h<4Vvx7x)xXdZ5p-Fb`?%~v*{
zsBY5@#tO$)HA>g$e%Yqvhna~vq(Xf~qXvXyP;;noU)8v=sBDsTw`)X67<$vL5|Pmz
zHbq9E5sSkV1+J)TZpBQ}a=)fuaH*<3d$e;|kMHwc_S!#19}yaHX?QiyGpvx#*1c0F
z^zv{GGW{-_vzE|^l~x{gy;<&3`vSaOL>x2Sq3%`aYav{=+yYlOUsa&PMEVjMVXL@?
zyDF}b66RU%2v-Sr-Ehmi+B&3lq^qiy7j9Y9um=6C!9+kp;kkRdtJ-)p9BaOkHDt6q
zuz;z{54W{c!#zg32V-oN(bhdf7JQgR%iwIBkRJPe5$+)CkhVKE+yI>Aj@3bm!VQv;
zi<(i96t}ar*Tf!gG6M_UbES1nhP0M~yCPSW0>sO6YSlYT&>>2!oNqJ8GJ6X$ESGT9
zt#qGZ?m?u?oUPKNR*&7JT%w(*9c5Soqw7QFYaG@smb=1rNAcw&R-URCm)b9bT|^v%
z-RTZ>1ch5>wKlJ_+!>Ba8W5adE96XPhNK^>uEoukTjuB$m!ctRmZm^!M)S7Z*}4OZ
zihR*>FLtgI4p;`Y;mjsB4=DDZr#tKcVRgz43yV6-ov*P2!!;tFP}oZ}b`Y8?x-f|T
zNxMK}PsO`IUPd*d?qxQW8AW_|fqPkK>mX*I$XqWEy)2d43OC@aR9zXn%jLQQ3CWVo
z?_u35G}=*BbA@)ICbAP1>59A3??^=+<5q_zNc&>XK%I~7st~7@ToEcwjP7cUz`6&k
z1Dq$q#Ko-%y(8V_0M%2~hK`AIu$8B^bGnz?JMj(??Tolrxli$(P`q*X0x4d+;9TVC
zdcQiT+Off}31B75Gk3ZDl5i4Nk^A?~i>LZM<hOLef|c&(-EZrH#I}*I8`AxbLm3GN
zkLm`jsLI&n?r}aZ1&lVR+rYiLCZQ2FVI}O|r#a<^o12s@$o;M<e{LP=^nK41KSzqv
zI+W->ovy(ulkazmC9VS1)qdYmUG2zlHAi$=s9Wv>&J98|CS0vYoCh7QpF$(XT6w-q
zeWm>tUOu9oQFmQv5{|YQ@q^nG(&7hIF3lm%^Vt!raiGN%{&BX%tMs6WhNksYx~uJ(
zU>MQPIqul3H-<2RGSyL?ouxV|)iV}msh$xnxeY64%xkd7cE@Qf)&Xr0*fuvpU~9QW
z8XE>ydZS{E=)qZ0TUkpzvV6S8d6+-7@krDLUy9*Q&|cZ97oM248E+68k%OV471ef9
z)|}CFqd1q;*K+IboGjJtM%6UxT%Gd#aLb(P^*p8JPSz9y!YwA6DVl6BcRsKUXSwHP
zslKp4mF4-`Ia2rL>nPK3r)n&^-+2wPpEyl39}DJcCFEY9QRsg)(S=!Rjy*Bl;1l_%
z$>HjnnpTP>Ro0YbT_P_y6=l`BT9rnP{XPmO;=7C7TikJ{vEz^|+3o6%Lp7`~Y9}^7
zEcff~WZ~vodAj!3+0zg-qFm+fpF$jfR4w|%OqNt%`DeXTfF>q==f8)}lA7zGhmvvp
zFPZ>_q1(u(A=Lu>wgoAWRPB5<-q?=HV@yXWHFHDS8>Qf@>vbJxnrcMo`6U)tci|&t
zh9>PUOSd}|gX|aJN<&B00?aXLcmmbW<{TYEQ5fQ)ngvabn7KuCLq=(^K0+$!_SC3J
z;ri;-6t9=Yo)f+jt3T=2du!CWvZ*|mJ!w><CWBp7Lu)Kvjd7;0Mos}z3uW9qjXO`;
zvE}AFbLCB^YB8AG&!JQ#G@>Njq*}fV48CN2COV7&`V`%3%u$`qK;7BQLrJT-MZG;5
zMH^8r&wbRXgEPF@at}DWC0=V_%_ht_4m$tDm6kme{l`GKA5-q3>`$zm{b+vfTDuit
za|w@iqv5f`z=%_(K4HCfgjjI3<WFCXK~KaIwcNb0Do#(;fPP_B10vxVR_l-(xTl0!
z133`+EqXv$l_lCMCl;y=3=FFt301`(dQJ_Gm&&bM?BMVf;zWy`hwXOk18M{oE2ef`
zX-`GsBffjA`&?EZ42)rsdb!VM`7`mDnlHVe5w5)Mi>BL(wXTSv+WfQMSxMTFcfZh0
zA1y)+RM<0pDN7|2%Qftj=)!q9OTBfzD!pH3siA@mp?Z}+F@Hs43&J=P+oBF&xUXjE
z*Hrz~ud-DBj<G^=)YS@~aT;DIUpXM$=IiClK0X|rQDwVax#AFq-lP-}O}5MRNVfDV
zzPQHd7mv8VwZF++YQWmX{a3RPXsX??SccGl(<oOqVlDT$zh1Ehd2Tqw6CI~E;9xXF
zrLFN6NQlv3rSCWuYb?xJYOs^-g(xmY61aNHb|=c-$XJBzD@O{{+FXmX-W4<t5Tww(
z??)|0KnqwUd>iZg13MUSU)jP>E%Ma{i-_B}Ckv|aLd6YzMI{1HR&gN(!BQdMzJ4YF
zcl$uF30^98?!tE)mqe&v<SQT=%olzcz>p@qfsJHx&Lu)VFr>#|j)80wLcwUbKvU6h
zc^rr)wdtr6WWyhsB6-T08N@jl__JNM;cS_{XS<weMbJ$(&aZC4?(-a(6Nekr9DA<r
zLD6-{C~%SPdnq4UAj~;A$adL@WV>GhrY9vdzNkcW#1C+P=@guf3Z#}9ub8>Kzsh-4
zN8+kg&abo+BMoOxwK(LX<Q%VQk4U(IyE*Rb+KtXbtwE0JaUegHfI7~1qwcRozT(q$
zYC0rI&4=H0)C3uG9O3+%R1#8Co@0LWcvG$$v)w(C1AMn^w}uiTzsFMg=_BqkS>*W9
zUaHrKdc?g<_W3z)!|KSNAYQK5p?G;UgIcZ;+2NXIe8J{kq1`!%^Gk?XPrg-*p4%$(
zZZ)L0=?KttDTs>sb8v*r!Q?#8SFG<|>$3UyQw+swtotRGT~~NBmlUh2+YtAyK10R-
zHuD0TOB)-i(c67lW3UQFPiDDa(M!sR>i@s0SDYeBX>OrBioL<@`jzs-Yq3~WvY|UP
zu3xypUp{_Kr=K%9^tO9+Zlc$$Y?G<pUP*9hL_v6Ub0a$z%e~W`Da(+NcxNuR1}}z_
zlStE;IP)FMR?d!9up!Xa72rIf?e8SEV#S9HSh22lU32Ru%bqGdo_z~K3~hpw!L5R}
z=DOIN+G;g7EW>plt*ar_vIp@nt3?VvA0o`KOH{vS*{6!6c9%7*p$X}=?7`g45AAY?
z$(I6hqQM>_qb#nB8gA0Vm{!yyDvS!8huWiTG&<2eJsEcS7+kxDbd6%j8-N(8r=s@g
ze*)%qU{2=;VcZ<F$4KHw)gWCf;jsqhL6|1+7@Ytzv<oK}{g?w^df0PB+|&Zvy)f^=
zJb*C65bqrJ1_(E@#j@w}4M#Ey43n9w6q`lW8!UUJa3P1+VCI7`d<M8ccw?^=*$pxW
zELSR)E?HKS<sIF!ly6Y%#lrI__~n7>1(-{Ho{IxK7YBG&l4ouRK?2Fdc^H1!V%g2Y
zumFtsX~IO1J>)ZN_8B5!&8jqACb(IZnl};x3%q6vy*75we?hB!Tx4&RSXLs2uflv6
z#06*Stk@ceWosaot?98`L$4es_!ijQof${kJ}+X%y<q$f%n;CAMdq8~!_kPPwOLYn
zGbcgR0WcD8(Lw%HjGM|9FuX)K-YOiAgBvsCdJsLPIo_%{G9PYLDRedW+sOS#X$*Nt
zOQrGa!m$M0*1)_9s=Tvw27KMm03`V9ioJV=O7LA|X_u!`C=68^zbzd3oyb>V3S7Lk
z&+*#<j^EZCnc#2hEY;k<qq&>Lr@nn+e`D{r_kt_6_)zc0hveLX^zD}g{Vwawkr+_z
zf4mO4cRTz?Hcj7zEo=KBM(_|3pnaGzzbp={qT`Kd%a1U|xiH{|hKeNplp!$r_FJL<
zNtpeX^g|^`0MGLBvwvwgZ|PSXfi<)J76bo47*JP8$hsM<Z2Oa5J@Ib?W5K9n!#piq
zvvy5O%Q$?6Jg%^C9KOjNw`TQfjht9GX~H<H{u|>sIA@t7#t7aPtHFG}upZp4LVeJ9
z0-ShM7mCRroS?)4t6o8?VvtcQ5WOP;V)Jo`eZkM_E}XyqVsFsknvVxN*>8_>HWyC(
z{<8C@tvP?(#ZNnZJ7V>7$F12Fzr@+Rbh@+oBIl~uvZ2%N6VHC$(qU)UU9b*b@5G%P
zuP}DOOB*Y_5l;5kZaM41iyv-3f82-O#a|d(fAPbh-?hQJG&XI`eH&hiP1|$d1`yqP
zsk33KlReehaFLU9-96LJ-*{j9`4`W>V9&$fDXx6<0w?-`lUv}#m)14jwXEX4c&G<5
zklil6g!t69?5n+q>)wEO#0<+k%=gk>-j2}po>`?o1_9hf+LvKx1^llljLyvg$&X74
zty#Hq;9>wc@c2Ae0`37LJZGkOqUV)|-7)$5aZYb{uXkn_Myn5%KH<kdR*_nJVP6oS
zo!RbG6-F25FxEq*xwFMa^gi#Spq&t)7v2}8^BxI*J_X1JLyL5R_k5o*f>?eUR)X$)
z(EI5H-MqqRxhCypmE=|(VwU*ydqH0opr6&Ab-nvJXMSPyO1|OY%y(q>G_xyxMPali
zjowc;J0A>s!Su{5j9#X)1Q!DNbnH^tJ_G4Sf%$Z{c|Ud#w*}~QdM_)ChFXFN@cFVW
zbEii5&X#;z=I7fi<QpHn5*iwA)PxOk!X9l`;J8Pd^)7h3CPQMkMsTz-S(R|K&l5QA
z(Jm1<=F(m$aNMKK!-1LnFp~mq7yi}5cbEhdwieyuF1&@wkY^?St6><PcCCUv+I0fQ
zJ=&al1mj>`zDnb0w<*}8y+`1<M|-cpF%#eQaNh`nD>`Z2Az%fqy#kiwU!J}AzY~U$
z(!NW<9_{A@#^uehpI3O7Hg{`zqbqIBSb_=O3-@D!E80VwThmAcEd~WhONA<8%H=tV
z|2JUBiS}Cx_GtIDRcy35mkGx9NBHxuAF!nr6|jO9DS?H*JOywLgJEFWrz_Z_eU89!
zk2Y0Ok%l(sIl+r-$z#0WiuTYZ4WghmOQUHsSRm$=a8`>qN*?xV1$(sH1&({Pw<|n0
zKMgFnuV@<DoD&6Ke<R#C!vvz+3+J7hjP_j$_GrH?aNMKK8Bmbb({R5816H(N5wOC~
zK7Nd*P)mFidzJTL$b|Oq6ztKSfELf3qs@s?Frxl&4}w8Nw9XXJL{tK2DGWo<o}plm
zcAdazC$Kp=A`NW~Z}d~fe(5UhPrFUQ9__CP9QSB*Iz%3{HGH+tV=r*n#TS3tcPZGT
zeXc`%+@sBjPw?${r`bs0aA7ztrM=7K8M!_zoQn564f_a8;6D5NjrT5>WH^t{Z2B3j
z7h!O9{nfM?3h+kSZ^D3tdaoQw$}WhHEo+n{p@P=gf^HF8CC6m;aUBW_7-*OTs-iVX
zfqrhVM=phtQh_~3!5-~ef#V+SI)!&>b2b)iJ>+q@;C8vRSHR%zVv@!+nzjmduIU+y
zq*^f{{BoKrM}I+@xd7yf&-cq%ta2fzy#lK@F4Z(PxEu>(S(Aa5B^B3C2JbJ6xCY8Z
z>a`3PF4{{^?z!4XVPtmB<$?*X$vEK;;)IZMc0a6W9^mYo(`}9P=fljY`!NilXz?)5
z=E2VRy6rlk{7=_*0oFV$3IP?Yzt!MLC5_M@dvI~C$u$j^(>_KMbp}v8&0z7<4WC93
z{NBJv1V7a9QfT!Z7f*=$guE4x$Ml149#}MPxwn*u6MYOs@}kdy2QYn{T;j<Cmp-CF
zP6LXbBp#*o(WLV)`s2wsAHS}-CXQF)`P>W?kJb4o#T4<k=_7_bZI|xpp916wymX&b
zFnz#}=cdz1B)L4E?W5(jc)mD@@YByzDsmKs=h+C9@orKcYvXY^p7j%79=tQY{78?7
z*C-a_!8M-#;2|~cwef%&g`PN%_V2KQcaicyTF_0Ipnp(<Vs{8K<!(|6WVKL};@_F8
zEXv=t;Gfc65oc1y=nE7r9<`7iF$(ehLj;s)>HQE&chxo=<+*z6n8IGY$xAVpzlF%{
zLx|^4kOK<<$%auKA?(?#scn_Z4Jje^_euH;$7^x9X7LCUQp*!VI<=R=Pv^SXG1wbu
zRy_3JCzre0I%PbxrE`Gi$NY@p?xac?h0DHBn&(2~-FZYnz2s<<aLQnH9*eY@(pcXu
z!e1WU^9zB8e<W`yIrZ~a$vb(l#m86_kE)DSo;>BCGn(>5UvNrcqRv!B$DLX~m$}8R
zGoQOoerC32WHj=s+Z#za82ArIs6jA;VK_wjkEyT0df)Zh&Ojsg38f=C!R4Gj4Z9rw
zbcMkMItCx-cQoq8%+J1PQ{AT-tZ3$L%wWSg!PT1Py3Fpc$UGbQ!rTd4<MBThCf}NC
zpe=y7md>|2@IOwV9~qp3u~y-x11b_<>M|`B=!byFGv9g)kmB+ppb3KOi2+C9h5}N!
z9|KY$UI(PO{MyiQy{3Ho15zQ@0h%cMxFF`c<Xejj^h-c0jxeBXn6OoXfAzjI4KxQ(
zPnfW*DbU~my^9e@LBBW91h7%KNf=cWRBE8v2C6X7N&|h_K-9da!cInate}|&y4*nZ
z2D;Zk`wet2dTteVzkyyd&|3yNZlDUhq6)DX1Bim2HqZ;`$`$T41O271kITvPp{EUW
zC;A{2q5vI}f_Q7Rf_`kE@#y#z?k@(q41J2itu@g52D%X4it=qW&{hN8ZlEmmFpBOB
z12r4yAp`x|K%WP>3UP;ldZ5oyxKRdr!$5t}J1O5w4U~r-SK;Ox=z9jrDe!&Q7^uxa
z_ZuiO%%^+OK%wD2?j>~5Dvn3d?JB4MU8jP!8R&ik-G{lZs@eA&=pO)~I8mSbjPZT@
z8E7CN<$I=qrW&Zy&@D62a^ssYxSa;tWqiMDpr0Gx7Yy{0@wG7>Rw)<(NTq(XfzC3%
zl?I9#-;D;k+W7v1fqrRxUo#MItWvR^ifOch&IP36J>NhV8s8NLYBW&7(CswPF5~-8
z271N#zHXqmjPKcJ`SBJTXc8cmD&8TbQpG!@6m+xk{hon%uapY$Qv)3}&^v%Il|bo7
z#`;{M2FeGd!j3c0?Vwh%p^?c)Ltz<c6>hS@O*M3l2G?S6HyK=q!R<G=M+~mh;NCO1
ze2fq{W{ETp0HorbYH%e6*JyAp26wx`?KQY(4DMNj<IM&t4&H2_;uwr^M&SwoDcn4R
zD>t|>(v~af>kdM9s>61tJDwY3g{wglcy81%5`uRQY9}Mcu{otd#~65mn#qtX&;&d+
z7}QF}cj=CXq<3n1S7@k{tn2eVjlwVpK3pMg??Uvj#xPGDTS>Gsi4JQ-522yZ1)Xfh
z^P+ZpupOH^$htnSYg9ID$EN<Vt{L!enkGkRsC%p{&8M1%rRmrO`0x7qy>zgM(6CK(
zeFke9&LA9{62|l=sA;ShyiTOOeKh#6{*awYNeRG}X_%$Ju$`r7t^~L@4RZ}JN7FF7
zfhmB&Pjmhzz?EqjO6>NgVSWl1g?9MqP`?6Lf~2J|{|b;LnZl5CZyKgATqUT4DVpKH
z_>Tf7cfrh0!|)UVznSwN<+(hKhJH<Hn66s9$!B%TCZ7!xi|6XJP&dL=_&1^%x!cnb
ze=CU-wapV&WXjci9gizAglaxMAW`#CL2+6pE=@(|%vHW1Ek&j=T8if5wQMZl6tS4^
zHXG<^h%}ParnOJw%glVYKHIXQy0N--ozY_HV{v#prMPp2+WJiqwd!*chF2YB1-?t2
zsz+rlPHDa@C@{J&q2RJR-IwQ{JE5pRo|NuO$`UZ`!P8au<zBQ(>b|@hGkHGKU<zP@
zBMh9~J|(~gM;Q_o@h{`q26v|J%k$9{@NSy42kFSvefc2z?V%VhUc<V9Pci>Um!bPI
z5By$0H~ysVpxM(1U54&UZh!m>y7K2W9eZP;%g}wf3GrS5&nq~2!Xrs#ycxPLZ-d`U
zSR-|4Iumb(?#tPrYsR|iE17iN=)U{`=y>NhA4I9rm!bP|BhbG9UD_l0m#+JguX%|s
zTSE)F;D|&#N$R?x)4DGEaWvlXd@Lu~ljGBlr()r!L?veVogBf-lRX*Hog5<<9?tTI
zu<}ozR}P@5(C?{39hF=%LKh%34Cdd-Fv)&o0R4+fS6~2lIE$o=I9)epMREu|pq6kv
z6jt6@065uiBr#9L2B?H2hmdKaC;bvb=y%!jL!t{Y#q`)?qB}C#Qzz)DWLY#>nI9Vl
zrgtF(f-~;q{0P)@_T-x-`k_)FF##SgR8n_mRRwf!?s#SEdU?4W2YPS+2Zp4Cz=Ar;
zQxiuLzdZP-p-vWGI8R>qeBrgFmTD#2pyqS8(nra#2@oY-OAI*pm!XLkxBY<U43Th@
zO5$w@Cj>r!65nh~1X?+%22|c}>uHH01wuhT?Xz`Y;z;Ls#Bi+ReDPiX%&{X%1?Txv
zv3p+^!(ohLFV}UX-tFC~Ky@JCAE_6T3N?=_1(7Jao$p=-Ppx}XG=EYVYHWCN&c{2;
zKTbRi{h|jy8G43Pih)uV%Pw2~?mmRS6a}G`e?E!?8r_{!p-z>$Ch`8C0KMat-k%Sl
zEs@*H$&!x~%a1_qWU}lCRIRFPOw4~Z8Gk!b`C_v2Rh6ZQKOFpY=o!Zc{z>QUrOC<{
zk+%yMRxRqB<R`uN_RV0Akjcs;$@#CI@w-GcF~?23hHOTDpCqS;`<gAU@l?LG-kvxD
zUS}Ndd=Y9ZkA1$bV{3kT{wqzGI@b>zdlUKjZIC9nyjTw9p`CXCrsB*4y?4|jM~e>}
zyFIbo)6u-UN9BBZ=a*FNC_eD+W)@1|=}tFhN(ZJBRFml{9hX_Yj>~XR$7K&Fq7*%q
zUY^n%DOw=2wdP2zhBC+3VVSEmTt*7DHpkJC0`$E-yHgX{D=SUoWABNGhpHs!=1~D;
z6i%(jlg>Wfscp2;%|QfHoVN(79hc@VLri%ArkLO7!|5}HvtN))N}*)`KwMlD>_cmo
z?iIsgce)@s@_x1^$lVw``GmA?M@NZv^(I&7i8}gq(S+umNa>jl?khbDJw-8QNU1l2
z)&O@GoMEOsv^R7RRu95<$msD2WvY+}b*Fy-42}MQP`COA5G+m4Kq#nB0Ph<71R~32
zSLcnf$Gwi`nl00y#r4qWUEkbTW7+32&7l$6!zc!{C;uMQ_~uXr;1@ggl>3A<qEMo5
zz&`Jrf{SLWjXnFqG6|NS-PF864l3I-RRjaF*KJgYGKDCxa%{$tORl-Z<&u|`1*Mlb
zvJK5rwXO59pJmUt?Veg94|m(9wo;kN+1G*0vKH_UPYe~Mmp+Ji9T}CwP*z~s?TqFY
zKv9#Z?Tqg`M2Q{+dj}J75XS1`pG8cYA=*o9h9J++!5o445h9G@4C7LIj6n>2Kf&KZ
zIQZDhx^k+=r^g#`FdRpxYlK|~2w#P{1Od7Gk%v;LjZqsYC?sQdNffn=;tPHhyWuE+
zvFo}<p(eR@tIg0yVG0oHJ21Pzp2MhRw@Jb7vhviM$D~kqxp@tNN)cy-p<SN5(i?y$
zGvtO~eEI<KZkyp53uQB0Y5tloA_dWA*}MI>z<JRxQbutRsDx`FNLP~UtyVvi<ubjt
z_t^!YS`4!vW(qoiJpDDJy-%eU#b(*}lOOjRqPp0>&&bXOB9Kmh25%pdgsucb_6cP$
zUk@@qq#2u(A5tlIqfHCgOdhB69~l{9{xM_DL2#=-X8)Ew=VH7}79&QL0~nGmkP{q5
zwPeA7^Q)NRrJpDT4<rw=hih$nt&{CdUG1H5*9A{Gb8v98z{y_fY$$YkU*xoUzi@he
z?Ez=)Mb4nFoqylO-bQEDb<XGyoTUZMm^x=^p);n?Sz70uS$IL!nvyfuG&qY2ogZ5d
z4Lkdy3!MGeT;%)&XHZV>_wfCDrg`y%v+1F62b^`WaZYZB6Z^pV;WZyPKeIlFe*vdL
zV;3%(a^bl1e|_Gif9Pn~@wt+-E}U|qH@L*R<sB#c-t+3mUV8R4Z_f=*<8^zSo*#^R
z)Y*KUv*BwS9&xUG+Zj65sg7N?E0kk(f0T42UsOK}VEe}nm&%#IvRoV)E$8t_pN=i>
zT%Qid2h~B!Ik{CN0^X-%lbYw#@n~wh6VEv$hbL!IhQt{fpQA7(FcR;ao>^-p-qKv+
z_^?L*8MgT2n5P^G4VB<@V=36F6Q{Fs7YWQHl;+MXv_jM6AmbR}03ImKi9QdcWoEmx
zTBoHfce+Z{QccT>Nhz715BfM|XgOk>C$Xp#pryGB3$4pELPfk3$1?*IC52WQ5))O7
z!4lQ6>yb+CQ1BoR?E+0h`x1fU9&MIO@E8=F)+iX9ETT0U2Hs*%P%w0?tCP3Ddlvw{
zP~kZ@mxqg2;y61{m`pS$&;ApjHXPu`y1;&xX`{_NWQ4Tq1&({PTNK`<eZ9uhW)IG=
zu;jTM{|zum6l323LlW%-Bu@warCUTu+8j_AEA5{M9QSBHtMD#ucJ9IBQuo6BG)&kk
zzs1E_Qh@Rt#s3>HOcm{S73|UGx|uv^=L;NjX%}cbNaUe=nD(d5Ly$}#ZH@rsL3^LV
zyR;wIc-lYKc-rjCgXt!3%JM^2(H`2{VNeTb-K{`c3<)ePit$NI`<Dt$3#Z8iEjHo+
zbrcq(18Cj^&S5aj4ca3V?9rz5n<=ABc|U1rS7<zKjvU1M{0iZoD7al>lfDPaGMxSK
z@I5{e2^PSFwTF*i30yS{8PZ;@V2^e`boopSZEkmyhBikR;%U#)c-mKMJnd^Wo;F9M
zV0M2UyuTsww2J)*V8_}uFHE495bwI25uFZ$qlUE3f)N@5tuQ#i%!)0~H3&zhJk;zn
z$1y#|!4r!>&!c?|2IWADu>fQwg^Jlc+KUu=39Qu`O<UbMY6_4u6!5_FAPOM{&_7Xu
zu@B#w;rtV%Zk#}6;8QasPKPo))!c>?8RMZQA)ImeD49WU%HSjX2>??w116O&&fOK2
zUJkHT`@!(F9!^Jb=ImqC1Q&>I54HFU4f?ZBs)G4D7<MM?mrPLrX7+py#_u5j%JT;P
ze+}ce?)L%z4u-wJF&O{h)QQr$<1qSt#A~COy{D(S`!gl%e`&&Ux3YqU8{8QNDm2g}
z15Gy&Gf{<IZlKi$y2?Ns479~SUoz0w4fHJoecwR)4fG=eJ#L`q4fK|Q{$QYgH;{+i
zQYr0ap#BCLXP{{Yy2L<>4Roo2>H%>W%(t#LxSI^b*}97DHUoXlKo1(|Ap<>cpf?Tl
zfq^2Zw<@*^04dIt3M=S~2Ksvg{lGwn0gaKA9yhp;4D@FMh0u-^KhCNZ#KTz%nrNW&
z3^d0;Jou~P;C?Kp2KlI2m?gu6<zpOn$6;$a{uML}5X85@{Q&=i1$xXt1>mCSMjB`g
zpuR%KJBt-G9gqskcolAiftn4p3y|W+yi(AYjW2I1R$(77zCQ$nBPmGVQG<KiK%Ib8
zh@N<J1+lYKoSADX?1ct5!$7kEsSxFWRO+uczBd9=VZUu~_ZjGZKq~AD271-_9tEVr
z{?Xugr?5(u4NHZE1`G{NG|(bI_~Cu440NgS?J&?C2KpW#RW~@Lg9BkXfr<*m_fohL
zgPUn^^#<2ya2*E69#VzfXK)W1+=mADvB4FfrKosE0#aew$Ex&+1O%?I^^CzyFl}qP
zfmmZX(^PlPXF}w!ICpbyK*^#&5qxgc4nzQ+lqmSVC=?9WT~88l9O1M#^#u2MQ0cHU
zo$~Xc;2w`~w%HcDKFkq5d<)0s7}E8*SEDF)c5Dvd#a)QlBlBT?IW}jeU0FRY6zZcs
z+;0y8w)XVrIqhUAIW~867;F0Ts&;0>#=YzK?;6*8nufiNW6$oE=Fggjt3bytz&~>{
z{mIp=S@KA8x~Fyx)HFSXW<VF3;Jyvt_(UfOSWnC0Pj)ILQvi0PVJd(*nucirrT_*%
z9cmLXV35Lm4&X|I@i#RQKpxz3ER!VPO+MHKR#PcM!%^#RYYTgRK=${ym9jKRp}#ro
zBU4k_OdmC$O<`3D7<bxMvne2SA>+H<Z9b>_-R4PC;2{rpn|nz4&P3U=hNHE0xoJ_*
z8Gi+E2YaCmZ{sW>-74r3KFPBU{+YYYti5CT7kp5MGk2SV-UcRJ#%{Cm3j&}EwoZEG
z!<^ksyjJ&<W~<wte>`>}0#DaoJ>aRqV16Q5=q0+L3FM{f)w|LVbEZbCUcD=$;5)Mh
zbk`$I2L3<Ps`M4ysE-r6t&fxcw?67(IkEMhRUaq(kFJjsyQz;8ig4zpyVE%T+dl@X
z=YLjxocKSuKF0B>VxU6m(_s^e#&=&IaWS$UusL3HUW{Eelnd8wn79AUjMqbv8cIdd
z9;7pKymmp;21CguAC6I+xMq&mLxA3(X-Fau=`v1-F&}mV&y_eINdn;D7)LzE^>1n#
zy5)iUvrl6PKNYI`69-b7pMB)OMCM;7`PUyW&?gE0|2;1tA0vcBk4BdrOtpsdGf2H@
z_Y)<q4At73vH^w&8}Vz{;tGv3P_@ohGNNu~RywyqsGtApnbmnZUNy5~o$vb0(I~ZE
zW__1Bo<_J>yVQD_b-nAeQlr!ijrCmWwjm7GaJ63UWBh!e1;Br37S|GAMXhvg|A(PO
zCcdJ%&0mt3-fiNEdbcTov#+Xm`v8^WziaPCnKFB~1FA`UX7BcQn#M0H=>@y#-EIRN
zrHg!|1^^D0J@M?_D6>p^;66$3#>%Neow#?C()`~ZjycQH<#VzgZU$(Wt*T#B(8X~7
zl|7u!aRk8gx8K7tSN^B<aPg)FJ&7|t+zHmV#l`=3^>EoJ?Z38%yIS=vsv`3r?(XJq
z+;{nFdboSK;dhcAF6*!9;iNSGw~J#5v3U7(+r_2ka5F)|!U$WO?I>s-pue_<(>ab1
z{~dZbX3GDx9&W>g%sE`~2_z=}xAk!UH_qW$n*ZCuvA6lJn!~9aXN><Hdbs~tbGYV~
z)y=qk(@5d`Ib87xWN?#;reJo*hcY<s7vlgt7TY{ofsvt$4DKif%4aZUL=>s);TC{0
zxW~hg-905h{-5rdaew+=wTMo!#^9VOgF6D>k=Q=Jmj@W|ND$Ix?3tCpk5`rdS<}hf
zfOHwF)QO-gh0rFf1rVGM$XqYu3r+4R#VOngKIE72h2|Le-v_!unxBa`;|t9K(DBOb
zks0xJw>tiPH}T?2Nqob$Jn8P(i{bsyg;tf^X{@z%;Y;Ef>P|ph-WSKUj<rzfwZ3+C
z%)*^pys@WZ1};Xmc%{*j)&}Uio?B;CsSA#MC13Pgg!_1?ZmR*8IF;g-EqzN4F9}(L
zV4G%KX+cT8#rq$i91IL`7b2pfCb3vUa}&5;Qo9BuxQAv@Z7kl}WI=hkil(Z%wLz4d
z;j?Kf3Pe=AudAU6Y>^ao#c_FcD{kqOI}WWXxfWjC?yT;WRyxM!wpBJY;2oKgS-9J^
z2D-<1+;M)qEjGOtF!aSiVYiAESAEV~Y?ap3%w4z6s)*tHm38<whn{jH8@A==S8pVz
zvW>VytIe9-+!kL&hPBYRX5r4a^;VV6VwDD^22Jj=!9_!@Rn@EGxUUS+sQ92QoF%~<
zXJ<9kHLJXyp;Z2r$8nAA%+_XetrB7VPBj~6myrwZ)2v15ENHb#@nV`gOL88IjCnt|
zP42%0sO(y+>?#Z841#$vYj&-QL2?@U(8vWA_*K+5)WzgdM1j<8h{zbL0#Y=TVhkDB
z7;9+3WlS?0);B<x_@df%)zneeilS~>jhi3mS6^AXsCG4!1j3J6(ecifPB9{3>Qv!Q
zre-&}unrj-YgW4B<~6UrQZhv<*$iCW&?<ElsjjMRZK%U#PI9Rwf{Lm;RB2p_t}?%k
z6|Jcasbnpynx!uIu9}H^#9Ny;F@4mjSdMBZjRF}tSML2oN%HzXBvKJFY8}li-UGqf
zGOxM1rWAMUZE9<1W8H7WOG`s3Z>x>hGz%y<QsHKXMoTiC1!7HaY+i+Y*nlijZLQX-
zQn!Iu>3hQG)`@0;DphkVU0LhOo7;p9a}RmO@5)vbkDn+lB7it20G}IxCkNmuDHz?M
zVK$*S0FMvA69VwW06ZxG2jZP@F4Pb%=1s?oo8@&EH={^USgV0x-YsrsGq(7pZg2E&
z?AoYF<}?`gi^VYPM=3>T|IBYP7QrlosfJk#a}~_hFgL*51hWf<XKQbV`3B5AF#BMB
z2y+1DDVS$reg*Rm%=<7rG5hZ@T>JEeITdCY%vmr+FjS*V4L>tr=EGFNTn<wQ!!H72
zFg%HLEzC|Bo`2;{7Sv&KKg`20hhbiTp@x#TV15h3Gt3{td;$}~*x<qRhB*a>nuLeI
z6u|K8|0tL<U?#wv2U7yW@5w4*mcguoxe}%ohO&run9svdqPho$`$6A@;mJ<!M?C@a
zbC`dIc@^eenD=2mg~`Q%i#!-ACL9ej7Umq7X)rw2&y$<WV5sS~31$<_=U{Gv;Su#O
z!Q26JH_SaS55PPG^BByNFh7I&1<ac;Jiq=sm``DHF*2P3!xNh0V9tk`4O0QL0_IAX
z4KQ0_cEH>W^F<hbaNM12B>182+`QDMwhq6*(O>yusC3i6yiI+9Jj&vQ(LGWhEPFOC
zq~-^|*~8#9j#Hi&VUT5bGQ`UM#Ot${BCk@;fG6aC2Dm`xYnR|wG0S%CTa>T*mJ=}D
zP6K?t$uPStw|cW8&3Yb)EQez|J|g`x{=+=)*hBBb^-!Pb%J(||1bjCCK5zBt?hD*7
zzXr5QVM0~`{=063rCtr*h)>?X-&E%d_EhIzw-&&Tg?`41C^(nG7vcEgrTcpn*y#O_
zzGhMzKiT0ydqCt}KiuN>5Wf|n&9K1_T}Fx<fAWDUH`(-u0D&B(?_d~RV06mkmjWH#
zN`ur{Zd6f7ftbe%y4yhCGSIyS;s@M{j^{`fwBJCF80dh39yidF271Oo&l>1O106BY
zs|Gr1ptlXwX`uHEblgB68t7vK{n<b~ma0<k8ptzH#6VF4;e&S_Vt|1L8>qlQBMmgh
zKw}M5WT1%#nrxt{1}ZVoOasj^&^!Z`8)&hCmKx}C1FbYrje+V7)M%g<1H}xq(Lh%l
zXq$ny8|VfD-DIE+1MN1@Z3epCKzj{zw}HN8pnDCp&p;0vXup9TG0*`6J#L^U4fKqG
zo;A>m20CJ(R}FO3KyMqU(?IVT=(vGCG|<Ne`m=%1<ox<)AkRP%14Rv#Z=eAN8f>5f
z1C2D$7z2$pP?3Qq8fdbCrW&ZkKr;<A$3XK8RBoWf23l&M%MG;BKs5%cH&CO2S_~93
z&_)AYZJ=!i+HRm540Mx$It;YiK(`s_b_4A-(A@_5mVxdy&^`k_XrTQDdc;5n4D`5x
zo;1)i271;&FB<5GfdFXzx#t5?{T1hp3Yr0kXV$~kDub&t5a*G7#P{<Ccea5B0ODX1
z)HBK0IQpwI917xKr()}Rnj>Sx1SOwp7>*_!?z+>g_$s35Afb7JQWXwj4ufVqL5T{}
z(;W?iH0f|i0BAO9SGvWSH6Jua&>X?P$WMqe4`<$dm?w^1hX1aK+D!sH>U;-fC~626
zr2e~8+l;}nIq&cK+^bRQdx$Y`b&cy0O+z7wV;A5*J+7d{geBMAiD01RTV>jeAtd*^
z{D)4L)U|RBr-SgmISt~}3Ga+eojSqFbPb#<)Ksppcsw-G|L4Zkbz;<<5)e}K=j(Bs
zP<*1ZER)Wea;{LO^tct^6Uph!ux_M;QB*R1vDbN)5Xjds1ptHfS^0GRFCksvG&m``
z)<VnL27KnpdQMFjvtkAx;4-CzucGlT1Jl@8MR*4-(q%{q`Bmg3=sx?>ctt0*k8~MQ
z!pV5wc8E;(YPzXDzYHniN>t>Bx!est<d-2O{3>v#qPl;~rh~`Cn;|9S%J&CnBI*2G
z6_26oMvvP(lto0-fxUX)3_Wh_`x<qbkwhM*uQ*+gTRA+ocS9F!YYdwY^I|u2l{=uP
zEH)&`KH8dcFgA3@Q*rND&neHwaud%b7e;nGAOGF*L&=gzqBOGnP+dn7)?K94+PXx~
znP~c2?j`e}2`&niU=^P(au2fyq;j|9@;^UyDDlzGM@AE&^~OP|S2Q`@d+O7p$9e{|
zR&{iw`A1ITA3ceG{z?1?oWy_dN&E{=;y>~v{$oz)U+E=7$&#_qo#udMKU;*-tCyBP
zMJEi8{4L?z1@g0mZxeJg^+7jN8+0>uLHF1UH)9X_Pt0&n&Tvo7aF=AbXKHs9s?*?P
z+)G~JR&-ttRcDDqs7Cuaf<d=m0qR$B{s3s?OO{0zE~+T6`m}05`{M;W4#e}4mC?i?
zt=mrP4Fq+f?8A!AeDFz@eF#SB{(k+<7fpS!G2Pc;pUcmbS~f6}TD^0<RhjI`VH}DJ
zpMti(xEGs{9Kw3el<xQ_o_%ak^0EjVd5ab$XGF`ZI+MO;xA?yxC5a={(AT*h$irD=
z#C{`jNLtvjhsi(j4zdG{$Xjc5-i#GJ6vfQ}HC|ry!^Ka#Q=&T%8<Z@MBq}0_r4gj9
z_yBY&Qo1L;i5ZcEq^kIUN;f=G?Gd{ZoxlHtO6H&|usdl^N(}QK(Hmzwy>fFQ>&c?n
z#?uPpvgYPZ#`GXN&vv|&Zw`E^r%n6jD)CQ*TIH0~r>D{@*J~8swYRTqE~=H-Arxkj
z=_02BQB&6!;wG*C4RW=V><QgrO7bLn;gnQrbR;FJ>YoZr4RojELdl$E4M>F}c3`1h
z91w2}%7QjJC?B#;ok#!#gVU3hVm~C68U{Em5F4CB5sk074qOU?Tv9xS4bibH<#)p+
zc94(AMJZC8Ix>)2a6R3y$zsN)7>&}gBPW>{>j(yA8JIFfYfv54x_TVuET1h~>&=>s
z=S2GNYUuaZA5ib2|Bi!RK>ytwIK$i~4Gj-H3abZUH#8#j25hfoer>G2xu(qujSNxF
z3$1fjwy&xpcwbZ~CjL2;V1?qLyJ?NEyp3unE3`gDDKM@V_cqE#NN7Xo5<z(0MzviO
z+8Ej_n25J=aVxgguxn+7Hih`@e`rM1+gP!wX|)BKeS*mMHex@dR&J#Z{axreK@RXX
z%6?1eYE3oR+gRCzS?rZoXp2S_AWikPtFPpqRqOiN8WmuxPTxqymRl>W&5c&*nh>SS
zp%G(p#_^4|X|k~%_N>-7tgf9=U(H=4Y!0-=8df8luGJJpkZ1Nn&|GF?#Abd_9^R9G
z@OnW0^Wac^%nb4Cc@KPglDy~5_yg%UL)2!71PT&uf>*CBcd?;mwkd|1%{Jr33{+m^
zfEYMUQ^|PRcoBjZ182F^OQ8su8>z68SopsLY?uq!P+!Nv)TIaEIiWmfy$cbfREd0t
zk+Dj&ZC=pEqO(H%G|u(bZ7i>j)pLPih5Bo(=czk<LZ=9u(1?hqq{g8E&eh<{O3_l<
z(jr@$p@9xFE;Iu5LUvF?gB-biZ3OCs-mD7^cAk@Ps1>EFSJ&dJ*U%7+Lamrx8(Unv
zu0<u{H0OOGWqpV@Hl|WH)Is0I3IVo_Dy9ObSWv7KjY`3EXqYo!a7DybY+8rb<*XCT
zL}GNS7~xR178)@bt)jZArg>eHBx<CNd@3q^V{L7V6*}G7BZMWWyz$mnZ00U*U|x-K
zej@mpD1<+t5VG9sknCKxX;ohLz}b_f(34pfEIBwqez*L84h}`n3<}WG8&p3u{>&BS
zPp_ULb4U3be`Zcbc%SGGLc~&HcBP2Ge=rceZRS{4-sb`vu^Ei{r~IXj@P!bzLc%g1
zQ+`0VNiZgoIhSG!uN#fmL&l2`ybi!heae&NeuM7+j}(ALd54=5!R6rK`B}<9v)lm~
zhcZ-x8XcDl+N9Rm_0p%<-v?=5p6Rq3Sj>F^S@v4yO<s$%GW$w)IekH9*^SH(;GwOu
zZ9yE@d#_{tNU2_2(55P;JxMWt2chy>=0ca^Br?fwg$l%T$iwP~`?%1vHZ)yn*)L(R
zR2TQs9)+o9e@W0wOi(>g+#IzAKnde(#9U98HINA}0k8(<doc46ZqUzx#QxB!zl8m3
zAg#e>gQ-o%4SSlTtOZ`z!t_DZ`w(zQ1JXE+X+-EDEz{$5a7u@;%N<g^4sSY*$%cB&
zA<cDlIIIAKWb&>^FbXvi*`*Rk2Ljv)GZ%5>dzOl$G(C<|cElk+j?&CHO1p`}jBR$A
zM6(Z39E7<R(Om9FQ|3q0*032nYGsO#8%(PVhxQ!d@hrl>0rQXGvB&2zNAoxhd1={m
zRNB&5m;uzDCv1+B5G>w@>Gavm^OMpdW34@}RLUrgk&L1C0$~zG;9)Qv@6UpqK#FF8
zpBBn1?FHSWMGw=s;)I^uzAlBK_O=$ENktlyif)*69oX$E;a5&xFg(WoeV<>I<`>LW
zW{E%e+sh<u3&LFs!zo4%CV28f%lury;R}12PRbCao^_e3cwUfiMeXWXbF0e1%Y|(R
zSl$bhjq!4^&-QZ7cIY_f({kn^cdUb)x}SI0D~0JkFgysuE$y%POjr8vIj{;v_bj}r
zt@m+|90AFoRw++w&=ys$gD7N2LmBi%u_J@_iXBZ)gPhla&RV|tQE>Y=m_LJKQ7)$A
z()wH3*3lY8Ok}sRM`A;%X=qh7w^e0YS}y5P*^Ud}<KRiHgA);SyWty8;~Up}RV9yi
z!!tOnL!}KVI6dcqg+?%b!!X{c84qbf_aVLGM#auOZ8XBz8#&k^V}coxHaD>UPPj+G
zc__@?;9h~OP}y;HTC%tJ+0n$Ag+#VhMdl6JY*5#z7}L5aJ?XI9Wk@VQJe(iCinzXP
z;%ZNet6j$h9W=fKwauTW*w@=d2!0_<K8CvY42$binXw7;aQphSthm0LtWeV&J0a;R
z0mB6_^T2d=Pd^V5KGT*tnC)N&XeU%taffWi9BCCM+;&2x)=N*V9+qyh%fWO749EM=
z8^$+vVSJNj94xHB6wAI@ifSb|HN$XMvD0w7+2^Kp6yKco?l*Vy?rN51e?geGfZ;VT
z+#W1~HX&91UocGPH>_@Lw(KuxuE7)r=XUlNh1)i8x*29HTH!Xs?TbFQ7S02u{(O;B
z7__h;Kh6}?tuU7TWntF=R)2)40lUk3`-%IC&u+7tGJMsqo-KL~aXV>I_f<2yLnS>j
zqy;g{WWut)#+gKDS9Ad92zyCz08tFk;qPP@bPR}L?1H`z2M_YtcMoUhl8*s=ID4Ck
z1lav7Ccyrvl>j@aF96^KjeG)g0;w0Xc)^Q(pS&NpvUuL-`=CF9G!M}UxKH<ilDzLS
zdA|Y0Fit|EARh%|?;FnPM>Yn&5k5{PB13?|W1?Mwxz7q5;lz~Vpv{~sL1-Qv;zgB{
zqKI^J6>clF52{?WhDv|<V^StTF|whJm(yDI6HG>y19T?y*4i~#Pg3dlZ{@A_g8A=Z
zo<Z;(h(J}T-}<Gt4kr|6*5UN0{adnRB{<!0>yp@bQ;MTwtBgXllr)UNX!rzJj*>(=
z@;>Obt&w=ic}Rq1Kg?*d5IdfW&>e^5U|W~tH6q<WbE0?yR2h1*RnLRNbA|OHrSsKh
z|H8J1k1Z<NTmSR38l3ePIXP3E^#xAOQs?JeW5dp_yI@WHmY3=-ST@wl*Z<Q#6IQ<d
z|HVVc-B$;P)6?r)cfquw7t~D){>?~tX85L@PWII6F1&BbWzPJIoJro)4VOEcf8mXK
ziOF+rxaOiYapz;J!yDoByl%9!scw?9sjzUy^%vK!_r^OLI+oqxjC?3ovOeyOUsLL=
ze`wjXChzpp9U&JpEo6I_b4Ft&pVi-auzY3KE48xg**OuYuAY%QlNS676sc7Ldo+ws
zKeOGLUl=Xt>7+wEJH)32h7&OV?9x1acFFheIEnwhllVV-693~T@sFb3d{+93PU2sF
z691MH_>V-o_;kRZdEw`eQdmAccUDF|?K=S<KOdikKl&cS=c0`8oG^Ws|M8RfqX~Xy
z_~=Re3r^x+bQ1rPllYgP#DC>U{98`qzwHG6Q(1_3I^f>`+b_qmcK3Q`c44%pu%JS;
zuCqK!^Fp(8fm}e<@TxHtFfbo<cGF-5+S0<p=qiRf<hM`u`OAG8D5IarI93-%m3n!J
zAQx)g&DCA(!Yh4xrC7eKFgm-?S|bhn5Ry}tyZDeK#IHvd`{+QJi*-E$N;*;htRV(|
z3$RD~bb;d@?NJKv(mq?`X%}fcZFQ(2?$Ks{6Fi#;r(AIcrP6p4YXVF_<u_OL+!wK}
zg|yg+05UET1H`{PCHOCeA#2)Y3ifE%2^{xmuTglsw0cTl@ys-plG9!VgZOEYG?0`Q
zIIn_X47A%6?9skP;J8QoT7@?;biln!<7nTaU^#EPN8q?e`%Z;7;r79OzsAviK*1jE
zM+J_1v=1u03HL1A&uJX(7ZmK#eqG?WNBa$hH{p)M{l3Q0{+)t7+Mfy>_h{R8dI3h^
zrig_3LOV~vqL+TCz;TcEFoieq6~SGsakM8W*rR=+z;TausluCZ<!~?5INB8o_GqsV
zIPTG|R(KPx1@5afj&_@ZJ=)g@jPiqht-_md9dPf`ING-;*rR=yz;TcEHx%BbeUHY|
z=K4EW;i>KUZWvK0A09E5^whtPsz!_Cz87*^o_)aG4?{MzA5gGI`%!^W6<{A!c$4&J
z;eJlzXuqIfk2Vk6^Sm(a*A?D`I|}z38b|vr1$(r4IG^EYb3q<_wc~KVuW_`0r(lov
zzY84qXn(5kCO$B+Y#8#Q?I_rz&8y}aAMM@>Z^A|4?xS(E^AzmS<_7`{N1H3<U^)xn
z9;R`$W!{dyjrQ4sk9)Mo2^=%=6~SGsakM8W*rQF=(~OTcm%73DO5iTlINCE5?9rYt
zaNMK4K;cb%<!~?5INB8o_Gm8`IPTHrVl^1wO1P^vj`nH=%iRR)1de;On-$)~*8=xd
z8b`ZL!5-}`0>?etTzLlL+XnZw8b`Zb!5;0M0>?etH!Hk}uLJH~8b|vU1$(rQ2psol
zzpU^s?V}3bNc&@f;~s4;ID=^-Z?6AB*13D0ht05PV*dt9k?v~ro0tFn2fX<i$S;Jl
zf&r)v-L@)xLar&v3-=;K>8%+>yYY_%{JH9p#}5ydpUqv~RC71E<%i~F4FT>xbD2@t
zm;o>sXmdFQ*rPpF;J8PdOV?mdaVEmGDTlzx+CMPvahXaqqxB!+h6t``4{cf6;`SGS
z#V~=;oWhjCFhbgM73|U8E^yqVy+h$$+Fa(cDfzLH$5O!+?V()@gDj+VodRhwBqB~R
zDB9yQ;JoNg7$$=DT?+PS|5D(%NBb3pcWED0@J8An3LN)nbBUamdng|&P$!Nym)d|m
z+Pwshd$hR@4u-o`>Jd}O19sfdFoH8Bh~i#_LCL-ZHz5p0Z6k2cz@UuOpCW#P6-g)s
z_6B1_@|3?DtjO0XOg9)UE~jkV;JQk`De5-fLD4ql*v2Cuo2DSz;JcSJQ><)AWGjkN
zWP{Ort&{^BoEGa+hHG#^u`Fe<#v@InO8Ker(V|bvIRiMg;Y!J60LdL!${hnJRdSRW
z8e~8qNa>%!D{&rWcLo)d%ux(yJOU!NYRuIQJ|&r=7)qm4k|T<Vf=DBup?D|g5fI(5
zLVf`TwG$7kW;tv{tgl14*&zJ;4j%|$>bUFvXeQ!~03vXrgWJi0gjn3y54yP}#T`vP
zT(GEAp(W|ZKgL2QmkJ|cxHuRK<3A$mw(7VYX|+&h)`+7Ti=o`k#3V`HtOfEL12r|6
zlm>iB+s031yZZ<VO+cTp=b=%$@GTS)djX()(P?y{K)fnPK{Eg;y2S>%3Q&pAT@R>K
zAa1fKx?2r&$Utux=r;yJmg)2NT&iZlgoUeuX2Q+oUf6mN|6Egrtpf)7i-EY`s(d-P
zD#%3~3hHB^HbkdzTMhIj1N{z=iuVr&`UFs(#OtCzQ(=1nQn)-or;2ZZ!JP$2aT#Zz
z3C4GhfohCzy@48y?~?}ijDemtzT?mpsyHSX=v+W5Rc!{h!9ag!e6d}l-{T?U`y&HA
zX6QaOI0r?lV(S4&#W4hs%8i-EcaDMP8M;-5ZnyEh%|N#sx@QgUMFSl%zN68fsuY}M
zpmBgyTFL;av@9^Vs}0>Y18q0HdkpR_1O2`6ec#}ye?i6jN8=kp*Q{cT8fY#cMK|9-
z3jwM0U25p+4Yb}sUk9YZe$znT0i?n{VCZ=3xQdqwt5gWrKpr3!q7NWNM=8648Vy~G
zfntDEh%JULX`t^Jx(5vOLqICT0Ymqifn1CiDpj6=B7jtget=Y3mK)z{1JxS3CPR0R
z@%^5G9x!x|7`k5?h#w>9d@+y*NaqV6m4Zu*?;-<L8M+mQ?hfO7r-8m<=)P;{eq|sJ
zot27hpn--1QmGncpkm{Do`Gf<Xr6&84YUQ2;&QElb{OBkH_$%g`=EgyHNKA<+>-`+
z&iH;{a32}yPsX<|Mpu=8g8`|xECPf^ie9+_kV@YY16^k5Y5=LQ-!#78G0=An-46}j
zOMn#TdEl=&^Baaf5*tTXg_~n=DY{03YcX^;8C-|K-D`0B4DK0&d)DCIGq~dh7r}_5
z(h>!v(lXZIiVSX^!Ic|aqrtTp+)W18VQ{=(OU1F@;9fMiBL+v!1B&irgUiP_sBi-S
zsq{@WxXA{`<B^JPslmkzZll5NHn`gi?m>gwZ*VUf+!2HO(BM8cxO|MsI(>k2`V5XM
zIECYUL#NN+b{pJn2Djhf9x=F1gL}{524gy=_!R(BabSqo-xPKSMNOG^^EDv1_PRVb
zY77bkErT;$**1g=$q)l=2Y`?OjVYwo61ey<lw)(Qh;AkD1i!FCHi9PLslnjaRT7uh
zy`D+=b&Ze|*y^+YOd7TcKFlM>=G^)YaR>h%(GKRDWAmG;u8De5(_r!f8h%g3nO^$y
z&)SJ82WVEZ;dgnCY79Lcn+J5e#>Mu@2ZJ?e_zhK88Xtw>6f_0+XKtoHy#AO^1je!1
z?{s~JXc`PZpegS{5d30_C3&K+6UTs03H-@UrDQU|mNd+4U^>z;OMuyzhFJ^DvuPM=
zGC7`xVJ{Pf!B5BaRe(iln0w(WPs2P3S4$e^HMly`Fcg~ZOT*;hWu8sL3<u_D8fF48
z$I~$Uwvb5!Qm61zxT0wo3i}GuFxSCVl!jq{Rg#9e8?N#+49{?{OvCVqcS{=P6}Yyg
zVcv(UBMlSQ%{rB4-ketglfsOJYi}B6I$Z1mQZ$zmqaQ?oXKfm01#}m!Ue}^2{QTLN
zMza&H|CDb|yXaWgU%Tqa(p^ZX^n3a|><V?hqj2IBd~EnPk~+Ow_RshF7gjA$hiX$!
zCAmtujo2!M5}8%XX#`d&lt`;mPA#fRA-c+`Qhq@pRSFwe_otBEi>FflBAZG%wO}fR
z&{C-sA}EqdVbkPMDYO<w1rbUT6~s^s6?7{ZR0<OiK&6mM`jm19MNcVgK<<=6ri4yD
zE+uhF!x(W>8a5znGWd0$b;a3&wwbkc)li8>*-cJ!+lrLZ?SjD9*ti{~yL)`bPnvjc
zG3W|JXQLYbKf*@uQfc#DbvAMx#vb$bi&Upj4XXeqI9H$#M+z4+`MOK!QnQ^B*unV%
z@!dV!fXw_FJAz(@>x;Ap>B#&Vy9C0K12}-+spI_@1|VI=*VqrU4=codC`%Ma_K8B5
z@ijJ&r#@VayJR#Sf+)I-udzo*arEaL=&Ir-xgt??8DC?c3BOBbL64QDGx278jr~J-
zYy{nrOuBBq#vX?y$(xz+W_*o(8~82Y(k1vv{-uA7%{_r%&kYg*23>G&LEn6s>vbKV
zTOQC=?&ljN-dP^}y1J^O_?6^*FIgG6aanZA3tP@imU_vS$dup3a@zl7Uo*7*FQID&
z0g6p&|C1XVe8a+MqC8T3fM0*|<5Fs#5ddG4wr}+8t*<>%8g&kruufRwdF;p~?SHY?
z4^J+0;bkY=BC`^0k;5e(6XUZx_5i|*_fl_0VyTxbb@9RJbcyQNt@>+QKmF}nBG5#I
z@5al#;^%KHk0#5ai73A>&HUP1zHH8T-{l!!ix=%IJHFN`?|l6){Ot93@$-qYqlwD5
zUtf3h$fSK}Q1}$~NY;Y@UMc(V$fW%MUOV`!0rCZ`{(AP|_Sa6Gk(?j7_TYunds~So
z|8VT!ABQGhIQU85GoG&K{2cfujvPFib;gmzV+Y?1pYhmE_XT_>d+=!ZsYByxYS)j8
zW3<GlO%}g)Uc%3l3zAzR$#`_hTC1va4uW60Y^_yK<#V0q!G#ZV6Nh#j*f^{l#GPZv
ze(=c70_C%__QT=>mtC;}MU3)zFS4`j?eb0+e#x@86XDK3;X7r9pXH_qPj9ov!Kkl+
zC4NSpT%M0qJTY^^r`EO$$Hiurm+zeQX?aEGe$C;r{k>3p_#%HeVyWo7Q=#ocXFRc_
zejw^vMOEicg+pDb{ZNv$q`trMX;VI_H0=BVnDJ}ms*1!fu6-{GvYmJQ0aWEGNIk20
z=Tsp0t`k*o<U#*!k7SW-96p5}*0F7>GcGo0&Za*c4pTcBK7f`)vYN`*%J|;>ohP<S
z0Bg}&Yb`zie^-4kod_TNcqr)GkM<(9U*C$My`cR)w2f%{pF$gYB;7CG%^ER3vS?BH
z!p{5rZ>@XpK5+V{NdHrZ3a!)I#?{6e8n0?wkt)x5#UI_t_e(C1-c=5J=a&7)a**Fi
z_aEp)vPLXgw4}WAa-Si-H7|SSbk5eN@hnpB?LP$BtoFZT#h*D`wr>@h7C+GL?2{<F
zH(9waS$6ND`WhfB$~y;w1+%CR>?>9z4)1iG^0mEpZs^_lDZar@e4N<wAj|)C$&VWc
z_qgHZXWzZ{4JJPElY?(&*+1EtzpL)xZ@dG)ad$@gqPmXx$(R?eeTxJ)-V(*j-;m#<
zWXkdQ<B3m_TONF3=J~y?g$vhO6`gy*UOpM`y}d#5-mizrh`eNZ`Pv=}J2xAu9cP0I
zRVO)7yc6+#Rh^eB-}a9O_TF)-Vj?}3U!SFZ6o16;_m`v2oegp{eTg-m&ClJBOW{?1
zh_Bf9v93IU&-Q=KNS5Op{lEN4r!eN${U|4k==mQm?EJMtr-GwnOMSgwRq>-7j57E@
zp7b*!<()tD*~CZJ6@QeRk&kLP1fJ!ccfe;^vLb&`=PiH^&&bCsFi#BYN^~x&g-4QG
zyc=gnZ+Ptd%E;DJlS{m*_WB-&r$^W&qI&IkDwcO+S>%S<2<zt~>&tX+PGY);mm)1l
zt>gwbIV&<JF)IS(Pm@*A9nWulqWBeEf0MKFnQHg88ReapO7@g1qStg1c}0Fj=X-xd
zGG|4}=<qBK8dRup?D}+V8YMf+o-9XC3nd-poev>I;xSO|&%pv7+B^CtD?3pa6VI{B
zizeo{N;SZPqsR^AMdbqXBM80_-T9)<%?OXs?H}6%4?NX={L|BO!qD~6;kP%PJJR{Y
zp^~5iFPGdhpuBTB<2_h>2(ch|@z2|T@@e+#u?fWorc_2_BkT6(*gKxzI2e^78IPRt
zto=bn`C4mHXGF!eKZo6k?t{>lk=})i%9C3oOFDn^v7{&Q*s%xM|FOO69&n3F#DE>2
zZXM0!GckOF{RojbnD_uGDLzvC6Qm~lu~^UjIcR<+iun;{*b?>1pHornII#81GY*5>
zpu|CpwFqt>>hm-Eu|#F$*dG1<slt{FI^97X&LZbycT0Okeo_|-d;i$!$&%=t#EdA)
zeGs}bucE#MIo>&t$z%Ihv5G#1V0r4dTkb(=MC~GUf)$;0hy~RcZ-SZ}k(&I%A0%6n
zZLY4xC<jDzAuA5szysQUhSyn-Iu5!WAH{N$vrs)}p?b#V{3D9hLT<kPyL(bE)v;tr
za#nPwOBJ71dGeC{g`H~^BLsN>l{a~DBrz*L5$OOtJy8`s_BFm)RecBF>_U*PkU*0F
zB_@vSJX-}m_Jz#)bM@h}x7qeEh8-?rU@LJX@yqt3(e^jJMA;3ABke~+iOSuHvYQCH
zv0;gqi=MjnkJLWYd-r1iN(dax{>im(O3zr?(Z1y-d*Ji!AAH*WW(bLOw*AabZn<H{
zr-ZJ9+KVkwdE@q<xWBuneamjtZq)krqa&-bwxLOvFIw2S?ITsw&?WW0VI+{rvfTi8
z97pP)a0D$rD_J=pF(_HtfkCz3&dRq@O{IP&4wLRE=r9JC-JM+iHuQWHD|SfBSvy{l
zQmg13qHrjrM=4#a>WnA^N+9vE^r6Yhdy{1k?wtQ>qVm-xnCGnZ5|uA5Oq3l_mFLyp
zt28pg?XNRo<tPWtub}v3vxmrET<evq(zsuf%1dk?!S|`$oxI2^O<d%$8CLEt{xnhU
zCR(5|B>%9*eWp}0SdF%z^))Ic@BSI{6V4}ruj*W)k+WEUl{cY}>5Y(&a<-x0qJ0`*
zD;h(`bA#ZSKc|2k;oIN(V=_LV{b{=j1yGTMqMPN>iiL|h-#{gY8kfZ3cmI`<ss0J{
zYx6t*<wNz>2PLDo-^a;P<<Vr>s|h=?&^?SPD`GobN?{}{>2?<;=5Jr?EmXPoO%*;l
ze>=17Sp)~)g`GDm^t;Q`;~UVq-o(eui(QedJd!MXQAZ||VjT;jR&h$#?8hmMVSHMg
zNk7h0flhqf`Jx&}-+hx~;K!XmhV$KD0Iu9mew+_;8ESP@uUcJGTeqgZVeOTT>zbNd
zu4-+I#n*4xxM_3g^cgeDX3d^6_o9pE&A((pIW*xcuB=+JblIgv#p5SToOI5)lc!kY
z)>pTVi$MZ4F5adAy3mp8@sk<HMzt5c0e8e(U>9M%Pz0N=wvB5CJO^Od4k-L$7<hBO
z2aj*fF8nC}qKE%=??TZ943tP;#S?N}DGW#v5yt^^Dn;ljTVM*bKUw(CUNA0)k<#>$
zuor;GQkZHOPOO3t`>D@*PUin#r0phMy-ki%Z<Cu+Zxd1KZF-KvyY%wa+w?X%azvL+
zRBO=5RT^~qK>3YPZPOQ|O4*K(<^>hw<m<?FxPFGK=;i5Os1!116+paxN+GoJPz?{Y
z!zc|p1GJhN(Xlg7tCJB2blvzmdqm$&$^o4>J{!ekND2|uIzyc|5}ndIL!CF;IT(p4
zNb#pmnqetl>eU$zr`8xm-w^>Pd`ISJR`{485DtW+lp3GWzJ{DJfmjgmj6jm$Jk!@Y
zeU@mQMq?Q3tDiobx_1^qClGY+NKO{|x_`#`YIur#B|yaiJw4z7jq%0Uj-3$XfUg*Y
z8cCd#%B_@!o^x_-s!=*O7Y$@G-+`_vIl|~X^)keqe<BS(Q&SmqVPq;=(lnhfs1^!g
zO@-`7HOmZr+P=~sB^vu|%|DNTHJ=k{{%N4!{|n7O{Qe}M`DZ?y;TqzGhaQL3gD^G!
z{0r<f%|BthT4)3)Zi3H5sQMuy`)oL%>gU_E(p3F$qa#h#&r(4IRsC!iOopnTJ%S9V
z`guqY8LED`NfDx27m+hV)sLb|Q}v@zCsOsJ($`hh&nLnenq30&W~ls8<e#PTM^RAa
zPXsJ-n15krRj5t!GS_Avoei%D|3Jo(D$5-Lhw@_viC<(Nd?F-|?8YC6rWhg~?^Z+t
z1&Mf?yJwbrg`s6uDq79vM&rf2QC{SL7`|b=s8wHi5rP*3Lo13QU=F3iN@C&v2C(4;
zAcgv$o)~0$5T^Q{Z5TpSHOY4v8LLT9{g1+Bs{c{gfchV@NmKuGy&%%n|1jf1BLeDw
z9u}fB^*^r&Doy>5LUmRD^NEmlqy7h7E8<C0|8u^e($)Vg5nNFH&j!JytN;1D;JT>)
zQIQAL|9o2ryQ=?rQSem%V<Y3U+?$Z>95!rKul@nf2(vH3EDMwzJwVQ^&T{d+u%>5j
z1nB7v|AWS#2~+;`ihN)BzhV5DIT_)7A{$=0HcN@wl_COvXi&3y+03!7yh}|m=AZJH
zHo_M|*yR$I`IzzpdW!^OBAIh3w(#0*ydF1Rgy1F0lsvblIlc-fWwYGx0o_IYk29wl
zH`+M;{s7P30_Qsg^%(G?SJrNt(O3<&QqC|I0cv}6HLeTdMMTbUg|UI*H95`*rVX8B
zv_2*}UYwB%;YI5jFi*9d(?14F)OrwD&KZ9ZN7U+5f?!U69_{Q)Fy9&fG^1|fkqT#m
z3S&iEc!iJebfY!Zv1-eisG5iuZIKjBQqD-UNjX*gQLFa~#OOJr$jeXdXyplaJ@1Ke
z#;Ax~<PqOI%Vi><)Tpt!X-z@AsjXp6Q*BK_16~y4jUWXM^=PZdB}(ZOc|1kzMr<`Y
z^+*pL%2FX1Jj*>Fv+NALNY1LpE17{S;D0Jp=|JX8$6#?ZG&R#PR2=JYr5IfW;u7se
zbPf~enuZ!Wq!=7138G_+__QdWB5}l(W12W(P`*IAg|m^c-fg&O36uZv?_s_kZHuj_
zrneQI@O!2jbpa^c<U`a%g>s2Pa;@;B8->Or0tvCg=NuG7gb2KY6+ZV?K}3n*dsyMg
zcMB$8FpBRK#diQvN;y;bJZeG+jTlUnRJ8E<KNCy=F*@_C@YGF$97!Zz(F#xN6vP-J
zS|yDas5FkXde`xowiWF$Wnnhnv~fjaZIjjGJjIr7WEfPyy&?=;xREiqji|>|Md1O%
z3(Tz^)0PNH1c(jwa(h>g3lyrC)thg$9=Ggx-ohP>CboV>TkUGgTjXaa5OKj&3{){$
zeJ(@!+Z7!k?@Mriz4-SGs+Aa8b|sxCiu}1GynHPtjA(-S*VDE9fVjLU6cki{8yK{`
z{4MlZ^-FdGBcf60uBn64ht<kA9~JTw@XP6g;jdpaRBg;aB^_W-x5?K-XJFYg?2m-2
z<>8Vs=%kt{Gl9?u&ufy|3v@u~sJy1~+NK&_5oXWQxTsfcaI<ap*cjgsDG&VgV-d`4
zs%y6L?K5pAT}617{e+HiH4<Zw_2bKyH#s{Mn<S^uj|p5`e6H*bJbR#|++)exgKSmw
zmdC1SpK7bR=&H9?^yk>4u<lUw=cdz7HuU|WxURN!ejEqDEW6pZ`{O#S^|jjFYTKvO
zLD$}jx;AQhv~PDLb@pxGJAnCqyUZa5kVdHx(g^l$3z~3)m!=p<6(n~Ev2{vYZS9q~
z4ooQz>!n$KLYAncb}xtEp!F=~UJhqF1C;WxUJiT50g{Qmgw?<`xaiC7E%2$>ZME#E
z!~O_a$NK3<<f{<VG1X#9FENz{Vk(t@I;K*GvpE%0X&|QQftY5fm<G4vp0w(=TJHU`
zuGxJ;w#`$_gXS_leL}2w)+zXAqH%5$u8R{5nU?)CPi5r$ObcrF&pp<;0lGFnt6ZYx
z?K%0hk_tdA`+1Ke>_F&X++f)+ddw%u*nbv!YY1g5T~Bh@XSxy@SuintX7z-|66W@q
zE~mfHE;1CFP0o_Zhka@k6!ut`{1sExFjgr(^!-Pe$uO__d{+5<3RL?PPSAQXj0K+%
z7mISZu)a}PBhnGl%#$t~%QNsED7~0{lgs{k81%L5l#n05Yb2WD3gwM;w!CWaV2b@t
z4|&N0AbkTSjCJLBNbuw(-|3-W@-(Ujd#8uA?_KU`N;lX$Jy@@(MM}5^78>>+71QJJ
z{}W6Vm^S!K|L8MS!De==d(=j=Wo#5O^?><2%soB_ONy47T~x^hv`E^!b0i#PM+;z{
zfXTvnhk~ofYj=)JzoE#hrS%fr-3A0_OUUli+r<5q91a7aUG@5vL}R6Wwc<&c6t{M{
zM^R&VUTt`;qcSA);>}IaF^fPtw}u(iwSuC0RK-4UWX4{g;-Kt{JFonl_G1&r0uu-I
zc|qx%&-*lfPDD3nuPBL8u&iMmv+Pwu^H1P2j2+JZ!`{1qS5;j7!+W275_T?d!bJ(l
zB}lj_gapun0X=XyAzT6{3AvykA|zbI5R-Et+yhB~%{Cgus%@>{TiV)+)mH3FE3M&T
z0!nLCs#MX^O6^IbEnW(U*8G3JnZ5Tp3AFF`{=et>p7(p6_vG1`wb!hfS+i!%%$m!d
zk*_Uy9d;gRaBMdOwXP&ybV0l3+dOsHBBXvCC#1<)x^Ls*mpL1tiBg(>i?gJe!rGz!
zJx&Z|pdMx75U2BTQULmZb>jV#ILTz<u!)GO3eTW2-x{!{2u`_Q7;<6XGZmLt@`yRK
zf|sQl>;?4*5G=)W5ey6`Ej*dxe*!n6JPQ$B*4eSVg7-noaYNUaqIUCUGa-Sm#Onx9
z3|WU1#M!9oKXpc@?fUzA<px@{I<^?!$Pb1v10s~m+F7MOE+xTvOU^wOAeu7JN=ZE4
zQ4)_kl8~Q+A+RNiL5qaFqkdN)>Jf=dC3?G-dO#+{>Cs<-Vn3d=9(Ga(?4$-rRXAWp
z?Y30mfF)&p$Rg$viughtL&s<VBsOH74~P5$c_?nSKysaU5M<RTqWKC*4O(HpjX~8I
zayRwsaGZvAMceh<=0S{9QICimmV!XJfn{(jA{$Auxs@AeVK8#>eyb8sKOstM*P6OT
z=C2XqhJf}5cv?UsMY+Y!pH!+XjwqMdhwW`~gvlmyt9*mWKI}t8$kSJcP~W#%R4c8-
zWiR`V?8-Q^%^7W;9M*){GSS$*quGs}Rch~uUW<(b6M9#?sR7v%pAlUknxG-eD|u+I
z?6cn&G_kwfvEIIW`Yf+xWs(NKAB4}SEc6VMkT9pl)v&f3X{W6R&I&SmAz)tfGc+9p
z>G$L9dAwnLjsb5+z{Pmfe`uo_s0m&o1Wy<pX8Vp|DEx%T?UN`+#)x{%JP!l$CwMA)
zS@|9rW93`+KqF(Uc1!j#qhi>{+=QaF`k1sB_Avt~lF@?H>YLJI*zG|g!y2tr22TeY
z7z(o|FGU2yc-<6}r^4MQ!tP*Avv_rOU#h)jf6286j>x_PqPJ{rd)xix0P76T-fn)6
zXZM)NqTl-iFj8~-xT(3WU0x{<XAh{V%QU#o@fe<eBE*f?SQ62lG^|tebU9kHdgVBg
zhFE11LYDT}4N|rCBC`I7Y%Y?0&yMg$N42CyHd0t*;CX;J&vlfgXnKk;-qM8e=Gv7w
zM3`ymQt|S}(s+Cp(PvYvW3;rlguL~%6T)?;{R*zWD{;4bSJH0x&}E<+_a~s#K>FX{
z>;psi363qp?smyC*Lz;X!!HOQxz>`w9X87&B+K)KX*VDaZLQ#Wf#AxA_u+!+I|b7Z
z;C;}Vid8`zVt1FI;Ah)oRkSkWk-`ozpf1)%d-47<JVuWN@HYa(0Ca<%4BZQo^jUZ-
z#9KO-dx8M)yU8*bX;O*7g6ejujfnIjp6#GH3D$>i10_7DvoA56$gbR~s&18)KtVQ7
z<9QGMh4`9RRQ|1YC6Lv-##ZK0G<xp<HD@{1Jux>R!01iD4T4COVb$>Y8J<ClglX9j
z!wzURyrk~$61u;Lq%>vA!~yM+`7)QNk!lK>0x=?3B_^Mf%gd$BSnd)&<>fSxQC(a^
zK`4yYN<r8MW3mhdd+Rtx;>#FC4Y@c%>%+0TXtr0osQlLnnXC~qxo$eMQ6-G))RL;@
zL2>pUt;6LUf2oIDHzzTj@;NKfhVB$$ly6wC{~>L13=$~b7&q&+kgsHMh-}u+B1wLJ
z5k#)bVSdYIeQ3vKeVE;>r=a&$)ZuZm3DQScP45WNdWR9kfT(jBZ-^5E$6ZOHKOZS*
z?nF{U&^NHnA7!=q^9QZ6;z<*jmq=40zQtBY3k<4BY=Y9>ch8{ZmHw*5D?^pbaUZan
zAw1hzylB?tMb7FNfgA{f9c{gJ5wJQ|AY&2DxW0RUXB)6ejN8UJJ{cl<`dIbtCgF9P
zjEO=+UuqjVnZi%owPW-67Kr4rKH!0EY*64AB8)PY!=pyjmM~?uE^ah85$}M{=$`>N
zK;S6=tpJA7{!KrPw;nK>$Nd?A8W>A$XLx?5qMp%5n|Qw!{-ZYlSWVzQ0Q@|1=rV@?
zHs0Q5`0oR7?V3C8XTqH|?j^X|uE#g0zXpIGOs2mJpbWr-zW}&}-`7^-DMtCHyP!}f
z;Dy=(6jdX=J5Xnc62DCQe8&!3u+{zXYBg#T190{D@1TDH@eSc%jeE4!XX3>?G0Y_V
zCZhH$uCv{K21ivVl~hz<cpul}N8)t|HC#+@;$Y`C^g=OOIXs5Y*p%pig>E3)`oe&t
z&grY<r4fp%>zp7#K=AT!6B7ohOOYvm*^QU5s*t8aq056MOKusxWX00*^3lu7pn6M6
zMpv$_R5~Mh{G`3mhM=9!pj?J|TY3DXWY#&2lCx2j@PWb1c0fX<82hgT2vKn=N<u<J
z5=6d0k23v{u4)5Pw7ZM70cl#_t=fbXoHeK2JVTp-|D{^*;AAa9@1bQDYyFESX$cM5
z!<%PlAK}!LqM(*iI#atlsQH2eweiK7Geg?I;3RGT<|hCxc|z--rackcfI}sVN8dZ*
z#2776?{R%$`gR<csXY|4|K4X@H}utti`VMUEY*A6a;rAu(*`Z6^x?NNN9XSPsTMl^
z;=Flf+Lq1w#0D+CVcvYbXHm|J`mNe^Y1;g)TI#1-$wb1ZH}3z9zEn$a4N;e6&eMVo
zGi$WC{h6aDWlqu_RQGSylFsQhUueA>MrkXGwQDEdQ5~B3nSP_Trc{dyYF!)j(JyMZ
zmuf>N7HM}BYeOckaebrvlk@ahnWMF`V*R-ZPio!t6s>Zi*0osMyLs!pQ4?=NYER&3
z%ok_sqi2P+SAsbDrhBors#se-5fNy2Ow@)oXvs6QdnRgyL2Y8go+q^*xf-;D6fKmt
zRZE!o{adx}GuCQDg3GkKj)&%G@xe)}_1hjCR8se1NZY$npRq!}eo|4+XQQ>!Csuqm
zX@0+L+IKfKG-xYIwQEbY6%%Vm-a0Q+>oa529n*94NwwPIt=eHl->>yZ(aO@cKCCUB
zp${50NgK5PPD<(;JtZ`1*67TTmiQJjwXRruY@=Qr96c*E^UpugF2ugoaO=!H`uquN
zv>w3^YqZa*Ce8|J4|bXH6K&;weO^_`q)FP>RSkdMqwVgd&v>XpOTrPS!O^28WqJ#4
zo1z6F!x?&}meTNI=*h=#9j)&|8gW~n4b2ao&}u8TYFoM$Ywh<<3~7H(41PALNc)c3
zplz*qV$v<pC3#rt#F4iSoU{kQdTw34Oz(+uyLRhd?fJw~?KhQa+B1n0C*7v)QcJb_
zp3vg;;4bZ+ty-U;RyI-VQLHTu9)@~tyX97d`hJBgRo#<0bK5haP)P528u}L8lR0k=
zU-`aEt30P|Px_^noT4o&){@g)_-6O&r<n4SW&4L7PoAVWt!vC=>jcAbmM42MR(kuS
z#VI^Rab4t$#)K>Z^HjvCYzR}WaE)*W;Su2w?=*3U;^c&YJjhWTNJ7%{c&?Vd!yj4+
zm_knaHh(F=@y9OVHn{dllGD?YDwu`IJynMnPH{|$qM2HwEl5jRKr)`{sCePW-(Jws
z?6c#_s)^a=-i}rxX|>2?vq*e$H^rBbo2KOQSW4`alBc|m7csyvK$ElX$~bOMOIjNp
zM?zs#Xj|5M5!Q$bD`f42B)eG&r3`1KY0HSi_c3<3sa<2{r6uK)dZNV>$J{x{Tc>=L
zrX{)F=)ja~Y7|$I4`Vr|EwSUr$(VvK2)aN7meO{46Z~mPURqK~gu&rf`W%=BI)|SF
ziI9}R;WyHv<zViIHZAgEl|fk)pHmaorzNFW^c+r6_IBQ8rzMq2j#R~_;c$q&MA6J9
z4KCl}?soCx2#0f(HjR~T05X~ul{O0Bn_$b8LyYg(VIsU1rzPDL9VB71^~PeGj7pLs
zQiRol@ZYe*%M(ZMNK2Ya){fdbA?*4n8jG)4X-S*Xlx0!LOo2|Kvd*{Sroozma_^KM
z*F#X|GzA(`85MSNf~%$jkLx?URi>qYFV`Dsh}+gVVZhjYMYS7D9;$|(THdk_HVEr<
zVQByk>2z7=qfhh#>*7Or;xGfHV2~-o(ajfdNT)kj;@xzaSH?&8E&&JKbU7UzeFPfg
zo+WVUdl;_Ng6UQX_@+H{Ww^-6XUr?Z#o+L^*ugr3lEiuiBz~Ll|GRj20-VI4WC0u&
zxS*TvaS7{mUlVXhr`sa&Zn|d$9Mb9jQNWS26VK!Q6AMT8l7w}-UkEs))4eS5tWffY
zqM(^3N&{|;gmt={6Q`8uax%I@Y2dxPg`<m#LVs~ADL<=cIJ%sSW;nVQyunVIt!}R6
zPd8t};;7MG0uJePIr+>u=vpufL;Na%tH%>{jNo3pK8c4x=zdSa;uO)31RT=o@`z2+
z&^<3<;a-DAmh98zoHS|d<hW^yYlS!o&qlq9ps(QpicYHl^BL&{iKWv+grRzhUkY9a
z;bGKt2TNF-kSR}p#9^txRa-Q4za`+1PM4F?(QMs~_X<2wZ0*JClNK4>?@3svds)CC
zoi2@I5f$9w0uJePIqe*s1mio3r&AIVl}G0b;akZ4MZ*wSRSK=#Dz5?cq3{jR`3oLR
zDc`(@0M95xoD6lX2;~TtDfR|RQ{vk95Ev-^=`aD8=!#_;?BFs4F6gFvlZ17;iv%3f
z>2eM`I#&!gP2ke^(9OdWl|%N6_X%$tN({GB!a7|l1=WOZNWeii-9r|hF6XhMliPuC
z{NSA}0bL$C206V1=T!-+2$3K{McN8Z<zEoq0Xp<nl_EOX0u0buC_!7~<eX8)DjM^=
zhnziu$9^aLOA(}y4jI*yT~BSc!?Q;}jECIQJt|?H?w<u5(&=*YnKX1QxQcEndTC0B
zE@!)=rNFq~6XDYL&^?C-QlP`2kUyPI@lZ~5x$y{SI$Z@=NN2DF=`e|?a-%&VE_4HD
zbjRWW2Rhx&0!ICUOIsqEGaufw@yG@oBVPHN4pbqYs1!Ku%-u}UZ8~vx<B_3z*`b-p
z7C{<x)2)-RPM5cqP)u|iC0<-$#_3|>?Kr*zzi04RJ<G2Eet<_+^60cieCz<f>wtEX
zf^kMwN~nU;O`x1+iKbEp9*TtSSPAQNmkKzf)8*_mY3N$8)2L?y7r+Bq(J2yOp3N2w
zt^4pWG+l0j0<6=0P{1LbF6X96L)U_x6t)5P0G_DQ*o)UE@h}M8?@3svtHFk%DCu&k
zhBRWyM#2Kend@kA{~F<5$ActD8jmL`HClCpL<qFraEC}(r^^X{#zc3i#JlPK$imb8
zv4yA03FzpQ88@elaU86BE8Oqn=>j;mT)Eyc9-@eJ65oyoEy6-LB@$$k3=S-vrzB`6
z2&`QojA|Snq?bsS(cy5c-R{EOsCV+mV9(--5&_AW9Ab(}>MHTugv<{qWq!F^QT}Xy
zJ5ACw;IZGo1^5S1?{*Tlza0<vK2cWS@ha?Q!zWkz+5sBzDmG|A9q1m#LrtW6LBJuM
zE~nY4GST69t|1bl!)4?s+k?iqiiaWSid7iIN_UgMhjhBt0uH+Aa#B881vu@#0*|cg
zZh~wGP<1)wPU@&y{0Lr&jw&0*DN#-bd={ub;vrjfKaj9amxi`T9<C~2unw1N3&hji
zVd3eD%}K!1ZMN`qY41m8gK1ubAy3U>d>;zhU5Ru*!V`ld{xb&cA$SoFgh=NS9&jmK
z9$`q1>0XwwPWNjGC&pRxs!YKy9;V8@JZzWgaw8dJLx;>ja^$5B4?t$;m;{-FHw74=
z(<-rc3Q+<-j|8$16BD4DBVx^?QzSt;OC(5VvjlAhc_L+;Kn3VfYUp^YosQQ7<WS+C
zN5}HN-|_DOWG~?#pkw*hI{pWN<YYH8{Wvo5l*|*Ip9;{a`Nu(Im5)xDP#BP;Zs(b>
z%`|C$iwC&*bfqZs8H{ICqU`KYQFXyiprgzqgpPLFgiP`O2`5Y)XZY)}gWY><di&ju
z-hPkHK_r~sDV)BiV>oeRga~T$_Frb=H8AxS9>|?MbrE6-+y@n1i^rv8?D+`p=N2rs
zN{I@S;k4=_5QKMwBL+IF1Xx7I`rrYU4%gq%=+YT2v2^AMFqaM$BC35aKrBmTq;y!w
zP`CRxuLY?gLIvnNgh${BJTCEcej~tKI#*~SPYEp-{*KB1TfCm@h!XsWoT6EQ%X2?b
zsdc(>0>*G3F4sC(+3f-w3IGED{CFk{SJa#XkfIK(q5tz3UqvVjfRU8edCCtv2>U$c
zgHaf4v@21Lbw+TAXC=2V>OAESqv)d0T#m7+adw{4wbMISUc_<>Z6yN!l_mEo+-}Wn
z+T4RKd}#wYzM1G(xT%``T4a0lPP}0|C-y6I`=;C&y$_JJE1LU+?Jd#l)8u|=ZrPQa
zq2C20cS3V#u-pdC4vdQ<h?AX^*Z|F)4swGqw}siec-fqC5sDiYM7!#|uq)tF6St9a
z4=Q1?+{<-YE;iAF{S0C5dgPCDC$iX_GFR-cr|8df6?h{ChvwY2W&gO3#EXZvI`1a5
zfBy>4tphLMp&>^*?;v2>cJ}YT^0zG%S|%(F`}eQ#cK2;});9gq5FZ=ny^sT&V*5wj
z%XqkWC@Ks5HsP^bp8vOWY)2~auvNO(ikA(Q{p+0me?>3u7Zkh5<k8>qc0ODGgSdWs
zA=ag>^<C#!@3N9LbL6ePj*81Aemfv5j-yaEQq)dys<?IKFEvYSJeS)AY`Un*c(wDx
zQSeZriO6v;aVO3|K(Wd#z)8sGKp{Yr1Rc*ZmFJ89%JDq{=r-ZYQ%$`BIs<63fGz==
zA|Myk)h8gHbv0E$cL4GWXc-`xE-whl61c4n&Tw!qIJia!cN~z6r6(F0$%_w=jBgI0
zX(GN2fU*I_id!HC31~NP650!Bx}a+YB*UI@pbr2^uG#>})cy%*h6v$BZIvPB1Cps#
z0g^HE>T-#D)WPiqBx89E&`c4_*MMdT=$aT?ettj_x6px>JHB5zP!cL{jtDyi&};#1
z1vE!MzXZhosF!jckSxI-sJ32#n+iz!h5+RX-1~qe_a6Y_P_>uR28hGrUdjlxg_8v|
z-GLqgG*{pb0+L~W1xSW%1|<1=4Umjw11g*>tycj_p8o(y#(ds^u0sWt@udJ_U)D>>
za&R*p+&VzA6dC|YnSLLTjPC>>T34~kwP;jm@%2)8y0?tE5Rl~bUO<w+Z4TYb4&5sb
z-5(t~7kX(K3s2*g98@{b1_!Ekpjrpo;XwC0P=f<K>_Cq>(BlrY*MX9d8<}ph1F<WS
zxD*FUb)ex6#1=r(c^zn~1F=M<Z?OZ-cc8l*2x_Ga!4oT_EkpPn-|2ux2w$!QaPcNq
zdD(&f;y|A}5a)&^oeQ;0LfstbItN;ggr#rLfwn<&ByN`jJ?lWfa-g>z=t<~?4DoA}
zs)YXTK*J$tiJRv@n;qyk4up^KEm`67dJ9ShG)m<67C<tVV#jyB1KkB^l%QJ!NYXVp
zxNkbReGbI))JKUBuQ<>@07=<@;Xwa%d}m<$j`Zc(=@R1E>7zs}_dB=-2YT4?J?7w!
zJJ3nT_jiCK&&eJ;=6(*80!XGY0+6Iz=-@Uubkz=2>-g3Kk|7QOx=C<)((!%QfzASw
zIXdS+JnLNIu63ZkfFv)20m+!hIM5=8uEc>>1Ck+jJGe(3=sS+@K0q?QXC2&24)j|G
zde4FSVZ~1Jm*POFfMjZ;0Ll0!I?!^*cRL^%)^wl;9pA?Q$*^w&l5NvR4&7ykPVZr-
zHo}3H0+KP`<3Ot%-zq>d=IsvjyyJTikPLgsf&Sz`A3D%q0m)nr>}kih5ReSJ7?3RK
z&446bt%Iv~aE}3!As%<2rySp(I?&G@-(Nb=I}Y@|1N{k*OzjImGM9QU8|n#2`eryd
zFCfXmR0o>w_|63+L(Fr07dX&8j_(c!cfSKQIKD?5=p)DXyaRpi_zu0sPHhq($<<^B
z@;kok0m-~Q?)dHnbd#uCO%C)HAj$oCKr+719q5wdd)>7*-Hi^E4oIev>ELo4s1T5h
z?{+{piF8XH-&GD&<v<%9x@`{bK?iyokc{tH2YTM|Jp@Sd((K^=;Lv^GK!0(3zXl{j
zbnk7)d<`JU=@39tE;l;9qaDcW`1%2TL*y;s;94Bq83(!*UAE+YiUVZ<l4;BVBxAYL
zf$nu6!=Zb|fnIkYrH>uUH4e1UfvN$?9PM^+-vuOjdD8KH#_|2R1HI%x#~ixfIJox!
z$yomA_<rp8UT~mx2XbR3L-NuUkj(jL2O94{Qvk`Bvm7Yj@tx=37C2C;<NJVvd&q$v
zaeSWxB-_cK1CkQ|vxED}fd*jSMRG70kfi%LN?GC{dgVq@<`L^_yn~BaTICKd2uOx~
z%)veG;0`*tLk{k=gFEBkzH)Gw=Cb1BVP%q+;SP>Fc_nV8gX6uR68DsY<M>VD&N{fS
z9Gn8%O!CZ+w<Mj{!EJDG)ei0{2e;qBopx|%9Nbq94ij%y8YzHe8mSJB--k(Dv4eZq
z!SOx`$sg~NkaWCHLgLOlxX&G203$C+Hy4nkyANY432}W=LbP&+;fclHl@L01i|%T7
zOxXK(LFD{)S`b7lV#I<SAjT8HJdL-;4jAgf`3{(qcw>-ADB9FX9Wa-G;pUPEjRtUU
z2Mjl?q@WBUG($+!0W%I5?huI3cmeW&)d*%LKrXgNF!KQhzyYFS(c-rp7=CdUp;-;E
z5%P~<wgTj`bp&%i!0HZ|$4G<Xh|v51AlFnQ7|vVl?ST0;FkI$~(3}9s^{)u#9f0NF
zG{W;adSd(<q4_(&h7L4e0K)~B2#tmaxKliWNoJHzs4MRc;gsJZNn-tvJ_}s%qwa%G
z*N!xI<A@IHM;Wtxul5^ir4CVpMx6M31=%=@2BHQHXPZB~g2rpnK(L_U>EBl-ILo4e
zU_rx^ztgUWXP!j^p@C*tl05|)O}NCO!H^9!H{k!3X$37B4CX+?)4s2y;rUGbCE(H2
z6#Takfb8FH3xz@e4fX5FA9oM&#}d%gJpzvY7k#!j21lTQ(S4O4+e0zI2}eeG*ov9N
zE}XJ2K0D@%_yKco$-R{&>^I~O7|tNuuW*5>z=tLsF^gB?bL0pLG@QbYAQ)<CNsyll
z+dqj}yru&NmqPGZ4EraU<z6QHhfs?aFD{9wqLr^dcBBz=>UJ1A@7yhA{}4||p7jxh
zkw+-l2=ZK7QPL?Fr5&S|QATSyLapTS2~ISOXHCU&e5mI9WGHU1vVRhDLkA4yyb{x|
z9cjjQq>-PW*d&%Tco(hxb1C!i_CMrC4Nf;-dHjLsyk=pZnS~-(JAA9kf)%S)N<`H6
z{(|7@AMy*Y4%a>~GV5Llf>9sA%XIL~Y+zAvnV4A@Y99GYN)Xt0UHI~g=K8YJ#@-~^
ziT;Foq5Sqa?WS=!VsD}R=9w=RseOHh;DqOMh<NS0J?zZp<0KyG<9szL==edG#LLgR
zpb+9D3yMlC_K4FK#7dT+mtP->oJ5dwSbgn_DGDG4=R+eA2H!V<-<$vE-MJFA<jAIj
z?a8XrC5zTNd0ALlR$hS<j!Gk#PD>$nuA>XSG*}TTTf7Lh(e|aNrk7Qg;IJJVCF{NY
zMuIGSQW^2KuJ_>G9cz}CrL7vBB7YfUZ_XGy{u^U6#$WyJj*N`)xYdKdyW(eYvkHEH
zL)FKG1%6lF-67DO{-xkOy1(w^?Yw$P7u9Dw9-V+{ym!94gZAj$&OH<O?0k0zw=8oz
z@FCfJDd>PjW83-ej{ZRN7={i%#@FfY4$9%1z@M{d1q*<q`#Z*gX$j?r77gFU5AXl}
zY*j@?d@|I(I&PAs`R`AgbW&4eajI8^^4~aF(mF)a<s6lE#UW|`muG<?*uOsitJBF}
z9JWIUn1X^hI(;*U-HF1Jd1TS@ch$u`+GNz;SjCI~6lttjbCXau-f7*)aSZLHSmml?
z7AbA`%ioojs_heTqcxwYUCj!O)_Qh?SEFH!x9}f+)LKoY&R_XsUigc_qp1{%&~bsY
z|IM`kX{l1zul(I*p`@isJ-6g*;iEO2lD(Qm$I-%ns~^AOKCZj(<_ULJ9O64{3tqXr
zti;AUq0qXmsvL7=>o#W0|F&*cu?gq@H?12>^M6}6mf8Oot(%m#qbUE|y2)Kg|5IAG
z@<mHaDk6<rify}%8F%&8ZTy&Tj7fKFH+Gbm^~q3`EdsjIc59r1eJJRnT4;6P_gy?G
zc%pkSyk7O^1va`DyDAZo)p$DFZn^04-2P4>z(;4>?Yha>?SSs>Q+{WL-{b5mN!RJ#
zHD0DrZeTCjNJ%IDldhBP_7x^8Mq`?}mqjOLA4%8g-nD_VFdO;<k!0i_={nuJ)*l`1
zj89=VLdN_#>2|tzjWc~qFJSL|XS%E0yVi11QSP_skfh9Sr+e4-LP5`iuEUS~WpuoE
zjoEDI)QeMo(LFiipsjky(g7z<(20AC%;ZephG5XlPRgvQhA%FDDDQ=9Q(}$TNkAH}
z;0h4UxUW}cO)Y(U+|kTMK}ET<*^7xRMOknZ1hLg?2PmOyjNPPZJ7e8rQN3<}5^OW`
zaQjc_Gs~|Lu^Z1<lkD4!e&&X@?NRrn<eN#=>v}1n5$5g1CU5P*eK379XN=r@jd8r@
zk6jLjwViHFTx#{^rJA$q9k^^QZ{i&bc1}(53aoX5T>VQ(fceWej+UC<>q~J<OfTHN
z6wk{$G&7Km>qD|jP2ct2Qp0yWVu`xPCcQrAq`dbF7oH^JCX8O@?d}Q1?#dKna%$Zh
zxF*M&8VUo?cihZYb1WSZ@SYGOH`RFE%u8)+lHu{*!C%OmHxJ$JMz+S_S`v!RtVlHO
zOT>Q&eStAsudYJ=`!!F2@?o$26q>Pc*k<9X65N-9EPE&7Dv$d4u5?o~3O)~n$Ks-m
zJI$Hy-0%oM+}?#CJ`n+~&oK)=Z+njXna>@E$LvAxn~$9YU?e`@_K@V%k(a!O$7nXQ
zQ|eBHHkgm?0Aby`q1d(or47bs#%Z%MIed(lmhg797sc%*Np%-O=kRVm%2=DX-;e+N
zHE(BN{_>i)a}Jrm=I!KxzwkzcZk{%kaPxKs<*#{KHXX2y+g0ofwj%dl3I6&SO@{xR
zS(Un_i7A)^AkA(Q*1OkqudhtzTj*0eaB0o@>lNH&<v*8adcC-P$*de%2&%9mS#LXH
z`jU-U$Pu^eoeuw%*Oa|u`p<>~5M=fG{z~vV)0f)h>(ATJV$J;FMqoJp^L{yFN~#dT
z&k+XkQ_#gzXBx#*TknCE33>N4wld#sZ+Eyy4j1VeN2{y4X={4o{-4U!a4P6|8=Y0S
zD^2RfxxBpkg7bNSa3SJn<TJfc;&+Vm7hB0|!MV(W&o{rc@jA2MTrL<kXRhSkZzCiz
zD4%Qlk4*ph%I~(lAAQdfukq_wANo8uZ-u)s5WXyKWC1$}&>guc42OAnS%HoO4Hqv6
zI~{%RoOKJ;M5ExCam4VSG^-y*_KerehtTROhQ9^Z_QW0W)XhV~Wai*bxE7$5X8$QV
z=C`=6W4wR(>w%`f#Vj}l3fwjIma#=dvWrnn_}cTJ2Z25HY}Tk#Ij78m7IVSL`p{YM
ztQVTT@<7-p+2;K^A0pH*bo_hi$5RyLvmbaKJ?wet$a5v*U-#6#0yIPCoT@pZBVf(z
zBFc?=QTP*HO~ad|Jazj>g}fBB$n<KCB$~y7wsBklI?-g4hBiu8Y_cR7C9d`=3_s}*
z6<ZM@xg)*E{(_T8cgs;`K0mzHp-V^h;b-m=QsF&i>TU|6yGcQ`b;orznG242wp~Ps
zgPgdvRhoeyzwd}}?-&aj4__Ww)7Wmj1(DXg(O#Gjow**js-ZZL!y12!ic&FiT51YT
zK^l#?)5r5{i|5(jn*K)h6{Fzz#S%#9IH>t{s`W0U*XiD~xyDhJc+P=(|LG=|g4-64
z$Q#UzBhZ^g=EgH-=(G_!Xly)G)2?g?Y$~RR3J%sBIdA41s(HPgw>?6V8)Tgmp>D)A
zeVH52tsX2$PuCpz+{`&6NY9cqH$oarM$U~E(H7Kv?OFXv+mjZ5rvJ1EeWs@I5^`Q2
zYRL;gMe@Ug1$!wXp(8>ugo=FjgU|shOwPHQ#`9*u83fB{A91|T<vg?C7_Sow|3%zT
zCc|zsL%8nhSlxvtce)ZpiJi@Om$zyill9s2>wW{hBYtlj#l?f4)t&Iv=CgYV9m83L
zt=R-~&bEcw5Oiw4vJL+!vzm3opl<8XAXFwHq<4%@P`KedS&ez~Q!t*{m-l4hTCk52
zjZbSD-8FBpf`RE%0dt)fDp!Qdq()k-BUI=Ws@`<3aoor`4tl)dme0!rRZ-cxi^^u^
zoFmh3fsccDyn^83#^c@zhds58z(7?pvr|3W*E27EQCUW?W*3~o)vR0Dj++m$-DW?T
zJ?OaEZ!4PKxVA*|4qoFHlR48J`rHhis@~L1^K9Qt!goEjX^gCLB(>jv98FeXIE4Gs
zSVz&uZ8=7&#vm@T1oOH1?Lvh&o>M(_7oeBsf>Y+~<od#7UQA`ORf*w0bA}r?{GmHF
zvUM{r5tp;J9tU*;1oskajwQVYCVw3=P`!SD;;CCB3hVfE<02S2+&++^{o34k{Nf)y
z&wiqQYWN$W^r$3I3^OD}T~uh!SeY9>Chjl8rCsbGJav1>f|Pd7@zxYXYwKshaYkCu
zD6S!__n)otH@c0SV}Y82V-Ri&jxO&WI>tJgb1b}2UWACEo5{j@wMLYbyG9fhx-GA9
z-kd&e6s2y2j^o<Co@fYg&1^4C;MCXa8aJPxkaN~k7sHI@oNJv68Q@~EU!f}fi#}`y
z`Y?zRJ)_}2-dZXoe7t^gyYW8wMmueMW`>S?o;`iB<am8Ark58eM1kg;vmu3Fiwn_s
zb=e(E!RqVSuIG8tthDw<be13@`j76X7dyXRklRDZN;P(ohZ35+@ha-og0D^-H3RHb
zjTYQ{dN|x)g{yf3;XI^;9>-S<B{|3mET~+IS;O|y+%5W^ngfJ=sfKT)=^JP4rbai{
zux;nBx#lSeC`QeG@&26kUcFvdg8iC&aW(@@-Z&K&9^$b$0z2l+pqanS)NtMHfE4T?
zM+@61ZaPbWu8uJCi|gL-)J}rf$-4jZyzqa(x7k<BG^p18&szt=x5=lg&A#!(w$<}q
zNBiEy>Z;yKXuL4|GEMJF69#jzEAKB2go~{k)$&uCeY6wWVM`CIUJnzody}u5(&S6V
zC7_U-us3|<C+xg8`%;(|n$zo{vCL^`Z1s8wybzoqXdL815%SkuLoxE#gl}w`eDN?K
zhx4`VAqv1341|C4nYc%^I4^t@P$YY8Pg}(-2+=+7lZ12gnqY&59}&cJ85d;HRvWp8
zt-$m1R}5UmnOyTld@!cwi>|QI11YeKlu#ElI~zt&SEJ>`(V8z3f`1_ZTQ|&#4TJWC
z(Q=gc63crhtE)UpFxjkTmuTjDCmh)nYwQ*;6b;$(t_*~`f)Q|F)X=Bx?NWxvy}s}t
z4s*&3=|;}kLfA%y;SWA#BInS48;Pm3l=8zZKv@=AM|;XRn$cLjzPl2<p?W>IxY4ZH
zf#{oj-Pw*ovj-@q7o&*KKTO{SLyVyuQ;&?zL`@1JZZg(%;g~Blrh0v%5{$WU%pEKx
z!S2TqU3+CZO&D`8U|16{Ji@m@7Z3<B|8&cTiW^^PrS0@}&3I$Sk%^k;oATn{-0WQ3
zE*aMn5LQ!HnG9_nw&*BlwRJXtjK(~K#Lc5Lt-_yJ(FV7+7Qpk$@c{*fi?%Z^?DTar
z-k#915fxx%Zf;Rtc)tv5G}T;+3Gx1A(^nM;KVruidYe5N?!v__&|<s=-aj@j?eKMr
z;H~5i4MRp*KVa`~`G^uQjyBh=1V6+>u>DMNkcDE@l>-^R8~+U955I1vfDox1KNQsd
zf-4Tj+r~GSfbO%Wjdx@+=DO633(Zqf8E4ydr48XP!D{o=7ix*f!hNz|CnF)egV7I+
zxi8cbk$~GZuQmO(#^tt`VD^Wb5vC5t*16DM%>}jGc7qCM#g8Ca;U6&nU-t=pLMz)-
zyAUi`^`*(%AIgzR<zUz3hmZLJ^V60j<YV5EN<42QHnZfY;BM3B&df?(bIzRY%{E?v
zjM1r^>qi>j43bLxhk0jwlhIuKqb6MRvbf<CH6Y<U3pb@^y;}`Vfux?0GV3TW#ED^2
zVZWMJ20$kY=jWNRf$-~p7a^H}b!4zfm^E{f&CSWiuTLS*^^fqsxz=s0bDL{*+{<ZB
zPc&vEwxL;x8sCfY+brX#S<MDHK{U{w+TFA&g!O9*>(@Bm>~DlWh7QN*#I*$Hna{J@
z8W)XFBRlIO?JyRLjE%<%Vfc&{+$9<Q=Zt~_HU8(+nt}rg3^80PYMKmYZhX%3EPAqw
zrl|btCl^begSjia_z*2R<9W7(#`8kgUSwNnyto(toBS=mZ}PwXyC(k|F-`tAzi9HG
zN@?={?#U+qTZ^0gZ@&$rvl{19<8Du@GXL;zq5`2RdurcB1hAQLpKW^}{DAbR_l+wm
z3aoI4H{l&!)$Q|egE{W5UB%b@)cUNXc?;3M+{IVH`@-V-tX{c+@N8giH$^iYFkd9M
zMJtjE&C2q^@K_Ry22WTTnh<4ADM|sO&<*hlT^j&SrT8$QQkRt`K|FVq=ZF9Hu_$7v
z+TdR2=pxy@4=EZZi>-A&yY|)M-q+LYq@EW+lceo)rM=tF_^p|}5_h{AN5!4TW_R>&
z<IMG5T-|P5mO9K9xZoUBx8Ur>zi0(#p?m%_MP?H2sGTc0n;m3BA?q}^q{8SrQ@>lN
zT}J)vWOH@0@w|AO=QeJ4oAY$zc1sEEU~OG_U8nP7|H0M_(@fRtQ*fToJkBT0bl2yP
zG_~-p&~u2ZtqHv-Jw$(j%WpY4z7)SXu6fEVE-WrMYD}3W=YJR<?oh@Z%QctP;DnvU
z&;ZXj5AVoMsJW~K2cc~aB-U(9;*GsWwAvFp0$qddCU1Aeo`3q8TKjJB-L|)zyb0=0
z)wb7e!A>Y#3~-BLwHLBItobPWC7M7SIN%CvpPK`5pYCmD)1w41wg?aYNa!HPKc3pf
zE=nqirvBXoHzrlzrg&-#0l%~ti?F}omNPSygt2oScmFi8+8t+PC>f*RP+s^{8`LZ3
zBu6bix4H3DeeL8#_}9A+8t&Ba&*3Y2uR55@hdi~vWFqU`^*hcnUVlGh_DUnGU%h*R
z+HPb8jRAm+ta6OF)n?e9>KCv*Pa3o5*Sm3b@kt|ViFyf17+H7KPaPj`WG#aloCFuV
zt9TaqC^%&FN)1mIptxflrq_#XKm0I?J$26sFsXVxvdEpkkW5WDZbGwX+a~h0jiW9$
zE^eoBv1Tdk8+&ViBw~Q6Yi^ofWZt<XKYZ%1NcYYqyubPcK+)@N8dAMMYai{Y{Sf5!
z`Dn6B8|o8X7V>vMX2T%=80K(pp1B~|%$i^Gfr=>aDhk&zy4iOz^T%tBB{nOgR;&s&
zd)>IDVP%t7=lCiQ^dMeV6fPFT%LFm*ivCnZ>IhL8ycZ#YD=NxLo4xu<r75ec3leC~
znze)lcV2DI3P68v8`QEREB1mv*@aPzZ50sL1;pmY#%yDg*T_oU=?BWQGpA+8?A|;5
z$9H7)+L?1~2j+h_w#0q8<IaSd&(s}vLa%$73ow}MQgilF-MdECL{DvB%4%bx@r?`^
zNA@U{!<T|Xg?YL8;cvG}-DpO!q2JsDjmitxNn})jjmP16pHnO>BfIHG2y;PWMtgpE
zwiTBsLKbxqS|NIKFp>dJ-n~6S64kYP>h3}QOHor=X&i|D6l%?wTT?M!VgJ>X)y*AA
z6j@Q)3`8huS6=x2u;4wyX8kO!y-8JCha+7PUjTIp1w-vD$`AiU(qrzl;83fFX&UFl
z^DuB}eTU5@(nH)B<l_=>a)ILQS47^~#pZ|05gLQGnm?j|Q!qv}n&S=!`=gJZ+ev4I
za9Z<`1?HW-`b{!nD<_kv+MWk~jx;AJDfp^<C_MmJdfxgy_(XC|R$3ng3Y}r=7K_oy
zcnxhCS~Me2<+Oj|y`d4o7972@J+<f?j{OUNIe&`@542vT=C!5h2u9#GbC`9e&zsRc
z0e9Am!A%!)Chh-$rABO|00c<~3`BtbA}>7VFH+AAvkf{M%)-2C&N=u9eE<gU`QGqJ
z4gesu8p<#b{^y56<cQTUi9yZk5P1W9gaUD<faQnw7x`Ntr*33_P?#SOnMo?-mGw_E
zMzsDI@&#66_!y5Ya5#(W;uXxxg-!UQcqj2v9nUw9$ZOm$zB8!B8d-FfXT}L@#&u+~
z|13B}Gp$?dV`gEj7xI}|FdwV3FhO_t@RtJ*g2bA}LA}NdZ40c!jN_dD!<@}Kn3}Dn
zWs~uSnH8Au&gPhn8;#ik%J;bFRcU07N7bo43Zi;QE$3uDXA@8TSxA?4?iXYNT{Y%1
zE-M=rZ<=o+p)ZXukT@c|b0e;}Kg)__arq0v8Si2SND0luaLQb8uC<8L6#e&v<CR-m
zX-?YX$HQvPn@Z~f)*Vq_E-7pFz|b{bMf9*YaAA5NJWVoV95&vR^Wbey8naVdRRo%F
zsq#!Khc;Gx2%6DoyqfU_g0~$hZ7^qN8%HJ^=Z)Ff;c8grW?}XW_G^XNt(;}G$CK>i
z7wDK_(F|VzrI#PBgs<rfI0NfQ{Sf+`Ea&j@!!t>@J_Y4p*B(lqP?@^Ar_kmJ7=pis
z1Ut{?@en=^&%cL}8T~@%SQwvj(tY8A*55#>u{;2O4N#;SM2|nAZKY-a>sxOG<EE4v
zf$K9G7aR?1kP(5-`o!@rrtU<Y7Q^hW9p?A3=)*zyL~{pc^*|`ri=e~5hoLs8#q765
z%<sJ_=l70f=3{=3i)dI~3w9MNX>HGfy0Ps?;Cb^o3={Tt9?#`7ak<1dw#hqCt**in
z%ZTcAaY|^gIU_YQ+Z`NWW~XvwgqUK@;^D@;;ih*uQs{1Er@~UooH2aUdu<n}AI8oG
z@Y(j)j^hg}1-BBMQ(ZMs2~DqF*Hb}F!3<%=T+FLs6|qfIKa(T1i*NqL_(I1py`S3T
zO;N}QCK5n;d$GOXsGffFL*o-&FKv*fClZd7KN4H8)0-sM9_{wQo9(P8)_kOc<V33q
z6PEfV^d-^Us8{2JsNfydn|mq2W#)h0k9=VH?`CtFT-l3Fr=?Y?H~Eq<52M2uP9mK^
zI19}sG|XDx!`j;`&C|xyt7#f0bez?<rfKn9GRSBYT+8}|wyy}&H*UnxJgt~v5K&uW
zl>9g!LTk92>e==I{i*&_QKdl02_#S5+raMh_0G7!nWW&xS~LomB%v6JJoQJ?VqW7e
zvnQv2R$#U)yjvhK!NJzoH#ZR83WS^}5jmNQ2so<mjdD;}_MA3>dRS8@t<5zoX#Sdf
zJs^p6f?%SyF?1g$AFP(PYap;f%?l5eiD7n3HS;%Evsg{OYs8$4T!pr$(k=vD#(Asl
zMf)OR^wbSvcERY(U~c&LXT`J~y})T}EWCtxVnW|T0`9i&V$vj!&3hpH6Oe+&XhJ>i
z|F0(2S}&uC5RsSXhBt`F-7JLGKLKy+#}bT>(=l!gU^Hvyms@RrUU-(30?qn5SR$}_
z&m{Oyd+OdKteG#e7c(xKm<9KhPYzE)ZzF~Pb>D_Rs$@T;ArS@;ViZu#kYmYEmRoHM
zgj@f>X3-5}z|3h>Is0z-5B^fjxMKV;3Dl(ZH)1AK^+Fqq3d27~5ZWw)D^9OtLc8AI
zlA9aI3x8YqB}u=(f;%pbZ9JuT?*EZSE9KkxZ)%Lvt9w;+SWo4JORX^e12SC<VV*-s
zkuFxM4ycD$C`Qh6n4`#P#NglnRz1f?SO`@x{tbnm2l5%W|A4V^zwrk{%#Wg=@(aVU
zGJeXCN3kH@{P3smBioodz^e0nO*KxBXhDDa#lXy*QyX5{9Fys9sW@tUX>Qz)1!Uy-
z7^!nejf|ZLUL#mLU=-{NgntAt;LU=4L~g_q!oH&L!yS+zA`8Qt9VCpCf_>r9Vnnl#
z&AeReLVtBdk*+|aDuu~!z*vHH{gH>OX<OT^4fd1?=1ZWH3CJMlsUKl6L`|J%T+V2U
z`_xm*6<2iaAgSvqz|$OG`_C2@2CVhFuVl@l<c5#}i{6*oL*J6gm<7m2qj3?5jlhgb
z&KcTOImb{)eKsDeY1GB)5(o8IW(#k9Pu3OxIboe!{WW^#%UTU*V0!M}i~rXAjF{jz
z5tU#%<8>qFAY#opoRD+SQ+I1S%EEsdOL<UKSmInw@p(rSfaF*oEIu+}Gv^@eAf|l?
zX~!aMjE1;_z~9Ksqr8y+I)yROR1D8WJwqmI|MoSdEoM7J`<Zb8OOvROD^yd=5EYpw
zr(tr#gHbGqg@WPyNY;eVInTBi5xVWSm_@u?;;Bo<OY1zY>aqG9Wc5L-9)LQoIm57`
z`h;@Kg6GVfr$7*{W-AZcoP&mcUv4-TR8%S?@<wQ=>3>cPaJ?7>m^u6N@-RI#TEs)m
zBO62EV|>|qHyo+6Nz$9ydgDv*asoazm%!O|BHJu$LrnL`d7@Sg48z3pY+vvdhYJUg
zEv5CJfNM6kD4uPf0cw2$|Ev!FCHmX#S3lT8w0k_YVg>&B9q_BW;HljXw|Wyg{MDv!
zV*Q5LbTr((VY&3mMUe&a%-JJz!^_@9mbxIH$b2AtJKk<Lr?~^+0H9{JL)algs|kZQ
zbQ4+VE~X{10X1tl<Y=BI`^sseuSAcMSX6|K6S;+AArUh~V54p=bL<-)=~N6~YI6;{
zVE$1455LDoKMoy6H>?VwMv5-9w4r)^4<&eu==a8%zLc6vu$9nNx`MMa-axQPTy#HT
z^(~kKmf>2jrST^0UDj=B+C7Ao+R_H_$F5de{kRDKPpn!a+O`M8+u!j96CRc7TzE0a
zMb!*FX&h<$Zd89Q*FQ`z2LnCWZLdy*;PS)wvG~wFou<v&x*PT&`Ztsh=`n#-YEHS{
z?3)e4t<;!uedsQ;rW#pqo{}UaFr^nb%QpfLYAq$Qo1Q@V&6-9DCFbT*ta(zbzU*wn
zhv|+`a`pP&N-&{D)DC4s+@?VgOCiK<Eu|Ux8`_@cuCUMx)^@OGYQ#*YviiNYQ;vN!
z(b{j&_!7TjM1%CeooH?j0=5P>>%HDg|1nSPG@#|QmsGdOY?WYtw|Di_@nhSJH^eGM
z?HeJTcFK#0!ORq-bw31bT&`Z<1zNfhJw^5USS6Th`s6hGb+BKIf`h0!uwH(5TF8>s
z>aS2es!%2qGKF5B2+kK0p934-w*5VI&oHTcY!~x9&?`oCGW8gQ`7jBJy1ycMMG{6b
z8%4ZWK;@wIU}$5#n7#Z3%fNV>vvEO$#3Bo<9JjD$YEClN-N*5t^>`GRsGre}$?HL1
znB#V^hKc!@oMZO-!D^jI?ljJv?G9nTgO1v^qSVY1CVM$d_N?pKl(rig)J?g`fMw{Z
zeE|w&vQRyBKPI?7CF24nY5Gz7?TI98!#W*q{yi$DF9kd)#;2_hfR-c3t#I3(#stV?
zn7<Ok9;5AXye>zc+wP~*d$x^+*va1vxG)t}E<9eXC!_7wEV>0I(p<Bb4t~ExzF1vf
z#^NUBaSzgDjS27jK%@yaP5{+Pdrq|9=FF*?GiQ13=Q#jo<p!qxU4T*{#2Uo&)OX_V
zML~<E>Nc}5l}!x<7i(q>H>M27f2PJ`&5Qv3FxQq!evrKxsA!~Sjy-kX5|IqV`Ib$-
zo~n5(2#mMD+NZ{)@cFkPRR1wEf3A_`X1Dx0`f>DGnKOrb9()<FJ^a||b~R-UP$GLC
zcVzVwoDKX}obfbyaAvO0HuEP=D{aoYUIqKc`s__f^;zkd^oOykf)Clq=7+zD)su+k
z^6>l#s9X>7j07o~HvrXa#5#F=_4=OBjU#xkFT@s(V-R+4%sv^-a!RAF6^u7!rNF+R
zl0q}HO_NGH=u*9Vi<x8;>PEVmrBi;j?4imNTe&I7F3Inp;3&A8QEX<<)@A5lCcNT#
z@Cn4Q<uaH4JP+`z=lY2~>c{;Kuc!ujwlZStj}pG&cZd|zfY-yFXEYVlG7n#a7vz=2
z%83{Ds-h+Z!e5?3I%2(+ZRLyP*?6A(qOlt}r@;)MWP<$$U9Ru-h#Ak#C7jUFjLC_H
ztJ#}K2ISiATWH_%C+_t1V%(KpF@ad`uCAZDb)4Zpq@E9icOfOFfx&^NwgLIVB%v&c
zHRQp6$QS_cdUvdmHBxe9WF?!vsa`|$o`!E~>u(__v>;eaLU%aXicc8b#gGX{BdtGS
z#QAq&<3L_fcz`6KJYQhOPKWRRLwoy6Xj7EdZY1;{%k%|2+X`5^nDykB-i6`Q=yt$K
z>qlS0MQ(g6G5_<X6d+=1=Png?Fn7r%A2eJ{;6}uURNE`>$_xKMQn#K0spz1gy{$9A
z{I3-#=1Vj)Tc@Ict!;tL{?kYp6GmsGbCwPo%hr!&Qm{SE%Db%jB(6~}bLp_03X8&%
zL_%mkFZj7Zh#RIU-JgPUWOmQ{?d@CIdBCivb|5p;-o;aUEr8Z9khp9QWK#-*cOp=t
z)LK7hCw@Bo353^LEnqa+;XFi!timH3GQ^gbJ&1^jd62K>EaXeburT~B^wbpJGYA@J
zuk=DDt4D@+zag+0jiMGMidyurT%zBRmD2iKNUwVRwTh>%8=`}F+bdUw7b1*kU>`w>
zR2|L_%@CUdbS(Hok%Pn0h_x0nZwyi%9x0P)?T*}-u|`7!xN7|e{H+l)*k22?QZ&cM
zYT9Ewb+KUcrFitRtzXgju)_>P7-=tX{-U54r&My1i~`R6o@gyV9)<jDdt!lZoVL1v
zCSPwQd;kT5v=&@swy@n~9u+BnF6KX97g-T|ZahSCTghsP<SRErEXAv=pSQ#Q!^=E#
zcMCF-7tX;8*I@i`ErUV?!bo}yP>@mEBc11)toddvmHAR&@l#i~BQjb_o^AIFh;}N?
zc=JWd3w>NJ>M|m(5B5$syXA)8YM~99g-Ul4P;)GZ6syRarojfC1{*Xh2`+YeY)%Ci
z%~?=T(ufuUGl9=WOwEX$DSC82C;XggB`7&62gg-57E)Y_wOw}3=-5cu+I$A@2Zk~Q
z+ulybe8G6^&%xRUY>tk5r?^7b3w%?9d~>O?e?v%YRZ;siB9lWdp^z|f6Egs22aF!{
z4TZTy;Xl2`5Gh8}f2Ti&e%@+Urr2FMx4@v^v!`n?y>%PrevoD$T!ZMFePY%Jd@*-&
zS4hpJE}?f#-(BpYioy#(#Skdh6SBT?d)IKt<at&?G^N3`ny<SAUqaL`Zuy#3J@`C)
zZ$i@~W?_EtYqn`^domh--Gx9+_4;@vcoHNPFj|bJw!@YnBlCII{2cUsW1<OjwwoG+
z;Ui4`ZgTBCL5xC!LnB<XlMG^Gaw^+kFqm;6;)m?!hsSYk=V}GB{<o2W2^J#;gl1T4
z{uhl7T6>phg98>RXP0V`kPCX1&e<>;uAbVmcGfiynvf-cB60kl?JhIlItzGvzIiNk
z2-0gbnp$rHI%+&oWHfV&_(-$2=^bhK&tMJ3oRNaX6nqWP75WL|0F$IiF!H0d^iuez
z7&43c75Yo{=Kh?_?TyNznqvREF%63p=r^l|H%}Xm2o&R&tZLPp`zgTyY#}%DhHS-|
z3(i)r$4u}<(|@+f+e0<yxB*SbPTlwr=6=QYI75sAKqxn>uJ=wj?y0*Ed6;a>Ol@5T
z01{J*!Wn1+p*XDXH>0V<xW0NFTB7*sb&ysaF8712b+&1850y-K>K38iRj-XD!CJNl
zxp+s?=0bO7G3>GRpqG0VO@@R=`8d<-6&o+HPSBeZC72fGZcJ6~#(ayrF+qs(HycFj
zvg0vi+4Pp@bAf&<^v`1NQ6`lm2*r+1Q*8K@TYNEPk?X}IAKZD^p)u<u^k~6Z>~O0&
z;{LC9ddOi4Iq+eRh=)lE-F4T985NG2DW7Y}z|3?s(2!v|WNurYYKyeX-hA@|9XoE%
zg3Icv1jX}k<Bn+qs@G!vdH_oZWnq1qV^$Wc=imI3p0sn?0Lr7bG1x_jxx0#1QniZL
zQ=5tuQS4oj9Wro@CG0uw%<Pe#2jft5LfEynRFxz4*DhVs%_&~2|Ga9|88>w58bn`c
z&hwgcM&@G<<VNWS<-L7k&C&FF_rU6^Boy!S6#Y&%_psmG#)dwLFy@S364B&MqMo(x
zMny4N!aqWX$VT#gyf#3gTdx6Nm1D8j42-Wi>NdSW&$I6s@8@!dEH-S155Sfe!VLWe
z(gsD%TP)JT{Pz32?V&U6_XWedULi>ewEV{`!6LWOV$Li!E63xDrY!Zi@j8|zq_iu?
zQ-ZR+17BalHh}hG(s^ABwnbL2vkRd03CQUR>5LHRBpDin)4!u|y1@$t14dgHBPc4f
zXcxvIflmF&M66Gk1LamJyPolDf=lY^Skc(^MCrXo8-e}O9Yzax^fmdeRgwFPr@0+v
znmZc{Yl9BwV+j$Pr^91l*dx<fNPI$zr)CaHd<yrz7qpD{l&-%e;|+-Yf#FmI-&|{<
z-m(x`9;`wQ6V|vrwL1Y#s2uLux&;7+QlA|Ds|MlibjwAUH!nS<2A7+=Pr_G@LO8gZ
zf_SqBoj2WEQ35?%$Kn<C4JMr#H|H`Zlw*91@~*Dp)^H9r;QyS8mC~G3S(9rUjhs{H
zzWk>q_**u80~{h;-MwgSI!;PVI3Ii!GB7@^$LjNGjz=)GLY_Hg8(f30ETDebVoj7=
zT`(aa1{>Ch{z7oz4D5{=bj0lS2qyXB+LFvXj@RQROu;%^)06?~gq#-7o<?vJYQlOh
z1kME>Yql64c+}6u0y?Do6O`_V^Vn9?BG&rRP|NQ@jsRl*f?XhA<e64Kwzvnv=g?td
zMwBZ225NV!j*LC0T0|Ldv|d7ltj|yxgc4$DJqH}@5BWV&&gWbK#XbS%`R2dLJhOl9
z%1?;Ux6A!eNDo_g^TH3KPEjhPxQ@sLpXY}c$^k_r0QQ%e1^ny@+o!RI#yc_)p4lt{
zw!JFNJlp=6FXkJ&#RSVR1cP)|u*b$!-Lh(&1?s7N6g-R17tmaUl8Vs9ho{IjG+`wy
zF~#Z<3O{Ue_z12%wL0Vjaj{ow>niqW;u}Y<Reoj&>b5lKhfFOoy1$p{d~B!lj+`+!
znqZ#5$_~AS0{b;bV3xsCy*?QXQi-e`S_7Fbc9qQZPRm?B+_Rk@Lq+M>7xm?8Tl};M
z@Y?!0qq&4;8%>Dug{T59YnI?CHT3R;i@~>9z?W@Zd?K<bEHs2t$45EgIMn`mXhr<k
zEwMiken%`q>=&94e9U;Ol}mpS>y<klJ+*D%2^L69>o9mCqWYY()&L%*Ki*1(Qmo^0
z8B^jG4UU+sLif}apc`e#np4O`AYAz}zF+h%#033WlygmEGWI_LHBSW00#DfH&W%s4
zZ$ax|nQ?}RZHOq}IzJ#phG`-ddoeQF3&VpEm}&VBp?B_uu>$tVg$^}%e%(v;s&7wd
z3jKrQC=B}$GI}Y*T5#|mf<;`@h_AQsnHyFPG=F1HEEtH+Qx=B&=HLiYh4)2FM`GC_
zV4M&CSdK%44%O*o7RwPi$IxAaGwbs+jP-MlVJAbOIkOxqCb{9zF>(uIn<9G?b)!B9
zEh4Bev5)nNLU_-s_n*46C=i|j7&*Z%*z;It0bf|{%h?a+n*67Kk9~1X{@?#D(Byw7
zW<^qy|J^TgoBU_6TlGEcR(&74RsZld7BBL`F?M>QI3M<PXS)1`1BUSkWI!^)5qs;)
zP>+np++6Gr4`87+FMQ&tRf?^b;oo6{XwE*PU@tco;b-sLece;b*2wNkut68{GW~n`
zy&Bdw3-)mt?G0q<x!gj`h~8txF81Z(V;St@#fLIt<1eHLS>nqagpkpBo_*zFNu&B(
z6dJzPDL5u36{v0gvw?7Txeu(h78!`_m%zljT!EiuufQ)CEAXpLv22d!XuMf8v3`CM
ztRYVQ3@$Y1V3u37J+B?Hzp;H8khS^_CBp_ov=Yb7X(M6gqF*e6?q$3IK9IqpaGYGS
z#nPL#9&a_*vVVW{G04h%@G1V^&MuA%SdZ=_z%TN!o^>qlb?%iqNPSpv3}5M(MI({O
z&ya|@W<2_p3!7$UoG_<hk4&5HoACaoOu#T6^E}UDOAt2zeF1s5p!+h5g6PXIp-qds
z;)EzhWcXDqaLqwA75gcUm=7KxFMFuvMox=?@2$4)C;Xt`ZV&l2rj5f_&R{8Y2r;80
znow}u^Wg8{<EiI*4-!S!W-K^pKv7X@lIAVX17Ub#J+U4itmYb@fQ>xko$yn3RXs*6
zoW%+$hUwz7H1km=Yd$EFEx@O2C-LcAOI2}Z=;VfctjjJqzIqlnG8UW^^2{~oU~MkX
zc!gPf@VJ#lPhB76uN{5ojuVVc3SEeM!dshP-Qb>Zbj{0<tWj`M#^uO^)1cc%A#8_;
zZ<Y}o*lQN*E{jdZ+4>n&9pY5rY^;(3;6mdbA-n%%CR)$2)`+xa7@00UIiBXd5gGjC
zx}1|-vMgv34G)S<e&XlHmyO|^Mp^e@mHva3>WXMuCxX`rM?Kpgfw$NQh2&fBLy}H^
z$^9y(cfPYfMZ7E4SM%skrT@x~{@x{>-tX%0zSEoF?0*sC=aJ?DtbJqgDg15BNLf}K
zKf1#dI=3sI;wRR6_+#X!$%k1J%qw;LnlLAO&?R%+R_twwYnyCx6(e{{<|bG{#-|K;
z00IB~6gX!@F$KOeYrqcQ0LDKB78|}uTsM5vx+Y&g^tQUO-feC<PKDS-TM;SNySKvL
z<G0r_#=Jz#R_E&mrU3feTW>I^#g-OlQ0tR}+T!8X78B#!9MpopjCaN0b>k@v(MLK%
z@uT>D{xUYob+T4*h`|nDKk><U0~!r<)~Hd41YPOJ=VW>F<LtRWVXL@`%7MKx*sIh}
zY@Gs2K!c@SOdB~yqorYuqS-6Q*;|N4w1Kc9Ba5&@`_~c-HiJWP&^lmmmFK}3fQ?tg
z_9)3Lw?EZ<(w>r-)S5;*dzO#`kk0dMU=#W^($Wv?zWXy15!2@NQ_^7u%7swp`yOtW
z&w-U&)w6o7M+tS^(Xu1Ax6mehBeZjJ?*&q`e*e3eFH)Xd{I;`oUjYC9tTpXg+--GB
zLT18rY;t#dlmr-HF?9GI3(s!wjNwa{o~qU@A%U+dUiGdrApCeGTO54#h;KZ6t&sFh
z7^*Oe#B0=HiMTi(ATFsTrW>c|JVX<jWHBSs>ux13IO*Xeo<PE$R^squ^tfn4q-MQd
zqpC8IYX>0_UIN!U4cw9QVTmasg5(&7d)^_3iqLml6y~}FmC5u2m6QMeAaGs=L?WEt
zQ${&3-ikm`Qqt7h672+S|3Q%;-PIndH<l?}AK}A=In%-Y)r_8bYC&vq!aNwjxFI;B
zrwbVzk^meoKOBeme#p<T1e9tI!Q*h^7<PojDasAR;Ov%2deeJGQXCn{21AXCWSg&P
zQLjjMbVLC3P4ADGBkX06TgFUonVT_!Ul8IlVVV8ug8gxVN5pqiRD5{7IXb(H;2X>*
z0hFqYpgW3YLUcMf4vwjyXp~H{W2cWxtcb@QRcRJiQo^@JmqkPjw?(6)<>QT#4_KTW
zFVetBT%-!wE4?Snqx4W;)M>K|QhX`n(r!u{tEg$CD=QX{mgg1y`{TQQHU;tEhco}g
z;e?vJt;@QW&(*Y)etOKxRb@+4#6KLL2}G9&qQg0YR&e_gKi7$ThIhv>l-nKSo{87k
z5yV~ZIs&H)VYh3riz8LNJf|eMY}JxV#g*#foS$njs`FK@4;$wS3jcT%u;L22en@Aq
zqF2e|OkJy8JTBTb*sWKI15sUTT=N7%*Q?~YsIDqkoxmjORn7^juC=bc0-2;&<@4xO
z*E-jW0?|ts7wU;qS6%B}JRsgRI9acn#S>^<8!W1RdX;rft81f$N&!#HN*3RfSAx?*
zSC=f20XA9urOIgSlWSd@T|98!HF!AE7k9JC1gkCbk$TnD&#`rFu_)4&7<V5;kw9@K
zs+3C_Uc2%iyx5q>xCh`x`cWvtuj^0X)0O01`IR?_ZgGhC9gZXtP&833yt>7>7do^Q
zpQN>-;ry#ii-MG1i~%Y9!0~#^@gf8-299y_;At6_Qi+5W%)<Xqz{cJTQdbX+S21-V
zobBqVZFb}ADWMv@G$uyXs9ZOvQrwB?y2iq}^?R$FvwU6GT39`PE<^Mdk+=pY>g#4N
z!m-q@WUUUdx&|ld<&(?Hr!EREQe1sBip@0`+98h2b@kOaV=pwrI>y)4PkTq8pc~fN
zz^?ul3c3+}F0gBWc3F^8E27UCb`8`9qKy%1F?FR(DMdru0~A$arN5$L6^<1hr1AQ5
z*Wh&G^4H#rI;O1_m~q5dbz`trFL2{gHx`vGS#@t2kH&VTT8U4D>a8p(DOX%Ww5J52
z7b+a8s3<85&gB8!uA$nS0zVZ+;DXp=+$PvgV9l1LbpWqjSq5DxvZ!*S2gq3@G42Mu
zNO}q=ir!L>M#rC0k^c1R`W*ft{8`7J!s!&=CQ{&)sIrtOt_Tsr4*|lXQes!e?RA1t
ze$rpm5M~Hr=ZmnEW5f^W4I&tsq~s#e!fUtVb=2`91g{ftA_u(2xPQWTRd<?I(JcR8
z9`l;S+ex)Vm9216XzUo+4eA8cjLyfuCWSI?Ry2>AKtESZ<+4>3!4$UHNulwI)?NKQ
zc#6G@NVIen%PvY6!iidj`U|{JUC~%-W7OX=I4WED<cg(=HdY9pt#H|tP~}=h8z&kh
z*I?Z$c#=n29*Bambvk@j3oI>LrMUZ&Yb~${2k<HGfnVVzPQIK|XR7<q7sf9FN9rt<
zdPf%Ui5|bt6SYOnQSWBV;KV}b2NzWYOO`0=Y|AGm{>KbI$9j#8pU&5S_1Z<p_j^GZ
zSFVNA1#Ws-0Zy@3^DJbXKu!(?SFPe1+G@UqkJrmqi5^9rYhe=fQq*yYE3j~hdL??D
zg{3POEv;14LJQj!aq{qKwa7wri$6l<img{q{F8j0XT2uHbA3j=-Foe=<DSppTHm6@
z%MisK7Pd!x8^g@EUVG~Ja&_w6in_o;^wM#nf6k)HAjGZSX(6xCm#mt-DkyngXd$oF
zOR5&H3{@^)U6QkE36i+W^60HYam$vL_*R9=f>T%Fuvm4G<&_-2iK*YMjuNHPPsfS$
zJ`s4ar6DQ$lDkFUr!KKDsrssl<x8hp*b)mnT*zBemRh)xdRbn{VntnQy{GGo@2L#k
zJH2dqP*ImzX^s;CXA8pR7U6ik%wH9(Sfr>cEX>6CSjzGq>(vV@46iG#*QrdXR8jA>
z-m~NT(YwrgoyGoz%B!wYKM)xW=!>S8&5(+zsO2he>T?aAOKd*$OHuE$P{r|OjHyCp
zTjv@)KmIgdE3MbN^mUO_=hdKvU81jJBr__?Rw`=9LN3!wq2#Mo_W!QIEA<u8ujP;d
z-`7~)!FcXFQmfRzVj12wxJqAH5mMB(>RG|&2Gr`6h<crx4sUJn4plFgT(7q<_X7jQ
zf@>9ZgN15P?HY%BWfgU!ItYT$20!eevzI`@Hd*M$RZ%Ly3F^%jdY?r5Sc-~TZDIFI
z><n4>TP*AWU?Y~3x>b~gHu#WA(+O8agcb+URjS+7F5SpTBk*}8%b^-n^c@!Vn5vhF
z)9}@LEBtX)UnDUPs9i<KlgRAcd&~377cGWne^ba?8{DGCKSCKkqV^P2xPexidN*4t
z#hv;yG*fYbrOa}=>JmjAKZVq|heSwRiQmpwx1}y_y?k~_RZylIBP5EpQ!fwTMCOjj
zL|xoEp~k8=i-=&PFr+B2E>^%~eR)LpbgL%zldXfI##xB|vh|3!UI)l_BEfncsF#(L
zED<KPnrPuttXj}jj0;_ZuXmK7o0W2^WZ6;;8#_E6#=W9mV|5ZE(fqTKMtd)GVjHE^
z9akqR>Z5H?z#aq>)yJrOJ#m|HMJ4LXxA=zEzGwL?v{j1wZTarD2-s4wk^hcF>qz2F
zMAiLO#`+(V5w-_GUHu;A-;0Kyy3dJ{Vpi1eTTvqH-@#t&A4!y|ZbE=AgnOw&M19fA
z=b(L3)S*@tMkgq1$1n?Fm8L`v?^v20k%=fNi5X$ZI0>oWi_|@;3bpDg{#j-c`@R_W
zd9V}XCac%X1XF`Sb?sl#XM2?1E0<RWCoh2%2DnspGdz;ZX92}``>pIAzSRl80P--v
z#hCi^T`sEOa522<D?~hNIcY}-TBgXRA;wLm6Y1pP{Dak~4ik~oKoppr)Wi-+O^ixv
zqDab0X_83kx{tv~U!mnPxtTJ#>o6GvJQZ8w=SX~?zUAm>Etbn?DQbbm9(bw<F|YY0
zL7_0VKGcD|S%|EksC{)VmcG)PH?UZZv(UijHC5f=P(81as{idQ{sS7DvA*bIUJ#Hn
zK#a6;wZ^J@LSSZ}TNJO_<b>YmX6SyRdhc_yHz3pB7bRwg7QGa@j~LNKsoj%o2Fqd?
zIC+s6bikiJ{khPnu8Ls~+IKlRlNd`Mdc!k;70KcW_h2l<l`y>RJGgcs`Gje4FhMey
z>!fioK?q?0?vGhwHCXD?(mYpx;7~oCC^#vnl02PAC6QTrI#Fb)0utGuNJgZbo=K#f
zl-`SR1xZCV3Ic~?pgPB?>MM+LD6{Zr9APL?1!C(hFW3?7rP>6#ui=+0l52`%a{Wb#
zHOC2Nd*8e0o)RD8hM^Tg)fk8yjU;i%Lt<rsHFd!FDrmj&vJXXV>mpipwHoyO7J*Lv
zs0+=;WO+%t`f(R_m;K7<^S3U~!RaULmA`jk*7`D+p9oMHu&UA;@T*~$jPz%Mi7eE&
zu#3?omxv)h-b4XerLv@C<-L}5rNzpCZ}vbsB70gav)69`#iPa6fwTUCOLr`}6zRvr
z3RYws^13B8R^rNSv#m=k)9+jE7#zAptdj%|Ixd!3>|53e9UsfW8|ZMla8(G6#_ZVZ
zwt><9RTNGyk)qP4zc5b*$at*i13`4C13N@5P$?ozA6A~51Sq4rSw_V&!_Y(MDH|?D
zoouOUU(BZ^mrqAgPflRr_Jx@?C4pGhq$v`Iir`BSa=wN%H^5gkgUL#7SwkyIDsgen
z!exspmn{q~x_c$ssvn{;FhD3}|3lFjB+n*Zh}i1(pK`I=N2>(Qf68iWmMQ9g%2IV&
z8qv@$MvPAjc1gWhP%8tFX7;L}BlTkmve?f$NgoqcP!{#e2`p+QMUB>A_6bu;mM(`3
z-tQqp_wQvh{(cWCjZlt1^bjHt)x+v^m!Nvg0<EkbOGNePBP&y>M^q*$p@oZ<ELj*_
zwXhONEtCbY%dM)roS?fzlO;nwBpS8;q8jgZi)!4F;mM2d3oWmJj8}G(?0)93dv7<P
z<J+l5W!>0%B$t=VdcUfhAiJMl<=sRfu*y{k5Df);zmDl(7Dcv=XL<^2LLG69omF5!
zZa0R@%NAEGl*5w69G1}No77$M_7jAWIxwj_c}rei3E{z(B#Gbxg)cgWTe}Mdl<_Qd
zBD$@+XpG6LR|M$Ociof_tlom|n@|z)QH9kV*}Y_?3pHF(cJLp5_gsrfc%fjGLS?1`
zH`oOCU4%EJ5p<;<!n+zs{RtecJZVqrUI4M>O6=ebdxmfcY3Okvl7`&?a1@@=h;#U-
zK;6wah7G{KR6JQkzXS9dqDM@_zYw0`vFNZU_YtM|w;az6!U6-J+{g;VaSDc__o5|L
z)W>9t*8tB`csO==&&k4LA`ASIX{2b=z9s6_V7!mu_o7GejNFcY>UUi%{Mqmrg&O^Y
zi({fHA(ug-6~F~n5TOyTo&_~mM;^!1wYM!QBc5deGaDS<TT-#KB&zA?Cz}r5I=K?h
zr+9E~BV;^TQTvGoV+zXU`tm9E>w|brLlY5NiR|@HpsncIHFZ?^+(pYV@aZptybKy;
zknE>ug!`5)Vujovhw&U|vSD6gPV7UZGkOXr;X!3808W<ee$kI@!h1UVRi1<tAl;$3
z5$CN4MxkLj7)O=+A;^%L({|yOJ@tTFO+qT1J$(n><CE=_4v6a51MS8rp+zr<s+x}X
zk#m`Xd@sej9ix4()xyPccHm5$`W&KNfoM59_o);08Ig%oPSo#-OnfHZMOyF2v3a}=
z7Uw8?;Qj}ZgG!(>T9DCrM4Ey}{V48j#5?BCz<n2<BW#c1pHLjYK<nA<lXw~V{y1(-
z4|J;U3NN9C6$@?7F`$>-XE~_<g69iRRpInNDg0%kC!GWZ8_jq@OsU?7_ff2-%f;*W
z@j9d$_)-6dwfBIpsz~2}&&^!mKq!HL2nvJ}4J9`r6oC{IKuQ97NiYe5A|;Iy0=X9m
zC?JvI+7httYJ#F`L%^<J!LkZ#FN@ew!Lq9>f@@#>o@d@OlS9=1|Ns5I@BSE`XWsXn
zcix#ZXU?3GbLPlpPC28TuaAH4K-s;rWSL)vp~hv>khIwq5iF)&l>OicYVVI8Y1Imk
z4IqL(JhgsNuL1HPO3^FF7h`x(JrDUIRk$TU1KP&aJE2(!=%tvibZ&tT?`3^(Sqfv!
zdYoIj@G=}fQmhYZO2Y6jSx*k?xs2Pq8|)iV^u_L`GkWOp@iAn5=E*e(X;jZ3V`}Fz
zCb=NeE9eC^q{>`yN$^BL9a$fJ4L1=*LbE2%Dyu-~eS@qiroMPkDdG+E(@y8YqAyq4
z8HngQ%1;R<?gb_-hHyEwLoWo0sh<FuZryuuqFdKWTGwn*5>dK=2?)3Z4cP+^4fqsj
zpDMZR5m8+7#I;6~_3A02cEa&k<okHb8%(15LjPRIbW@@_doi>8jAUS`Vo(3beD#W4
zTpW?LKCb)>(o62;S|36_8LN#NUHTm4Y)7n6(h(D6%3LzDYQe0U*|X-%pNVT=dUkRG
zwJmfrs?dblD7y}+13n2PgZ5&*-2W1?KKgRax)y9yTb$<&(_?6T3vMqAnIX~Y67QnO
z2EF``sdsgoF44JxC=t?o=bu_|k_;5cjC*Md&baSDD=oTApG5qGe6n|nad`{Q!b6aT
z^8{!Vdii^9ycb(sfh$~TJ0Q!4GLbWD(r)B7B8S6E4Ga$=ZG+XIzAW*6i|v4is6LI)
z3cm}DoEyBVTcP*#40Lujlz}%|=skVE_STnYPj^98PSu?)(!N0cS5~`*)&7Va?!Duf
zg}Gud2!1j-_?Ag`$}*`6eR(0;cP`8xu>E|eUNOB2S%{OtU3%3N2#?TfpV?ez%`C;l
z&kG1|b{dc3BYA>x3P?6m;Dt`3%8~DxkT!#2On+%-f~1p-1_^`oH`YlJNajL<pEsT3
z5W<^>fj5GIHSo6-En5qNSRA8e9K50T*Y_bC$upG(7~RE+4+PV;BF_sVY1e|B0%F=e
z6IW7seJfG+lQnSq1X4Oo&bN*e^{MPu$ojD1iFypbfGh@28g@~g|A1b5<0`Q4Mr2@h
z%fKGE`vvL0&|hU;uGSN64mO1|P=C18OpYJO<jBv`o`w{K#kVM>C&v%;<jB9DmdWu0
zJvqLK{E(%yaKQZ_hP$Gf8xO{?U`+i2xx~@3SJO1etLAoL{bU=xZ)Kyle(1Ze;O<)3
zN}oR2hDYNe=ruV;KBbor+<<z=dAiMQXu$?#(|P%#61Fu+fflj-*LePtE5@SFp4Wy4
zVVHOwMq`gs6bpRXhC3#H-a%^FtcnPBdi}*sC-8G?nVS*QW~9zIi~8Qi^|L;}&V{TG
zM@6Kj3ajRy^%3-P2z7A()!7G;wH5FavAzXQnVeH_O<0O%^NW2Qdc&o6!KX|wU}iun
zYqD~E!tqz+lW_`Fp|x)?$5Am)pGO@<b}-LOKY>rq*@25=Z%@F$`wFr-Sk3o0ilIM2
zqUwKMmDB=du7fJ61ISMx*z`NmNiU(C?EBZpvZG{%_;c(|7!1bZTlTLL5O@kw;ELD`
z?q3<)IC{@2hmGE|Hh}auc6!gck;To>^B)jjl>MLz4$nq>J7ISfdPD}pi+Vr!2C~qK
z2{@qhY~UqDJq}2^6JFN4LJzEJ^-=74xZ#8Nfq$sPgFt;0OXpgeN3q2q_~{F9x4?-$
zjCFM~d6DIORQ@&6C9ruLy0m!^zJ*NMT97!b7L%?334sh?EoKYz>dhQ{*H$mMpKGT_
z5I1WGX%dW+`*8E}H1oN3oa1kRtbZ3MdFrdDwSD@oejw~PS;wDDmPE#I)yMN;C$JM&
ziRlvQZ*YNcusFj;BMd0G!(bmAhMAjL?jSMs!QXl-m{nR5shL!=v;@2E>#YJ|_}YTh
z1*^S}t-sfezaa~ZrRQ-7?}yEl?<u3aNL}aj<D!;ZaP3^(5j#Ea(@?_|{SfgihS=WK
zw*YZ?loLv9)DAAyh<aEhE#h2WQ^CP<h`Ha>(Ut1j4qHxxPF^-{*eYh@y=-U98N8~|
z#pU7gEz~Oe(Frd5=m+HWpy{g3tFcVu3gJYZ`yRPLPtjR7o$rlhPO^8;t-F?70?DA8
zXmOIxa}m+wPUcV6`5qI=duY!0kMiawpJ(vaa9TbLOQGaS?<=@+GTlonim6y(A9e^N
zxI5wPO>N#J?X7KNv7r;c51>G)zT$JPmgZ2(uf!);_zwv4wQ?QD1{bO9hu;h{-uuO!
zz_|;!e|_Wz63|g0q^&4*h?`9hw2yQra-cl`SFqDJp?+_m`S0WW+YO|`RSwcSa5pT`
zxcj$pH-z_nFrWR~<sF~j9l1?6fPQcTVYr%w6pwYndh70oCU;`(1b(m%j~}AA*vzh%
z{VGN#{VF&dgdvazr}3wl7-RIL&xM@6@*!I?rZo)^ryfg6&-qWF*dTo;GT3?|X3h`}
zgo&x#7`Pg~%n7t^&CNL-Qf>rV93RqDT=w*CRP|}CuaKl7m@K3#QD&MAsE-M#S$W>@
z;aDs8CdndcRW=;dBRvNv&s!%&#>o&|L@Uzqqcu2_!0k5*XlWLz#ajI<18))J$<6U`
zvmf>46<i~dDz~7z4j8umapVl0YC5vgRGEwg{G!%8xGaQ$?!hWu#YM<Ab3S<%p8oM}
zPdkBR@gE1@+>7pn{Tk~(+4z@9FxfP!nMeB^S>Qx(4FXROA$<gI?^$mr>NN;QI=2^W
zxg0keyqjKF6ej#8Tz#kcCh@xmK0idd8fIOSu%6LJ04VhcZ{E;J-d%}x?e*QGBPcir
z`^sSyz5#`0_gkm0$1$i4s5-DtUy@@`+V%SOJh=47fvYc12zsLU1Ps4GU3+~pFdvG<
z^C8eD1D7I)-|_PR9sr2QlXroGae*p0*o$;OOuO`F1I#@KD5Vi{=JH`2D@It^GD*a7
zhEesn-o;A<*TMzA5gqtXoIY{*Uf2BFit`sOSimzdCvZZ?z$+*;3_H|`eXt_eb@T8E
zh14q*b=8*uSy8iXJh7Um{);LX;6_HRoL%7chfbIY4sV4+>Cjqzc7e#7Ily-GhV-AL
zIEzk4+KA$ZZ1F$Y;+eccd_D{oA?<-ts{vTqw!pdy&Ifel`s(<-hUY(H7A;)J#~nWR
zPJmF<#a{M3ieHT465{8kj>Nhc&L!-JFFLWqGjQ@I7mXx85BbE~VKhiz?ER(_FZN!-
zGd#OeDXGMT<0Z2yt7pxLR4l@N*h|iF<4|oK#{Uhl9x%`>y?W_$+=GxwwF&wRwKa|g
zdZ+EJPhf{iHq8n2(fMnUAIwvsz3}-SQeaYxZg8njhn|8`pAPK@aZ<T_{}3j75OiQ_
z3$vaw=i*M_DY<UM(8i*~zmT>KGT}X?PiN9G{r9QhRePG>2Df#P44MTJcv|0!*@?Vd
zCU{0)E&7^ydHUpUEqU_NACnzd0nh5<XCoKlLm^nMwUoWSShshtR<D72kiKrQPv18g
zi78_Q`?V?R0j*v{z<qg>sa1mG9AN8)w@P~#c}_5i-$Rh}8FF2)XD59Fl1uU{NFzx+
z)}U{a^aVK?qb+GDNFhlc$O9lbvq93ZC!Kbp!e>0uCrLGsd<Yc|IuIpoKsFwuC}}fD
zHpyQ>)`RqqV2gf&G+-AbNzdTFJrL{P@q@H!mmKQt2G{@(qx<&5zBt(o(V=FD>TVjQ
zPtkL+$xkhX`6)0z9i}{c8KK8*HB|j0P#r;%u{uhR)tjJ5=k?Ybp?C}_FcGo!zYZQ)
zDOSoDW%Il%0Ok~3Ztdk%&TR@d*dnk8_Fp3150{%!dmq#u)Wi7;NSf`7XIJXW*Nt-j
z;|PjfiH+O^othak^EQ++^~h>+i=K(6!K5#5OSOT07`-0Y(LSvK`HQLG{e3FRshAs+
zHU;@xph&|PhMZ?ehJkzm(!VFndLt#B2T5<lJ77Kte{w6b0AHl{9!n0q;N9@u6*9L%
zUeGsu^<AYG^^M)`-v02C&UKT!RiCuwlKZ4PQLMWx8oTSWj_$Z}f0AanM|cgY3`}ar
z=VEN-ctB;*9NbWlwd$pEeiImyVyeHi9p`)A8Nx1eX*+!jjwh#=iF+-+T%Y)KuN++y
zDbcrQuF%R}RXDgW;jM37gWSD*w4J#Vgd00GxGn7j-u3RoHQGww)u+W?rSHZz-S>M>
zpCO-A56kZQD!|wJ99j3yQMv8dO=sHa&M{M?y$g0s+E<6I(F0vI3>#x<nwfIG(M_#^
zEJYuI|I>~W#LdX}F*nA(ZO0p9PeC;7GIr*7x}i7<$Q=5E?ud_|);r6OTDuw*4d+<n
zvTF^8OZ)aurDA|ghwOHw#8)6pDg%2KDQOA*JB$V<CSZ#uU4&d3tcUY<W?M`!Rgeb0
zX?rz2JO^0=Na9ACzK+~6<S=h+LH;(-p?9HpO#LJ$aStsvA=h#+NFzvh5dH>pJ+T{}
zk01p)x2FrerpSUpf1}XridS`!!~^h^jH|iJoj_N8ORydKkhe@u)VYDk4d(zpf@uza
zTjK<}w?7B6j87m-dmI1dB9|D3Cg~V*jmRba0@7s&NE<Z$3Xq(WKw3gNoP)6!=Dv+|
zwX<Ctx|$AI+FAH-J4_RI(p5QfFCeGybyUKB4N{<g+out<zSq%VDB5Eb`d&vLNYGmc
zQ2Yq2k~YCb4rF?1lZfI+SY?N{dTBFN8z;IL6G=5NT!MVkI*>Z8a7OZk|0&F!oE-z#
zwM*lv{4>y{6@z>P(%)#4W<$~ri_fGgkl`Txd!o=7qyZN~qJKJwM-W5;Y78W|*FntE
zD^@3yw}TVVIq67OLv{~3rQiJ!Vl4LCqcPa;1&waMcQm#g@F}p_>?lv92PS%}Wq5lX
z=|y<_5*}rdGSRG-o0ruqoG|XHmrPxTXDok|+qehe;1P67$KklSIm9^mQ7`AXr*QW8
zN#C8VfraciKkNIs*CL-d0<D$fMr(cC_#1@!J{`wHm|fAPli9EJV;3{MQ*kG-SLXOV
zFpR<GJb;n|hnl^6ub$MCPBY7geeF48PGNpIx+U;;J$6?juOoaxXa9=q2)P8!d-8mu
zxT(6<9U|COMsjiZ9SExo{Mufx3j+oHjc6#>hrIaHtoOXf2nKY}7gFL-*hP<@JOWql
z5VM?5K-pez(jg_w$KjD=CorJHZSaJ%0y$C*)K3oFjzT)<L0a2&BuvZ&P+p(JX!L49
z4Xx2Di(ruol<QX4>1Pq{gG{amUf*Fm9K6f?Xpq34btOL|uPgbBuH@uV*wgszLm_;w
zMhfieFc8D0-(WVksQ(O4oRo$9F&JaTa2iI#`Dk1n?6UQ(oR2$ji54hK)_=}{1;C*W
zJ7L)>9sSCi51A~16!=#Mee>ZYDEb?rz5$T}iM|0b8HAPGf(qhL!676WN4?{?R<5B>
zK7et+GYBNbr7b}IGWs;aBz$JkX{67KLGJT>CcxM2NL|opgU&%MfdO$m#eEif8~VUF
zhW<W_^nVJ*>}Uz#?G6m!sCIVz8q7N%n-V93041`qE#oq9o`8|pbWR2X83=j{<i~Lk
zEP$1qqD?iYXtKS|)~9GML!Dg7!+N-6iCi#3N5}Dy)*=)8SviR4$M87}Jg%;F{h&*(
zDjSRk)pdR}@>s;6$uo4V=Tl#S_4K(qdnwiWY4`JV{!Zjiy&SRcL^=lv5h4UUWTs;b
z<d5Xhh6dY^AkE;dto}xzk1`*@2Y!ib7-1C#eT|O9$zoQ#t<c_vLo%E*;o0zYJFEk%
z<Mx84al$KvGL19fQW8#y*O73Jd=MmY5A2gTBffzgh6dyM1REfZaczv#N5KC=)!ztp
zY$u&gWBiWaj%O_`S)y;cIDrRcTXH+@LJFh6eL$H?AJm%$v!I;gKd2jqy?Iz)xI|Iz
zc(^hnoAn`Yv&yaLhjsrx40nCm<O%S3fKA>VH=50rwtfe-o&LSULE`tOrCqaOhgGMJ
zwApRl^W?sDU<h_|c?Rb^eJxR*fjckA>$Q4iHB;Ys?ym3Do-Z7uVU}ic6K1x)@hp!=
z&e3<xy{B;I2KCbO_^y-lWPKDli+`c8SdJol(7sPGgoh#KY1nh5{}!90$S{49wz#8Q
zMh*_C)K`93T2AWZF6<J0n5l=05xhY)vt&8X$Pag%k47e**h-HljIRsy(Pw22hVHe{
zoQl~h8;NI)4{Co;K!vNW^DA(o@sRfU9wd4@e24-g;3=@HqaJqug+dRzj+i_3usel>
z+hQb0Vi>l1*iGi#it)<_rPjhpIh}0p_yQ_U3qv-a)*ETP5V>oSOS%B$9g@u;@nc{(
z17rb+4rMHg-cB!LJL(9oqXh^4E)ousw@Dbvk06PAOeo#Q>QJ1%9H<Y%%K>_Mx?|cw
z<VQf6_6A5XNa7Ke`2xA+$R&LTvW-Nc0dJAC1Nok$8%Vn|umVj4!OfhJd<G#08}xOg
zKy|Rc;rb5FAXw@<IA?>%&wET$-wJLz`##Hia5NTPWSE|%Z)bGZPYQ%vaaQhL?)~+`
z6v@iffP8&FgAeK!2;(|rs;0eohTp8BTU(v<1%{p6EnBG_;c@KBT>a-Nn_BU()qQSs
z;X+)5+N^WUrvzRDYC3DhU&P;rb{#?3|HM8z56x_kX--CU>v*1HnYB@ycv^0U#i?yz
zG9BqpC?*S~4)MG=bO1^@w8X{p(9&rfN{r-gvIf?yAkZVe-%8}+w7-!J-2j2A-?=(z
zGe{!JB;5>BM6v_qVv<KdegesP2IO3LI`sftcEUvX4T2c(0i;f%>%#I&&>zNQ3;zUy
zr%s?~HY@UibtV6FGcYhdz&-T{{QZP9c!J|hhFfX=K-2tY#S2UEbWU1)U;`|jY@BW*
zRiGsEQZmh!Y!SR1(pdg6<nhys{)5v%dc6Jvn>ctl3F#(ydC_`Fw_c7fif0cc`q2`7
z0!j`<dJCmv(IFDU=szg!-2)X5cmo03pNi7yNF67l{no?8Kk#toB2HRPV2X^LY!nP5
zO+?{8*}_x)pzvh;6+o3f@<ydNi;ltMaS@7-1efTernoFPVXM~}K{-A}<GtCG2c)wW
z;4zG)di-I*hO@n8dZ4}sf64rtlmY}Re{8i}7YpQi=a$!?wtJBRo8r&J#_z`?J`QsI
zja(mCd&3&DA+ISv3fm+X_SeKOfW1EN$)$QY*PHz?!DdstJ^n^&x!x>?w*O!#rXuMT
z=SJ-=u^5K>9_&*()<6OGB7KSCY2A<;VWwBHkE7tHNP$=4j~TD`(CagvLVNw2_Nph_
zI>@US#^2&)YK2PAy8kBOtgG@sIN5duN!$oqJ?{@hj=#(wpbBGyOh=jtVNo_3cQPh)
z?6b`VF`lmV{w(g0JYIV~%2Xp=i*kQOIoWzp$|_N=pdZ%T_IIwJPr~yJ6_sW3$AZUX
zc&vf9JCR<7#~<KPhQ~2GJiI?GJf`~*D;7L$<&ALf>9gkpUC<>h6rIHK)~U0b!8nt_
z0)d~}x5NK|05kZfUygtd<OQM-hB&rTiuas#s2nzqWF}TdkcCzZHANjUv`|NbfoUon
zTDN0Td3lx^uvX1XP`xAG|HYx350;NQQ&p|KL%r@C%}be=p5;C`TCK=H3SFZ<>##RB
zWmEL;)6`{wwM*-3Ye%I`Rk5MGF{*lR)=N3+#|!q>E{~Qk&8djKS*2!VsD2r0M(*8>
zWvYi8s#iZn@olTr=(ow4(=Ju*BbPPa)U&a1TC}lIZEoWxT;2cltg^Ccqf}g}s$Ls?
zGkw}Q>b&CV%hVmQ4dr;9e)&>$B$83DHpRNd>eGcs8&Xx9(&Wr#syedi(e%uTjZwGn
zW$J_FM=yReJtfcWqF#(STBojBouR&PLLQa^L%Z)haIgB8Q>U(8oeSLcj=Ot@+dFy9
zHEieZ?e5{F?!F7$V@uuL>ipt*l~Am{TD4X^wmN2BpiZ?}J1Q%hp5m6f_30^-*7JYW
zEmxh}pxW+tcSF%9CNVxeWpc&9$!_n7y^||8s%6{MF?F;qXV%qYkHPv~Cs*CNx*?`7
z%<^LTbaVgnn0oW%ZR(C$8S2fRA>gjOva)n_draNSs`c8;!^fU%j7jOH9zjc<bBfh@
zYu(<cD1D#0CEi`D-d&IZ5>odpaQDXyj*qH0PR>x<=7iMv{p#`_#p>AXjN0h5qGUBP
z_ZRg_d_;Qk^#yLH+VpAZ^=e1FyGz~CGNxZ3GIVQMo;oF@W)`~#vI<q}T(@`m$Z|LH
zm}*^`H(X6E&MQ*`Lh8nO#p;bNF8U&J_inY!O~_Mg=kAK6l$EKgFQ`-hQF~QQ#!A&S
zw=8e+r8TOgE*hP`ATQ6&%*#`Y>vlJ~gC8x*o2DMVz%A~bK67iPYQ0xg=c;za<94cN
zS{6rApNy6lsJE88Yqz*5Zi;%p!_nf@p=D}B>FhJ}CaQ}UMO0nKZR&y55f!&fRb{BS
z5DKf-+eVd-dbD=wy6BC)d-YC#Y`a=i=f<nLRc=JZZc9m4(F}~$Gr5gcsuhRw&Q)*3
zxTU*>ys0{cRAsU1RC>1>oU1mk-tTVCO1^iRTCp~<e|_E*Rb8y&x2c6|6?%DLhB_gX
zxo=|cBGo_g$%N%9(alxUGuElLb+z+P%S?BlcwV)xyH)L5zQ3?sUDIm6>g0A(cU8rt
z2I|sOiMw~ufxMV$T~+s8s<c#fFD+MHWBLZl+@;^|`{Wb1kK5=zaoYSz?(=HGHr2;H
zq#o+%9;zF1+IdA4wdro=XO*gEe@y>wY6BuiJ!*Lfn?^0qRrj~eP%l(xMDxPxgX+?Z
zvgu0)WUC&fxn;*1>ytCfR$rv{IOvBH>J&C!Tn0uu3XY%GD|1?U$~p|@N$J=j_izWu
zOplJ(2r~4(k!6|bS((YB`<KCJVrFJ~W=eYI(!)D3z||RUM%5DaloL^>6=R=pd#fX>
zFpla14d1GtRu!vtfec^<u@RBSV?%t8o#?Va@d$OY8&YMts!fJkiY=3&qLFECc4m6-
zbcp7am6g}d&l*)eC~LmzSe&BXUe(~1=hds5;c)Bf2GxkIz9OQ&cJ{lKwYzK8EvvB)
zyyzTN*JEe?1o4cn%Phh`3}oD>M(3()R_|4t1L(+WS062jx|}l9(u`56ZAkT^wt>!G
zb9U`k_hI*X5#>8<i>ez}vo9j*BWIWT)Nw<Z^{P#7=5E#6?UcFO?N(Qw_4?pE)nRXz
zs%#jEVUeX4H(*>X-<OH0?eJ$=YRR@t)pc)1R?l)ZB;%Z(<(n=aTz)vy?WZtzCHAka
z&Rn)Es^TLtr*^sfbXC!?&%MUo?Vjl_JffB!ownUwhOwtQ994@mRELmS9OC~ABALm(
z;XW@tQ|(w?8Y#=mdQ=?_9IdM;yLtM8O{#saTHbIVJZjPewXir-b&jad5P3${TjQsz
z4_djQX~_#YR%-UDuiC7|Bva~5Hl=yBm~1|euluS(y&QClbF)&*^Bz@KUbt3fieF+f
zIO?yvaGSbX9WBM)8d7cD1b25{Ub$PtNj5XHS8XENnuU%mtvJ0$WnEUq{KlNq&Ki-G
z_oiA=I!4t*(0|dqEtA!PL%Y@Xxo$@B(BzxyRn1ZCk!2emTQljcN3V?L;WtjTjx^@o
zlBXJ0W+Ydr4}*KvBP(*%^DQv6)qP+uw<uj&ros)Fd6pkigF<C$W~p1|W^UT8u2j3~
zQn+O~nPjNt85fjcx_!@aGm^``sokVryAZo#Z0ODOEX<x+MeE&3qf*x$PEWbm9X#Z;
zv-;<hLAW8kHaQcs^klbQorqn#tWI^yP-PJu!0K)qIX%yv>`qdj1>D>%>MyGg(eE{?
z8}`L^+uXmZ*1OciZK`c427B9W7pt~069evDnI&#&O!|pxMegX@Mt4k#+jyrc+OM8n
zwcpK4PdW3=!#AtH1Y(i{+(GL$sb4OHw*__TlwE4wiEcyP>091f5Uo{jRJs}UIF9b<
z7|F|<bmg0QYThn&(za1s(zl@BR3awrhCP>5?pQH+@eXx<hDr#j^K)zR${tI*yD_S+
zDcKcC-S_C=@#>oRwUIH1W$3Axqo=52rJ<7On8{;G%G9qX<~HtG>gLs`f0ssPl&KBf
z)~Y8~?cx!y$bC<}cwwn(+wkq-lr8GL3wM>(t8FoE1CB>)Ri}ncZ*O;N(^FQuc{zFN
z`gXZIgw@{dVuyYte(#C{naQc@pBFT!8aFab)#R$!{ZaJ-_O#vDl`m2a_4CyA7uKn+
z4XV>xeUxx>uwTCu*rsY%y9vARZdBi0uwQ-AvXtX-yV_Kfkr$0lOjYgImaDBRa|bU|
zueo(uqq5wbyC<qwV)p8_!gh7<g&CRYJu8wkQ@*KJt@o=ZVlmOGzeh55-*e`cxv8}&
z+tua^*X~x^0*7kV=6P<hn_1f{Wy{V_uP7@E4_Ka3Tb7lgA`$hkE|J=bsf`zpN?pG%
zbMT1rO%u!18>`mtOHWy^;_Fm9HxgCX#Wd{Ztn;UpYuyUB46n&?GxF5GSJkP}htwDx
zS}$Mbb{>^_OKnsgbKL!Jsxb{%0_<v3&&1#`9IaQ&*S?9JdYgI`YlBx;9aZmM(6A4y
zjLE9Qesx34T6HjpIrHb`dzaO#ohr9py{sD4kqeJjj68jF5A}~_4H4BjV^B12T2007
z`cIzRx9?(wgXA?G+`V<#Z*5iI!TQn*O7ql}i!#*LnEkI@lv|6zbR-UgDQ^<?6zrn=
zv5TtK4UL2uhg84F?aN0_9<Oe#;ZD^$RPJ6pDr+NWkYzY@6wCkb;y5uF$8|ST#pa&I
z{Wpq<r#_mA(KroVQ&+xevKwEYr}85y>ePt(xK$~RjPBa{^vof%)kz`M)y+^-xw=CP
zDlMdzG;Cr$lNa&;gkg#WAUZlPFMpCc38tkPs(VP4=HkepN*W$h?_h@8o?Mo5bG6zU
zC{<ss+SaJ<U7cH&l2@OX6;&@erPz(v1{!KJ-F<5P>bl0A?vNF3{b6+r#_qA%rL}i+
zVf0hyTzB8yF#|ihpNuN6-Hq|NGi%f&H=3E=SmwTxw={p>;ZGaS88rz}=czBtT`YmO
zG)~GaQ}>*(E2=)mLb7IU)~HRR&gq#|A9Z&u%UY8)s?Wn&su0u7W!R|SV630HcKXQ4
zSSwC;A67>ZbzOD}R;bT8+m??=Q`wRHQ3raKPaE0yZq;U&Iwu2*uytw<8XH;WHmZwS
z;mFNhs%&?<I@on@rds57a!=o(zFp}isLO(==9`rnAR*NySAEtJLarfkY{$fYq-))T
z_rof$;jrqst+9ToyECQwE)_bu;WYI)3hfQ<QV(myN&-iay*P|b{!FddrS8R16FYx~
zTDF%{{@_y8vmpwtx+j>c-dI_h8Lf4vm0=hc<FK2d>T&q}1?%j^4N><5%o!tQsMl6S
z)K^Z!ed(Duy77%_ca6JWJ=YS^K2n2~Y|BvI?p`UoRd=`3O<OUU=BgiRiq$JEGSp5i
zPF`)XU+vHsT8Bz6`J`8Gw|k?yv~-s{dDJA1j@?*<CFi@?R9U0k&V}VJCi~h=qq62^
zEy)61=k|W+^V72P((`)dCFk`z#&!Ch?rU)v=(1P6HOFmmdmX@je-ak;>IsFV%ZUl9
zJhb-o@`}c2^l;<#7nDWQ+<ueQ&hkU5L#bL^syftR^{P5#WT{2Ds_U*>5QJ(Ma`Q5K
z-JPE4cE+JS!|h$N+l`Oucj7wC?V0P{$8c2de1}>TGc-`o3BcW<I&H&>xszHJb6((i
zb#2%EJZ{d%f2k`C)7h*AJgTZb33WK0sAV{QM#>i6iZdBbu7~vb!IwSi)Q8LD)M&f9
z-p!cz>6G-$vXad0=VYo~%R=fo9KRk}7D@5;hNo~~IVD4#6PlzFBWm0(bs&m$(W}_P
zJFqf-t<7GwU1MlU6i19@b}u^QmOh~t@5P?<$TD}EddGF^80vyPgF;#Ls_mhS1&!xS
z8<E{>T1;!4tl~<9gLilS8o&i&w{0-E5$B;vJoEH^8-Y3P-E}de+qD>78(gmzw|RQP
zvlIRX)0|l7jBOn_u83OOoLaT0&C@wzH}>fq*#9j7dj1X~4MZ}2VOt`mP5$^NKQnwb
zV{28l=kJWzbHtyiy9%~f`E1W%oEO6SS+D+ZC{Ewqfertp@fx4)xY`!$gBw&?C@y9;
z3p}Tb;Cdfy_~YLx?gE-vJ^NDaU5s;Li$igRAtw?-XWE!>jc%E*obJ1Ge?O)pu*LOb
zTZfK+VkjX$6jxvyf!7q8nD}RRpQFvqVv1QEN{AVahCF;+a7}IDEq1;Wy;(W*PE6Ea
zBtDQGTN+AmrXnW(_~&Cs(GShaoga#udR(!X?AY@V!b9*^;wiY<N5{sDhxlxW?}1l5
z*FdNE@z15&`QpJgp3#OQ=INYRTF-CuG|T72h7CD8lyF`s&h!KSoatNmF>$ecD6U*w
zoDrKRrOt?*7;<9Hz{W9SfPbxo%U@FNjCL)~*ClddC$y33CJ~_Thr}QM6bY9i{q@W=
zagO)-)qi~Cv(wwW02?usFtKSn2J9H&pAH>rZogdjoa{Gnj(ZRKmx{|wb9}aAWZX_;
zdz;4XxY)BKqg!D5nSZDAtgoLZO4+5pf;q9OO(2vo+qc<rVolxrtCqvQ^4>lWb5<x$
z;VM@`%oLxev9aac4@_D9K?<()*}n72t_mfb<tsEkcA+nBvk&P%K=GBuJi$WJH$^fB
zm~F(rDmmF_Ti|WevCXz6|5_yMvx85Lefk{7`AlEn2l8(|O0b`qvE{`*6HQ(j<BL2e
z9;1GtCtzJUu`yeZ%T|Y+icrEzbPD6+kAIkeO=5lLvUcQ+o_}f3(Wjr>OwT_Z_&q(_
z#UK9);89?+*g1ci2`(r0%;SQ@NShXNu=mIm^_-rsN25b*Ox=!;d8`+c*;af;e~Pb8
zJ@)fLapz-?WwkUn`z;@?Uu4G9*mf<<c$#%wfJK-A-UzWh3H%Q~J~W>QH0{FvJ|z@4
ziLRfXq%CmK95()W*Yl0`%?LUEajG}mIldathz<M3pcz+u1irVg&Z%au;I@X`w4YDA
zSNrUA`=vg{H-Tfz_~cXR#Xeh%!PN+acE=r4`2=~1&(7QDW2QH4N4tIaa5#3mroN#!
z<jwZu)8CB2_FXeQAN<B03#%XR>CK#31^snCz1Oc7gyNR?`fyyVvFGF1Ys@w_YX=<A
zVm{X9^gfpH%s}Fg&qwpMohClde_<$Ykv_6khY~P4W6DAa3jx=L95a6DDJLE;W{J5H
ziqAsM;!xZLp@gE4gXsx>X(sNSFgl-q;M>gq3Y57x<P`YYFecXDqP*B~KHd0Ovkm!l
zZZdoue;A9H>Ca>|PiJG)+HnE9#^dc`uv^RtIeF#~;+*fr$Okqr$FbJ<H2cNn2(lQ{
z>{Y%<a$+k(j(RWvRW1&1Fi|}NA!jb~ckv+U#4H6Z2s!g~Wp*4SAT|tDTStMnolUzK
z`(~dW?W%yIDJEFcp9f+0md~zfJjBfLg?UD^d1iFTnd}?AO=|%@&c=^1HETN#+vu)@
z7|gq8``qfCm(P;gzT=~1-~TqAdHzDN#a<2@3G?*WP+Y{PM$6BLo$xy{JBH%YaMuWH
zH4|gb1~s0C(h8p!O#hn@^FKlf7Xt7oDmMc*N0gf(Ax0k?$0APt;_x62|GLWf^ZKx|
z&C_F==4p(2H8XHr;OB-Mtb&@3v3v?=1^gL5di^-rtj=Tyi5VL!eZjV4&ogT~K7n#-
zu&JyULscjadk|-(rbx~_{^)=uLog<kfGra<g*&H%^<dNX<TC(2nzl8~@z^=bvF{$g
zHOIx)V7z9txE-gwiT*#$S57u=mHXOkjz?y`i-Z1uDxdJb=u`g}eKz!r*YvrmA7cFr
zgB<(qc*ZMkeSJCxJ8@jhbl=9+bE0Vj@0<QlZQ%V;EK?)~^s!kdn0=XdI|mp&=HTgi
zeLFhV#L7SsB5q$sf<z2$a+ipQBfz6B5syD;8{$S!4zRzrU;!u0!w1!%M#b7WODbn^
z9A`oO!;wKB3YD|8Nl4#ZKLng9gbGdb2~nZ=U;paxe?1a|CUUZ3(8OmnkGe!2oM}V+
zyC)~U;mHB|M}IdUA!?ewBozPaA5Rr;L5gvzH0}itIQaxxQfz)VgLtMv;=M>{4dDSz
zZLb*17AW1aZ!wKowQ`mm0Lbqk;6o%ff%vg-m)Hgyi`$0CHx<zaV*NXa|Nn`E<`7y#
z9dHW3^p9uN{Ja255aWfr#5~QTE-@_fAaTAYC-U`1{@Uno2oh=|jMD0=enfskE5=#e
zk2nqqCIo)Shhk!>i2cD8Xi+|apK6J5mh>Z@qxs@~M8<$kU`oX!+Z{<c^%ELN7zp~E
zFiO)ffgT|x&><WU#1{vg{#8M=7>P|JRttBD4{08Ci4TiBNaUNCxH0@b`06OMmukLu
z3G@rk67;u*`80e%8|F6|+7?oT>ob@Ns`dt2w*IwGwbQ+k0#@DD2$uv~cDK72uX1$M
zfnhrX^*0W%lMrv!@~BJX%bkwfp2&xg5GLUkO^Zy#NuE|YRU7q_Mrm4KNH{~&0>UJb
zno@M+8J-53juhimpGa(G$!jh5Xmun=yid4G{7CbtOZ-^mK_cHF<?nv_cn%3IAc(qt
zh6!dLWG^DcI7>CYsZ9$A?|5S32O?$#1*iaf&<p^b`F1Ay|A#g#BpejVGT#a1geqkU
zP5n<o!*ZB7`Vl|WmPMu|0mpWB8x;QIx;sGI1qnT=(Q9Y1sVCuoEL{cdVqF^J99S*f
zC0?a@)Foam@*t5fz4CW7eXK=7M-w(_T0qO|L`q;GUyn7F$!D3(T3g664VvZ?q>Sw`
zQzphqZKUO$NaVx^kx>7efP+F!`{|z6F;0E?-#j%r&7>vu<;M01WM6CBNRW6;xJyjJ
z#L89^`O+=!EJTkl_xor8IihJUYU$)}4o=w&rTk*Sx{4{`6io{Vbn0`!%Y1{8SSN9a
zaF_T%3yF*PpyrVvk#FPjZzcK|j|8`bvoy^oh-Lj)6BaGAkeY}47-a7v!NaeBcBlk&
z0AP&Jvj8)NE(7pgYraNoL7BZs===%(s%ju><22Z5lX+=K{RCoXG{moG-V53K;q^>D
z3d;^6_7(0D@6kN!67Lmxkm&IXh$T4J@^=>f4Mjru1pTbNQ$WjMu*5h%AHYJsA<Z&;
z?;8#%1Zr_4dUUmEYm<J8PruFT$Dq&xT|Qg`xK`*b0I5DqU<jyy@U*63!ak9H1o%#*
z1f}E4?+HlKG)$1F?IC3i4CxJ9WyT{w>4~OkGPg-)$Fm6pWr|bblAS?rI)&V{It1M)
ztxs({12`E8z1n1&Y7bSsxV%`KVlDz!3wMb-HIKT)dqf^2dVD$Y-xxyNh{PkBM}kDY
z@65k(S<hM|gh3EB{$|koQGJzG=My~j1f$*x*=<@KW~KKDCG69*=q<oukrGZr1enYT
zd|4SMtgnDMt%Vb(At4w-y{1Kkog)1h@TE{fJQ@Rcgz>svsg1-*S{x=YVBgV$u}Ux1
z&-fMGYmYq+`t-#Nl2LF2z6NC7<o^VE<?M#N0>0{z5IDh8k2T#i!D}y8T5N7hcmO2~
zN5WY^ppk9J(81beS3XSn3~MW_htv8kar!Vb9SQpxfp7Qo?Q$0&`zItE`vws|&}w_Y
zXzJSnwm`bBpsA1SV)#C2y|&s0Q1%iMq9(jA)HLs5WM9ytFo709uD=?|=nCCpY<Y8I
zF%l;yVzqFWxLNb4OT0?tL1Jf|?QzT!yJ#K>5)(Z+k#BmVPa@wncib3<k1LT724Rz?
z1@wG_ND1*Mgx;iIepd~)gnlA5UVYt7(dkIass79~PDkMhzxj=jixTt8M#*!v?{F1>
z5&Jr64YC&@u|dRI;V$uc&7&^y6_E#te4!v4O+4tyiF~o0zcc9jIwVv__`9YBF96;a
z`YwQld~G%FzT^ICT0q%tNNE2TM&|Gq(nY#L1P)v;+$H{1^QcR_P2@r14o^<p>B)(Y
zdU7IPqQ}lK6|tUMk<bXb*e;Z%_^v~LPg;?k<S&M(QCm%6Sr)>uHlBG?>q#WmMtoYh
zOZ-Ihs7w4*<Uu0e$LH^2`uGPD;vgK>w1Adhij=@YzAolXvH%k6B`V=AQGZkdo0iD8
z_|b;w@e54s^l>s0>Lm=-)b7_t+k7R%+if{W^hz8f+$FBoJn9nHh&)K-oBjMPrjLn8
zsF`q~rUk~**UahA%t6Aa*%%<1r%l6z#X?PM=#y{%<DjFbn>_v`a4!<-A{_I?#9u^A
zI8jHK+DK%yur`kCp{6s42rp?`$k$V~7DIxRv9l-dGY&>#ClQATcZn-BkGjM)A`cQb
zd2-@rPi|tMzf2^=Kv<?}!AiiDLj8slv?!lYqiGQh>xCM_X~@piqA+2xriFy%LJ8|N
z4HN1_N?>rl{@H@;O-O7jajS5bcv$nOOZ-ISL1LFU84yIi8jxj)d=H|3pwRc@NT`l*
zK+^(xD8O|x43tX&d^IL0p%co38dtuNv=3!oMB=PUq$?~jKU+m-tX5}C@9^D;8?@Un
z;V(js_6@H*qGIVEkw6Iy2aXP{B4H_xMh14j$BF;(xJDgtm;v)OiZssvG9X_UH`P+W
zS`-{$AxmhleJ$xnlql_~FD*NZWdfkTreVS;k>&s<2xV`cgA{b?-(A&`tU@co^8omA
zEQ29P6?Tqj3z0;S+SpV_q45^u3~r=@>$L;Bb3BjiH%MH05P#9?BDQ;+Zg&x377~^^
z<@N}|KI*Ua;Q;_%=f<$XszrWOQ-&sdwh9Yx`LR>!*w>l755E|RV~$uY+$EmeiSnpR
zOwc?MB=T*P{&7hk7a_qdp)J%HYdt(m->`eJBQ7CnZMYMF7QRsU?#Py~@SmbFPcsao
zhgWBUux_0(ZDOg%S+dzFF&`3`g~Wyt=LmO+k7yosiF-sIBp&hPM85HoWlcTww;Txp
z6Zk4qw2ZF`dRr)gg@VqKZL92dVzEkXFom#FQ@ioEA$zYDh3SdKeI3FJ@%)M_!yqc*
zF0r%bSk?jg&P>`6lRY_+FWU4sf&OBVPz51g(*l+nB-FH(4?gf4uq;d*BHSg8(;OG^
zf#XFUB<6W?BH!QPub2-=Oz~vI0^u(4Pnt(vVx7o?#4VoO#IzIndpteyKH)C0@C4Qu
zb%{lqM}kC;FDGu$@~BJPsCgtv<ZDY=mYAY>BuM0|KmCK8FN|G}gyjz5J|x_1_`-yz
zAMQ8{LQY!5QY3UVVKS--IE9QtYEEq={!7G!pOILQI0%))nlYpcCCo&k1(Bh_!c@(k
zN$_fB9sCvpO^GXz5CvhqrbPtS4(W}6TaajMqJWsy6?xSWStY~`fNeqv5=4;+Vif-T
zZYB~836(;d8WA>zjJ7+ptd!9*2=b<2>L-|BC})>+Mtz(<iL#AS8~vTKz>A0W{(4UE
zdW9%GG+5VZwt~MNzdyf^PQF;L`Aw|SaeovOyNodrw;*Bc5ZHB?!<sJW{2hJrE>a8J
zg=*P1NGijx=~5a^*lj^fk3roC1|vDsb$VW8n;4I%OsgcvemZD%WIrNdlM&h>DlsFI
z&1<*XN2s1X2wQHn5+qQ1A1@vVQ#8#ty>|d**c2EN()7ltpF|uct_WU3Cz(?0Z&rb;
z1vA)0wujsdC322PwuSscpy$J0iFh6|uVuf}7CtJ~8;LU%v9EBKn5=o!CGtJ5{#lHV
zP!0BE#3906Vz%Z{mzX1Rd*tAwRZ~0}u|T*>JYVyuOPnQgTaJ%hE%s!@YT+(%hvs<F
z9Jo{DLE@91ocNR{C-%hSQJl?)37X?j4&;kn{j(hF+^WlAr3T!NgiAmKy2qv@Jb=V;
zP28i!MFds^3qmLDH?@)20|`C|QeD$dx)!Fa1|v7vlAgsyKH)_pHzVV92;N2FcmjN)
z>6Bh@+gH~RCa?zI87bctI~YkH$$&$IyTsEpkGe#@Pu9P!`RG}WCnJs#?h@-XkGe#@
zLbiFisFtNR690sRcnLHGHLc+TYd0aWH1Ss9F0ljt2$)-i7^it8NaWjN{afo%+G<&S
zvGF?yc9}@1>feCxg%W<%)b5^q@~xvTjQe@Oc;PN_sOC|Z$XCi9*F@xVJQ;C}aF@77
z^QcR_NaR7H$CnfN%?mbyxK;B=koce{C-TL!{yM9XUxtK6(Zxoggex^IBK%pTgd0U_
z`h*YMJ&8n@#HWS3M7~Ix;SdjqJV-p~$%!9&a^sH==6&tSh{uGxME7LzM~u@P+YZRr
z*7~;{eJCwUZ6vlt!h({}TGKFLEE4y$slanQZld6uY$?Yq7^F^Wz#o`<zck3wk>Hg;
zQ&3|GY7F`8;9?|p53yRfOT1t6s7ri6<Uu0efa`A#UuS!-meo6tT7A8#!r^m=uWEfH
zNPJzmOB{;l0O^a!x7+%+JfA_#@npm?!d>Ec&7&@n&m#KEF+atV5etO7#3Ie3E|G7q
z^_Sx_i?ci#agK18I8XDaOXLe}{pI*9<6=)ntQPJP|EYP@B_0uZkjS^%`up$-$TlIh
z)XRX&0^~O%VXgNJV6RZqrPMrvgcC=X*i3zc71`~~=O;VrI<dzC<AuA#w!I`4Vw~m}
zwm?2Z>5q{<x*=gtB(#AVBdMKd=^IoRL%Rt{U#udz6$zyXPYN|Hq0c2q9Oy(*7ZUiT
z3^bqqha=H~I99}jB2P@L)#5OLar@TDtb%XdrGpQx->`|BViOHt&`T38IQ_D>AUp1Q
zEvu+U;xHg?7VZ*n>`i&pB{pat2@<ymzkoQlpV*j6=x+-WI_X8g7YU>Vgfv*=2uk>~
zrUmpB>8lM0pJ-Y{pjY2!pwrv5(|iK8IM_DbE4&dxR?4T2i1%q;t&vfn4_Vg-y4pfk
zz~`)dJ^Kudp3{Zub=cC{`Y=n-9J5oHMWnUh-jB{b+ZjIF89v(?#<o)*tRj%OnFhjV
zn)aL8I1M-#$rsKeaLbU;i3Djv{$bFsL`pcOY5uo>4hh<paDt}!8xVM%Zf-u~yHn`H
zfPI>Vha!^ENT}juRL+1vCj(@QgxPE+NC{tQn$L!{)_oTyBp~^R-F5`SXes*#kndf`
zaC;>{@=qOF5rKmMTkw|E4DNO$79c*L6(~R=+pCCRI*wS1P-t()jCRBr860o*`2u5r
zGMI{>*S}T?zaPqR?tZ6SYm{T}@^T|_Il{s=GsQrg3Kcru?<^Rei-caB57;R5HNat^
z1ldXQ$HL(R?KFG^TJsm(<KZT!cGNMFA|!SKaR~}>M>nC6n_~V6pa*RGAR!pSL`|m<
zI9$+;53e>ZbjJA58OQr2!8{!aP6%Gfo&J(LSNlrtT<sNf81@z<hE2Q=30?@^c-Xd@
z<Xj16o8RR&?Q$5lCQB24GYKq(A8%irV48vbc7ln8-0^<HV9Q>^sbV18_M7C4z2r=Z
z{V2ihgud9e`a~2>LBbUEyP>Ry;bTaQmG~4A*7F3frMLSVcl&Cem)mWBT?O;&b;&Tn
zE4jsAa*My@7F*IZpG|NZ9q-2{{io<2j0A}V!d+r=BBRAABQRC-NRU|K$%$2-oLJ+@
ziEBJLk?->MA8F4<z5)r?wzmRq)ig}lCQ=jJ0tCVLhRd>HV}Se^5_T&B-!$%<ATNUG
zkk%F%2mHH(Cy{s{BR(zMC4Q!P)FtxG;r=xb%e{bvkx2Md(*go5AvF~oLH27T7A77O
z?h>m`k!BMYYmP-IknbAzcZY-g7$l4$rzOcEB#a_s>pSN0?c(#0Fl@C;an-aI{lDs^
zL*p7v6((<*ML&$B6+_}zOqpTDL8tm>#}<>EDP-Ph9^+)&;Z=t+^+<Xp0o*LyCGutX
z><8irn&ajWkZ<Ak_YZyChs0?C&<Q5!5@YG>9U4BM4f6@~gFbD#7)AYIt)D{h^bgxT
z<jAR5Eo$$Dvj8<h{{>jnpCRFfBk+;|tiSLUz`X-S{0lH)kQUDdED}msg~WnC0Z&X8
z&X?m~h6E>seV+JT;O8PHNG~)k-sT~UDjiWc4^^L|qX^U2nYxf2l6<AOwBq;rNNdqf
z2E|v0XL+2s(c{D`k<j6U9iEsy&VFH0_D!wFiI;l(c_6=JfTDzVG|gw1U5&(&MD`sl
z*nQ7<T}b=~62ydWw0Kw}dzD?vlI+WyJx<)K`LIUfyGSTXU{~XS&))8b#FE5Qq?ZWE
zn&z|P+37LPFgsq^JscY>#rBRyA}5a3jR_ONnidj@gc3~Wm>uF<ZVBCa)f(Byh>U&5
z{sLvkT%kK7pCJ8G#D4iw_eGIuKWt5tLD`;Bx)FA!V?DQN{{{5_y7pf{PaK@sNt!$r
zup_0H3fM~=LohJi;oG6;bbxkhudUpRveK>fGfX=vqdy#3V%$dKM{>sI0l49))H@_Q
zs!T^Xg}|YWRuLGxHsM~!-q9Jeuj!20*>r|ugU!(yvy<rzTg6axhMV~})4@v!=`Ezz
z&SE@BRsBMsWgligM#8R1XrTl1PX?wru?TIf-f&^vzX$=t&uF=GGWd2*wLF84NyzuS
zxoI1E+O!PRv<uX<3e>a-)U*iHv<KAGX`FJj8n5KWExGYaZXA;v&*XIdUnFwAYCjGM
zo3c%8BU$rV$u}WJFwQpWu@)w9=%E`;^`NZXn;Kc6Hw9h;%I#$8{u~^}1QQ04mD9vD
zw+!wpq&5O;!<N3^&gI4}ddRr)brwGzz|c_<4WB`xb0TBG*~!m(E;bREro-L@U_Kh)
z6IH?EQY1buPm~($E;<7ue%i=4Q20Fo5f%PU6<ZO?tw<<9ctTSfzz$>?EVOLlQK5t%
zG%X^q0lxao#|F?9X8Zekh1y=aPm2irW&wI)Z-A!p;?uPLLzsSq1m6Vxc>|}g$)}An
z7Eb64jy48J#v!2;K}y-ZhTk>dUV|R>jT+xj;m~ALeO;b_VbNO;4czen_7(0Dhii`K
zqk!om51RP#=Zj8`CnJs#?h>EWJn9mk5_ypLx+gb24kG`drzd_a+$CO`!eJ0~iFKMs
zg2bCVIq_ysPQ2ff6ZxS8|6=qG<aZ*W*9cT&<!qwpjO>X>vV^M(kWbYnMTCol8tXpD
zR%nskLi}6OCy`hs@oC{Mu`X4bL9Evt7lfMlaxEJyHl_;tdkqQU5-x{1#+b464YwCP
zLtdbv<(1m9sL9gqIkb$^)sJf=_RyB$&j4S0VpDrx<oO8()K1u-X(4@HFH*u?A|>1>
z(kB2<3njd#X(54?z!~fLK`6mNqkY4We^1*{_XDm!0^^0d#BrMAu>#<Dkq3#hJvniX
zCnq*|a^hA`PW;G|6F>FjM1CT|zg+GOStb&uL#HLl7$kH%>zpZ+Fds>qko-mDgqt-D
zv&IiZO87*iras?RG}UqbWEBq}krUr<D)qG|CVnqs!hba_B(NRmXtN>XknO0OhAsuh
z3wMd*HOJ*~-~^EeiLHkp-xc(cfCRUMahetxODs7|WqqN^M2c~i4I+x8`l&{LN|RpO
zd3t+ms!5;PNcZ{LS85}%90>sswrX+x4B|gD#}zT)2cDexUnH0lRt=G^BwmdK@%?~*
z3H=(-ZK#&c0Py=3>~~@(Bp7!EBnc%<LZSt+QpAe@tAz4f7SgPygY0<-g5U8#x0s%A
z_`wd=hf`47J(+(b(~%a=02Js*?WA)CMCWL2m_Q48Hk@pZC`^?*QS|S+c!3d_PjmP-
z;oGo~K4^;dV^4;@FeS&JnbVM3It819g`4dGf%3l~`J43;@}DAMwEq{t-ti55{yjRs
zXTy1u7%$u<PSQN;5+{p1NPPY@+T$s0;0u~Zg2e0*A~#Xe_c&cHwUNlOXar%0C+>%0
zV~}ttcnUx-poCA5xSfvxk7;q3z!%i`jvGDUCmTu60VLy*&^*?`4`zUx$b5}Xfi^=M
zh6xgP(<QVekX<5b7Jg4^H?5+U;bY=7ar)*^mZO-L<URzl8E7-1c{MaO{Sbm)`eBNx
z=l8k^Ub9W5>>LNZ!4K<DZp!@`uD0r0^9lT1iLb-1L8bgu5JD!5K*D2Es~brciQL5M
zYZb%vS~bI{QKvn3;%7=&nlVu?F*WUiMvu)j!y4#}iP~78Qscl^f0MSLNo)6``Cjc_
zKYxxaDB(*@^GziO(TpBiRLBUqL41{b1Fe#>1ThTLu%|W*69ysqTTUN2T80PAfn$Wb
z#QB;>UE%_f2Z>d}mlJQ$Jn9m+h&)K-7gqeo!#T*aEE;wZV4YCHUo<TwupkUfd0*Sk
zgl3x7P9e}cx_^N^5t#|WO05qQScR|j9%P?H(u*tL)52Y1{zwUwSfF_%NW93C6W4lj
zB0qiNZy0_5OZ&rpcIaCnp$+`hQy-y(Oic?36OlO1h+z>ESSQL6_z@IZ5Laq(Az`&p
z0t10D;W8u|w;6>qT_lJJT{O+-7gPB45l9LAgb0nhp%F<)5EC*qEhOZKl-~mR2#LmK
z^s$v}0EZ8Qm)@$M!7v#K<qrc{5jiWPAOCP`fc_CA95M(D&v*2A5F&cOA8Q91N&0Ag
zp^4x_uZTY?BRg(yG(w+mBSJLBo%0?11#}f*LQ75U-o`dDK$c*ePLa0gE|O8u<jL1J
z#lF5N_VrCMx0Kg6#pUql`6xEwTn^clNV@eTS0P~w5&nXN(W|jhxIJh##hKbj|L1Cb
zYU5JiDkQidNcgFZ+`_V1QX7eHA;E;eh<v+EbH{!U5`5F(V8z_v*bK$mEe&+WG|yP@
zwioLa4^8*LoAeUbAJxFk(Nw-^6R_D;NN5Xzt@pKsv3VOX*wh0}53~66_G38yp)x%k
zw-u4#y$;YIl)w+Pup%@mPWPW(<$R1fKi6S|3DlxT?q6-{*BR42H2w;SWBWVcPe`cD
zsJo(;>yS{U=~6j^{%x5eQ-<}tgyetVoq6`&ael&0!t3m{n<Ef@jl@Zl_#fdeaYZKO
z_^TS=8qFg?B0q5BpB$$_#?R!iQN&Ut9LyI2Rthz-#v$7oNlu_I3y=@gCgBNyNl1JU
zg?N^TP05oywQqgY0MY$O?Rei|GhVsUvhVGI%|VJ7VQWvE-L&w08md>2<O$gknr7+k
z+7^%_)YNE<*{WAjh~MEs?X=|QctGz1+>eA^d37VnUM&w3zCgmrnn3J`XmEFD0^g9)
z$jr&Q1M4R|4*ZA5{nfsps|phsBl?oSATU-;ER5?Hh!_yWCN7G{Lo{EDrx30{!bo^@
zHOci_9wsn;EhqU9iDiil8ZHSEYHA~~KN9Yuo(`C(X_zowqy)A{J8WtgPP!oc$S6n-
zBf&d?+esHNt>^IJm_gUgXo2e4Dsnc%>$MrINrqt4(vB}>`Wi_OV<0~w1MU*}Q8o@&
z;!h&Cv#OJgSddtbsD!)3R+>j$VjGd$a&gFa^kl?%;V!YO=24e;lE`hj1mt^rGGbrh
zF7Z^&qb_lv$Zfe)<Oh2);t=63@ifix1S&9H<hEQk@;RQ2I7YZj9IrXf?15pC+j7iL
z@npmT;VyAuj`Sz7O7lpN__HS`I-{jeiTvu3f4XP~eFr4|QFXnGYxT@@Lc*XxN&RE}
zHAozhMDfw|NAX)Ay8{VRGT~F9!@b&kM}$ZJM{Npftwh2Q3tkDN19Hdv4S|f`G{P7S
zwlu=~Aowp5$EA@yj{H~6WX~f1DH00Lu!WmyX*#MJ84VkaM<YZnlYU2LM9%G~VFwaA
zkMM)01%#Gp45S3M%QtiK^<7htIO>T7!d+sK=6I|T$WJ5D##DAb^0Pb{u|&8_T%vi@
zC02{vmRp1TMV^dUE8HbEXpRSYfm=i#B;Ml5iTtLKKaOtj9HWCe3GGbogBlkvz=u|c
zg!w_Ef|AIXS#!!usw-BMI4ggvESObV5~-O~vb1D@^KmovS@^=Nb5+0JI2;|Vt|^~Y
zId?(H68+pmv--xCR7aLX=R_7QafT)Srf_~qMJ1wJ;;jFzjuGoXyWs|=-|N(pg;fPr
zv*wgI)0%1WOJ>dGXVuDqaQbR9H9gMJpA-$@wwm81z8FoVd~bA3Go}83BR)j#yw^;T
zUsCFH#mzatr%8(z&5u?&H#8HET~ry7PpWpo{RMvkYV6neco)X6oLIdCO<7dApvJki
znF^IlTMji-@biB13Ex(@jp6r3jeOM7*@l}bewB@YU#<5m<RkU`6uDn&K3jfIGr4@U
z`OD_g<3GpDFCY7zNwECtuU{&?#gEPUrA?nR9fGq7zoyyOI{6t!zxue39`XZ+ex>~!
zAV2-*SMWoBo0`e=cl-E_KEI*)A|JoL=a>7xwa4%3`E}k`^!UX*zu0~sZ)EoI3VdsA
z?5xNv{W&&&0s9TMzcwr2|C$=-gpz=NawvdA+{~<~j0_*@Y_ftOp5#HFq!jy=^Hg)e
zA)laP(aeP<k@7`ztDP8Sd=Htq6n)sfS)OnHsX&$dSY>obnlq6&c(^m0IKo*7;Jh-y
zn^*Xj9e@5~<n;&rz9Qkw=G+pClgruU&g*Td<+t<>l2JWrNpw<0b;S8sa{=F4&}30L
zU%zbNIKjPeEZ&yTwrm3YELu|ItU50Dvke3t;+%{WLxRi6=6COC!+3nhgZN0}kv1Y>
z1UP3PVHa>Pu<Y;uYR4DWJ&yDg(h(%{OF*~hAf1mi56S%a$}aN)u1|gP41~+~Ntw4&
ztq0$PG!bbnQVtSdNo9WjZ|z69xYmNiSI+PSG3NJ2a(wN;IUmWq)yCLoKz2Hkc|nYM
zXH1S~Z|v?uo-gO&8)EpD9P|4l`8C+4dy)9M1-@g!{2uKfe>a{TCx0w&<ow&{P91UQ
z6R9VX`Tdc+sw?hnA+<YE{-*8;aQ+>g`I)@Y8~IbP@6^rFe_6&qz%oDng-Qa_DM<WF
z7W4Zfx%nfKJ+S2;n3&(%9=J-5Wd3Nv$oU5nyO173;$KLZA0OX8gmet)2PE@rl^{>u
zn&(u_!=C?F{V<fzMVgFs7Lxg`2j?@U=2_I{e)*u_U?e_BcrlXs{gIr{SMhl=KDfZ!
z`R4f}KEvZ6Z=O;z4=(X}06xva=YrlxGS8rydj9|R_s##u_{<YwCO$qvH5|#b>wl9^
zfGr>6GEc9WXWmS?o6%3NA({R&@+0UQ_LX@sh)+$>hJ8w3=E)!PV1;=?$X}k1t9%Yy
zKI3B^Of==qvyA_Ll`{|En5SM?FP~L0kL{Sa{;ziCK^o)Fl&5?wQggYf$JA@=`3%bY
zNaj%!BR5Y~6yZsP5+w6G3A`r~pR366$$1OP+?LD6)ob(PO{D9Q%&j1E^XN9nct_9t
zc-y8FsRD^NY0U4B<oxt|9@4o;yd%N87Uv+D-~Xon5VqM^*YQ#)FMsj^?CId<$7|R}
zk^Y0kYuD!YM{<_uRcCX#)LddU<^DH4?TeA7Bk}U8`Tdcc*CSoT%?ppL)BOHOUY&(~
z64zaL?T6QGmLc(?koi5DjjK;c=Iq_b`{m&F1yTwUPr}WQpZ-0@Jk}a4V}6uxMfxie
z&x+0OkK~nl9aT|SvZT6VQKfHzgeBBMeWv78>7}T*44tVLhbF@XUzJ`%IhBieO11!B
z^>wPwELk3L7L}G(mqeT@F0AJ*sa$YYX{ocqF273`%qpvPP=1^yRb`cn;9?BUkV+~e
z&fM8FWKa&ziq7I$QM9_mTVgv^{uN>b=ZLiS#g4_@3S--}jGMJ!*{qssd-~(|QH7Ob
z0ne1@%&(3vbj+8eofVU3Rr8#+ic3Lf{FpJL5|YNBd3OJVp`l@+A?(|I0jzI;ot@V$
z%fW(BWUDRv8LULxjl(KTw0{LFm9k)En#EwvRjyfQunNr{v9g!I5+G~oyxjupJgpto
z(s+3bOv-)=CU#v~8QCkAZE&%V>#`$S<5s0+S#1ov6KtWDWnevAso6PTb2a1Qdy!@-
zZE@vGvyot;Ew-{!EBgv;v9{~h4p&Gt8w9pMvyEWYntcTp(X2DpW5U8<Q7tP4TdLXD
z9ZcDQSd&S7`@p0(&c@nI{8fTUZL7eR>9Utw*$tL$w`?DnMAf2`>A&`1BAW;%{%!}8
zets(+w@S3<n9im|5?GCvjRRY#*-kL&@!eq3S4mxrYzUZ?SY~CnST_3v`FucUXBn83
z-3})8J`W~a;dQI++11#c3AR#4a2c5N)pKBrwe0UF8ZW<siRUTZ%s5>PCap~BZbsMx
zVA9VIVvQ&zzPD^D)`t>H1=t0;jul{Hw;xPKPTyX}?o2Ql_iL<dCz$LN@d+lrabObt
zY%tMYW3~IhB+_reE_Apzw&`v9bOe~hQUE5gl!Hm67h2hhKBjHoTDGpQsrN20De)rM
zDqY7HU{V_|mdW<L8BFTfX4$Ey8oSkC66sGk=F5EW+5p_|*8biGlkxJYl?4VGfAhg)
zo38_tvb({ey6pR45=+t`+^EvBLNICh6JXMR70IUTjbO5;yaFa|TO2aAtp^j?)t23C
zwL2_($g;m%yHl_(kv>SZ>@zTFTlZ8GOAVOVHG)Z`7Y#Oc+rXr4JBOHk@PVPG4_*bE
zuUk2Pn9;rtCO!0TFwx#K!mvwl#FqK=1~A!^-vX08Z$rBA@>ej?-fP)+Ry!oa%uV%R
zvM(fOnmSGclNRkb-Doit^AD~tXG7#9Xg0>O@nG24&_0C!5iHo#mIVSvrj%iPx477y
zY}whCRiZl4uCT0aD<hj^*>uakx2%<G>`t&O-Lgk4n~kG})UnvII?LX+>~qV)ZA^))
zVhwxBvR5se+SX|2SoXMOA6oW>Wv8_>B}Q9zre)QZ@y(GEb9M*AN-bMr*)5jswCqF6
zezNS0IOAo$Wwn<5*)qOQP3k>r*%%yWM0T!a6_&kf*?X3KZrKVPd!+0}%l>BBWE_t~
zyVtTeENh8lk7!S~tj4l+mOWtEla{?}*_1BE%adRUdc^+CvVCBf2r!D@v+NVA{U_LP
zt!<B^m9TDL;-!aW1Hi;fs+A43EXQicTUnlEQ>}KIm7QzZ#g=Wf>@qN^ZHr~Mf=OTP
zw6X`lB+^GLd)(UXvvzM<_Jy@OV%axV>*7c(^(KOe=l+%@TWz*wXIWNl+2vqTw%)R<
zt(Nc0l6Kr-Wsg|)6quBK7Hqh~?e>zDy=K`#Fp2a#EBnc^U#-?X(bN_XCMEh>mSnX<
ztSlc)A}F-%9IKrJHbO^LX=SS{yVA0oExQX${PBHG!k)0&XRK_mWv^N-Uxg$k4uVN<
zd||b1upSa^d&_vGPFi^q*a(OHcZ!t_w6ft=c7|oSU{c3yE4vI#>fjrZgk5E|w^_Cg
zOlo_`$_`o96{|EUdy-|nz$8+x=A`TpE6cNNm1S33yDe6B2bg%i8%(0-no!u|){gH;
z61$%*b51f5oM72WU|z3T*(l2<S~ktH3d<_Nq->3qZLsVKFo}R~CKC3X)xH8IW#6%~
ze_6)&35mAH$tLDhFp=>EK+==hR+eXF=UP?@CiTt(lO9@OwX3acqm^9=CM7mob_1By
zdz-bp8%+E?XtmFRN!h<!?S3$c^h2vXY_(ro?YCC;tChJuOxaVx#PdMQQml3an8Y{6
z%J@<rDZy9v2wP^^pRC<x%lL*JiS#CGcdKRFt@b%9d)~5_t@Z$z#PYF~ePQi*#am+e
z*=k$hoJ8tP026IL%aW{iFqnAGu(CYMrdw7G=C#+dl~&95_=uM)t?UkKceiEtSnV^G
z?E{mtZ&=w$I8&0^dRfMED{0XnFe!1Gm5sNo(6X6e;$@Cy^DSFs*=jKHd@-1eze~WR
z4!-P0ygX#tZZIkFjJ12&$_`n^cgTp{32-4^x?9#0OteES8wn=$j<vFU%Vt?N4-Ee>
zD_2^!3QYXfTG<B6uD9BoExQ9u+IugU)cd$)`>fsTVEBjH-n8sXFsbcZ%YL%jUoCTc
z8@nVhh~Z_BWvNy>63lD4m6cky2u#XWgGtOQExQ;@V!7P1JHVvG-Im>BwU1l&oMo?A
z_8%}Q`-5fwwc3t2i<a6>0290JmQAuOY}r&WDRC~Cv~q!EH(0wZmfZp-CGNI%zgTTd
zUsG>OFtO_ZCY}ddmT%cC%Ps(u5*Jz7Wmd+w;)wPR%eGs)N3865%U-eCcdYE7mGMe~
zMAf06@tkB?mSs~dn+7J^cb=6kva$_U_5hgl{Ueq=X0^|PNxlEDESP9YxR$jAllFE2
zlM)41TV&aEYd6>0-EOsf*^0!n)7m{^?f9}2spAVP`_9UK29x%-!^yPRjRX^anU>{P
zZ7!HZy2@(TTDIQW@s%cG_pFtDZSDSJ*$-A5bE+xP9ZX{BZ`l+uiRx_2rdjQ5FsW^^
zWsTNut7W_=C!Tj&yC*C=V71?YNo_w__N&znO)}aMmSup6=QF@0mZ_FiTJ170@w^gD
z`hJ7eUS?%iTiL^4QsPm|_E;_77a+C$YPG7r@!SDSq8bV&UPf4!VYO4i#LGIXy~MK1
zt=%=&?is7yYuO9d?jP3fbF2N*vahXO5-!q6RD&!_1(TRZf=N^pz@)E=t@d22Ew{3T
z)^3T_UTC#j!KAj^EW68U?+26Gp0Ki)EqmXxe_Qq)nE3n2GX9~wMBmx6o?v3v2Ta;A
z+RFGR^rGb-(o5L_Fp1?nE32|BYPD;utj@BVEZbq(OP0M3CZ2h1Q))W~CK3E>nKQ^l
z+7?XgI$BwGE9-07Aj^hXmSx#^%fgmT1Cx5s1CxH4Z?%i9Y=xE8T6URb^<d)VYRk4-
z?ekXlvSqJZEnhSvz40F_`_bC{Vp&|W>4Pp{Qd>96dV-0U{?;zdYKL2vZP{4MB9<+;
z>;f?9@hdFjYa*oH`z(9NYF`GE2;R1`kFDLOVA8wCtoCQCWmTeW3nuk;v8<<MeZeGx
zQ!PuiT6_xGi(su~+bny>vT%yAdjL%Q@l^=I9s`3ZR%y>#yH~Ajzm<JxW#3r#gVn~T
z8ZUh;8we(Kq<~3#Pq*5!RyNtn3N4#%wR5d(A(;4EY_%6z?RqQY+YqEh*I3!@mfd5u
zyDWPSOgukt**jKy(8>;3_NCQ+114>2G1%10mlsF`CxeOS1Te81X0@ZNjBgr{5|b=D
z+p_b(#7miFeEER*TVw6kS=kj<b}g8c<vR+5-DR~qt?Yiw9<$nKz@&~>t?X@U$9EKn
z_McYEmlTNXM=MilrfnU-Bm%yRKv*xUO|mT6Y6n|3%4)}0Ho<BqSvJ$MIbagYA~5OQ
zl~&8Y&X)*kt@cGLd(|?&WkAZl4<>tjry-{736^yS6T7}(VwYiMlPsG8CQ%hyyIEE{
z4@{z}w04`V>{`qI0w%TH0w%TXurj{uKx9u?*)vx5vX#AW*?+;L-j+iRYhxK-mLS?5
zmW{V8&$6??B&r%PiQr-@+icn0VB+r{%Xmjj%I>r5B{1>wmX*D4WuIHw_m%~Q8P6>&
zJJGU}ElUKG+6Gx!s%0a=q~5cw-Fa3!+cLfjLcCO4*)q%4SnVa2)m!b=mNkG$ZFg9^
zd#(0C%bv2@=dA2`%igfs_bfYXwVzvd6ijO4n;9f}zBEDD31G5iy8l1Ky$5(z#TGU^
zGkf+)AOQ~K08v^bh;%|zdJjb@p@b$FLJA3_kpc+<f`AfZ1dIj60?NG#Sg>AHR73<+
z^a5f>MQjP8qM~BC=6~1B>^bLv`ajS2{m=7r*g0$7wPwwlzGn8>vn|yMl#bEC%F*!*
zS}w^_lP!0#rEUVH<I-=pbQ(`u>KRb@kGbcN#g1F*3s5@lX^YibN?zu18-UW91E923
zv6kv(sXmq(VX4b4H3^i~awRAv1FPm)Y>A~-gVJe~Te&+d_dZK)x73rCdIpr%Ouul`
zsl5S8>pN^II{iU&Pgsn8_on5(v)ot|kH+Z408Pb#(sA2^!hhtWx1~l}Dj$@VD+Q(F
zE&-+OyUB9zx7b4#dm9w~Lo@yQO;h#zc+`cKng&X1o@uGspme&~R<6`i_gn5$pmf}4
zL20XAv)un$?pv1n!gA?%b~+8#*V7_FX)S(GntOqz=%ICub+l9hC>^7Z#S%ejt43Sy
zbj!WUVskA<&oyh!WtO_uQWc=IK6-dur$*0>>lj-s^{}PrcX^uo94H-Quf-07()!-E
z+)pj{q^0NyWF7ac#dtqYb6rctSgN_DI)l<_bhA_+OAWBp2vFM6@s?TwO1GEemg>^q
z)7RZnmx9u92Z7Qtrde#3l}oi$iRCT^rDLqN*jg)BWvTlu^?;?G0j1O3W2x6Ib<|QH
zfzoAg!ct#aiXOMtrTZr+t&e_NVM@(Xy+CR1Kv3G|xt2TMQu$V{)XF_<xsO@uDJ%Da
zmHXOqzq8bjR_+fg*Lk3|&r-cW8T&wK`{r40o}~({+|^cYtK~jysmH9`vsUgsOYuQo
zY8P569+WP%ODxsTQuOSy=8giTEuCbssi1T%%(dJFmRn-Et1b5i%e~1`w_EN#ptQah
zEVkduy>6)wE%&&^KDX32mV4G>e}K}OBL{o=XlSVmEfsI6cA#{OZWbE|Dvr^pJk(Mn
zK<RQ>XtBkXT4uSofztJRz;X{->X4Ot-^w){;-xl&c~mSYEZ|{5bBhhP*eHt?SghD$
zw^(e0#dce4uf<MT?6k$2b1&UEP;tP0Y_i3sS!}t*R#|L^#h$cSwZ%?ZEKYc7v;n2l
zD7DxUi|w@7E{mPE*cpq(IaVJit#6dY##pS>VoNNx#bOUy?6}1~w^*FCX@Jsc%(U2S
zi*2yjT^8GGu>%%6WwFy13%Fhyv7mGs1r{r|*gA{dVzC_-d(vWuEOyjlZG2uD?Lg@?
zhFffu#R@D|Y%zMByl#^ZS?r+24q2>ugeMmV%A{ejQ5K^YxNCjI7TaL4yDYZXVh1et
zxy7n2CL=w4k)U+CZ7kN#Vv{X4&0?!8w#H(gTddk*J?nUB(C?&m8Z#|MPpfHcjm2)X
z*eQ#hwpessPoE!@j@#2>y)CxNVrwk6*J1}O)-KA^*9nx?S8A~(7TayHy%zh!Vl3K=
zOTWI;bwt18*7|O-*anL|X|bIaJ8H4_EOy3XXDt?}=cN$~%9Me{dRuI=#im(ogT?N$
z*iMV>ve<hTJ7zI7Sk?}g51;cXKd?B(?V_G<0EvHp*5cR6oSqFR?2@J-`}YPzaeR|T
zJY|Dx9j+j<4WZ*<$WsXUArO>#1xP^{@(#&hybH>F24qJV@+-x{comeX1M+kj(ilhr
z#+#tb#USYvfgsWoWE{*7A|pXkUkxI&2|=3+B4qD!w4Wfdj1bgu5UBu3?;j5$cM^&E
z2qF)F92|zwT#`^fROSGXO<~B#KnhS{_%bE`9Y}gPY!Go!TJ(z6AkqW~y}2lebOy4n
zRVXq52)&3QD3eSwZ9|bXlEMCMP-YPjI`>l}U5e@17yXYAhd(|P?=Uim{_2uW&vxs7
zhzuDM2>I$Vr>MvaqFVn_hWM*U0sf()Av1wQ&--_?k-@|O89FWEuJh#XF*4Ma9sZ&z
z@o-h!j0~CwWd1<SdA%Sg_a7sJK@>8r#soP*YLAh@zzCTZri}*qL>)0QXn2sxMhTr?
zNGFU8nj&Q4@YevKyno*t2u%?(o5-y5{?!^8WC${y&P%9E8csE!$CB_51p}FeM4tDr
zE=o1Qv^uS_4UnWTWH68&VaP-vac}`CSsg2n^n@Yhq$doy4@f~6@*KswAXLv0AcMn@
zZ-HzILtK=;zgcLkRzL=aA-#a?4nsx&p<l@bZJq(70PbrLSpeiv7*YX*UP2d?xgSVU
z7(&lF(Tn4PGKYW^gdx=wt4*lPpFrr%D8X0_(b(g<gd%N$3=Tv30689pBm<$Nm4kY+
z2*Hveh+Iv2dWRx61KAyhJOYFc6${2XKnT_=LF8i~Y;Y*@9T0yQ!qFY$!jL9F62g$K
zKn8~)!+<1(A=3#N8k!b8Conq<Sp{Ty7;-ld@1I~e@gbKU==1&wMQjg~A?Stkki+L8
z$InB)4?`%ew1P4(DW=o<Jxqp}Q8W~pe_E#Hc}VB;kb&nR<IY3U&O^v=_5SI!ZaELR
z|2*XJ^N@q*A)kaHDL6$Z2M6$Y|8!d4g~<@l4H?U{O!M=Q&S3~?PRlLu6q`~V7$!r^
ziD5_{LS51`=9J7$Nu4vNFk_(?%FfHo_voDLybO=dEKJR{0Xz`u;RPjg^1vwy2^W_Y
z1jDI?sd+dD$YY0xU^+|5(Pw*1%*f4On88xWGaH>ZsTc?LsNp$9At{A8s|O9JaBhYQ
z=g^~@DJ6L@asH^(qO4(Aso8ltav@}?Nh`U+6r5g^mj-1iX>@YZxhR8hYI=|EbFzzz
zG;JO+rQ=6ZQcYlN>fG!!&DPJ3de5PnGzxN3%jTq}%}>eC)8?6Ef=BrnK^RQW(wb04
zVIhuHN`bMHGU$XQ^{{HnqCz_F$yiiWmX~%;VvAC<i;+-Ds3sLhY1IXz!l5~#T<YUh
zx}@d6$}YV;Bj#olr=*!DbUnNB(ot-wc}1yd#q|8JfxTRsaI(tFki2yJ@U52f&K5GU
z@^S7|%DnuN!o1WRPm?mwYZCu|x4+P%cqWA&u$6KSC-ii!FrGSED-3}idJ@??SL<9}
z$e~*2vh0ak=Q8MlY;~Mg7$bO=Rv1iAZPVk^<{+&w9x2i%Pldr@M`(p{?D<(?C>@>^
z2AGqx!m!}6S?9sQRufvxAqQrK#jvMkg`pw+D^y9yIay)if1RX0AuCMKHsMgM`fRK)
zxsWrfCNIhlFAjYwR+#uy>e=B^!Sk@fBtsOB#~2*O3p)ubj6*d}gK@Y#J*t16SUBRH
zeibHWhL7_VnscwhgzceMVW@ZF)wy6|DTbGD6UJa%%+8xTHa|UReoAIxMldwKi1Me$
zNK-H4i_UAC<BO>6Tivjr=bSPs^^}zK?1kysJuGW{QFwifP0hiOIwPYnSdrt4!n*eO
zB0c7Xs0eQq<BLKEa<B1}cqUk@hi5FzPRqcYRfrKbqY!ghc3QBKpar9TNFr1=HaI$O
zVgCG#&~pyF(w&IYw(@iHGO)(<pp;ydDH|SNgaV;4Bdk_YvL!h=NvXwI=fJ}=axy|%
z?D(P~X=$PAN2HeI;H<j5?75gEZ0?3-Wu(oYh&i}$VMe;Ly&$!)D5Fb$*EsX9TaQb-
z_2_+BkM6zW;(B%`Q2)KOXHO;3t7o^%dMRpl-7&nr@@?kr)lV2>Rm?-z<BFMxGe_Vq
zjoGY1EE{wj$j~*p=A8d`Fv*3i%g>k4$Z~vj?HSIUjg{B%k>MCQU|qXm;Slog-99*f
z=yE*c{)`4`Uq{LHNC=U_nNskDuU>_9$IBWfF(ua%TM;4u_9BgSSf;;b<Y*nN<a*&}
z3?ctEVWB;_G6W!!?7NiimjwS!0D0zi96N$Crhhiw-r?yMVJ(xm0p)zIT%Yj##zDu<
zyBS`~P1;nFI^AyFdT2!deGdt}2f46+s{Fd+zJBoEYRK)lHyBnF<U-f*gavT*+N`+2
zKafi<|6=NtNh?o9S437umsgBg6TRYB(s|941~2Za6W0#scGm7G9=+zR6`x^ukd=R2
z*}UJ1--jZ%iz0hh9m38~@sL$VirX#!t$a~*w<9;)7Kd_PeWYY$`yW@n>`B&L{v1j6
zD{itbvtm`9gpSa<H~QjQXuR^OlvytWY_<dO!obR>$xuKfQZu=>wzjgkElXaxJEQ!I
zm8T;6Pik;|J`BB>%&Kj(`VhV<7qafiQ^NnjH575^3XMDQoNy?Q=)dF70WZ`Jk|T`t
z6YYJ6>L5N{gb}|Gm#2g1(0D|XoQHd1ibuGo!;9l#fAxK>k&g?B=V7FeS_V(5e*1s5
zwJZ1fGuOTPG9e<V`elviaNP;jPlSdWO{~5@Gz|Hw&@kjzhK3<u<b^ArY)chix$6@8
zLi?ODsr=;%*6rujyG!FL<?_nF${U9ID=&{#HNSFCpnPBTmxx>ub9s48`ROaKn)Na@
zlwkaorvh2Wu$-(-jzkt#?=JT3XJ}2eufB}-qV!kHimWJ!Uj1Q7ov)jgzgN8m%!;Vh
zua^B-J}XjbtUXR@)mU8^S5%DkOdM8Zg_$||ix}1@acXI?t~ftGE;lu=EH1ThZV9c>
zisJI~;xe(wqP0TY#gkcfUV26;j@wBsjB9=I<ko%Tu!t#6EsfL59o4=~e_TQ~#jHNk
zV9iBXk5(l5E0P1{iAO6EW6Os{-jEnwp8TH5e`WHH^29CW$*WAURU~gg4%+@vTRY$i
zRNpldE21hV@bZ|Izoj*}3F8>6D2gmc-b!P1|AO!xe<Hii>fL2OPMw<73FG#Z>Mwt<
zt=%^wz)@c1MUfRna$I?ltjsv0dh39dkXg16=<1&v+|&^zTbX=x|1b%ZRgQhHB5_Og
z6r^8~9F1|{wF(C*qUwU_wWsv@t*%A!7DakWD+4!IjE$}gRFw~nu1GvuJ~U8~_+I(Y
z*owqs<(K=*hc>TSh+4^9S1~EFa_5t%?(*bK6)~O1Bah`v@2c#1bNS)@iMy!9>`&ZH
zUzNpAMDI^jqwE0M_HS_g6Bx8GP@I*RZPvwNVz>`;09~6JV`mrFEL=snJe<Dinfl8^
zu3n(&io-?xUyS@a_@;}nr}14B8`LujbW2>3e{qrgsiugF>k(Yn8Tu-G6YsCCVc>Pb
zMc;qIj{h24p2YV$Tp752z;5M?3vtF6u6SIehwP(grI`sIz|QESxNgIB1FmJb3UOuP
znrbdDo@Yk~;2!OL4@6pxaQzOwFB#nwpPrNs{U(~8sJ<K5HMqR;T8_ALa6O8Po-03r
za-uSS$9!+Zw<k+!)-!eYSZnOy;kpDDl^<Qi|NbJzj^f&ai^9|J-4Pe*J{@Pu0<sT-
z-i&J%u3@-Z<BGvWamvg$(O<N}nSr>naC!Uzpo!=4>D%Kq1yA7m2KQeM;qrL5UX1d^
zm4vG!E*BTQPn*hx%H(Cx_v0dYN`E=%t8kIte)w*Li=LdLYXhz(xCo=`7nH$c7&z(f
z%|u-9K=)lpI}H~-!~0KHTkz}P^1i)%&`xy}u2-?EeLb#3Ty@NK4IGN$xX4zjo4c{c
z@6nAxKidfN7p{Z2>G26}A6$cLBrb`|)9-y#`BGdj|C@2Qs~_YDql@bMYy+G*gUhR9
z`tFMG5xBr~ZO63=*DPGoz`w$`*CxDg>VKZjIPjmw4UlcP?!k4lp;zLYu3TK6EPW3_
z_(Fqy27BmE@Qt{#agD~+2xYJj<?$>ovb{cJlW>iJE!QDGo(@lETjY5(t~sdNGx$D&
z?=@(n(WpmH=2Ou9&^A8C<zXj~4$+;FrgwSa`FjGD<IYqp-BdZ;36ziBkThW)D^I+o
z_OkNi8>?e}#+dn1<%qreC7KHz)>B&$S)RCV-r(}FYo=D8`H3d@xbpqwiMv+su1LPI
zV(gj*tCpkolal5^IQW6m+LBGxFRKV`%18FDE!kE5lnP;zx^d;Q<E%IiP6868NZ`)%
zQ-qsM3W>WQHUCIp<&u~HEA~|+-%_5uVQR(Lb+siMDuzU^+}%8hG^RnkA_@~wMe<$U
zcHgk7(cr-t>Jv99dI;$DFI5JXmq)#HLj3YUMgJynR|oAFiknqSH)U3U?1j_kzakHF
zMXj0$$E@DnVD;n3c;ygY?yNkE>F_Iryy-At=1<Ir<-Z_hOuc14CMB8q@SQWE^WoPQ
z(v<dUsUQ9W<foIoH=nIo8hsXO8?1WsEYKd9A<MHt)x3y5G{0kRqa+g#(Dasgkfyi9
zLzRgKCM0DQJ2dsq4@;_MGsPR;Brv2Rc~^N<c~WFW^6rYUo63`-E0Xt?_bwkL%ai<H
zm+wbhOnt*7IX3%;p>a?M?G7i7z6kp&<#H&flq<`V0?<%i8eN_gi<Ux4O8w<Y&1;5{
z(=*}>s=ww2Owg!6s<e-O1WL6~QvwjRmXuUEJSKn|+Eo3L<xSVTsZ(o<V*;?Qwp;ZU
z#e_DB+sDMM9C1cTByUQp?OweiRHTU(nJ}St;ZBm7$0|o0uU&X1sUmSxZ9;W&P&TgS
zB&L6)_4E>$OmbTwhiJ%7Qtf5c9YRH4gebK&_^dEXtA=#th=WNmvi1kcoiZ}6<`#&;
zg`k40Sp&Lq+<Rz_Xf><8ME|QOZC5ewO!@dW^fz%=`KWf~hig)`_6n2;mD@xeL>5#w
zsf_McDNq^o(oCd~judp1-8HSO20v-=BM6E1WP{W+(q=Vh;ZFfaZ)7#6K&vc8R*u+F
z`*ar7_|t>wFN&>p;qlsnX!Pvbg<C2|tgBqMCaLl|DyO8%n~F)MWD~l3wGU>k+?#+t
z{>#W{lzeT2)!$-pM1CtKL{s+A$f9bl)hShsJ6IWrDIa^hVrcB)Y6qTK^5^XjtUST_
z?mByt%9B5@Og=u5@{IgG{Jqy+5<N4cslm+SNvKa;D0hfmXT;)aT84|UFtHRX_6r<R
zU5`pzxL9v1b_imo<;Gh}o;xS*Jc@lr+41LTZEjr6Z8|0xihU3wJC(?XR-{Pl39a52
z4AWmTMKg6Bpfw((Y~E|xmw{a|;%v9t!_~#zf`j8cmUS!Ylw^w_yK-;y^8IAnR6<e}
zLSrh54x?$(R6X*J2A)Ot%(D)`_a-AzW7Rz<t+D8Cafq<`)ds8PV}`8Yqvr39M!`8l
zqAMoH1lC~uh^pE4+y9#}Uw(J4F-H|*jDdaVN=O&;%5z|ZSOZhY_J08lv*vU7bAN43
zb65illaf@~A#OIsRbviUhMuW-fm(2R;s!LIikoOB0Cj|M0mYF36R1J=LYx`M_;hH(
zT(YJTnVrWbR^CP(W8wr%EvV2fxYnsk^_e6RYVP@!w4vKzs!YC-Oh5T8l2<bn&7Ql+
zDi!Al;oe{|7tzom1$D?PJr%)1`M1_FkHMT!9XEyQh(|m$1xlS7Ox6l0Gd5&Gj%H&s
z7dKc{fN7rwv2n-CNBNVgM<_nk2IW_c$hy7ms_v+gpb_U~OdX+3ZC*plUevj&yFfLx
zU|gd@D<9Q+!o<oc2PY;~fBH>r?KGN--vgm5q(G~zT((0^?TaGeJ?K(<5;9>Hck(Pg
z1C>eDw<tbYymHyWzjhE7SQR>76I8w`Mp~C3$=XqkDJ?8(d6cyTt3Y`$4OXp%Gp0&S
z+u*l0gp}HGRPL_opH6vMtkkOiB8!J16PCrMA?i^nk175?X7MJgLT6D=rXg9(wRX6$
zBfMcwARe0gOK4Vm0=30X0PT8Hbzh}3Km&)am4e85gV0%s*V3kEN@O2gb4>VuTL<5K
z?d8$b0ZmjD$s1O}E2|i4YhoY7bc?tOZY4?+rCixRMmLJUyeX9SeM(jHimB8CR_<wz
zR&@rgs=`K%|Es9U6m{-jM@_O(tKl4?`*G@i$H=cl^6*_SMk+rwft0jXN<#Y3pK!}n
zLqDh+db_DGX$wp`d(z9zI;{(elpZ!uX?hR*u!?_9YuZ1!orDDwNS*034_j4<PzBdn
zkSVuYv@1}!E_$+DZsAzK6DQ8&Bs|Ze0_X(eZcn!8DL9D81{@!9#JriTr{y06-z%Hl
zpiwrYHpU8U*9tI?VbG%{wlhrA$r@c6aW&TlW4~=ce@$)>+-<>WS|u8ba$`m#2oo?n
zv6=yzMfuPl8c;0_!xkGY2{nzhC>abl24W~D*aw*@)~0Xa-BIsVt|qbiStH)kENTl>
zGAa#>Uz@69A+mCBtQy6mtvGq8y5*9jvPw0+lhr}#k3s8pz7W!wqIAXWw{VJ90=JdS
zMOqJ8)^N?LSaycIr=`1s-qY^(XN~s+KdYv>C%5IF<<7uoqvpFzd1HUC@1T*RjypLf
z7M+h$d0L}W^<+Vo3Tx?|e;H$yM&a=HkEtA~=fF3yqN*4fsF-Th>av*u$%-k*;eVGW
z@2a@|0ID5+;`Mv+-Tn|(8+<piTW1fM(N!yj%GyP$6_6#R&^iO*>U>hKX8s70+k<MZ
zlum6yY;8e6yZdUYJWlQv9FT=@{MV6!%TzoXX7(o39E9VC#y6iD-)_*fDwYmbjuoQ<
z<QIK_l|L$_{Op<`5{rV0A(;9wtHx2;MtQFM^%M~R3K42+O39fVai(I*SyP;IHGhJh
zqsWFQzVvLrB0O$?1YwVl>`Blx_C#1s8%<+(m(|2-T6LIc&`4TsW7evL!b`_hulf-l
zo?&2FOQyYa94pCPH6K_8aI>`7RkK&4rf&y*@4D8|`;0^&25mEb#F?m}Dzg=U$zY$4
z)m)=RLh||g7hXQoG%wf{cUaaa%~Hd%*OSp9shlc|P+U#C7Sf&Ebe~+S!UY#rxKup9
z!d(MRgKf<>nocA7Q_w06GzYj)n95aq!0=t&h7`fs*c*!?^Ezh(tNj7Qq;dE-nRNDZ
zFH7qHLq53Wp+_M#PHOWH8rg)JbS;bY!STi`<@P^lWa4TDYZ=NS_l&r~rq)_>C#aP!
zn)5mm!HAB<hhDRhaaUSpKf-hCw!32KDp>doEmMEoj((I>nTTnBU*Zl|52{J%NE9y~
z@mB5)P`8S;Deiy@JBo1&-vJm(sVMCvUc2x#sX6u;sX1>Je+97ask6wRM8su#)i4T|
zaHw$!H<OIs>cP4uahIAVE2c)0FOXEd(rRetX?X8k4JrSqVTjf6J~?(|gViv^*wEr1
zHPoK)a&bE}m=aia3gfV`q_)tHLZJ3^6rxlPXi~W2l(=i6&B(J>$wVlrTy_f00j1!%
z@*Baf9EZZehFtA}NHqyvPf<+C#L>EJ^^xKRSgt7MJe86k4#jZ=U>|~3IFl&O*fntM
zk^0IqKP!$^O%F>Uy}#C7#Up<w2@Yk&Qth(^z2`=xK<&rSp2jyAgECi)63ZDDgm=JA
zMDB6Bggh!5Swd!xC7O8-nyFD`g6Slt#ccbO3YCo98&@+(i%l?di0(scAffX?mdt}C
z``Ctx@v-D8CN;-U43m6_Sh?(=S@Tj2OeDS3qiH=0^{P2dO{(sz(xU~>5qNyy>A6_X
z)GaLYDb1|FQaW+BH?D6A0e5L|cMW-{P~*ugK@cl%ZTcI>DRY!q24IXy$_1USW9Z4i
z^T_VAqJ6<ebaG})v%C&GuLO{%2CG)kO}@d=R37;tDS0#ty<Gnto|}rUcNM5Cur(GQ
zzZ1oe96kS4wb&mOO~$XmZcbFq^N1ain@4m|FFZU`fBD4A)!J}r@=!@AbnoUhC9LY#
zUz4H*)Sd~gq&8J=4`mMqd!ko%>uoCS0h_(XmYxErpy)ZF(K(o28UF;w4f(LHs#*V6
z_X~}1NDCP!M{mMhXp?<hb7`bd{zrA~$5`RcAp3$J<(H5pC%`oAIH6{dNgV}GGZoD?
zJC%oNJdme?!f`d1pDV12$80IVX@T<9q4F1M`H)FAQ?aR;{YhRLyp^T9R@XLIb(%sE
znP?_AeF1XAD3r+j-JMihnH+Hes{2jA0Fg&(0!gT*>I<y0$0+*JP4LANuu;l`Hu!69
z)A2AlQ2t=yXCG1a$%L!HGD8iDX+AOcfr-h5)||(+qurF?M>RZ;O--6tK)^i;h@-mI
zl~Jj*n#R-me8ssT5!8m_%+Ltm!_PzJy6wgY{manUKWnk)=~NDdZ>pw$O0iR@{7aCZ
zYIe<H6oc}!U26$(g?~9lc{Ntu2sSm55j)Y-LNa#*LX>CRLkY<<4b3|#I*m*L7>6>U
zf>#Yn70R7D9?D><E|hW&U@!+ZL1QJP!W%T}dKMfHw;)NUL)ELwK0KZ7=caQ}sLrS1
z_33tTj(NX-7?ScjlG>vj0qImG1$5sn@Kebi2^E~H)u9us)h~)p&sWtCDJd%E;YMWa
zCfyw|gmtT~3@Y*0wAK=8EUKV;0`Q``SI-L-sfEV|vk@1~5`SUG<)QpfLixs>Yac4`
z0t6;vcN$BD<5VZ69lA<}W~jTh27TiJ%}A%C9m7vPpt2#UMUaBOsBSr+>ysV~0jeuM
zYlS9iRn$I$=5ADM)3y@AC1??Y9F>NO)Po3|h^(RB1}~fm2+^pYL~_YDPD6oEOzNoM
z>5kRYT0tIa<+xLo%XX^U7sc@_d#5jJnKU(P3^YOwDMO=m5CPSMRtS~Y&|ToAa`JtZ
z%6aqb5#WeG_xBpC+D?7~?M^mWwG&fd=E_mRkI^TIoKEUHXV3v)*}PUd!RlMJQq^>=
zFQ|84786SiG>s4&5@t=Mt6-+$n&SH&-W;hw3SQgKS`JI75PK-|Vrj&qU>mD-mvR$p
zp3+~B=&uLp3trOH;N6Z}2*M^3X3dzICTN;S291Ua{@wR<StZ|Cb0elC#W+*_5>RdU
zbgguv{<;ERT7=?m495Keen60MZIF>0#>fsb4(ZgOXF~PFAiRNGJ#~k5YIVOL+!j8Q
z(yxqe9b{aDB_(R-aq<A8YPRdIE&A(j{dJrET8l6J!yxnfsSnvwCsLlSUFy7xPbs^R
z&6c}3(fadN?E%)1-^i1ACf-xji!I_W;#a6$`C|4J?<$JLy?^<6?L71+5$D7?8CI{S
z|Nr*;<=U5P=^5zD*fe$(>m*);t)ZVJ{w9B3?y05E1YU>j<$L+(teuj{azZ6Nn$Vv`
zI{tntW=s0$*sIvLwcpl0&jyGRewZ!c<*Ximoh{?N#W3emNIwppbp7=wl)Kf@a*@ur
z;&ByctFu+v@|(yK6rc3br=C3QB=NP*C33BE7@s75*tt}65%m43^On<4j>Yq)Eu>$r
z#@`llz3eSh@trE;<T_yM<uwSc1l3*fXW{P_IZ+N(ye*Kv2H`Do7Wk=%(OZs|lN5iw
zoGhovXMsNpbhe7!8`RTs5&llc_kL3@x^$Y0$$Ve!Cww&f&H2vx+IiL~aMnBHokPwu
z&O+xGQRs{p@9+iuTHe6jE}Oa!$~tac*Y7rT8@Vsar(`QP*1f=O?z-;JGS2-;?w0S$
z4`eg>r@X{%@5Z~k<O}j5H{jNH|0kc5JLMm8o2=(PCLfjG%WtL6jd6urD=XzY@;CXD
zJS%^Z56B<oY59#jC2Qm%SuGdH>*X!-2l<g)AwQJY$*<(w@~|wC-^m-~uX2t2UDEyg
ziK2(I%6Ubsa_D=NGtPNc%vThJx;af1w#r!`#)0=G<ibClQK#RCGvZ1o$4PL$7C(tz
zPAABGF1`|7oNDp5nCJ9#J`zz*3#aZmal<wJpM~l<@lLeU#F;1RI}MzFi;VLu^g9im
zR_Kc@&r6+heg22giD8@<#j9eeb9WdP8m~y~2k&u_@67%SeG3#e7ZOie4RaJW*?C@^
z76-*ti%&Py8~7dqnUmtU<sDb_aj{Q45A3+;>Qso6VvTqcpBc^^^*u#AD7Jyx28o}=
z95F@QfzUK?Pb&UE=S}gLct^aac#lE)4ul^Q1Ci1;@iW3-i1!tLiug=?D*6EL<2(p$
zl*)tn<RR4u#X={~xl2@vSx%+6T3qWawfP=tssCBaL(7Wj|NIT7)W$t=j>HFH;Xj3N
zra*S8QyYep?h;(xt)6pJ4h>H_FYfnZt+-yS6W56<af`TB+$L@m>&0quv)Cy5I(LfO
z#VXOyc|;6y1~?CkheUs;Tx=CLhz(+?C=~O>N^z~YN30N=Vc&9bjkr%lIuXwO;&*Y0
zvqkI?FNxjab@4Cp0A`C#B3t|_&Wd-%Yhtf>S)__Iaa6n|j)=qJfOtV16Q78W#Ub&b
zNOEGG=}xlK-kIP`bS63J;=iJ;GuO$)D0~@am~<!2*)Dz%KZ^0rOsAvM!Kvf;oU5FL
zVv!i@T;YttXmq(#CQ3yK=C2f|o%4)Hb#{t2&SK{xr@8Z}*dZ=-E^wX@0q0_8u+!RU
z=43gIofxN)QzN9~INV{*De;GJom}y(_)gp;o)$x$r^IiV35Gj~&M0TJvrCL{o)gPN
zj#wfVi)<%LWQts8wn!0IiCLn+nJKQsm^eceh$1In<cVTukuyysi!x_|Sms=V(K1Oa
zcUC$poUvlE7$?@5-!J(qZmfK;@w%poBSwzearqTv#*Q1GG-2YT$uIajbQ~QL?wgjL
z(SN|eL4$`39X6bVUkqXTr}?K<&up^gU;nNOL91dWS9R$4uYY&Ba^|e7Qf4n%x(oty
z!<2-I`zL=sJka#<8Cv?#`%OMP7MT0l=T%irJ9IQgeXdOV*SPUvN*)hM(?4zcjHt#)
zuBvL>crIoHvOrIpzT+_{c|7YsbGB~#?DKgWb8=$>-I|0c3A5zT^D_c(k&^fN#U#D@
zTGOn}Z#JDa9VO7AW7V0Twr-o3my>(f-7$fxCjKxb2SP0A(DCq*s`tlzc&vWEm}%3S
zB7T@?#}Lt~z$Smsz@>c~-*xxa+iqIhw5n;~mL~64eRypB#&P32bZlDr<WuXWP20My
z-^_23ft6u;o)6LEM-fLisyZ@l`n2h9uRdNCTlMa|FLQD?PMhALW2cJ)mo%wgSXH=n
zTh;g7E(^CiR7r=9J@2{n>CN}uf9S1wSLNisH)(QMdPhUktE%x=eYz*GdLzmux+<p0
z0}nPu#I4(6cXWKcL&rgbtF~_2x{VUv{Cw4}aJy%Q>Dg5ksCujF-2-!~rcJM!`~C+X
z9;=#<$oU;Q-m!HXN@d%Et=pcidb(<3xZR<Z)}bTn=jo50uR^>}cYRuQG+gxUkn}oq
zWL$i@>*>wUJbS7tBC<|ZxM;Z63#txOwfOXzXHjld-@$<Pp`9QpOly-}pXOCPf91?w
zyJB`#&2L(Db$&>H*%%_~Z&(G1s-}%MHm%xN71L@XTGB&-=bQK&PLDx4O%tfxs;0Ht
zx~=c?{;KDzUVZI()Z5Ie1j-y5cGBFwBr$c`^ed;$RI)9%ZreR>d?3)I$^N`5;1Q8C
ztGYw>>H@ThYnHF@H*6A<*KB4}ir;$cwpN?J&^QuC(Ko3=id9RNx`E6led|U=*CU<u
z`QgW{+b(R<eBAgZRaI5-RiwG<)|shQRb8vP#Z)!!wRKx>()b1aA=~h^8G0y16?%xE
zYd5c=uZK`S0JE#A9;(Wl3Go+S+WgQbRS)k0SoRpMt=kH&+q!MTwHq3IeY<bNhB-HH
z@4w;Wojb3MdFS?<+da{CL)ppO_iWfOc|(IaMF&qjcl*t6oOo{g6VH`Cw{!cRn~UFh
zW8b2MF?p|Sf8>!38@6x1D0T0{2cK`U{pCI1l%M|Q&IL^#4LJ8cI``*5%#REB?5e7Q
z>z{oprc+>R%+|nDfxy)<^}m`E(<BfR(`U`()d4qVzT`2Tieh3q7x)VrHd&k*C@kn4
zRS?rSE~ZDPh9!ZL#r4}X86KFE`3wFH4_p7>7xVZ>e;9sGMHhW(lsNzJPs#m%_eY!6
zhOc%i*cGC^codJTH5F5s{@lxFF#VayW@4p7pFZqe7K61|ec=<M40i^&q5PA4FW$fT
zESt<mvo5@r|Bp){#WbvzJk9Rk#B9U2Lw8egfHf9FSTFt)Kf~k2Ut944Z^RC>fr2b)
zEiMwn@owX4Hi}2^0sJ6qB<NG9G@SkiOH%$Ok8QBtI?5v18s1N=;}3`F?#)NA4Qv9t
zht=@Ytd%&*;>9w^ktN|JaWtgVT8r=ak$<qH{BJGkD|(9u*_XV4&A}-?dHe-Fo0G0Y
zv6Mf^e&t16<0SVizffpPZU+7gj}t9Ldp3k0WqtWe>^J@!A0@7KzTj6oe_uNb{??MK
zcnetaFrQ~qoXzw3Fu~bVSe0&O{X`Mp!>>k3kR^-x*Q|z7nf!|n6|H$o(E~Popls-m
zS3QpsOPnv+5~mISdrSWFH<pmrN&IaVBSx_AIMu|jY?zqHDBY%_ol5`jweI|z*7q+y
zLOj6RaKWG8f3lN&B-Zu;c8R!zm-68#)!E3|5Bx3m1RKF-t5pBTo@TeP+f^?6iP7R#
zwu@5_+OBdtQZyDFMO)DA*noei`4)fE!rO4&ijVX6`Stve${po!7Uz5}+Q3I>377J|
zybo&iH-4|;Q^{P;j`6enE}qQ(VEeI)asU>zXB+tleg|KP{QZ5&{GBDF^;>ok|B-dz
z-|#K`KGqX$pfCSKrCh*iRQP+XpZraEFF_v0!JZTB7Z$*-L~rL#R!>BuoR5Q3hrP}_
zi2G6I-|z`Yv88CqKH~TCo$NI=`qU8-;snrkxY{Gfzwi~j3EP7f+DAl+f&XAn-M=mG
z*<A9Cyb-P|U_pCcm$$_?mHBM+^bzccs`Vt^25q{fXv^BFKHma#UG_W=z!E>J!rwI3
z5jr{{XV0;JD(~6<(7uoInfxgKn4MxRkk1d0#-%8yDDeww^1uJ6b@D%G9V2Me_=RQh
zZs@C@@w<6HSbCZ0C3=d0Y8zAkX3YL4Ti@kF`ETq5dk2~~L1#-ms&oRMRVabour(EX
zG=Du4%>M^lU*%)DgAwBdO5jFb!Ck>cW9H)xQT|P_>z2XWioe$Sz~8jEacm@SE+qSb
zokS1r%pb+6a!paU|3c_RR>q%XyHVdyutR*XXd&V`$!}s3HF~j<ABdcFM(84hnu;=n
zI$@k>A;u$C3+TBYqhJg1D)0+fEo24)Z-7v1(0$n~_B3bwB*IOhqZdxSy^_zs?o?BZ
z6D>s-U|k_s34S;BK8_Ec#cttE_!_nbJB=T(#$3za%By%|q;(VIE`fXw&r@?<BhgU!
zMFU1QuYt`Uus69QI`gy8+YxeaK>kAHaWg+{#uY99F>G7|{vz{Dd2EjG_xS8*7l<Ah
zM^5r+{vG=Y?_F;xVsZ7v)d5#L>&_SBdk%YyJ;Y*F9v?#7m-(N(IrJ?ud7O=X+s0xo
z9}Vm^@W0?O>}R%~y@9xK?BDDRzEgq!2!2a3n^MQsQnUcx22>N|SC56-X5wXlm%t8!
zY6dEk^=EhT@t}%v6|sBxa_;gPrDXxT7<#wy4fy*39;5q|E#%*@n{kTdx4bDI&VOQ=
z{1m?n@e0{sb|LDbJHA_r680*a2>lN0A*Qqc@<IGC-^cc_w|Op~#uLQ9c`18=eZ)TJ
zPq8c63U(8FoOKfk{60RFC-TAUGq#oejy>D{{6p*kPr)JQtNHKj9d<q2!3K$!_<L*>
zyPe<0m$0FDd;PWS2Hrq)7s>oawv)$-F>DOaM=eJ3CwUxi$=mTu#bf*e-Ua1Yhp*>R
zyqSn#kMMfDKA*$}h+LM$F6T?xE_R%K%F}r|n~S3bF5}DCFm^TD#)gPD*%xdW--x%Q
zU&9~d*{qoV%(wFS>>>Uke~zEvJNR`xk!@!U*(*3?GKD?LbJ%sPgg4{wvd`ItycLgT
zfAGu2S3HlU@kj73_B+^n{CPH*Kf_)@uepIOXBUfoJYTG4)x1F5g0no!*jn}$KgNXc
zvCg7C+k*RL(|Hsd%f9B7Y$dzS(Vr{mL3?w5pn~6s{(cjBLZ!2gt>f#Qwa(4#W`46+
z&(<U7>-k#j64B=t-|g&n=Qe&DyH(yQ?r`qlcR6?SO=#m)>T?g;!F~Kbd7tloe!tj)
znG5$0*aOZ39Q$bUK?fh&QF9)2Raia<{9*VvkFrN;PtKvw;{qS-nD20Qh$q++;t6pl
zyHh-gox~^kQ{t(Jr(AsM{)hdCZ)e+`oouIg27cEwe64&=Jjd2Xu9a&s!fte4;4g?5
z`15sM<oK}tVn5sM>=wJ_0dasIU@x(kunYAXd)4=9#GAN(uz_t5yTt4Kb@96Mx;!Wj
zvNz-#sFzoq!}72=!XKg!yzG~qy=<@8$M%VRa-Uo)_pm);t?#IN)IrMbTHo8^ZMw6<
z-(l}yU;Gey!8T_r{l)h-cPr}O(7tW%Hi?iE{&}CjFX;L}e89HJZ9;MBTYWy{ABt`6
zF@6kxNgpKSHuq!qWBG~r1he%=Xdmyfx16{5+Nk6FID3RW;ymp>?R<)P;e?=)K`pxK
z<6G-|hWY4U;@{#6{yFZKtaZPPs^<8JYWUgsI49Xj=WF)0_{#Z;o${TEJmsE}r#Mpd
zJ<I6>ebDkP!)`eGH*`Dd@~!oKhuQlyM@W7j@dN+C`H}r7&hRtNPyA>0vshR=3iHfr
zwhey$4eWcit9CkOEsmAMQ~W>t2lR~?wA=`>kUv=aYVGd-%g>k23FkxSdFKh|e&<$a
zfs=w=|7O@XXU;cbx%dN~TP^&aYV7fy5fRuozW_VuBe92=>*PB{*s;6AxyShz+U3*E
zPUl5upYw_1S@dsC)TQh<jCuo+zn}TtEEe<qqYBqjU$U9C!?E`_03PYX{5Adx)(bQF
zf!g)L#U5%RMvyy1uDBArtxfqY*yVl`d(dBE=en+QOmuR_%BeD0Cdxr_M(x+NY4|$_
z*J<Y)=a^H;zj9{Oeu3+_^B?CC^sW1xJ00{+?1&C_zQT^`jM}xh-o`lk8rG3BY8$Yx
zYg20%<9E6<YG23iW*V{*j8oA(nGX^RL?wSkd@h<h%lSuQ3U)&8#?JoZ&I`^C=YaE^
zv&(teIpS<`jyk)Ycbs3H-_dSs9VWS~Bfod59iOamUUJ@a>dS!q$!R3_I8Ed!r>TsU
zZ#x&t|2Zd}Z=Ke%9TuiBGFrMaLVn;lGD`m7Tp*>aD;vl^oSw3=Y%b$vOW8(VEL+Kb
zvcK#gJIXUoXW2vk==|bbA^XUS<N!HFo^}3o)|r2BP%e&)iE<*FMK**p>GxsIX~UwT
z1_Hvvq)nI;**B_R)Mz|6AsYZE!j0ihWRwfs#oWkz^|X*XI)=`)jzF+J@pLefV&S=I
zXfh~cb)lesRFtP6O6jw~=(dbfsn?ia5<NPGQmF4Lq(NKkCir8Zs6QU?Y)E|KHZn#c
zK|EUxb|kR_R%sLoH8w^f17u_qV~)yCQ)`YAjSc1}Dym*obQDFnpeYX;j0d4rv8WWA
zajvawei5wfioCXn(XvWgOA}EAS_Q4Z5eh0<TZ|W(SgK50cR>+T`CJkmr((vtA?4Qw
z0mY>pU)(c<(>54ybc~L93HVmHT_~R_e6Wv7r+rX6=04UT7=?lzgDGI`z&b_oWT2g+
z&~_T(#}8e)@NO|dU0q$)Ery~cbm4=dy<ChAk?0mQpY(MPl?&?W5yi>0p2ikcQ@x^)
z-lZYNBKl<^#v<6e1+19}3#Ua*S4G*Ur?IE6A|TR_GC;cflPsm^$qpdf85<ai;|vL%
zQ;IP-R6CxES9yiXp{nljW9?x<b183(-n&Cj$<f(VBgZAj4U6m9rB|0849ASq!B=T4
zqi@&TvVy|=xkX*|F<G5^K;Tjp<?L|v#RT`I;Y2Xz&?$c@#mwn^B^W|R;Jn7UaV2?0
zIAtp%JuVwZ77OVrkZ36rm6%Hb#~i}N<kk&9T`xF>yYKT+u-sQb$HBQD@SE|2RCvq2
zyy0`0`ys!Ubi_+vDg}>mdIheCkBs=0lze2k(LOrMaYRn)Txj^%fPNp2bs0vdwz;1e
zC_oU-$(+yJ;|7ZLrIr-u>r?HR`zhasLlZ=Nb05z5EWiP#`Gtsn!k{gD`p~iwsW|Q}
zow=VGyrnM>r*IE}o`tDt%>A5S+m@8H^5soVos$CvUzo(=d<DZZbBc%M=j1T=OTI*j
zwejVo78Os-Uz81%U-1dbfOfuu!tDIQaT$vYquMYMV8dJ-`RUdeoxOc|IIayRnKJjJ
zf%+ri{NmIc5C7WWgMGOrI4_*Jr+Azy#^Ju~yzFA;e$Ve#ri}9C;Q+i0R4C5Ybbm0>
zCi_xD&>#7`I8#ByPeX;J&q1nZcw41xrjHKgT$n-VFx0sFlZijuS2`KT$wBmIK0t}4
z`wA2?q;M{Cf8mdz`bB(}uQaJJU!8~Vp5^okV-cU@D=?T6{ndyT_zHB5DfBmk7W+yy
zIt)k4(V?fz{hjA4J*B<^?}$Ye<qs2OiLcbdgOUEnFT^P7#4qQ*g5&}mo}QuN{HfwN
z@vFG6RKvk2wft73<HWB4k7{>ZMn*cd5GI~h_>EzBw@aDJ#k-2L4v7R~sDy-|0&(JR
z0V}bvkhzX%g(7$2H}Ht>so6`h1Yb`4UEH@A0%MEjl1A5{o4Bu}8*}T38q}#1zXeI7
zX=X7uO8D9l@(}bAq7tiT659bW6!l!3P>Vj~7gTOe{F4y%P$k~bi0|aSJdZKH05KW~
z>ZnfqF78XkQHdqg>>G>Lcv8=a-wiEO&=r{5MBJ{7Itr;NXaaeN*;M4?ksv4jJ*f1s
zSflM2<VN5CC+1#gbR7pm<uxf|0dt!f@C^6O!J($3aLiy%1`4dXcnZA;)gcr<IXgEa
zzXUC^g;9Hppy7m0@}-{CQbenA*&uxB=$&*fpgQc)Z7pataN-XLZ}>{VP<ClgCil&x
zCL5{8Iy>N*F)pRVNbSE?N$Fwo{ISv-5<R7_(l8hamx^k)&ItUGt;H+A>MB~si?0yy
z6^zX&&dN_OVzP~B5<$HL$HbW7G$lJ9M-gjwPg$(^5%g4&EKymfakW&R3@I0i%T#QM
zK0pUk%0*(P0wR5-`us^*D%L0@ntHH4teD9%LB~#uc)zbyodzivix(6S@RizgFy+;P
zj+qwmvA$Au(4t&oq?)7m=(C39QUk@ort?l_l*^2LZM529I0?8gKZnU{M6J@?4(SIE
zCzi{Ncqd=!Ums#AR~U%|%uLOpBASY`o*JaOAy}XOfb|SeDKA1m^Qcf1uRe9l`qa$p
z-vtUn1FX;rE2OAUq3gkFAmtn@OU0)Z8Z|dr78Rsskp`r&)w15VETX`o$WrdL0#qu&
zxXM`YzW`c?4(F4bL_@gLexiAud4x1_;(^p9dX$WDXyVn4CE!r<)L4oZ>%&c%Y-}*;
z%PqABa>^zKjf{ALG&WUAM0|9_On6E%*4dyYb3X>0f`Z}n8VY%VqlbI67IlQFywG_=
z38AH!Q$1yKhn|n2X}Hv!>nU3p2yG?wpitS;sRutt#8WE?Jt|bTa=I%9n#u4Sol=}L
zRzcK6axie>h--O~ldZ4>!X}mFqR%<y3h7CR=_~OL9at&id!w%e&oY&5Oyd2~6mv2%
z3Yfguc}@uqMw2cnEW{ynH25&t*7;K5!%-zoQRq_MgB(UDqR@0J+mB#<s)71cWFhrP
z42V;ONO?a3TAm6hMBX%)w=ADZMe~VOpN15~|IzZPaL$SE3B`a_Pfd1ITtOkkr=>_k
zP9=7}?nyQpm7nIT9zz*I+<X<6$}z|TyjDdcBdO$qYQg%qWxZorM1ge-Um{Yb=a-O!
zCFM&9H}VF-g{e6u0G&Dl^LWhIj9fJMXDC{9od6I&(Ok+n&<#1g%Sd;YI+(1OO!M~!
zQkUpx8PSklaD*XO&uB8TVN)=acS@&B%Q_9oaJZ*xVwQCqQaQstWp#Rxu5|w@(nWM9
z`JBHL>q2;I`FS{99*4riLw??`<1?Dng7C}u;iXdR%Nt*qo>4fojLE%5G}4!9u><}n
zB^MnUJ-G<SXfyeyzoFv!ec9=y<4Vx5|7$b^2$_Tf?&TrBwl@|IY)1Oz{1G_Sc(mai
zHqy;~`Pu|B5XUNFqBvq$alQ<k51b1JDScQzPQ90J`BlBdw_$Z|r~GI5S0T%F6)l@K
zyr1%4Fr^rtfQ)Tef?1#Dt~#`skeU8RNtEa$nd|QbrXGv(Oky-~;jDNZ`YZGOSF5;~
zxnNWtCIKc34Ti~UD6AT-PI{Cj{=1YUCa~ezMQNV!LjU6m_D9U4VQP^H+99db|Gwg5
zNHPOJng2V5U_`<khm(<+T<pJCIl>r`#=-q(a*2__P?VUD#<A3dF#^G3Dap-aa+&`M
z6$c}b_Uq*}{!E2n{LxM&lgs@T3c>)SkLs2yjDZ+_^ptz80Wk2GrHfo?AdEboOUvXc
z0}dy%^U}$cQs?H&)&7rE8l!0PS7$5Baz7pNCgR7K5#}mnxW4)mocGcRBX_Mno#u#s
zSFZlf0}@T$TuQ1{DXCLQNtLKatJ^3FvFZ~A7IiBrS6Bh64<!KfK8wELq4kLZ>n(gC
zGFpn1JFOU1O?_ek{luadAU6utQ??pb)mTUjNRm%2<tYptQvPIPCE8euq6pweDswx6
zr}IN~rgfXic!Fh7-RZ2_#OfQN94quxxRA0<VYIeFde7ktgBt!eRLiaU)|mRnda4sC
z*F!>EM0KZ=HN)*^0D^8Ibq9Kxf;aL+%NP7}aXwiD87W`1eJmey*lxw4HFrsoTEEJd
z4C4B-CubDqj?c`*sjE!xG0`HiLl9}V0n}E(IVr0lWKJ2p+gJSmvB~bU$);x%r7^kR
zOZe{%Pk~7o-6G}dYKZiu7S3I0`uahuEk75FTKR_6Cgq<f473}hEG4BcWeW_B(KH}A
z^pXzdYup7uK+yqT+`R}io}W=R3`_GO=DUdIX^d5k)A9?-uE;23zSbJyKuR!>`{Jn_
zQDlv?iq)$Sd~Gxk**G)15JRKy;;w349}NNKYu`%+{HzIF0p@G64at#LzyiMR0<6Zg
zpTK-QbR5>WfL?>*1!ZIPJ}+NS?MFp6E>ITr(!uD)c{-@m_p?9>QjGMqC0(AimuM!!
z>g6Q9b~+)6a-p0{Nk#|}QIwTmSRB5=(<mG3A2(WU*)%F4x*pF(TWnO)qdRl!^Ad_F
zBW!D+X|7QTtxp^9e&99ACfd*MRw=kT1ufK@xeYlr$~uEED!U2%CCJnzI@;}~Hsi?0
zqs3r%-UORrGz}N1RcQ~ioR_{lI)0wHJ<Zlbr0E?b9(3Q4LE21fG-U4F(ezRocOvhE
zaFiGB<Q{P@!{I`{^z1@RE_yNemZP_Z7<xs<B$Nx@34pnhxo;Z=_Z5Yp?|SZX#1)j8
z_nhb3lf{v~JQLSU3GVwwP|e}k7W&kASxNfIQ&6*pd%}nWJZK2L4}iI!8649$+~ktn
zlAKg*SYZRo;LW|o^C{<5r8CZ#rwi~KBhf|!M&GvvZO0nfCH7=K5+xDkg#+$pu@ivu
z@7?><mIKv8235=bYQ0PY2fb*Axm!%w#Xbto+-L5;)b0V5Lg_HP7|8v%$ZAKWLep~w
z^8SFJofj-El>szky2*UMNuPoN_ZpFbldW{}%Wd*%TaCFZ#6YD_`W8=C7F=s2B7KV~
z2h3e*fM{P{e(^Xg7?``tSP4g|D5)?zm%5L;+JFrsE~V<b4!3*Autty>m7SiB_a(V&
zj7SV?G#pzSQ#c(G76mfay_WxKja-R)))W<ObttwVR`FTb0iiO=&NCYztIalIq^~G7
zGo!dHB`0GcmBw`juS454XlU1)R*uplM@?aC)Ls=zEMgK;am)F7r9HqJO~N~ca#NW*
zl}F<2w<r@#cW>u42>Xf@8&g95{A^U!2Ge1fuXs+58U@`uIPKmjOVdj=bf<x0eZ_^@
zb2YZnV4cv|RMFjKfWf{3Y|^N0pSwA2`-u3-KHA<($;>Z=)5zR=Oa`av=5wzJPS=~e
zoA_!PBjRWH(&+t2DQaAGHycA|`qEM8_j7VkMEq>lD6zBvEo>V9nR2TF!`)W0J&skx
z<}h>Pr0Kr8LNC&L)A3xV)mrMbgx-u}ZoJf+v(i^ECL<HJwvoDNMPes0doG4li$p_&
z-udKSEOj6E`-<@%4789-<U07bB0k_NDo91Roe4L`G^#g-+pBdQR<CLvcD*2Wf4#BD
z?I{1N`fev*HZbOPGEowI*~*a1^U;vBw$6stGh#9|+Aeaj>J7cI+e({n2~yVrwueV$
z=sff=F$S|bA5;68&U>N2>JsgDljSNZJ!}b6$xbn%EaFv?oN9t-$B9_!V(3HR8w^Vn
z=BCIY9VqkBtdVXPGx&O_i&BB+?oem;1yEivqA)*~xx*Z78UXU8H8|Y4&h};u(us~)
zTxprffJPVz^k#H#=8iN2m|yJ?GWQDS6{P_yo}%Fynb`cNP1!MKz>f8msNG$xAu^de
z)}R;o($%{~G&;_p7oxjj2*cJr$&NQ@Gvo~u5>zwyN?w2rMS0;k_eyao4wc5xOq<*@
z#d_74nJ+sDFAPhh;c}K4K!jR-c_XZQm4O}IG*e6vEs+LMwTa@+_6Ab5?c%12g{pti
z$e<?3If6V$y+>D!eF-<s09fK+A&{Db8#&BP7wuH>#OmQRLv&HW=B&}^bls$9@<ikz
z$^@g`1#$)D3DsL7uU6HI430*bF7%p%ZXJufmH<_1CFaiJYn3JyN^l==Zp3NhI^73N
z#X=PdL5=!bO-16iPqv3`b7(7sCXdu?ES?gn%WZcKE0fU&O&@s3v?O%GJS=+MhmEFy
zFF#Lj`M8hR`lnkz#=b{w_0vo-Boj5d!`Rha7xH6Hu}UjW54DdwdZ=yVOQjiIt;w1D
zg!8%*YUfKeGtQF^EtN!kC)UW@7oW{HBJ)uu=y!9)HwfEZ1~*TbT?Sn~`GQ<}8i@5g
zP+%*cR<G^?GijouCDBbi=FZ{2lYSjK>n?EbZ3Xo-UKYA~ykx#YG{7QP`+<7*!Yy`f
z2h(?UO58s>Qo_-`wEUcL^e#QTJq&g2>Y)@K3NUh!adTmj0UP30AzrfM%|4|DZiF^o
zgna_$mKh|*r*1)-I$3N`xH$9@potmiGglj|vBpN{q5U&=i9wtAQmy1t7e6k9p>Tw-
zJvTQ)MPFue*Bb++1+Ot6#z3UZ+~p=bSlz3G2Vug)eR;HR<X&sSxHG2mzS4xp_|oPN
zO(lC)86?T4-W{j!F0OX7Rd=6^lA{S$qt_X9nn6eA7h@2+-YA%9&?##7%3b3&QhA!K
zEX&DIyXfu>O4y0VZKG7x;x%01wuZ2}WmK3k*W5B(Z)7)cp91qycQ+dhw~q3r;Fhji
zWq?f@&}02A2E@H1k|NN!h_@QfgGj%?u$X(B+fF5qJ4+d*co`pFc<A1)>dA@6jin+K
z^<+IIZg6QzR5zB2s6`q04g=%vQPCLO4K?tc2HuMsU6U4IfZym+S8(DF0+@`uu*|*7
zAct^|33p4)C~&uH?=vYB-U{BT4UfZJj_#@MHIWB{J3w@o@LsozG9P!F7SoL}4D#x=
z%I+qk95<bc)G&UZG3axSSt2bbwJ<~NX1Vv9%$}k<UD<`jC8;^OVzwAVPNO8fN%sL$
zhG#guG|V;FzH;#!LG;lm6CCAsa<90EhJ-{t4tI97YoUFaE~X1$?k&Q$7FHspqN_o%
zNXMJTit=;tjw?+12K50|{zEqdM9?~>D6t?5t-QOzBC+Br!p+nCMcx*p+rzNxXuqka
zs~zFGaPDXb>E%|KA);VvRz@NE!=<ivl>B<(bD6O`;42uFx)5t7=JqxcvAzPEOdliG
zobET`#y4~Oy4rh*)1z-c6KrGruUy)2bo(0=4%3)yTJ^gFjPg!UuD2=Nfd+!dWP}E(
z8W8b4ec7In2le))rl%Lu{Q_MygWdHigZ)ugg=xAr()pFBoG34x;8w{ysJ8M{k=!E9
zRIjJPTTKwR9GQEcEK%AdYh+q#CVzl*=}?mUn^=bap~wB-?ea!@H-DI0c$gG1MKSk(
zB2UdVk?<*$=l!P<z-(w{wOXO)EN?bs-fXBnMDFM^rg4*e7-87WBZ@d?7RRC9BI4uV
zrl|y^@weKj<&>HvT{B6d28PkV&)f({HvlXM(y=d`<CSn-qdWnlQEK}5yc{gEqRp&}
zilC-QBW^td_3~w<2G?Wt4SK0>K6Yi46V|{$m#JTHj3$rDZy*f$MW!3#&a?sh0Q7$6
z5o55vYSLwHz`0T7w7=P&b{jjiTPfl(FX(Anb${<}*Ko}4A#hVO#gEdS!3D-M7^B|m
z!Q8q02Gl9N4W98vW@O9a_W+C1p-A^d=OYAti<!IIc~@D&V$;hoioWE~hKl5^F#X3O
zyhn#y!8FP0w5M9i<~4|0m*_TbKi}PLXxu=1LhtZ-UUgo^BDGgBz-MNBUw%%yLIxTH
z8xt9eP+NMY8syXS7k*fiLv^Up!3Oo?mOz@SgCQn19PGJy_^r(4CA6#`YS38SjE4Di
zGctbEa377fXjQDvLRv}8<6B{JU7|a=eqY+fu%A|J4UHCrOlpk`0!L^vMsNHO&}fd-
z&AG8pH|J<yaVlQNi_xH|Pp`mm1JVpnu|C~8G5FB5raSZnK0Ul*^zl63X1;vYQ_b+x
z+}BeXjp2vpC;XJa0N5)bTh#0_pBKUSC@<W}J?xHxU#{FF<{mNb6_(g~x%QR;q{{A5
zI|diy)xhWoZ+j!JvK@8*jv2?$y-_9blkww;cU^6!_Qg!&dSA^_Sa<67_<^fERpbuM
z!t=~NG-#X;epx|Ej#|PVb4@n&p!<=UE=7Dh<_s;ymII4upNtH}=m2h^QT80=EJn7-
zCyt`Qpv9e(w26ivkD1?xsf}SNX=_BP0n^(g9*rL%sg1a3_Zv>XTJdEMNAvyG?n$6&
zPFCLhcLtK`cOA?<?QNZ~3nE>gpdW`_m|Zj)(|2KENrCb=Bh;XHA+~$qKBnV`F_D69
zQo#h;NRrZxq`zc*L-p$<y-jE~(K|t5L-kvvAY6YIdL*I@15fY0({E+;Ekr3(R1Eqx
zP;kFd-_j+O_30-bh+Cqh=(j;yO5J9muBk*Juu%!nPlV1Dpx+ljfL_n0Q>P#G{AF4y
zL6eb>Al{5J+#J%)uY?MYjM4H>-CBS`Vl<=4o%)B8pk!#TNGC%(bs@<Ff97Be8V){g
z%Am$^Uk6J)Y$d~^k&^neR67Y$(wZ*{gD}RE0v73xQp<B+wqEX!HuD39K}az7ax=5g
zuJp}HIW0R-cIxj(K%!~0*xR+mR#pzS-ac?r+uH%~L%XfuZMYmWiAcTS@{tK*3Z+F{
z27WK77oZ;-Mzk+mtph$WVShve8gq}EIW7=PK9d&Se)lW2(W|AZjTFXXy)3VB^g11m
zo6>qRn0(NW``Swyd8O?uDNm@}Q@&75v{CJiTq$^KZ!UJnr>ngdo#+g+QDvNnE7h-w
zXz_?G8gG?4(`<$z+uA9dWq>-qbi9I_xmTHRU8MLn(lt8(I=x7@P%Zwomr`UBK&PeM
z@M3Qx05L~mhoI5W?BZPYi^~;~I*#WxX;q!v+awKOzQwe!F-I+^Zub;w{Tpls77xkE
zPQ{pahe5Cvr>40(&AwK&o&`3VZ7;Q-n_obi;^YY5WwI3T&BKnF-k`qQV2yp*-X7LH
z#(r{6G3MTDN)uyea*^_0Hz|Y3DMEvzA%(e{<qEYI(gt~^J)dUl5nPRI*=|JZdnw7K
zZ$`a*v&R!~5vV;)cOM2+m*{ABhFW&}GU#30*jF;s0MicmOcUgA`cexqP0TXBtk<Tl
zGT}%hn1)eJB}hw2WlV$)(`r$LqaZ~dr&RfrlH3p}$%hCiUm1&07AgAXL%y+bu|+>U
zg90$Fo#?L-Ns;Dfj4xo(V%TPi0y?8m-INf+^-PR=TUdvRMD2$}vH;DNi3{;V8Kg7e
zAVo@LVuEI~#&baH8BVemk-Xpx3FzN<@B&XrwJ$G-ClI4~#(kX`YgJa3z<4I53$o{>
zjL)SQpfBsrcoyXebT<lQQwCI^C*$+T89<<Ww?2%|CzpZ(J;2H7tK)R<iC<9X(o_jf
zkIRrs9%WYrz{#gI5du9Edf|uGlqU*wgV+Mk7~Cx5g_JSoOrJh>^tka8Cr?jGWW0zn
zSoa3t0e(iDK`tV;Bfx*MKi|tuormQSjzH77$Ir2{;dwEBR#2X?J;v%#bpE?|3gNgV
zXi~=_c&(Vy1>LNyj5;azmH`A{rc6WOb8dzm84-ynTsYK#X}7JcOuccF@d$@>(2j01
zGAt7T)rQho9ZH4Qbr_(F1pm$5NQvcS6~PRb25Gwekyl9JKTMdj)@5ZW`u&?Juz|Ah
zQ8ec#5i|ZP%D~6biU!H}C()GKHf3cdv&W+;vllB%PehZYXtiVzDaFm?;=+<Nx)sL1
zkes*e3YALD7m|#DngXNe3rS4GC3T3aHU#L+=jzp>{8^Xt`4n3j^sK84YD{^3)}@Hr
zfahFgKwBi8nVpxOf=%X<w2Tz`H8g%k%^!4?)50GoMXEBlsxAtz3W~O=^0*|M@rM+u
zizO=?_Z;|PB;O#xOa6#T9>!yv19swvF#IhQ1<+XCD2{5y%EGsmg_o3-73ZVa-*rh5
zGD<Z^g_N3>mQjE-zDJo4wQ2mI%3Npbj4oFaRy%bmnfhn%{B=Yru~80&M0rz3Y3G$h
z5#_@cM1d{{s)>i_5B>$ZG1h(#73cz$yDVVsRk;+Za#@dX2b4{*%Gef!I;s*ZQDHs-
zorMHOV9!GR;G66Hy*Ge%o{m2S#Gc1^rIP;|A^hud8VzL!h?@mo;EC@Zu%c@us%IZ8
zVPt(leu2((A)W!CJt96p8@~xr-p2JlB-dKw2Poqk0*AAM%nVe<cQ9o?NR@q8a9IL3
zzfn_rvu0C`AC>CP-f>9$57!u6pF(#x{j>poW}U_$^F1Iu)!9)M*V~fXB2R*IM)&=R
zSAQ&}EhR<m9-a=}E@b>l7abpqEL`i5L{fJoQNZ|2SN(EeJ?oYUF`e2hSKWwRFLi1u
zDt|~^H67i)k;@3qNA~oZ=b#9(2yL+tzx~e3XMC`7vCshL(l#d_>IKm+7$4?^h-o_G
z@CfRKh>%+Zvl1hy#UiBc`|%Mff^L~3BdEjmIEf7OEMVd{8oXJLUrq2&9gOaQ*fbO{
zF`v_f%X%~?2oW}OEiy)hC#qXvIHiEVOZ4qNJg=-n!)da5z{uy3JUtlFjfth|R<jCq
zXJVNOu^tbFNL(8xu`(Fy!NjUys3*gbZQ7nUls$S8hqK(MY%eBv6DQYcflrlyTC<8*
z1Wi+{$4?>HPX>!b%uCb;ow(Sc$%yrcRS*;1luycfv@_wQCfwVEuh-#Tm!L~AvCE+e
zi&_<ZpVO)skEw?Tj<M=P!BOMAzBgJF23N)d^-P;06B%z@?^=BIhbY*lwwu%=m12G5
zrD_y!T2IY4>;0D*iIO}udR|aZO>67Npf{<ObD`3e1zkWg^3w6dNL~Sc+|QdS#xG!W
zRKs<vdek7%XnRvj-whnjG}>XkotL4z7XWJ|L8OD24x-aEaQm!4Xf;B8*MZ<u``&{u
zXZ@4c^m!b_i(vHG4dPEC{tMy~^u2x?5OHBI#Q9SRKX?u6w-Zn~pgzB$b}}Hu`qMnJ
zuP$RJaPb|{FM>N@Be1S(@n<DOI(ytc4*+?IBC*~yY5af~hY;Yqqv6D`u4jOK33k`d
zLDcnuI1Hi_5wC!l0-{qj<ohsmpoItx>;#xa;n6i*{6n|v2!yM^=<I=gt^)D^5c=1@
zG2)SE5{d7P&Y(ow1ACRCc#J;1fPAE)45GKW(wkqehGbtn@P<;K#`?j}U^fBj(-{a(
zfkjcp0@_Sa3qXS+2uc9-Bti86U8A5;fc6vgB}(sZf(Fq$mg!x~9~1l?%K4ar38Ggq
z|3vU{z~3nav!NgowcO_j6o^Pta7k;%mgDM1@I`<-0`8LlVl)v0LCjQwBt&mE9z}u;
z0n-Zs*dTh@FTM14F~LQEucc@!Kx`snEr=J0xEsV_6@#Qt;kuJzOaS~j@l!yEI?&kp
zv9_p2Tzwt`)EH2o-5^F1&s6-U4r8Ur3LjXnb8plERs0O_RmCqMf-3$lBB<i`f#|dj
z@~Yy$L`YTq_t4S?4c4o82hFLo2dav13WWakCr2O^qRUDAmU>rFqBDW@p(q}sPZkjR
zWjJGl$<Hf7D|wKtTw8C*8>+_*?zEe%_y~bzT6Ht}>DLCR8%kRbLtQpZxggp>dhAg!
zT!&s68%;w<Gjh^i2@%GSkdlM@XsKEBoC?m;Ij$lcLY||aqzLq5vY)*Ot2v_x+V{xM
z!~}pRw;T1LB;wj3#ur|UcEFT9@j8a_+jNxEJW)lVciKib1*x)dr56S7w53GSGcr?4
za*%>w6f5zBju5|`#3>WyAe4(-PSQayWrny<Nykx^%SgHqWwjH8vga~o&qU0lYFCW^
z&poWf2M>n$10Y#L^d^DBPEhLncf9KuryQZgsl#zR(3w7OZb3m;+!e|xNzY(ix)v3t
z!4)zOd_qi<WuRD5ae8)smn@12xdl1cQ0RdmaZ~_XX$T6&uo<7FsX4S0sL6$R)K60=
zT?k>U{Gl$t`R2%Rul_i8x)c2@uE@CSde5A)s_zVEUSyo}(Xw?H^_wn*b8;z8+~txx
zpNSt3e4(@p=sgkdfZns1=oeg~_bwrNmqYXuWkkQ>Q@EmcDSG=-!rvC}ICX!RmXMG)
z*E#I(?>w5{AK%mHyJUuQ{WXz|vR0Pl;1T(0)3W9soZj#MA@0rNqpHq7;Ct_x2^SK`
z06|ef1_Fozldy;=1W6zW0-6O#SQJ7s*$7EUW*{H}lAwf03vRVm1+8m~Ew*S8Tu@M;
zVt=Sqs7pn~b|TnXvF^(IeV%jflZ4pM`_KFNycZ_-d%ov6`+n|OQq&(3ol>-4@ncoz
z`)~W%IJodkX+CV)f9_buV}TE!d;b=7?~=$;Rj?^-B<O!c+~R}KcrgBI^+lIr^{y3B
zkE~v+Ub7<G$3&k{FRqHH6`>5bOzpGBs@JO5rj056C=DkH-><%dOY0)VY3lrtIv$^|
zZjOvq=jN-jx74{;FN4*4mpQSHwv*i5-92XZQFqIjw6~ps-Qm`mZq8u)<IO4X^N&mN
z|Db;8>~>qP9;jJ6r<JcFp06J7vNprLQr!#ZqwWcHWYt);&886D6+Uqqw!L!R)#{pU
zQ~Hk{9!@JtNmKu}@=KyowQI?)aaW8h8aF0wOd5orT((y2y>XlRs)KvAdTh13&Hcbh
z?&1tdbOv`;1K=Mueb>=DAgiJgHSUDkwc6d~&U*iuXP$B<c2{*c%8M*=)B2>TMebVX
zqJVQzSI`$>=e>KiGoUNZW=*!$Ew;N$#a6j*jY*m6){jYXQ{BFQO`EN%;Xn(O^4qj}
zwZ$e!53F+USA|ZY?e@JXP4#m(soA^S6u??{6UEr?#*{p-D%`i+*@V-kr0rH=H{@>C
zI*3kHiSyO8E+i`<*-EdJ^!maZ^eY*Y_QZHHQSA(}-Ob@Nw~GGa&}J8>!R~US#s#(1
z&DR!2)$uxb<9fB+Ep}(A0d77JQlP^w^;jLEafNfS?M`;D`bgbl?{Wrrb@~TXoqNAq
z@8-HucZM5Ag5B>7>cTPi82^3T%~KQHZE6|ZNON;3zH7;oQ`HZ)8*;{UR!eueY4y)T
zpqqMr^$B%P9Kbuv-EAK}^UO0l-J9H-)b==d<hA8wEUapGxxaPqQ?FXi0NdUB%u_^c
zao=#m&X9l_?DV(YmsKYx#hyJT`tzx7Uv=MVc>I_`fVSuu_<5T9sJpq<-_t***pIkV
z;lb|zaMK`m(A})65U^)d1WvC&s=HIiq}8Xvmm#+=<TtHGc%DXFOjZrP6Y7H-++wxW
zw@V$n0SVG~Oqz31XEz0}0f}k{^ml_k?tZ5J>~r5zFOqO%oBPbu>ZlK)Q1{>99&o#>
zh;xbU4DGD`>%+N1>gF5VZ6#_MxU?}-`=ouKZt)}Me6Rw(LOF8#!oYGEOL6z9-}%YF
z^DE)iIyfJN_SBzaJP46x?&ofl@m^<OSLfocDvE6D{)p3x@%j+y^|||*GcbTKB07IW
z1_!-G{mnxDhZ}!J-0XIvD!R+9M~vO*ehSaHeW#?UuBZz?!KuQ_BWhwq^>$GstU7?$
zTC0v)i14Kmb@S?oiif%rehK(xA=EeBh(B*QP+b>M@1mx;+m5JHt0K;6%v9NEa4cNO
zas~%yt#lK7zV)coCsL(s9vXC~cX8J_8J+!;>iswSZc$EMr@iT~r0-9E8S?4z*+vD$
z%U8uuY|+AbN&4B2*N3o|?aA!ySJieXFtw95er+c*m>&QC`X(`SN{pRb(Q=?66u)KE
z`)*c?$#JsQvVunLIOOOGZZ8azLxF5|xVu9=UHzc5Lz4oY4BIuIgGHhl@#!u0Qdfx{
z8p71WGoBeQZdQf@bJ|4D!jM(fDu&YI)dGJgFh3Mr5=y-$6etV@t3m;1Maaqx1+EKO
z4mfp=9SS--LH{C@>dX!WN}wzZ1;TiZ2Rk(s%)#ph{rXENbskg=q2Pj009<(}u$VEd
zE(iq{Fkan?aju0u`Jq5jD46H{tz>hMT?DK4hJrKknj1=m$Xxd0v`}DSD2Tr}+6jJY
z02l;MUJtP;T6zLYgQ$Y-6GDNNp6#Gujr?5{3eJJ4_3R<1G!$G2yB={usqi#>7I3zP
zg3H<4*-&f<1=T?07UxmuB4iGtVhLXGFFfX46$-)#r3WR8V?})QM$!;=>D|CM>e73i
z=6&@3rQzwlm2t#J??)L&U3ydACp+<yrw+)rvdD^!8s38!NrJ^+d9DSrtsGC?4*+8o
zP<iyyAJcNl>_g1v;x9il@pm?UFxz6YSaUses#sSHQ0aOSKk_NPpVru=_b}vs$BMf2
z9?m%8qj$RD>78MCdS@G+-Z_S+cY)#Qz0mOVUSfE9*BGAOHyNJZYYk8D&4#D<ZH9+8
z`Jr&^z^_$2ZiUDLMvUIS*4U-@5ynxM-ZZ(^I-$ti<M_cUdcDC=B8;em_{Ce;r8Duu
zTB~1j!WQiZJtgr0G|4)8f26TX@9!B$U3$};8_CeyV9FZ$LB_N3BYk=+ja_;VWE^$r
zJxKFDdJi@{y=k(ob#SPz*=#s^->$Js@8QUul*05L!8n4mlQ6AfczUllJiTe!h2%Z2
zlHCW{zRf;*4`$iTY=@TJ3`Re1L;qX+5Uu1yCVqfq>n}8<*YEIiteOOR@6|ND{)&;M
z&suiKw}nszhJUWL`Ht0b$zVuD143B#5MKM+X#Nu_@<@xg=bhc~3dzP<n|*Pq7jN+-
zJ+&wIig6xA&vRRm+n!sj@C>t}wMp`vgQFBZX~Lc`VefeogVsOdhd|JajKQwETf1`i
zYBJb4!RUA<--G`YG;C`Y&68ZNA-VUMhV<IcFw1ipvYzo>aP7a^VKSbk1zU_utwix~
z3X$)Juj7(kg8$o>6y@xH&zXNi{B!&eK6=Hoi`kwoZKWnpxR^cfc<REXRzEK&EsW=-
z7REFEI!qp6)5|Ez;`(hN6|J~Hnt4JrqeYhbEKIF&VpB|N)!8!a^Ph}t&lXrr`e!({
z^5{jjIaW3P>c^Ax5?t%IBsdxW1iyF$dE$kL($>|8H%Hbwhfo@K#LvV(K?+Z+q$DNH
zpS3nc*@4p3m?FqiY%LjJQ6ef+{LrD<Lhn2ALn_hhVTO71qP?C7^puNW9=}!*OFDf5
z+C07c;Ro~d8qP3}UN>t<X7k#b|E{ZLU5LpPm>CJ3ajcu=MdOa{mh}vN(52VQ46|Rw
z>o1z6*Tf|D(K9f5xUJ=}b8u%aelYIYc+R=_V2EEUDvT~(9e$ve<8`Nocj2{7L(lA$
z{m|gy2SIwRVJKNF8_EK$>ls)GWldY^b|`<{mKu?aw8RhA((5XQQaEy<%+tE`qB*`+
z(O(SZQmyMbx(rHM{?{smyP<qRQ}m)a!d7<t1<Jo`UC$1hDcpfyyjA06&!jCx9Aa`w
z3+b6S0*!a@Yvn3UCQ^%l@-%G=RrFM=v%)jvNg&JOz9p~vZ)r0~-?SP3qoMc-o4Cc&
z4M|IRBjZi@wF*#6v+Yeywk|ne7^h9iAz$#6W=qMT*-5gtwW(sL%keX&2-4g>N-4ca
z+UR)xUWyWVM@s=ENHtxnVol%J92P%%x&8w96Cd=x8s<%(jnLou`1{**bQaqPvo%%z
z))tcW=8&~Uf_g&EqE%xWo3nyw$E_jEVMBBpj1f07bdHV3@TppKlu#Rj&cE@9RtE>s
zia3wf2Zqt!WRF=|Tx-#>F|F0KiC)yaeStR2dkmI}@^bnit+=IF?PJj)0G<#&oMVT2
z8Ewa<?fo82a`OxI{<2@U;uq@!Iey=sqOIPZX>BRo_qM&$4)C^`-p+K|72Z~-#hBT2
z-tg1jrQ<?8lN>BM^P)B3`Jc8^@}5cBV@)8l0;{)Zt2J%Wrv2xvOPj$(HygUN<C>OE
z(Qa#6mP<RWX}cors@_ccc+=9j=xFOHyl4lscM=xupl+?E)nneyLRy@O<!*eE7A@N|
zOW$ab;KYR%t<p40MQIHntvIu2HJZ2d%%Z)4yegcQdV0IwX!Vm>K}%}@^(u5)^=I}v
z(K;wD5*95EG`k&WS(LYyp4QQ0Q5Vj1p;bwYcq7FoQt=iNTA^fC*z#%(ixw*hfxT|D
z;LuxwOY2khVpUoS#fwvEmoCCbn_^A)=<GX_Ua}JP?pCFb_VsxIq>Wo9EVM7##2Iao
z_M(!O^Xm}MqD619BW-=;*rHu<I$CG}xDFDn?=z{ws~BmepQq+!g|s`}OE%iy%Bex?
z^1Rg0tLbR(rpH*c_)aH<)})PmUeZ9zTb4&l)lB4TIojIbr3URuF^TlRU=Q-Lv?tms
zX}_6HS6Tt>#s1@GrA+hLNk_}6WSJSQ$1=;uXfYL8qSuAd2jJF=q-b4}S*nwXGr^Wy
zw5FvELF<r~FV}T1uTv5Q)w#X!({(sn0P}c9U6OJ#e%1Irir+T;yl0QXFbF@d<4#S(
ze*CC2PW`xN@TT$6cKrT`-z$(kjGy=Xe`Wsni0setJKO$4=*vHdn)pF<yQur+JznpZ
z{7pSy@A+Rmbwa5l>Gdx?dE%(+==B>t{(V$f!%@*tkCDuH&wZvh=ye4>J`4T0j@S*+
z4B5|G$y5J=T6JoeDGt5ofAKWVq!xP}ev}s8^S^j3EZ}8QQn|LSq+8WBWz+DjF`d6P
zdJ?T#Cy(MLwc1o69%-5-Pf2ZM>#E7y%i1Qhig2r@4vUU(3}=<ayP>_xiOz4~hO|;|
z#`6s7Hd+ck7GRj1Zw`mFiuqvFvRUC8KG;)hTfF}P#iV*VFCf(AoC~*jnN~g(6k~x!
zS!8*ecBJ~MnyP3uj-|pDf8M~hf;RJ6p2IlJ0WEG7w7sf83gA@}CR`C5grjILHYd^Q
zRHMx?lr`h5ae}f1l?sXoqW+OKaZu1<K}Q4~6ZEd2<AP2IiU~R;=rciI2>M#k_kz$v
zG=8B;OYJLK)uK^?pn#wxL9`@7%k>fz6x3hPAVEU}(b@@ZcBG)ug2oCOFKD8m$%3W{
z$`Uj~P`;pff))rW5>zUvLQu7!h@d(_v}jcOevP08LF)zGDrl3SI|SV==w3lv1wAC_
zF+tk|Z5Omd&`v?m3fd!RpP&PR4hcFe=!l?Wg5DK$T+j(YF+ryUeJ1D&L0=2{UJx~B
zIwpOBTtNwf0)mnR^%T@g&_zIlk-L+u%YlY4ngWD&7TjzgG_XKrKq-ut18EbDK&i|H
zP={+@odYzCxzC0BTG01`Fdp;5A;=Y!ASfUxNl;Hgy#xgX^%pcq&=5hXf<_7&EoiKu
z@q#7_qOq9{<upNAf@TQH7c@`M0zpNBN(EI2sumOxR3~Vqpf!RT1g#fztDsGS?htgh
zpnC;v74(px#{_K?v|Z2+K|2LKD`=0PeS!`MIwa_@pd*5g33^x1aX}{p#RQ!a^qHV9
z1br>&dqHS^y!<D~6_g+-ASg*tPeHu|1qJmNG)NGw*wZ;DRnSO5qXmr>G+xj|L6Zed
z6O<)rhM;^w^8_srR3xZWP=%msK@mZ9f>sJzBd9^pdO^1e+9c=>L3azfSI|~L4+(lq
z&^AHa1?>>DQ_!=5_6XW1=zyR@f({EhBIuZ)cLg06bV5)}&?!Nm3Hn0N*MhzmWOeXz
zginwwC_zv_P?DgYg7|D>)V6U}P`Lhr1_>G>C{@r%L8AqY6*OMZL_w1UO%s$QXojGC
zLGuJH5L6_nR8WPWYC#b}b%It3S|g}I(0W0)3fd&-4ncPdx>wLvK@SOfOwcw#+Xd|q
zv{TTtg7yg7C+L8nLxK(qIwI(ppmzlw7j!~UOwcJop9%Ux(AR>#7ldy<Ui~M?6_g+-
zASg*tPeHu|1qJmNG)T}8L8*d93K}hFtf29NCJLG?XquobK{Ev93!-(ty53zNs7O$$
zpbA0Nf+B+I1g#XbMo@#G^@45{v`Nq%g6<Y{ub{1h9uoAJplyP-3)&%Qr=VvA?Gdz3
z&;db*1RWN1M9?uo?+Q9D=!Bq{pi_cA6ZD0kuLXTC$ifVUP8pvdS5ShWfS@EnJq7g=
z6cp57&>%rW1f>cZDQL8yv4X}6nkZ<pplO1#1kDhXFKC{i1%iqMl?tj5R4phXs7}yI
zL2Cpx2wE@bRzaHt-6801LH7#UD(E3Wj|ti)XuF^tf_4geR?r?n`ve^j)C@G7M+q)w
zu|_bWmFFWFT?KS0qjJ&xCD175egmX)&eMWk6Ld^a5c5P@ZXl2zlQappS-3tBx{Pfe
z12mdZJ`g_oVBB*9&=rgx1scQX4M9Hujb(0rXMFHw^d%6@Y$RFNcEN4}MoWRlGrCXE
zK0$N>bvo<*C|qC6z-bfXfHGM3I-m)R8i91I{R(IzbAJTNWV90q9z(C-AkZY{&cSS+
zHZcfDn@9)JCME%C6L~<|#O**=vDy7VI<>w8n#^1`%miw)mk63As8Y~fK-%4>fpn_A
z4y4oaKcag9W)(HpA4tnh2GV9rg=-RS8;~|}NVroX*P*+oI~YjYG8IVMTq)eofwV2Z
z1=1mUNzmU#E-}foWfYJ$F-N#1!rdv{HsRhD&ey{;+aG8I$K<ub(f61s%&i2vn$c~-
zJtpV?&{WoK2AakQSCirPNXm5=0bRprEYP)#)&l8tdju$pxfg-58Jz&qe)$Y2hq-R}
zRIj-Ufi!oipe#Y(0_C!a5I#xFU_{@GwEs2&4PowOpplHG;2X<KMxO)CVl)h2Eb<sl
z1IlN#1ZXxR`j9e*(J|pZ1=4ap%#Y7y-BchQ${9d9lr=!w>;pjaSnh8?*D*Q)r2R*q
zHRduG?B#|0GN4h+%@uCBaQ6wfTe$ay`$4!tm;=`_nE|BjD*)1YEh^|XL5~An&+h&i
zNSplxNSn>U1ghpDKw9oMf?fjBa_<ApXIoP6ZD#?aIf9k~X&*c-$RET)3YHrVw2)D@
zphZAhcav~00u8q)*L?_7$mj>4B1Y%;_0s$*pfGdG1l<Kx%-lyn+QfH2CCr`I4;xV!
zjRMl)oi6BlK~+FH96uLst8j+}H3R8f=TF9WRJQpNAZ_zRK??=d3c5wmHbH+D^o}6A
zzh~big0g^gdQ<_Gv%9wm`U8;m{hNZm0$Rj!y$5(GLr?*bHqjvHmq5Dq-Ug&=?*l*;
zY|BZ}{RU_lbKM4dIp-1}?Y|Nr9UF9~ndY_vO=J@XMfVucV&(>1<joF_0n+8DK)4mc
z-7e@iKq+kYMUi`3bmO3d3LNbgwY@q-X@b&$&SBlZ;V&Wya`eqjqg{Rvy&}j53$<>X
z>!EIfdJ5_<XqcdKLCXcv+AnQi4?#l((ULE%TPA3^Ao_Bpb(bSx8m$xbkf7~?o)Z*A
zk3yU1i}qKey9I4U8>+eA3VIsRsJWK})pz%}*=Ucn?lD0bXh}48qo7X&J&lOhy4_LV
zYt&EB<AS~tbP4KvEjLQg3_;JK=GVF(2)YP0y5?#GZ4opH^|RKUDd+`3e;0HS>Rl~2
zHRz$0g7yiz5jBmL`;#E5b2K+vP!&qI=2i=85=5)FwC*Q@R)f&o&jj5s=r@95f+nC`
zLV^5zM$qLbWtuzxVh`mAsuT37pzj4;cZp}>IYIvt^x$Am_jiI033_^{r@L3se+Ahg
zPj{rC5<yQ3dP&gV1$9Kh*CDz}P_Cf)f;I`dSI{eh{wwH`RL{Oqg02%(Cg^q`6eYy&
zF9iJx2w4l<Ln8Nk;dTi3f^e@1dP8)N10kcpmM=y3J0R`a89|*<>1x-`1Jb&^1@#r(
zkf1ElogpY+bPIrVOjZcDM7RyYZ3EJ-Z5Omdbl(Khwj`nn*K*wjoeQM>oDQVr!h#M9
zdJ#>A)-6EyPTLX|R0gDNxd}+i-74He!W|RtKZ3p#-Hw-fHg^WnG2R<U+dNRvV9^~Z
z+;l;+1kD#z1f=a-Ca6Jle+HyObeo_@MR%KUyq%fz!84+}Pjn9eX*Z6E?gxTC5p-J6
z*Ff5Yjb>PfvJ;T@OBX@si*6s`k_8PB-OGhb6Et0PbA+2EXujwc3s){^C6M-CqsaYS
zxO;_rP`KX<_mpri33mWUhwYG{zlrYq!hIy@GtvDLNc%-y=EYS<AZ=e~LFbEZvY;V?
zhKt-NK@&uGig42f%@N%~K^20cf^GoPepxN(R?)pv(62;yi=f9u_env|iSCO)I^?g5
z?%RSs5_C$?e}J@!Z-rB%J^ytO)E!9Yx}L)I5;Q<`hYL4K&?M2FD%`b#@<q2$xDp`k
zt7U@Lh}>^Q?p;A$&^^>~nl7kX(EWm56Lcp^r#8_Oh<<UrHcWF1gewBl+z#P(3iqyX
z$Az<O&pscJHak+d(ZW&RHVMBt{A-T_Vqb_C8$pTZ$1@lW$@R^e^Zsry01mK?mbDd#
zPCaO0eh-FDPH17CBN@~#EzChMbdo^}^H(rbqqQ){iNUXh`3kD7PHQFsn&Zc}W_p6z
zp5ZYeUd{w#c*q`Q(>gp_RnYQ;__iahCJjY`XFZ{XxTVQF3h$qiA?-oNtdC_DkZ8My
z?t7ufkDsz>m3PN>E@l{pQcc-C@M<SwU1O*YEVB<@r+m=%nQLS)n1DTWHDddx*vNEb
znQZ)R@77X7kp;@Gh1c85+-#_LmI>l-n`nj_n=OnC`Bd4oa;5$AYr|sr0T~>&an=(m
ztXjO7j`PFQ1wUnXJxf9>e+QGt;RUil`{X5pNRt-kuYk0xt%afWGTx(2ebbKV(kfsY
z_HD<EZpU2Hjwx-&&?*=2(eUT(nETo>zi-F9+>Uvx9doiBW4Fq$TJwT-%%$y^Yuhnp
z?U)<eF}Jm29&5+^sU1TrQoTp}@K`(MpY53M+A-azfSO0!6Kcn#wPUi|F-7f|8{08I
zYsWm;j(Msb^LjhxWIM*DDx^&)lG-st+A$gJm>KPuigpYgAmu$e#_nmy{GlE5YCGn=
zb_}hP@g8k+JXL$<(aibnn3Q%*Mmr{_9kZ|<Q`?TARV3b{U4OhCv%eif>odGZoBF05
z(}SvN^Jtk%+A(})RU4UW+R0qkhFK0(s3^QJS~9<2;X=B|&!~8>i@_CTICa<H;u=~?
z>uKQZKLe|y3+cX<+E!{h#a7e>xK6#KMcGz`<+#>-99YB$RJJ*mk=RyeC6Th_tR<-A
z)FRUH&O0J(&bQRGcj9KK5ciyiF=i#Y-6@J7<y0dQXno?63FZIaaby-%>lM^`o%Q@S
z9Pj07OIe;$@2@boSbL<mu(~3QBRf5kR%@Rn=Plqqi#B^P&SJGv7HVVLi`YzOsZOsg
z5yDu23%GGwp0HWuoT#)Paj>W`q>USI%$+4-Ik9w?nMX{*+VEOjm{LS%BYPy>iGuqQ
zGV8F0y~Rb(v%FwDmu{u<<c*FF(@*J4;k&nfN=M(B+eT+%O_eM=_gvt6biK9c9;y9)
zHk(ybP=b5&JfT?yg;Cri<tfQ>y?w`H(jzz^v{VF4ywPr;HXI$=cvcd43C{OsObb_*
zL|Uww7;a;$zWKPV!yG2P>BjSm31&fMtyefr*3GOe(tDCTNs~mh-$}fQ?Nl|9wqo8*
z!hBQVS$68XG=54ay{L#TQY@(9yHY(T!CqtTTx><*?ld|<O<#J{iq|`<_!h@@toWEh
zp;NJKJP`jA(E}e)x?pQX8++k}aLpv#UV%F-=$aGHJss&kp}{$fH>r7|WOFHQKbg?7
z)zH(@w#+JPRkqBY2~UFZ0qrm2)9^e}7Y05V-=lKEybVSCmyUbfmg62bPoHlBq-!rd
zBAqU(*4I0?O;%GS<kIoH?M$_)FUSLQ<!@U%b)4(yr2E=D2PZC^j$=cs3g?7ts)S@;
zaB8$SfQ!0NF2a1nlo-&p=vjqDR{<hp?#lKYrYKCWrF$lDClxL`Ux>?|I#qK?4ppTD
z^)qb5s9_^UUp8VyYA`r*IC1*#sF5RCVC0C@5u+I`=rqlyv5RHBb&vjniPH(})}vL@
z3kLBW3>}3*Ye<C?R4@_=;@x`0O8ief<3Y9_wf>Y0acl5P!JKF7Ck_4OqJFIzVE7|t
z7$!qnJ>Nt5zyKU5@H0))4KXY?0+Z0Ko=4Dgy$_#^hajx<kQmF2#Ds3Ehjt@OD8yGl
zBS)iFmb(-a1FfDB81Rh<W3QNz<Bl=;Zxp8GT0Q-Ni<e@b`PuG{ZtE@$#Wz51=h<?X
zw+(L)_HDSqvR*QBaMHxfF#3ckkBj*G4dmK99Dg+9*YYetc>l1fMa>9utw*@T(F{(v
zHH2C{kek`~ao()l`cs1%_cqQv(K!8hR;(Gvb2ZgYZkm34Qse$vjkS}r%R^bQH^J8L
z3$EEs^C?!eUshJRofmtKWM`h(@9X~~P)<3%6X(Sq)1u|}tn!(8v3pn**ckp|?)CGp
z+q-e8MW+*2)u84L*5dqgT$LRxEU3hZ`@w}krPM(z3KpYG2bYyaO3NyP1;Ge9ie7WE
zkq#BWX-IUr2>X9l?yxVLdN$>{O*y^Ry%8C>=7wHY<l_2M2|2L~$$Jyr{p0a%4XY_;
zms`29PM&|hZv1TS_1Epq&BexMEV?Lu-nL?&A{h1i;8~-&$%~(a#{G%UTVFO%Ub5V1
zDXbs%4#KbH8(%q@u<>bfV?zCR9U@l@+q0qmBdlV${Ilr4vPkg>6tnym7A)jt#nx*>
z>-I!nC%t!}2je<eJ1JwgiYvI27t8Z}rK1o>>EqOGD_n=OGi%G1A{P%GFvBw4-uZ<s
z7tywY)re+&JMH3vIvg7gmA(}mHQ^%ki{@ijVA!I&Cg(5Jy@^V?WTTjFAI2e_HDQ`A
zfupUkCrHVO6UfmvSv&=}IJ~$D8(v%J`9*w1HIbCc1wp!mkea4oiv|waFD$L8s;r9E
zTDg3~aFA~p4lXWO9y}{=;Fi;}qVQSSqOh#UqM?Vyw`RaZC3(H5xFQ07Rz$JyZxK8%
z`}b?ZOR#lO6MU@@2n)wKFM%XY=Fv4D`o5t;ZjEuyvsM=CHh4a+_|gR2<-k~!Wi6Z{
zUPwl3!|-GTi36cUVK@{Cmmt*3=ND2FY%PhF6)rOPl1nZLBA0uv1_#szL3Offs+N@%
z1+C!XGBg^MCAvtkkAv1SL{&*JIapO3M7q?Jg=@(Qqgl1c!d2J0yNf%{qtz&FxLyR3
zn!Ex|SheuT;)40OMu7KQ;-0-4QP3Id6e%W)aPai82T~qNo33-4M$C#m`yCgU#{G>G
z64vcWY<QNkZ{~^p6DCtZX_}sp)sz{?%Fd15ZUi%rKy3Y;q&dlL%sf<o;}JWt;bBr|
zp2*3`niVVaBoD0H6RB#N-gDi-Xm!)fr0ndRS+QxJ=HaH9N1CP|TKC5O%tJ72ZS>`A
z^u5@axhLXpvdG?32~C-Ynx;eUKvs56dH38{fXxPB>$RjCJuoZw!?$P7%!N>P>@*OU
zd|k$xGLv$$N?$=~oE1B!wHh-IpWFb0xv~A4pzvOW+T`S)o2DPg$}0Ucq_bnc5zTdn
z;V(9Dm&ZkKZpu7@Q0B$zLBU}-x$a<M1Dz^HewukWCsqcX#+T~%CA|1;pJ9hDKHQkO
z4~DX+?z)Bz?JKuYCFjM)v#m*ph;pag$tf?-iw$Keh<ey5Uy&EP5Xy49ac@)RzORmD
zk(mS*=$V@rbAVtks&1-s%AKrol^6T;8>-Lu)bH!rG<{!FMpEPCdD%^Ke7UhB(12f0
z<{&z=vrB0sU{34>O(GuFQFGRmxu+@1*OYk}F}#REGyQPm%!jgLce5A*_fYwntejY*
zHdX(1hs1^#$Z4zGF7KQdTcY_jt9n_94RcZDWx*$3PU>PO-nnN0J}6jJlV)_xYFgpT
zi%rzR%_AT;>>#TBE^sg>HdND%FYY2AHXe)h0&()brpyC5Ii;V2%8GT;BB*_@X_~&L
zDcc8ct~(g%K_1Q|4`;>x`85X?9)`sU+1c>)5lz8jvIQ3J1<{<2)PH5tg?963YG~LI
z8!4F;dsvH8%*=y4JCWG17<zC6UfIoFS*@k^XVOkgi-a#BiRpo+bYK1PAK}F*^{af&
zsw;MZwi<8Tx0^aejYm;(;M=R3ruFpI@9mi#yA1Zso`ZallNB4R?Yw-IZ}qXJ8~1IP
zeq{a6CX*L3_fQD)k(Mq*<}_V*WOi;=?E9}csJqESlOz7!JMhlVrl$Qv=$LlBlmeyO
z_CqY+3z?CV%_`5&i|u4Ch*Y$x!GBy^*-Tx6oE)<17p<&%4-ROnZUWmhVRHSxUiEvN
z#tD;4_n;vx?~oTOWebpfjx_GgMp4Pv>iWI@QrdKaygP}RK=X?~c+pPt=~=Om<|!t7
zQ<#yH5#}6UZsW{-v92weKTu6@<6-18IvEf>fb;Ph_Rg8;;n>M9IYP*adqJ+hzE4(G
z?wRPm*c&YxSHszjQ_s|YV<+A+4!Cjp*4)yq<ome1*l$=ap>gk-=n;7SS6T_h#tAmm
zO<KJ%*SB$kgNgtdF1Ac_P1Cm`%Vp=}#fpv41i!Xq7SwZQ1Lwu2vR0t^mG94-fyXJm
z$lD_|jjV(mLRqQdDT<q!fu;<~N{Q<pK!+0L=Vr<a&7G-qWtFBPfM=oyVqg7N!u%ji
zBhGSTAGL7*M|B3r)+f;2n0Xu}g52CAA`P#Tu^W$Di9g#9lmnkqb+rWo<@TBAajJQ4
zW9eR`H6kz8z$(O&&NESxglzesyjU4)1#_W76*d>D+4)HG9Hs-!uOaPFf+!!6-^XYg
zWn~`wd$6ZYTz9VcdpiOOUGj81^c!D%@tZ!4e;)SI#i+UWG^HmsX3d+MpL1r3FLvq+
zj*8|IxUxU<IEwY^=ArnDI&XrBt%F*Ga>!pe*p!bRfhKD24bH}_!)v~E5^u=^k@)-`
zD4XID@9DiSKb+Xm6}C1WLy{xM#M0pts$%va-4oY+3D2(2?%n(^_VhlBD>TY?bF_1)
zc_@#g=9vPbnVKN@sSl_>B8CsgMu@K(CL`q$L;Xq5A-!{3^oBss#DuNc`ma^v-t+eK
z-P;_19_*Y0a}={5oR(ZcUy>;YM53t4)?98yFI%&!x4o<bd~*ZYf~e);RqP3vK@EqN
z0w2O7qkj!^*8WUt2d(BLco~C+>@%ZcH+xn`{{#oC;9zd7Msv*tsGas>G^L;Bzf*Nh
zYbg<(4X;C?tCWe5_G%~cu&z=<YzJy5?VaX)ombYI5G86Sb{$4P92q95nf8$1^li@|
z+5IhCsDH`L&OS37p{HVb{Bw=~PNV2C1hOffN_y;o<{POi15HZ4hRevCTt<4sPTi1D
zB0mc!A@i8cQeRM|l;P``o<ROB?~K9_TcK@h{x5|)^9b_VnPzUAr|;QCnH<@(Y4SY8
zbT$N={|{0~Tlx@4DVwGZ?}8i``b|he6zp81eWBK_|Jpw9jrtFr<|WV`c5oNv<PF#K
zhMhnB2X@||?WAK(DBYXEQMUy7`$7onP|;p|#6WKB)fU}9q0T`?a0nim75k&+(OIF&
zXArDJGlJ^ySK!ebqz@ThdL4vaI=xo0p``L3OJCC*8jEt_=p0qZIeD>J!X4Edx+)pM
zy{|d+3PQqtqB(zF?0n{WqA2CYx&WgugwUB@qp2^O^4+GH`_SNwx!RYwaS<AdH8*s(
zA~k0+51q+8QolFp<Z%xCUp|wl*+umXCpdjD<4()EFA;-?{X5`xZtOuV+uR$rA<e%!
z+&4X;*^i1Bil%Ps(i0kwCEoesO&?ItCKiQo^J&B<dSvDH;LJnZS)0#RAg`PmLGgee
zTHC8ZVoZy%II^&R=gUZXjJwf2ELU3KVm1{Vwx`^;VM2f{I)}~pbgDL7Pq``!W97t#
zT)^z6@xj+)Su}X}Ya9OgZwh9xJPsAtgsyDE5m4oEy0Si?wVOZS2EO!D1efy7lT35I
z3BXz%IdOz2-`w7!yBbx7<eM8b-}n+`oBvRiI6i=!qo`p-35(5zKJpJ*FUdb&>$Js8
z!#Flf`N!lb<ey7~GkFU6=N#sO!w#Y-auTm6hceuzUhC04Mw^SGN^R7?{)JFFxr^RO
zBGqxI&^w_du~fdxiD2URW!4HJ%DKz)G?Xad>4;#saPnS`$m+b<{VWz}{)29Be>5?5
zi>9fBohvcb*^8;N7TuYsJ+i$LmMwe(H$kTo8Z#ftja>m6j>752{Y_W%XyPeE7OF{=
zMK#d*&_62zJ0dob(ulwxKBXYGEr89M8}<&OwX>E)6ut=-L2P^*8Kd#laythxM3v-j
zmOd+wKEfoTXUz>gE$O~foZbo@FV@zOm8d`G1~Vu(zY~3Y-I>IO0;=X>2slbo5}c>3
zHH+=zto0$n#u+N3g$uz5=b6}0kpDBV0XC7u0c)vmzCGnd0adDq76kSm%ms(NF=iI(
zgSk|PqszUrr_YMaZwdMymO{{>d1ho!GOEkZqtGA&`;yK?dir8_dvdJ`X@hpbi;5^K
zDf48YM}KlXs`!2;>~pjhWtLYEcFeoMgP9-^PIy>KMN6U%ViRo>H3?kP{WNWgs2;Xw
z-8+d54Tv?&nr)nnemj-%M)bFlpr4$i_~6l+b!K==px$6Uh%j=N-wS2a1(e}4kDT0&
z1~2wHIWc|D`1R=>n+K8IGxzX-Z5K7a8z-aV6Z;tqH79Utl@2rETfz2n+OCqq5b+Ab
zycXTbsKn5-)XmLA&2t-^*zgS1@l?wU1&v~WIvXC#>Q7bNW85T``#HCEhCbqrx))w+
zl%caY3d3igcsaquC2Es*h0D}(i2MV>P1PJ)qaDI!X%4N?R&ZQ0QSmfJ_cgvb?8`B=
zfy9k(!u6&JNlg<!^P%>czBL=u6;w8=Az$vyA{b`ts3TMBA_+{bbFF4+z)uz|@_m-1
zGTbw%knri8H&jd1-+0JAZx2jI57i$>#;o6yPgN3z9|<fFoCGB&<M){DrMQ~DwRwT=
z=H|lxROUX^I%s4r(^dHlYDAFE&1A)Ko9Akt(?ZRoNpG%?vK6iKN^kB8%TRzzjAeIv
zmPO7-hi{o-S9@&YIv%1<KY&Es&@p%Y^xwt`TlB8gH5hdvbm#9X=y}OUE+FhkzF}-4
zh?czwlH}(|FW5)jq;s@oi05^CR(CKGG&13M|2oETus?GL%%Quwk6xJn7;_B@e^=y{
zEVNeWJsf7a1VkLhC3~SDcgqLlp&E|uV7;D5ZVcZZg#zWjY37c`=uV2=iGieHZy>KW
zzST6DYv>ddiKc9K<0L0*(wUkhl)Lf}azb9Lf{b!)-jqYBLOFOnyaUNeS#2aUT1f^W
zdGbh8bYJr>bh1%-95pfAo4v(_>m+R9NLfZ+8=q9%G=5I~asTARh8qySyN>sUj~vY0
zq+@gk|4_8O|4*GcXpj;~K<D`6drcji$0BK)RMU93X>!tr3}3^ZsI%Q!pFX?(3M+A4
z3hbi6Vd-)BAUAfOwxPKvXfB|)YJzIBI@A~XE5b66UV4(xb$S-CC`~JHzb8kV)E@0b
zlV(k5)wM^)Cv6x%dvt~m^N)yF_9(L1HzpE#dTvI}N7T5co9lQiCa+*97lV8ZuTTAh
z;{N~=ZG$s5H?bieb|n7%8wiY@l-O_rZ`!Yg+;OD-MJsXrYI2Tyfl(ktTXyL^h)9}B
zdk{9E9`)t{Zih0TB6Wl2v-EVpO09z1^?MzRax1i&@)1<mvntU1H$+wA=S|U_lpS6}
z0o$12jF~WbW!%OLg_#q?EVW8bd178{FdONKnm2PF%6l(uAN11mVu?^RP2bV@5;sl>
zXGXg4acMn*I4gGgWA-j)=n&nezImUyBp6os!9Ratf|A6cnVuJ*#I(~xvytcj2#k6c
zy*I>NW9H7r=(hSBcVb+10ld5B#@{Z%=ohGI=FX-ZID4diMF5%(+{T!Y3RDd&poFIa
z^-8RWUFtb2FE)pGgbz`a8=KBFH9{6uljF1*ySz3pHe72pW^QNiVIm<2h7t+|a0xp6
z&%$}@Oy;xezD#Ub159o2tlZeQCph!LBXImo^x5*|X#c^X=ZAt_x`3v2I->srs{F^s
z%zI0J1yMAb*$6+lrp$ZMqHdh5&|7*CI-nn8(KDk+YmX0!@C&xiR1O=+(9$4$)m%j-
zDZ1?pMkJX#dNwy=v|9dScKI39|7;@A{1}&!(jF$yUZZL53!oNmz6xy{k}$WFw%}5~
zU?>Ynrn^upO>PQ6g>PVJ)#89q;4m^dgQ}ilJumk8M-=8@^I};1)yyM2q-;)t17nLL
z{~lYLxK7dF@r`C1ubk3N6fJ1uo@G;T5R>hgVn!bM4Vc;a$lb`$2>Y*~MARHX)If8i
zam0lqO_|%rQ`#5j#g>wp>(4~D=fxHQ>h>EchB9R}RR<`=jse!MN<yC53xsJ!$}{80
za+7CJ38%2_CZ7ATBB3;ueA+25)=jHX3nP)oW8y9I-q?>Ha;E3fjEU=eG22L8=6`A$
za^#aeN(;Ykgpqe&av)5z_|JixjmkG4$^IlT%f}(SwC)u8_pzBE(;doxJTnShBXa@d
z0c6JJAmsrRif)ZFcQ*eSlX|!b*qUkE*u`w)1UtSB*Pc0J5-wN7U;Z<6*eIMm43+l=
zvCt6u4MOW%k04`EzSrl{<K`BqDOPux_e*%gtJbUL{U+Y@ylviEg%!@``(y~xw2XZa
zmaiA%jkN{1ndgj^4_ou0m#Z9Srelk|)>GC%+XsC=esNZ=PpMo#esN08ggyGp=|=h%
zz^mWsYG|^H^e7e(BZ}6y4}cpwM&fMGKhSel*m2+;>ss5fHP$gm;kIqZag<;Ad=T_?
zObDFpys7nrFOJ2<1r@d7<$NJ`m_K;ZAAI|&z_O9~dO2flDL$dKrTFtHKH=#FjrazN
zk9#%YTC5YoCs=*ebFEboE-5Ia6^#|)`S^0UxFEuxREz0zr-hXu_?W1_0>W<Z0PtFT
z-P7Mk=j)Gj7A_x-!0v(~`dDibn2)76Si)Ww!FRnj@z(=WTS0{TBD}}reFffY@Scn}
zWrX?k22n$A5G&~&#HxCFqiKAY-T_P;(tA84y4nNW?(xdK!0l>xvjgaaIsL8p_;H|+
zbI!4pdqw=1_$l47_@uk7+;~5fej7@EXRYU-(tR}6{KrArh4i$tLn17Ji}WJH9buEv
z#(lA{sY`skXHz^|EXss|7MbYW!@ekCN_TRqi=Uaqf#mn@uxKnc2XrNU(!~K2>`Azc
zt6iY&l6I0<8c#w!jBnu?^6fdsJM6b}#XBt8vn62h@txxn;>o~y=h`hEKEFi**Jj$b
z_GPcW@MQ`D-8+PcqF5vU2ieXG{jDOh&&XDaAap2V*e88WBpP4#i${tkx7bE0G(L`k
z)4#=(gCrZ!Vm&Dbwm3k_i&|`$(!IqF+`jB3u7eO>9I~%W@ci8(bxA9iAT_v^OHdB!
zr0wui+dnkkp2@xo8Jm$JWHZ(dc?m?`NsULQ>jwE@8c=wK_qK<1&w=s$_}QGhM)<8^
z-AQ_6YaN`DLT+IB&q$+v83Q;nx|JN#;BqpL;z8Ot9fvf@QCJVnvG9<|jO0XGD_wSc
zT#Npd36z<x>`SG^ut*%uT3=)B4^_6bFbk&%2Pc^0gl)d=G{vm_DztDN>f+_qHB}|G
z=6chiBSM#kMzP6YkYAQ#$DyvNv6NXYX{pBx$zo4A&367~cSqmUUp)&aIy-OM<=Bnm
zBwPMUoFwnOW3PmslkD>skn&x7DVEPT$!;8Nh;rUDx(WU&EWn+_M=?8pH)OycuBpN5
z*|6ojZ>S`qrWe#MvYg|F>glJ&BYM51<$PfOx*OTw%ippL#Bx3~Y;V85HGWb7>ct|<
z`N;4W`YXeAk#yLDH7J&I!d^a*Ea~H~oWUy@osW%UL4Wl`tn8qLl9uxiyOzcJ`zs1+
zBRRBc!gBs;U(FsE<gczNtE$1OVWSZ<8maI@Nf}&eHg=BoS5Dx{+;ToK)L1xNg;g&e
zf70;d{rWg-=ajvYqj932j-R%i|JdKKS0?)_d0{axt#Cd!#%A~nTCu0?-zQS&@{wS;
zqSkW0u-CF>^Zc}kb!nK`3D~3L{MVRY;IG3<)<TGWY5$T%i~Lwc3<e9CE$1tnHdr{x
zrT)6C8r(RJK7#YL{S*sU_^S=aqTd+NYJas(F=oFtY{Xxu*$Ji{vz+hjSJ|FAf3>&V
zmW_OGjI8w6d3=kZA8b0kT_vxv{ndIcB%Aq>&8XxC+h3>Y79(fu|G*uUydHX#y4Qrm
zMU+D<r`sUnZ*9Y)m*d#Z2-evIM_Np<LykicqLS}`R%T6&<tXPXte8~EciVBzl<j>^
z6ARpH`^_=rWTW4(TWx=InB{bIGTBQH!D(boTr?c-EMzCQ!Cqq6vChV^?GQs$m!K<v
zQW$V3-c<4qh<YrGcQxWWZGWYwacwnBbaSYns^n*Fe}TEg!Rg_AizZnm?}06|P!ufZ
z9OpDLno2$bsad?d*>cWxuHw)ggOwiF)7bVd<Y@V><(zNqIu3^7D;MjYoC^&3h3#M1
z>Shk7m-9Q6A|!{y{EV{2;i@QdWN%~b9S&6|Sd$&0l60X{%JFiy<EM33bSDNvfLz$m
zq1r$tA3$eO*H`BH7xl_Tlx1B%He{3p`43h~iIBNAM(v-@QXN{Pu&fEaC#-2|B|gHl
z^dMD(jt^xrVs-GjK1yWQHw`J?aV-9*e$IVhIuZ7%WakAa{MFOLk<zN7T1)kJ{uM{X
z2si(jx^;f5duK-C3RlvPJBMtFay(EaTQ{Misy1xl&eg;YWZH)UK^KAJcGr<ixc<64
zbn75e=PY0*fr>NI1WUawwcNRZ$$-Bum->ddto1G?lKgd(P?U4au!vgS;QWcnp8h(D
zT}!PrQoT@=D!F&4ZZuR7exkKzIbkgAS{g3W238sW_1D&7EjZ4=udvi==P27e2=0dq
zv6xRgxW<SN@#DDsrDcU-RE4N;uo@c6!^#Q~T{jttR75c!981yJnQN?$u(1pMf!1bD
z1KQ7|^(azUuM3sYE|llHl;96UX^WE<nk_<%S_{pGR-)^>LS!lWw1vi+V$q_A)LLW%
zT)0WJo)j%Y&?3XGk4{(BUZ7ZMG0UEX{&QeEz5)YktJ4e|AZ&MBKukCF9hgppC#&v?
zT49}8k`y^lnWc8cwY8L}mg-?RpMP;(RzakcS1_t`4C}`Ihip8TEpd_);&AD@rFyDr
zZrKB<eX6S`VzHv7&QrSXM{c<mEx4u5R}Zrga*ElNqk5^AnL=JkFD#_$N%b}q^2$}=
z$P5f(v<EI!AG0Xs5{!jfeAY*GLY3|$Bb!XD&@Khl0H!F5RG^xzLLa5CN@p&WxZLH7
zQRY+uGb4#HWhGhFF*h1zrJ%B?YH=lds=sl3EV5!n7+Y}E0ChVHjz^Y`*3@9dBh^Hf
z8mOLUej<|O--vYAw-nw^ppvdrZwr)NC<VGul(kAn(ttQ6i0iun3N23&)JooDm*0v$
z#fsJ^tu9ot!2GMCPmyz$c~9sh3sEXjbhQY<d;mmOn_{fJ-Gjk)<_44EPwR7up#Z@w
zojBRmrg&`816{(#$deRvE!IM7m1zA=v<N|K2VRcrE2@gp<wmZLj;`$HRf2jItx_G|
z2HSl)ZiTWt-VI|ap(9<b6(DT8zORA1+CKE6bz$j9{#1p50GLjM6I6$;bQ2A#Tzx;5
za=ZQ;%^P=BbHc@z>e!V$jyjZEY1OGK#WVV<R>zCUuA;y^vWxH#wL6f7{x`aAGJLkw
za{+DMq882@Ra<Ir;5~N6=dZlBrYKyKvD{MojHv4`5bi+WBbG~OZG2`emP}jfFM(#(
z3;4^5>ad5yQvYXcNFpW|I~djBfc9@s^k&0FGpcAa-V~$vx{>bX=R3VJmXimgi_yhV
zZy2qhA2Siyn1qr2gsNIJhHnNqU6T7-9hX!1!-07Sawoz*b#7NW=M&umEYd~Q&~-Yx
z0MvGM%qG#|z%3+7I7=-KbcUv`iz<y{)No-wfm)!dKrWj_%LPwWq7krEjp5LEWx!Wc
zX#F%=y+DK|(SS`Xt1a||mj*U49f+f21=KR5lq#t%@FeS_N-`C|^1yy(P$Qu_M5BUc
zFYp6XsFAM0SO6`YkwI0IS%u7Tqfw&<LidF>_NY~XWbR3$2GX5;wK_m&k2=Yyf6OKv
zwI)!=6e=Lz=Yy8Zco5Z(ZgSTe0u_%L$EbQkq2}@Wx0Y%!<V5mzWsz))QtJXwu^W@A
z@z*tJW8g4T(@YIB3Zd)5e_GnTvBXi|t;;%Obd<Xp{5Jzk0u^)DN2%)is8G2+N<>{-
zRgw|X>Ou%wRIFUzY!RUJU;(fzgnig!yAXobZ}Ea*<P_JpNyI2=x{wywKMDIEkJU{!
zSF2nXk_IHHgYEkEp%QR?uZgMNhy%8(3nMZB{o^d9pr^w_X{M!2V|=k_QQGOCiep`j
z&_og1*j9-B#vBc_;NI<cp;E)&t~~Z?@k|%vdrA}6R|W~~BT75%tf_8ygJ|g%@^%8`
ze{3u+pw4E3dOmO^>W8=rxTju_GFF8)Y!B;D$1qyUgIV>WVf_9w+P!vdadB-J8U7_>
z%*EKom3}Ud{m*jQyB5$@F9&`u&b}hf7KLlkk=*Y&{J%YJ?hbU-t6W9;3u;Q1nzDXK
zY@<m?OT8wxxxTj$8OS$q+4Yh8uJ6D2n?Mzk;#&fJJ>t4zrj2ouFSrbf9@sZA0ps*q
z%hz`rVhMFskHV^I-h}Dvrx_be6w&ER*7dlrM`?sEoV0xXHR1LsE~`P+=o`?12l)vQ
zuzVMHW<`L{TC{xUtc7#u!U-$MH~ejKnkE-4-w18S>QPPm+&!hQ2Or_$8%bFJZB37A
z+GXjxR4WsD@TN=OrP}>~l|;88y1s#Am*?Ayv?kQ0$PJcnkaoxiISRS!BTqO!J&KWp
zrF?_2ii~|6rvpzm2ir(=qx%&dOlQJ(-RO=*r?WkpG45G(y4aNzbYF+IX6WukC(#}W
zy>4{>q7$(1B00yeT_C5s;X+2It4+DK<N2tzom6`lWI7Q}aE966LP4EC8afWQ6ERmt
z?Q}JdVMmz3KN?iJztM6=nu!Y66dw|A>E9y;$hL0YC4o+kJpcmno_dJ$hDuF>b9z^h
z9y-3M^hA<{ViV5ABs_M)pfR<azZwnOU)zd3>h-7N22x;-sa}_mk6nMIF>Bfk=Wj-k
z8+lA3eW3cWWPrL7+^jes8j&QA(mU;)j|`9Y9sTI&;wU!jqSNb~Fnlj>sC`NeVmpKW
zN*#fp8j1dzF!ue+u!F2_G9aH}k4H?zd+H?T0q02&JOFSW<OvE&2khvvoL}?knrar_
z`s6%h)PBsmVCZK#5A$3D#X{YL#nqPch_eslbc`p^euokEM;)4{agqb<0cuj6nf4yz
zJ}Hx&)z0-jJm=Sl^E?S>IX5}?uzf!N3f{BqtThs@e+7lWa_S9{;K#<SYiMJZ(_nmw
zo>VPu#HQlrtTSZSIGQhZZgzBq&<!$^%ZiFHuyNKKk?vMEn#i1Gm%(H4fIXeH_UGcs
zdRuqGkXJKMz#8ls11X3!DPX2c)|p91*I&!~&F1rdGdODajx@Q0jCPC3<%lin$uYN{
zXSNVyaZ{)cYqURQ+mozr=B_;_&$cl`5O0)4&M)i_q4w(!I{4UAwWtgeBX^quWBDTs
zE4Z3;ereNO5Bs#JPE+?7s;3`2y-GCqE5i*zX5*;4*AV0VxbAKVPZHf{(<G6TJi||u
zf!_Bg=YA8we4Tx^80Bm|6};76MRi2-9DiZUMndNS<I#EkB1HPHZR)`|$qTG*w5i#0
z^6h_9Xjw7Q>Er9$6JbTG=LCJG`051h%d;>}vaQ|f=hJREdg_ist*3H*{_1JrVx(Jt
zpUzq?<{isQQ0EGh01?bVSk3^SF5>}zgzsK;F7mBM2iQqY^4HQS5Y8Z@?uB+%Pa|K<
z13xFZKR48lryPV7FDaQq*ZVqyeIYKpL;PjnEN6%@lIkyGkMNFkZQD?zH8L)RGHuBB
z7MF(6aS_TJsXm<um`gV2R5&Ayf$>(yBP2509*X$tL^$Bg^sS`GtJD!Y%ZOTWFOX!O
zQ6d{>VkC^34{>ie3}Gy1zVAWyc7oMSXNx&@Bdm*OMK32q<(~)3t9i@5GeK#ufuO#&
zCMT*7r7$BNGL;#8X_*<ICK(A7W|VHrxysaE0iIB_oT;iW#%2`%Wwm^40Zve{oN1=M
z?&*(Kqp1yJj8SYk(+zu`zX(Tec<eQXJs+hNH5lgkN%mU9UVyNnJ%ZJiGuJLffZ{!M
z(3$Im&Zp?(25O$Of%CHEFUzV47iUs!d7Y_093Gu{6|8f;p_R^=^NkW2k?K&MWN{XF
z^(arvI0epPE?!hIaQnE>p&lk`1q>+Y=n$vS5EuespiodjeHf?6Y2XO%sVnoavw@Yp
ztZwG!TW6k~hA_k%WrDNBx17R+<c<2?<>W;Gryx$3df7qej%8j>fK@zFbFQ;*VVhW$
z>O86%aNMwV_c4>OunLjDmHy)<A@PmKy9CtvjiRX%YC8(bFu2O368Bp*loJ?5&=ja`
zCMTf`R$@@>JYj4~@>f;rDIw=~lK%9a$oTK~lKj+Aq!%Maw;O-;(vke6I?T}%)HUrN
zl&)#}`wOT+=P|qG{83%R9vb8?Fb&QQMMEhkd5G1`n?zq=-;Th?8)d**?0gKh%tAPo
zj+uqf@l)kcm!Ilk-3(Mq;?wBXSz_8u6f}LThqKT=P4;Wm*Ul3EFYpPStIHa{t}ZQq
z4KiS@-}GwrHwbK3)jdw{Gf>oT4<UyW{DoB&*U(`~IN}Cr?bkIaIw;_%3ym)k%M97o
zUr1BEUgJ||=x)g4IJp8jWw~Lx`>P9TYQrW?Ru~pN9Gd&XK^K;DgW-B;Zb~KczlCXT
z?fN<X0+GDY-+?`feh{YbO2TY>l?mNw)RRK4HYDmm{tmOosK@h%J#-+9dZNFQ=9Qea
zMvc#C9QJynp5`xHl!4vVXwMCk<)^h0Vf`s`oqr)0_Zf&eYF{;bvtjcMdsP+oXgjwU
z3+5SCpY7tT_n*sQTEIT52=k=5vw?+GGQKetaE{k>lm8+J^Y^8iaEbZ8xY@|wZTp$5
zLfYMCIDBWKvp+27c0=G36A`+uzr&FD(BzS(hj^#ac?|AXi~L>wq3k?9Lxt<AD`?E&
z{DRX-CF3hpEuvaq-R<1%rxuaFLe)}^GW0JEjZaOr)9~rk(DxX6AHIs^E<pwVD?b$l
zm3#=q41BV+oO=y(7$2nYY1PyM_xY(k;g3?xqO(#${m=XT@1hK=WPF&S4vfAL-Pz(F
z!QRKGsTK4U4V65fwCQX$mg5UmEmz|Y8V{YY(Ml9n6x4)yw#)go3G6BQELK(%i567o
zgn7t#<TJ#i*XTZK;t*S~x|y?WoI?8%l+k#joa_woPv}ckLZ<Fn4E5`th3?9POc6la
zTZ?Hg3`8(P=A;-FgZNr}X{oBfmlibohK&Qu-G^a@=s?4m+RW-w<nrN$b1~ql#h2Eq
zW!@B|Gs0+f)ZM0${%O?uCwD^Mj;fGL{U-<ODxx~CG>mf>oKb$=PYUR9&t=BvN&f1|
z1xxAJD`&Kk=;^N(XD&Blz3Ag4zLHzc6@J}$3F_K+j8XPC-LJ(oA?b`YEc#1)F}mfX
z8Ow*jay^aVj58EEOh)KRP5~!*q`%A)@~F}Nf})}t`ktVpX1xDD9Kf+itC~Wc8bx+4
z5+~kMr#iR$HdAU<a+KWRGflm23hy*Ze4n(O2Yr8K+k93xlT(ZBEo7HgWjWtEOHn>_
zz5ktzZglVFd-I78jUt*T%lX0iGdD;s`V`#p{?Q1aH8ic-8ArESUTcU+Os?XSbO+H^
zI*zH{q&|#ew0p(n*+^BTsI)lAL3GpD0iWq__2<zPH<EtSNFoLJ8=vKLP&xx(JirG?
zc`@9{Se}a7sG#WD$_k9K5=^U$grKZQHEw4^UFt6_Xc>-mG3+S+BFx%wCoIuWm+^9s
zDb%A17z$N>ttp21jBUuvK~CV6YL?U8a941nYdJ|O#vvVRrmvkIie@vNWV8#qndai}
zeGQw4*1Z*du4&>Y>z=`Rre`qC>PSo1oDzF2(lkKW?q+JXQu{7&@ml3NFQ~sl>0e<v
zd(;T-Kv+GCmZKJZQPF&g&+dcfzbDi$X>}iX&1ZF_<C2{+`vaKmM7X~*Chm^@$UofQ
z9~<X&sw>0Gc%~vP&NTS`s){0J#u*0F65(aYRl1?NGEO&NScFqiB<y&@2Jpq8kdq+Y
zm`4Aa7Z6?@r9pj$VSDOaG$BssBGZkU7)O;YGL_ZwJ&K)jdn<h0iSQ675I1K4;(^9%
zU5zbJ8P~cQ2K}HJsJxMi#%5RN<{oi6Hz)XUGFu7tRL+gl<1c)lG__ODIGs6B_fS)(
z%kz10x^_k7<8^#5i2FY-sHXPm6?Zv%8nq8KPgr(f2+Wj_U$}8uWS7J9@t%5!^Sb{^
zv_jlVvYa<e?+OEKJy?6w5Izp>5vhVBHS;4V2Y>Y{UiLeZ{w-6Dp>!ij&`rh?jiY|;
zP2CkUdFyZ7NMY2Yv*X)--BCs8P|J87vv&*|^rKr=t<R5f-u0Vc>N@v5ZY}YN)lwM|
zOgLEni>Dz#-L(Q=*eH04mkh=AE+!qu(4euM>q|{S`r2`3eFV=NpSuz1?2EhRHAwfU
zs>UfWVJq%hGcxZ{J<N*B(krd(9@WFGxNNO(dQ^|F;&QY?S?7=?aWmGF>sk01R%3PO
z^D#NE6>y(sU+|@$YF6{nkdE%-@pOXosZGmh{ADz0^Dmk9K>nY>BZhw)%Et>$Eax+C
zcE&o-b>bXat#*D{?G$toYHFg@+^6lp74P|&Q9>8B2rG45hdz|S3p7{d`rhL&!W2VY
zdAXFHi8K@W>tSJ6UL4gzcbSD!4})8vr|17^@s9qC>H2oF30j`iGNq|ME0dL7Xl52>
zUuP*=tfZy*QxBDY7KOl9EI@0P&K96G4iM-GE$uq3GWtok*g+GJ%OP|D1-K5NS9gTK
zM!;x@$)7i1A!%Gd9SACfEJ4oDbd+|6CIeeJ)3VgUcxWs1T^~(9x;zkdeKfLheN<`S
z6FR0BTpx`q<5AJ0Dyz0!XEIL#_{;Q^!W7d6p{j+1<y>uAFPa(u7h6tQ(e+WK>-sK7
zO`JgU(cZ)`ExX3--rMSV=;%uJ9htfCrgYvlZus<+&U;3QR+`3%VXR-&W8A+RjRb!g
z4>jI5YE)Lb7k=C{q)9FA7t`oI;QW&(lRdeZkwbS;kN%sLo(@3&kZt~?#S1On#gm@%
z2q;aGxxR4-l<T9QVdV==hkG^Te2i-rV-9{cPw9Bh&M^~WrnfSe7dO!;6>~w}aCn}X
zbVJ~E@AEoCbo3X|p<d4QM%@W+j>Lq5nQG83x=szxGU)D5t#JS)muB4~-i!lGJ_eKB
zGRh*0c^&9YJ}Nz4_e@(g#JS5yRi%FgO`y<`S{R{t7Ha$NmH@0suP7@(?fOf@xH_rt
zG4p2$y1Dt4nO);)<Em<!d#4Wfy(UCS{_-k()}R9>o%;;e!(ZmjmECW=Pn}>??psV`
zqLQ9TM{HTnR`xG-zL4ptTCto5d>`_hOMe8J=9Vt_9LkRoDk(}dkKp=f=x_m*bQ-?1
zo&$Ccsvl-)T*+()t)`(PtK%U>-A|W2<NByi;`*pV;rcQmlt8U%Z?vp5@XqC9*6i!J
zwzMmuec=krzK-hxlF6v5st9A!)4ohgY%&s;i3E+15L9%e!j?TwOFeC*#)%XLWL4%=
zS$nz`I$?ySlTe>B%f5yJYxPD8gTcS&Ia(!w1NS)|F2n6h!5<)FucP?7a0U4u0{oG{
zUdQ%CYAyR_lJ0|vW&0MYF0J0hSb&@bNgQ!&KdkNgyV&)xwu|S7?T5*d3s>au+^|+9
zq5n!o*%jA*<WZRHOADv$M@g7IIC74)A0ua}N7tvobL{bdL72j}hrLv7*)N_3(~mv3
zk383Bsb#-RDU4)|LW>M=GIq2Q$d9h?8~jZmt>l_;BwACMi`cFRqvf*fJKzf(!AXDc
zED53S$kB5L1!*Fv0V}2zEDTpblDxW*7`^PqzJojz1u+mFxRX4vo)n8wMc8+d-Xl<2
z7nM~)zKrHq+ayR8N8%nx^nn+i!TULJyowyB?KJ}_1*$2K7m+_NLUz(8@l6XaB|r6L
zOM=kbf!}rXOCc{qhkW}4h(Rl6&^J~)c`<bSiq1P6<PG-h{%e_}qYwv`nWKd50k<$o
zhb0aw(~~gvz+0K4a}ft3E%>|YTd;i~@--`XQ9U<l<PJxFl9fQdxqw;{a)-${E1?Fs
z<<G^o>6my4{%<?ghr>sEBNJhv{(o__<|UjWpHZYZo2|j<n+~(=|B#Ne*+<IZmi@U_
zx`QzpLq`kRr!|o<cyU=}w3gP-TlN>6y*391uFzTaOPc4agewER?D`ckSQ85dy(0T-
zip3lSC0w!WZ^+IKq@+HR{ViGd8&Xm-eMiakSE%|_ljir-KcbxR1Lceef;6O>3&DI^
zu4}*I`wA4Yq-DLIinBqHvJ>dz4zKaFhuZO@DYfYMtrQxETlOeU>QgY3N`4#`2Oa(b
zZ>O`)P>`??4VaZQ40`m9&7RHQ*z%#3x(^2a(PC&W8(PYShW!9O16`d=F}Q>cHbOfE
z{lV!4b(USjChjE@*!X5yuaNMH91Jh)n{0}wcS$;|Yq7N~+z0j!r}~Z-e&)lBz1IFY
zjE&d^E)AMiDlO~m;F5n$pS8&j!1gj|rf!8EE#*upLzcUfZM=mH!2{L!bLVg}M#0>{
zzI_CGL#YVXKqG{&f|yjapJQWo?yzL|@HzY@lPS#Dpvs`+dy^c>G<u=ha0H8v3r1P?
zA$uUa;a7BoSV~zsC&3XmL6L|(E>uDLU~VfEaAm~nq=siN-3emU+fem~3Qy{t@s{;0
zeknA|?w!zSKf{($ti#ub@n<i2%uLMKdItn8N;b)_iMvUB*e9J(m|)?DWJ2eGF5K~c
znzV;gt1u1PF(~Z*&gc<{@Gi({N1!`G0ek^)sf*HkSwE=koKZvYN<t!xzS<Za1Wo(q
z5k*j544!PImc!|c_#>@F&NkS3c?r17=g^;P@#oS7(7J-|{2TQG{!D?v%c!RJD>~fi
z(mLplItcYjXpDLjU^BoNYA|PY#>vF^*{_bc8A`f%o}QtbVC3A9*!)AoczZQ3u%}z(
zFWnA}6l98e4)!@nhLlS4HQH`qZZ>f=K155$(?gp<TzZ(y=}+YLCg)1HMaxU^3@bwK
zmad#$4(C!(*pcBM;W?xCAfVlUl->Uh>eSneH2LAT?A`@Plhp4(UkyuA3TXgk|B-bv
zp+heG3>rV{W?6e$TzH;c_!$JW3ooz>v{EbeZ$_G2c!ljb%JvL<3Re6Aozi#78fgBF
zHNPayVNZg;DhZ9_rCRS4>(SliDQGu8b!hd=ET~e?Krju097Bkr(@yO`9J>WA#QJB5
zq$aWflU=C39Qyc3d06}LNA}|fP+#hzo+K~$xd+`d0aTDEYyj=TR5nrLiQ-X)9pF*M
zZD8q1qohy4nCA-o?BVKhxXJ1NBnb>%0CRNZ8o7|c*1Zg#EY~XR`SS{gCPovnxQ;$&
z7?J0}gm9Mt@07A9t1(=pX`ggTS#36*_iEYKvejKscVD`Re2RoGR1{GQL8VmBSXhDX
zP>~uBqt6plNWF$I8|t12Z|;Pl<D<OTxt&Kr_d&yCqC5Cw*#RPOJx28m%;?y6vgr=U
zEW^G-?{z8qs(WBVsC+So`u0}VwR1w~-E&wTP_x+IwC&wWeFEnuuR!A%f=4);{z)xj
zZQ4`~{Tt3jNyks8R+RlS5>6TaEM@;p27zbjVR*g@aU75Du=Ewea_!I6BoI6juuq#&
zp<dNue_<vIeH5vM^vw%V^IwHy<xs}yu!@vw`krfBzIC9MkQ<kNMsbQym%O;bp2(g3
zJrwfkm>Ky!elNf^s&_q+S-!1oAD!7?>b|*b>Jzdr^(92sIf#M~&7FE?7W$rIGt_A?
zW{TNN50oN2E-yE@faY4LUG+L5-@$3uM^_ND7FGDH<+l>f0cMi243o-A7z~UBQ}73C
zQL3<(Yb8wb<S8wfMCWrZk>|h>iXl(38W{Uu@Hc_9*d_`w>pND$CSWEhNKD#R!o$Gh
z9z#gfabCP`+ZWIhvNu6rX^l@qfpxnbfWo%hO106l=z=20x((LY_IF)6<1hBKLxKOi
z`;j(17L}J&SEt}ZN=39Nj5pmdQ)^ke>k^{GwRC?Cz2{IVDPeR;1qQ|=pu~g8>Qb$-
zkfzEsT#9{j8dcLYm4<~hCJdG0YXF(^^IvtlZEs51oi?UVYM->tySKPYkE$H3+))Yn
zDjG`JvS{;`SJkpj4U^|gP!F%Zf77L}rVVvdN}P+kyFF&BW!qH8U23n5Z;|$<jMS1b
zvu_z)_wkst`b7`!9+Nh8nW}Mvs%x>T+N8Q}imL4$+ylE0ssnXv)p9qY`nmZk-o5|y
z?!O<qV(adsZpz0)Q;u$Nr>2eBtU8}?x0KwVj>S2b*e@Pb_bhh?*>0Ljddn>-jk?pO
zKC8;ykh*Y_df`U*{wLHv$LVL^t>UkCr-u7ZNh{g8{kD&r^VIyYs(=0#cedJW7avtO
zt#XT@NE=gfFq~4azOdX)?v}JMX?@cEtA26g{p#P2yKTY~D$y-=yN^lPa@tLEyPsD7
zSP6&rI_~Gq>V4~gdz*WuGqlI<gGV8;`>5*fc5`RDX%Dz_HmmC(IDD78Sv|M%ez&_C
zRGf0qeL(%rSqqQfd7~S0pKzaeBAlY$SDPTzv3Py?(xXqzRyDiaeg{?OwW{RA!7c6_
zmHfH7<3_~WDJNh3bLFOw-E~)_ZXT0%RDHJUek9jhM`2X`-bUoDw|A){D-nvmc@1t~
z^@2K}-nHC(r+<>0c5qDE&0C`6H}BtW6)jfr5x1e_ay1=(dSHwCbftUsUUf*hyWH;X
zv@!0V-4wUpz4^48?)2|LcBC|<-IO-lv!;8A+kM;>4el1T;)GhXO9kDrTJDM6X;-AA
zH5_EY%SL>6-DQ^^b*H+Uk*_XLF%?k{t)!SsBM*%m0=LqRZawNYjB)>gjBvGzFLrO&
zepM?rjjSghM~}}zc=Oc?cdWYKcDEV-q}4xx1Tzj%z+fJEE25T%Hb=wIrQ}Vy?+f>|
zsvA2<)$LM!w;}m&S#iJm*1t`ay4_UmSe39=4J-zo=x)05@?pKNJRRNQ&Knagd4lrn
ztL}?W9Q^qIHjhy?SF0|e*-wm{+Q&^&Uy@I5^^fi2_EBFWl2rf>cQ4-me2H7D-h)pc
zwj=KN&8i5wCk?smW4Et6MqQqd6u9#V)yX|D&z;ZN$}KsqwybjRUsqp#`r|)ek?Mxs
zE8XrNKkp=Wzhlc2wJEc=9Q+uCXSeE%jEx|s;D>luiw~#?Z>dM@T~DadYt;bvEw=6G
z7PZjbHfFA>%YRlit&SjD9-KWUs!pzYOP#jXe*6TiiEMe|<AbM>gJ2Kx!)|w+DshX|
zylwcZjXH^{c{&8ew(ON|g3q@ebqxAC@+<*L@8Yg=GCKPw)%$Pu-J+(10#14;cugoU
zZEyN3>HE`PhPm|aj+om6GxJ-S%c%F=tnx#Fg`G&ArQ_!igt?a?hpLpHAl$wK=q&eU
z!o9g{R68{>K1;hx#)rTRJv544hz9N~vy)(UTPT<t3e0L{13WuE-g!C{yfzeA5(>_S
z(9V#RgV$9d>w3KY777-I0;Q~_{^^9Ql29N!WX*zBUC2Vnoz<b>e7tHy*1}MrEM(1q
zV!VDW3I&~ND1XTYW`=^1P@sza;M@hRERrXeooArR2n8T92db4?Z#L`A&=S)_!BwF^
zJ}YuU)-s4~fY_Q)pa3s~3hqw>d21**Hxy7$*(~}05cekFRTk&l_`94F4<x_=f}o-v
z3@Rvu1dv5Qfe=Jx$pQosjDaK&3?yb@Qx*+W;*m;R>Mm-nOY2s(tyNnQtw^=is;yX;
zsznVh)w(Zj`R@C9X6Bp_`}=<X>-t~Uci_$3bI&vTytBQtgvYA7E;n&D3=tVf25;pi
zR^~Fh*^HnSXyT_k95Ny}MzvmWbBrqUoibDnUJdAe=tRPuA}Y%TmO3K<H7)5(6<aC+
zfDS3$pi(EW41eV}5Pw(T@x8f9pw9;II35Oy>Jy4%RN1fwUUN)T!A%hy!QvfZc&eQD
zp<Rf}ZwLOqhz9|nD34nJ6eIlEjpr>q0TPAkemuTcN=ZHj(h?=?F9H1k;hG{;a}>v@
zUN5*gM)fA;BUB$SJXKCBrH7I3<>EoWs9Yzo>;@?JE3_VSn0OkVz{}fS40Wy;m$pLT
zZJ`M6fs$~N7OoXjm&kmJ^6@YbR7WU|QSFQII}@2|Kfz5Ass^v7$}S;gtZ#Jh25}>A
zJJkp9z-KCPaiVP^tsRC3G?hF<Q=KX}Z#z|Wxou*)%MTlusXnVNQ{hxk;I&PoYJ8bS
zUviCeROvi?JkXbx47JMXo5dLa&>5<Ag7dahH6fXn9+FqY%e?JWjh9pC<@dy3inW)7
zEd7Tc3({h^z?wJ0d_5inlZtV6dMcUQrd!dIU|xVH^xC`(0!AJ04rLi7K*osUVZiI4
zEbk+bN)NoOu=wZ(g46LpgvtWT6CBc4_-CPTxFhledHsYR4dth(ePMMQh76-HWB|0m
zn~u<wNr;N5XyD3Hfh%L+et~Hc-z%f?CLZyj90lo*J%y+8j=&-+f5vbc(p2^cETY1!
z0c-tz7t!B`2PsJ97)goJo8ai}c)(J*M_?(Hop^A#(|Oyi16RS;&Fa8yQ0`Png%g4j
zL@QbXVu^TA!q~i^(3<Xn_U}R!TPj2(`$?Q#HA(6aJba6(9x28}RE}3T1j-nNRK^Q*
zPIBIl6H6Ih$eLt3@riiw`g1PsTRhh2hZw70i^uA1s3H*WCRU2RFjkOG)|4L5LB1B&
zMPln3v6bBoS<ZpM`qxlGb<~>P1d3T5c*D2<87i|pE$7~c^gqN#2^IP!sm+OzINrey
zNuLYTIe5|ndM31$N>QQxv^tOziKG}@P8HI{^q?OEeHT1%kV>XNSA*UO8~5XZDV1Le
zba}wS&5{lG=JC~IVIV#oQ%1kUL(JL4L3oI5f?NQzi}Ao!Dilo%@fXl~;!zQm-U3~@
z;q)U@2JTIJ5SjWZ9%Acunz@%|ZjHSv*j<kYsfq$&ercAz*HO++_QVr<4YBPp%+>I5
znuDP^$ZNZPLq<-_y-vd*K3c4#`EwG8Gw>kdR9KV{_UYA_!`X(1*anFcm&SY=%^TI+
z#gp52EAhZ7D%?CN1%>WRj2jK79hc$hP=r2(co%UkZ#z|5rO&i^6CU3yrb0(ZTQ|}J
zcjosyF~xcg*(quErr1c)yJN+RQY!Qr8E<U?T1#og;cE!>Ls&Ar#z;m^f0w`)gS!$B
z5`fCB0$nk=$xwmU5T_9xPLBbnd_Kj)>W6Aim?Ppdp->dihS`UfrZIF4hYxIsWgJCa
zKRgH|l|%8M4<YJdiX&8yRE$?ze}95rYxUxxXq86eLB3qQf#3&t;M_$}wBd4Z;JvW*
zJ3NS{b%+zVw8XHdY?N5zLwmz-JT#_yG9KS6xeN+tcLA*=Cw0HVLrJRLwRNG=M_@4(
zPWz@O-KWM@=&jrs(Avo&TS|qpX?YhwOD6)a(Ivwh(0?joC1;~WW~+>3xPF6eo?)FW
z@=QE{RM;j1+V(ij{he^<1#zp03LABX)VAov)>e89-i0i^W4tL_h9|^jiQ5U(w_<Bg
zc$;8#u=F(^wD(jZVsGV!?F95Ztv3NkC!WKT);rh&TbGIhMN~|H-TN^NZZJRytb5U8
zaDhD%29_#amG_z55%xty!ww01BcfrKq(HhQ#Z=f+5Z*@PO-v1cf`?9C34x#BA-3jU
z!m)3phf_o)3!*4BS3$W>U=fvl0_P5erxWp@e4YwtrsDyma+bhSDwTLbuYSXJ0$kV!
zP2>9Qp96f22l7-n^_-qd&mkc`!4rD1%IyT-;ejj_CIV!q*fb!vNkGgLFnw2-xYrwd
zUA(p*Z@9vbojZ8DwVp;<SJEi!SQ=$hsuAJ191rS?;U+r(>BdWve#K`Xl@@5CQQ^ud
zWW{|Om<U@nU+&vLz|cl$;u@tDaF^~Q;Ue1!80icY>5QC+3%S+XU|T)ir;}E11AMe`
zl-W%;TkxQKQeiyc*ZS=QSBM5ho8T@y5Tf!M;UPruThTy>fT4qsO;SLHiSzJ)R5V3g
z<-=W0TP0;ms9b=QVeZ?26Wc(usI8GQHkS%T;U*<7!2`$wybiGiq_SC|wf+*U|4n=<
zqC)G)gF7S-C@LB&ydKeD0tDW<uFARrdd3$o!7eBo(~?w7U7Wh13?%SCFc%6X0PlhF
zOFZa*@>9lk;+NHk$}0-__FgM7bIy%Msx6cREaAtA7u57%L^cOc;N`nFb}^)CMY4#>
zR)M8dm<jT>*$D1|D{qNQMO5foT8)~3m`s;@ysNcsn4Oa!Vb)O4m4Bhzmy($c#!S<D
zTo$R=oX#~SMVRBgc;u21H!?gd$}-%#>hZj;4g?RGvP9bHTwL;LX+5Hk#{yYqCC)|U
z*-Ytre*biOS<JyxDJ+8p*Rm%ig6^T^R$?Wa$CEZJQ6tAd)NtD<&(N?m<;oZ9CQTlR
zVEN^G>J1NOIe_AM3YJnw;lDjwg2ya$G_=P*@aTn(CMj#?WQPUcAKZ8vEz#n^GS;c|
z@bfd2>^tT`1_Xt*Sa`(q40sL#4|xz%p19yldHy0#E#R_1o>;)e?aer?fLnffG6DB%
z@Kge>*ufzL_dww(0@H93R4o=4^Av(~J=aFs-ML)ijIZr-b{*HHn#G-51&h@%T!w5G
zTyv4DEbAPAH_9%o^tfbIwpMV#G#77jD=C-unRV!_hjc3kD`(wu;Bk?k?(O61SF>fP
zU;v=mpwb46rQRs5T+Js)b|Z25o~{w+%09DBUH3q7k)I>5VU#Os?Lv00^42BaTtX;I
zyt(w6V3zKD<`>2^Ek7;lvKH=$=c*t?-lW4fFf;k;mSitZdrP^A)+PjZNt!tG3;>h1
zJdVI7Irq+JOu2g3uKMLZV@XwRIo0IjZVQb%SGk(pljXcz?`rkcTwcqQAZ+%2Y;%ok
zQ*Ey4ic&5)vW&+CsG4PJ$X&B03%O*|E=}cnO_NC~$9+UL*SG=9WG1(7Y7TQpfz1c*
zlSt2_w+_ri)_<rmP5p<8(EJh!i#)Fa)fMMVIHSX97W<nHj>BZG%sCwohs(O;M<wix
zgPmcpvkuli%`eA8{tZ0#_d5I_XD19SZ-@SN*q_cPApgJRv%BgT-45lgJ9gA;huNQ_
zKKTZZ{rzvu7o$@8Z}vIrW?I<cv32*q@yGoa`5|U}YzLQiylLIzXqH3K|7P9~W&{2Q
z^Xu@ouqSVa9oAhAGro_vBb~Xh!_fxqahzj+G`AxSjx1I~{}mqly96BPBW+iS{nJJ~
z>}0VQVLK*Po_)S_dCIY_J5a73ZxngD%YKpl{R8$XOSgZFhl37wTI{b2+@qW9qcAM?
z=NgCfM#ig|Yc3&9Rhrg3t!=fGbO`EA#b!y<s9G&sdb@?4`)_RJSDxOerPZC*o^9`~
z9xL$c({HcV{kYatdl;@dO0Ol%ak8Eqtl)7ybEAhvhuC_Zs!S@dBB-LenkNUZ>Cn{G
zpVCm*T#w`FaFRzY&tY3D%Vo;TE0>kaI)-v}5U01GcTfj8TUnh_P;g>m5RRH2Y)+b%
zgh$ot4a1Y|4aVO*K_}yHzM$FoJ6zBr{8iI8fJO-SDgKTW6!r0$2q?qr0d#_J`9PzD
zI~i!SaPytq5{H&M)C4p}<XRl}6QHreO+@v1qM#a}ae^)f8ZYQRhqy9zf^hqRP7>4w
zb*v&Brfx!tW6-f?g)u(?XriF$&a?z*l5o{PlLf5-DiCxzkcR3Wpee#V3ZyCY98jTf
zZ#eD~hrR`xDyBV9qpRE?pi_h!4Wuc_WvLp1N+9*E5onsoC4tnphk#BM?m3{-1ib>J
zu6*dwr$FjnAG8YU-XNgU#l~<TwNdO)8Iamo<+yc@`yJ49vHK^W8G^W=Q#nk487>B-
zF2@}@6i7?hF^<av8ZNF(0h%eO6i8!P1*A4O&{Fr#15z88IPMCdSz`BApdvxPbm(a(
z_eUU&+Xq0JzXzd}Q<r-Jsp)Y*#p23o&a?zb{ipy^KhAY%Gf;`x_>tpobLi(lT84H2
zsc%mMsc-*wTokRSa)$tE_{Ia3ipvXuwA3vF(iGx3pL}1ly^9>;0iSAmvqL`xnksU?
z2GS5b4y3;Q2}phWCy<sB4h2pT8^;5wjS)a<;})PfVtSV|eaxZVPVQC5z2ms=fYguP
z=n1IHhXJX}rvc4{%NgD*Abo$!9k&vwO#Iyhq;@X`(%R>0CwIF;4*_WzdJ;%&{1Irl
zxbljVd&il61f*g4!f_Gw8`N%pAT=Ecq_yaUK$_w=I=Npt^caxZ_>1G-aNHM;%S0bT
z{pby(Hu8ZqXHEs0Ct<Dt(irj7O|`KeNMp3cahEynddJ=7xceOUu;ZR|+#emc$8m2v
z?jJyBNLX@v*znB;(y+`2(){2`R85!rfo6)0$DQ1Zj(gY1^@&@#K|pGk>qiw80I46R
z18EA?0BH(c05o6xxEV-O=s_U0@mnBGp{E`9g5zFu+`EqJ-qZTq-=Wb!8jq=tJIkTv
zK<ZmFkcRJaAPwKofHVhp0u7Upz73Qw=nEjVyB|nH+69Di+{UTgk&YYexJf{H;tI#s
z8oqkRo$t_%K=_Y$>ozDFJ{eYv-RHn*Sl)JW9|8>*)2|&Dp!=X)77%E-cd+Be18G?1
z0BKk%fzA|HRy*z@CwDE7x^fGUhU!;98kXNX)0cqM-!~lB?zmp)Nvprd0ja-Z9ajmY
zeynxqLLl|+CLqnDhk!JXo&(Z6`WQ&V67;dIWC3Yd4t89^amP7sq~lI<+%(6PIBtRC
zE&<YbT;<T+KpLax9Qwo|t}ap=xY)+T@=zd++sQx+B<;(c=@Mt!?6`G~y9P*8;}<|0
z^T(asGe8>icY(AXkFfVIehdLxC}=FuY(dkU=^P+!g|<2FVTWD@(meVbkcPfXKg%5s
zq}&;fD+fA3{HO=gFmDFZFt<6m>wq-OKLyf|-tSCbb7(J+`thmbzI9yu5Zj8E0BK0)
z1I>~U)BqI;Y5*E5Xrtq{IdmgXiJ1NgNPB{B0-Yt?M?jitAx2v2M;9RNvmOql<$#k@
zYL{~y8lzKzG<7cqQdh2arnflLdx6Tux8FL`-#hf0LjlHWXN%myK<e87APv=EAdUG5
z$4vmL5F0ZbH`{Sl4mAL2NUw6-Z9wYsJwTcZyBzl%koxupkf!s8K#Rn;FM%}AyJBoP
zT(~hn>fS^kwOayIBBm8U8iJ)xt`0~;{{tXR(>5pfTOdu-KRDCBI@7m-)VKG6)VKct
zX-NBEq^$lP52W15jyoMl!!i#@T`33BurxZv4+Co2?$9R=eeIBUgq4dq6nChfL);go
z?(K2tO^4bY`oy8H9r6;^Zp@*$L;W1e@bDcRPlh)Uf7LhkVHHgSLL$NRR{T9q5HC|y
zbXnA*8y(^<KQ(;=qYg#yJM@V||8l4cdip9i*`Z>G-s);iKXNFF{;AsN>ChyHiXB?$
z5O*4>jfD=K@6Z;9u5{>Yhra1y?bgRFTHVv47KiRdlBpk$ICMT*KjliYE&7u~<IqB=
z=}L$G?$Eucz11`ewXLGV9J<A!PaN9s&{4=zwZTtVil#gC3)ErCz2eZ3s8y6(<`6#?
zD|Zs!Uq!4p6#dGfzc_Rx3X7T+BrIxj=uwB72Uyd49qM_M<?<X_l4H454z)P+7l+<<
z=wpXg4zzYRJ9MQ(H#_t<hfX}&+W69;ykjia>d+q@nmyQ>HaoNs37~24TZfJ~-f|~9
zG}EETP-|M`(8Uh*%C&Ff!44e?gv7*qnFFN04Rzef4i!1H(4ks~E(Ox}{Bnn`a;7%{
zsmnig92T7$e_sMpyL%jZ&6$4W5W8q9*T<pb96HIN(}6Tb^BlU>ncm^hUC#6uKpMVY
zXbRNsK!-*+G})nIhsqsV<<P}I8q!OF21)AP<G9D1+>?%b+M!pR>6<`m_jAX6<K+JB
zP<J$k8s<Jg>hB>A4Rxjy9hwTHE}!YR<qoX`QdibGxr?3YHfMT;L$^EAyBv3)LytMr
zT|nyZtB!lqao+%`zyEe9KHS9(NKFrMD9@qEK$-?K99ImazAbd7iyU{3;~If_Ngl0o
z=u&6;BOrC<ZpZ!Bp(lZQiQT6idfl16=eQ4m)Rpg?X=H>Aa~B{rJ;ZTG0re7>k8!5?
z&UAt^o#adxIJC^kH9NVr&a}muUgFS|PVO3qZgr-218Mkv38Zhz<IeOcXZn)k+8z4F
zq5n9!_(&V`en1+_{to3kQ+zl!zD;u6R3~?uL-U;JLdR7&)Zk3lI&Qr~mpjv|fi!ME
zcHA9K?k<NOcBYRz?spEo>`Y&G+*=NP=1lz)Y#L+$X&Q8OsJ}DK0n)S|?YQwk8q!l7
zH{Hq2cU-ySmOHM&aV?J92Baal!l7H8=}&<)1dlrI_YS@4&_@o1qpW*<f%LuX52UUf
z=eY3>O?Rl+$;}7SSXMdHl@49((4{~c`pX@9#G%I>`kh06b?7aJ-f`%CAocePAPs%S
zXp6c7X*>o2soWVr8iHj`uHMOQa$KvE+v?Dr4n6GTb~x@yhhBH+A5QL(F*XD*IrNr8
zA3L-i^@xVA9}orwXzke-SFXr$vmLj^ahEvmNyk0yxcAUUS62db{}uIe=(4!wKzZl_
z!r$*h5Hogj<pUqI`2A-;wiWnpKd_SK@5M&-q0&VxMZ~iMPl~x8x&*W-W+xaPHj`qW
z2g5UIQp_7*cyvvQc^?Fiqe(Gef!Wc4=?cS}IxvTT;ixNRiwEm)T$f@-0dn_wikS*{
zb_aJ#!EohXN~RK!Ckv#Q20(7gS0-0hEioF(gnlA{jchb@zg(OWRAF=h)Ubo88ssj*
zMJ?tR{udb<Z!mTvA~S)aoqk)542lc<;##u7oqW8;FwD=;zYWfH67l%8kUtFhAj9(`
zVxmv~!~J3W(IoUo^yEUy1Ao6UGWZ+=nSuCgh%~`J7^<ttcnErDnb!@4;UU~f;4f3N
z<L^TwgJB?KWVc~Q0qDLpGWb9MnX@~2l)D(msN(87TI?<|h}QS~xVN1f&**@LBs(oY
z3I}##Mt5Rnc4DeJF{?W<S9D^2(t#<*7wcNw<6(bl_^XaGxKE|V3b<JCpd|ZK_-ZHS
z<4z0?p>jVp?AwVsx)XCkCuU|R=B!T4xt*AcIx#=)#Qd@o^Gqk^oleYuIx&Z)6>*K}
zh)&FmPR!Yzm^Gc4OFA(;+`<0TuU~ayUg*TU*NOSM6O+m6!Ti+aV>&S>bz)|9Vz}bU
z{?r{Fz+`{Q{IC;qdne|1ofv-aw?B2~vrY`Z`rDt%@aw<*DI-Tx87lC&fiAbQYEko&
z@`^=^cr%sJ$+}X5c|L~as~dQPiZ!TPY+-%#B0Vg{7(vgYFB+{mu5ZP0eNNj^hnLeU
zKk(Q(EXw`9L*>d3I3KRuoavT3a?Hq)Ub#8;jk*zDxtt3}JRBx+Xc{#qcyy$|9z~Wr
zax8{7<@Q`GXh-CG<>qic$d4K8mD{sma!<$`4nudA3-lvK!EHIl2AVuLlsdJArekPX
zPUnHcV-P|;(}uF6UE=&dPI|Ml$gHd`H`-IGnq>W_)l-8*!e-$BpLD9U3Rf#F$0E(f
z18H!&g2*^1>q_+wM(Y4?3C2;qI4KqPl$ga;)(i&&)ium$T;i2?T7qOnN}C#Hp32Lm
zEWt3En<XtZdsQ7)Ks9v;2{k+<R#%ByNx2Sy7g{*y%By)2vNfN9)9P0=RXaToj^}xY
z?vzn0h+uUHRSC}VIUsTjC=U8;)U~$OqFfOv_cg=q23&7lx5D}6lAmQ&Pop8lW4NdB
zFn&vli^vpLzB`$4xvreScc7K@a~C_9p(uR6C7hZ^g95oYuY(m`6KpBbrJn(64P317
zW~9YR%9$M4oz51>nV&^`0W|?^T+_}CwMKN<$fwFH;(@}3)!^w;;@1IgLhyUsEI(jj
zo^@qbqq*7G61<;NmnvIkZcWuHII7E<S^QFO3x##zvK5wSL3%1SA*^71YYlMM39f*s
z!cpeuRB_=n3rNZ#9s!0mjWyM4zNfI6v_Rcw(oRY*7miO7?{Ud?%B54PR<QWt_)y%u
z%G&^}rL<J-m|@2G5jaJusvcKm<kk&K$S;4ysQeLQMvoXVJdqfQ$Nn8Pa-^8UVC)z{
zXLp_MvxkXwrmJ*i6#CD8`j~=d+c0FCf~KsW>8h23OW;W#S3vu{zlmVe#}?l!1ac#u
zVVEyT{~d>(&r2L;rvDI*Vfh$Rr2W=l<o=&N*g;>b<UgoTj+41*zb<fZ)pU$aS1KtT
zZ_1&qO8*Un+{RfrY0=1W^epb3fJu+E-}~sm-&%q-i%2{E;FQXZLV(hK9{~UGY<wRy
za?al|9sLc_yI50!wJrzBjqMoU1l&8n8awL_^f#Y#hG{=|bUoxc{3QK`k51>RDYqn@
z0ft=qIE1Fzq|>|WBq5g=n(&ra)K=Fu;CkZ(2b+s<0Cb`e=Z-F~@T#}XX?>^V!+y!w
z#x+M^|407r%`Y@%Z#>cKapmI|yoF)E_th&GyhW#4KFnI?l@u>!S20->Yc2e|r2Qrw
z+0*i5B3bzPu8CP3c<p|I?v>3gZTWC~a$zhvB3T;QRlwnvms}s)8Y$Tt*_E7@UENYK
z|GSOr;bBE`Mm&H2=G{#*0FtLhT4%hpd3TRZU(o`ISnG@@VH({y)@!aM({u9+JvMRH
zqc}OHtYmKc;Rr%L0ugV0V)KrsgOc^xo4;(z*;@5^>(^(VRle|vZLNFqUuf?OsmC}{
zO&KH$<A_pnTBNxBmH#jr@z#RulrhX&=T1w`d8wrRVHmegoxZhjZ);>AtS$4FdC7^f
zqPguiiN(aOsng)J2mdc>Ey!y5`k<!iEnjzO>YALhw{=hZbrgb63->;Ttn^CTm#KIA
z$`Gh(hHroSDp31Q5q<s(u(JgEYKZR}0q&`(NBAH7Mr$dpadB`mDm}BBy4>jUy~(G}
zoK$iK^0cC<iJiGrb~h%LH#asVaOq8=X(=)vb!dWf6AAR=>MC(Ea-sqvxVp#{5D#~l
zHrLnl(Dup%r-BkJK^0A2Y2oz3g4qdH!$T4cb#+bkXzzw35WK|Hl36nn#~yv|vAIV#
zdfT=>cnnj;mWT6OpK6_RMeB@9PV2FW$2&cgK*hDIaNDcEt%a{`Eqn>7I%iu^a>f<O
zb(d@{d~#XXI_IULU4?u0L1I_on{=$T`N`H9Pq(gnw*AU~Yo0OJ4^J+9{(|qiqL}sA
zd?bXKV9d!qQUa25t|&&yd;HC?wQyr{YAiWpV=_CIEZkOt9DL(n;tU*#JT-BoPvdnP
z{avl=wj|3UENX|tJ>+~@SrM}x|NN5nJH=9>wQy6**YO^kpFzNqGd7{zZq9&o{*Kn>
zP5Jv<-)Mb2xp2z|k<B}r58FCr>-DFU6qO|lB1P@X)X&y$TK0EY`Bv*^n|CCeH^H$U
zn=i-vnk?LsTzA*z{di51h1a+GJvNE^g;#9e(PPuW6hIg!W?x)%M*fa1&yW4O$EF?d
zp9O5j-bdiQSKQu3JjhDUxn!BQ^mA|}?O%Q;@!a<g%iebf_1LtBCGKVXd5A{}ARnHF
z+`dK-^k*oF9h@v`|E<_V;e}I0rS12sGs%UU_9Y>@wdokIW!)8ikIh@5OHLe8-7;;y
zzi%Ur=3LJ;uU_lR`8z)QS#r*n<Z0Qv7(6dImuZ}waw4jMY4an=$&AaE;xit89xrIJ
z@K*T0nMWlhXKYDM%5E)MP*hZsToWm49}drx$e0;7;bl#plD%cxykuGS#gpf4LWp07
z%i|+GF5>i7l8M#av*nv`eO7XP)&=kF-+(uGeHQA8b(`WnHeJe4%-EKkv$1&Vx+j^Q
z+3}L4MM&GZ?SJ?dp8W7GNbLFn|MIshGLTB^*40RsvewP#Ls?o61_kH_%8LOi!q#1_
zVzuS#Nb*Wb_1H8C;Xz84v^PNz;oc066OzoZIeSam7b-24VG|5DuZOz~(i|jFT$0G&
zHw=aSsmb$vMEc^1^Y&%K<<`d^|K`Zn-{<cf{QG?`F!86x;AHDJC>mR)oq=+ivGfCY
zv&^5{{_QuCZmm-X(%o6vtg)p4?fU^N7NKCzmAbM0PY^^9znt1V(ql8@+WOtTTUnOi
zutd73{T>l<<zYLtXGlD*q$d(*)}$})tA)L7Qa;j4W}UGvC36fCyrg}BQ1N}I!vf{;
z{udP$&uyP#_!k+ub<gkn6$=&2ZGF-|*&Itw&1x;&o4;e@`XaBnC^<Ef|7t#}%OZd5
zp7q(L{%QHnZ=O)lva8?NJsUooh62IYXULZm=lf075XI~IW#Qg<b1z1+@XfjH&wee5
zkSu%?Rftv~D6q3n%>Hune82gZ$r)L#e{KDw{b&?M6tXBh{ov-ZveLP*+`bKVVUf-v
z6`cJUSq~#CJlOgexy@#xv~-#O!LyP+b5LKrgZ47Q_OkcJwMAYNlJ{S`pD^LyS`aHP
zE-Gn{AU{}sb~L?}ES=a|5SiRsI<bS`qsPJ%Z_YzIe)Gxx)_3NXCKsZJ#Wug%bX2k-
zlD}i~m+KEnmc+)+&u-58phxnwAuT)mjeVslI&thL=l}D}vlc#aK;Ixy)0n8mEd^DT
zCnivz%Qjc98iPcy631oZ`nd`okZrE9sn7Q?48}z@^&`Fd6FfUd3VWJg7ktPg@^%&O
zWe^$D!hXr~BD<*bHt%0QJpar5{ab%YU9upSoRWuHvnd-{Qq(^FD--V?n^~2e((+Wl
zvFAlL?AiK@y(kg+JAQo<EVX`xI%Y<^^#*dAcdzc5T!*;F{g*eMj5dK?Rn+0hIax@^
zx$W<NDK2h2?+CBQrcY4_cWrKmHFgg+{^m;{(Eoxa|I1yQpNE!tw`=oDG{CR*uOAH4
z#-=HXnzT9c)Z`=l<P8)=&^Eu?V^ad&CAU(3QmZIQu{?Hiq{k1hfD6gVvE=!P;r^zl
zx6XL8^~z@<i6U>?m$LR#C4dR`Xp&;u{KKt<uay=p^UK<YYT(n%2GYG5uOZR0$HtOd
z8IT@V>^NHbZhHni-YN`|GP%z9Ro34Ag`|KwzAu+=`isdcX_HOfA|y%6Z<r)Kdu%F)
zMpA0?gGh(uFGwfX^+(`QMfFb>KG+&;{<6oWB;&RD6B^FRh9jH5f%N7to0rmV^P=R8
zeyx78a4*}IBjIAv(slSIFt@b*EQCZWkl7lhGISo>rzv(X5Q@aeytzw{gPmm=rR{^A
zF*oFR@{&qfiL1c}S87n`+j2zi;yG7rV!Qx1ejD`IbT7hIT)Zq+)c&{65#TEsY}E1i
zyMO6?`hkBX?N7k0<;iSyYT195a?>c=|DyIgjmd9l5hm4Y5|p)HYD~5olNvP%i`$!x
ziFgJ(wQ3S6X+QG-f9ljETGT%20Dl_PB%`eT*aQ6GS$7EALB;LeV4^`rHNUTpF>|H+
zw=ClOP6DUdTh(K8CR!F1fRVTFU#Nufn&4F`DlRE)-|?B0lh&Ph8*_^A3KeN-#Y^-P
z7-{)w%^ui(l@VO`;J%-T6Az-E9Q^w-yoM!ZMeVC8ETscA*uHn*XX}gVE5Dtv1uAWy
ztxoK_6sByFO4}zJW*-=2S6I}ZM|V18*EEedvMXDpQ`t3BO^{vReySO1vx_^OkXXpB
zH(_GKmDo2K{>XSp#xMO^|I+$I>vKizk3gt(Cj$NuMzJ1-M~5(ZkV-|#!dNjnbqH!-
z=@%tzfz_I9>tjq)+g^<^?wLBUy;4FIZ{2B}ZH`&n;$op1V>GY}iGPHxzTjm^%kKR}
zt>0plP>ceLaJBB_zz8qb?&ch}Vsl<9YtMl7`53*Nfn5CdpCV?RhjXtC{u)wfR?6C6
zhvED)(2;pbrTnKb!hyxsybm7G_Q{Or2BFq2ZNCRnt^EhK?rOhP<g;3zLeQ3ZCQP3!
z^V%O_`I3ezJO2d^hGxL$*5~Cd-MSL(``)>8ON-kpVL!QU@4We?W$p8T&%ywyw0$Po
zIeX72X`dqQ$ED>=IZ(aLcJ9?d$uDg^`yp+#?6xk9Cl_Y7F3j3hh^$5hapuB(M<Y}=
zKL3+ED|^a+fx_^=k+<&m`TyuXUjlKzprmlp?83zC!Wl)0*^?$uFXT`PM{B2#^agcJ
zB>43}#%x2N;poe0aA$pa2f~iZ5}2K>!qMBb!SNYKd|d~7wqv3F1?zvh*E*v7|JT=T
z=I8hHkB;@u3}c7IdiuTmIBM`<pqH6>5-5CeJs4;7otQZ;^VHs$?CR}@vCJs6Q6Ji9
zH#Li%+ItL!78%fXr<rOG>H$aashJ8bcY#aB7&k1!rS6%T)}>5w*lDwl@o1x4AOF~_
zQ+v~^?onZSa0DCg4Tr{KaM_dQG{uGw2_$^RDR?lB(Ky>Vnn|HPCbS3)Lwm3Zj)bkR
z3yz55Rs-u^W@fj{tV~)sq_3X}@S!OQoKx!i8p{3y5XxbQ^x?hJWRJ*2sxhXFOhP<3
zGU`0QgwV(|&45f4_@j)C%ww~dB@;6k{v2Zm0p@~|fw}(4S(-I;Hzjv;njC_CjB%aT
zpglHC3s(kZ`g6qf!30<`lkz#;&Ew%F^UnA^q^k*WPXu--Tr~Mg4{}qnVK9feU`q5;
z!NeJ-HjQa5-}rzmq;`0kE6|QO+|QRN&dWSQir&bmmya|#Arqyy7XpFhaQTufqtg>R
z<r_}dalRo`W7B+t_QbR(Ks)aH!i<8~jEPG0mGF!B*h`)$Fq_Hs;QnEDVtFx-@L#^B
zzM*bOqdAs;=!o1Ca&?+>3uamP!&Q`vmsT`*q1G-VyztIS&=ISh?gy{<*_h+RC9v4F
zAN<un2P-mgOILIS&M*mH_1D3S7u;1)`<g!rgAH6qpYb-`e%+Yj%2a#;;=N07;SEE^
zqqr+lZsQ34W~gjZGvvOyHx1QKF0!>()V}5a5>v}TPXDNUVQ7@=)`GVUdw3KRni!f)
z#VCYV!~NaxN8ldU)$*NUWd$z8-Rs|Y3>`VrTq5oT?-<W;r|*>NT7G=MHHh!}SBu!d
zXf3AI%=O{#`3ofgxY?ICGS949WenPlK_0@eqz1n1Gj5KFuFyGuFL>WjxMzKKT~kG^
z<v%d|#Hb!w5Pay5mt>q0<>>=n@K68O5)@pxUbwocYDFWzcLkpsYqO&jY3yhIPE6bc
zIrHp=^`HBb#jyp^3Va7yStXw)uudiT!q`7Mx_Wj)#bR8^_oaV^h*t74Suk?H?^pgN
z$>OEa)kO_;vid9d+HV%YTHZ`8oQQs7MC*AQ>+<C_O~QU_*rw=eWebo?i+H?3@SUF&
zcUI#9Ya}{JvGOlt<^1Ss%cm^;+vlE;FlQs~6`xa&(W!>>KVm1$+2lu8E1j~k-~T!M
z33Il<jJZ3rs;ZJD#0y>!{*n$nPCW|z;4?A7o$|an$k>p;1-Mdzj$HvGUdj@LL02Ss
zm~*wC!J%pp2`&)<+$V1inxKnO!`|dan{gXzmmn%0;5zx${GjRunZZ$m=nO85uO}m(
zbu*sf#&{<Gl7=cQ`3m9z(@k!SX9fr>;ysP{L%3Sq8qBJPja~s?)G!B^$yb=;gMvOm
zH}tc^oE`9RE|1{|4h|kbL6a-uE9RmI@H*YT!F+selI!7DSgxOO4VS}L@cWt<9BSNp
z6AaU<wCY?hILwfr`*LlpJv%DsA3Tn?2-y(`Kf7jm6)!>y4mZwTfqTKHEW#m7O?;D%
z2nI>ITpdI!@pkg-C}M!(dQ`yLAk4wiBU62u1Iogu2C>M-qP2CH!j?bi@;D)Luvxfk
zrbr!>lEUORE^WrlcAEGI>*#J)g8}Xjg;NJbVi9I?EHVQ*-lY(K!lMH2jOt1p33GxS
z(BLNRs-~rNm5p9FF!(rw?<G#kHFaxw+R11m!zMA$IG8RqOFFQUU9HOi!j(b%Ali=L
zg}_I0FI*LzAVe&>TE2sO;p(75m@K}|$P>I5UbrSWU&wfLb?F-9Q@A#`N{H;}YJN49
z&)ea7!9zm!i>_wsdg1v-sy|+(6`btx!gYp9AWZ!B&lL#`E2}Ei!g>?Ff$D4l4rXh>
zeOuv%V2`*w2>#=!l)47>aHA0)62&1YEAdGcRUs-Ie7wMC+nU8lt_zGr9+LPABwQAg
zvzyddUEyMP{(%v9rQsSL2&fqoMa;VM9qrCC-+d|mK<Ho?snC2UBq&|zY#8;3MaDT<
zCZ9TJoLS<Gn2>5j7vRH%&ggz;L<A#Rjzw;80!)>ZT?s7AIS}u%9Tviyg7<;r#D13w
zGQC3XqU%aLE$kh#71qL%9nyOimd3TS8kwnH*vD{@=yI$(Xj&>C$HRjS8_W2PF7_2i
zf}E_3ndrKN{X!m~5#->i-AVPbR>KPq3AOG=Y2jyZFFZ8lIT}F@O3D-*e#0WxKYU6k
zloj)JKRnz}C@c6n&!rz4fFr_pMU<taxwbYHvLnMxbgzOO6q6~n>Qf>-Mkp4MT3O=a
zg#*IL!sU@GU9%kTT)0S>kz~xfk`t~GZVcWPoK{!29Jdzn1vH+IM^UV;!f|fl(cu*$
zI1xp<xuF4zH(3*T;W6Q3!cRe#e1b%eMOGo$S$xyA0Nn&_cjiEMCRtiO(g5Pj5L~?s
zjmk5D(&SBXxyzX|Rn(kD-C41~{<F@UiF1H`EA*iVF_)NJDIwVJ38JUZ6zl9Zy3Pn2
ztug)7T;3Q)2zIB5U8ZBo4D?d5#y~RVQqIC?gEP9<84<zg7f^y&q_VD=$M4}HUFf^~
z8Ajp!7!Ny%6Z^evwTRVhxU@42yKoa|Z(i2yce#MlSzY#1ni$uab5z&U?~A|s`gCE)
z!^QC&FkOkW!h?G9v@%q}dZuF->lvWIlg?`i&J+y0^kh^}t4g~acJ0ZONAK0^GMH{v
z#_Q-7@sRM5IImhjXD)T-WB8l6+V|MzxuYP%C*q%=cg@Or#jJ+Ps)osHyzogQ8jDsq
z?&<iKBA1nJeNH33n|k3N<Np#fT%=sN8tcZq@Hyi`HW{p(^1|oi8s2{B-&R%5uA7QQ
zShxmG%>HDg`$uJhe)1Xyuo<8Fz3>HNl!)Sds+#3!C$Q|U5zXU^amlHifnJy8jDJ;}
zH%fFRj)Z-C{*dvnpNoY8s4RM(jZOhuvo0kRt&U$yQR1R-c{~9_t({gF&)Ae<!5=G(
zx_GtNMO%hIt>6h-VT0k&oJ~fkbeT`s9KT2;(WK#y?!{JkW&8%A;~BGAaji01S4pjo
z^XL?*q)e5tCjM7pP)DJH<TvtgZ9FdhWYkeJF*-n-XJk-071p6}tTTGlN$AitFGuaS
zK0Zq9pia_mf4CuDEDUNS?Q?qJ#`sF1P$kJSHMC_WfT)nP5x&q6sEW+UCTuYj>LT0Y
z^}<btoWfwQsI)7Yyl``zw+IF~)7Tx*y0ta_ccG@6I)^9JbeBK!UQ5L?iyV7%-G6|B
zjyG|R{soi87e5wZuErvKsbUdkqSjv*&<c&Z6TyhDRV-5L1ehNp0CuZmAF^zBA{g<~
zL|8^iiA8?w#F#bRX$1E7j*TET!fGQf6|F>q29RWzI~L(Zn6b#4&Q_kYC5RSa{+UP}
z3^R=n^Gw|~&GUF?#Jtm}I?uWrp)x1LPvdDq5;oyD^n!o4L5W4~!rz`U8td)?gD<Ee
z!8}0=0gZ-;d8aO#3iyv8QXNGuFT=r{u8PSDe;Y4B{gCkoxE4O<-Z9)L8SW4h);`UR
za^7k9xM8Bvn%Pwi%V$+rV=<{0?ljh7812Md&sSyx4)9s3kVR{}Sopj6EzaAgoVS%#
zjp$nLvL65UfSdDfW8pJWMMf(cmaH`I`m@fpIt(1W@DI+lSY#g(1LX!j$0GDU7Kx!A
z&tioX%E`8oK8JwF7MvYPTntU0bE?)9VC3HDMFz0tMqSlsab5iyuF{JfrHl`z8NK;P
z4l^4`)@Nyx+@Tv8s6?z!bxi}R#>ml!Vx)nt5(K=+;Dl)6a*-6yl)n<*^@SH+c4YWR
z^qSKRUSx#Y@%ms!W~I|c`tW<I7a7SSfVQSjy@col)n@fsp<4An?q%}?-&o`rx@ALq
ztQtbU6iaiw$RPD70y)M!7GWTQh>mMq#&Xz#(Tf`m1;Ig$OR<h8(LtgY&jb##WXh)(
z&jk*;`Ix5idhu-Fpu2woqaHb^qaB_X9Q5!{fmtt}863p@J1G}L)dzar3x@~?J$;ti
zE<Beo$n*aInXbfHLB8J&^JwfAaxgjEKMFdw)Acf{9bu*e(4g|nVJ{eIrY>UU^`UsG
z$Bz`CYrX7&wLytL2Kr2^9}>I}7GPamw6dlFt&a{SUkr6>$-`??Rf=@M>L)a&UhrpQ
z;71$N*q3b&J7WSPvnPBV-2`N3bcL~N+Kk{8BPfkLrj_0b|1Oeob|s`)3Enm$*_P6C
zEQ7xr9_>4N*3HYCYq9eN^9_3q-`@_tKMePYn~CTOO~8+g#6TsCd;c)(Ag`AjqR;kA
zkrJ6!pB>yBJPAUE1i>vbWx;&FdN42ev5dD_v+$#X7u;&}QOv_&Fz5w8k=X~P!fGxy
z4{i%KVdRe22JJVls1I%rICFy`h6I33YB0xt(fChocCaBh7oXGA`;E?fy{0+1Aeb-i
zMWSnGO9(DB60s;R6^0KjhRBMpsKau5QkzUD(UWS#!t~{Qzk<z%?3t0n?E68W6+$n_
zn7gBcEk>lb*Nan|bN%xXuuQ;y!G(Sl<8%#Vi?5w9l-0?2!8ZA8FoVK0s##$sP&S)s
z$XK+oqPnVSO?hqAN~XpS4Bv&*Jt$}wnNp6_Voy#uOjv1(W&DnHSgU`xxSs9xGE0|n
zA8Izjl4-P+!Bzej&_{J0C)$j<b83)PSDP2ci{h)0RFlCqK4*U<q?N0cy4FzrqD>7o
zOO(6La6?eoB<Zd<#Kb7hKRs8bjc)KcZ4~6pj&gdi+^h%;ZZr{`r^RQx(Vn4`!#DYD
ztRr&fM;CKZV!2ej!ObS13!;@s^dI}|!2~&Hd%bv$s~61k1JtycqL~sL894#lWih$z
z1&N4xeKkV|$h=ID<EvjsMbxiAC-WF<o!pH?>!(*$Bi{x_v}naJ6Irtab*^KwAc9#5
zFE~1)?|3}gRCf*r!@;qU>(BuXa<Ze1^%c+$GWz~#XQky02Fp+|$QdXNwbNqu*w#hC
z@sW?^-5nCG0p|rnjFr4-jRfShIus;zZKyFCnZZq{L2l$n@-~dYY%M46@*<iGm|mV%
zrEwTxY)tgJ+|BZHhCc}j)|EIO%!zDc>aEa}oohtBjH@YGX0#~Bg%}*8>O<li4r3TE
zD32^Yj*-vudTF_s@81CDGDXurm>lw2gJ?Z>k9a{rs6hk4&bE?M!du+iT;~OaxWbeU
zA_pil8`M-Ifwvj2w-=mZDzLcBF?zx2;alPYhD41xBpx3RIH^0`RM`EZ%`!WTK}NL~
z%rNXB(Mp-PP<Eza55?<>DhyNql$~YR!w@$#NIZW&IMY8L5z4gsL~v#>8T+MCH8&vF
z76dm)VfLamMGaNeg{&?YnhGS4;hC*rgR=}BYSAn=T9iaqqEpy82+p<@sm#;_6~Sfl
zez9hd269orE+*${FxtaZMzGir7z1IXP*Gd67B78eFh!E5pVm}W!D*uH@AWdrum=nL
zV#FcSXtRQIBfQyz+1nhsL9!PSJQZoW(iR6T9jk0ffK%+7BC<ZOn8{RKUT}MOHO>iA
zfA26E3#X6>QtRJoG7_JS>^acEPeab0F#juRFuE$_EBCYTBMCCzLGupWWl9oW!W9@5
z2X`BnvZHk?be1T%$K`)Tb5orO-@PvT*-}iZMvmTR!qs0B`RCy_@hhQK?fs!vwF9FS
zY|&-V?gbBo?}^Z$XoYEU9t=5_3UY>cz3jaD+5YW_e5TRHgXO_D(7S1fU`1f2AvAsJ
z0`~b?5o<e8?=qjm+u&T&XyQfF6RLwn{z2H?kg2+_gL9)lJrd5dzHEqUed$FTPyidF
zrdz9@C7Pn{1>-j$<Z<+g<LPl$bg}M0Ys7Xa<aJc5QuI);oPd33e4JQi$evNu)r-%u
zt<P#h_d*%R+H;hYHHPUO#rBrQDw8K`4T~-grvtG+#|zFgTp#65U4ioN1?L;~;An-D
zTo>If0Yyg$GkQy^#QJ&@yD_LJ9l61fr~~1%7i={8iSn(_3obDFDbW?2SPCvQdVE=v
zxVISn^yuPqCSyMY8g#=HMOQUo`GtO++#GF|*L^lpjt#7`KQQb(!=6&tgi7op<G=#L
z%Jxbx*b;q3;&irzthP$#(SwUcILyIkrwS?YN++ZHAS|Dp8mg9<PmXOy_G&*WWF7ME
zGQ;81(~7zHtQ%Zz2z+%Sp>_QghQzlgOPVg?mB!=__+Rhje-!;#yvLWRs@3(i9CQR%
zNj`-+_%PLoq}CmR!PQYViSl8paVAQSp|3GCzCJZh$JbOtUu)<m{R}Px#huT56T+Nl
z@!@PXmy!n88|Ha@qQb{kQwiJ<b)Tt(MP~)eSv-7yxgKw)e5zsxMsM*5wnx8^(Bos(
zT7FkU9WUoE1UDJS@y)7HYVli4c=q~eBo^0VdzQ?01wS@%{g5BZY8slFD{3`gZZ!e<
z1PN)|+}lkOe(s}_rU%3ai~V2Y70oo-X~B@_+ySf+3bki3G^#xd?aJhuHvmm<Bc{DD
z5Wx&tFwC$R#5dyGOI<C#y`arEYzA2AKI9wXAP!?13+tDnkPkOp3<I7<e0!~1Wv3v6
z5yq&CcAG{<wIAFSeLL15Cq(a-LW=sgY$-QS2BV_dPm1ffXS4}<cC>z4#YzmBykLxx
z=ohVb-i$S3{rSBZ-_5<?#He;&5?c9=GunZs`?Z`ClEHYxqQ5k~hO+{}1mpM+IIhze
z!AXWfhsg+?EIAP5jEtIH&R$@tF;T8g<`)J{nu*Z|B!c6SSLULapwh2K=44uZUT}Hj
zR_4|UNs=ofrlr@G@Jge_7fUa=C32Ox7V&zSl3MNGPq$Q86nq=B;`PvK|2s2O(Pq&L
z{$)P;p-n^!<puu^E|#VyhAxG4y#HeakQt^?+aG9?WgA0GT1s1#tsO)^)HG(b$u3M_
zjQeLS^zpWZA>WoDCxKp?cn~q&t${L{k~T7G+DPPpeD(8!gF-C;7!OodBA_-Kx*Esx
zP#INJ&RS86QC5~|bdeD(imY(E8R~@S(u&k@th-@HMbE*kjr75K7;3aE06CQ%s<@$0
z<2Rbu5FfS;IToauObvP)?nG&Gy&yZhLt;AKOkW3mLe6FeIcOHNm6q4vejl5H#yySh
zYg+he+A%o9bPT3@UGPqO!4m&U<Y}DP?`0~srT(4ZGF2A~9t+!{jjr{A9pPsZ60cw7
z8dRc>hn!D|_(!7k?+5)()gQ^;09L9omumdaVYe&sz+ha)9oTYW`upQEY^Qof)hd~)
zn2=!_{AgWmr7$NM2J;eCtB_mTP@SBi%@@|?)G`m1ooLuNJ{c^QJeXu`qkp|*MO}mJ
zq4t8whV7@ts31d&k?BTF$zW}ZQss5=8UAJdg9vh0;vqpiW5v-3KL>0*jVsU@-+CDa
z{UBbL;RU^o%P}p^eKNE-XGNPT8kVr9(l<i~VEANds;7P#S~^kru&LAP^^gp$UQzql
zj_+X^Z5m3geh_xiqWWR;gp~+}z*LF7ydyZrUys0NTK$mVPtj6z%cYlug(RkTg%P%n
z)?PG3M56nWtAm>w%A4>a{MpvL5_aVMUrarQ*Be=aZZg(hyd2eFYFEq@u2-a$!mv}z
z<6ooNQAO-f&Df6FtA<TP(JiYluayz(Yf%$TjrHr&T;i*%7wY!<=-{&vq28+T5AKFM
ziyqeqDo%)RZj5gzoyUyBlN1#U0}l3L5l*UML77=YAv4Lb2&YP7QiIxAWp~F_R`8L}
zRWQ*S&anK$%~7DN&X(T&$A*f?IuS4U#7?Dnhs1)6fQ!uzt!X@!=OQ#T*GvENAgLt}
z#q<xlla*L#6ASoN3qjz-QY^xgYGV-wzNf5q(rH68>pl$*_LQ|vDY|<NUQt*nhnY^+
zCxP^vV=Qu>*x>4-)cm7<6{eHjxnu-(+eC_MjZ{j$%kW(lQ3(7>1U~y70WML1z#bT>
z?_4DGy?%*@CL-TJ{4hp%45a%XgBbXT7>9%MEdmbG;4rrKd|^a_-f-?nz2VGVnm4JH
z5+*=r!#oz@Tp>RBVCWZ%a1;`Y@CA>_%t9=}F<_>>fGieFli_-_Mu-2Wng#>)BFeiL
zoMxIDPGjFAj&m3ii?D`_MZN)(#mQqki!1k(^$Y$QZWxRLq%$C|x@iVG0rQ&iB%%{A
zuNy7eR1WH@u>Md7q;D95tZ0pl3;t&Gs9Chj{HAI4vQq)5=1@EyyeCt?R<7O1AxJt@
z-xuoG9lbem`TbN7Qk}aGtoMj1r?g^`|40fjZn4N9PF~yUOz%j`3eJ%E7wheOGks<H
z7H7)hBn~Mtabw4>3(OQ5BCmbLg@))7t*pbzHNja%-xYp-0iVshfch8<8e~d9J1>pK
z1H8JNBX6?P1F%_xd4pc|a<|}u2wxxDnNp{Q1V4(fUW=~fYzMcUV>n?QRQIoT5m-B^
zwx$AA;WdWA^bo2!FSypsc4cYfaGjY9lUd%ndQO$Ie|)`(Qg(D1=FxQ8`Ub=GiPjXD
znXMa5_}OPgRlMD#CaTmqjnb*TNdnBi(&D;WRxDm{bL7V|LoyI?=1kCG4?uf6qUByD
zj{0K}_Vf?qyUxM3m<3=rpaK$>qd;K~QauNHqR)gBdy6p%Of14KL@dJg|L}NFol!Uh
z3CJ=3k_<cMms)hGZACN2<K+%&GIV+(CNl!dj3MR{SPAQ7(>WPF+&V&Mj8ARE__U_d
z^Y8Pe?)9IC*^%%E1pP_S6aVL8mcS6fzhB|v<^~SeJ^ul*kuVd_{)1|aQOB%vJpUJ>
z8<5~sx&LdKDrcmYA~B9yTqkw7X~6tL`~<>ZhljuZL$UH)7bW?JP%{Q(&f3D&O$`;E
ze+X;6(<v8=FkJ@vW-SRL=~jXIL&f)ch;dW%N~rtc($VNmV`$+Il`n8@-qGk>AYMbI
zE7caEb|tiujBT-_W!{HFTgPP`V*-}TfCX*du}rREOs)6f$FY)Pd2}uTZ}DDx-d`bj
ztm(!3i`a?30!H3oy!zg;Tr=wVr*N|7H(-xtDo>;J*D2#2mln5Kcy0Z)60MC`68>xk
zdRkDg9EQYUAl5PvJSi?m0<o5^JP7UaEF1n>#%UL{;>CG1e2+Th<qVGT{qvdm$42nT
z<h;L*BCDvEchFzY4(KhSp90@Dus!|-w8vDeWry0|$bbZG(~ntRg;`Dif}cPewq3E|
zm>OI7{0o_1VcVk{j#-OdC~9Pz|1Hc@zvx&)Yl?3o`8Iu6F2dznXg$C6cW^oy^6Y?P
znothS;RnwA^1q5XKhh6DU!ks{oC{9<#XciEC=aQz6avTAc>a5g<3K##;3E7P%83bo
zlzimzO9n3mm8<J@{Ruvs;>8rjyUdU=e)8^y`Y!X-YSDMmrj~&e{Sq&WX43vLWI~?n
zW&Iv_SbE|0{3d-5pGVeShpxbCcsCE>&8tL$H|gh*HZNcDv&q*&8p%aGnx#~{1o2!J
zAl33HG`yNzn$1<Ma+;LquN2Xg$7#nf`8TNdH^J+-@$eqBU(kDVTOQ0=<)P4vFE@%y
z4?-xH;oC0Z`x~?=$2EUvn|WFP1$Cdx?6{3{KV;+iCVDTp==}~ZKvX)qZ4$i~#i!A*
zmU0?1?>th+^Z%iaZiIum-Eiy*q<BcQq}j*LQOVg)d}dtG7Rmpde*9CM4ccP)?bMnj
z_H9}DzoqswpUwnr@%%PwKlg7DZT9d+os0Fq^jYVJZLh5x`b$cDr5^{|7D(!REsk^P
zCo||9(Vc=Y4%!0QgW*)J)QblN{DjEOql52&fmrP#z1lV8o+h`J?;Gap5%#M<;x}S0
zUZmO359$h!j}KPDy^#&zPO#*tb<q73(xX}dULv>xpf~J{x)tDLf(HP&vT^X6aC6j7
z=zannekbH-p*qHsySDV)+5)Vk@ch0qh4GLG#3I+j$5`Zd@E(0_aHCB{#i=r!o#b+7
zNgy%LL(Vke`3pn~MxaJ#iCG%3#yS*kjFs%EktlNC(^$!$Ws(kaq1OyLN9RQF21o|g
z2AV+;&7kFhW>8Ghuuf!~VAloBgb7O){NHG(HX=mh5CmS}h8<BFs^3beK4vH+RF4Jh
z1aqOGhH8hnTn4>{>hX@D+SxHwPXu%rWlU0XjOXu`WZVer!)4kN)bI71fGIf7h<kTJ
z;DkO18^f2&(N$x)%(0`jeoZ9afCN*Yp>x$pNmadlFE(l%C&K<4c>W3T8xfQ|G}{{k
z`4(W_;|s*OD&{sPSUvy3fVs;BHz!I8v`F}Fp#ZaOlO)hzpiTK(?!5hpddpQ>nLW@#
zA&GmRU|z@D#3t&Gd~x@76L0f6-eD3lrrCR^NyseC-k+N6jd%969L3+iNB!kGzj1gb
z!{4O!_uh{F-q+FJpLg{4{*L}W@ZbGqN&3j7GQ2zo&sumJj55*vM@MfzmV)GJpHDh^
z`_GQvern21+#6?`2%E<Fqa?y#s?YWC^*TKF!)K}UzUt`f*ByQRrlYUlcJ%c-=PTM*
z#Kc>SO!ocnx_850&gyt<AajQ`qLp!nnxVn5H(FzGp1YJ<i0EN-(Bg;bzolxhs0phb
z6t2W~DMe__g9OCFe*Th{U`(H8?6ur>(y)`8W4&wJVtvDYu|(MQ=`icAusL_!Fsf7U
zY758CyEZm6JoCnJ6CR1xoVfDz3G>gmX-V0Vo5Mc2;W@eC;)mP9>}}zo;J3cNEgW{?
zs`+ashpXpJIefxNRKhihmCX|-oHYN$ywk%w{PB;>2wz@*W9+l$S$97Wn=o!d*mv7K
zL-w4$f5OmJb59DpREMj^hw<^@n%veU_s33OHhW1dKYZQ0FnntLUlxP|9&U-P3|H>m
z9u9tbPuTb2*z}XjCTwckxn$guSHi3dAK5wN$6?o|aP{~TKUi{8?A@Btc{T4|cHg__
zgk3HSAKMTcA2#j{SA05QTub<p7aZ@Gov|srYD277Z1+uJe(bcGIZI-B;h=|Oqr=>X
zx1Ch8X~NJYcbA3TF8uKHme|0s`oi6hw1rvYA1e$q;nIcgoF4YPYrxRzlk!%CYaV`d
z<+uqm!ojiJ0cEF!-K$S;i;X)w%nIiFk2Vy9UB`zj$A?|3Uv8e>c6-=;TP%CrlCXR1
zv{=seo5O211jqWj!^YFXZq;Gq_+Vgm^Xaj+al^Ln9ye_FxYJ{oh5N8A$A9ISFPbk3
z`~BtKTh6?D_a82s5Z<=o!U?hL@MUj&c;|-kQ0Im9^V-72^I|PO+8(<*)|UDg)&zt6
za5WPkcGo-OhMgW80GmzY!wK`kGlGHs&4_*?To6l$y>M7?oWE`9-DR_4XHE#8@nYk*
zA!80-wY@An__T1vg>B)Q@gw2JGhvq-A9-{FlA`G4@W&fs4{s}2dSV_jIyPa=abdT4
zPdxI-_U$cU)5BrbX<^TYo5!_%Htsh08=iDynhu-pQ0(I<nAl^F6F~g)V_A_1&#l52
zS@|XKcNU&W-D8`B$=#x>a}%Y%gUkXk#VZ1J9^|e0)RyQEA{T{0Rc?G?*C!@DHEGu*
zicij*lIs;20{Y)g$~-MMUfhAG%uQ6~dd0c%(p=A*V%+CAU^;rp2f9BaH@+mz{YjZY
zac*KmZan;hpPQ)3jR$K*aqh6g`Ak|oY&hrU#%FbKXLhbP2SMl%veR<CAtpTRIZn3j
zOz9S#(h|<<${0Q|E%TJz`1~grIhYSL^6UwoXys4o7M<J@`9Zjx2}4U*UT);rxw|JV
zo~LR$HX<gU<t7$D`Dce<p4}mUjC>gSkh&{3A-9XsS$0XLSig~XCe8>Zl6rb7b0+l;
zyot1cA3F?>Ks_M6XXeJs(*5rpOw0_<><|WQ<PjG<j}7vTo!yv{8$Z9J8wHtb)0`;C
zJWa#IBup5$*vcNC<`&ZXtS3y`SsAv7|2LV5{|gy5H2;%30}zhDYl=|KQ5>VXLU418
zYMt`PN&O|Dl;iPTPJ5)vgeswOCLXvNqe@9&c0A<Ax9eOy^p$F(;uzKc2yTv1WrIW+
zs(l4F$Efx*JXN0kA9&3%s-q20m6HeL=?s7C@w|;E^x8aG)ALVgd~fc4D19IcXsrQ)
zl-~vTOIuOe%85`oBElt9Vt9-R?M_q^DupSN8v*Y~Y3~8#$@;!mLgk^9iFk-V@8kIb
z57L$qJWPa(sEiO;Y6U685CvY_g7aWRpNOsb+0btkD@9Z`;nC1$?F3{3rDfm7!1FG^
z!}O-wqBuqsi3T2N3Dp<e6rswQjPx|78#myAvsB&_IG2)ZY15lar56ejGT~qA697l!
zfi#sifpd8iMgs1NNCCikR%4?@UoI1;OVX(ages=OaKZkj4c7ckkQ$mIDqo3cDFYUh
zfE7_$D6o`Dqq0;kz$0NH*sT1Ipgf?E3J;$b5duap@bb1(Wek0<G#|<&fkjjn;1O{G
z&eK4IN{hfEDohIzS%K7O!GkoSa+|<1Di11r0?N~P=%r0MVkY5mJb^cQJ5#Y34;-Q5
z67();o)o@}$}WLLR5WATY|W=>hsd#X?SsmQ5nt<kZ(Beg=@a=yQ0WbE3sm|<Z1dyi
zu>Wg~<MkT|{(uK>#LIAxu|P<z=uz-44^J932HL4Yl~FMTYU2i`v&s66F6%cUuW!YZ
z;e{;m+ld)`B=43D1hi!h(_Gl%Tu5bnF*BZ-?0aQY9uZiaO5b9ez7Vhx;JW-pctUUG
zT?l~w*lzzx5~V3Z^+m-os*}*R@~xseS#VQ?>IH_U%1x|%Q>k*oDg7<vM%-`2y}a!i
zFzbc~Ma+8rK8&JbC2u>`{svP$(O`OaromJf;XwveLa9^O2t@<YHjio>9+o?*3{YBj
zv2Ss+7&k?z{zP$%>O+E?V^nu2AEEk|;i<lDcpCw__n>fj+kXx9S%axkHqGmMprt4>
z+smNrGh*)Q4R&MxiHAu^^=rj3s)NyVFj=W`(n}g569(FgfXnc@@w~q6#C=63Z#&fi
zco2-Epd6!+3SCJH9Q#HW;E@^^YK!6+)t#8dpyyPd5Zn}@`mW)rzGrx<oIp!21DC^%
zMPi<}o$5n)Q2$b)GYAD0bpaIzDYVXzpu&clc}ew0N>h2z&{XMPS~GbIyyKh|Z9NZl
z51zDF;8)N-A(VTqpM>@~r5KW@G*C8+cSE~ZDAy8KVFIcJ&p}?>v+J-9YCD6(%j+Fs
zEpsM~(kSzfLfI{_h>F6}J%H~hONCo<)7}qSXOK`|&11s!k!ZKgV`^wJx6MoU%E-=6
zlbxL=J3C#L!9rPldL02{Bbp5O!a#_|Mk_5u*FZ1}=4mNfh`^kR2N_9azCc&3*+b5k
z644Z)Izn-bYNO!h7*$T}vGh?jc(o0#^s>Rjhbd6%1-eQkWm-bhbH&u<Rm!xOrVV21
zD#RLSYlU*9f!*^9@W`tGwMB7^>dyr?$Eb3ygfdhOUQIQQ?lg-()t-WzB2+mCm;PGN
zpX=}-QdI5{SV|YVK@v%BEv2P?%1#OG+$(nG(#}5=(oViucL|WPQ%pPeiC`J+>{Mt|
zncCe#6;bIS&XlD>;S%jCnC`{HH;k(KU6KI{ltzT893{||gB)m&S5xaD2QicIFcqm5
zD2`FRL~wJAD))y{hUzxOtEv7$aC406^U6o4zHWG`oVBD~>t{3cTks%|bnZHZe}wXi
zLMup9(&=4=GU(4#F)B%cWt7~mkQQE3Xx*uRwo<4fDi;f!OFNe<q@7n4T00z(y@iJX
zr}}rrF{&9DL9rN7<=kj`<Ty&}X*jCA700N`K4jRV%DK&SdmOn<G91+c#WAYYf}3Mh
zIXRhbkE6MB4M(+6ag6GZ1UJX1a%wT%-g}5Bx<2^vO#h>X!lq92b@=-Fw_zQ4`G{rY
z(!MwG+mc~BekkHcA!A@aB;ZIfOQq(xIiGFh?Bu9SHXp!ox|DOl2hiNRh&Xg&DbC-1
zl)O|_=YTPy9vAv3Hpj)Vb7ly0-VDzGu`c7|8}?T6^b*T(=ak0-WI7N#(ulO<Vz`LO
z%ITR=>^E3uB@XK1VIk>yewMNN#-`;>9(PV#LQh=aE@{hP{hzFn=1y?St;AXlk2}9D
zQ6t-u<pw0~>9#cG%JB`EdxrSM!1BxW6b2p?Z~(>qy_Ql(;eR7O?IW2yZu{+MXtyJC
zD{x1Xlr^){m<Kp?6p`Ta(~YGiTKuq;PT25si=6C(<HlNo!dk3i<^Edk%jKqHG35?m
zXS%SL=W!P;7rt-@E!SFd_bj)dai=WT4|A6+mp5TkERRCsu2y?G5_iR>>$&>J?iS+$
zJ1kj})0MdN$}C^vLa!-{Jg&4epU=6DOBOD1HIZF9<Z-{3EcNAbJ-d^MYgf#&NUr13
zrNvyiW%jS|i>7|w<N`0VgnjM+K(k<)i=(k52gR4mRRqcEc&^RVC5v3TVwO$nntZNe
zaRl}+anYDvSIISox&o2QLMAtvH9A}{BdZO$4HJ>&u16DD9*$-*k5$g8E2`_f%CvWr
z8@Ft1xiiN^j2ll)0&)+mO;;}1*645*nq9rdy={_o+~%Zdbf=3S7i*a;l4WUJwq^CQ
zN{ri&Z60z1qh!q&kg{2$3!}I>&oUm@QE9%YA$Mw-eEKnr><TNcIx;z-a$LM_vxd74
zOpbBOkY*!SvD(Du+T8Sv;96s+=MimOp20+wr9!L%;f$#QQ5Tw@Jxq|=J$Syr!wIIL
zc<hhUSU2IZ6GWEh82COs9O`bwW2Zf=d0*6koRzo_W*mas-x1&j;Hkyagl7bv8a(!Q
zpBV<cj#}+)JnT&W6_5Qr@_#Y6^47k!XU71Sq3g^~?fh820+0Q<Y9PHj@oI42keu3=
zdOfUpS}j^{j*GLUxm+3rD`@IZt7R?ka8s(vwVbWO>vb#53f<vjO|{i<h0S_gUth|`
zq29b%c5|M!B`rs_oa5M7v9hZ4+*%&$=&hK%rU|zq$-d20@xgoT-rf#ns-n7@3xL*m
zTuIQOuB$(#p{}_e=jC8)aV-yqSu5*)uzMV>K^<sYZciyFI59B@r(X^>hhIwaPr+Yg
zD+bT(|109mP%fTq?{D~vP6!b9e50cQG})mAK>5O51~gpIHE8SAm75&e>Ch1<wIf8X
z6lkQ{1v){{XF%vmzz+{Ein@{kq+uE0xIqq`1T<P~@E%B&`#sPY;Rd5@t1H8R#tJvj
zapgc7`Yk{j`t3j(f^VH1&q6&>>>dv^PS8vs^>-nV`nv>3?QV7GS|F1ePVOO~@#0Dz
zIvf)O)dH!@J0O0NaJ}$`oGj=8AWf_1fHbYL@gAvfR{^OXHv&x*8+QO{j2;A<B-}Gj
z?nNi}A<$$oJsiz@fgqlOtL}{jnj+k(jw^MX9B2d63~#yP);YP09CwxDZg$+y9ruXi
zo^jlt9rupoK6V@r2riURl>uoAaoL5&cN5T5F}(vw)AV7WiNZY#q_KPhNMqR!q_O<k
zaRCN(%Jl+Lx&Dru1aykHceO*m0-7e=mp~eppu0``BY{p8(?LL|37QFXx}bSL(*<1(
zG(*s>Kr;p112jtzj|AddnvFEaN^?9JlD8T@rimi@)Jsf%g1-qt*W=w%bU8}4B9?YV
zuRHWNltkq|aEOy}%Kh7+uJB5^0*6W*;tZ0SzTnX34tdB+HSOonK!;{KROwK?LzT!Q
zwOjAdr4C)^5OZJUGLavOve5Ze)Z$PQ-B9Iz<j_teo^pS5=u&h?l&eDZq-d{0Gtt3P
zuGOJ09ol)YH9Zm?8I{X*=ob!!=*y_-D2FCHbhbmg(K%DOj~p6-u8wl+9r~F=CFsJb
zX@x`2IP|_lBhXb*xj!Fa(OeM9UF6Vn4s97=O?Nsp@F>d_IJ7p$au+-FBZu}m^o2tg
z541L}ap+Eme&Nt(4$VB;+UR<WMN=HAaR^u6m>7*3Y|#<NS+v2Szc~~?-kJ^?Vo^Jg
zzHc8o^a&6$8}DUws6~ApIvGf96gYH>GyR!E4?FZ25HbSp{n>G^I_?9<edEx<xz>+E
z9XbL?LzU;y$qr%Bgh`E=j$7bRokJTOy40Z?9bz{@{WuIrV>!;D84i^IX^a*Fsf`-P
ztpGyNLVVA6+z*}H7eMOrHxB*VnP#JVqIQP>smtRWY64Qbs~tMuncnQseGa|k<n}o9
znlt?jNPWvhCqjK245WSxbtvDNP6JXKWe!z4g!7G!=_ZG6bLcT3_2Ul?y#S;s`L5$W
zaNM_!+wZs@XqMEK!+<oTM>>?}5U+_;(+NOoW2!^59Gd4)g+tXq8mc<StpZZ_&U0v+
zGu`F5XB>LYnZE7NdqA3gpE~X<#|7wCYDf<PQn`a2I@+O=oZLbn4ON9hRnBy^L+gOl
zy)BO0>bR>NcZ1{Za_A9<UUqU{JM?cL4S|pDouWg5G#-;2SLo2G&a}p%wGM3n(vV*4
zxN97G2uS^S)S(^D^kpEm`>sP@I21vrQ%&=L)D_%yZO|AX4f8A~ca}rT9Xj8k+kw=T
zpE-0dkh=1ell!wndmZ}Bp#h_;D@Qvt7)V_i52Rr}-J$so)i_k|Sy#}&a_oWHha+|k
z-x$ZS&#v6nj=SD*Z#r(T;|BTGJucK$yYn2!(UWo;9miE6%Dv>cJ&ub7*1aqsm7DH3
zUb?5;)sDN~agRD~hvVLK++N2;LhA=tVW@i_MJ(!yexh<2h-Dm42L5$MG*P)+8IMDY
z-+%Ud-V)!ean4<=r1^U>)C3+xR$TPFYk)Q)Tq)*GFx;+^VtxaL8&p!vU%>E-SBm+F
z?l>k_=4e6TN14#)Oia1x?Vt4feh~o3Sd)~Re%CJ&>U(7<jVQ|xNeCHUpVs-uox=Pf
zaUsJm0{;+w`X63&$RATX^t-^F&Vf4GQ0SyXhPV5&9C!Q;H!{qf(0?E4!Wee^@pwM|
zy5I@@5Ae6MUo#BVRb)a0y|WCDOyCclces<l-_Cy38ksDS`5s5WuQf6VEZnK?<Wc(l
zz1>BoC;oQ+ZHCQy&~!jUaxEZNf25e(0lB6j#qioBekw>Y&jW5m0;ZTZ0r@d6#e53L
zuUIK2gqQq2m16pW;g_cra~v3cQ%W%tHJ}n1g(V%Ba-45ilNMDqtn45|<AzSm#!d{^
zaoL~3+d46ibYfoW#QePz^Y2bfx3o7w4F_~$CUjy-Ix+Q~n2S3x9Q)dz`t{RJ%)_0S
zXFD-}@5FrDiOJ%NZhq?5k)4<mIx$l_G4neyb)A^=J2A;l%=Mj^Uv*+$?7*}`ms?r2
zsCh|w#iB(#ht=rhGmycxHP}XJaCHN>c3OkF#TM2#FIoYU#xy;56FWVwFTlZ6PTNt3
z$x9C(2GaMp+Kb{jx6WOh9XBlIjvO;O&r84R%j{&NLB6|X{(zlT)=l$)6rY$(JpNxt
z-Ao@du5LH34J=6)p|mf-*1Y3qV9VNXz*e970Bjle_4h!6-*OM+kW`(ibU_>rR@&6S
zt>9LU2XgCoAj_0jt*%<^%*(5>tHtRktsj-Fw0z<+-?ln%xG@2jhEzDKDp*_BSapCj
zwh1Fl9pw<t0-mNR*KAm4XW-1G6;0Jnl7X>byQ~ba^T3xg-4beM|E<|194NS^v8Hi)
zT}7pHM9<o>HVT$%@wZka(CQ2eDfY`-lal5Y@);@>aKr;&immyi`kKPkX+;9xK+JiD
zR)Svv5l<Y7k4Q8+i-ra#-wdoY?~!SkIi<P&KtX<cutKGBFsqz!gl+1UozqmEKdPy2
zOgb?JF>RQR(?2^1@%u+QNkb>WfZ>CswIJbKRgnr$IX-l+XvFE2<%^IpC}SPtBso)x
zLtFrwYg6wE-9b+3S&z7l3OSrxH!PvQ{1Kz_M~oRgV#KIKV&rgg`ghdGks>f+^r%t!
zg3j(b-Df`oYdp5<TrU@*r}r#rR)pci6f^;`jnsKw1)c<+^xh@3-}{>gHob@Wy+R;2
z;u(ffTKaDU+N3Km^Vi{ra16`mSSI!3$a>e|p7%nFa=iB2quhwRln~Ir(H`7cgfE7d
zD9yf!$Z?t=?Y9>Ox6Q%Yej~?`l*pZc0bAN{Py&m9$}mfhwBt`2ANo5A9pALylfd_{
z!k0oL=lmVh(cizpft9PV&HF&Pu^r=^fO~V+VWF&%gO?h<{CteVQ@^v}Q8VN^{3QK`
zk51<fhuojnr!&BiOYe=+l<Dy42BNed<T~6|T^hk{sM)x%`Kd^NOM-iPO>tasKQ3(Q
zsrOQ2$`X3PynnbLHW9a}nmbDiBDjaNZ?ZI2Jh>#<yQHZ778pPpH-~=k_)`UOKYzyu
zzfQZ|Go~*0mV16zLUvby<N@T<FTu9At@h^~)3^h=Ieu|LylX+P9-Hq*L~v8_7Nc&u
z0eapwU7EEuD`V`R&R-=FsN6bbuHRaaHNpG+wd2<J+f|T7@DTr8@Xh|+*N*FPX)7#B
zD0s&&yyxw>JvMCyTMYM#lBY*n=j<&mY5x<9aaC&jSVnBl-qz9xj2XT7)`tC074-54
zKP6Xkmqz@ZMRUta+HZn|<areFziRzI%zb-cRK@lGy?bw#O$h8l0%AoC1P~BH!b3rV
zhCmR6U>+m^c^OCoi4Z~_yc(X#+AQ0(V4>Ao47J*7zi6pdYi)t>C=a2E_yPe%jddf|
z7Yg{O{63$Vxswgj-|zR|@3(L>XU?3NIWu$S%$d1&W`3-%gGF8i;d&;vA3-RBKLaVA
zJtJ-pMPP3DO$0JQCVq%@7nte9ZsBdLyf!@~Z~M%v`=&eY1`oWE8`!(#+L8@*pIn<&
zcJ2JnuEO^N;a#9b8i6nBzVE*D1GKF#KSu>UDuY7B7kN|oKzw>(+{izCjJ}ieCQa&R
z@UJnsaI(=GFBb=5#S-TiRL`%fE-$JqaxNWpZUa98ISlwGA=SX<vHW}3yVGPnehncD
zZC(#lC=}q|nhy{7D*&K=aSQhX1qC)I0}6x&@b9xj@mJotTX(T{^<?kPF=nXB1njNf
ziHS1PorL+^^X!dhJ-p+3EWByno$*#^s8#n(@0znYSwX>0ZdUktT+JHT!kkzc=R#x5
zfWH<#Cd;IHV4}9)p92h>T<J`aPL_1Cr8AFCa5LkE#-FMC+ULFZJ4{al0#kRfzt?|#
zX9yuAHP2JG#}2mlAM!SEcX@CN<BVDRH4laj2v6`?$$~o&nvbwmF$er~1p#8ee5vkY
zQq2UJS-Q+Ydb~Sb%&LATCcUAoqbZl_zKLF%5DYQ7k_{ny*XU4cIw~Jw2wCz;K!ns?
zT;TOHip+OhKxD6(U~v7d2u?Y_-#;EHp|Xp-^%H>!?3e-nUvGj$iMx9b`0r*oYJQif
zes6l+Zg=3#x^J%X*2e<l-Ffwhy)_>Nc91M6A_uonB>X39t_p4@He~0VuQvuGMVHrq
z94Q4uM6bQX9a|xLLa5$IM&SCXR>Kx%zN-ECG?!fywTt0vM3SAn_x>IcQ_ip1AzG#8
z+Tdo^UvLLytKT>NW2@Rr0SKSq1=d@L_McpJU2rp@pb)&^4hk%<d=76C7e4z`YSm6^
zB3i$<B2o(?HUIhQSaj6<@Xl|9Ov!3gjqKeyj#B04?bFT`%_&Xm{Vd3(UVfeff?Jb!
zLD?MwxE(d@JhgzYQctH27`q``e8eIaX8PQ^@GSgIh({db>-M_5W=(JX9iRz(UVq42
z|2xFuZOYw(6?R>dCy?Qx=KK?|Qs8e~vqOluw|+ZtfzP8)csDm)IG*5VH(0YnbdBn3
z*X$6T13}_4dRgK9_KbLQr7Q4eDD%TWh<(gypL*ViF1eB-gjNr25)F&$NVh``O=x3+
zX5i((o`6sayT7?Uu(=wk1Vvgw0Z#~uupF6w7Ov+W_q9WT9=+af*I))iB9>^}>>Q9J
zf`r|DZ{TR)jp*YwPX#xVyP$t4{`Na61+(7)|D{#kLGenzi&EcA7_oc5nOt+R-!}n4
zugY9~jg*-6n^^_p15$hhj}4vH>|iw+)#HL&q;yYTzsVSe!qp$E9=!HFYP#UF%zXX2
ze$a-)-PPUeo2t95-SaMJ0-sMvZ!p)p>YHlL%K}OkgF6_b-^G;kvSwQ1AWy*>5420&
zUOVWf;@U*j;-mUo4=6tvnuI99G&|+|E8(o1?C`FOvJPf?q;dfxP`Q+ULM^-5F={-r
z!F=A$djszTuk)YuZj$XAs@>HyAUZon_RfFn0@fvIthYV}D`noDam?BaFz|IslXvIm
zDTg+U_`<tsPns;W`3e=X|5(jO!Dm@9b>~edflYfPNsl)IA}BPr!ZZ(#nnnHbvk%Y*
zLVgYzEWBtnp&wG3{D-PzrDO!Y*={y;S|8`#`C=f%u7#jG178Q8Wm9-}9twm+Hy70&
z6a;6z95&bInqv?L)Ymk`yVFJrvYHmcI;iG@ph!jvFNV!nDLa908@jvFf-60eg}MWF
zU?of?69XSJYgr5(A`2Le&WAz-#W0grhv7#+QbVkdYY^k1w>}Ltb(c)<eJ`W=#9+3e
zVN(<fo;KoQ&6hISwl&cbi%i7D=$^VJJ2<#*4|;VV&l9pA3fW_VWACLI7QJS;;q_la
zR|Yz}4ElCVaLT<NsSk6qQqG4TJ1->Tiem8xC^ZaVO3*sXe!!M~80^aOwe!~VBOvHN
zDcJepXTD-<vBQbF7%9}SH*^d_6ZpDrx8ZF#Kv1Az&9r2wOr*%p^rV~*x+vG#o`4VG
zS7fY{ij#@K)x%2N%#rFeG#yuy)?RuHLhZe8JK(3yUG$vz<aEnBXU^}-@cOR>_QaX}
z{^^J@P!_`WZrY0;>R$7$S@-58|0VBzpQ21BqI})J=*81f-QaE*f9g=px2KQG7%p#p
z8I;<IL#NNYb7oC*#+onFy#9Y<rgP#G;NE@b%;^&%Grp=g9hHFit>`GP{|u5(IdnRz
zF9Ob9E%l8ed-3#pi2c_2eNi>>b-NQz9a{Uf=nD_;S#|pK@w2Ye$4^8hw@t5R7?@8v
z9W|V(#i`)7>3FV~PTFPZBqN;xvban~1V^Of9qpvD>OIMd%+smbO-)amP-g=r2WP!1
z^dnL6C{2st;t|xlcgvoY@2b*-RrH$v$i0uu^=yZd4JX2<RZQ;$=F501Ka!C`Ygs3w
z_!7x`ZxGdf`uOSN(u8yi<s=%n`YMU?Y1ED0`g}B7N>kk-*at$NJWI*>;;9R-ObFC?
zq^?Lg-?IGzhHRmD_KUy0Q_f3uiEPoy8MEc5prHWQlXi)5saI$`hUyLc5b84kW5L!L
z<r2Qqb5w=zi=f*8nEFZDp(YGC7mbL`=vLDBYwZ!R4V_WnXqknMyx&g~$UOTZ_}TC0
zKyIGh8G5D<n1-JU(LDQ<_HzI;&pxdES;BvxP(LLbf}1&pWM}2(gx7u{bcAEW1iq+;
z4!8kT5zO=iuMRG@>vnsTy&TB&wCqQPD6`VL)4h{b7GX;IpG8Te=}5L(THs|mBkFeB
zfs4B@UY~NH-vOmBBbB9hr-j6Yd73U%j7-yLnE~I06RPMf4}E#*QkhW}gMq*Q=Ys9J
zi<bAki^xhCtuQmzBtsw?GCo+pP6Gc5WqhF8G#{)>)u0U_|8eNq^;=ju7f#l_pU|*{
z!qu_|SV~<mL;=F^lnGTu<&UOTvzZ>qrlkbjt=T~u!(0Ckgh6FP#dU+uhVi9pt>x!v
zyj^^k2IbSZrzKO2A0krqYHHvgVG<E|8`^#M_t(Q<3)~5MaPtN#maRDO!rLubK&|%+
zHjmexNoWuOEw=z$28m4rm8g_1pNUFg6=7=LPWtLTgV{uq=%e2H*Wrfj=uno~!ilbE
zW46uPC?c|NIm`yjV<7}rdAblUu~`mj1-S{j@9o`6jcBD9RnzWN2P)Lj^(Vdl4^Ue&
zg5|A$3=sk^?iala1!HB}a{OJtg{6!>=fBjjMGWhWO&(>DvN2GzpCF<2LZ^qe1c7Q0
z-PV6B<o_vr-iG%O9;!4`j!AydKei{=edAqy`-wv*cH9e+lAxc?GqEKBKd0m;noc}P
z_vDr}^gYSIpr3F+{H<$BJ}H2=TaF((aj3zLOCRw?%^yx557}{nSL<Fxqf1-R-ftwO
zr7yqAe`$5}*-n8sc7Jkxb<CanjpXz+pgx7!SsY3oF4=lIx$fIGJZ)yS&w;1S|COiB
zf+z8}ZckgDd}(7~J%A^vH64y1+Eidhb<g!vFNLx$t@$>&rsIbFE+cUCj`cr+uln4Y
zZ<D<BR%_!_cYvL=e2o~it(ppD-p0ec?K~8wt2E*Kht}UuOTNM9ZTKr>e}9^JV`!?Y
z?(4a$x&~eh9E3@~vj{SN;d@kG;FShz%=7a~N=h!Y?8c$`2hsEU?FpqPH&`M2ezU3H
z?!ZBiHDJC!#<d^aMl1{TJ1VUTH9PbA--32g(-Lp}KdF+$<Zr~$mGk@U87bh^i9s=;
z4uxn>^*b7}O=16e8e)CpNBRc<S@T73%Y3;0V*xSGt40+`!BR6EbI*qT^}-%YP8)Hw
z=3MYuk_Vopj0VLtS*~oLOG6ci`9ez#)DOl7jvORL!6QxX$p{siwq?er=#d}CW`$RL
zEV^c3KP~#hj4cNm5Bk-q-6syU{0!O&-En;<cE?PQG#+98c>PTvksP!cs3arrqm$>9
zT~f;+S>dNeKCyDnTV~F`0c}+f{<X}#<y9mFc5=dJ&q{VgN0ioGOA^#c@L3KF1&G)i
z5%a@yRm7{o@!z@wC8q=a&(BdEq%^g7ppw^%?g~9K;_C)cs?||-Uw^l<qwMBZ%CVNt
zn1l3tnf;%Y>S}R`$vSnQ9Ee3#sv7Bp5{3Ni=b<fZRM@0}>p;KXN=`Z1vJOz|<c1YO
zagPUQE#)ZOX^a&j3$1HfegS<e&ApcHC?N!QAO!cqiIy}>wVa7x7xdY*mb1)8s;HLR
zFpn4ArsZ{!C9`SIY#u^GJ#D5O5=vRhoiunM9Ac{2awi&{Yc_|tW^<dI4utH$m{2SR
zd`qv`hy^0KE+m(Xy!V~`H%mu};tEmADea|zwfqxaX;0>f;SMW;xobcEDJVlizXdaW
zp_$FunCt~Ingbc(U}kLK_<@X%g>+_oMzd;v##iS4jPr26G{Sw*xLoRdyF~~C);nU>
zto#z&VE2!^&QxoLD!;%75SvhjFPImbg+UIZ%W~Aup}oq!$V)jE_yD|Y(7b>VW}nfV
zEg13qZyDJFX(S_gU_>knW4*ENV_zskWR?})BJ+w^4@GWuANS(unGuU+n^E9SmKphm
zGU5YypJkyoz?D;er_iVXBRo*$_d!?`T&_ev$7)jRtwrKO1l&!EVH*eK+SeH?3>)h*
ziwzrdxNO75Y<Q_*W07*M_;h8F2cJ>6YGU{?#WJ5^`pl{LYuF`*36a5(r`C1YM_^hV
z@h!h;cQi^x`sLy?oZe!Ur^07=4ReaY-2l0`$rE2u#8_Cdl=YvSGI+?)VK?18e8lMV
zF=I2vwfYO^%q_y@A!^-rgK7`)>gd1yF-kU|q_<H|{^~*g{(9S0<x$T*`~1(x4f*}!
zuP2_LFe2gaJ0~&xmY*iSci-}iTMZ*&^oEF^*~#qfiED3puJLp-JDWaKldG#?d2VSx
zvi*cOd^zJa+9Q;p-3#EY@Sw19rsZiL1)?YuA?^+`M%08jo*>!|-i{2DUJsK%<<em~
zF-Ttp<0~Je)UkbgC#6`Cu=aN7V=zX?F6Irf6XKYaH%ef9eNgaDaY%?8J32F*p>c|J
z<cwD+2=*|zi%zsXiMlFo!3?>*O0gq&>!#Teq*u2VtbO|q?PJ?B!jG;pTN%Ell>#45
znWp6O+8*GNTVk$LRiW~_J_+^4s%3E!L>38A5w+c8XoRPyB96KtR+1(vQc*gboZMQA
zy_3w_Vnxazo)E{DOmnlWeOjZq!1@i5bgfi<Bd8z%{o0#(aQZ7|kR5k3-Pp=|Ys>*E
zCdx;efvx;AyQBy&LI*Kja+Ta3V%OOun9`aFUW&GQ7=6gKW{N1w)b`VaoDGdKQV?gD
zjE=2LL*Zw>Hxs~0U1S98-4d-3g^gIPb;Wc?A{!-u^rkXa4p?J0n6EOE?f`BjK!V#~
z2ODX^hrEop@g@<v06*Kr#<+wrYG<50n{$wQLp;|gzGcwD<rS5S=2fW!IR_3&8kQtq
zSB_<p__=1!o>yKoclMG(b#qAHIlx->?Adc_aDRGfxei$YyluMY;;p#h(&QzRn27r9
z!?2#%3U8F-on+c4%!w$8yCNTZ811*rN3f#dN;KT%cuj7fG<g6O?k;c_(tFArpGdE#
z-Cvm1X%!mlUW7}Wxcd+(yseNvH_rARv#6-pu-{Rrc%sDpHuf2X>gMLXfa<Ow`(5)@
zylinLc6W<&!>e$^E~3Auu-CS02aRjLue{f}d9^bx5nHsRaIRrDo7;Ob?)7eUMW_9N
z$|J!ouB_!(7KZ&V^ACcomwN$DEtj{q*&mwsihTRJ(K3rFamua=2&;f(_rk(?rO2g4
zr8(SPj*k!Um62h8q)@5Icu{rX0tbIq;nUo5f2aMiIa$=+ST}cE8usVrVZq9HH?IAx
zE-n{)QtdBPv?=bw2<$oYEWX}zB~C><;ada4{?eQx5}V;JoLgPGq?p(-ygvIY75{Gc
zGTeDP7o_LSdjx5b8(TJk;c@Wx1@mvBW#_w>WmPT`-_qI_&7TOu1#a97CUAoEYeib&
z#$`A>u3TWhQP^ttGKtk+6WQOITSPj`+!Z;f^f}nOETVj;qSU&VIr!E{|1tYR8Cr>J
zOm{_|xGPk|`Ci1a66;O(GKp@Da>?9_e5}L<gt2ue7Z(@d>lWK^H4FSt+u-qCk!`x7
zdNIZZWYQW#WaM(OLU^s8y8>Uq7`Ejaf-1KXA28j{j$GSz@gz1Y@z)y1RHGDjtLesW
z3p?6%mB{{4WY0V9U`Duxifp$bZDK@*9aM(fL5Av{S6R&a(S0t~9WU(@jUcdsyptk-
z-gK8c<abseMrRlMsFnD4(_N@`)7xEKH^H2+5}S}pKE8D_?5?hVK-jFr*FcpIF~E&R
z_EoMrm>#^M&t2}|x~bGoflgeSV*f~`bp{yL87>+&>}wSAOVd3k;=BaAyX$TABs7Uj
z;HQ)>Eau_<_O&Y6O)hE@96V6X-gKSo7Evz`xZFi03#$2b5=sD(?dhT-uo4ft9L=Rp
z^04-EcdhM_SEsk$pDy*;Y<0Sab-*vE<gM$1s?8<ojy7}>Jwy#?^O|Vh?;dTlk)v&@
z)0lqvWA(%hQLsY@+g76M0zB>td>A%=QBjp)^>X!rwFsSQ#45EqJK}hdp;omBZ?}Uf
z)rfkaeqA<(pOG2X64&h_wvA4K%i0WUsf(L-p=9053V6$<VJ&k#ATY7)(zxgb*QprR
za@U^)(&t{5yBwF_SSwsF2}Hab*Um1GU!7S$c6}<4-Q3GqyM|S(sJf#&l`jyel?s&r
zo_L=qKXR(XjfOJ9D#c$fnd}%GMpB6@f~?gpFRVOVScUwtJA6^4_{_~(qsRxiu~B?U
z>D*$dLns}5%f{Oi=c2mSDvD%O@c=N_fz{bjXsyxkdie)Id=naNr@$k_SScdR%YN#m
z%zL@d6hxVtXrm?)P$bbW5#)=uD>W^vPbR36c~}RrB4rR$Kn{P^K`lCn5P}#v+I~$F
zuvS{*3T6@h6~bd4Km=>6i^s-wB5cNF64Til0!(|t<E=Q01F#g9c#GLnSgKasS;a;*
ztS$;?yB99YDy*K*4`B_ftHOHP1)1ViA`x6B+s?#@X?3$67lXPF+NVO^k78YIN&OFL
z;SG$2^&{)FAcCaee)wXFSa<6`0tH#Yo%d8v*0l-+S;4oFyk$l*aGiB6tRP;lja!iy
zENJEIdMjN7KupFikU1q-GX;twvOs=tX!Wp`3tTdBxyu)#&sh%&%ur%fUrDt1Ufq>A
z9DSv*ylBxvTy)D0s4`E5C@v_*Q3qCUi<{D2iD?k&8r(!(UQJD8SbePX0zVc_asw(o
z+I|Wp?7*HbrR+_3y=(z5t1O}&831xNNVLs;^OBww6hW`V<$WE_T9M%l@=~!Nz6Gp|
z&&s(hzC)BKh}cT3u2v$%9}h%llQs6kwCCz*tUnnpdJGGMxT{56)?;fJ(2XJ*nPkni
zCX1lwbkM(a5FrF{o4@U`ix$=J$eC#S75L*EB`8lavaION7}(=^;g%UwgJ@Q4G&f~;
zB5X$6$$&eXsrV~9OAPt6=K971)1Gjw)vnV|;epDPrxsbBPB&tB6ILoO)3l;Hk#U--
z&PZ*=bYfjYi*hcB^oo2BFg?NptiSnwia8%lxYm=6tQ|g?hQU!zA9!T#_3>aKCSC5_
zpla<?q#k#n#vSxsFX&<;qvur>!a}rO^7R&BJ~uAt!l$x^^|DGKo)~^OY#sGUe!Ib{
zEiRg}XdJ#+#;uVe>=i}b-7QXAO6RSdRW%D?>R88AP=Xt$a+EIQMO$NdU90t~k8Ohv
zX~Yz={KY<=qS&6WZC%yrFD!qBxKY>Y)+qopfa6yT=Kh9N;@eA7!dccrA1?us`lwuG
z#=)zySd2o8d_NO$F?xZiavl?6RVo|?uyk-GKg_mjeA@*j1~J^VHrF9u;@dCKzIO3c
zRZEputEFYWe~WOaC8Y$G`>@~ucA=G^5;3q~=<|&bC}<^KSC3In(Lfz#EP{ZnRDNh7
zm@vHd+*;+EE#g26Nn_ty?OP!*&_UADG^{ngMuCD7N-v&=YnZIHib1F#Iqa@e2q+&l
zjj`$!3fjl9a}BFrA;*&K@*>(+)uoG&qTlzq$YVSW0I5v_KAtGxN}Qy$L?x=gEB>^O
zeancW{pQ^PK}X-)DE_VjrUScrw9QtHw%M_wZ8oCRIDcRi26+h~h+Qk%-mD4O9)bYa
z=QQ?R2kRw-pbz07G9)G1KBCFkG+qV)dro5qI#@Yu3)L$0Ap<~3Lp$334gwo(V+}}g
zI!(tC5F;R*Cp$#jw`nT2naI(r2IOKL#I}<~)tNa&Yc$cJwnTzAf#ZY=IlT-g+I}5>
zJBvA(S2N>P+_O!h?Z-eNYnW{(vsEhh0)kpi!}6lyW!QkCRZOh4)AwUUX*Uh|S-W%}
z!^NytlL(>qsi_jDdRe;_CdyqprMPmTy7AZAqoR2*$MI-eSF8kFma}tUo5%Wx@378x
zzs|O(xC+MP0Vm`C&bT_&&0`%FD$-quyV+D<KcZ7x#G9h6f9lkt?as&(awGmSf7p0X
zjvc6wT;lw;s4nS1bP;fTRKlO(>B^gkF<-ATqIz(whOX*57q=eqrsSxe5@P~W1N%KH
zQR;EK>-=hQQ(9CniSTqSDXoNRjOsl`O!i|zU_|wsAUr+;ue-1=(sd`Y6ALf#QG>f8
zs4Ev4jHn?pj?opHOqXb{-L(jpCK^#gDFPU4x>g8|hDmR1*K+BV`TLA6Jg3eR)rV<0
z+}<Dq;h$d!{SwtzW`rAuZI(RRCKI+TXEM5BIZ?rUMbCe1SG%hDxLq=#4MiMJzO!S+
z`c52Azq31-72p)fwWZ@pc(&K9Kvr=)4bS$O`<bmPN~X%};&42k-N~e+#x$d<>}2yJ
z(6lEUYp0m~vA9O#4^t6)uz4GN9G@%1+;xbW_+t>|X?lh|R4r0?RF@%nt6h&$GqpJ9
zlr|eHZ}7)D{sHze>u!Ag?k*~=#E2uOjIUa9?Z`k^DdvTu*t~%O)UaPy0k{h{0{f<8
zN4NWog*k40+FLZCyIjRp<Ai-e5sHBw3rO!;UkOTFpX`vlr%2)*lsw+ceqZ4+ro(=&
zS;&hpvAf1@R`~AD6#HZATajjhyIfY_zZFF<iBRc%qOg69IAkp+;#15D)I_Y~kGFs0
zdKU;`_}h<&g$cGpF`MPLVpdIUA}-&wA65P+thivxXV{O4H3l*D9E1BK?cce6f%!S+
z5g4<JQTE@vxJKhj^a%zyjM{nTXDWYs<L%Y1`?@&UuhH3y1vmpY4lEGq!A_fk4SR;Y
zPEmN=ymuBk)G0))8<z%8#!SMn>lK%<p7bT<wqGGTwL8h?yVoU^Kxfd5FD)v<gvM@A
zBymO@*DmwT2f<h@z;5<BvnLEeSx0rIG`t|I>F8AT<}byfoQ*{~wM^ny3yvOlmDrjz
zdqMFM*2cXGAI(J_2-;7Sl%uw2y$M`{Sk*#}wd10$9WZx^)Z>jfwXe%AFjK%wtnwDw
zzcf2T6}hYC;)?b{j1!CQDMdv+pgN4<uAZ|%s7CuilWRO|P1ukU^(%$y=EnZGc@p=K
z!VQ41Q61U8R){n=4t85C7KgT&TpV&GPH}S~aCXU}N?4MH{je(FR4G1<$~#T2{%$p&
zLjQLq-sPUlU2e05vbBGs7@grRLZ$!Kq}Ad|yxWN5@pgti)#OP<vBERfzTVD(uEpxH
zVJFzC`^pCGAy!{piKfh}r!Dhx$z?mkPPFARuI;XvR9pgHd)ZR7JXmuqod-RuF|i=w
zjoWr_TlR6EyL!<*l#m<j^$FxI-d$Bu2!CJY?~bumjJ9?^G2w$1Ee2=p#X7O0i|iY1
zvkwy);4THuum`9p$?j6Y$Q`)rR;4yj1r2TYHH9HbTp-KYthm9`PPSz$U?F*Yu`I(7
z6(h}v+0Q7`%vq?g_Jn<Qp8X_i4~xgF*?dK6wA)C^0_BBtWT?H0_Ed$#yv49*+ckpk
zSR+o##a-qLNG?`*y4&ei07pQ%E5!ZK_83dD1_TXki5zS3#7YX_iYbc>JHt{lE=fbw
zI7NZpjP7mNw<`ta6Dx^^J<;MBOKgDBs<Fi-css!5+eu1ccXQW>bzn>^N(?(wVXt-<
ziRB52ovg4wLU)A<tCrY174{mG4FeLAHtgx<gD6m}<4>@syJr80)h9-%8Lk(EFdObt
zY-cUWpt_u?6o^Yq$s7%9&r)bhiso$Pg(OmminBTGyB$R;)?@5K*Q26;Q8S1Ea*m5;
zCDa0D5!g*=*mD&E^B&9&<UT^X$dxaur<>GN#jY8`+uev$XOG%5%yN_=R(WIX#r7Xq
zCNyu2{YTNfDBuLt=@LgAq;xEGBmqg$9z|iz=S51wmu&yudKPDQ$$TGI4U42u2}0{X
zp&AnJg`8t4?LSytBjMmtSc(}{2D{w<SeFFL=!2>cY*UhiPRLv3?I%@A@$N<CaxKVy
zO1D4X4JrQqsGFZ7#pn{W=yt_dcUj4QvK|q6B}i5Kv?Wz-FLxnFbTLsk>_1yy3!=Vm
zad$9e@)?WsC-h$<&RIRb+uVo3$11PSUg+wI^DgxAgI(@Y%MY@C7P)BWvmeNDph7o3
zr?mEBHE5!vse?4_xn^%97^}SF?Ez7Hu4M)pQc(?zl8Q=d#-u2z8PSug^eyG~Ace&|
zpb87NixyzP*07Tm)(x!CMkxx>j#g1sM#X$o`Cx_fz<#R2WzdV3I;$A=5ET?HweZlW
z70@NF#25?}xKhv_7WLN~=tpxF%rEA<xtpS-+Vx2@>So1xyt`t2;Sz4qwudW<Zte=5
z%?L%-o$omC!p*R6iQ+NDuEYe{mLrw7m(u17xu#*KDlF9Rq*6{S>`^N50Z6>01iPjU
z`&Na5{#8V`MM)cbsJql5a!|wFg+)b`T$YqolNPm06fhNSrA}0~i_BwaoLI-7Z2#Q$
zT}Q<ss$`R`6o>3so0S)@ISl&|`w5YnZNxl9om^~oN5uAo<L#;Lt?;z-GhmwAu|ZZ$
z;dH~kOCew|bNw9J%Pq^`k=e{p-dOocbf#O1h>xwD$tFc(%~Hrt815FOm!c_VD@<o2
zPW8qT^C>V9D}7n^H!co{QmVhz#+%gL->Ekj=<-6B|Ht)f(PAEGOkr1iuLvL<s?T0>
z$sXzSb;IfFa{Mzb+2$~hxr%4IR4}B%Ia=1Xtf!=0U?dW`*lI}WB`ijv2cnc7fLMt4
z7x;L`l2Qqqr--}joo0_wIV8KWd{uO3`2v_ju}ZN(I@mw3N@;gcsA2B;g{>xMM}@t~
zeGg`%VodTX)Xm~8_5=<ZK7|^N<nl`^t7{6OV>&D32q2wz-Ej(ci_j~E9dErLN}8&c
z<?JpNS82G0T`o0|7^s|;{;^PC5$LOw78@^>-_=U_O+rgcTW7xc0Gc*d`aJe7>rHsw
z_|U1ziV|}V<LaX2uz_}44`U#-&Fi7hu7-b)^j{A~AjU6KTFcD$5w|_z0k+S*r3VtC
z3D-#pC47~0Mg4SE7-&YesA0#sWpjF@1axsr35a!9WA%W&_bRtE$?&Q|X_#(q*_O~B
zG<2kfyxJ`_Bt*p-3a@ehR&+L{LAtwN7G7wONqEtZH;@W}$&;3@d(0=ne5~UiV80Tz
z4g<AYtisvHqMTk?Ev>;<6~Y$9eNC&;>dM*G5S!N><tcba-Myhy5qg9iIPuQ)%_zwx
zrjK}YqZ;Q#lrltR>%A2vhc0%6!a2@F;iSSQxN$Xmh5Q!8J{6^kDfQ;*C|SRK4VOH&
z-QDkJC{VogV6mOWix*!Iz(Wf!+U86eUyW3i&MPl2N)Ss%(KhEt(Ka=dvwXy}L9ml}
z5hnZpHu-|v&1>xKPxQp3ym;vpF{FR0P_}plY}lVU^C#m+9^38WCnVRDR!!jf7L_#>
zSg}Tj6}saZ%=utL72zGa$HnDqu)x`5wB1F#tJwnPJByDQ<XVARUb_nkb{3y5w4%ND
zLy8e`F~a1k9AB%;7YxyMNW|dB1Fee=@`aCB{^Q$V#Qm+H;->_XN-V%q4GU5b91;Zl
zqTq4@zI_D2M<9^7^Zox7^AZ`Vg0u%wcNX{#0N37$5|}6$Z9uW;hy)qXontclgrHzH
zoG{94I9-p(ru8MLVyF_~(KZ(dqJ^c1<s}#*(Kh>Vw3tpr+cf-Qoul?W_IP2VyGy0b
zKS60ws17j-+@W+Y*Q=UD;v9*hZ7PvyyFD~Z2d)@7OE;L$F2MZzEo&n}gmmK@BR#ip
zW?iRLCbpb)omO6qG_>T3@l}zuLf=*avF=j7U9#U%ekcz)Cpx3Xf%sMiN@#!k><`6y
zk3$z$bYMx^=Pi~r*kN;tls{@^q16OC>tv6TavmFP`%o$@#EZWfT(NRAmb?uh)}AIN
zT~4-lsX40}ai@##4roVmp-LI7Gt|5og_joHOofPc7cIhBMfNP^k3r7uVDhWUfXvZj
zSBiOn9MY>)2I#t67^`;X1c>=##Ef&UF|gO#>^_dkBa<3n|H7u~a<AYNXHFr$U9f-Y
zBq-B=Ko?-e=mn*P&~^_h3})rfWQP4KHN}mU`u`y{0~Sj=iz>K2Ms4tGRit=#879wi
zt!j(Hb#a$E)7gg=|FkTjZ5vf>LTlz#3Da|{U>HWF8)8SrV%Wd2pB2-hUMMrCf8GB9
zFO6E=nP`c3XD_E>6<8N&Ia<1kt9iDJVdhe#yA)UB^AYGnw>d4ZFBWu57FG*Z&AX)0
zY;+ZsWKMq_31KDUy1$^`nlq%&)m75YlwOO=zm>FK%~=v-bEUbYbeUn!mWU|kFLN~S
zejiC*4=={dqSAS=gv~~wbj?42lLWkY1ww#xv2trRa$?p)5pHGKdK4MvZ?=OLMWbWK
z+F~tPy~ypUUg6^Hqgc2U=R%p?Ez{)f8i}}~zPm-Jm!C!IE_6U*IUy#FG-)9Bb}mMD
zQo+Qww2Ie{TVlx#gho04;FsRdF!~@_LnMnE=#3jLkIk=AP?pY?S%C--;+cWx$0}my
z{~i&aJQSCsyf3@Vt%&g~=46}TeyC!;>|#lfWuFzKp(@55@O>xK!_qW^7Nq#rbp^f)
zG|abzU7U<m@V#rHNISQJ-`SZ@nN7fQ+u}61sr_LdRfy_C5cAjw>;R<u6qEfUJOfvV
zm{o@P$4Q`$vUtRY)bI2Q;k(x8z?5!W0^0|D0pFOvZKffM7coqHfHW2lipb_2W-}V0
z127NB;5UW*9?m?&3=4^dj2h;<EaO^waqyA(-a6!2Ve@zy!)zwy4efYFP)$h%Xg{C{
zG|B@6#Bpw^_(akC7pcCA0dhfc`8<5!W`0P_J$QwaM9pG`>E$hYNlQzM7~Vp}9wJKc
zl_(ZaORCFi@WQ%exnX`p`CbiESB6zAsHvhYVwh(c@QDtXv!Jm29vSj6LvF?jii}do
zx4`Al9bC9H%zrcV!N^eJ2OH)m4Dg`u%4jQ!D;HJZi!1X};+JYXdxBwpM&yY$NEz@s
z17>6CHAyI7^9%Yf(9dxB(Sv!8?^#Adi6&vDu|OfeWLNt$kyIS0`>)t~eJ~miM0FeH
zd7e#eZCtmKl`Z=I1*(#9AV`9(w5XDmXP6h6;b|h5NhR_%5nUh<Nh{Fkm4$}+4V&#S
zF~!S}&v&f;I+%1x#i$11+XPWd!UZ3YkV?b+53Q{zjA627iV){}Cd!S&5>;7^?s18@
zTHyMNW)x`~CXu^{EU!XknnDqIVOkDK0Q2_`L_jI-W*40)1L*!`j*oW%^+!X?u)otc
z7s4XF|Dm_Es+{it6p9MFKR=Jiu31Dqyi%n3D6xwTbCq}paEd;>!o+;SFjtGd8U=&K
z7?g!Se^bodDI(que19B(2BxzFV!0r!03i=W?_bEy;t|DpkRi#u0OUhF=NVd#HDmVr
z=S0+#f}k6!c^ICnk|GG21i>dF?G5CFflCatL3~?m!u~RnXS=c07|(Qu%@vC7e@u4M
z2?$P+<H$C_iIH5`4j0_v`3Y$uD2DlhAe{%&{^)#vGbuC=Fx^4h@#j%NCubVwL#_~H
z>|GIf5P>H}AXhTX-?}&sni&34?lH_q1=sy6Cg4kK!+gy3b3_|}Fk{de{BgrKcm+%p
z3?t?f@I+bMfy?Y45p0G?I;05l{-F<_$)k6eSGz`maA*T?Ls#O@Fel`upTqYYBHX+c
z06x)Yv{i_5jL~jzMMQD1BFf9HQ845zMdBSe5DWX5r5r&E8b`%Oi)H<2n?t<_B*Q|v
zdW;Sa0@fo{zH>UC*-ws9N703DLB9zjtGklXSMgE<VdAC6M&p*>fm?Xhn9+yow4X(N
z>e}cTjQ-MJjErX1NIwa0v}FJOzIJfoTvYe~i^HUA<BZf@VEYWRx=6Bt)~Ivv&oXcQ
z5RSd^``X4^PXn?x&S;F_RkM1FWHk+JPQx<*Y3^`Xy`?Ryw>Yfc)}OqN6ued-0+~%!
z%(hm?>?I4GLFaav$=%3cJDz6{XGRL@M%2LVDp^C+!0oCAY$iIsO$|)AtOo9AQv(Z-
za5oHT=EVQI8knuQ%ah!Zvwz^Z2=1QN+~qmk$wKD~_EN8xg)aDEp{vTBLKi6^K$3}2
zm(_?fcQAwiDyvA^{<Ip>sk)0qIxrk$jTEUoJ-78oB@~OmZHO+ay+m-ZiyR0!nAfHj
znvq)?Yhi(vMmabOx-?3{B?1(LxCDral;kR~BP2P&7+5%#mLQCY@&;g|EN<ZKKz@bH
zZ*eHypv+Rk%c7?RCC{ws5F#b}&jE+Bt1%Gvg0OMTic^A;M>uu(3qa#*=s}n9GeD;K
zZO0DO`(PRtoFVtPaBE9Z*}RI1K{!ZpP*T#M1*LNa&6_({A%`Xn8#1W0eC~o8eC}<?
z3a0^rOWvxBpu3aiBXuK5?TQ%!FMiT0#liu+pv2<bd<o5|#`{(YqU4B(-f}6*>@l!p
zR85T)bI@9{!HP+>mQFo1a@0i6d@JVR>QOZtw_4AyeqqDL9e)3d3u|g>Jl!^q98~A&
zQD>FEF>>M{EB=nrPd;f)Uw7Q{HE*0~MNgeL##&x&{r$&Z^t|QP0SU>IM!tUQfEg3N
zv<A3Fn=e?2Z&-e7oAqjKiM87-u|8at3cn{+Bf_g*m|^9*2AI~s)M=idTQRN-(~9*Z
zY<%)wS5gP-x>Tz&^)An}&7K~kt{-)a75&Ejo@tw`6-idd>YvRkaP^M!Bzw+T9ZRgr
z604&psm|&))w=tj^|~wR{x>K7vC;D)or%`2+83;SmS>&y+{$&XyW$5e^UU`w{fQOh
zN&Udpr^`mG!$Hrv0#Ax7InJ|j;GpqkZ(2{RDzT26FI+!p<ZoQP;ygR%of}{OmDRZV
z4eMPaX`Xe$ocg4vhqZU*!`2R0(*88-ZqK@re;f4cN%K6@JQE9gto3`&&D(ChzOuyn
zA6HUo@t||AQE?NW_jI)uc&1uiQmuPRtS%)JORdbQo>3z`qvm-oSYLwpr>-RH=50@o
z8hD$h%zAdE=ML+zE9ou}SYxJo;_9ulwFj+rX0!GEswC?{YlF4i^MZBHI?KQ61?yWg
z=@95zR!zPCmil>~K_3iS;Ys(r_~8Z5AXiqLYkZt*jQBq+&NFGt=7;`i<!`h4mst5z
zt^TRjXDIGQGs*hYm|ASDT~&?m(UZ2!w>nO>o>;lfmDO#j)zh=h>X2$pc;jzhp8L#N
zw4uh@X?YT?BP-W=G8bFVtzNe!kBwp#H+$ke`6P|mU`>5vp!JRM!kb@h+-UWA1Kch3
zY_NW{y2SdIkz`$+y2bkI>SoXV)}R-rS)(8J)Yna`T5feh1<iNeYFZsUcO0_z8ZTJa
zB^??Bs`l$VO`hY2Jc&1!T8B_q<EQ>~BU)_!E%U8&u968SH%|7%jqGv#Wb65rcUa?7
z=Qx3Dt&#~lJv}`2R`dq6&a{DbrAwxHrUUFb`lPE@{2(i|a-H?1%X3HZy`Nj_S2kN0
zT&dPokd|2`R?iY^)>P{i18?Y7rdqquJRjF0<Ug*5(J!o5R(X=Fpt->l_Y2W{>s?7(
zt<-JjtY>RI2k`;>3n=oZu65I_|E%()ZX7tzimt9fcbRCVzhKp)KYWL3|JCYL>myYC
z_-)pl601i^owY30df%wFK80}Ij|>}DdpcXQAPVn-i<&n!T6b-*`o3WOZS}*}(q=1Q
zZYZ?AR-&_e<+gL8qkLz%#+tozt?GxZP9=-1>Qp#Z#nhUbi4(2ZJEqkg%6zGG)QMm8
z?q}t1um+V_*(KJXR4Y4ye{&>R|2wAD&ng}Do1@kDWLZyv$zw*zNb64kjvA@fA6Kti
zI?+08+%f5{x>2s*xuEJ`(iqsKj1%+BT2HKPH$WQ=pw>~pa=4>Adi<`j9iqn8S#x6k
z0iwMb?Qf6S3*aB4+mBE3B`DeoxSU@K`gB1*ImwqRVx%gXt#G>_4~J%4UDUnyPb}A*
zB%iA&X7A|zqYsQ`gwgF+w0hE#3}|!lYeL*{fJFR^4pF1;wZ_!hIZ3{GBxg*+n51aa
zpgz}Q?aIk(g39ZcNj~e6nPe0v`AU<F%p_lNn~bd{kMheB>bz+}l{tCe-XUsyoqexW
zljNJ@WIa00mEh!!u@7dy&il?J-#AgOj#z6@G&Di792(T`?R8dVk}q4-7m_j(6djEL
zWUbSh=%f{AYMP^<$&H{vTP;oUO%Z7^8B`mFp=ullhG9j*9=bOQxW+>lrk0?gd$YpR
z9j@?nDG!ksl(Wqjt8lti686x2K)^K~x(`Y`T1Wo2!ubsz@<jKy686xo1e45zZk2$m
zZMxePo-Wru7#HN?w-tY1!h@T*J#@z-+%)nh!?{O-OkousQqT<wbQYbb1elL#;z#-H
zAw%gT2{7joILsB7f;)s1#@%?x2;Kb>_R!_n%|g)SLP{jFjQ0{ABt^$UaK!!X3_T-4
zbLjkw6vmQk8ws2h_<TCw3NXjvB@Kyiy@dJD9V1~6-D0#fd7)b(;A)$0KL{i7bo&dq
z+NR4D8R8?;o{4n8FC7M3#>RcMk>U4<@EkfS{O@hT7mM(0I@<)8OJ^S*3ys`(4#0O3
zPX|cmMrSx4<o0DPfoTGtLua{zC-6&w&!w}?!4udm@Huo|a_|IR6ZmX8Zwmb4)r|zg
z5>MxQfk(asIz!MPPIPimae^NLv+$tlSeXkk#}#-2Yw>`8I-@!$JON&YXc{?mqEXQR
z>2wreKC6B*9+3)xJ0+e@o`WYaQ{w5=I(P!V68IcCzZGB>oj(dNmrfP5p-7#;N<1hN
zol4oFU)B;>=XeO*iw6ay!)yD{R;wEc{7vHNsOJ8%O>@scrJ<)8bY<h@(AkX&B$_Vk
zjxa0lBL&mFh{p}QJJHif_%B!?ARS#EEXu9|=XyLu)8#p&GK$?ucqbl)(LIO<O+n`!
z0p`$2z$y_b=<;M!Bua;yiJXK8@4-Vdy2tUL!RYY(Q`BQqErDTpNJE!xjHKucMST-Z
zmyPKZi7*?BVRYFpPL_mss4%*R@gPe&+)ThIbf@DH*%O$r0_d*A<D^A6hzIfMY``Pp
z5a5y`6QlblJWd?K-Fz~P?m#?F7~ydde!~2gStLq;GKI1`qQ&$nTMy%L(jfeMJR%N(
z-4TI=-^Rm;boqdJI<Z(HB${qNJjjMlhC<Vwg$HWVZY1!M@SuGNwBSJmI@5#*15ZF|
zxs8qzGpO305Gp8(s%eh|siBStFo(CeoRA>0GS=aNV9|M2f^=S$;9GFo38j%mr>6w-
zA<j}|Wc?UINcG^tbvqQ7hlJ#0(Ro6Gba)7#%SdjdOHE-JixV1KRYn$tiC3e74?6cs
zkiA}tP8M5ZnW)ID=i#u9QTc|O)t4$NCX0REj|XY|R8<Q=r&`ib;9ub(7gW;hxk#b8
z*6G5+!#+I0twIQJ84w}cY6(2;gb?^E9@EIC6N4Ttq7&$Z2Y5OO5=@0NR)AS_>hK6^
z0`&r)O@}Lph)9PwXA2SnJRTYz!%bi^9@+zNzQ^LeAY$jmktNbYfIS!?kJl2A)s2Eu
zEweU790K1;&$e0u?2ibU*+}3m>1nPdzz&3vZM6i(OHXqxf!Czx@md1^#sl%p>IA)x
z2USm}N`iD=mmr;}&VqoBTYx!qCQ0lxIMo8orL$gwzlQUB0cJf3NA=jpYn>h|O2vK}
zl%mmGOW<KV;DiqQoFF0)FGMDXj_h!#9|HUEfavjB0tfJ*M0D8ykWOni%wadAH7lqI
zw3nXd+Rgy3#)GJI`Uo(K&W#eJb2A<hmB46$&!M9Rp=Lb@HKGG@q^I1rj_d^-*=1)e
zcp8#SAvTQyM|=TNcz+^9w1Cc2kSgT&S}g%?hz1Eq7&(*_@IdU-LbM9#M7I|Nbk0M{
zKuZ~ugF=DRpDiQ$QX_?m+8-oz*5V<jbVGQMrQs&PQ2;a)yL%y10I9#rg-8_8p@dk*
zQnQi3Qi-R-^=05!H=Y6Tp5t*^9qF)bFNkI?XjQ8PY|MK_qZQEEB*E=)*iMM%Gy*`@
zJCz5(D`|@e1re@g5C0LKXcVl{=pOw}&&DU<WvxO!GEk$eRe;~ZVXd+@3gB{7Ms0*^
zHvtfPrV$W>T4l|m+dKW%Wu!DZBe0;Sw7)9_pN<lIq=T|-6~)S;!=ed#rwCU=Bq$+d
zU@Y7mAtE^jIAtMFSgP%x;bE2!z~!PjIH$t{&_!w#f$OC-(CLB4GAdR#5=a#ItRl3j
zGz5|xosNLiIW)0WnYzQ%9gx~tN|@=E;6XNqn}9U0vgwd-;Lk)V=QFjDRT^1~jzF@c
z97rf@A~u0tcu>7`<WQ150>Ywd@r*VU8MoCQ%y#TSq8;XGw=0I<!IGjJ0g(?p7&Vld
zeMhKS#lbtZ1eh%=fi8zJ5rvwHW0&x7+*cj{9o_Mn9miNu9E!~0kjOzLbf`8Wp+mJ1
z2_3ppLI*`czl6jg)q}MJzIHqWSO~JpUafLC7@5Pt$Q%w{DTgDGIUEr=@St8~cchj;
z3m)b`S5?`O$O0XS%<f2Jc1Nz1-QmdW4vXxVGO{~dOMr!9c240$Kt$;dM`m|8GP}c9
z%I-yx9ZwNPLNC@5U>!0Cx~f1gMi%JB$Q)jb%;80y!{=yfc2}n3bX#Q5RLc`Ll;&;{
ziBh~p2my9HMxnb959|Uu?2Cei0;h)crdpcVG^IrdbuaB+;c?{K$r;Ho-!Je0q{G<@
z`Vi|a6%Vj<$O7!z%Q<28pm6d71#_cCjwEP8Tq6vHY&ty!m`{^DS%5io21~5N7drwK
z2m2yjsnk*$IUGrWmEGRyXH+`UCT>+cu-uLJ@VJfKpWFFAxBmq=7h2HqJLPfwPSrX7
zMPOe}N@V<9@UtvV_)x%dQX#_~-uFS-zk|m#rhfv5UuXcNbCpn@({F;qV-<j%24}Ve
zSHStX0B7)wgeN3O=Z^xMeh|({i9G}7a|zP9Ai(K94BLrf=$_FB&QJ-`xkZ4}bKn$8
zYzdsD5~Q<SfYa}T^N_?o3}>4Jxi5T}Xv^uW4>m1Wr!hEFwAyqWq-ZRbARTEHPUq`p
zT85@EgHF8wr}J$xhjn0`(H)6B0@cVl6|fw|<<LEy<D0a?rqlFti}8AT>nJ|msd7h*
zDK2e>CPfh6Y7HH(bsEJoJOdlqEF6u|D_*U2BmkbnwJf!otiD>yw%><G#ECGF57$Oa
zC10(jU83fQuL|3e+>4~iKSxL5aoA47oJ6i9BsX$A;o!g`(3SJUltxFrM~+H7*qPUy
zVE$#%m6o7b$@x@t+gv*AE6DCOp+rWA9-2!>>66z)aesmK5=4%5B|H%W%xgk@(Vh|^
zj$!381~;;Bw5&vc(<;K_SXaX1l$KnRQ<j7-zvF<?V8MSU)<cpT={5^PHJ?s*X^|YM
zrF}(%icuZI3Q=ia(QYEzv7dmZ&SD{nW|MMMBkar+2wyf)aB7~lEe)7f8-U%Fos-d8
zJ85=nC(ULjeOvUwY&z_nnCvcVB+yIrp=>(rl)$fUBv2&rbl4Yx_cRjtwZzk57X;pH
zB=DKUJ5otzD0=LLgz3sIm`!J~Fdnlxm)a=7)^3&E+O4uFmbBlXrrDD55~PzQK{}LM
z=HWCXWrkmkK+V%(cgO0*>c-Y-U=F8&v+!705N{+<DY|?P9clGft`=6m)CxJRsvxJ8
zyBsG&#~_U{9)?u#cjh)4qBr1y#&8VK$Y4nZqZZ65!|#YNpH+`MQp@sEXd$CVYMmLG
z@HlaoBQDFzvM)kKEx`j@xgL(3W@I_N0nwUkogNTbRcsb!?_odOWDe=4mv~w+P8+mh
z$Qrv)E5>1o?6AI>N2^lJZLPjsr}`qf7>QcD6Ay8-;FjP)L3YCVSfTGgp(rAe(byYF
zLmb^pco2;aPXq!;XRrk6sA-VH?3J_44k7--GAZ^*KOQ7?B?fK<Ri2>CnFD9J1P{S^
zS%BGeSOTGE2waeOI-Lby*>pxqFjJKga_g|z8-%>fi44GD0g%>lVZTwC3lEjTG&~@p
z!)g+ECy}2Z=2nqNKAkp+P|rXmIqIfOJg)u@6RZ`mBA6fMP|S^4M9fS{$jU@)!%cui
z#Zp6StX#%o6}pTi!j&oHIxKQKz{hxy!kOCd0bGyFAYQLRD3g;K`@zR45=s~ugM_Fo
zhaR1IwN?U;VeI1iB8}13b;hiJ0wvcOvuLMv6lyr7kt&$nlG@4PIQ0L&#2Ap{p!#4e
z7%E0EjiN2e;oGsgp1>&lXFQIdqcR6%$KMydgSMsPcamO%G#<bMO-JW@0qVK`JlKV6
z@kC>SZ}CH%o{jW!wGI{Fha*?&G+Rr7B87($c=uFKhrXkeM0bg28UZ}0TRKd~1rq1S
zGwsgc5pC-X!V&Gz1OefKjR+@jUPw&-+o(;heL%RJr1+ZPFrJQBmUVjuTnAxs_e``K
ziDS$Tc*7Zib`onZ(Mt@{I?1*{IvJcmYrcmE?6Jx}!UHf0wN1MiHR}-egPN!L*Us2@
zvDTf~I&|y+k`~|(0{DLV6+C<eNcXseJ#<Il{V-qY(dB1=q@k<eWlpaA_HMKar#nW%
z9=cNnT;rk3@AH@jT?IQy7!!cY!h>?r$;Jax;pRx#rkgKe4_zjK*70b;=DYDiNnq10
zmavEJ9|c_Fq04vU<b$q)by?{DlM1K%X9;`g?h|m0hb}*~V;Xc7tf!cN1#Sl(l!eYt
zJS+>{JrcI*G8*`|HUCF}ctsJ=eO1C9x;@c1*cNp8H6HVJD(@Qjufv1<9Mors@+}^q
z=x~b^S)fZwWE-oqeHR2o@@0whi@@n@92_F^Q%w15f`eX&-+P1cxn@6@8H*R-*v=uB
zZF}Grhs#3bmIiKNxGX?zS$JxY4$)tx@+(wD?R){suRRs2^^46JDXmE7JISXbaQZ7p
za()s;Y%RkiU@kjzdL2;Cfzqram7T$zauQZYsq(XTg-~a)@_bB(J8WRUDMXy_I~blf
zV(@U)HVB>w>L4PHQspi{2QAN3<{6F-W(m%(=0Tc~{_kL?Yk%Q_nqq^;hdCH*Qmy88
zYaWs2;Fe%-lffg=97HKkM3DP#c-WbPCf)40HI>+^W$^4O2ft7rQOFbYE<^F)D+eVL
zMgCRzTpzV!@I0)xfr~2fW&WJy2G7W98`2t09l^y3L0b~>(I#j54q6n8Cjdqw9R7KZ
zj5sXj&kD#`fRDa;@DvZM;%QtWbZ2Dfy$I#;QrsxUqosI03y+cFZg?Ic#c>}eM!gM(
zM?Q_mah(f_D-9kQ73t?LIp-)9ZbZe_K5?!Qw<xM@e%uf_c8<{#om6dwWhWLJ{J87R
z*<xq#Fch&zoZDKRV?MZLK<yCb$ry5DI(Im#!yUN&Q60m;jbF|te}0(l^k0L!V6l4*
zg1SBdkl0WCCLwHTo>z=}--{~@ZlH9w5wGisGV+U5<3Y)KN-OI;@mn>4-cY+WqC@eF
z5{GvlLZR6FthG8SB5H}7_a$ddy^t;{EVHn};4v<uB6y;QEb#-Hac)sm6)rYoa<ii2
z7keXV2{<jnvwB2Db7P@X(Q-Q=&!KTJ26qq2T9$!4ltk4!x7#`U3i$!Ps$ogTgB6@A
z=ZP4qCAcZusm%8;t7x8}pj(DJPt>M7?uc{t$MGv>2S(i*NLi^jt;!AObbW@O#FK{)
zgPc#KHUNGCkMk>b;d>}Nj)Cl0zp%lC&E0^o`|vnF((;p?S0L;(ZW*>IBAga1-wHdn
zDecvsc%0uEs6Sesv~6fna@~t&kMrXqE%SDaHV4o5D0~a#m{JbjSzU6Lj~x6Ni08lX
ze2b?GWb`w*=kYi{evn^@rykG4cxv&i#<L91kMTIaX22ie;XoS$k>S{T4v+Jr_7Ey1
zQu#RD0IF3hSSMVJ3KgoiJ4mHj9WT|rbM}nJMJQzl=P3CV>D;m^jxRFG<$-Dri5yE-
zjFZP+Y3bq~C*+Y|Tq(A_X=#t__k|@T*wt9Qyp2+;xE&j-D$<u5IACi5k3?ND8GHSW
zh2mh2afKN2iVPg62Hn4CxpDiLF}Ec2#U&B_)EyC`)<)y+06g)=UHCgtK=<Nrl7M0%
zoHF!AKr(cOhL!<><$$<v0)m`iO7ew<`k@a<+>bT%fQD{`=*c`51Cn&hG*qjhH5#hd
zP=khks-X=U+N7ZeH1ul?ZPn1D8hTtq+cdOYL)_9P`FmbNf7cLA3K_Z>9Z5p98hQ>;
zvZ$dGfKmiB4V_BTEz;0R4fRKm4CUF&vUcMzzDnFR8k(-5Y7MQ^(En&?kA_~<&^Zn9
zDqfj#XARw?p-CE=qM-&29njEQ8XAM8O2xf~CTS>3LsK*~RYNm0bhn0zG&EmB3p7-r
zp=u2+(@?F3)@Z0+Lk$`_28Afw=qw<~{g)cbfjX494*|&*{0fkaF%3#nhAz-hi-y*~
zj*+3mp`ax+PDAUUum=c<_y&*+?SwH`w)qf1Du#y6XvhWSDMN495Cn`DiJ}jt;jauG
ztD*6LkTpWz#oq)06`-$5=tW4egx=5)2L_4jio_(;Q$u|<G*m;QHMBxQ0S#RZsgtSn
z*3c*oP0&zCLl0^w1PPOIAJowE8rr9!S2Q#f?JHvpLwiVQn}(i2%ShZV4ZVZvk+`!O
z+J=^qxOJ#|37M#I3EiWi-)Sfg!;uVqM?<L?sw8frhK^|{0S1l?&DGFs4XxDBzhJRR
zx)@kJ63WuhLmE1$p+&IkB;6_vg*DU;)`|?>qoH#e8VQR@hJLA`PB4ii?ph7?*U)qg
zm1$_Fh7zuK;{F&($W)GNs98fjdpMyhH8i59gR9ce_}&gKxsL;F)X?V|>Uo0`+NG}p
zg*DU*Q(_1xdPQFi4FE)&!fnjdxIzsT>(F0n+(Q~_)S-tpbQBP(fjv*-E&!7GeygEN
zI<!lFhl8FPx*3p+F-t>pG*qJLYBlt84Lzcv?Hbylp_erDzJ|WikbR@WOBW5LXy^_N
z6=`Ulh91(;pEYz)L+@(na}Bu%IJsS;p#d7o)X*FaRcXktp-mckL_^PN=%9v9Y3Oqe
znFAdT+<;`eb<?;$8XBshF&fI(&;kvu&`?N2KL;dJeoW(@)6m~_=uwS(1CVU}w>0#*
z4!xjp-)g9Hl2eXufMjm{H7*&DOmC=$Cg{)^8h5vbs&(i(4K)CgDK~1|V;c8@#=W7T
zQ#$k<AjyG=0Z;a~_JAbLtD)W+>ZhT>fMkqxjT@(-sT!K0p<+NX#zBocqM@TY^g}>U
zMd+)(WCt1oNOE;EAX(ljja#ar9|Mwk+z&{mvQ6WTYr0b!I-^5d0Ld7gVPZ&V7$BMN
z2tYF5B^tLvL#qJEe18H+#{G@P{ZrGuqM_Gy=(m7mjQGJ$Dv25z2}p8q8z9NSL>)Rs
zLo+p04@ky%N<+sr^lQTj#h`{+1M3+Bj*2l}<0fg`0*$NCxNRD@UE_{x+$oLgYdU!h
z03^BM{iibDsT#*wjKtMy+*XZyRO9w(+(C`22KzGQ$29a84eihnOew>M$BlnKgcu@I
zNfHxMc=7xG5^f1K^^RqURDajQZ2}kgFH*z@TYz|~ODpCvVA3%8mzddVhc!1=D~#I5
z&F$L`M()?<+aZZb63doI2tQ&hlgk-}!teY^5=YZZAF>0D6VmD?&B2lS>W6Qgu1Le+
zKPnnb6G1bCq(AuWP#74hpy68h=^xM>QW(~@W&Q`r{gA2G6%D3dplJpHrJ(KaJ>_NV
zSZ3b@th=`*fbZW56Ajlg_u=mk^ZJjXi4ipKT#=s+Dq4F%lYqah&9=YpiY69l%e?!C
z83Es4VLJ$#YkxqKG#7X4;i4j@+)>bUBKU*fFcp)I<YW>+_QO`p9DrNfV3q^JH(jkX
z>j9=gLA7Fj1@P`Rm~FspZ-dzZ%+WTOmzjY2xs2Hhix<wVSnePchwrqd!NLa)4!Vry
z-)(3Zc(Dz}LSd7Nis#hKn_W0(4sT&lKC#xV;02{P5>3G+m0Waj0&pU#0xN3f@aV;=
z2tSX}(SBT4hI<{gx2+GX8?z%%eVVP#a7r3Fd~mWcTOZS;GW&ncs#@Z5*0j_ST(d7j
z%NJ3XW7S(I2d!U0ISA+dljCoF`J^$<n<tIXubnhTu8JAjU&4j+*|TTYV7;%Xbcg_p
zN|z9fL0jO`ucSqT667ys$W19jhTlA7$nb=Op@WH&e{UK(R1geJ9-bm8?~a*dvR7eI
z6`eFuK(-mFM~TXU#EpfVeMhB%AEtIj0-i`+3hxzvX~0J6QxYXaNHG2Ut-&*BD52J0
z7tn3GT&seQK`Fyqi2(7?t|y?Sc!?Q*m<9_aFo?!b#IFu;e<;vrsI>4CY%sl{P|Fd&
z@qnKM-A+XZ5}DqxVG&e#e~$!sgWWMjCs<{AH{H~Rt}mmb?moLb-{EcZWvTju?wiZ$
zMzk$&0_f&|&Zc6;PxF_OGDKqJ->GocsW#Ji@|QCBX6*++33%%YbdkE3^c-=*SD?d9
z<psQjo%%iqZHjM*j(O{aFT>++^43QqAmvi%*)T435A0~h-?IzWcj*kmt<>gekMM7A
zSP;hg1~#7gVuJ`>`<}r4inxXc#9!{gH(Y`$xS1)feOJ(|B_6k}H`txhgEKt=5jNs2
zZ+!^(HKS;>7&Sp$k-ncBp0K?-N{l0AM)+2oSWvewHeVc`k`*2#yuOsChBZtwZ4||%
z=8KY)CdqMViDGiSV8|8gHeXCR)bNV;xxWeqALQS_*A0S275k<A{3ZkEy>&q1q2e#6
z&ze1R?*W<w!jfuv9p(5x+$`RDgSfa?9E~4&7kE^hA@B2cJ6DCb6E}DBo^f$kwntsI
zt!~qfcCOowajx5L-+D*2bH8@%(1<IwJG4hNbkvt%;~MVPtE|0InvhpY`y#yPk)2wT
zVQA+FFGAxYu8@Y<$IA<}yExZVcNGBp^-2h?5Om{;cSkE7_`kn9Is;|k&*j_({eufr
zJ^%G?RCx`m#WNw0z*g5LIHCnjm%i!Gb@?Szt}ES8<cheV$aTdViV&^MO+>E98;8Jr
z<e|iFy8)cEQ$tr)W%;}*yh8?uQvPTmitFK#!aND{nn%fZA`m!`Qo^POXU-|u<-rk2
z*D{7H5u3_Luo9k_X8~L?+RN&d=X@rctARBCjNn)#oI=_Tu}Jn-;$v}2+HDNO$6J%|
zXK!mN9i77~b6RhyG;tCceoo62qKUmY400xu8jHtQAr6w7c`sm`Bh^WsD>aLBH9&Qi
zFR9Gg-H=R_P{48I`v!#ZXBNjN!0ECXxXl3K)97o2?|lGW9|vG<JhKw8;kH?j&Jh)9
znAcqgf+$O94|3!(I7I!Iqn!*bgNSt58BIt<2(NX@Fn7FV%{uss6<_k?lQ>stp5>K?
z7nK|sRcuXLxA_*Fxl}i(*poKDXxfwWRyA1NU$B<1b9w*E0V|P19Bc9N14{mc!%%A4
zoJoQbun>6ou@GI>8(<Gz8q)lri0(}SuD0ni?Z|T+Kx$y^7PyVV9R?U*ks0pjOFbJ~
zBWxs{_=&^;Awoog8*LRVK2}={j|Wz}MJ3vkz5t#M8nekv>D9>Be7r)!gTq23A${^>
zjckyM-z)h01|EJZ%Nf^)c<|BFHJUOD2=VKMzf!T#j-a?I5r~jd60+r6>DcKM-E1j?
z6qN|!5xtP{Fs)YcbWydqGn}Hj6whz)un-i+Iy}zr|0bN3{|7vb@BG?wccu5K9QQqV
z+~R~538iXWx`r|}l&7IW4b9WgLJd`E$giQ_YKZe@ncH(3+6kx!o_OP*_}f!J$MILv
zwP@%I4PDfb2c?#D9W~TdL%lRKTtl2`b5N0QpV%&Lp=~5I9)8x1TSy<<&n=XPgx*3b
zlJ0E{y$6V9h1)o%q0SH%iR%qW@|Ofi#vKfZ-N$W=&`>%c8RK@1%hI@7Kr)rlh$mC&
z28hZ@u1rbXBk)VQXEbzJLo7MXM!B|gImEPNDnDG?(b^3(t-tjOWbfvKFZA&+9f^sY
zOQ32nE>V$i2GRP9oJXLLplJ<rpvXCdNZE|L0+l@bhjCa6%j68=hrd556o+riWUr^X
zY5UuuysR(Fti#_QCUr>Bv=cOx8gk$EM;*i;Tf{OsW018Zkm}F7%B5+IbsPNsVP2mr
z8cMBY4!<IesiJZEV3`T{`$K+wiiRz3nN#uihd*jE{yN~X)cjB&)St+C0sDz%c8Uzv
za6gp}9mz?m!jME_Cbz-Nh4259B?6(;xqOkLC*d@%{(oWbhhvmpD!?Z|v+?;&k>>l(
zs)(U1rb>K#^TX8wt`S^mwIC%qIeEkot{1ef7UWc$#!o~$|8TY7ZVVD!EjW0KY+A03
zC4e@vmy4)Z_>)Guh}G9CkO<To{Jng&U;(=PqXn1603VmH7A%<s{WJqJZ7vYv_X0a4
z=`LF>Xz*fN(F-^qVX>qWe@S=QYJm^kw&RQV{7ccLGf~oAwpws}3f@Y*N}E}xC-ea6
zE?X@)kLc%bFpd6-PUm~sYC#p$*T;BmF!XY|E36jGhGB54qC=LFzspt&xLaX$qyeGn
z+O8JxGrrq7lt%u5i_{7XipTS`k^xN$x;%eV;Dh|Y8@YkK)!i|hE~%U7G6PjZgJV2_
zFT!tQh8&z8>pxlZ;q+NE_aa=bF4TS8H?TMGMldZlnCA&(p21W<H;{KKka;|i(Hwr9
zvEZ|N1r7u=j|VfFbF#~(WQ8|~$$Wee^m)w%+4*J5bHcR(mjIfA{IYpj;RWyqR>lTq
zdg}K1)a1OS0LaiYeaN?y|A4^W;EG;gAdq)7ka23i%M4Z~_%C_y<I!?K_koPpNF7|}
z1Fk+9I2Av5Rdyh+IXfpe>=HT01~SfM737A$#H4?HMzdJ<K+b`TBf<RG0~yDeivQTM
zK3J;=W}M0j9|7H6(^!OjL_MAz*j;7@j)y-08qtE|>@~|Qqk0Ak7+f8Tg_rxTMcye*
zftrJXw*!06+Ww}RtFp3!-Z9zvbq8X@D`mV9Gn-d`5IE;=3f3I-)_+9KSDwl#`!1`@
z5dYd2gmXcO<m>h&WS4!Lh2UVmCzx?2ha`6wgolcRx&<?jpyso4!o7qaJU0hdiUP(l
ze&%s7=|5DH8q9nxn0It^08YkhBhq`Vy0vb<FX)!_<$n{j2QrSZ><2Q=NT-=j%ZE%Q
z<2bp?$tno%{EsO1+3iRySm_JqboU=ym5_2N>-OMeUv@A*zHWavRP`@G7R)$`yhkkS
zzWO~7?{^u_%1h7+ruAxxWfNET(e2wk@G?Xxkas3n<Kg<%I#lDDTQ+;^X|AH&Xpg|x
z!7NlkbAI>$A_GSROB@*5EBp*md1u%rcMbQStS(gTFXJInFfN=%QOS)*G#Q6t63p$c
z{RzU~P5bX=nz=sh&!T^N0;}|7&F>TgzCaC`azytO*d1|4FRy<*iPQUH0j`18b#QWQ
z$W8-?A$x7G+j^_Pm6H=(*^F+7YMu9;U_OxU3FgL5Lu#{fvcfqM8Jy?~q@&w4&zg;9
z9wm`jF$<*of@69G(t8ERqz2McgJb#z()$L-BnQ%yLu2Bz0!Qnb;<J!cRyZ1Q5Fs?C
zJ2C|7OkGoVWctOoEZuM?yZ7l86&Oe#UJ@MRDhZ^!oHpC<nsN5rhPLhXD%&gbjQ?15
zQm`|`pl{0gluH|eV`ABLGSA!|j86_`c*sKdDhlWRSjxl5)u)|A+oU%X+NE=FSuE5{
z=J8OvE0FhE7P@L~cp~@;bnitylLin4L0v!t<mBgu2ML}b(#__coZw^+B4wA^1>vg%
zVL~wPwREt6F0&Y?1pzk=eI=OLj4H^<f`%#xfAS4e1mUTi;5biK*}Q`ANucgR*PoV^
z8-7^?voy$)I%FphvQq`84fUT~Ruvqb>~E^JgVTnO0pB^fWlIaf4}z%dQf^t_f<VS=
z;h;#PTiIO&;WYrk!fS!OQ*#Q!l_DS(-8!dia6x#k@{*1Gg76g5&dMzaPXr*dJTQ7F
zWJ<4KPMAC;<MxakV@k%<DMsZYTxwxN=<69N=TVh;+XI=~4rGYFta~;^6gsXZ1`QGT
zOss|m$J_ox)t|0+rEabsmio);l+<!>{aK1_<~9Vp0SA>FFj1S3k$^9lfmS#bpu%=i
z$k=`$<8h`OOzRuScr>Lc#Ob90{m1S&G?;4#@}BYT8tgy6>bhX&_TchfBUW^;E>CGX
z8xy=^eBGV_BfhSllQ!bB+Rsy((8*A%2X`LBAj=i(CG1Oik5eyfU=AxEO*s!e-!Mz!
zgPD&8T_Zi-&}3Fm{Dk26*iih&VCLh&(XqkKfsDT^y?%BuxQbsB%zP$fXNBU|2GNCb
z;sbe)x8#e2wg=OP2Ynpma%8-~%;P~TH#ao%RBj;S`A}wa2!CfnD1SkL#;CEs<s=nk
z)+F!)=3XLt<)g;3+wRGHG~OET2`=^oqXU_zf(B$cXt6AR08K$b&ZXq=;){qHcTZEd
zU}vOdq4R^Pxh239$HxXTAN3zv{+9z8r`|*@?BrLMXP+<G;EadRmq<CI*?(x&u)wP+
z=b=?6+QBTWoTEd!g07shZ?nq`_P$`QXIxI%w5+<lzVP=KguIWux%OqJ7oP19vG%=z
z>F2{XsQVbhM$lE$E>wJxmOx;C-F{=)7iE_MnO|lF@;)o;n;ZTU5)0;i#vVC1zpP7c
zcq<W^Uk3Ig=d!zU!y80y-Oy3*6%fQlBqk*zw2SiLlxKY4Fve*_4c`S?(czDW?_`2`
z7<Z4L9P3$2!DZd?Zs2G`9)`2nx{FcXO&PD&U5xQ=Y6|AqF&VE0@}3VCKo6Wcka3X7
zH)QPf`Uk@938E1)j-%Ii$_-yU&t#j^>h=uB_zC&IfNnzqIF6h`7+f@0_!WS61v2(Q
zU1SB@VF*miDkyX1hW`ru`i$4=!ckBisZmR32qWTBFaO=J;drjq{dh*>Sq48J;)0p`
zf_cwp=ahBJ4KG6iQ-xA_KDcsU0g&@^!*hYG+t;nklN+8YK%dZ$=x*8BIr-tSz|BS?
zQ?v8K!vTZ;VERzhh`(uBkFrZyY>)(j7xq^$ZD>~6(%f(dkyJvk=12iv5{1A2iY@ea
z^j&0Hk{kX6eq_p;$qm0NJiaw6_Zromf-4V}83kq6=Z0UDXh&Xzc~LexH~h4~$HL@;
zjA7i)#JCbuW}=GCoU$po;rm5+LNN1rR$zA7yxj0=pr+mh>uZTjv*kMWI}o6dIc1A;
z!?P6L&5kVeM=)bwR+(9rlp9V*7;AueWgN_gR!6N31Twf1wj*r8RRaPwuccgqNk!R!
zy>KyjhsQjaRd9Pgo6RNCP8hM$v-+K2&1-8`zG~Er3$A>=0Kz&jH~jvWtO{RCklk<G
z*g(d?w7|Hr$O*lutUNco7vaH7s6S*~R+t<9U!1)Qd{oudH+;^SGhvd9%m4wRMi~eo
zYSaXS28f#55U>O$6OsTGF(wm|5R#b8KtKc0$tZ_o5UsSdMN3=T;v;Qsg-5EQ+)BV(
zqoSgqqGEf-Snox&>U{sT_MS<!ec$i*eYRotUVH7eZ)>mH-shZ07~d29HQ73qFaex?
zvjDQYvclRTNfm%poWC=SmrQr~`B+?OuDviPmUDU_6_YnB+?O^pyK53=5SF5?+)T^!
zTMGmYh)>d&QpiHSBSTb#*d8M97Z~21Fr9j#@Qs(MjIxKVk#P#aQD_9BXX9>ci1;#Y
zNXj4U>Y+GG{z6yJgH%$v7k2Bbe*wcPpFIR2X_W0HL9IfK9jrE%9IiU#J*xVx$3EkU
z0>Q|aKsCK!!C+E%*UL%>7L5}EC>H#wnJTqT<jA@a0~^qR0*rj7&DHxj)w!9BA-}&@
zzoW`@lv~T<B%x{8lqz7YMD_;AA5zqT-<me`T!774Y2A4jxO#p-OfoC2yc|+)r|I@v
z9*{Bmu!!NqF>(Xk#9g*{NA|A0G-vN7GQxg<)^9ZnV4DZset)&k`p2hoNWpoDp5F2@
zSg6{1Ruo0w#9C5+(2JbCLT8pashuOPp6w_jqo;DG-`XnhbM{8>5zuPO00?B!uYxGq
z|C{jXThEG`men47A!<d3r?JH|-(TYOdx{o$YMX2Dl`N%x)1>x6Afb6$LqSh#y$5l?
zWdYA6o{omrP;;H<#sK~wTonkkcyc^A*YQlMQ~tAVU2CAjgYQ_P)nIJ{@K$^9@i}}n
zo7xUG1U&75j!<*ZL*MxMPkjKv5&j_G@b;UFA$*O>WAGv($6Y<}&he_rTfgc@1kQCA
zh3;YVM_wc?c4F<>IY*#uSHiw_791)`Nm0W4oaU(M``3L4V`e}z_L+sy@u4rsg?y9z
zrm<AN>{!lmASQefHe8Id!vn;^;R8-)qRLaQjdZ|Z95dHC)id3lDN5+1nMXpcyxMP_
z^9e5|DO~S~?#}a-U<NG?sqNUuT(lcaB{l->I><i=0ks^;zw9suVf_{+^J0{M^UJLx
zs0A^^vevc!e`wTjaz~KDzmGB_r}w+=+J+SEF*-juG;H&1qjZWn3oLQ8uQVHM7&EFT
z_Lb(NP&rhRo}ywb7?C+9KA^kk;G4*HJsXLcb0%V1f)4Oj<ZUnv>2%jdVt05E-K$fS
z;A%3PHY^&0x#~F{Tv0H+pUkG{6rf=4Xn5wB=n+%}yYgrS$HFm(3)1gv*pA?$-}?9?
zo{sO~^!xn{^z4hz>i;k0IeQDLd<~~i9t-tbe-IelM3gKWW@M$*Kflta{1-l-)G>s~
ziBARK|09F{H~V2Ot+ztV={;&ZgBioV97Zfvd9-`Y`HCy@6-~;BIJf?ba+q#1&Ipxk
zVwz-%B7hr=r^9=lIhaeqfZqP-Jt$y#1Uq5`E%^IXWAEBp;;kyZ-kb-QWoNxnw!6yk
zK5T9NFc!Ohq3MOAe4@9c;2ZN==f0DgdKet$JqqV8gmP>R<|#v;5zH_{J0quqqhTZ5
z`VIx4gDLgNK8>XCY#lBOVh3>E;klfeZgXwiO1&f=gtukp=0W$An`QlA<C9HFl@<Mx
zmlfP-kU{(%Zr=oDxjTRZf=Dbh5qkn_NlznHSf~E^pS(ch-MtjW1204KiE2kemte$x
zv_(q4z}G+ziTkbJaCHy2HE<8ObEEXXMg3=u)4fkzfL<r;J*V*s{FA5A9rzdL(j?CD
zRCD}^=OpL=R|=*b<MZ|E>o9>Nv=!JX(-U14T4E;$ioQpGVsGwdY7b!}l1IHIQ^^}X
z0UOh2{LMQ30gu+$4;4_0>Fq7ab{p3^U?h^SUFa|i(l!(<T3<v{Z(ai%`)Xs!NqAH*
z4U92L9)aWS+)(XUpO!sqX6RIx2a7`?9=2kvp9|8EZ7*Z(&7z3|&l#^{Fh)Q3wq#Dl
zf;sbw7m(zwS+=Y_uneCF^sK;l2T7LK<4N<@RRPHL)sWJj0KTsnz=sE0Ta-=Ti-%=k
z{=o5_PP70grq`(v8$XW`!xhiXdC}-Pm2=$q0$z2g8@6JxIXByl;0#&jZGP+Y0FQtA
z(zJDN8Q)SIV%9|SdI)6KMiV3`eg#{6U`qWa@|FD!bQ#BI?M1D=Vv5|5r34O`HN9=(
z+9hx-D2zdrtF5iTfr6z)JkogrUde1Ef`185S3^4?tsZ09<UKiy<6GrTUvR_=JHg-7
zT5T<*%A_ehAiVB(Qs45twc@+zo*EB*L$x`fujtuTnk{@v5oHzLxn4|cu%RaCY3%T{
z)wHw5{O&x)?Xl~?6!2z^%7diXylG}7Vt|nS8RUf^;8h8uc%o7HgyG$4R(hCoc9@k@
z48+?Iq^NuVLc**(W-f6?VjD)nmRMhT!0>K&_0SoM8G0ge+O_^|%%qu&W!d;Dr9y}M
zygO<5D7)ADI2Hxr3X(Z2iz<)xc^^ihVzxVgu<;cHs5f{I0E@kg$cu(|n`<MT4PkAU
zoHSk<jBoYomxHxWRuuc1v})_z_i1%J6k&W976}@N5M6Y3gJxDf8=j%A9U-EgR#Nzk
z>bm`Iv;><!#dSNKPMMVlySpA&;9IyN<56N(K1_oTVa%AI_^yoZio%Xzd00uqqK=~_
z42vqedd7i8KnY<3_*ljn>$lL!7|J2<<Ej|+U8#ftzYd%8X!KjsRB{`~xBZf%K2-Oa
zl~163xGo)N5!#s<3ohOF8t|flXgYx5u5C6~kBy39rC{#QkOGz4;njNBf0z471!Aig
zo0_TT(dI3;-m}DpSaNjT8`uuf{iwy`!^Jc20r+<OT;3SO{L}GHNc=_c=Rw{}zxX>i
z7Vqzue*`0mhNzNtCkRtu9OBY@)K^78r_}(NOE3}-Sy6w6b4th%G?n1L6OiNwt-lK)
zVlFv_e)@bB<yML4VDvh4%wN@1SZz%uGL^>`A)4fRvPk7YX=DbU%>`tytS?G|1A|@N
z^CgxRtr#z$1+-IT^@tWgyV|n;!Gn+DF#?)m5+uZ^+$*?S)T=71LR5$z=h!Y2ZIeg{
zk5~_Y24);XMVx;@wQ<0@hp8g^FG*BbZjgxno|tjT_6l<9s;w2W=?DduF$+X$(SMLC
zWh{?b`9RaR{-#*9bp@e#w^#U@W>#Alaw$ULCooSLoN-5UB|%yP2Vk@Y2NFwg`tQ`+
z2WSb7z}HRCeG_mNZA2Quz~_-)xVVD5wV&!#(zM1mNY7g^6OH}h{fcY-Q6$+7NBoZw
zx58wEM@VjXwRJnw^+f*wEcl+hs8!`wD`Ort4ndlLE`{sb98o(Vc@e>I?#3z3kWE)W
zRJyjMxO$$UNh~{xsjkHMnYcSzNcAeWgF6uJOq0MY0C^!#lv@hJoW_21&8XZW+;xAG
z%3S&Gdo*;+@fPfl?S2}4KS0PYS_lZHaUWy2qlbq~?e78e(Zp`|HKkWu_cIFC9L&7E
zf&v@W)&_<luu*NTLy}^!3oHCq2ZP<wbWn?hwv!WHZCx*bQWQp85wpEi5v~dx8<ID1
z`F#ugU88avBpjUy;p||CsdYcb5;Qalf&=U7>|WzmLP_ib#0A%ZLq%>CHT>H>e%I!G
z;`-|L0@vofEECPp4#T_N9Og61?ya)=PhtGyurQJ1Yo9X9?lmjdCqKQR?B2)0_c$ow
z#*E54*O%QfFb#8DW&Hvbz-U!w=mB&Awph9GrnLb;p4f-YVd4GGVyyD?k6jy=fe6`$
z)lRj)w<BhR9x&cC$ryUYY||sBLw_(s+n@+I3fnz>vn%ortvN<qi16wb#7IZFp8B-j
zsJzDrZAVOX3ee4RXsoT%t1^P;7@rQv_)$B>R%eE`29pYAdbi*55dxsSxe%+{%;2A4
z8Ei2^TOqmEAEoY8ZZSh!d(-YgNOa#jnhgg|Q_addNrgnHxE!ZF!Q}24u%_u)xjx)=
zkLub;=V~A-ZRPH+I}}7$iGIm#&d>!gure_>n2X-fsfIt{(v7dmTJ<hX33TqMrkFoU
zQB$*QtEmpW0(+w{167i{^Uw$%<9T;iG(1Apn$EYbLA_o?_`Ec|efmVqh~h_lrrer@
z5~wQUP0TQ+`JhKm^Ibn>;yZh*oj7c}31W7ef%q2%H+H)={sX*cbRlrf3JmtrtD6w$
zE8A(NA&>%ZvKPJ~LcaJtC5QLjAiA{?q89x?m=X~<wW7+p?;SBR?<q2EG(b!VDLdKp
zMR}7Akkt}Wd7|kHf0GW#GC&Z+fX`7(VI1$n7{JVQ*PX32wNfEU{b*L+OY6Z=s<QPE
z)sfpUh-e#zDfDr<2h;t+`+i?^B?>l~E1gDY3mC~bA1F^!EIB%b=A@AEET2C*k7i+r
zea=CC=X&>{0u?Ob?kk|%Gm7EUmmJ{uGok@HE_oxWKN5jcJR`2)^mgG7mqfR{9gF?&
zhd4Io$Xz173w$?31mZmFfB@ThG5jA&Rk#=Vt>u*ZLE6G{tA<O{QCiKV87M8|QV&YQ
zn2W_`ahA`T4%i~IBHM3Wh7^hGC0`#o@E!a3)(?8nEin)?yJ@yjiS4WkY~w($cbnnu
zi5$mV23x_>H&c+QSZ^`lO?lIdVwkq+MsXS$gT*idJqAwByc5?K+YN*vrt}r(qAM|@
zILq{A8O7Os#d(zPE6x``1>&cKer7J|3C<zo|Cn%9Rw_o{U+9vVajbXAw$C0KxRv(?
zgrCy1yvka7QizI>158b>+&l)jjs4L@pk^RCVm*Y#8`$BYvz}1P@|M<BEgo3ExUd{*
zYin%}!WwRBrKk?BA<ytkS}>_Y{1Lu?PU-9g93`4nId`sSe&qrLovxifXI_V=raiy`
zBD_4T9nX8g)=tn<<Z^!3f6I!WxZ@-U$M<AR!#+Go^XJ88>Bku1V+L0}X)Pd=HRrgL
zN5$boDaPyJe-8^T%sFC~>MvLuhEG2nvdZD){k->1<s{I{&0$96vyj1ut+Kbo3Rgah
z?OS#@gb?M1!sKL}Eq|4?Y7A8AEW~`nT}N%fv!L9~TOub0jBr_h0i8ad93MV2KA3dc
z+g}h|XfAQ@K0FS6Iv%v|?nA;XOM8p~M}qdp7!XPW5^gqBS3%!7DtzS)&jQbH9eI;i
z1%ran15@=Uwj}fssJnv$aASSGhOdEMZT$@B5|?;$5S{mDC48&*!XKp5u}0;`V7?LH
z0KXOBHr$i2%InO^&jC~ShTl<>_xE}~#(B%<VCC>T-!>`hD?bOTjP+T$sBlE=M~=@;
zgr|qA83(FxgpQdzVRpIs{>9=&RalS;s|S?fppunw2r;^{6Rw`SF&du_r<x5Yqk{bu
zG`$T_&_F1y!kRBCafn}vTc5wFt-|`>H>d`dngR~h1bIL}&;(f5-&BJ5KSSVC22<<9
zvvFUeGR^SiR>4(CH%CDl_^mczz|o?n6DQ5)h$wZ34jA*IL8SgO9$8g^K(~24Zm9&5
zaiT<fYY7gloMw{GI*%KLxG`oy;0I4uRW*(BS;GW$;Dw>*XSh$2WxPT|rfWB5!EBHy
zFp6gzMY$MP1?JGYOHNE5na~uKVHe+=m4zt8BPVDI=xn&WX=1hY0J4}>Mj(stUM}{S
zvv5A_>N!Y^Q#{*Tn-z)m`c$I=66ustl^0A3@72&Iny#?M4{eR&P0)|!IG4^wYhKyf
zl2aAb+7<D}Pn9>VskSbl#zF7^lp$HwW4SmTru|t|GAj#HjM*rpNg|g5mn=>dS5%cZ
z&8xNsj?*|Y&~ZPJI)Q9OQw&s$L)PE8EFH(uf8|vCg3bY{2BYVp%k`UTJRI;F4DFHo
z-5$6p)Ywj;i~!v8fM<4L)tq^y%3#ccUhEb`Xk$?L#NBxrl>Q!3gg}Paf7j(4H$%?u
zwMk0IeP~t^o`)c5?<+v`!#OB$>o?(2Q!;LmA{-O#tvtww8^){f-#>e(y4suv5$-5Q
zkk@aWdY$(G@b)2=vo^aIXC6N5`2_T#L*8RxVchs}npY!Ifc1lT+ibcJ9GXe-lAYPd
zjc<*<0Y@ofyVI{;n~D1!z}3@XK^*j1J#k9Gx7d8-J5C7tnQPOC1?g()p;^OJO20-+
zpM>7x+!KAd-VJNni|SmDSJD+Z8xvoS3peQ?j&S1SICWPf_ALgo)&nP;?(_6|Uo*a}
zFg~rowu4f!o<nqCD4iF84Y~2iFj&tBmAfK)0l>g6F~^yu*kNlYn(os@n&yi98q{)L
z9B{!%F&(E13A72IqUo>S@_{+alXIN-{5I6~$3kvjEab4tsVCUm2cpZ7irX*Or<2#4
zf&Qc2^74iSu;TpOCF_RQxI#1^=-pkfp*K;aF!4&1o;B;Od=1lqRi2mOH$H7rErmlJ
z;A~e<8t6rJAc0~xC^A9ngj3SAzKO*qEl?({nIRpC@5KvmA;MkQ9&QRr>>Nmz{e|ID
z3>k)lir0Z*?LkNcXZ?GFLoZL1QSb}C=M89s*C+Ij-`|8e*lG116LW9~Ri5iBpr`T>
zUBd(q_xY*`p;;i9ql_dNDW+!3(yN#6O{?bG^JVQ>j__Jtacy)XRzQ5QWD}x6eO?L!
z5BecJu=CJc5JAZ5S|`Vv3v`(BG(V+i7&o|JWcsWxUlo1oBW9yVa{v{KzaAOLh-&K<
zpcwfRt>^Izvzk`X`v8>Hg?-)~)M(CW3d;U(wdo9(TMr6))C@WIh>1RY3k-p6yxGjk
zO-3HPm98F~DbhWr?btkES_ozsJysbc^J24W=OSE4s^P}A;ob%=LS0{Om5coPqLB;D
zuI-B<^sB3^{CH!*vEY9<x(@cgKwwfg(L~q7@M20$?-rQ$xOGHsL1^oApYGcD9J&V&
zAiOWlDBBhly#K%<eJmvHjv}LShw0tnt441cVhAb2|9vGsQF~pHWa6;N#J1k;-Fa=n
zYz)OL8gy2=iMIFQa)iXmU7@wz6tB-`fw-%N89ZVZrGXdr!@&ve=`F%SH++r82)!nO
zUJFJhSxrZ}TMiYRuU1<nD5U!d`S{H_jgdxg2DhQOZ<Z6Cibb1|HTtV?w`*XBxSqVU
zBXr|Up+NiUrIXs0lKofXnOC@=(qA}Nn20NCR<q65P_r^X(dPN{$datAfS4XUhpeq>
zp@T!lxv@3aKv;CnI24VKFzFbv1COvXZDo_J$F^vQqP8A+;)oNUOX6vwOc8EaoD>gd
z`gmJnGahuGFlp5UWm3nblRA`^Rv4o=w&W7nv<wkwo{qLaZDV~S-d%|CCC*hvQ{1f~
zC!62VAI&goVCNvdySvZ3m$oGq=Pa|`iBlL6GQiRN-ngY_j)W1m)dxlR#8C*Mc{;IL
z+0Od#)!3CE(#l_tAb~4FFVKWC=sJblETNOo1~<Ue37w)#n^o4Ws7mz?!Ox)0vW4o+
z&M<xHg$VD?&Ir~aZsPMHE>tZrA$C^5NkYdEG&x!7dP<vqX6@SWfh@$!*(pbBW-(nc
z{V4+QL~<P<eu}<yxU1k5kNdZ1k=hGp9V(cn4*YL-=X53b@W8!NzCohSgE5MmDc0LB
zNo@DPCOIcVrXVg4U!l_ixX^QOLup4n;`*+Qe80x~M0g+E!X4qgn3)sd1KIHaiMJmS
z3Zn}bc23}60Jn<#sCg16b*`Rmn0E}MXA6E$7mwEE^{!&<Dp!O)(PrN4fsl&Cpux>{
zL`7U1Dd>V=H|8U}*Ad>Y8%v(0dxy~B1_G71uT_jI8V5~18&)q4nZ1XtHE%+r?d_yv
zE8O-$nAC3;rb7~*G|O={kmI4JOkCCS9xXRsvvzz=li(>0A4;2fvwq9N=8|Vk>Q8Wn
zS>d5c{}J`2BHeoA#aOJ$`~eK7ClIndYWm%NQ}tO}0S1Ugk-M)r1Km~34i80g{!GcW
zItH}yca+2d9>RY6_(mO$o$3CJ9^UW3G}3sUrK5?my~dJL10}|5G$!v}>kkl@7|R?U
zOFxcEO40U7a1cf4Ok6)HH~l!pI_Ae{jMuHV_+Eu)=32dL8ZP@{f-=q^=#F6qn9%Cq
znq5b$DjFItB60Wj3%vev>7(C#jgi1wM2xCzM*$8sT~DdAr+Xjnnu)7WV8U=;meF-0
zItj80RWKkW`ZTH_vc8+xui?E5;mKKd3Zh1_BU;M>Yde}G4FxUBmr`y-M1rC}#82DJ
zvp0<D{%U!!0J{fDBXnwD46X#adOLI=Epp-jNtB=0{Z(7&J>CYvH@jyn54~nq;M#ET
z#qJqnL(iGG4lu0GOGY=;<6iNzjeaOr2!HY94Mx|q;WHlBz5B&O?uf|^bg_IO!fqj|
z5$Rg)>e&m8Z-x$n58&9~9OChQu}i!MX~WTXDG^Uq=y(#xymUl~QIzY5mOxMRQJYF%
z0eVkFwju643u84x+h8L?LmErA)BgDzHGyjC1~&%pigZGrOGS(0>-sPPZW~>|k#2R)
z>G*xd@rak<5X#$M6yBSK9YuFbz5S3AGrh-L8|ga~q(aL2%>@pJd7T4712^M>c0}+(
zb~BZ|#2v6jCctq);BhDR0;#1PY$)u&`TyT|s4QPPc=zQJNjj=JMI*X4=X9@rPp@7C
zl|GOo!UWh~X32<C#+SW52l(0g8kQ+I_9_UaS<t)FJ9HdlyEYDB$D21})16Y!n0eiu
zqm<Aa;9K<KLSoahqrD66&W0O$x@fc>!et~JLRKSW<+JkReOmo{v7yO~!2iaUTjRON
z1Luua#y|`H>W1xLZP*!hl#$Fp@c!C#)gT@0>bV0bAcFfp&!ZIk4^JSZDUc4~lWKCm
zQHa>j3BsFAoh^G9_vp_;&xFj&6?Ji<7Vm)H+6FS@74HKS@})^Z6d4!aaNc@5mw4#B
z+12wAF#}GTE4LuTAo~~K9^BhKCtW4cQHcH_8tdx$6u9Uj5wZ#ej=C4N7?99U99$&2
zTDhf~WLej4XsRs@zvmt8q8bSFA9Uv&!E+x)8NsnU-Y=emt*{SZ#J@S<u*EF$s7FAn
zuLwsDcy|1-QRE39R@WDK%p#f&qbU7QQ98{+FKnJ8p(KniOc%_%Fj9CR)z+^;6N`*B
zo<$>oJT5zh)pp%A8Uo@;%$5@MkpO_WDo-~H(~NSDQJB$P<N4Njdf<07V;WgH(e*$l
zIjwST3i=0)oJMQiwWHd)3ax;A^p7N*y1=}yo&z8ay@NWCWRGCn<<?k%B_-Lwen>{S
zpJ@KKqb~Z+T)x|9z5gte#0f%lBTC}pk8j%3)#1IMuaLMph@&hpDC~lRx8~8Mr*(*q
z@8;VjJ^f#BO#qeXL8Q6A&z4)gAWlb^Wpr+2qzpWP!}JrpHXWkbcprB`E~D(PC`0`7
zJ7rOF=^!<6cHi(dgle^Q<#)>~&>+eYfy!pm>EA8RrQ*uONJc`jL~}5&-?4`>=qUSm
za2RV`imQm*7n{Oe?pW}X?wjpOXaJW$V70^1Sw%OZF2{(lG%uTD;B)`&DO%y2BgUDW
z<1d|zc-_G<g^+RKFUPIhIeqxrhmA7~4ZRPanC3=LhYjGfTArb<IRKR5CEiTenIqL>
ze&`2l9+#h@;}e(++Q37V^XAN-_Z?d=afc4Cs%mQu!88^30C0!yd$;Q1cjkZyd$%4H
z>G~1bpdv(}%$-v<XMr?*|6h?|Z;FOGJi%66ItX~01NA|+jqwWp2EKX#@^!6)Hg>{9
zZV9cp5v|j8K5_9*8m!8S#umJhyORd^9sl%J!~^k>JDOvPeR*Nendb-3>c07WB{a;O
zR{*wThZNVV@op1LuoOz8tE|+giM`2%eY1Bnh1UL(3Mz<!Y^Fz`=%Ocf7KBMg_cc01
z=c?4cLN;0s722Uaa4&-nY;OOM_Xu`R<X6;(N@%Z>=CvM(6r*=8?NOW=^KH;IQ)o~A
zmXP2|@1Zi&Mti3i)DOctgJomRhX`@?yutd(ne*ZXpT7I4TnM`NmxsU7Rt+=t%_Vq@
z(eG>c0MIHPwpDzDyI_{V=X=&Dbnp{Ih$;3J(ZjS#xa*V>Oh(AQkK%M<s)*58nffd{
zYF}?ISzlrO`!LgqK8Mj`nlVJ<>73)>+`fSn<PkaSH~pSMqjQR}a3Y?P`0&;*KL<tE
z#w-k_qN3sOV3!`2q$uh^0ZYsZA_xU;^V)Pg3}!^~Xz)d8#-4m65F$5Tg>TSH=K~vx
zhHdcM!QqH>N9d%0)eNE2TDtDKijrOKaGtuswU*w7b2uz-Yg~>;e!IWaSHZqH$>aXO
zxqh<(^eXFZ5e_jTydZlwFxb`e3H2^QU68iUX1b7AAI1sW#$6bh@q%$*E+EFIFgp)H
z3`FT=Gv)>&-^Y(J(S(YA8@CaZ=JmGE3CLs(Zm7cgWgi;aObsC}s`i@<HW;y2f2vn6
z?bUCGze8&AFizBPs&=sYkoRD6#UbxsmGVCE{Fzyh=JQ)gq$wiQE86-@NJJ<mVldSF
zpQ-r@>r!r#hJWE960i(5cg+R>qRDCUWE(sbVjP_8bjWq-p02M<f@KeuH;dD-{Lr1n
z=|+TC=LdGzQ%R-M&$u>rqnSkK!<}hL@V)NNbS3l_R0{0|dUueRBp_nCs5+&h$7t3!
zGyAVW&=(Ot;`TCdJG1(Ra{YVUUg2xVn3mx7%0q%n&%#6)yO@7^Y1vG%RIh})(iGR`
z$hiQ8yD}7<m0}lw0lU}Om7u$O%`hdD5?%wGo+V%yQr3S1j|B^QXFE-|@v-$XB1>jf
z2`=;ZUaJ~-Vq#v2xQvCv)4du3_^q*B)OqXKzw#Q;5rEU^EI|acdq%RWrwLvV)<Giu
z4oGyM5t)c8#y-&BY;pg^)BqR@@1gFaqaVTE4|knFYCHIfwyi62Kczl!_L9xyi|wL)
z6XQWwS#xFk2WW>({u=8V>r4rEoy5rghU+)P3%r41Ay2Hs9qVu+`q%{Zj^C4JFKw+R
znitSTuVNewoLFI<KFHl8Izdl)IqI033D;y{W_%ojW_MaQ2s5I44^6WY9KPI}o`qv0
zTcPt%LAvVq$9B<p<sAGPBq8#^h21mlK}Sw3+6C`>ljwuk7RJXpF>B^q2-e(4j`;^p
zmTXnl6me(8;4z+yqCt-8?mCFs{xz=Ok!XQ{S(mY)NH_Lehj#Pfo!kkF!*$2ka4_<l
z;7^~$JSN4i3Zo^m0Ejr#-b}wU-L4*bbN>I42O)9i4)Wj&2Y8aA##h|g-mZJ)P<Nw1
zMA9QZkcCj&^D)?6s26AyAr%mI^KOAjiW$NEtI)k*Kbz?;s;-XhqN(mJyVuwpM55e?
zwBg6P5mXm1qE<pD@%)=;JiLc@RB(h3d_l=-YlbK>Bex)nbKG#(oyywDkX>hRKV#oX
zy<F`t@2$MI6i!)z8?q!t;7{+mbKMD2n6AiMUt&PSf<4=C7CXqsC->w0T8z<%c&Ja$
z1G317q#-TG{sbUK#Em>XBob*xLOdsO!gOPEfyvgqOw;D%tBpp)$yI5bv0a3m*jODP
z1mR{xbU@8nvwLT&y`5Tkug&Pq1;mIr2o9;F^kxh*?#n{1*cPE5<Gv~M@2uJM<jSS8
zUlTztwu@>G0lGvRv0XG6z!yv8FZN-oWqJVVYPyUi@<t>BxYo;nqIYaYjFp)C09z>2
zyO1^_w53U0$cER*!Y%)$at~lI^Loqf#41@=KpmT+I()8$YJ8bT;_)Z3&Q+G5so;tV
z8;mKm!FN&LDtZfPlgC)fgIB1Jw7Dm6_%!=FT^<e^az!l-X~CjmjHvR*qdYC}9%awp
z+)Kkw7ZWC7PXi`e2I))U<7dP)+!FZ@iS;us!on7y9!ae>vcH8VnLZjDG~L|Hth<@i
zRBy2=4F$GT%w7_HM(;xU7jL#3aL@EP*A0tB2vAfQ-kUzNm#W=jL2B(HV3l<tHwfuV
z1vodrWxX)~nL>9T!|E{O>9XrzJ%zIS@_>s4?qef`G#1)&ggKX9IJ1{J=<20UZ<!3U
zaqng>bgnyYa=%Gjr;RH1$J+E*n<JJjh#S2MDq2556CiGKZs0-e6s)4?A8!_1Qxtn;
z9-?J_c?no7Xkvd<2pZ9TY*ryeV>z*QJyCu+m%F1YQJ&xI>UjXSRPtB2B40yVL9?-F
zHCXHwnJfj3%_OYAu4eB7B<SHTbn0X497uUm<-elm!&tB?!HY;Y_Ff0H-Xhf~cM!5#
zz-n=&)7t$cn&_fC&PHiTlhWI@JGP5RHnmn*Td52zOAl!0n?+L&6*$yG-rXwLmpM~`
z_?rt{(Fr`L^~53XU*b_JYxw6paRwbYM@FDSO-gJRb(=^RCP<stW*J2VeMKHxxW1w+
z`Z0Rzi0rl5eMQ-nM}y`bs)`FtFu8as@Z0qS7}j59J%G?4_cINuoh?Rq{IT{d>-Zin
zFe6NktI<G<vW#o9VaG&nMi-%#?5>`#gbh$(ZATS)VzbY>pHg4)ViRv-cJDk1@gk?E
zqr&O}0zxEJRuBoF5g~SwrAZamQc)@`N7n05vP4PF!h{NICgWfaQB@4&V&u`FnIb*N
zY8)<!I=&`UqcsHM@cKY-kf8XILy}VjQib*Y6GWa=lI#eci+lwz$N^k|cowO|BH(Gr
zC%6P_DUktskU{R~ZD&Yx6C==tDalH%9y<j%<qn|r;2qFQDdS_|+H8S~Mhi~QuO-^T
zg8KyF@E)e=>bV`B8%#)}FyAa>#`+GsGV2n%!kR;K!xHS83^KgbSj7@Q?$0H75tGZj
z$b7OvY>TcZs)RwmzHIkU*6jEs!J1<3U6D3^u+6z)ww|*$9Bu0UQd^ZuzKW?weDL4U
z)%D)p@p;%>n2bHsSLngqDALC?=V$emGWVM6vW-2o282_}3=B!;iL)(j9Y0S0KKvN7
zMy4ouDAtx?UHZ6WRvHEv*o<7qiHt?W%5GVjVB%}Dgd_ng_Z8&=GuBr`f{>mTjQk1%
z#O<QWgX{aJ^D4S}mZrej`U<R0-&caftFZPwhIW|MAEDHDSpAo8FsswbHi6ae0Rp;N
zVHt!e3^Cy(I{xphN(3aU&f}0~f>o~pCBb)cKY&#)=4Oah$0L<sAMoV}F7ZU)ha5p{
zh%OUXSzrH!dgYED$4pAY79lh+o-}UFt_-u>8NP<R3o<jz5-p95^v%NdV5QQ%hl*fH
zeF($7druZ+@W2wDEpXkniUbQ|nXIWO<j#J9S(pVA@GP?{ExaxZb>|Txql8yyBY!pJ
zsc;HRZD6K^SCeCN0fF~Sq^`K?DQqx?0i^4?*C8r}<FDY@M2EfvONxGc#LSu2jSq#n
zA{4C!?e2BSxDXs(mjNG1^fBB?Z5-fQUm_Gg3NnpmVnc~`_Ih?ew|j8+0p-g>=~<-o
za;LhUI%3X3+=J!PO1Ht1QtTP)zTGewV=Hy*UL+RBRyr&biG?v}joXmG%=gW5^A4EB
zhXQ@G_;Mu<aS0gSvk=2l<^I~(3lxr=GW%Cp1%iTzBC8+8VzZ{RaK!V>WofRb@(jH0
zfDMHU`<C}*E$0qq8GCL3&E67C7m*s1^I<D%dRMyZu8Yuwa2I;pvN$r-o1gdDZ(_Yv
zY2YQfwyvJ1VBbf#VuvIk=>*vT2n_nExc~Ji76`J5?fpJB?Px@ZWK$q1x(0|SmYzvr
zmQk8z7G@iz+3>wQkk~>u`mn`Q{|QV|pdQkKQn^W;=8AknrR=1Upb!esEX>87Ewen&
zsLsoI5r+*foVTt5|D#K!y7se5i0fa76{lD%+}Hj<bXsaaYO@drj&b?6360V5<bzm#
zJcM6iJ@vn0^K1ct!$gP=ePKGFQvxqwHa<E7a(jp~aj4Sbn=iL&a8Ez(--)UN@4;(}
zpE~92y><hhD}Conocak<1rHWR$l!?!&By_=e(<32YT7aXOC`Klb`ZGhu)%^mI_0au
z8a?}n)i;wEG&LJbo$~UhC@$TrcT>bZc7=6j7Z1Z=ULgzhcQg-4CNm5I8;HTs({F{k
z$(qMljWbEN!73{!Hl1N>b4Uo|U}C>H+hcrOZB0B362iiwyJm*|SkP8F@FJ)dOhl%1
zfCC79W@$baXoY{M=EwE6di1F2E1{81HVObN2hc1nz^dTMS&Rodvh(uq*Ub8FHOB(j
zS6V=IP}^LGH4R1LbK2vf8DecIOg!Nni=AU$LkE#;N(m>sckXU?ufCah+1yOKvo~Kg
z);JBG1>DkM>#SVby}#JW6AO3uKH5LR{x$cIB{iLwWNn!_>~w)m#rsh1BQcK$#|-^P
z=6$5#H<UW?EYf;?R1v0)o}=$x=fI-pVV@zGpwpvq1yf`-{Z>@tDK$k)oh5kIB*Rq5
z8-pqsgO14M6dJM6f!pUO_~sGnA>A4yBkeVxsl~FvzAIrOkZfX(ps`|U#cEj3a1D2~
z6I~?9XxvBh+83b#5++HOJ~q`TCxVYA3w#{^883+tp~<>^I*YfpE#_u1J1o>WM2ttp
zgClg7KcD@^<anw2>SJUXe9?#1Qi8Vs`SZnJ^dW?%1nu<?h2PhV7xqQ9&mKCxUkhsW
z4|Ttz2G#$GaW}%;wX853wOIo_-09ahuvcw<uk-8YYIsnc9{<am>FT=4+(jL;t#Z<J
ztKhUkLCQJs?tiF+o`2E~<h>qV=f*O1V+%!(5irU0(Q^_wbn@V${0o-g4Z3IB{b!zK
zT=9~g(ftWu3d+f3u8U2@W9?(D%|cvAy%xMuYAZy$s^f^+xP0FNG@(Nmn$_vC9Mokh
z)^7wSiXNJ!bfKc>Y~p)d!Y#_^D;4(=*ptJ%V~Xf@=<w=lY`PPF5`8?B5cE4R>Ci87
zu-Nj)%yPGJliR>Cp6K$G))i=O(e<%ac)7{XnSc`)D`24^Zz9jFrY~F^TLp7y4FSs1
zNHQ1V5s)-~W|-oZp^;)J-K(Lp;}7I4NyEMS_%O(TNWsN>X*4pElDM_%*-mmtPa~2>
zQ_1!RibV&_YB#w2n6-&n*;y4^<*u+kdsqy#)E!*~5;Q`3zQxt^cWk)CU<Co=SnNtm
zgHS=Iqlc)RXU-_u++SpHGJ4bJY<z_dH?{h#pMW+Z+c@j!=Uqj8BsPv-NrDzepbu9`
zg6T&8z`ul#HnZ!nD?%?!iC#q*q)|rU=qtJ&AX0SVy>y7p=BcipERZ_HBc#{*^O+9t
z-=#3u2M`+@xCpmS$@9-c%kfaE$|LrOFykxePNFXLx0{(6oJ`k}K&Zlc;g67Zh}Ym2
zD?&D5p-tn*4l*t`w#gwxU_5HG6_qe%p&iICb3nnzQGC>!kQ>G=ZWzO)7lE6`gH#2#
znr{$wD-Z%=Oc8;;RzRck>3E~-7<za;k?C-wemsaZS>lwS0DZ5vMoYlw?_mP*LZ>`D
z22Fe5AQrFtnjgC&k0U{|8Tm6UCoq)myq~xt4^XZYC*I$N&m_4bo00W5*&6OgR20l>
zJ^2Ufs+*r;#);ZZSex?l^~?bXvJ#b88+hv{0?p{dlf=|&HOPq2V;R$Tipf@8o1tt=
zQR|ShIXV?Zc!)^G2doOvAk7b{Tu8%;Mcq+Cur>Tjb|y!5hNL33(n?70e#0|RWsO29
zKlCW%xQwnWkU^k-{hkKm!Av)!R?{*GeiL9k?^tEM%;i!Ch`LqQUH}(~g|>Dg9bYCU
zF+!5~ISLL%8c~Xy42Unqc^}InF;)Y^6fsPWvho%oM#VUAghEP|QUjL~7sh+fZD^9h
zm7oCPA}UraqE<MOL<n{|>*%fv!-AVbPaKLgP*?mF=4NUFYZS|MS6Tns!3#O?guyzg
zcX7=4!eo9MDB_+@0dj1YoBws--=-3bpDQ7(<s`t@c+Cxt8mg=Z0bac52TdS*zaSg_
zw{pwH!AC*JWG6~J<}*2-8{3tJs=d0+*Hm0(wF!Cyf1uzt6^P*(-{NjNcgvb5=nb6T
ztB(VTta#;{<V0L5%5nM2I95DeTX!tBD;qf28Sy}+6BuHhs+;2R*)tD`>Em$f5Zsf1
zFG9FfjCw9ATF(KL5EIm28R|{Mi>-$QF*)HuL?u1Il6+M!`*}Mfx&NbgEdm~;R}_NT
z2hTm|f{6D-v`=ue<hcUIb~dT8T{^eHUA#!p82A<6XK1MjhT3bIm0>y^#}gmvQ}{d{
zDSLK(sJWS8d3c>ppq*g2c-kUTYHfQfe|pSr<7)<<!nt!5@4{lQZ-GKD+w)i8^#XJ>
zKN-P|Z2Vn`KN9QY!qFzA7pbWu)Jcv}sW!*C4*Eog8~&s=QAtg`8X&x@8J`Vt&{sj`
z;6z7Hd?duKB5Ri)39-)^m4|Rc60*aADzn4r(;{e!eyDQt&<~KLfYR{PRKg}osZ2PL
zbxu~O##y7)3!HOC5yEggLtK;5X?OhNB_pVuN=M30qGi0B8^w-%c&BLzqWnpd(ck@~
z$r#xk?%UWzcNjH&aA2vaXQet*X?SOkRR=qK&LD=OoE!f-N=E$aDCfzqqu8nc9;SId
zzH%aGM^VP%qb7-rXAoJSj+dW2;o(f6v+Ydzi4=xR{LfFXOp?TTFq0)RXD%50e2St>
zNmXgOE*vBv8oX%ecUlDK;=xW0ez+xTup9JgmP=%-=oMuz9a4(<!uyt)b7X0@_)<&G
z;K-@Y)FC8L=kg(6cVWiJwJSMHd|E2_bR?$YiXmiC<I2H)&KWh>(>!X8#yVZpqvVWB
z)tn(HGvl9%$&Y_L<|=LsM6V`@qFghiuYeW|?Ht~hH+0elTP~8bfZ5kjsd#X%2XRV<
z;9wHGLn#d%#Vk2Hl2+-EEUL|xGeM=u&KZ(L!`I5r%hDf=65PwYICscMutm!f?K8g)
z_H!Ohh@#9NT0U6nOOXqV3vBV^2&|Al1+^$qLCp~U!qi2)no2v~rA=}NqC_p7SLrGC
z<X$@M(#sVUpFe4@y-dDp{Qv$@p6ejP=)d?!d2I64=8EmXT7dO<cCM<urj9}=+ul}H
z-=S!)t4+zMm8sZUN^VrN<LWIa(=v5?4P{TL=Uzlv2c#H&-;kwFduv;uWma>|GEjI^
z0^RmNdwX$fT|m*^lAtsKmDO}CSG1E7ly0vH1zU^pIYN9+M|)fSHBN4|%nW-lu%c~g
zM-We#DcU;{dY)Z;zin1cV>6x%(B75s^X)Bx&R`+vtgNY3v{Pyrx9POZarTx4^w5E#
zy(b&<*xO3#n}fx88;_#>U0ua!6Yb449YH_8XjS`%dM$TgiX9)_Y;B(xSS1TAS&)rB
zENet7QAsn;-csB^FK<({_a!JF4Yvksn&a>R2`{jVZ<=TysN;DWOYDvG6(Q{t^?vTk
zY<r8hGZ<*$Hv?&(%4!SjHAA4Esei;P)V0ioSg^Vq(dy^w1x)NZdkvnuTNxl|F+T06
z{Y%!r!QQ!`y`~nZr`4+&wa(tgkizz5iuQ#X<|S^hclz2}`QxM78FeuuHrv}Ij8VUo
zsBQK(v0@DUN<xG7P5~{(1AjNx)MAzYt+p|pPJ5dllTJXc^0lmTi@h@rAFT9^`e_PO
zYG$`;Z>wy>mqi0y=Uc90%j{9@odP^qC8quu?btHcql{K}ULa6M9HMBCGW^c(z;mv^
zw$P4o$tE;1Sc4nVG@1}w=DjHLwzn&qP5T0uZETra)FgTvy{2m>BWzXeYk*MJv5Y9%
zC3Kr=59Q#?blUq^Q(NW(Xd0~9plGSuu!{+@19S<(jh!VMdl+b#YP>iKri$j)Xx?m@
zJAoR9GWrOKzFW1o#0%!Pp~gs!HmWW23DsUx)>;=LwjZs1g_yK0b1$e=VJj%w7;Ou8
z>L{?Pzyd9(IaVv>(H#THI4oUKI{~~|c%D<y&XKfE0z&gu5x7aw&XvH=Rr`&hj@7gA
z08uk+E-gd*19lOXLu2@Y#uWkBWr}v5Bzvz$;-n&26QrGVzIGPR%NEUEhut~1wRSm1
zfc{U=NE+BO4{M4PUrQTXf~49GT|g}R{qKy$kwOxyuZ*$&PahwPi^Mq5BP0g#88Os`
znd#7JksbP62)g7tEW2%jb{`-ql-6yT+Ed8b+sXpLhSs_c#Wqp<5b6bjQ%RMwb!lTO
zzECQPb8SH`PkI34Y$2Wp60)7e&8>JZq-~|<LM)f$Y^Og^Q>WNgX}Jt=*gLD+8-qaU
z)NWvileRO~1p7j<t=4X4pxfSAu^Q`STciD$0crNmS&)(yjcb5)v-T(h)9sx!yNc}=
ziIst^)Y8nLE(!9WPYr?E<$gTA)xI)NCn~I!{hKJr7Pqzp+gqCz+dA!4raT4h2Wla%
zMT6ZEJ<Hx%5?I+-8-OT;2!d(e*nu_2bloa3vN6S<W8$1NooBJcN(RN@^bd;e<~8^d
z2%?N8h0BK19vx0RKYSVf0qSTJ38X~{Bu))QT8bi<L!XhrrRfs{C7Jp}5ly5hA_{2X
z)<n^t5=E3k5mk2RTN4O0D}!~pvnbyKX!0Udux-<#NV_SmCR1d_Hq!QQKvF0@+cwHZ
zT39eknvI$#X6aZnzk?Q4v5l56-M*sJR}*ZYZ_L68kx)lcA<PHcSSF%nI+H+Hv8CJE
zKvT<fL;AF}mDB`l6x-Q0A^X8C^P#~N+c~!1FcLVW1Ya~E7R#{xl|kT@!rEFAPqy<U
z2)t4n2rhuC79BX>_8y}Wm%t+%?AbUQ-V}<q!6qfmq9u=Q5`&0EnjuA7+ZEe*8@*mx
z%giQN#p)H<bG90W<Pt>gl}sDn3<|6~?3KY!-q|L~#`D37&4B<ucQ(oPBStI$ON;kk
zkR(!UlWk8jyaY?~5$49BuSB<<w9^Fx{Q}wHv;xCv%7&~X6#$(U#G&7ejKHS}8iFs`
z<)K75&59_eqTwW1Q2&`kIZe*@>c^1=7>QPirfU!h_1yrBP-({gllH}cp2Z52=1-LK
zj-dgeZYkHLc^oVQco|otPSVT`l10(lMA07-MU+C(PW%jhuF;|Y6#4iU|CX+-X%1n|
zZON|#I;t$N0t~N_ICUm}0EnB?szX16^axdloh>#?@{1sCt982pNujjUHf)3s8Hik=
z-fWH$A3?pbsp=2ZE4Jhj)N#mA*3!0=5j4-RRh489(W-M_N3<xNWqaK1gYOH|4eu!k
zw%3rzx9xF@`U+{dLGS_h8{CX;Z<*g-7ice9t=JAqRENDL0Xyt|m+_oKt5<f^z%sNw
z?~Zbr+um5$IWGjp{+pzbMi6{4S+VuIMSs&_%?9cgw9dk}iRZ|&7bJFuy;XF9Iv833
z6UX+VEb`a`5Uneq73zvxJ20G=+`KNC6P4uABn|@Z>oDXLO6#_<BW|Ygw^iYJTZo1c
zWiSCqcO}0?Q&sQ2gHS2$v#oHSg+d{VT4ZCSxY`4(fm+=aTo;-Pooay+P;BiI2IW<R
zUd?H#3v@#3xr2-e1y<77Q5#2I>E6I#chV1uEmp~FLL_y%|HS1GNm2l;cK0y^5((mv
z;yt!C?r#_bi8K$s05qJ$fhh8}f;qZm9uf%V3to||*w(r;*^-6?5=Oplo%?ErK>i2|
zQ?YfsYZ(LqR1{c-$2e@a$__&O2$g%A1VHdeKgJf8AV{9LeXH1dB(Q|K-BL$(6}=}z
zu|?dwxQ*GQ{DmYn-2DuiD<#Yo7~OFGXHf6u6O3%P;Sn%8_Td8lw+Ij?ZF7fCtLo5c
zQ#o{6L?NwOs0tMgrxc24TRHSa2?SaXMgVk80{WXcbU39@^bmef8JyzKHzm+$X@*k~
zppPb?pTwa;WwTgiSx5!IBm>)_AA}Ha=+7l;orgJKTEjU-6;OVXv1}+4<DoSZSW+2Z
zm?)yP6GKfjHe4c=B#?T)i^P3n7&%&K???E7P{Y3?*!LRj%y8LzS`&xf2n^99T07CK
z6t|B9FlZLic32Ajk4qk>?Me4FkPk`pnM2!Ci9OZ|9k!QC$S@3burq7hCn0uw;{v=u
ze13gBz24ilUsiL#w{axCb6X3$>-#OU2)S{!;;{YIeOIE{Ly2bV0v#|U`{E6MzxrUu
zm!eCMZVuZsEF$eS?aNlmz5Z;1S}QsBw&xPm9QrGm4DbzFcIec;L;n~4b&^1`&93Qa
zQ1sDBxS*QG=``K53YpQ%1FMVSr*|m&__<gW$g0t`t!=A+5Lm6~69hyBBm_aOX9_v4
zk8TKdko~Jq6adHQ`o?yMMt#yS_!TgWfS~9Xp2ZorGG->GUmtTDnj1^WG=1vp)HDSb
z6#a5hM;VP58>~!Z_0jN8YZN_~SOB_abQ||*n#ejww}`B0->sxAMT-u7GSQ0n_5x9e
zd;|0l!rG!C9e6ZyhfbaN|M|(|k&W<{G(>;VyOAMEpQYw;`tqrYHe79?p?~kQ$Rk7K
z&AQZFl#Ohpv|If#;SK#<^2ku0qK#0AYm<|qQM7FJG2o<7+NtHJUm-(AAi0iHRTsiz
zq^H~1hrL`n|4^t!@ER2@R|YB^a{CbapnZ=SAZjBEmo1yqQs1g*esvNMQsen7?L}J_
z?!ejW@LHnUpl}^uvWY;Ff^8G1!28qirV1!iMSEEmsP>K_&{yO3bP@$mwPUuYv#7@o
zdyA|qb%yquL}Vq8Aky2me#Ues-A5JQk;Q3bS&)_~#G8yU1@B5YbUSS5(27uV4SXep
zsw6xk?q+{rdxhzF>@8yQ{wXmg3V@{dp@dFRMkbu`1!_KKAvK;)(|)P_9soA}wO?^?
zg4Q5FOY&>>tVycS`{Weu0hzZW;sUo%(SE~m2AYA+;uUR*_FJv-Vww@s-2sgIcN)cL
z;7o7_NS$hx>Jzek%BE@Sw1uPN&37l7=K!3d-Kt%~^z@`Q+ReAga)*5l^<UA#65zDs
zInH@>x}){TKEj6T@U=Itpq-^fBydC$ecV;MT@#{UByeUo*44qK(bh|pQOZaPVOFWN
z=vFF{>Dq1T2Z=6*RbhUCON$Vy=usD5NCTvBfDDvGWVq2`@2IH{1XnL@4y>fPxLv}N
zDXaq)yF>Cf=89}MhOOtA7UnByG4<0>?_ug`%E*e^hQNv%MXOf-P5qMDI_)Rw2|Nd7
z@8Du+i`M0hSg0*>t0?y1jm<0|wV$dK<>8*zbqdhWBq-e;#2J}@{anJbz-l~oTP2{t
z-iBZfhllP{DLkZQF0fM=a4FvJ1$$D_?w12xD46FLGP_6wfw!q^NjhXMw%696vrAdz
zYQK~nz0O{TN&mG<wu_c|gEG>Kcb_ZTLN$ufrE;c38>fGZS1coltY{uxZd|dT<2nAK
zWvZgB3A$)YOL~*GTc$2TxOx)36+oM)3#M`;olQ&?&pMMJE);E&E;hB>9&BAsjB$bf
z>xo1p&EC;ggZvbk&qz8&)GlN<Ps^OhYB`aelJp@_yI4QL8#T+`2tlN1SrR)tX$}=%
zBD1+k^lAm|QvGIT_q?Qh%4X|go)IXX9iWGb7433ap+HHdhc~rFYDzlfDW%<7rCyCp
z(ljcll8E@$Ff~*yv*1%NoLmSsOs<5%J5jWy`rJ!^m+4eSigjPC)`3_mXEL-R+vS)n
zd)ut`))k6YY!e*=fXrwCEV11o_Nsl&0*GI)P5M;=hd{F=26ij9ucDPo@#N-Mp`!i3
zc8Dp!+36?=)Z-9<g0pj_C{DMBILZt6p<dC-B=l^19S0x;be@EsgY5_bg%CdB&X>@0
zF*c|gkXE!Gs>K*kYCP}JeyAnmy-g6j?O3Mkv<=LxioMa-9;o+{FkB)9gvO3nTz+cT
zOR!C_-cp&>g^1+%iFQL=Omf6UtI=-a{X;vSRo{&o8IKfmfscofgjOp7@NVD()HIWM
zqSa{^^7Nz&Ssl<W<7|d9a!%b`1kBKFH63F}m072DlfHn)gyjwCxAXF1fO9aXE92}S
zxMNkE6F`ccFl~u?BU9pBw)Q*Q0=(!|w7Xp{tRi&TgK`mZ^wWq*VHy8FHj03dTBvD+
z&*Y`PJ!E@_yX(ZEf;ev3A-M=U4Nt@?+V3T$G<$1{i1cWGNUS{_|H!`mF|qWd1q$o2
znh(o9Wrzv>lP$z;d4w4KvrUN6iAi*uP<zDoESFBP*GM(8(?+h5mYJoDgv=A>!&0>l
zLr#t7)3mVd698CF_1J`*l4>#{J48yLww<Ns?Ggk{3I1v9oYUdGDTI3o+8weW35vQg
z(2TWMFNf_Ay)$I*gz1198*DFfccDY$5&Iid`mlYf%(}G|njiT@$U|$<WXMCTSgS_<
z1&My4dD;@}NUpSYlT^}9CAoz1HR|=CmO|-?T8jOG^RV(ONr<G{4_-=i&{9QvtzbE)
z{b`2jN#|1Cv+N0zh=MKJaJw*DvE{L(uoq<>Tb@4Nz%tQo7qUFf-cZxQkP#9x8iIhM
z%s9A^pfNab47AZX$tX!GT}awAyO6Y!1xDNd&i(QzBYidPh@ERUs?#u%RFONQ-DE%N
zk;~a`k1uCC_IZb-E8;_1(4LTE;vg+#uegk6!D+8;ZJvjSYDWbeD{ZChpxaKaIXNNd
z<0=UpVTa1AT^?8Bof13}qND?n7)4txA*1a0Zbe5xvi}+hg`G&zQ-1)W>1GKVEnst6
zV2LR>C=hcv#$J=a?6NQ7j>4Km0CZV^tFM)#%d<BQ0@q0(6b-LZx6Bvt(J0I?nJ=-o
zP-ITKP3CbB$zu=8{9JqO@}e5*PmhH7?5pTlLLBBs>^HJhU4WS*J4HZmm(Yb0TG|?f
zuDC-IxK2W=I6kPYw>R>bZs49Z2l&`Q+rY@SOq|lyuy7Gz)4m$WbV8R@K>T~RMBAd;
z@!=JJYb%!R9tp!CT}u_5VC_c|fb%&52s`9n3B)N~94Jlf&9Y=Wnr=(r|Jc5cTgDk)
zptG%+95(GIyhOH49N~3fmKO-?VvC)u3qHc@AZC)_pGq*!={n}(+*yKuCcy`Bq*!qi
zgu~D6w6$%S&jPRj=iQ37RYLl4nul{~DQoYulg74X;zW<3u=kdc0e`>!RtOhcCQkLp
z2E<t#oyY#d9^vleTyG5>K|+lN$-C9IN#Z!(>tIFsE7_q_D)cbEUe+GqP@(o~IoJ>A
zOtG;&2-zpr<N?`{k1>;Rqvm&V4)LOmkrmM9hz)AB>buyUsWLlT%d%fT0dk0i%q3FD
z2vhJ<$@+TI7qrNi$t>a?9XOn7ZN}jgOeqOXO8Pw^<;d(X^7}fxZ4F@RsS@UZhuFc=
zDIT-cE|*2g!rIKW3-=*~<)ETXlQPhmbQj6ME9}C)bPF%>O4-}AqyZ|;lcniN%cv*Q
zWoZVT;NmKQqRp@iBhVvs*-V+8h_i9B0asAeR?C;rDM>#jqE|_xSxJu((W_-PJLwt9
zUc>XNW#-x&Wf&*{%Cpzh)wR=6i<pE0`v)vG^RW_f5nrdaVCqxj`E2b+`VIiF_eosd
zt4mW!m=c?17Du;=_A7mjP!7sS$%pmoV?;~jeA-vq-Qa$qrT(38{)Bb-wLJZVVF5L-
zXy0h9tOp&i$ympJD-mE(NXsCm3B4b;C=lOey`Cn_Yt<%ZmINXxCruV-B<-hZve{@a
zXqg_Ex!iy*?bV6wZnB|amxcx|en`bM%qCVF4pUtnIvSth6iGZAvZkhPKE7Xs2#Zwy
zSO{V|5~XKJ&@@th34e9CgkE7^j(`>$u`UU^l5fJyA&b;4L6GGga+5((O5k+To$|iS
zC<&XvCW4}+*?M`T`7*MvjkZysSIdOJ7e)nd?)X7r2@Itn;IYzLnk}rWv!!)4S4sX2
z@!~S|KCG#m(&|Vlw;I$x0hTIq4(%!1$H>~(DB50|#XV8d>sCWX?z2&-Nms|gSV>2I
zzsQe6*K{TMa$2QE^=s5kq4Y#;X3`%gfq&Rr%1??rB`twf9K^XQNi4r^Z*8t)$kh^p
zh)rM>7E5TLYm$Us!u_OXT0#LWkWe=cQ)+n$3T18hC(BxJ<>=ZF#XO26G+l5}agyL7
zX@`^~kthXIDam2#ev|q*dYnS(EX|$NJ{j{s4($j@1v%N;NC|<}wg93T29Kod5ZpXE
zNpQ2%9;|6!MkdJEB;l#Lg&ayx5}cWi`zi3Ig}rumk}%L9Z{l9Vxk*7`DhYv;kz{g@
zA#h0Z;5vo`Ac{mCVZE_jy$wB2jpwtp7wpv+kW7FIQ?wVQ&4loSF!f)O0IUSYdNd(v
zgY8R$*aR=f<*U7|x`BM|SEK;L*2a3kr@#f2SM8#k!oZS@^&0CRIOl>FU$+ZOAESea
ziJM!;CDdbwvDLP;nSG@bb~#Kj>Ni*s;^<jPzL>bUS*^u*QYhV^y{~_Wj4*-+bZG=9
z(X*M_2fDO>5oV{c{WI=LC9S674`tSw^a!o~M>2~s%oS0gk0m4x=7VrNKGFMmIdJ7o
z(LU8*;Y@~->?3+B)UT*pl%A^{(2Jqe?Ty0!J}4>C)nQ=%Rc7Iou+4Tz<{>`k;%fA@
z_)3JL^+_O!Pzrk<*5d-S5%Y&YfubFeC}4V^Fz9IsO1IzG4r}2Vna!}bkd5%H%z9wC
zA<V8lC-V~#P{9N}FSApa75*l3S@t$uhKlF1?QK&BbGfieaf_&5qUOPcMb}@D*?fD=
zoR+z*MEYg@NuI0%#OCNckw)~2PN!E|W(ki_%<u^bo2}T2f(X4S_6vQO$WbDLQ)Zf0
z8(aHH=QU9Yr%^yb5Qk1-WE`Wx8^pEA4#<K)orh0Q96ALG9jqSX=Qwk4b&s2MYX4N<
z=k=oa;)jU{9VF2L_J2Q;Af0bRDcZ;JK%#QCLrc==O656?9dlrcwYP`b*lifbD)1Zx
zKj8(`VFn!<o#vto6jXKSZw#Y<X$T|uPM-*u%hRSyKyU=#;2Q)FuY&wVl@gSRLn^vq
zCeGR&`VCxz?$8a!-NoGpA~~Fn4^Vd{W6_N|fyL*MB#9Xn2wNF}F4lb?fiB_zVGoK#
z>vR?FzqZ8<%7MHI^mA#z=K(uo6h@$8U=%FjGdK{Wf^*4eBZ<fu)C@&VMKct&9@5O<
zeIVH(FUlP{#mTYm2#h#%avmKziEjr--5fea2U4MOp+4Fahc=soS@F#|M_L0=dcaV$
zYo#4Q$2UJ>;^e=bOL0mHlO(!G>d>Ko2#}KwQR1f=2=q21F#Wo%1<^&J{*K3Eaw05w
zLN=(2u;d#ui``F06#?A16``6pWr0(QiMM3lopg-k%}Ht9qzyJ*Pa!L}_76V%5LlMP
zLSR4yw4%0~FcOM52;uYoVDmWB$0-Y$_yh5#F+vLLI`q$YCTL8!r-f)N2YyL!Erk!c
z0w+d`I7%rRT`a@6(tP}(F8p+zPi)w9SG4P7nAjoA{v|S-Y_Dr=fu6cv=2Ot#J7`r#
z&O~btt(}8r!aD7c<RNZJtOTX>q4o14vNp1)F}Q+nEZ?fr7K&TTf>f6FW1W<jeGSC}
zZ)6YoCvk#;{+2}d*AzB4)<EC=R6-nLeSao{!A_z5e=bACe9Y0>Mkht&=WLZDN=uqR
z%Xgp5B9Ib~`ra>l4y#~3#ON>NEJ9;e(tFzB<8fEX3<i^tSW&cJ>UVPVa3V%aQPOj_
zBD(<tl6;yfC9p$#kwq}Krf4t8reFrNwiUw9fa)JIZ$!YMQ+UatlXK@_v3xG6T8iBy
z_5j7U&L#QrbsVZG$roxE-XgmLrb-H>o!VlK%Ow4g#{ENSP$<G-yG~}+q%f5(k^WGe
zJFk~{2XzE|%Z*W-fx9qF<SCTE`BY$$*W%!rbLeEsI&`u_&#R>%&#cz=GJH*221A7d
z3x6N3o%*)QB3}Inw9coHn);4P*2MYr*=Y4$0jKc2dWsRp(O}fSa~f^X_&xP99*jU4
z?KS>{ilUCf!zhch<5WkbGSv@>>ZnwTi;Z8YsA;JbxEkN6sH0P9I>)!oQq(c2bdoq>
z9Cn+crl*o|h(>Dp){Z>X6wa0E9;T|>6HT~>Q4^VM3gBdip1+I;xQ7ve3FCCEh&pl@
zwL;WzO;@@_>Yr3q{Qy)l(V;)9)FGnrh{`m`WKwtXa3zgL#n_dJ;6<2$vMU0rPR_w~
zH?sZJN6GY`%%W9&l(fPH80Btm{ydyb)iy|1o^C=cXiZqd>T7nUuMU8cSdiB_#(6#+
z$Ee5I$<A!^D(VR~NHb~gt8Xy7WU_n3ubfrXHwCB-XJ{0_RNt~wh?%DPZ7vx{aSQbw
z_Vvd@e5&u-iK{1!$ElZkhQp8JMeo04OL@ZhHH96D`YmTLh3DZYIM^t736h(yRjZSR
z@uLaqRa4`gpOjdXNxUeT#DoeE#d7=MB&d^zk&;o)gJVf%3E7T=^YM30?Lw)#FG2F}
z8nY6!$KN$tUGDQgG}7whm{%<}LdFa8RgG#yVcd%};P*8;RHA7ZV4Ml#=sZsST;nca
zRE;fVHJ#=3kqSj!lp@xGTsyHAi&Ek|wkU=8V;rd@b#V$QaWSJmOksw_m+L8NG>0DL
zV^dK55^UC+8z=M??=oVve+x$A<@j2q%9$PQwXk&+^&4*fd^(_4zZGfb=@_G(e-|cA
zr9dl)@^)1<-p0(cnt(q-I5tja*5F)16^{VW=1bDzn@`wm<KgZnRH5qNI^!uS$!`Rv
z%a7EO5CAD6O|nZ(6_^NMbbuvzd7Tm@?gA?6S)8AON5+)#?Kz5C#(8B*K^(9|0<Mn(
zmNQ_&`1Yxa+9nE>DeI_|qC)_7#}Pp8PKf|?<aWxOXITJ~4<&>yVWTd<eE~4=CpJ}`
zF)h9fpW2w0$Zt|VvytC)J}<=QY)a59owmhi=?gXv#&^ss#s;y8&4Ts&nk|j-Yv#id
zg&D1W!?%@1o>%ePApoA87z4(&@$%_xF)9~!1cK$ER%lG&Myk)NY8$#aiDmNh)XT|e
z?0JGsUPB3p6bN8)uc@xAwO>_#P8dMlA4lEKs25`1;K{ZJNZ^nJSDUYhlm7>k7rWge
z?8)S-Vk)DAGg+vAWZzGeVF3n)lp*^8l}(yMWBMoY$>cV6@fGz$iaTG>=FO>5)Q@SO
zP#W`;NJI9-(^G--iNu)-oJ1Np@wB3TN*EY>J38m2xZg#pd~iXCqZ0D8=<y`=0#*GB
zjgoiA1++OPvHs$lOOu#;IjNi{w(I;h3V18(^}0&KQQt>pNLT`}yu!pUWgAGj7;{bz
zD+ww^ouGn&@W3Sfga0nN5}_0<!333hng_@wbTE%RQK=!6i%A0w?zSVU3Js(@h`)9C
zdkO?DS&4-DG|PztNM@1$tEkT~jein=c7i|9hTE))`YeO#S<*}ADe7~a)9zL-Wn&l2
zL=9_q>z9F}`&q|b1k}rDyS%_<*CMN2ERM5>Ui4A%eCop}x)a(b2%Li$jp*3~*68%E
zj7vTQ0uV{7e?er?NG5CcF{pJJWbH)O?pIKbH2fsi@XegXW}2KzSCO_LOLL%H#s}W&
zMO^0qA<;nja;$nW1BclFgk)mHmc^hI0MWCIih2oK3=bopJq7t3mhbtgB;Vg4Bvu1g
zrIH#Lqk~S9qF&7;<|2px@M)hLJA#6f(6?k&bxa2rkXpPTnN$o3?J3D@9q_7Nm`sx^
z<i<tGEd4KL8iF@IbEumzh?$_i5`T|@SQZic+(E=%1n3f0BL8v_vwT8%CVSdJWZn3i
z$|C6t2a(2_UQTQ97DyJLx9XVW`#~}H-+(O!Zth1&v{2$bB<`fd>qz_p31wO*#(yaq
zxQq^5pi;QSN2mz=OrsuDyXPdU1;8}%_aYE3njw3AE>A%UBI}p%Y-jL*FQh#8`aGVD
zQshOi&*yUVn%Ka@h4m;@E^Z5TG|X=awhG@*Q8%dSCN%am8jAqIJrfjp2bjDAj!+A%
z{O)As_YcamNz}{w(>@GC155Dj26bbc|A`ehF~6q+A%~5FyScC!dEy~H98~XNSOeks
zFth59IDZH7)8?Z``|)=LaUu50RxVQg%#{#)BL7>e`V0o9-pAz!k;l`^wF%XusB3I2
zR8E4{lPIMJZJy4@w6>8#x!Fbz#^rb-UvR@MtW~;@&uU}U(nwFWs$Dj!av#8##=$HV
z)-s$nd>qW0W}O7<Ijn4MWyP}xwXYaL^EQTRcV8C=GR3fjE{sE&V2^|@pluUjg}4BM
zGH)RUdk=b+!?y2T?D%g$!DVd~SO7lcI73-s{oTzKb5ij5_S;y;Z}GPTm9Jpc`Y5Yb
z+uaYZy9^s`H_t;8P?bCy!zyZo)%A~9U3XE*v<T*sR^YNmnxto${4Od{rkw-u0{jW$
z$A%C`&tBu69R?<~^*Xn8oa;GQFVFZFRK{M^9)UUg5CyKQu#>YOrZ8RkSKxPYDqiwh
zfP@!`?Dc3de=c$hk;4<|<eYd=wFiG|0lF5|bN2xFJTkd2An^qf)2>D_Ep`5zfQ)uh
z)r;fC3+)d+MpcK|)J;HYLygOU^OLLNJH)|8Oc*dyI>|hy1C#^vr?C0*4sui3j7;UZ
z0i#T1o#?cYQY6JdaZ`0Tm!_VD`QS*Y>SDk}0OYU(<>vexLJ;a`1OrwQpsgbis%vHD
z8OhKeQ?+Fnj5><VspFJq{VSdV`;zjkgvGIr6Y`L@B<|<H@naHM0Ob@AiL*Ihjr??a
zaOfWV-G&*stO;8(o6CAoretr&KO}1k8TKoJDKp5uqj`G{fBOJ>3N>@x@UTX>FzXpe
zWFw)>Aor~wIAQc`F(7%@0B=5kpCWVBG9)l_SFPn={i?h9*OC8A{El>k&_hUEjl|4H
zk+9vpdtLTkP|ZJp+<Gd19*O&r$Ua8k6Ug-;hySi@Yj3T^18O)OWA`n7%&P{ISej&`
z&r5;&I{qdU#MeEPM0Q*Kh`1zN$;U4d%Cjt9#m6;oAWsvrnsZ+xC)Q*QAG<6^WGILA
z%gvnMhx}!vo^DAZ_4FZSSG2-vY%OVp_+c6sK=NmQjBd;Ad>2EP19}-brknVXXA5Ub
zLf}XNI0nGrNO^>%?X96UJe8zQ6~pYu@K&KkR~lX}P#7QP<vh&gfC+)0%fsA2d1kI@
z-0=sIzqGMKMA_6UxJy{9OA`+8l}UWZ3apOFn9k)E>hNG^@L;Emj?cwRCOHTByaE_B
z`RI!r>uj#L5+yv=IXu>15Ml!mM*~ra+WARjKz@h<Wm-Ard?(F2n<7<7WQydBfhz?r
zQ`Bmvh#Bn$0a5uHuIvX2c#;AE-I$aY@fQFnj5czeQx#<wGFMGN0>jL|48Lzug&E{~
zpB#xgnD4Ivd4uqm0$6~6X8tN9nvj@z8xkbMHsW^!m25@gNlI)-VgQNkZRk+`Bgl<T
zr=DEgjt6Ul-!Tq9Pf_=x8G4axIdHm);%oLf`^g4i!Z`dqg^a`P$dg9?R|@%57Ui%O
zr&Gw#8HIBU7>5+eRli7~2+#sRvdO;WnO0NDJnALbNx*V$BsD!Ol|1|10OG$Hd;*IZ
z{}bYY&j1!J#>gjLju1Nlx!FiukHl58kbuO?t;FwI0@N_TdDRO3bzilbf77mt@NfE6
zck^$?Rrm3)C;vhG{v8$bA3<U=V(j^QknmCB1ti*#nE5Uew!0r+m;VtGk5kdVkvL9?
z;kj^LG9bk7#w2`09701W)|OItUjgho6y`pOMCy4Mtp}x7zk?hxBhnF|<$FQnN|a73
zML#xEU&;Zw5fET41lB`@RSQ@*VSSF-Ak6%BKpqrWZNPexu(|>3BiQtxV?{o|-^&Ef
z1^7JzPb1J&P{_{&$aX%pkx);t3gBCl*96~sq^|BoD`SB&9)G*MadsHRCzM@)UBbFM
zjgKg|Q=VndXujcm7<poku{yCw@;JdB>Fj!4L^;?TBG*Pal2T{uB&B{vS$dO_?8iA=
zg+8HvMMnel=Xb!iySvxrkwrco-6OSs5l2n`0qneffL|*C!$9RLYPn7$AWKBawooFB
zo69-seSrs+g~y!B9$_;9gn2WKo9_o8JKctAOstr(CXA<QtRqVpPy_(}E1<~G=UDeV
zR8Xt++((gbL0RrYNQ9Bd_Ms&IZ^&&yF8?(o9ztT~yGT$Mr+KheKgD1E$ACOdIA0<0
z1|?FaDat35I2Q@~1SGPMI2#H2k58fgiji_G`8;LDsw<TLhqX5WucFA>fcxGGp&>z|
zfPkVT2#N|fK~R?58xl5wuw=m`Ac!p4SVM9X7BRsD1h+9k8Fj>j5gnNk6ctAVR8&-O
zMMuF=9C3-uIF1W$<NCkvsjj*W&ivo=KhJ-koSe5#ojP^u)Y9G6efv7e=!*<cUnm_#
zUgTy7dGNbKcwA(waM#H?{@Po<dmShaWTNyO5-glE+Hr;>)Wy7Nf)!`P?D@qrE6qh#
z*FXgn{|?#?<w7WrgmPCZe@`bz9b1Q7ybO@j{v#;Eem><)$H}?~KlNJ!^}s+L7g5bc
zGPo|_byEoxhVvOwCvc(M9&d6--w=TAATBGxro_?w{!C!7zQ#%#{V7vJbY7>?a-12e
z^SX}yj&-E#E9&l}`Lt6YtTmHI?_^#?r+SUi*IC2Zkh|f)*s3VL_KmyTfy~#E*=@Jf
zjo~QH;vjC{3q@^9xwpU_D;#s>3?LKwm#1JdLTmaM)6grth7PaDf+9D3u&@oU7;Y2p
z@Csa9csYsVcn2m>OV3xs&e)k1cx2EC)X`wDY4X_!`brwfZXdWZ2wCUlc<5-!qDpLl
z)L%gze0PoSjKPjagMPTv#dpExz{yoQ+0Ge@O<b11YOs18inLKjCgZ&TSmuAnYTre*
zV=#>+;q*p(zDL6bp<!c|=i`2R;7%SkJ0gQ=TwUG8^o2-coYJ)guqop-sK+hc^6rTw
zGVio!F$!3*2;-f^dSDw>{ng*GbM%$@Te3Z~5|zIMx*C<7Jk~_^Eiba8W%9m7FA&<X
zbE+3C!1>Byd8(zUY<vw|x)O!UFgXKnN1AjGMAm|<rm_|sl(-#t02=pWAU}aBZbcOX
z?}zZDvjBDj3?+CSporj0fExfJj!dw`NP_UBa5wO0krD0<@F74tzTxHs^1>0YQ_n`m
zSb&KH7X!>Em<dn^;7l+x2yZ>mPYyg0FPFu8;MOmoze4K>Tsyx8+JPtJlnXP6%kh)(
zT#osW2Y0O&RNy^z<IC~g$UJ<j7*DTMqO0GH4>%a#dF<UjII4~_3;(-f=sL)FY4Wa|
zxjlqbzXw^(yK?ID52RVods5F&Na+jd_a%4CIb2uGy_ye1wvsaMa=cX}H$f6>q+VCN
zM=hPeV!e&O2j20Qt@lB9QnqPorJSjtsUbL6C7b%_=upKZzK)Mq=F#@@*mjevPm^n8
ze?ReDdgTO`$hk{jr1bUW()QdJR!zI>`pbH<OthCGf5=>Pej{iws!pvaasr#=uEEX7
z!>Ja=kKUPjqdj+~?xQr;AicGoUmTrOV%E&6IQhy`61t@o4f+@bHjOups?tvc;VSRP
z0OIW3DQ=3>C(u=LqqZ*=C4EGT$`Or=6q{5nN3RE&!bH`nx2Y?OX^kAIJ7Gmlm1iIW
zOXBzp<OLM)!6<}81ea34wQZ>!p>ISoZ3i031MYQlz<o%H<e4OIcI&g>>*c`s4byEA
zguw44?IJ3va-!h`ZV(qAfJC2CH_ErE-l4{9Jl_*&lKiib*1fVW&h!fIGU=^iyn=`q
zT=L9OV2F1Uv}A(0FEGU3o*5#?nG}8K7#iTQgLjY8WmQf=gf!~G?{Njf0h;K6b0r)E
z1oup-;ImC~#2+C&mZBe;)#m^r=`)6fq^)`KT|RU3vpT?A^gVUf5}gIpcw7Zd!!=_u
zzW>I%O!?6TX!S>N;**2!NWhW*JQTe)$4tbJWJIiij1%!A83Fr{Vvm0;;rf^<v`441
zFy&LRBcN0BnBuWhCtpHRZ^C>cCvrX0ke1=`PZ=KhNaI|dU(5=88pn{-P{QHxFBuNI
zkQ{sj!(sG9l$1TAUt|y-Muszh19=qs--$yU2etVGN&{bpj92Ufp8_}^AgwEM!+%Gr
z9I5b!0KX^r0^ntW9{`eY^%9PU0|fwSnJm!}sXtQO3*dc#AxHY+rbIu-c>(o=(;+<z
zr|M4HQfOz4MKWz0%M}3SFoU1LA43$J#Af1(cck2kT`8rUHW1=AMot^f;};?Gc3X4h
zR_jj?^zQ%*fjqeldj)zbb^fA-rQSJezDRF^G%cByXueR)zeHIkWl=uCm|u*i5(A~8
z?&6q%vr3w90%dZCHUpvyxVOXWHyz<c@|^oTWb~I+p+Xd|MmntsX8X%7^m3_dJC$S<
z>+~l~%K*Jx3U$J9WpE=31#>WRW$3SI!+v%K@ZQ>I=*1n#4g4ODv7yUKAX|na1E&K#
z3*e+3V2x7n7OC+kNTuu=bln#$ds~~CrtGPMaA0FuCzA)<FQMYbLuEsofjr_4MfN}*
zawh<o&m?oi(^EtqpbgAS2qYnlkAte9>*ksTbEe$P@QwmA6Sx-gC?L<zpp-m}+vHw=
zS4m1?J=kZ<orZ^Dh_h&p+(bAeF8FVbqo>=-#0<QZZ<d#Qdslq2epKNKxE;8-Ej#Q?
zxlLQpmd_5QaLyHZ_saFd_<<=>g1088w&j62MV?I$Tq0UMN@-}CJoAt;69<eOoI_1-
z%bHX8#TX_p)%NhR1S}de+VT;O9J!f4qe@nj8N~~6!uOWj=N*JcKR3}NMVvkjd9YKx
z5byqw<!hU^v<NH8{Tf#A3j>poen8Sa<mC9lwmcv1A*aS3md(WNx{TP<-aI7U^i08Z
z6xZ=zwUGzeCXG|d@qLg=n}yYNw7eK05OmpR`1I+?wqlClWU{l|LSX{U_7a}yQzWa0
znAX^u_OitFE^>=RyY69ey{op2x9{Nm2P?34znjZo%1!7~MIq+jB+oyz4JXgKa@oRI
z<#G!HM+rVJ8dxoADSY{Y989m$^~{tv{W*a(?x$=Wj=U8(3tcOzK374cyQxLA@eD`B
zBz>26t1C}CnAiX4)82b^?b43>wEYV1GJ9KR+g$FG_0&%`JT2{KT;&NQ)-EU30UU(5
zjdgknp7O$bAM>kcE!NLWtZJtRd+=iKrrBzH)9fm_X?CW5I5@CI-!|I{+kv%$&%`|_
zu`*UavU0UZap<kaf#X^!>>Y=%YbVEH=Ex=8^^(?44E;{-IHi>1TXn@8L^o(F2z#TT
z9&*{&)Q)3PY|DdufpzV;e)Tyz8B#V!?7pu{$Ys+9f_tXmTSt{x-#?e64b(|;GUq#G
zGv{d!CP+NCVR?EBw!g*tu;@~=>}>ZhI}e#<M{mvlH9>F9yP*oxl!rZy#1OuchsMby
z+#%~uuqnyt$z9P$66E`?O`Srroa{`HM-iL4a;4fWC58^hx`pGtPCds|MWH+v9C$Q=
zE<Qg5A}lkH$*tT`L$P2>XFV>(A7omN`Fms;JS`n*+1z;|ft_<L(-P_@W#{hHFw(L*
zJtg|<nU-_py^?;2X}RitTJ%qkApIQ&$1_sjCZ=y-`dLZ0&wzJa9`{KypGjU4a3p)r
zWbKz6-Y2<`14_5;xdcAOshW<|rk0Q5LifCAz02}EL3ts87vpCQ!;YqZIqY!4M?6CD
zh%px+nTMZm6S_{tk!K`iS3-Z_V1QQ$LI8s@0eS+g0Z1!?emDoILr8@$0r({gU@pLn
z;W*8R0)(%`zo(E&zaAjiG$y<Oe8>n0?g8LMMcxj8J*a>1W*GcWAqt&|DH$9I&<|iO
z!4QC#2rdG6m!J?JeiT3nz*zu;_n>$yi?4x%8)4z!1FRvq2jF3XhXI}gNPC0MKabQq
zNa3`iZXEW6K;dPOoiduTA(xNAe!^Isa1}xRD!d#-`QYzS^h1i);>b||QFuMT8iG3j
zwi9dvc#U8;z*hv%1Dt#jz#)KP1n&dn0i=Hp!0oQ|HmDmf(U&I-5z1Up;4JqJ)HU#W
zoPJyZ<qOXCGQxj=qy-Z6AUC(7kn?_UAkBT11-O^>0I~;ibL%w%?sk360vE7RC7|$0
zs4$FH;?@M8DXGWoSOW?~+r~{niPs>T%52GH`3<1J!nQq4E<>bq<1y9~K!JH~rpevF
z+_b^)D*OS$_b8I#Zvfh|ZU?PCiy#SL2tjv%@dSMUmI0&>1Yl&Og`Lpt6|faJ*mgT>
zpg%W5OPcx`0h{_QfFmJ%5u?mOnZV0!TdB_wc10IoaL~(;5cY!vPOhbs7ooaL4uXpT
zE+d!;z$^c>ZOmVcRI})#$bc^qyq8epKKe8x@gV0-2A0F!&=`0=z{do=0J>xYoC+|A
z;6#Ag0BIl7=47PqM=CrM;8TKy0NFUt57z>$Cb$NG*AL-8P>0}7fJIo_GqwQ?c3sDL
z8r6rNLF#&n4+5l(fjHxRAmB3K@YlevAse3|$yl_DK&M=SMZ!B$|5MiDkD;MYlyy3O
zA~fV0^ix?@Qjyjh{aaCfB@72nOdJn0ve7>Qxw6qe8z5~XtK~-j<1B<Ziu4iIxIBL*
zzA@_m)@$HQc~9EgP)y}J_pm>}7f$o6iC>Bh^h)GrTbD_2?$rS5?48JiTVJFv)MqMZ
zCGt##OG+ju#Hzulip~v9lo4_%G-ZU;5^(UW13)Bx9fApomH!v`rEkG3N#yy<W@Zm|
z+u^RwrRJ*puZjAq`?|W+@+^6M;=|(BJJ3xnA1;y|B1y!Ferh=$?B<KOoxmd^93sN3
zSy<1tc(;g4C@$4E4!PDlfk#FDXUcg1z{U->sN^2<lalkf$-()rm~#S8Nk(@}FDb%@
z#meQC7Wyn~uVjxk+4vUKq!OL;wB*#79Pb7uwnX_F?Z7jVyUFBwdko^rvyyedWXX|d
zpU8eTGPcHh*;8P@WDUX`5(m-0d{Fi|k<Nj1a36&F)#=Etm>^HAI)OiT;Qn+Ii&XGU
zM}fbH;B^XcmWH_A(}BCRJWgajaXxPTpdWHzCh$y$H12PPzl3lKSGk`78UXM~YebIj
z>5rtRcSD}G4Z_&NGs8M?w0(jM{qRhtq))*FO4ZjUSt1xH0(;MQxCl9cFX*3%H5ugX
zAmw-9^I#7kho1|W^AJdT(I{R#Et&Y9%h}Labs`Rd&Mcrn;Kvg>;J-YM$AK^JoyWzV
zT-bzgwg9|%KF;{?ouyD2lh6>s03`9jGq7bkV-~-MrC|+TOs)|&w1ZSre+&jv`jw<k
znG$IkoTL5}h&E0fyuK<jr8xDd8#&rkrJg%^XX6EGc{n|i71?&~(nxD+k4Qs$#GS6H
z!zv+~y?bTGhwI&4V^jJ?3jcVYyU|^B)a|IIH@g$3{Ig1(y3-xj+9RbZQgvUcs;F1n
zFF)A0wLzWQ=tkUBbxK&x4degTqx_%}H81)`rJ7yT^g!9rspH-8ZqK0^pA3qW;^U^e
zrEW@k<Qg@*UY*(8xGH<=4Jq&cQT?-GUt?Oo^!{#YI=qfFxYaP7?WXQ>J3e1MasQ#M
zV^bSiTbrI!uPJxm@740qs_N<*)#{8>x79V*sKbt%T+`67TK%c6IlX$$>W0!_?=EUt
zkve6ZsxDGV_4lhuVbwq6E^jJMji{-OX|3u>XG>{n`jki{wK&q6o~mXPsS#ln39X*r
zGIdHzi;B7>W#g;V%O^B8o_}s;0~~Y5^c<5>uuQFA;FfG!sFp@++>UO?^wfKwQ!fYI
zP-AszdgM~HKQrS3wIrNTJzOo{2MTAYB_*nTbiMk%^H*vuV)cFJWOemibVfD$U`mgO
z8wvLBeALa}s?M(8_1ONc?(|(p_cytn)%g1T>8Wmuo7!~M*M|=wASv&s+;CsH%6E%e
z4ykk8sQP@l+uWGee^41RmwXvf8`?KFs-zNCF-|3gR7J8%3hz?kEh@KOo$MwbDxKCn
z^Yme7jCW6cd4yUP%69j=Em?zltI9@ISg!_!)Yz~Zl&o@#cDt#O^wmdqxkDdRJ>7AL
z&)lNS!40iyVYEqo=L8?Y19BrGYH4U;!<&(QQ<~CK3jh9=y7t6+^-V<>Jmm3%;6-l#
z{i(asBR74hQi{|i_3o<uf1k4Y&W2&*2S=)gRjXM=>P&Z>x+JW6BfCU}n&Dc5TRcNW
zqpHI}H9M?MFH$8%?l9FQtjfcxOOd*$=%^YTR%60ya1lB>^=oxyU9dLLn9(<5=m59$
zt%lXX-rZiFFf=kYlHKICMhYWt##lA4#9fCmxK*7}q^39SI;v8_YDSn|O-IzCyWAz}
zgl4sHi#izis&QTRV@vDY)#|TH+@f31+o?0u()y8VY4U|r(o@H$XGex+>~hb_R?8aK
z9jd-deS2bXT%d8vFt>ASamv`pJ>R&~zgEkdcOBZOZjL{w{=F=$mei|u$x~E~8&>VZ
zswS*XY*hbR5X`|dX&r+70;(#kIyCbC$>DUhh;!;347<$vZgzV0{I@bHRrwZmMp(@X
zt22t!tPrr9Ap<*Hm~w+Usb0O)Ws7>LwCKty>WH&bT^(rtwzWz<S=+1{y1I?(m(sAR
z?;0jwHfYj)>aPJf@^Njwo2}mJa!~!LEUex{fXNr^yhDw3ixA=~Qwk$hstfw3S8#9u
zy}197yFztvOIpUJx>M34_q!u7vQFNrPIMc$?z$&+ikjt?sL^f_vD<OKn(vO=m7co4
z#qFd%aQ3NgI~CmM7Iv$*s=w8`&1yujcR+m>*r#r+jj98IqC3=FR8}ITuneTCnQqCh
z9#{z?Th%j;8~#$g9mJR~ADW(;G2r)Vpc_&X>a#P>NIRpcB^`ZIs=72@%@}prIbxcs
z*{8}}hN-k(om$c_HG7$xnO+(k+G&4!WR08QZrnCx>DZQ1H~Y2Ue~%UKVuY!8SX~lQ
z=M|}o!)n4#wW(8By*Dp>&M>TA*;jpDU0r=CrhST=qAJ~F^|pgaIQIjU=zgH)eO1=5
zNqxA)jfNvr$7WOxQ$xl@BiYp%L#L{H>%NMnHnix^e${>FqeF(J-aB;F(ur6h#>v{K
zmY1k@p^VB%8S1E>u1faZ5SgGl2Kxq5`>B-R%0NJMZd{x(G*YS-l&DV8b$!=u-5>1J
z@hY{XNVRv1CKXSax8sr>m$(m&xLhs&p!Dm?EOqWzsytbB2^Fcba73L7UrWO3RQw;O
zP7UjhP^BSsM@w#_Iw7hm>(vQi^lE8w>U~Y=sjJa*ScuWs>M3PzwOU-iR6Ud6))z%0
zs@*uXwDI1dQ?p_A<VKYkQqeH}H$>7~P_m)*LpN<}q;OYinNDGe-P+RP*0dI<PI+Dx
z)vI-FgUbV|U87nO8ZmcbKlQQGtXk@JKKNl_q(@}``zyw$XPz6$%yu{S!}@q2(vYh<
z)MGa6F4+41woPuNa9gC`o(WA~Mjla#MZ?Z(P?Ow!TelWscGdq;b!|l4dIxF>R;l$>
z?w0j~=1p}|TKcI2IAA<j*X#~MyC&ce(=RnL^-y|54Qy89OE8p9#wz&S(2P~+&Xe7o
z^$qEz``sHBW=+8&KA<{+BR~`W?QgACqcFzL!IZ6b*9}cmbM{@OCSx4-535PZs(-Rt
z>PFqP3GU_TEu{^r$G&P+ScI{Q*F^>z2b_~NtP1N3>bkdf%Yf6e*1BoxbhrM)p;K39
z4DH!BBh9@~<wW0jVCnrI4$a6_i6tuG0~jn(&4H-;vBoXAQKe(npgY51vWQBLs?m*+
zjPoMt!`^Cfrw7mO7)dWZ6zq4R>aY_7Be}tCLL1vh@v^XPnDK9yVBBu%R;1o3+2Z0T
z*?6{E=6)pyxQ^<vwqL1hmwuq0XdCPmc+%~shPWpm-TF&Yqy@7h;e&oy2UUmY;$cIE
z4RNPW`Q~Ukj@5IUR8`d7KSg!gQWMPVSUPrmzex2|cgiEn)CpTuWmpDQvN|DzC7|)7
zM)k$Ql0vn3oSSy%yc&0)d#Q_{s+~3UZm0CI84Y+RzPr;s1Ys)Hy;SuOGD@?DW^7f@
zw+r?Os6W-XMUkqAdaIrLmAb1Ys@`l@RMwOeNuPirFi!Q4s!1h}sJ_ju>b{zKWV&1O
z(7y0icba;ru5sAn2CTo0YW7adyQun)Q{?vAua@rI_54v4ZA4exy5s}(&$j5D&4|Jq
zh(@B;Y)<^3F`^Q;K<m-{srw64`=wUl7@eYCae~c3OwFBYUXkh)E=*O=#eJY2xx5*R
z*LbunJ(7C)cz4OXL0N~?_cdEoVpv5>IKZ|Bdvz*M{|?rxKg2hxpD!;`pT#w+zvAb_
zT3ggBmv8x|Au@E*t_BS0_VtmWk&Gdc(xGL;`t>V~q-Qj&RgH06>%-~+tmrS5hWcfz
z`#SBMvaB_|^er``M5XLh-I`Ttv+5R7i<-+el&TIT?l(i;*rooB3BL}7KEslDW7l!&
z^U`G11pWnhW7lYldzD)@w5;W^bSwi?$};*!np8n}kDHB`#x<)0H6OSg#qobK{_PR*
z6I>kDaBvH&O=_HaXGOTFwX_g9je8EIm)?W}X0uA%=VrPs>8We~p*{_U)%q(+zz>3l
z-DT?0;LcLj&i&xV!#IY76hf3xuc{BKgpm5AvN@xm6oX)9y*jH|wQFWPOV#0kTNFIA
zqx*G%de@axtOwNcqWP<5r<JB>)D5foOIeT7DTj8sothfnPkChZraKQ+l}_nV>UP_&
zHU*2++gF6EuS7iHcU5>nX=G?w>7kV3(#Y5Dc=!?Bbx-M3S@g>AKho;<R6hkUV^-CM
z-6d|;uHw>ax0{@uwxnZrcihr{$GSPYQnRO&p3VlhxLa}Z*>TsD-DkM#)UMhsSP#`z
z2+R*F!dO7@3Ql!(4GtFT@Wr8vt5IulM16jRn|!02@{wu`HsTO~P`-h)GtBUx7e&?8
zN#oS_i*VwIv%2pWB}cN=RY_5tfvo*{#Gs*(nyRu$O?v6Gk(S8N)TV}}(xH*aHJh;H
zPAM#{Zf$b2Z@^LOsCq0Rcy>TN84a&$bt5fD)j=M4r!=en``}(f;R{E<D^+`IqvFKl
zI30Pl!VMRfs(Viit5+(b8QE&fiLCRmyJ^IrtwXA7BGpYB-5U?>YHGS^aHOfa`Wm<Y
zdQ)ku`dwo1+<^M3O4p{|sKRmQ+fEoNyO-~~C~HvGhVg$X+wZ0>P|Heg#`TF??smk#
z{VK^ls8ZYyCJo9Mno&Mz-qxn3^@DjVbknA6O;25Ub0l5uR$=w@ieS$`X?m0TYaLp#
z0Dbdf8#j4>BywAZ+FaAviWX-K>EE}ydT!~^>Qc_O4x#LiT&(#xLH~P$+Kk1w38$Rl
zY@8dpC0qNYr0)v$Jw-heIH=m~JJi3Rc-7FdHEv`bu2vcfBYlU}sdn{|92cj%?zjjB
zbQBmTO_&ZRMxQHI9ZQPUqLO}1>ZFovw*jr$np*Z44vx?atH<iXGCM-*AP#VqQMW6u
zX<9eBH{7A#YJ)SZ{VNchhgGwBenrVIhuoBYTZ2QAuvVRjW-V@3N#puW8ULQjYF1C+
zWvPL6ZsD8mu3fk!xYzAey0rYf>NlUu_zM<<{q8pyyW!wjr|yp|SLJSzyC0E>9#Wex
z$6$M`&Mn$M7UBEB`5@zNceq-gcu+OMvoG+|(R-I-qG1J^6IJJg_6K|7isq{QFEqW8
zUftxDsSDhlDm(nmZnfBLZgH<|QfrpgPr-rkP^+6-s9NL46_g!KpW>z*QireD*Qy@9
z+)ZZ2H*NM|JRlmS7=ydqRccl<X0Y4ju5#aVTW+j&|Nfl&F(SGwgriS=Lw~h<MOf`s
z_29|iCEz9CI7L2q6sNOWRurk%k-7)DudBvivD)LhGQ(Z&rtWtq?Q*xP8|&Pik=xZr
z&Xz;L4FOzrC*i`Fzk&(8!cB~eTZ_x<Uc6fNKK;P6PH<NTM|NnFb(I>?5I6IwtY@;G
zhN^r?j%sP3Wkzp!hc=@d+FTX4MokSR6@`-Lgp%@D;#nz^8A=@0kyqo`ypqp0{6CC3
zrH)wHU}h*OcwZ=a5!l`BW973FppQLI`S5|zdwyGX9?IO}E0Y<*7d<K<Z1xFh2pbmi
z;Ufmvm^|JG*vXI8jQoLG-QjnhhW@tRLR2w5l$;Otr&zhHjsff%%jXDoT=+QoacwO>
z#;sZ}g#bUDl@R<alw|$fgZ)%&JRM&?8cNQI)rWlJXEJsN=lJx8H^g0~CW(FaUseKK
zUBZ&A3wp9Y1I}-(96@Z4^K%RuRugi-W`~l4S)rthL&@2Y{lV{l$6#hcnGQl8w8p`G
z+t>Uy2e!YCx4RG{#Ajk;!dTrJ@oF0M`QbM_9{g?WazaU$_{t*KnF+y-o`eQQCFlk}
zD~&`z8+@4<1h|zTAAVaS^|x&fZVn~Q_g9b*{OA}1mmQOuc1$YMv(2wa-2GeMgV!T?
z>wU(DCzSchk4h*BCEM7o#4cbS>>bx9lS4^4J_}h1(|xhyyyWKy%5DTduIw~aFWs-F
zCSnI2Q-)s=`2M$LR-jBn$eA2UE{YAgwa}AKXKeLjj2~A|@DK*VY@e5ykmC}9lYNq`
z1a#!3AxEbD{7~|2RI@jfoEJ)37D~=VA`=yY-R3JJ(;6DV(R#RnVKnA=uJD=mLOiT=
zoG(>A16c`NDNsyh2SQ0x;pCD~QZ87br^N9y2IH=~XOquY<ImchDytxFKzsR_$n53I
zAK9StVTxL#5{7HQe17=wbUC>354xk^%`_@MmDMq5*9_==<kK6g*Vc*9t@F2~V_-zW
zG>KI{ZW3U(nE&v}OvY`d|1$Q9VPI7#xxi;*R01Mh;2S?EDjz;=i@O%uR~!eRwm6hL
zT3T<`aXv2luF;9D<Ln<sb~GaEt4ijnjT@h5&G40#bxIFw){&Kf(q>JQM^=B^9uAlf
zLdlb`Hu<Ybh^?InJfB%J@%D~UGkw}45=ui!=9s`|G++O%evMB*D*;R4e2EbLorl|l
z*kM1;{;_NOSa|uZXF(6H;Qb+IVJNvg<nZW$8L%jnJeBh+NnISoeBk;PO6E*04kcfX
z#njAC2IM|p%)Iva7t-MgFcT~fCHFzR_~G*m=k<vB=#8a0$FylYdJ7{_RRlxHW#B^s
zAqO@vUh?42SmaI!rLiHGha4O~)Jw=Og%qI=-WzgoxUUGMq2d`KhZA=svKE7{lSZN~
zmmx7W<Wz!TU`z*_5K5i`HYtQ3wM_~R$I&d5R2fQRqCVts+FuVN>xGNTNXb+mz(XEj
zW`&X~IDeg)aHoGfyu^_Q$%0VQMEaIgB@U~3flxA|d^d^>4<%Jg3hT=($bJ`cF6N<1
zJ`7jTiN=v*IU{z-IW~e$wM)+PBI<zIPY0lYlS9^9U_RNo8sfkGXvI7-3>%awFj?&0
z{vetrAE2>Iey8ASm;BFK9!KusrGWCGjZ6?+A^W4id@`-s1f)OI<h|m6lSg)kz+-$F
zE23O7udq2_I{A<lf`U#}BDt4u4%p6Rkd=Vo2H7Tog=C(ljomiL?gz2a<PU1>l3$5A
z$e5GY3y#K-^W6rNLq$Hc@dOC9ku3}m=98@xSU^^bLXevBfKnF!So{+ZB0;9DH;n<5
z&$IYXIos;XHz!Qab2dM%C4fr0NkzFAffay)PFhPjcvQp;mV92se{HognWYjz%Be|e
zA<!mlXH0-do;`C4$Y>3!Wn#7t3Evp{7G{421)U|rPesdvPSZ4US|uI;PVb0KIEckB
z{QC!Jn3PLvAs-DwXvz52iGY(!HW7qUIpp-2n4H$xW?wBizFKljEu3KqAXp~z94+!W
zTI4fP<TGJM;k&RkT}%|7gj(6YHcpKbe`XRPO9y0>N|l9BtN_tBa=sh`b@S`YTQppQ
z0@sO+D%j{{9Ayo)qESf30?JtuZ6UZ#%Z+pYXLb23biEX^!;e=oO(4zy@*6dF$!93a
zt6lOrf}?Td7hwKSPJW@_XdF3TTH&7=w7mm_hLY**SWh#1k7VbOdD%9;%zjj|bIC46
z#b_bfY=OCS<#G+lZV*^#9Kk>_F>FO~?SE_mqU^UO{Utt;x^19*M(kL<3RSKJ1)U1v
zd|QTZYV+zYOJWj@BOjr$OMZ>uYL}d^&G4`2EH?v$xRL4XSlpOhDA{>rYXn+9V})~l
zg>6(XhBoCKh|9nmq_kZac!Aj@*%%JsH)`yX@5hmd-Am3FZ_s6O53ex6qm9iVxKEZ1
z6<<)8d%NW3k=-k~cClgZcFDE9w-HI&L68&4na$OZe4muI-cwa)*9fO)ZJnl~_;$ba
zY%%Wbg3{w4xJRbFk41MsWCwIMnU`(X+pA!5jntY$##ep#8pn64P{SwUrT4oaMvMG?
zja~B2@swA)<fjOZ#*r6#a&kTk$g<>o5r}_+(RL!_XbOw<(2y)uU_J}+*+2M0c0S4j
z@&y+(b)1*lQXUy|mD9Aj&IB!1Q?4)n&fny7SkV>MPfUI>2nPu=`U7XlCZP&ykkcWE
z$rgKJ@+!fLUGf?bjF9ow9e`wfc8o^I>2tiJ*kQJ>Yf;fnAnK4egHTZm*d`76HW7>w
z(J+mrdvif7MZOM%QjFjh5jRaE|GO3&3(z<bhE5h^l}Y4$n~2x0r5e&{9eR5xI=(jk
zzB6LKv5r7n$TK}Aa^q$h>Zg0CfsCri-%v;8Eha(03ORdB!LOiAuW`y@M72n=eVABr
zrkyahr7qUGJcfytP{)+J0qL7S@WF_Zk?eh}=v*YzL}V-6gX9w+4sG(MG<M08aBjt6
zPR>`UP{&wj{u`p3))GWsJCN@T#AN%Lb_Ci#gW5PeuqF`(PzcEiB#m9}Sfzki7dd`T
zm)Ir0P;j+NK1j>s$QwL4Ip5jh_mlQQAOwbNpul{Vx>7@b#T4Usl?gUcLz7#K<RTH}
zkkt!}t(HhOfmkv5jT*b;ne8dBcFFk)6zY(Bcquuz#r*3Dx8Lpp!D+I4+7T8|vlRqL
z)=mmFjqeS9F~}GFSou7b*XCnOYb-mL*%7gsZyfQhMq7}(4Fo^PJUe!TJq+1SolWLt
zk2Eps47a<8>p5if6GM4>9i64FB#iRMFz`JHr>riyXUwkmtV`#owUE;qPBt^i&l8;1
zLLLU;w0N%o&q$`J<Vh3^i${gAsM({|Gsyir$Tx@HL$Xywd1Ri~c(Z`_ITyx4x`||-
zQ$?nQaL^v`2O$4Ktx85!1Yoy68oRCCd~`{HbW08yUz_7QtNa_1906Pxe*x!6@MY7>
z#UPF}@+ys8^4)@~UGhCz9!LIyCntZ=lbc4;ULy!IgG^_~8fLO(ZAboXqFV4M*fSa$
zLkEz21w_Zl|E94^-WIDOrvSMtI2uRpVceO(JP>)cOTJBTG>-g9PfpG^DA7JSUwA~D
z<l_WK<H-4*ApdluU+;m?@np=FHP`t44TRbcTteA8nx_2+Slf!ttybuMCbsg(;-G>F
z#nPKK+yeHvhV*eXDuaS?%QyL6M(#VHI4=J<B<K&{3H31uzLJHdc;P}Ydg2=eiAZ)8
zk)5yH;qDJ&e8>lA?2;$R)0kN6!TEY6>X85F$;p56<m5fDVl#&1$%3PC<ik8Ud8Q{P
zpW(?(JLpRm2<;%#*|E!QX6H(F9@!cYFD=Qh7I7}wMh(gSBEB`{kUs&!U?ubH=J>0f
zr%RD}+2c)iDP#*k9LxOi@OltDTo1Ox6F&+5ycYAf_O?r1Ib_d+Sdjd6E#^-TAJ&jT
z7%o9bv!_MFV28~MI+fkYSr0}4Svx6Jz%KZYhK%~@Fo1QQfes7Ir`Zu&Y8o*PiW@)}
z!#VNq0(=e%I*X<MPJ}M8`LM;T56WZWO~nZHWY)}jh*^mjD!U-Fho~QP`nQmq_>eO`
zC^zy3*kELcX^VEKZz`uA8>*akzqYW#b4`NaLJ)#)l;4DMs~D~jt|L^)Vr(sjKHK_(
zh78sjsLeMa{)MuigJ6=3#o<?xDNjrTUYqT@&09CGh~HSW!2hPPOa9AAv{CJnJGjNd
zNke{~;A)pV&6ATa@#LmSwEYhdTq4uiv6YqCM<qLt%*)R4mp%bCW2lq;C@}w5u+vZv
zq<z5#X-LNMzV+oaD272CvX6nk074<Mmjvb%qd=(?${{Nkm}{#404}jSMov*Yf#;u{
zOdTQf6mmr2I|vZw$;KICV~vV)K?uc1U{nR9<}mGnUva+V7F-L)H*`VqHLwps@wgz3
zU*hy6);0=ggDt_lVGHP`?^J07lG!54A<F@w7lmJ}aU3~c#SghlK2>9^zWQ@1>Z0pG
zyeX8NE**3HNJIhMCARN)Gw(`mCyu;9W0!oJ;A)rrel3q9f5nrNzv{`2548735JEw=
zRbW0#y`-U0yaP#!q4+Eq?EsqGBS^jr;y@;UUt^cNt|R5uF8NBq(KvDs+ieHh_!<PW
zWW%6>QAbuIrDEgzJ7l*LS(R{YDK;kfyWFROV2LbCU>+GQ!6+FE`K~esBB>P%Cjl0M
zuuqrR5(S{TBusNtA)qp+fYHX-FuJ~BLai|%xI#wdcGzS*zgLyh^US1TBrA0;8O!^E
zx(CT8KnyDRQyRPE4|mc*CEp=9c8SGuuYq8SOlQZU$LvFrok#Yizyh)^FocDVtgpZV
zvMnIYIJ;@~3N&e#SES^hgHVd>)Z<j&gN%k5r}oHWKEi)GSV&aUS|)-Qh`8X7V64m+
zK5EhjOp#=AmVyBm$_FW@DyhX3lZ5FZDh?3k9I{~`T=qH(!LReMQN14NjUZp-9o&u%
zfEamlrLjvs`V`8mUGf~k(KzzEJvsSiPfot8o7N}aBRCpI&ezt_j&Xx^o(O^)WI8)G
zrkQ=3Wap7F8*4@E%%Az6fzVSfdA7LFG@e|$)8vvL@#N&^b<z6d_2OF7c=Ee7cF8?I
z?BYDis|P(!(|-a1(%LT?l6i)w8Dr2e&1|*h^Z)4;;^;UHF0d3j*Jv(-=G7n`_*vC;
zAgY@D-N+jW8HNklILU5`V<TBF#J>l-RbUR;BU);L?;B>9!qm+m#GcFx?nZlAMWG4k
zO|X9}2+<!I&&rOE5dBKl3Y+T)SQ6Ts>x^rXxC7pJfgVrJ*ZN5YfwmcIE8iRF*&G?q
zI4uO>>`!<Vuz0f<;6;;2?uw%*NODF2Tw)Td0oIuWUjq0ili;iWzB36r^*D&tFlGlq
zV(cA&Pfdc}{!zO=(q3%PT`yjfeS>SVZ$M2p-MAbMUjahw$=C+2Hs(!-{*|Wy^-KXl
zm5f#U#>;Cc`MNel#`YuEybIB%*aqcXZHBD7z&ztmIm#`NvN>c7mapt~BzNdsG6u|-
z`!kXbA_E7>_!dQ9E*~s;0wn7>_){9Y<i858cFCR7v<~@>(}}BH@;!pFdVuq#i~iMv
zwqFOKX0q=E=8;ho-L}OJW~#ob^U1vYTaL;9Sn_kpei2wmXL_JwOl7i1K(M;Gj({e7
zQ~XVoV9gjfi9Qcvo6TvkRV0nXJq+-A5aL93y}*KxyW{>Q2vRaug8Kj)>f+A~*!lk~
zR6hlAO(6eKist-8CPnSp$>Eqo65O_0lPnc<?1l2Vo)o9F%=E%@oefV5gnL0a{0YyN
zx^kPr_Gn0NUjo6xTQ)kmW_)#mQg=}-AY(ZM@+Ju+)g|#cz)>+#K;}7dlXW5urLNFM
z$m&5DRl*xIjw4^Cu}i*I<HVc6St*u3I?5^mU38)D#scFg<4X^5)z`=8X`|oM#yWcX
zEr?p=d|@c;k$GM>TCX`6^x$rq#{Q>*e||4SZFCcZm|kwskc<wan{JBjXZ!#O{YSWB
zL)RyajrU)n`B!NA)_cBbm7|zLXCwGSl5LMXeUQu*kzEzcnD@KulNFhu`DAv5%Y!Mt
ztCg#Q_u=zkDbjlER)e3Zu}dBij4#iC^PQYrE=)N-Czj>O$VX`Gl3yaY+9khC%j3vr
zdvbEVq0?`V&yp?nWaL#EyX0>Ou6D`!vQCyG_wZ8V6K$*np?PG71lm|0LGoP?OOwB^
zu}i+92j$f+`4xhrapWsCUO~>+efk$V+UqQ`ra1B{5KiM+>|sw#zFWjOWP1hLo{U4X
zt<ELW<@3pwi8P;#=FlFpMi2(sPqhSlM4nHk&E`A}sC|qbt-pqkzkpE8i6@|=7=AQ&
zw}vKonaSu-5W_=0LSvUaJ4H90JV!9jG{Kj9a`MYPx#N8@QEonnBYPkC`+}Rsd;~s7
zbeqPIX9@1#LSEv@$rpHXa&0@dw^j@r#`bHTZQrE25~6ECz9ZiENVbC|+}2}^T8J+M
z`DOxDPW7n}pCc-HWaokq8{y|^97o<)W0$<Y#`e0J4;@~qWpU)IHFn8g6kP3+^EIH1
zyW@TMAmS^YjQnpJyW}lBbzhKg6da8s_wWkx`$Zl*qo=*kL1-=624o{PM$;E2D*i(h
z^T^^v(XPYHJyA?I3GX7=d9-tfCnmpJ@M6;#c?)T8o$r!g2*N>{#rPvSSjb#*I*oA}
zXV2ZfMRh-lGdX0sQL(GP)1gmuXcSqRz&uv|7cC`YA>Xw%8^ji%4B1M71@wgFASKgf
zY^&++5S>fbEU?hDZW@vcbgmKcC&E{25!p2$4jl4pHI5^{L1TN_wFl`ZynOPfynOOQ
zf~#HfH?%yCoNrL|uSw4%{W7Qx=lhw7gs+3p!(=RhHj;g;rJsU*ucc%(=Nk=tPBj4H
z&?HwHyX2#K>6*z$3y#K-^Hr>Vk7(mG5b7m+LSVkpgw#ZhifNLYN7fE@Fr{OPcG-+6
z=EidENey!^1aa9R9}Pk+WQznA-U+r{OUW{%qC#Ve<@_%7gbHQkG=R}sL{5F;|5k1-
z@@dw8i2es;AA{fvnUY%b`+}tj%pudh*pasfq9;I%KlxJ{yX2n<u6D`4&~o|tMZRd(
zAOBIkamWYB%p%~cV0~-lBrl(BoDIyk#bR<^52iH>`@mwBSWRmo&jDdd<$_(Tp^4Xx
zD6|uVJ(5o3^u>2JPSclz;+>krc<efvV*Q||D_D|9J`$v`rPD&7Ys)dUiQE+A^UWuL
z7$5SE8oT6qf~#Hfd@YY7=R0ft@u7`#B)`ceKOclCKsHuGmO7##*()%BV6Lru8-Ug%
zVO&}Yjn$%@L#E3W_{uf<%f(JeANG{l4WIYHA_c<;-AiDs(6@x8BX=~2nzO)XgV3L3
zWg1?90>eRaPr^9Xj0(1axc5Zvc^<o(xZm>t1Jt;SIG9HIRt4iK6pg32BDw`vM4eiU
zzgA$XKO5GEgAgnyp1`X=c5-|a!XH6sDw!ANjs9@Own6ynpQdBu(t^g{D*>=e3QY#I
zh%89LLQEd7aa<yJ7Z4glwp?H#**XwT^wBQ%MQ^FBknCI#&5)m`aU6N7#xBD@3IvnY
zV9PbU6YS3#k}*)esbM-5W!Sg6_i&YI;)$?rs57zL3yoJnP&Oh{-V6$k1eCe6?sU{c
z#}HLA&+whr7N6Y?fH;N7mBudl1%mN#CisO~9!Ea7FZHWk@=U?eIC8%H*FUvry8{S*
zlAR~8kQNqdNXFOga-EzR!u~wSzh=^aE|o_{`)Jg5>-<OvD?n`ZF7N{&1a$~Z(k$S8
zsR%WQ8gGLi0U;D*pNqID=fU%Fz79ggHk^afaE}DUVk^L}1!0cOg<1{Bw|uUK%lC`h
zX)O<cKMO*8yTSNrQbAhF8t_{{DAjKOmU|F1O2H~MBwH!4;5#rK#@JElBbYR{=6bde
zh8=bE`gxEf!YDZrBng7+O@iQ7kpH$NJAsjdPh?&v6p^!fS8mw1`ziLQV;EW^K$sER
z>*9&L-iYl4On^|^%w=ah4Z=ov-xdPhGx?@xL~i;99>-RJj!<S_^SN(dpKr5$z6zNe
zK?ot)!vYJw1ZyW<o<nxFKzkfzvo1yyQPcK14zk~jBx)>|LWN{h#&{S{UG^~X4up{1
zLu{tqMCkH`<Jeyz^Xj<MUq@`JQJKa$sM29H1B6zPc?CC1K~@M)V^2&zf<i~Uf_?ho
zZUP8nyAJFj5bb>l{vRz4p?H5WZO>7So61=n*Fs0>2A1eMv1Z4KFLWRt_cG(p?Au}*
zZPLd#7FN=Zx1w7#PCQ4K6VN1%8pfJ*xiNJu>gP+tFcrzD%IRlxi5c#FAgGXek<am4
z&@rh>B=<}d`Aihi#4a(BOXiud8zlciu`k7m95TN59sNkg0K<oArZPrZM>ii|6mr^w
zT#U~Fz3_~FPo{Ld^Ns#Si1ebcSootzBNSwNK-i#4B<EVe2N}pY!J)zhf-~87xaIVx
z7(-%X9ajx56_VhjW*a48>h`Y|*)UothI7bD1?G`)JwmbFb)1A;)+7;I-*ULjePiS)
zsDv(f%a-TB?mC|XvD-h!fi{Q`E<uc6W<^AQvaMc=Hv3z&*>5m5{HZ<?gxYThqsLf<
zHrB<{zwbfFAnObdb%v?atT3D*JPLd+Rtn6DkHwEB*g9(XOL<Mdv#vWbsen3st&L6U
znA!ZFVVz5|ukTDQ2Gisqjv*(=aU_q-JLK4{xw`(iQUswQvOfsS%YeOUVl!_g*v%l=
zvO~BPhJFy6Ib`fKW>b}o^sDl4rVnF<>j57Eao?EyJ*lgZ?0pc=ZOA{>IF9^Z8oT6Q
zXq;$j@twwe_W!#zHVfzcomx!$uqqYtOw-hE(x&%{;oUqC;z+hkV6MqsgCt|h4!J89
zCEE+~hIhzO+7vM&te1^gFT1yNK|XCLJo01*4Zq5G5{Tzf<Q+A3$wPvxUGg+7k0a;X
z;Qi-I*+|a?VJ^nS6Hvi-u3_>ySmz;YrDWT-@tcwSeHXew{-DM#`TK&aUGfjKJdT`i
zhW5MQ4#qcuL9F7uAy^4P=-&syp4ITxFn$dXM2&C3e*r<`)?ug|L^1heAgrcjPiRQC
zU&HuJJO>7%a&Pc55S01)*?)lm9q&W4EmA0ljFu6dZM6iCiad|(poYe-sGJU?lf-a7
zSvd&Dpt=@<sFt(BucX5K8}qOk1)@vjZ-QXvKrKPHd@n&T6@)2HHcRAHffj<hwfq4v
zzQCA<$aji3hwN35xbP;xTO!XVJ1Q`TtS9<IR2=W~$WUzPfG{A*I;2bGi_qTX(&ij8
zHV4k`sExy@?F520*(QPckAWT4uo<l-L4oXX-FU`<BSCDKn)%jTzIqzMy|o_?!qq$o
z<;dn^EQp)~;~MxRi9r|&uWMKK)+Ua|#r_yCCo&$_tdqRN0{~uaduvT?Z`y&`G>tWP
zKrNW0({Au;BQ}*0o4Sa<8>OovHZ>8Oiik};zE<t7y&1;;0fP5&@dRGGcGsG!kh8ni
z)Fla1nIueYk}%at;=k0ly>=O@s0CrZka40xd3!Cv3n0w(AObpEW?DgP(iL#-d12n}
zcV~O8&z<eHK6kd)`rO%W!|ZGRHgShPF%2KK)e<C0#W`eNB)0h@vCUugHh<OI{8exB
zSG~<v?d##9Wc09JdSb^iU;bp@2$;OW>lgImWYaCgrdNnf6o^d_h)oQL|4WbTsJ#lt
z?~oqJCF`Z5v7?sYY#j|UFB&`i(b(aS#twfpcKD;Q!yk<uHX7HVHjX%)4zYp(Qde%Q
z%X7bh#Ow0S{+c#RO$xIMMQbp@ILWx!n6{!fH`{7fW6kia>=7%`OzH1EwJQOdB!O=l
z5IkgZe1`T|Lp->!hj<am1ING6gT$Pt)3E>$le02<L#}%`_N?p>I1|=u85v*ajF~{D
zm$gE6X+$4S=;!MoD8v@3LdW~eLYWdNo<lZQU@n>0*bUNHuSpyHU9iD6>3Oe72$&Pk
zHqAwwu(GpBT|j_*_x71GG4sj1VX#Gp0p}!&Zjt`rYUexeqa}`EjJvKZ#C|2FcWfl_
z>u4RvEiwC$<Cd7~B)fpvwAW|PrM+80sE*7t?b7t^Ac)DlT3lZ(uCEr?SBv{!YKilC
z9q02p&Sx*qXD`lYFYdqClhAptN*{UtNgsPrkdf>~L5>z)6pT6PpGPICX)WaZJpzt9
zaz-0tg>K&i;t(X)RrZ(R_%6aiIeDsd0=`rTu3hQh!lvDwrFF<31L1f__LacGPQ!7B
z5CkdNbb*EZ`PAVfbvg2U5H!f@1QzZEdsa)y`lHw3E5o<do4n))K`3|1SUl_i0wlXk
zU?G`~O<D_MT`waft)&tC_aN9aaa!et1A}vKEdx>wLOvPeA#&5Fk}#br3Dc{RFx@H%
zQvt`<BOrK4#`s~>86$u+u{2wxWPbv|z#Fv$4{7;su(L7ZMQ&<AQB%kBFwBmE-(;)<
zs;||umd`+tlX2*XoK>!p02Y$n3F220$Qd@#VKvi0l3)Niz$9U6<vi1)Dy=0p1N3Uf
zrgHe0CZpgUamVvvPc3~YK|e_j!F=6!WLIiP_6A5)2tLztM&{2FnL>J5s2$r=OF);g
z){|9$=mWVP0sUKi4T&w+7mmX%6%dul7l05lvZWf5@%J<!CFAcQP?`J-!Tnpv`EwgV
z=lqtLaE^UR9r8QH**r4(4*%Gr2Q)O{JPCzQ17V<$dE?+fEmf87l>@Z|90{~c?seAz
zyH0<Lq8-Gr9pa4IQILx(*rpe1<9oI+^|QnhC%XDG4CUB%TuvD85%zu7?m*bQOzh(H
zSAWh$l42AgV?$Boa4o?`kr$G&)$;0uSn~_nroU?yV=WCyR)9^3*J|U5ya>D|5%7lp
zYt|tarx0CYOk4z!=fw+FuO33W!97xPS_O{Mg~ve%H`$9?Y)m=zh{dfSsD|0ie*>Wv
zd#nP-@7FSM(pt!qB%Zkb(VwH4*ki#$sP8S0B;?YE0KHH<7OGsLBw-3T&^S?6&O9<t
zd7oc7)*B13m@d+5E19Pp8wFf!XX<=1=KJEb4Whj|m&_}@+lK5N)c>Bil1t|0ANIR)
z*eX*aL5$gfF$bawDWCH=*f$!sg%TC96R^iN`V8cG_FwbckM;8yXvojT#5NhCu|oeN
zm_~yKJQHnVQ!n#*)Iw0m=pn}4wz?J~-I^RSx~4OX6`eA6veAnZb;pwx2()wR8XP~a
zm%~XO*<V0$PUWYuugUW#J6hyeoJV#K=vajlu#%r7M~pnO(?Q27)WgA>LEbPU^j6q?
zwSR**Ts3iSl<8Z|_tp9q!Pt<Rhhyzheb_bYE*BZo(q_*X)-EGzg!U6s!uI?|BsYnu
zkj!&sx4*{NFxv)a_k%D4jeCH`x`Xm@B<UBTFbLI?(Xh@iZ8^4ISlGtFs2sDN`7~be
zyBAwH%#ZD$SZp+Y2Y*@A=V%dpnJOnKIb>e7vAH+~!tpwvjQPH~cm<LxbuO7#I_AY{
z9K3!9LWOsNZPw5PsT<CuXI&&+JS~JpC{GrorfC;W!2AcH>!%&Bi}rMiH_DPQ+LG|A
zd*+gOlwlXaT$0H*7srq#(hW~H(Wjf}*L_3AdA?D_*$Xu*WChPBqZjaCN3C%ODr^HQ
z7P;S=x7V_#b`+|fC)X1>Wb^{cd;Axbu>(DQ)_&xi1!YDK1L|q8R)INWGyy5Ss}b+=
z$l~A$93tx`FfZn&oe?G`@L)sja@25z_KYl3d$z&vS?uzPHfazegKhqUhX19-hii-A
zqwe#X?&R!BRCrhndqF&0>x*1$t$qpW?|`s%LdMo6;-uiFU}mq(v)cXIvqi!Hdx`k&
zKul^v!S#T#ptGoPcP&9*aW%Iem~KEWtFF`1-+^t^(6r^8i8x6E!H4(2y2^kqFuA@6
z9<VLN35Kts2mB2^;BRPb&dv5*z_T^RvUB<%oG^gUw;`}e8k%h8_7YJJnO4k?DcW@@
zW+pe5YZpM7zvyi&N4xoM5B)K%!d!74fOVcN6Y~Ot*A~P)X@5OaV_M<)1?9f^B&Xos
zPLMI}?1eqOH<D{A_iYJtvn&I|t|K1_!U6b5fPi}`=*Jzk0|2y7u?63!5Su_|?=1l*
zQ*PfgYVc*axE53T7@_g69`$Sj;r2;)@;?ja7K;8bpMC_LA@*2fWDH`Rl_p@rqNnU#
z<dB^O;^sa1*&4g#=V+X0D!4a-op2BqP_k&Iw0UK%ZyR@|J(<}Ljo)WbIiJi^-so4}
zXq7iZ`7N=WOXewW@hfjRMwuFz;H>#HT)P31@fXn03kPZm_;X5-lX<(ou|ZuwOjp7a
z8QNHeb%&VTGqR_4t7n8A?z0l>!d$d#G6?Y?^Ss{d_d2#Cb`~_w)yia^@=bo_n`%v@
z`ymMZB_26sp7Jez<y)+>xrG2Xcn87r|CU;x&oSj8FgHS5Ci5&`=eK;FwLA_Q6SOj!
zr@Yp$yw)n`W7b^^f*WL>@;=!E<5n6vW?wBg{=MGVXG{Jbwr|zdka;D4y23ZEe!9Yh
zraihY5rk^UJmvopN8jFV4v%x*?tTvU{k+v8XE&Bj`iB)FhwiafVpAdW4}drf$o0*Q
z!r0A?Lf+$8ETz&~$gcvyJu(``AdK0KtqRZj>`sANnW*NGdEttUwC_>Fk09PTCC@$9
zENU>`J_f6_jA+Nj)3I+saE6Q}MNW_f6SyKvG6kcE{B^n$$h^3&^7r*B+ha!%`A>8w
zka@~`M4594wZxp~ov!u}!V5CyV^J{m{=eO6^Xwk*+l@`)Rj8Ra;85A*c!I=Cu}sF2
zc$jEgZ9I>~W{SroruGQ*%0TeVh}I#w<yg^I$O}q-&82w22!|B!C)D(B-j2kN5%L%H
zoTI<ZnO__&b_#JAJEp|M;w4TNP8mGmxJBg)Coiigc5cRz%9D+#ES`y9ZJQ%MVSFnt
z89ez##nA%%I-C6P<S{n!lX;8g*AzRGaQW?JKvX?HieCYoRO0<Q@3m;=F{R{Z!h;td
zCzZA?YU6J;7DH3g>4+R{Wd?o_`oe+E;FzFVOG>R|fTz>sla!RtFLrJ}Uhue2P`+r!
zg5qe|qB&L0+igv417<9!#_v5kpZg>=B~{Lk$EEkSkCmvIIlsEtIpUMd_I@-nF2SdT
zpUlR4G-HDDg>#CR!t;_vSZ8A58tBcKU0qqVsM5LICtt8=PBoge=C>lg$Ha>`%+V<7
zufi`XBTh~Zrr)udiz??7SI%1I-0+*6Sg{$^RWtGHi_`wQyGcGV-F2q<obvns1F9G^
zv#QKla*_t4<`*w;-b7+XS=5R5gigIbcihRiqm2$P0Ivq0MLytsr<T0`h0Zn12j9f>
zVCP=2;nh{k#>`weXMS;|v-7xg=Z;v2ydNs&m)r3Z;Pdl~7du-uu3oUvDe8<<ty#{$
z!18C86)%|S96kjP4lb>zbbjfg!T9p3s8iS#*EjeTac4j`fa-;_M;4bj?M}th)N>?%
zG9lydOg;@?EGk|mzmEJR@C4m={O!((GZ)z36g~TNJOn-yKX&fCmW;aP2Nj)5djeL@
z7K{Au$mE%`(CtmVJT!jM?0L>6rWVaBUMSDUPp&L4EiJCZuec-YzTU_(g5nCN@+_Nn
z3eU#=Ygut6eyI_I?%yUgzPJXzZ8_o`1d_kc=v)dU3&3n0m>*+-X-1Yenz$T^o!P!=
zJHi(kzL(u=`0iM+!@fS)X`6TBd9aJFnJ}}$nPb8{#}~y}Hn#WMwjV_yuWK>l=Q|7g
z#?mF|9;dgj?>{kJ`X02{w+!$M`JM9isL)89ynd!Xb!OLC|6Yfz;pNc<Gppt~8-TrD
z(t7-6jOn&(LL3P4>!v>(8|2w0DUrMMxbg6QY!vXPWMfOe<E9>yyuc2edSCbMI<D(~
zVx-Ja;Mm{?ReA@SI7##0w2LitUI#n`st@8|4dVNP`6l9jK=xfArdJ5eAAB%+Cg&aK
zz6au)V8<yV)i1T=dlAh`8cohpTzBzZihPA4^Ua5^FZ>3?HxUM1oMeFi05YF#SZ;e`
z9WrloGxC?Q6lHe6bJ(B;ko^EB{}=h~C*YzNbPATL(?CCAG3^Nc75H}`zIEtx5Z^?!
z2J}31`F5fQ!TC0&J3x1V%qJ6T8Q(EefpusJXb^}mxZzuS_|6;iF><44<PLOufYLzJ
z=?OX;WIkCK(-T2_cS;S&e9|zl#)0kx-3?j`;!8XDGLAJM^I74gkJmH#e5=4Im@DQ@
z8ho3;c98k}U-@NNG5LCdi!g8a?f~<ljBgA08n&2cJ~@!_>;GAhj|80$$^e<q5G(>C
zLFW7Ttr)=k;`%>8M?kkB?=5hCr+qyr2gI+to6k1nG2fIka%1-kOr<VoX!}QiA4A!V
z&_CWz7UcA!0C~*M2QC7c&)1NB2jaJ*?}r`p`CsxYQ!qY3kAt2B?F2mv+75ac^k>jE
z(6yjHfy{?rS>kt-j)3?jB=dRVY@C&Y%(q%j#7fOCn!Ewodwq-+#tjzDhe3R*n2%#W
z4IILfXg=nFa`RZRUw&gh{nRlZH+~41Htqud3&?zmVCxc)DNj8<Lu~XGBae1wg3ke&
zk12P&J|6|AKFjgh?*CPe4>7Zz1K@mQoOWIY{jYNCq00xEcY^p_ulW%33Eo>lY=e0$
z+2kju!Vi$i=i|oIHy=Kj%cp8hzL5`4!$AgAb3WD%&>RpSO6G&B)4?Z!F9nSUO#qpX
zDR&2C&x8J#9-mL`*Iz$J%f~;>XFOzlq|-bS%KG_$srjry{#ziEZ{&P7v<LLg0-fj6
z=Y8b;Aa3;XCNp=wxa;+LCdU6Lea*|=G44?DITG{vU*-OSGAvg#66+TDufs9NfNAe1
zU~@PBczdm5_1!_<bZ7nM(-vvoHRK&b-f=Xal}O+2$$9&bcNaH-%%?R|*T-8&yunRB
zctgp2coS+V=mya3ptYdify}1{y7b%Jzc4pR%<Y-u+iA*mLYXr`=Yj@<%!f}>Fdn>*
zz&O)xBgoh>dc5U8xzRInvwLoKB+XX-|JVEzCgA0HAll)6Iybbri9HrP4>STa8WaI#
zg3QNXe=*8FggllrpVMKByV2Z#=Ek%6Y#oGk55zISM~}Dz%Ux6R`M>f{9*lDwklE)v
z1DIQu=CcavHK1ET8$maLZUNl@x)EeP9K+E}{TwN`lh_B`G%+8hxeH?UUAS4pe6xRJ
z^vrIF(c^~6M4z4iEC1w(_JbP?^n-P>4)ZbljLhf0hxshbnm>QhY-c&IHyr*}eHCus
z@G7Pvue=l&U&me(mh*z(m~+L-;?lfDOUmas<)Sb92XZB13hL|Rib=eh9KOt1F1rgA
z`f{d%`xP;JxD1(ts>>J7j@8SH>hgl(%Bu233!U;RoX0!m!?7VT4^M)WlvEYNQO_Tz
ze0=!=Y<-xD<%-iJysP30bBR}8HS+kH%*A-cMU{)HE8uFyC<(+|Y>7m<B@(+NS|}HN
zykeCLRsXe`DCsMurEFd0qGi@2*=txns<LuI6<RR@7yso8u_I89U@Sn?i%ZZLDbFro
zQx@V<hgY6*Z6{ZB#S$@l6;gp5adKw<qRObm*r^yB#l>@lxLCo<Sf^ZH8&-^&SyR4H
zY8I=@A(n2RIcHAgF&D=sYW{0<-&ID1cL~bcor;OYOQX)rl9F;<=q+<N9*SpU@4%_>
zE|M$E74AhNMhs2vbJ4_$&q*E_x*+5o3^7(6tf5XPXFmROCGF&_w5Sn?t6eAO2mHr8
z2XX^AH58Nv#I>T6QwN0A80gPH;{@%q=nWvQ;hmgMfVkRsax#KAfC?%GnkZ;JE<`wI
zIyrx_=y4#-MaYf<aYlA>+Q%8x4T!U;lXE|i_HQ?kZqbWC+S68`k)rn>i%w``+M5ET
zbNc~dMT5NzAnoaFpnQ=n2GV*ffEc+>&NV>1F6-pnYV|f-bid8r8m}+v;+<>T;t(Vy
z9t6U9s1xt(u;>>c9lvbX)HV%BdobV1YJhaTcL0qMds{7vYiG(P1L<g-XVD0t5mI6r
zkoMp*i{@BVX3>0$DlCdxv<gVa<yIhV`A#6+=R1H#No{*AIt-*sd~VS%Kzc-+fQv?*
zdm50Ioo{91fOItG0*w>PSJ>REfOK4%t!$@7F9T`+ez2%pf~jqYMPn_RW6@@yLaFVa
zKt+OvC*mz^g4P2~6?7Qr5<#6im=b9~(?oU|&~!mnR`%WrX59Y_gpFm4rU54!6rW`J
zC=qCe<ep_^eXVS?l})s=(vyspH9&f9#hq;IoorE8AZ@w7m8DyhYf+)qTWn=d0gV-}
z;yXIdWrAh`d9qF>x)%cJvBu3MUE5_g_jaIhQubY3+Uh>)(#5O{gMqxV7G+vA(xNdI
zjkhSrqRAE&Sv1X}%Pg8>Q3a5mJq<wGs~tdkJU<7dN8<ZHGsXK(UCsC_0@7vY0_n0h
z0O^sv$>u&}bDsg4C071s^^O4P+P((T_Tsx4duIUY5+NXMc_@%BG26;&EV>>@uajGW
zbWHzdb3eA|Cm>y0H*5pwp6Lsu>qrOEbxZ=%dY9VVN+8|dD}b`4MOOpq63texFD}ey
zOYU@_If5#IiUrleIqlzSuo96yWMz*6m5S^TkS;L;7xWq}wy43P^%ngKghE(%ufUc<
znOIo^R4%9qNYBCBZ0=oFcAu3!Wo0i~^drz^V&(Q8xNsD7FVH+ei<3>g8!fsIXujnB
zWMyqqj9v$ePO+$;MFW8JJep=@v#ji9ARW_vKntXf(LD_+vS_YF*8wdQy?1~X3Hk<T
zvY@eNn%P(cq{n?3kRA~a+uUbt?&}t{TD{MK^!j{KFEdJ#fwaATK-%6QAg$N6w^?ID
z7A>{tVT%r0)O41K-v%HZq4%xq3oBc6w&|@#pbBZ_Rx49|jO;9+#gZEWnj<J5s8G;t
zR_`95N|EgW((B*rHutP^j8}buszh&&mCd)Z8?Ed%E877yO<M+v3d%eWcUA;l4pbxP
zE}$iXPU~yVj4tbEdbM-NcyJn!j>}vts{qnoWu=-C+c(X$au3i_vHTX09!*~W>3Q@W
zkS^P~zlqQ^AgxzpQ6rEpaWjxEu?tAY^dp=5nayo;zR8^er03D&Ksp-l0BL)zK)OXI
z4=~5yML=cZa|4jpyBbLAwOH9*R`$4+J#A(Gu(A)V>~{mr8gVa>p66d)fJ-~6?G|jj
z=-TeK=w6E+0n#3P2c+8(7-UcukS;qONb6lP7@JvQ`6Y`Qh8Vr|7HzQTZXjJYZKzqj
zF9sSTR<;3ME+{@7Zypph1!#hxwqawrn?=bMod={Xj|9^8{s44^l-+F6lR&j1`^w6?
zM@)&3MVS^|4Wy4VZvg34;4_QbWEj~=Ky_mIY%5E*=pvgt$I6yk^cSF&Qug0g_5+Z%
zcg8SN$N4}y8W&mFEFc}VzX6RFD<1+~Bq*3^$`%7%DY8EU=@#v`xg)cT-enf;vM6P^
z8CR2mbaXGZs18WSWi1f?aGrR(l|2D8LS(N1jS_S+1iBq(0qL@7R+edH`4(-l=%_`d
zDA*nL;+>a(^o;r!(4|txFjS>I9c$5CAYEG(P@U*K3Z#8`#pb?cWuIEv4?wy$26={*
zoq-_hRj&+an#dMgwA`ZIK=qPa1ebCIeF~H>C^FU@Q<efXh%62rbeW*v18LbkK(j=4
zz{*;!Y<f1n=p(rw0_hUJ0_hU{#~c4vps}k(FL|Ol_nv9dVxWbRTMwi?ZHE(dEh`4n
z@%s@-kGk`qv_eW;2DDPp1|Z!Z4*==t9t6^5KeD+O=9-vh0O|9MVjw7B4E-7CDnU<K
zz2~joCqNib&}*A#M%WoZx{kAf&|%081EKLiV}P`$Gp$|&kRAt51C7x3&@E^@%K~Xx
zK9G*&r9cQPa<8+w_X6owz67K__`;&N$wt=QqEsMVBG<}lEc%^AyMeUNuL9|4jKm2@
zcX$x*jIn6EMRy@bxBQ}0Ov`t7Gb47|8D<>BL$9Y;$;5wckDhy$fzATOJ9py$KtZ=D
zgVwb%sM(^!7X72G$^EBAUs&{$Mf_bkZF#swxfZ?K-sFB}QJVxKJISIfi*hZRZc%Qc
zDKXum6&9_vh}X&5m+vk5&xuA>kz~-)lMHIG=)RMUY?nnVIvUwS7V#$$bR92R^qEB$
zbT+va7QJoJpV61PY<w4kI$PAsq5&2Sw<y=5D=liYsKuhkEaDsLb!~?&`qiQYT=D7L
zt`?nbQ6t8h&gG3?jef9b)Tu_st1+E>rA3`jGqPS54Y24Hi+W*@>ars&%C~5SMe{AX
z!J>Ajo3dRknrTtr9wzteWP?shG3Y{zq88m~(H$1uZ_yr$-nA$m(@uNe*`i(+HCptX
zMSagSC9*B5?`34`ENZssON)NCsC{o!qRFC-7HzX=w?#i#bQ%@|?Q@<*C!B3$V=OAN
zXpTjTEm~<&i$(WZ^tnYpTGXwNse`XC(;jrSh_5r#vKbbww&(|o+VwMf{VXc8XrD!&
zSoFO`XM{}IpDk*aYGkKa)Z3zg7Cmm!^A;Vl=zWVirx|-G7V$Q&ZX0jxYV<pcZnNlB
zi{7y)zP~AvV-c@=w3RIubvWP1F0*L9MGY3+Zqas&4qNn<MZZ|odw{W=Zc%|nvn*O@
z(Q=EfvS^(}yvEVqe__!U2()a6MSCskcY(>xx99<j0=UM}WqDPk(I$&{RitG<0%7UE
zaqw4*)F9k&6<KGCP6g5>dRti-NSDpDXr#@Z0HjOsWeVC}xkW22y2qlO799lAmfy69
zUkuS!J_6E~zp}FLtSpFYHLaIq5pQ#9SwD-y7G(jUV-bTqD=W2VxkYtAy54K7j5kJg
zS>7tuxh*#LPAj|5${w}o3!D3sMO}uNmY-%(4<POR`4$ZV(zWrWF*^4mE6cO8LMxjK
zq+_}eNc&uC_10L_Xc6Bsp)I!n>9U(F+HP}Sw6a$$dfn!JY|&>x+UM`B>}M-;adoU~
z>j0$ndRtirkoI7>MWb!*Bp_X4s+G;KGQJ)}TV7;k%dPA-i#FQad#vnni}u=FzK==U
zdksi?^@c@1*xX-%v{&uZO^IGWx<ns~`r6z~i$($IvN={(YSABT?p;>)wMG8{()}9@
z8!H`vw9nlw>SxjUK;2~qTxd~|&Ak*z+badqURB!Mr9j=K><Wvnv$;1~+07RH)#mQC
z=yjX>cZ=S(x!lXp-v4NkgFOoERXZS^+X<+<_|nxP?tbXpb1XXFqCr+K-J+2;_cAM+
zV^NvST@0k7vBJu(vFH|yZnt_{EPBS~9<u1L&Hc#AzPIQE?3d_vbOh4%o?&HYT3N`-
z23T2!mGLW6+Dd`VooQtyKstVNExN+yHUQ~}H(A*RtGCgjJ8ka$7VWfXuhrXU(F->B
z?-p@?NPDV=8FUhm_TW@2JJX^*Hn+c(6#?lMO|$4Sn_CW~BN?@_Wmd-Tw`dQpwz8Y7
z><)|Wwz&^j*~3=$q?Ns55%;gO<xhchi+-}QgiMp$-J)SYx*a1dy2$3{0O@vIVr7?E
z**q(&u(Hdo>^_Sgv*;<S_mY+U4M=<Xv6X#i(N8wFO_uQ`2}rl{6d>*WsTTFHdgofb
zR4a=B>Dq={*#xUs1myLqMcmiZwJory)*?QTrb}FBQKQY}BWt?s|HIy!$5&OI|H6Ck
zwfEtKgyaN*piF^)fI=XE%BTq;Kr}$ez#s^O<PahuiOD%k4n#uKkYd59wkqIIhgPlD
zUh7zKsHjz|XcdQ6TCoOEtJR{SE%*DZXYJ>l<nX)iz3+YB&wKxP51j00eb=+*wVpNX
zeZKonk$x-EUXflD=~YOazqbYZ3KFOBjY!{%uRGnZmo!M68u1EoyA2X-v`AA#nj=yP
zBu=+NuvLPsfyD8x6W=Y6I9FGQv`u_}BGMj_9u(;lk-id%9y{dRdpJ5`sgFpRB8?Pj
z93;-cnUFa5GsSnFNM+)?LZr3g+X#tcp@#`s+AO|TK;oFM73@aQyIG{4i!YtHa)?I-
zdrI`473nqceM_)+Mfy;Dof&?v0wQ&X#5L3l61U7i!RWz8#<B$)FWA|F6^V4dNUKF!
zFVc3A?t#Q*dt9)+g1rcd(|uR44+Q%J66g7Qkx~kLEFBWZd=ey%Ww7{;6X|S7+(y$O
zafrF%yHKR1;u{vMPNYj9aV*UuwTbUFBHbj?9U|Q)(o2vymRCjEFTV5`CHsa%%7Dam
zFiEg!BISv1iAWcTZ&aj>;=2VB*VPV@ekQ*63-*LaFNt(Oq`!;wwMfn^KjwarIL}i>
zIv*03ZJ9_b#di%P&ea}~ej&aYv;DAxA#u#~h$>6t#rG_cW{K}Yk$xk-kBIby`2HRe
z=im*I{v~?fLE@g%2loxQ9Q{NZ1c~!9N~AMHI$NY!BCQaqMx>1*Z4s$mr0YcbH6+f#
z!y-K<zRyD9a=a(l_o8=PBz3Nz=M+dBqK{z1L^@4;&k!tMq}k$IDp<8h8%4SW66g6=
zk$x_|_e0_w{6(b0;`@zADd+imeIT7?(LT99B#t>#r19cA2@<#4*^oGmLh)^c#9`No
zv`KthAaRImM7mX^dqwX-!RS$T&ecmI9T4fyqSqnVcOrE!^244i(m+U@`%!{T5h)iE
z=kGkhiUnID*jkYq#rIOdwu|(f_<k=^w>f?qQ$;#gq=h1Fg~T;^l}JB=#I<p~=<N~g
zevzIK=_Qd4i1e{YpF-mDek0fqf_1}fBu?#Qkw%C#8WPv!nUFY^Jn=mb66b!N=q(rD
z)grAG-*tj*7U?RHc8c^fk#<Ak9NaC~gCac)iF5FnNc+V16-XTRZIKR&?<a!&TQD`x
z50MUu>t%>Y!y$1Uj1z3ONOK@@YDD+PVJie%FW5Gbehi6of2~M2LgF-T7d@g`V(cNo
z9)ZNEJt@8~i0><c9T4o#f^`V?86=M7sQ7j(_H&gCiGBM);t~xN=``^j1BvrDS$y*$
zaoJ{x-a_$RCB7Gm?>h0_ED{k#a4dI;^h@#m4J1zYp!gmV>9F{I4T*E_%=e`%NE~*O
zNLxgDL!|T)UvGd&BSl&u(t{$sEYbmy4vCaq>c_W9q<ckrS)}o0zTRe$elF76BK=FG
zQ_B6i8Yt2bNL=#MAx+Shf0ju1itl40y&}?kA{~UpVUGy*g<#(cMh|DRUNR(3HzZg;
z!7>FqU9ho&O%W_tu=4~f7Ho-ND+F63*d~##6X`LLUKHtlNZi9d66r9cak{R)6Fq04
zU!r7@GDJEV5{DQf*y$oo5NWzdr6PqPaSkqo#IdXw-)528M7l<#n?$-pq<bK7EDsCz
zlt?d#^twoILE;b}2=;eKoU2bn`bvC{3HBe6k{9_kln#mG8z|Utk;aNNNu=o_ohMS6
zNEe8-4ie{TlStdd_s4==E7Hy4dzWCpgv9xKTzsDs=@pUQfW)c2Ez&{pJtEjYL^>|M
zNsIlkJwzG+iATk7!A=)xiumS1;{2T}SgA-$MGA{lC(?S6+8}Z6w?pFiZV}%*Mf#OU
zk3!-QPm1)4`0f|%Es;JD-@ilRH2xvjw<6i+`y~%RV!brM20-F;2a9ix_)ZonU!)?D
z%0)UK631LASglA=kuDSIN|APm^iz>;hs5zcAlPGqJulK9#rJJUT#old`ciz4LSpM^
zFY#+5U8H`HIP4%uobDL$ohZ^Y@trBy9Kq@ZyIQ1cA#u991bYM$r}hLSPVEKpeO;t?
zMfxiw4)KvlpF`r9zZ1RVkT||!OZ`%wB~p<{l_Fg%()A+UFVZU_eJql9fgf|GNE1Yw
zCsJ6X3n6i?wg`5uNOy>IAEf@;@;?ZPLp&<dGotqgk=_vB1CY2jJ`~>$@%=$Cdzr77
z0*URx0FlOtbQUDe%M_7{#J60q#Ud?(#5t%Dy?T^}W9bWNgf1Jo8Os$62So<EM6hPT
z9ue#b!7SU4&xOSC(eK(gjR}IS7OYmVy9K*fF#4?<hkakLkmF++kT{Lig4GIkhhTRL
z<|;pI5E6%7Ay}1QcL;X3U<U;|Bv^*)$JZAU$2VKBBEjAi?0{e+JU{FxNG7acMS?{H
z+aTD@g6$EEo@C>?Iw)9Xz{iF{;xuLmHe0Y}!L|x^uV4=dc1W-e!7{q}Y4n9;(hzL6
zV80P8_WQgJ!9EqeSxJ5@1Bdxio=8a68j5cK{}QE;^u%oa`&2mb`Ok6uy2WnNR72U7
zjQM}J83El(#|Sb3NMrGhAwP%ffldhZ{T=94F`Z|D<f3h3$bQo4g!~N%wM|Utb0B+B
z@)(i=F*6vCWCGdI2^j~ZAvs=W7LeCEA!~q)O^w%SAsti@E~cb6LTv6CkNgJ6!A{8Q
zK=$^E*ZGhl=pB#zKsu+yBk8D{hJo?OKp+Rp;*rrn=ndo)9knH%HU&cOdyXMX2su3-
zSp$TgB#r5;15zwVHi*n36d69GqiiDjd6Go=WLH&0DvXN~P@R0)BYS02lOF)X{e(K?
zzl9>e2MrCKTDl~BsHe~eO%EO7x_gYG?DV<W=uk~4`>Hg~eJ2%*>==E}VW1PjIGL{9
z@qhlC(LslS&H>bTLQ>XVqk{;ba}<9QE8sPw(_QN{nO+M=+~=UtLB~TpnfPk}NdD&^
z21)^->=!7>gwMZ?P7nAfn_9T@C%dwK?b>jiZdP<@=%ja6FfOv`nWooqB!htDc0wiq
zIoJuANjjNa2OMf4kmkYhNG%Y0pF7nP>s&&}(0Jq;AoTX>n9jX~Oo&J5_t*65otVz6
zK>QEK{MQ8J>jb1*TtDMb0~3((2?)(c{)a=YOhDEpAZ-cAt_0+_3CL>+$X^qXFB1@t
zhKTua4*Mh^BNLFR3CO$zq$&Z~lz`B$&;1Xlz9#{BGy!=f0r@Zi`7!}<+2rZuOi2@v
z5edk&1f)Cxxv&$m9IOqs;LP(soYv)?bja_<1mqV9$P)?38wtqa1mtJ}(t`|``EY&)
zCLp5{kf{mCyaZ%L0@9Fxv?d_eCm{DEAkQZt?<OEb-R6I|T=ZK3|HDYX1Y|-2GAjXD
zlz=oPAUhL~dlHZ*6OgwPkk2|HpbK5Qwtii>b19rSJI>|G=!A@hE4wPZGFrX7V&%%l
z@H*e6IaiENZB1R+$5%BHWsC0t4i_UfL|4|qrzy@&^d;i1XsoEKjyXHK(Dkk5U{xU=
z7tJ67#>A?yaHTAdHeewT&a149u8r1KM8G||yeYb}DZ;uUYEF{n4bi66^Xek?#7zRq
zO(I_en~5fXSq{38irSh@VGyzqMP>x_E=}2$we@x3>>Sdp3NyWn!Nyz5tHX8SMkG$L
zl~vT#`tfNhO`|r!TE4a-Qn}i&&6I^3*Ot}$Y$-<P3~PBqV|`_~2}F`>8|tHVRX#V3
zk88Kj0t2Gg+DHvEo)DV~NI^|RXIjhGFnQ<9#`?8gQaQ_7-WWzjcCISDo-V9IL5TIy
z#4{;YHs*UFQkEtZuQpuKXsA{wrS)J{Y0923aXjJ%Ws7Etp%R*Ca>h}OtZe`<t!9rY
z30H&S2Fy8B-mu|pDUGa+fUl}_VOjp{?1^JV%o%%@-(UVe?|m25f^Ks>7hDL9mm5wR
zAJ%Nfok5~9_7UMR_JK|$#y;pX82fIH+@~-0(M0ZI--q=zadBrz@_`h}!fPAQ76K7v
zYF<^<yax1XQz(JZga#@>SE*<UcMa^vM?+Y2sq5uq#Q0rMJSg5d6>Gvp6)VBq>POA$
zOmFLBk^_vOxJ>1*ri6+yWKNK+PI;gROvRljwW`j!oe^!2DE(Z=W16%!zrJCkXqk48
z3ny8Iy@<=Qu3B{LIOyEy+J@PnvlWn;iOTAkh1XXtjWibKukD<%!luHyNEocS5|*-S
z3TnowNr|g<Z9_#|LZm^)fk}A%gqE)&`dr@yKB)S}d>ZR92x-hf2LNGrCoSTQ@_`vE
z=Ts1N*ZJYbdI8CzA^kj`jmcN0x-xCqxq-pRJvX`*W(QUxuEqcZqudJ&2o*&9QNH5x
zrn&|IkyV07Q+Cd~;k)fxA`~(qWL`r<xUNcIq&T-zn-o(L;!TdcICWi2%~mcdGgcyw
z_^vf0d{MMMzG5kkuJtvixO2fc>rA8N7vGdBuc@h~x-MT6amOkVWL=o5ItN%#6JC$;
z+sVe8I%j6+&fPID8d;scIt)HuNl{N9ROs1ZP0r?f=&4{j?0uc+YN#NtZn&;0YB%aR
zmnZ1Bo|}j1n7zQ@g{;SlqANAp*ofUE##ZObFI+XVqP8j4NhlGrL{d!2k6&Az+c&OX
zjuTbgWOL)&ET&dgKNl0H)jdKSbJ_J{GR-Gv{Fyo9C!RHa!i3Ds3F8Rlzh@GFPtL?~
zXHL@6ita@=?TA6$JDpGAa1vq1pMj9ySnRXtY-Q;*a?x*qu}{V~{u~6(6Mk}m#-D|p
zPzhi&zGJZ0jsK(}%}CtpU;6<YlQS`1&AMwOe))}6=g_kmZlDY4ji+<C*oV%&PQwBG
z*6EDVE?VnN02ufA8uHTdpjb3|Itvuv8Q6NqeSQzDxJ#aOd}p2+r-e7$!bQKCdZ}x=
z6FaB78}(cUy*In+P3m0UOvLxq6wvt^J!FH+k&}a5$3A@__L>@VYYEC@a>gN**rz`#
zf|w*aeV`YAZbE+4?z2oE5MAgEYqEBj(SwC)WV!B-BSvOc!X}5SGS}BcR%b@m*Jsu@
zX0EMo3}=GVkW6!=2HiIEqG-6W1|w{H<Wy_>6T>Oq^0to_E+}pJw14{r!S?b{>;Cpj
zGurb*Y1bEg90|7WP20K~O6_w}+MD{em!{aSPI@bC`)z>8>sj(DPnlGjk=EJ|<;vOH
zeCfwl+EzNHYLBM09!<OYD~LHqkIZZNG^MyB_xSPS+l%eCjG=Ai2Rp{W)$&}ZZC~r&
z_VR;iTYp2L3PSTs+A|&~S=iBwz1#Eqw)dLZHg!vGTYle3(Ui2S_mEzBsNMZ_>)z;H
zImeH@k31lI+f#b_IsDNwN@>P?yDdLu!P5tw1;y>j^E;mYk4~_4Z=|SAp^PX(>oh2~
z7o@c1XTWv!6u6MvliExBwkOYQb9YW}E9FE7!>6RA-TiIxY9w!UME$s;Z|uwOPkYHn
zsE2P4f4yYc@(Z3t?8t8j&YZm(K>6D*b{BR`L%4nJP&!QM$RRnOI)v4h@1iQ8u4B<5
zw*Tf-c*M0&G}wAHlDmE85AB!z&{lA$<+y#>z{e?Y`;1*bpin8gj^F>cE@b|s4>o_?
zUT~<bAZYS*_!;=D+TrJLN0<0Vq3YYCecLa{Xg#`*5{5O{rw3!}dyw?0782N3@G|-B
zD|n4B2k3HP@xFrh*?o{Qw6EYz>c0C54iVT<$XRMDc!4_2<$x$6@<My}Z@)C9xP4A=
zd%+9EtBV0GoZrzG0njDd_O%zh(DGbnTd3_=^D#G4MU^<`<@p`o{=f}+JgxQLI+BBv
z3f@fn@ts<J0ez!ouiJXG&53yJ1@E^7Pyh%A+7!y(_AR$hdGIM}w6<^eO{aSz(r`PF
z20|BiY(?X=7rcyCLDf!eFYn*FKQa>8r94>09Z_UqS^EVqFE8c(5QZB{)Sn#+M%{fr
zXS2N^*na7uwhbAv<hQ%6)C1b*yiih7JilXvDG&PNIp}AU1PZ>_)mbd=_)b?x5OJH#
z9v%-Z(|)2{-0?cs^Wom`-Qj=ibbDB^SF#HB3#QvW?GT#O8EPdbpA877vnN?9I5~Mr
za$zq_M!jqmO!naPY&g9h?B^BsnuwF-0Gz4h$IfnPhy*W~p$i30LQKXRuew1@smaNH
zOvyT8ai*MVQHUPB?cphfy(lRVQWBCzJwDV65lzJrbUOKyZ%>m+qzoGi?;v?+NTkW6
z1ja$XB$Qh)#Ov(ny!DanXw|;4f+Z*SNKQ$n04MjcV;MdrrUBA@+vZ&MAB<d%L7@kj
zszBrvbYM2>jVh6fLzSExpd1bIBu5UkGADF$4vur8O@?$gzUdf1S;=U%o;F1?lttM6
zZ2O!PKbcq}ry>!mc4WmtG{ci^I%FIXuN<Ez>vl}vm__h$Z4jbn<{L&-J9|u1W91lL
z-BeoP$z#@T#9>8s(-@v?Mvn(^D$lgTsq5n7*n!H`*gGgQ9a-w0m4IE}S!6r!*gbKW
z>NP9?m#*`!U4xS*C(H8c@G=wUJ^Nz#Ia#h(LC*K>rXl1E2A-q1|7?6yyn3w5XKH$2
z=Pw2fdErLA+OwPw43t3-zsTpHf%<wC(MUZuCPZlK{MEhz_sX2C{vJqb8*tK!$<cED
zX3zoNTD_;4iQ}DcmF0YB@PS?(Zc$-DT)(cO(sB;j?+vC%26=V7!gf9~iDh~XGgj5o
z61&!N{%-$Cs}1#PE1DwAQtW(e7wQa*@UVBOZ^W5_@#rufW08mI8l-aA#5vKc<E@kB
zd}5%fNVq;yQS0MJ44&&T+p+Vhy-`==43AiGE$2)7sLsl452tF8aGho|cK&ICm3b9$
z=vVgrxRvE(Ekc7~+h#dm+naS{OT7x5ldTKu)i7@DIR7%?S9lxB8Y?QHdepu_t5$hn
zMFx`BSZz7q*jscHul6<+H`eQ$yw11wueD;W*I+QM`khg2@W32QEvC_9290<d7|lm3
zt)w@FIN#eZ=y*1G4JD{_0(FodOpr^w4L%+V^l$r1j6{{yY<msme4t4A{ErT!vbNgZ
z28Lrnj@zFj9hG$z{HS&3hQn3VLo6pPi|`+H!tvT4$9BeQpB+df7D8vvai~I6)^+g0
z?%Q&da}-+wm35;XpyiL_I&@z{W!-FhhOU`n^bESk_M$nKljKa-S-JyB(_YPTlAYx`
z$$JqmAv&=hCb0*ghN`Y^#KEKGgdD0jmGv8_`lwb<H|merUY+kTuK^)?Iy6vK))Tf@
zVP2Qx^me`r5w;hxEWl8(oRgd{(9u-Zo6uT-E>MS%eVm!PbO#WnkM%XNy$?M)f3=)b
zOk4+nP<_$MkDPu6{Mz<b#=Shr>F?Z%QH17jG+tJ-He4S?j~rm4z0M(Xf;SCCXe14E
z!n$5=bi68zP9m~K3D8}KIAje})(ehrzRVlC)bp^YmJ{@FAY7fP|IkaSjE!4v-t49J
z(IX#Duv<(kilJ3qhZT67y8qfQ^&*);$Hkb8Sl!&9ON|_K&qIqR(N;hWap)nD?j*Y^
z%lRD~Uc(&o?k_de`3yE4hSN&+SN?IY2AiNF+COj-#T3=`Kt^^$er-KA$ZDOFiUkhY
z*$pM(iYiO3cgAZV=xtcohyzbcZE%)rB!z}E+623BOKo&EX)xq%DBXy5QkxvQ_u^z_
zcpGNIN|xdb-BK4j4{NZmw?Wf{t4oYle+;EMoD!|E)TIW>M4sqa0f$)O#&zK;4se;t
z-%yU0$jKY=t|YbDc}vGU0_le<VXisBW}`mJ1Izikno2rdg2BOYGtsJ7Hd*R&qcIj$
z{1qxLg{rfMwpc;Lm`Z=(wL`bTw@_d|sub;)N@FyY`h4mt{DCU15Ls!FC}}BPX&JoI
zg6<^IrRw7dO*CQgqKafMiUBD!i`N6<MH0LyaL~O;6sT5WVRdHV{{+yaTM$6)ap*yv
z5XpAZB0_qqV?er-JX`frGz)WQ$xxI$b(W@0^O~qpE!Ep#uD5nWaYbZx9UaA~lMEUR
z?4TI?=t!Kblt2#~&c3Q%&+H*spN57R^uUHXS+VU$Z<&V~+)}3~BF1*I&{NELoa(QL
z7n|nf4Y*rD=1C1O5c-NaapnvRREM-G^^$09Z7gSlR1!?OlZ9?Fqn1<3R6{jHU8GhY
za$0Jz%GKCd!b&%;#h6noG%|q@Ggh+HdW}uQSi$Ss>etrkObs=OPeoU(4Tl>nHB4Qj
z6?4(0`Gkrrk)=*mPilMyn&fj-deDs`+w}V_(}8xunMy5?N>vuuj^qJ#YLKA22@dXX
zR6%k2rn~$?{Ha#hpS)7_UGbp%lK4~QbP4Y(eWI19m8iO6N=QEqK)OvemKgVGKzry3
zlj@KC^@yPYA?!>Ymg+I)2Y8hZMwz6Vi$x1BqA=&u-X~rp!RsMhoS<7(AEkH91>GCr
z?&%vreyyQWN$&vdH3#n=u#=h*Or<0p0TLqF4!Yk!PPY}-?L1hLD4(h_lm?_b$tkK^
z`aC#ba``oQDwzH`rZ>G*Ex{}FR8l%+95z(X(yDtp)ic(rR?<j{t17gF;v#vJdOS1_
zyAv$kVy`$<Plh<WMKhed`A|I@dS55wdUgJtK=qta4SE%Vy%74F)=P;GUant&s9p_q
zXuptGQ?&sn>X!PWi6Mg!oIzXawGijGFIKbRs<Qf-xC>Bd{9ZTO{XN{|qZegR2BT}S
z#8LZ=SEh&8Nz|;xtWcF-kJo0XH$u8yvW8kowN(CaXbFnkon%+_N#8`}Z&-l61WZGE
z5taZncO?~)>Z;Hcq)KwJS{q7%C)=VrlNe20e2}i{LnS&aW-er^4wHbT8V!cYYr1~r
zD80>4MMF(m6B8Kj7+3nr>q2cB4h4FVnObk0Vv;t59?<?UNyY$d3_Y(ASR|N3Oe&c6
zLO*B-7D>NwLS15XV2TRr(K#+PZdf2JU+AqF>ax%fy^@9n;zhpN9Ga#P*dJbDTB<p;
zQbRC6e1fhnHyMQa;VE~E0bqE{K1Q_|2$siR-&$&`0cTLQ>#F?w+Lme!{YIxTn<js@
zq-~);YN*JJxie6@RQ)G5?@b|$)^4d=(a|yPO7-77ASpD=gD$md(4|2Ybg2<}{H~=S
z<dsSiyl7Yj-9@56?V%NbZWQzmA5A3*UcbNvfzeZf?vF){nkJRJfIckf7e2~Uwl=HU
z7Lo@vX@MPdpM?<!x-Uzp{-^^TSE`mM0Q^7DS`PfUJk(~aWhUbh;ze!8MU})-jZ(fS
z{iw5&&YQ+)qlNUY!39PQf7A8eE0&p5lY45Dpt~9xoFi&GPS%*)#{k5Zg>_wCu9~8L
z7djjEAy9?%)KfCXa3@3U)jqT^#Jg0<ysD=S;(0Z6d*8g~Mm=MK1+ljY$~sr?{kx>B
zO$grH8dSdzT`kEzFUeMgo3N1F=O_GMXWYErHK_ieO{7=RSiO#KQmL0EwtCvwt5+np
zp!+9O2Ko(B4!V?n(ES>JQ^+7G{hC*|w};0OGqjxHX0C&yHy&`v$3DHuatEJ>T7s?W
zU5OjOczKNF4q?Ow62;ox&0;(5_Ff%nqV=ykl!0LHRW*$;jqb33-sGo1!E#5YXh+DR
zrMcyvbUBjiLt=(I?j1^+4i_wUJcqG*<7tU?;&glKCtuwO)CDlt^rqL@Sne6@OzB<6
zPEJ2$WzY+2gYKymm!I3=><Ra3ylU5SM{q(e^r+-PmonkFyo-^BrA-R<Dzf)+oNi64
z@#srtCyk!;3S1{eAMo^~*Wfxm?6WARZnw^Q^h#VO%^r_@^`zJ0Iw8A_s>Sg*R!XiX
z-jnO3+tgE&zCisrW9|E()1BlLC&&H_4qEupc5$5T;9QL6<_5iQ9d9=Lm_+F{yOuM-
z98LtykRkQhnjWR5*n0Z!V{%IDzEDW^-J_iSY7kDZy{ei<%s9MVd_(c!k%gh69|OYO
zXiT7%^C#nBdw3f%UaG|C+x{9l@B<a*fI4Lu<v8fo(IZ6A%IA5)dB-T~i5&+=e^r@U
zGZc7(0{+c-XV7YbW|lnt$}HzYgJV9&x>+8Gat;~1zrVHqRGq5h%k=8F@;);fLm4pf
zeQwYZR!^kE8}KrF3~C|ScV{@aI(q=<1;2BfK9Ha`2vd{Xu6NU9N%ZTgoI8x$!zl~4
zdY1EZeYQX~uz{X)aPD-T#)<&@2h7)aKE%1pp>r80E2J|(Q>asJ|H`CK&J1U>GpDzo
ze6u9458W*1a_1*HKG);7d^uZ;M$p?tC9s?p1EhF$^?2}rpsgmCSUEM}uKQXVPfn`=
z(*qw<3tZu_0q6;x*)>&F*vL3n8I@jEPdd0<VAJcFlOgtXw%GIv7p|ign-^W^r_(W@
zw%X6=gE%?_FvlaU=8!SyHC3z%M>a06)$ciWt}u8K9p<2uU1@qaYKvBG8oNrLWTD0a
zPf$MF>`!#;8CFm8@+)Vd{RQRAIIEnW*ssG3c}<n{0%<(2RllYN2O&3_!D4xlm9^R|
zIzP4PY=>GC>qmxuW}v<v9>l0->?VVaLTA%ece4R<Jv{Ptkv<f<#im0cC#%e(!@uRL
z>Kn0&w47b0fQz{M>^9EDeDu4=rZ?<3S?7C|70B#zZD^faO-7e`RjBmaZCbH7Su3ob
zbm!l47TJG6>5{c$hBL@b?~AfxmUA*)GjzE@2kTQ8C(GuvhPa%T!$);gYCgJkJ$@~k
zGt}j-6~sBCe)K_*6sX|L!E%PVJibF-M8ERd8SehKL6o};uc@H|J!XV)_s6`dXIf{Z
z-sm}5L-oWgPMi(<cE~y19i_+aD6a;X<%}{x#(G^}c;}2ZUK0Wy*11l$`-UD36LA(x
zM{{FcZUr13o5wet@g_vBmGn#MKa1@FsIcxNhn#Y^mTIq#Yj%NAwE{Pg=0f8{?<nAB
zPf+;=!=A-*mb*mwi?MC><bH9!y%EtRYe#=)x|)45B5$CFlPo7+an=CP;+nx3>H`_g
z^_Ekh%x;Ty$^gwY8W_zO-j*}V7_g8&LA0Fn)WD&X2W)|w@D6m`8lWTFB4e!kdi*dc
zHWjNZXO2Nn_Nw&5LyXQf=qVVkFkv{@C*64l?T4~qGNRY3J4@_EC{VKR&UBVI1M&MB
zm}WX!Ug}(`JG1506gP%f6_B~Sz!(rmZ^wKK>nt;{;;y;eIMEZyi0V@nXN7M_^*M}F
z;rvmLFR~1Ja$M=qk`iVCJBSDlDx69KV9$e{fqwASa;lumbp`ijOBHsm)Xx4^PxGR9
zXQ@3JWk@#86z3whhRTHIjk@pZ=0yPuQK#$t?!dicz26fM6|F^4SbM#WNxQ~6cd3Sc
zzJ<KoG_1w5-94reaYG2NDAXG%=NF33MQGxvsKHLEfQH*I)oHqMG5*YGy4Um~48S_<
zfSvnHOc`E%9iRU=_e<N;O(B!FUrE!`EP-dSEaw4}r~X{Q52{ym)nu}n{k38<JJgGN
z?V<CK8mcoi!mBW|&2JR#o1Cmscrz&<DL5<a%_w-XafY0=4sngkk%Lp`e6FponLX+q
zTHliq<~g828lJYY&P8Uz#31A66VcN4K}x_lXFH?3O9xN_{4Pmnw8ut@tzx#vRuQ8(
z_C88yj6t#fZ!%9BqKU^EGyqgvq8tNsqt#GTLBncP`8b0Gv2JRjTWRb4(+g+3@k(L~
zJi+5BwL7MXMvR6tyhEo_Nzt78(J{+8(_@nx;^os>Cg&NR{~k$aqS5H<$?H9xNk*+d
z-PgbkHp`jpu^r6hwwz*|LyaY0OJ^C*RD;6w@~bbMX(sYfh@4;a>6~pK*j}S_j(4$c
z;R#-iujE4$y$U?7Mn{ocHM!m=x`0#BR*jWBWmMVQ(KyMzd#rP<`v+>RI$b5#xyESl
zpt{~TacjeJZgbz%vAI@H)B9K1?@(OqDt3-JH2Ltz{$3VJY$ty(cLy-UwB7u-vrl*L
zAgq&~!~bIx&=_Wn9CvsG_+tx4{<`29JlEKY>ljN>Iw^A;<BeAE-;U}i^$rgrSbd#}
zYs~jhy*kt5&NJf<&7kiQSWY*^y#VWrDx5pj`qkXsq%hXQF;UgLx>~H-Qp`X`Yfyj0
zNubliKxcTXD`LyLRD+)Bt--EO+w?R8ouzLV7m|Sv8E7J+TTs&&iB@2a>1n`80R5ZF
zy$m*4k7LWpP#@`%PBq70PH#o0Ax>7VSH~k?PYV8N`V1J1IJl3o8nfBhoNSCu5n7tp
z6|3!M(X`3z3OY|IClh^UljZDHW3>gc`c`ekdgEzTfl0@;2f=>yh5H$H4<dVFCA~+}
z_=R>V!geQlloJZPKoQY$DLuf=3s+;MuAiO;fhD3AwVYl7Zq6Y0fZhS_0V!StyL7x3
z*Xa}B<qvKLm=WDKz-@`~N{b2}11AUABB87J(@wv@tGaWW5!*j-Ogk}Ri*O?ycliu}
zjf(WHHTD5yKG}DVa$fiD!=&ix(=KPf=dZ#eyz+X(0In|Xn_{*ijmsnGHh=PsmCifr
z?kzL)F(P<U!hOxRJ<euGCt@1s9nUQKxb@!kc&ea*P_fcql)q=tOb<VhXjopW*N^Xe
zrkHG}{_Ju6j<D492tBXujeHCR>ctKmXjAce={xjr&}u5^(vB6+W0+fz`e-KT(q1H}
z?TUX)Q;25*3h7PCDb8m$-9+|kXbbbXYy#@S>&x^M`VRxS`ZlZOeBtj^tdoOIz@cX~
zPN~t4s5dr78*nm=0jq7tDcE0Oy;6ny)Io=iiID}`xdq+#_5BcfBVW3HSb+EB<`}CL
z5vJ=$17dJ$IeIYy-V8rJ{i0jfe25=(AJHM`=6q~(&o@={F&o`+Mc7xh7Tv06Eq%~Q
zU0ka|;cKlxckH_=&>cP~^oAFwPWRYPn3hh^6y!`O^`inuA@ryBjM^v|t+({y9wH=<
zel!Qtn9v%O3~kOh8QL1hB@?^RXfkvQ{DUrS#)EoQhOn6UgD#EXpkBHMU0P%%!%WrA
zsc5i*&TPFN_G);2U1%&QOoyHY&Na4|&V`QX$Z2s9bjgSW-7{fXQs`vHKO&)DQ(>?B
zu6hDKx_9GY9$ClxJDm4TA};T6{%o9>Y4}H3JeVx!FUBLqtD!qM&IiT~<H7rngJvGc
zh-F|Et#w1r$NF5w*XuBP$P%xG4=Y|AV~wL@{v?(K`B|BB#7`b2r9ETNoq|%~eyaW(
zq>~}vVlBtL^0gQ_i}eP_PxgGXKQuG$5`Ax<)@^hkq}M>$1eiT23ePL33k;CtRpEDM
zmb1*byCdas!;mH$L{2g2H0m`sPw7o20SsL_fQtC*Z-l%PA$v}*iL9+?!UHmwyEJ_K
zB?d<|%DKTM)8%cV?Zis_%*S$m;z!8w-zWvxlvi6*0c-bDgJ1^?OJ+GgGuz1&w*NPo
z-KIW9sc)bk=aDtI*%T?mlh>F#w-~IqSCg-Qwt%AmlYd&t!P@RNwF#?P-b6q7aQ5g7
zJ6V|?x*Zu7%emD(h>~LSj55<!tKS!J(jrm@6Rmvv(I_Xws!<2J4hBdcOrTb#J)mW{
zWes=<vOSQO>ehhYkZTZ67jADXXPWT)JIl`G2{AZ;w!ijZcH#IH+Y!qi!p_hDI<K>{
z*p<<{PVd(2q3rJ48|z$q7(4n~Cs7vcQ!V6Rpnoe<p5$I$xze&nYvWrCHF|3}eKwB3
z^Mv}m(;lr4fOlGh^pegVt)t!P4#MQS4ncKkb_NHbwqnkd%m&NOrbwKf)?m5`XxU>Z
z;A+G@xW=-_lH(e3Y_jYes)HBc7{U+5Enme?#o4Q`L3Xl!3!g9Wy#Ub-uCwe5C~P;%
z=+M*f_dI+DS8Sr+#Mx6RH>Z#ns-LQSnC+LCeu=~nuUqzG_7~8Z?O4`iT;E2#r|PD8
zoPuuygpi!i-%(mm1EGYq;~*S(;8Eh0nzZcoT#bm99$7pN#XTcYjW|EDH|XOdRN|)6
zi)t-<BN=Z8mDo_R$#3^fr0k$38@Q=2);rOiDR3LxWnaQjXi$TBSj)06<@(PUOijL-
za@&OTGaK>Hz1>VT;OxvD`g?_A7G%k<rn@N6uc1fPM6#8Q%sToltG4}pY7fiC2Qa?2
zeozxnXY1dgAQ7aXf45jz7s*~tPAKpX8R5hS%iq=Pv65C3EW!jh)W6gydxuJzs@5;U
z-(a3f{%4yy`7za)y}RS_`=*S!FE~VdWvca&ox9c2b8{!=z7%~sx~!%8$?~j=c7CM>
zMWTz<#w{10HC|ONdi=?Ya#i1{YV}mrcaeJCdThtEqO&KT<7D+(-MCIYy7`~iO<Xg&
zy5&x_acVTW@w6yDi>FMxa!PgZn#p6QO&Oz7B9A|yk`Gmn9uvJrE#5Uvow`UZ&Q`-C
zs$$3EyQ6Oh_dKEc>`+a+f@AKxW<m9|DN(ilv5%Y}>IV~)h3B5p%JwC}6xY29H8GpY
zj}Mjfr*P+`23wu!J-nGM-WBeZ%2}C>Nu>L;dC%wV%lkdT<R#BBE;xRlmt4nQ<gn=3
zEc#GSU4(0wxK?F{7RJStn{CZXo)L?g^FZN?(adk3ATNuvLl<RduE-8;j*BKQxjZgI
z)03TwIA<Qwds_4Hb*zX>*HV^)bp1KfaI9#Mu6JrV;?nhDgVXi52B&L>!Rbm?hvGyu
z`m+Ilufo@{cDi)kfv;`N9{{yU_(BArKX>CV*$2lOyZb1v0qwnDF)m?z30{Ni#SH5p
z_(R6?ulU+lF<rjU;zGJ`_=Oaf!xXneBr^nE`0LNJ`1=aJwpGFaegy;#GDOg#ODVp}
z+Gz!Re`>`q@ugDI^(&Txbe)72qMD;?u9hP%U1u4bu4Jp?Ylz}Y(%4RY?FAWW)8%Z2
zm(rDk?eudYs*aVjdj$MP;cM$=)G8DsMd9EL&2*ipy%+kysVmLb-e`VYOIZ%mwE!lD
z3PD#QO`*)vb(z8Gy29Xeea_%?CG$l3bS2A4@%U+ehPc1L7lotCRH)e2!sWQ^V37iS
z$zl@1Qg|r%!4JUau=bVKn*u+?gb)3+Z1V`;o{iT(Ry9)u%?bX@5wq|V=q8;(KRES#
zqi4|$fMxS+C*7VjfO(FSo~`qv#eGQJ#iXYKeT42=SoC0KCxD(N^ntj?Fll$=!~85Z
zJ^$q+>+k?PJ%ktUrbiOQT~QkiTlDyWk6`ny*^%fG3m;ntqi@k86+Td-@Aqq-26|Y+
zhe>aFC9kmP-nWmh<+Dh70;dZ^H_m;CBSrd6kw)A$j#zX*y|br(pP%lrclL<|Gq>>R
z$*9gMI=g9cur3xoLFDVj=b!FH=^IXT$C`wKTCBq9#x>pWrn~vtmu{_#FFj~ax2I_V
zOt+@#9uM7yrc*V#1x?!<+;OHSiRqT{Y&_~$i`$fR%Q@antAGD?3~jJ6?dyA^wDmGe
z0NUtb2TeO|v&E-<oZh(5Zo=O>Sad^0pMBAG-M>{pYgcpfL8t3{;6^()b4X0vI&+*$
z3tIoMkPZs55J%sn0|#^ZkO>K=Gx)u@KKFki=C<g#fX@!-MkR7f_XSOEkHXK?x||KH
zj2lCAYs1ejonM=r(XCli19X?zuNXRq<ebqq(%*j4-5*_cx)H#Iq+=}3IPJDf9qWB1
z?Yn%p-saKGdA||p7N4$L+9UaO%R3voedQw-ZG_@?P;@WDR5a}z{4Ek~8%(8gBy=Y0
z*D@WZo64v2CI5JdPR-&gnwF+0vRO3J0x#x5J!*<Qwr;Rf=Hvf>Mmym-4qtz=@pYsx
z$BzlCW&v0=Kv)u&i0>a~3VcZ0FW+ItzV9T1<lkixED|#tKIWSteS6L_4<PuSZ0Drf
z{Y7wt>0GPyuXbcb?Jt|-tFOZU{d@elYw#IR40VXLX)Zm4j7J4vk?J>Ev-0yNXO6(H
zmqwZ&FHxn@ZE$pEE5o9#!w@YU#$R+qU{f$Zqh~?d0tpikmI7BoLJt7;6eMgEAw4g?
ze-PhHG!Oee1c_t*GbE1X5G1rZ!ny!h?@E!bfy8=0!G%-%rTD%HiE}j>v2fS`;!46d
zpnu8CVe{c;X%-}6UJF>a<1e}>q@TfyrJbHH-6GO^BK^6W?|WFJe~9$GNI^{Y9ABPD
z#UdTV9L2t$isZtWGZqplSEOQ*mWosiYtJE;igd9^SBi9<NZ*L`E#@i?TaUScrS&lX
zENv0#Hkfn9?iZ;Z)`YRUMaqK(V{ETTr@=%r78Ys0NV{N%*!O#py7%$1og#f8QcsvC
z4lz)qsUrOxR+fEV6e$fhi?Q=Xx>BSYL^=&htT#!d+eLatq)YqzdiRTTRHR?Q@^LJO
zMLG}6dyL%)bIp><^rbYB=7@B+NL7P<y<H+Tp{sK&OE3^vqW1u^)F0iSr8y$m!+orW
zNc}{bA`-n3n8R)r>6egr%=}8EhajPQV9capJ;_pkkw%JiHY5(4FVZZL7Kz?6!B&dY
zB)&fp>?V<Ri|^f#IM2Tp?6;860g%7v1bbbie?sD19Tn-A_%@F8OVkR9_1Z-GnfO*A
ze)dK8voMs98oGhO$d|Fzg54q5-GY&o!eB<&6G<4BCcZ>wSIjZs&!~h({AU{+#rVSL
zBF1=53__GmQziyy+$Ww71I80Nah^tu=fa>epGb#P_s}1FkO*{$2_x}yzky&*p+j4h
zh6JU@3_^9HY+}Gj%+&Knr<>OK8h=T<^XCoY4C1P6V!lZH{KY^?xGMV`{7p>jbE5-8
z4IN^<NYwd{(V^B<b|(HNCPzQ=p$|+jbg17Xe)<_5<^|QH2A!1R`7Llu6!FmbOZ=RQ
zcxX3G(Q!`bOpvy^jGUMwaSnN!j{_>U@Y+gHIQbur=Ymc;<X4w~Y)(M7cS3H0EBpTt
zt~@^Ei;;lP(eeLbd5b&b^%;X=`4!q7Fz4y#T15pn_B#V>@ssIzx~I-OR?EX1!j)j=
zp_}A*DBCCJ5oVq<eNLXv%sk`Hnm8dRlRhzKo>Nxgltp)&L}s2nSVa&s&m)VuU)_UC
zCcg2Oh<y_O=8|3<OL3wGBh9#UW#-v|G!Jz)etKwhW#+kh3{Hiy;wV|cakbI~VY@Q(
zJPgd41!kTw>*)?odR>@#h~4^;LNN0fJ+dM?zAnr>e}XA{?p%&b{!)Bhn0eN~^QR?X
zKkAxp7iJz}U8f(M{LoeJ1k60|FNFO>o6!eJa{jt7^W*~l0eYQ2l)o;_Jaou7bx|iR
z9bdfVB428XTTLGjZNyjpC@SAFbUG<*&$qqNa?DP<`UZeGd!O2j%eKI_W?Zac$MNUs
zgHFzCIs3Pj4LrW>8bUAs8^PN%N^)Lnd*<n5gT4VC!c@w5+uQS6jvtTqK2o^t${m=Z
zbsTN`2#gfu?A>-{2;igx(Z3e2YTtTJCQR(G<A|@++kq$+6n8Ac*|;V%i9VI{;<g{}
zft@Bkk{2``$_`Bk6#kk^U@&0@YI|#2aQpmknvX@-Ex-J)l*z}b&m4WaIXb=NyFr&F
zH9wk3W<NS%UtovtyJ|<vbN$;6FqO^2K&_TzgVL^k8x__3m{w2Q`Vt)ZsDg~XN1thq
ze2{<SD=zEtq1Troh3)IC3Fr&-{RrXXWpe-Teks1|G5Hqb+Y8^HdzQ5q*aP?ywg=Z8
z_#VXfHGG@#t)wgZdnLYOv84E)`BJ>C_>M)G5WXKF?gvbI|GQ=QAB7JgP2ZpHHu<uD
zr84^R{~Oo%^eO%?OdhWH(6o_Lt$l$@fTA;oa^Ab@^`l$qwA%_sdgcSl=o>?#pKnj;
z+k7lLZR<3|ur0m$SV6>VJ{FFy-&WMuzG}|L+$a4AqWwWaH98W&-_xUIh^wft<NHNs
zv^?u@huhkdlM9&+Xxz~+_606QK9GYWeWau2fLSM>J2yPIlOBDhIeG+rdh<Jnd%}Cw
zj<$C@zWe_8@wUKWN4xbP(TTP0Puuzz^p^aVV;4j}dqkUwz~T47`jfL?Yi%pGk8bTr
zOH?}&%aC?chIYc^@O@Bk-e8YT+xiAP_66nv)PWCQ3m=S?efo!#3^fDV7a&W;?gs6~
zme;sfXg3*c_Al0M7-!?o)$Y0C9;@BO;?9H{nYkow>!~_3=ZQ}MKHK$phyU=j)<2+1
za`x{FTn3G8#ST?PBgS^ivEgZ3>2AQ|)C@;bkbe#R4$z}yL`;3S5vM&BP1Kf(if`Q?
zefI(T=(Bdz-MTlD$_+v>?nEN_huiUYAKfuBg}7L|$?|g{*T4<>v3-GNK-+q9Gg9#0
z$OD}Lp)+dDBj-^6MBBo&v8{@ZYke{8$FD)J<=Eu3)~})5e91%`BHb&?rwo3eGl)U~
zK;MY$%{$VO^CHsQHrv**`kgRs>n7OZRXY+p-ezRs@b8a-y@}G#+0Pvtor5yjfOvH#
zIg9BOUJ_jd&q*&uKc)F(qCM%QwARJQYyOe<&<NAgw$6vQvCV+3!xfYUwMsKwh~MOo
zheX=e>F`d>-{I2%Z_Bmy%+vBMqNO|gE#ID<w)HL@e*q%XF&(xk{(bZkW=m(_x@Rx{
zkmim2!ykVq%vGJD`UiY<RCj7&YTDL2beyx`<T&p`NJMs8+E&`e?F-BopKB@3b*L{M
zMpVLJTI(&k^&3QMEwoT&uqE5l(Ydr%q!%{=Kp%>J#s=W<wFs|M=88K!8sS@CjC^@`
zC?%)uS3X6qD>MY`5$d)W{jT`W7XL54rLKuZjnO}--804g8r-l26qg<((Uc=;oHfvn
zc`e7fN59+`xE8*L?}R3gFDPzBzxXGJ%D5{(j<I7Mp@HIe?Z`_oIj2QG1JrzMOtd5a
z$fNrLb0pRC5m(Ex5oxW%VX#bpq^{N-{nNKcQKUXH`XT<LwNg@tuhXW0)=Bw?Pu9gK
zk_eNi7<&(&4;5XO{KMaTBkhg#M9Zh(7zDXl@WsQg9u<!m6JebHWeA8hKYqG_#|y1!
z9e#{gUro#Vs!YAmpPV^lSlN&hF&T~`Cd2XVb62#!8126AiaU@y`hX~HUp^)fe(1&O
zn1c)uU0cDM#7al&67T?m*A8Vr-q!Lm^x9fp!{40a&6f?dz%&Pqwr83rg5Qwr@%HjV
zZ7t71=y($mwO{)JM69@uZ*KXUZSUKjVkN!Qror|(hc5q)x<=a8Pw4ND$vC!rXQyp_
z5B(Tv+TXT4gUpp4e~98Z{t!hvzkSY|^Ff%`R{nCw9sff7r7q$jF1$IffugYhBzG^T
zZLLIl&6AP0`zZJMZq9KOrS)-&|I*j&$SBPX_hxDP;}r42_I8RHG0wlxF7B91v6h41
zF0<`gDkkZci*C+w)}DW%Rnn0KRp=cFU;Z7HJd$$xchnV`tgiirJ0PRiv?|I(dCGQo
z^5K`zQFdrH$;j#Lb3zn1l6>!LiYH~euD0UUOL26upyPRf#Mno~dD^_8<i$*~IKSf_
z9U`O~VC(OY4q6Z^DC;r$)1I&SDQl?~iMTS-1DE!3V4d7r2n>l9cdX_J+VfLp?aL1$
zkVTD6OY-*fa$(Z1Zim=>aW6E^ze#%hQ~ZVFLHwm$KXd@Xf{ww6W^wzq_rg)qk->4c
z9*^`wows}&PHQD~WDTk6MYZ7=<fi3bbodlh30kq`7}Pz=vd(?$bTlDyN9}eYwI*ey
zH42GRzxFzv;O$@Op1QAvob=h(Lj8$8eui7;nIJ810xj-n;2?)50)BqxKwC2j(t4k>
zrso%`iCOSJT!=q3|5AmWg@F6=Qz&jU$>CafwK<2Mp!RHg=J1bUC!ki+5z_IeTxb<<
z&kq)N*e1E*P)9w`nG~A6_(E%S3FP@5fBh#la*BP7;yf3T<QzYofjG(7e1+@bvG_x2
zQVseadgh5g2JxMVS5m-(KmX-NM=;>j)x%G7MqV|faOm<;=dVp&+>$)FcU@rR;w#2(
zt(~x9nd-lOT~*JXQ@zC#Ta(hynI2kt+Q5F*mzVXJT$vSY44>|vGN$jvXKmQBani{-
z)0R|RnLDVhd*<TFlP~C2e|F8Vix!_2P1}?`dR1Oz+~UP4<1cJF<IE9j*ivtQic8>N
zj~cML;|@+w{0{tN>lAAc?pY1Po503cXIYc2X}IT;XU()`Sw&X4wZK|pEw?JIRn{8o
zBI{!7GOGno;cUm#H`n3cjn*yJ9_tS4PU{})K|FKwB>wHSp0)Pj$-S4Yx2$*ZM9s(6
zSJrpdaVuzdw?lSsyN^B4&ay|?+4cl`l0D7NwP)Jr+VkyF`+R$;z09t**Vq@?>+Q|<
zR{XopzRAALzTN(XeZT!{`(Zq#_oV%l{j~iY{_V40vR|{`wBNT6+8^1U;rYFP*~e`B
z_#5P8KC@^*bqfT#byIG@^;GvH&vg|Z9Zz<;d7c~S);-__@ZU{xJg=LVq!rz6s=M1Q
zkP-+axd9K77wG1>Ucl?7y7h1zHxLMV=_%cULC2*JA&v@oLC*^+kK$6D>ziv`-%cYD
z`;M-kOg=OpI$R&T4}$mU6Y%E@(Hl?FDONC>=2rSRlc%HomXuq|EG(bTwz9%_rl8Nj
zshG>BVD#&iFSqwOOV>`Ln|cLSu4S!q^SW8Jv#TqK3*aKF{z9u~G4=L|ldQ9nt-*5^
zTXmRHM_cEgiSvcVA-$~b75%YXh+HtHX=KVMYp%6$06GNB&%CnpRs>R)TQjWQMJxMR
z__a*V2rQE3SD}~S1fZ`~2-fA$SZmmh=>;?Al@t`tnv1`)3KkU?<rU5?Ei1^IF{7X~
zKd-nTFMoDH{&@w9^XCCBfoEAkNohfTS>E)bf|+Hr3+B$qgPd1dPz10fZ*FN`ep%tX
zxp`&fC3!{A%`1dgX~ClWg5t80!dbHlN(yG;J2$_ew0v&i{PKd5#d&3ANF{GU;oMmz
z^U8}6VZof@c_n!zi>DXNDx5nP>V<P>Ac~^$(!vD=iwaB2N~af;Ei5RQJFjeRc~Mc}
zc?J1-$n6Y@x`c8DXF>kFq9R0<Us6DS%S(`G*>Z|}2J%XODb>O`a|&h@0z7vf%3V-W
zHYX3So<J?k%_~}benD|b-mE!!)900xEyyb>FDPA5SW;G=S5!Esuxug9jxS=(n^TZC
z6GbgRu>68NWOZg<c~Mzjc^TqF@^g?dGE{~PmCu=*KW`2~qdI3673P=am&_|I^)pvi
zIH#brEN@P6N#Puno{NL*m6jo%vKb}wif85(7R@Y~H)keFJ*#Nm^u>iU(IWF^&MYk`
zD=ekDm{&3bIYCn)@_FURRpG4JWhJPJ>3R9*mCRd+N}o3u^*DFdg1r3l@;M6%3l<j6
zEi5a{D=J!S?bz}EGr{8V@BgQnU{6f_I?%IxGFoC~9W){4?2bd@m=n(|#2lnLM03o-
zQe`2EIAT}uz?N%P*<nT>WVob%DigjA|E~yN@#0F!36dTudR}L;+S804MGL*tP3p!u
z3W*wWUrKbeA*=P$VZpKo!z|&<+E+Lyh1hw=8UVbs4CKTEl!Ucyj5)K#FV#*&Me85u
z|Bu;dci~i?J_&5J?me)~@oco}9lJLw7C+6yvoGphyB13mqOc$~TJ@fN8T{yX8^lJd
z-nV;WO2F@q1GHvVe>T4HY_#ex28^-Mst*hlW203E4b+K^R{hofIr80wjaL25pk3H#
z)rSV}%tosY*_WP5kq8^D`p6`f8OKJe{%)_=YVmBe>SMb|X8^yq?8HW^I*f<UMyn2+
zIAd(I>JtNXVWU+?44!M)Xw|1S-L7}CW-uGA`qI8pXQdMxt@@`4)`^W)ePut0`7Fjp
ztG>1e>&UvY(W-x$@GE>aT6NT(s8y@zH;aaiR()f)>Ly+tW205y+GSd?wi6qz`p&3!
zVxv{Z3>xv-xP&EEeQ#f=<Jr)ejaL0&f?N_~>xu>XxBWH7f$G9WtNx?IoRE!H9k+KN
zodh;oWjPOOJb{f?+0K6LlgLJ^9EU0-#zw1@^BwLR2pg?(o$Xqo6C17a47x|N(W)ee
zetM&_gpF1uJN5`d;@N0b50h9YHd+;OsNNFUXjQsV@5)B2dO9>vJF(HK-p&sp!uI-X
zwCW`18l9;)Hd@ukDb%HlW204lO>DwOt4=X-9gJh6Rs9Uug^gDAcOJkfN?@Z^15C7?
z*l5*2r<<;qu57fRe<f>h0ybLrd3u53{}mgpyKkP>`k!Q@bzdYi7{^9SjU068uvfFu
zx<j1ZK$wlz&2pZGBgRJS4t2f=(740{ApUcJagRYyz=19K>$7M#s_TJ_tRdKQ*E#9k
zC^R_zG#jnE-Z@hPpax<#T6cr9QX?R>5H?zOqjRYSiP(bJXx&ZDjT+Fz7KV-1z1VqF
zgCO+N<g)H1MytQD(Ylu!C=+=~V54;}Gx-C#9|!=$`G$?w-R!)hV;+I@V{Ei;vr!*K
zL`ElKqjfJg8e>t#^mfG*s?HwTVkINSRQdz2YjqoZ4+Zw4O3{9)G)7aY&!^Vl4^;cW
zi<Op$l9u9?D&Pe++Nq*T)yEN<XjY3CRU~^+3`n6xydDxSlHf&wgYGU-pjwHA)tQAq
z9XDt;T6d3g1acf3t=m)m8wj(}y1f+5!rWOh6eUlcMc8QF-UjQ$M(dtrP-dfb`{+oB
zjh23q;`UXIdS;JfqjgVKZ2Qq$G)Js^in>cHp{E!&TDQO2ry=weuxb(Ut2@9z=qt1M
zeQNqw<?cZBu~wyC63<5K4pJ#F>G5o|Zl)TpA?hNAjn*Bk@-+rFNM@sThp0-8Ody2G
zDBUczNn@acjANs9hnmEvqAO}PT6dVbUMuFJOUJR%x~HnW8lQnC`4W{LbT=T|DKyf#
z1KkQ|Dz!i=Rasm+k_XhOLBP)n2kTP>#p#>wa-aB9t*}3NrIKMm_*cZADyK_$U+FWg
zM6E>C6;nd^o&eHqs<Fhlu@pt#C>Yfr`|A-y1wz<D9hT}b<_EY&2ct|<&BdaHSF?CM
zAYLTF>tS5t*=TQqy9*nwtCHRa8plTKrX+n1B-D&3@O%AZkkjn|9=GDbqS<KO%1}=r
z%tq^WOD};#sA1e-`j?pA^iq{LHr%9i$~bJOW}|hxr&B#+t;%e)ZdGU*#WfP?jdC9k
zm0&gAiH+8MGQ{Dncsg0jeKz!gP9~0x)_u;X#<9`5FN8kQdYZJ(|B(o@(YmjOj%Yvp
z7?{~;-9MTbgpJmHEyVdf0UNFRy3tN#qjmQiugorNwC)=r-7Y>Gts4$4Ly?({*6ovi
zDV3kuXx+Z)^RNV<xl6Orx~oEMq*{ooDt6a~(%{LqsLmut6Bo15y7i%Q9TqbeW(Cbg
z>oyt;lUIz5){TbNX-!OEacs2iy3mg_9176!w7cFo#UyPAJ*53%l8gb^7<y47ut=DU
zh>h0W6gsXUSR~Cx>t14XV2X&1*1goYF;SUcXt<Y!hUt|wED*ENx|>6}8iD;WY_x83
zD6AnEAZDX=FE<&4`Qa&diveJG3;~MUVjx%^VWV}o8gPc@oQkp0x~-w#>NIB4<j<D0
zEwo=l#70ZKaw1BXs{iOwOi=3Cgwfh9^-4G~4(T8)=*|F=Lc<)4pAdsC4JvR~L*}>|
zC<u9_k_0arRzY`(C{TN71)!G*dY6x;k_4~&a6w@76fm}m8Z}KSc>#S?(64-yr)+Ij
zbs@+DnzX<Uy3fN11l>PMs6nU$9apNBC;<HbrnNlyae1iCSj$Ytr;8W09T!y+OEpR}
zMd`<#m2}=TMjI`pcRem(n#bRCz4wY`Ce`Gg+9c?%fd=P@+K!Vo=JrVdv1OtDbz1Bf
zVOEO!yHFnNgQkRVpOP^K;u&|Z_MwHLVWV}QHb`eSTK5?f?0<oc*8P2GrzHElB&*qI
z-F<$-|8>TFHd^-&+C;{&(Yh~7Y?_VMeMMpmx(84h=r>3?=u-NiBFEnpGDyru>-7$%
z<9Rau1GWq=b0ZuvHd=4+T(k;om9WuzLm06QzpIx;jg2bv*=W6?4ESuc-moOS$=7VO
z-pDlVFl@BmNn4Q|J&Iywc;nuuq%|9@H=e^7Hd^0l*l4{8)CDltFdMCR20INKt#<~e
z@3YZ*r&3&gZillc+?tKn8^H+?>j;$`1TpyQxc~RrXjO_n;L&Wfs)s!pIqex8KMp5T
zb^{gtM9j1*%{~);nweIG>>Ek1D>JQ1x2e}AeTuqLW9=uP)1BlLm1F+^2Q31zB~jz-
z^j=gsm~QgG{inv8&A-n~t0tI(3Sy?E${_XF`W`hvu?aJ+DzS${!KYmTwfufHE(6KM
zG1ICy6dxpYWu{esG9I0nY1P~QdOGke73P3?0?P!V*XzPetKKn+dXmT6IR2`h(VCz<
zGSiCsn^Eb)POCmNco%kBb;#g8JFWUuy`baFH0-qMGo#UoomPEr&^UHlRc22|O~lw~
z)veA$0Q3ex-KGyHs2zx%R^6_5*JN2VJFU9IxP5k7^>cmJK((ORY1N%hCHCpUPOI*6
z=$s~=omQ3G&zSTzJ1t&TvI4&j;^dnpd1j}@3rQyF_<VL+wZ&-o?6j)I05Nu2wbkTO
z)2bMDTGeX6^uUMId{;PZ5aQTr)m27?*=f}Rdkr$C*=f}l`)kQ$i_MEL^i{Cas;%~-
zQ>lpH$}#M;s?{7ic44PgR~X!|)2b^?FUM-fXQx$H>60y=omREkKhm+s*lE>58?T;=
zvD2!b*oWZm!cMDhGy^8aPOE-u(^-$ssbQy8KQmAqJFU9OU|^5azdcnq8z5KMY1J(@
z9TIhAr&YU50hygv?KVzkr&W9GX0j2T*=g0SCZn32R^4vX3dYG=Vc2QaBKu1!t^V!m
z3^m9d+81Rd4)#pf3}0^0!TJ=&XQx#|Tu#epr&U=lALW9Jtth+-?Kafqt_5x$W~UVd
zd}W$uO$~E-jQi}gYPj2u1+cKwsu9L5?6hj6-uU_KwBp2BvHwe4b-Mei9=nE}R*f=2
zz>ugjqF;lqf26EN8?Olg8|z+`?MC%zn8<WOYOKqx5M!rR<4uTMW~Wt)?XjpZW~Wu<
z?q;gJI$fD+fl+04TD8zP(T{z0TD8bv#7?W0yVFmj!u#yB>U{f0h|aLns_AM8et>1z
zX;r@BtN{>qS~WvmE~B~LQU%KFzJ#4t%`_T@omR~<2F$S2s`J!d9YZH}T2*8Wb|-dP
zHOHWx*lE>VgLY!4Rr3rQ$4;x3*lSRr7(1<6;^g4BgUn8=mO4MuojH!3R$X8WNN09h
zwamcGPOFw1Cwii=)2bD|A=Qt8s|x2LJ-)~?=m~PALrcsUJFTiT0QNw_POGYLd_r1%
z*_?(Q`e7b!l?XenT59K_48l&UE^;rSGNE~+?j^c;Q9!WMs&#&M&_tSQz26gjc3O3T
zy-mkND^)zqeV4itzscit?=}sKsQel49@CJxN#y@_TKz)NSqV)Z!cePzsb1Du#u&t}
z!RgHk_nMw$STxmrCZ-ret-4>@KgLk2ekINCGt{aFOum?*Rz0Zdbz00&tA4H6)DDej
zs8tWC=e3eB)T-Yo+DpYV)T$Ns4Jf=Y)T*^k2i$TDq3RrS48iqN@6ei`46$aYRSnYk
zw7pdqnMo4^t+=AG33ag2K1%Vk>sxh^_cJ_iL2TZt(PMjQd0<UaO&%{4&C7Noo(wR}
zd8ne^ZKqShDZ~gyzYK3G1?!|*=dmeeQbu~C!)i;dH(<I~NoT$0hv{mAfqQy*!4uJy
zsf`Bd<>58<O=0uas7(gN5~mDrjVuXcRd=z$dNWp7hyHJ=OALCFS0S30dUxxL5;tl^
zU3FLozs!^l+@djXvjJfPk+P+ljXPJrXA-Y8GwvCn5e54NUaiGdg!^c^>@CJ!<W;Vj
zPONTV5@n5IZ#})^O}`lvXP{MjxR;^ki2j|?D-62GptI^DuxnSE2$mXjfo3RCS9y=<
zGOf@#s}1uz+_q_Dm4%y36}rbW-0r;qWqpGQ?{+tD!r5tbZ?r++3a}n+ca6btqp5BI
zy;AgA1MFddZT)oy#GNM6B9LETpsqJQcO(4<<7KHEyjOMdxDOTH&`?XSz)(NY?WD4B
z8>$Ia%_J1+MvtaMeH*HYdX#~GYTzfJOa!C`{+WTF!%G@VK_8}W@@Ocitd{|lfh)~Y
zHyh+N+>rtkny~`6cyd=tqfFRgsa@X17@jH%ccvo1@b<z=yf$yQ_omK1?oDl?mpanD
z2zp<L+G8TeEvhEH(YVcI=#UK#^UB(a#_$6C%oZzOQ`k@Gz8Le^a>LwVGV%p#(on*y
zyG$M8*>;~(T2<QjV2lc<v>N5j984yGIi=NTkCzs_mdQ3l0CR7QQ(BENXeUl-HP)a$
zr?kp3KpdyE8fUOXPH8pXcqQ?=X@bWKVZ$k{&hUPudnpVsGtjCtJzgk<c;j=H$$5-Z
zT1_+>#6-w%!m`vPqXs%c=9E^GJzl+J@)S44IETh_N~@^`#e#|HqSZ7L`6%I(R%aUs
zD<-3Kj&1=bE5<3Ue5ebjw956a(FKg-lvY*t0yK_K_=wr;TK76?EzK#du5-;)&r{*`
z#z~yg>Na<sj!ihF)hhcoii`Vgu{!2##Q0#l|GjK)XkN6`59S^pCPnT3w^O6%8lO{I
z{l_SvF_`^D9d~%n@@GT5FiTHH8N5QY71uG@O`LZt$9VS-EVVIAl%ml>jF3zxtz5I-
ziqT0c&rFhN0ezFtQr#4H0Bi{2>7-S66L}n+v`R6vZj4S^^)OH;I%$<^&={SxN;6Q5
zPFjTw6i+9udKxf}P8#oK<SES1NvjNXr7r1IbAFANGtzOU)0s{hFK6WHo6(6*8ZT+&
zDW2)1@j^yk85CJb^qixrwp-DrA(CxFFs)YGKLzF!Osl8V0XRW0t@f(@Iwwppt)5nN
zpdtj*>KS$$g6X#?`WpKX!geQlsG1VEaVXgh^e0PA4fv~Sunp5&bkwu}7XX~hwN)B9
z+aNfY2(L%C;+g840MB1|45zkA&|HIte9CH-XF_9vU0qk-7(O?Om(Hl^2JOq;C_lj6
z$gHDg1jyQ=SK+~Z%KwG-9msNbl1HgfVA(L_pLT5NCKe&cRy_@Zg%DBOSgMzaImq3)
zcYwRI5M--90p5WLLAL4};NA)2L(>}X+)fU#d4=^c>_w_ypn-GA=BIz)UG0SV(FECQ
zfC1tNveg>94w;V;WUJS`e5}hoeE_fao8=X@*t}GI!vLBfTfHeZm<h7gpM1+}2(r~%
z#*Sflqe*Zaf`_Z#_BfmI1lj5xJxgKVsR^>xyB_yPln&j(UzxpU(9Af3Z1uipipiz^
zvz{(#mtY9810#!3pcp|m6;J8KVz&Vol8;Z8O`AI~?BeJqfh?PjMuOU4`sdd|h?Sx~
zv*{TZO_r@bmoo`;O-+`q{$U_PmaV?<k4`|AtpW}`O4fxeTXoY$F-De+N2BR37P3GG
zNq7^TzFkY1PuI^f@iCz}Wgm_R)Af@}F*tP*MkE5B4L?3zq$g|m9%IlwUx%P)hhpcA
ze9xDnOr-}x5Vk>U(UU~1rSHSg(A26>xIruIKY;>0fB=Qx!i!U<M}SV4mQK(V<N(zB
zQGxqFyMJ$#fXK3G`={?cAVTu!N0U2^53NDT&{+{DLnn1{$;6(6Fc~@r{&<ZjS{%1{
zu+<B?wCf1EG@gU{Bq8Y1o-an0t!C@(xgpC|g~qrVvTSv(nOW%Adb^ICY&Pmn|2+UC
zg$|4TQ(Gp>R`051BgFu|C&vngEL**A5@E7z^=ISkN|vquVmu64w)()heX?wI(9CiP
zWZCLtebj4Mt5t{5gH7hG`C-L-bu8ZW4&#$p7KAKY9r2S#dFco%=>A#P0F@0*MTgbC
z^<qM`6t!5NxA@7PZ;q?XQeuhATf2C&Y_-%JiTPyN>H-58vTU`?xQQ(LO{CnJEL%0|
zBLH5jG?@gLEL%nV;{b%5jdKDa%T|}WG<^KElOfAiH@IZR;>fbqPy7fu{u`wLhAdnC
z)F3#J)05rL%;{DN&jmM`!!LcRD`eT~W>cg%vTSvW!D3|DYM04BEm5(T*==eQ7L>`d
z)gGPUc(QDDtGfjyWwLBK`RR8JoL8V&GMH$WkJt8Mz1NS%I&H4CA5ms6g8|Yg?fNv@
zjoq}d)9z$w(c%zqzSez#Rt$KhCFafnc*VwgFh%Cm8`teLZ6h&|tv}KqeC{3v0&LJt
zr;#xz1~3qu&S{i|jc^RwR7RT}JN;3pd5TyJ236=gWp=+;HALJ9gDUi0aC`WNtcByH
zK@~-KOPf8egOxO5-W_63`?m&(9bphwtCX+V&S;8%4+so0L7%*m(kDi2E!;-=)aHkB
zF@y|M564QOocE(qP8rd)a2eh*?t_#S4K`URZ$Q?6`q5n`O5OMQ%=Z}pK2zRUIv49Y
zdJSowj4Js9u2&;-s3YfMT7IQr^_x|KKhDK;=5!|{<kY!@viwJK;MFDCK|cgV16bBN
z1Rn-k^>cK@-?@NJ&BUL<c-2)6$o4;{pm@?8pW!}(Hr~(@YqdHZFcYbb!#59_Zy?GM
zXtg@MAlzw<KwZ~SG@#G6M*5M^(^CA-lBlht$VKoHd^bY#lx)j74TXx@CXUl}p`x}v
zNsEuBBwDABi|{g^W{#&Bapa<{9z;C<p?DhjJPH2PsX=dkn%<McP2CEaI!(yAf$0_T
z&fqY8%;H?Gv(_VkN<uwu(XKXfH5AlU*VKU=zeV5NI09^x&f`|C(;buDFdQ&(8FdCg
zOW&&fP9r}YYT+$@G<{wN=je)+co)EOeXwLXzqi-XM6df#(il8HZ;eSp<Ebs(`oLw|
zDO4=oU50Dlv03m9_Ux}cbzhtTQFo)|c+4K2&Z7Aoasn=XWK|4NWSwHj;Sg7mx2LEo
zQz)3GA9t*qA^jJO<Kf9;sxGW<Xc$vdS6Lga3gcRfI%+}*#+Z@5nyJPSM<n*}J~GJ9
zi5C8^5R|X0T4|`tE9tIX_G-NP2=Ripoc`jDu6onTRQGOPv<1SsJA*C3@Oo!tFDJX#
z6~RG^T}P#E*)bODwq3#3s-tS-Kh=)QoT0YbVLP8HyV@C=@zmq{_5^=5E%^4YUK&(A
zS^d!puG*=tzAU2du@?o$sD0KVwezxwGqhLrlH04*Th<HJ>VeI>s((uIu4*+C-?h7{
zZ>?67cI~dlt+jvd8C~rR&sey7)Y+r1|49A%vbU<$e$sr|+NF}GRy#v_y`#Es2~JZN
zWq!3-t)1$OKB-zgws{wVjp%jW+iK}lb)CJdLe0B(bhWx+voqQb_P(xKh3~BnUK{Lv
zEyPMn=>zM9U{1A4-ZfYqzAU&3H_oPlnEhVWV^Otw2buoiGUW74q)8?C(`ENot3JrY
zB7BQ?sUbn+YU8~RAVrlqwOakh+O=nJ@II6bc<!odb(_6wuWPGzL{dEnwRnXS%!Z`8
zJLByg)5k_{o4juKlxZq?i>jTfG9s$!F_oGfoI81SaLnjm<7w()cJS|0rcIglm*C>+
z;73oW#i;b)Il&vFZ>v*+kDdS3i|dXC&v|O{p!F&x_}FV7y%-#`UghmlCkHd1R7v+f
zxcl!@cHj1jx^;7K)p_b;Ytccq=AS#&`a^2Q7Bw-V76cDPgNs%FEh;(U;1%yDW__PX
zJ;Z$eh^uC5pA}<$|8aKc{5X#FnaStHXx?Fz^@nV5VbFw)F~(mS7j9NEbci{RK4c+b
z;Dr_bT%wbQ+xI8)cOw7U6c`^eYkOg}yRgcKK~P_qZ8<BlGo2S9e;Sv5Ub6F(I5zm1
zlpQReVGcmuO;==}WTNx59@BC(NY}kuj<|GvRm;&JU8$}pEH3f^86@H?rpqH*T<|z9
zFSCfh@;MU{_}A(3TP>E7B28g&eC8E!Mm4l>9WD>DNQ$qph`;(n)&DxalpVUh!E%tU
zC!=h{NKV&GEk|6s(v%s`R8DcE0!Q|Vry_uIK}^MEG>gRlvl`O~P<o1`14bTV8VvS$
zd?6Ca&!;R>WqSAm&BSFai@CVm$>PJfe8XZlWQ3mTgl;M>lrM<Ljs8%!4&sZ-qDvp0
z!v&N>R$Ks3e+W8D`<BvWI*W9f!Qz?dFSGF_QvE_)&&L;)y$YARS)|J&EYjs5i*%uC
zfG%DKrfHQRQf<t}m#F9qab1Kj;324)Y4|$UxZQLu#24@qT$)*=3)LUc`*C?0Uy9><
zTz_DgF3GxfOMBsxjW22B;Cddzi*TtoFkLTVm@dsMUW?21EIxwEtN2nJujBd=!*`&i
z9@ec@N|!fSq{{((N%=!uxjjp%<%rXkiZvhC^L5jeF306U7B9x-DtsMl{BFA5z%X6z
zV397|`lWjzKFugyj<84_fqDRHhAtWSQhIddwl4MC`UnK>tMg;cUNTkMx@14vjCu1*
z{sGa^jZ<<8F4S)5OT$pd7wGCPS&0ibNXf$x|HG(4Em7@5cL^?3%Mdr<as`W@;X<7s
zeRU!()cGM&{c)X@SSVGBE?Eg(GPPJtLxE}&y656js>PB8xKL#xiOX?mXK^PkyI8y(
z7pgpE1y9>e0u3O<L6>K>Sn@nBT$3d<vZywpKo_pP62JEDMhUswjn&<b``Y|;6o^Ya
z-`Avm#=U4h#moa%e94Fp#+R%PU9(sY(si_!qd~gTQaIjFl5x*77+v#O4$^gwmZL$s
z()u?(92xz~4Mx`%mV<OnOCjB8kgg#uM_ju8!r*j$z~FSHg<QP#qqwJIN+9DvSDLM8
z4E%TY-aWjk;(QxkYt~NOKqNteqDI|lIH(v1CpksKAqYrdCm{*vV*()}iDYjCB!DKd
zY?rY_QPEPNmA2Yqr5;);T7yv0R$H_lP^_gb){R)}sT7ZS?|Wv}?6nj6UBB<WuJ3x^
zKfVnsbI&u+oM+9<nl)?g?J&DSADj#{7$gdn#>Kd(Jp$%dDK4k+GcBfhSc(4v<9#hY
z1Mv=)aSz<?mGZ-g`z@K5f!k?v*FWN;!Kp7GceXNBfL_#q{^-0oAZ8T(aRGWU{2HMi
zz=fpKP?>L;;yE)?1_r*8IZU^9pX0f+aH!*0o!VpytB@WjPo&8t(j!e(f-MuhL{i5~
zrS$A2lMacZXqo86bO&O2OvVKA5rXf?T$eGx@wjZOjNv_`AVXtXA@u@S3LvMv7LRx2
z<DmZN%Kw<gXEH4|4_<u8(z3);)GCCbg_G*W)Gc1NY*NLzD!g#z?=|!!iKv(Yt!i<3
zP+`ra!L5~ApqVuIU65ASI{c!^lgN|k`B7PtfL}s+0^cWOT>A9H>V$cIyW&ZBa6LaD
z^4qzc+SuiLYBn%Wf(^*>y(zbcdooEm!R_Flz;}E;H+p+wKNAJ_?Rs*3nm)fCXeZ*P
zUr(e0^=*LWUf^U$k4c03gOgnn-t_ike$|nzBAGP!;fN=e+2Yp^eu2jX!hLgc0foD5
z2_%ySH{Fs+gFBI>E4Kw3SAHZ+CJnBRkx7H^U$~`~`_jm$!FP&e)ZiK@7&Z7cr2iy;
zZk6@hxkTt~A>%4MUKmJ54X)3smj@PCgYgA6m*e$20WS7(S<&K>qqn|jaTA!_*~c|~
zu3?gln+sg}RS6e+)$2ws?`qx(E_JE(0<HpUdIzq2d8`k7VTyG-Y}w(OmPGQ6Ip5c)
z1r4rm@imWR+TeS7E_E3JD7U$?tnC(GM2wXjo?J+iZy~rHlV6x4Q#ybABwE*(dF4>)
zyZg9-%gZ2l=;*v~1F9}F?uGS=lJ9L*4!An)ad2>tn=CDEcT&Z2pUDyzadoZ8<!UbH
zdiEvUxW#SAUbS%}qpS@sy?V8w7EHNG&y!eOUsYA19JymlR}B{=Jq`}8MkaA^@Ex{S
z8{B-LD~Vf&RL${amRG)fMdvSjzH&5nRt|rB22=eSIyn9FP7R=y(+AEIIQ8JHfYZc}
zae2Qm+&F3QW(=GXQOEn4o5g?AB~f+gZ8Dy_udne$vV-(2|Hr60Owpkk8_Z(-pV4&a
z^q1DwR$^n#l$smy!IGlxm_NUwdcIu9nXgDev}*DoWC%Xw>d|y8`&foV`m~%MiZcT(
z$V!#`Yzj?>y|a{68??co+YP$cpa+01$CYV4Vq{+%bh+(?$5X~t$kPqt$%{(H%?S!E
zFsQ<yDuZ}nnbPBtjtWH#T5ZregEkt}Xb}1Bl;7J8+HBAkgSHy9&7d6y?KJ2igLWCT
z+n^^5+GEhu2DKV=z@QflddZ+e2EAs`VT0Z==%_)*42m1{p+O%T^tnN&4Eow2-u|kr
z0tN*QN;4?KpiF~$8kA*F$e?V4NZ+R7Ac>no0}UEt5INkG>u7`W4dVIY%9T`c3QaL6
zY|wOrW*9Wbpalk17*u7@a)W9OiWs!opmhdqG^o*_O$Oa=&}M_S7_`-(Z3gWyXs1CB
z8MMow-3C2j&>n-HHmKF00|vcd&`Sm#GUzpf4jc52K}QWbW>DOq4-NX*pwA6DWzg3K
z;Xy;!Wx$}IL1_kM7?f#HPlK`y3K^7bP(Opl0QE=jm1>n3bc;a`7_{4<R)fe$q*~n=
z43;XCq6ET7sbp^gDZNWDGAh{!gZ3NrmO+~^Vk*6#8??`$S1|4>*Pr4c36C>K{i8s5
zh(WJB15x401?cAny=71@On?VU*MUGPRl|UCrL0i9qBMX8N!b=H%e0OF4VJRFk<Co=
z!n+-4h;;oe&`^m!1R5sMS3p-v)Z<Jq-t&Q!3>mjD;YL2j;;%~81cN36VbTWIALH-E
z5`7<Kuh15hu0lHude@+%C^hBEg&BoDHRxM|x}Z#z>v)5>JfmcPN0Jo!mqBNs43w<9
zLE{W!`6<`=29=-;w9KIO2Hj@Ry#{@0&{ud;QhryWpcGn*hYy9C4EhBgB9!bIgVtk4
zs$|nqj0*k9pghd6m29;^?-}$9%wUyk*K<5{fk8VB`qZG_nAj>Gxdu%$Xb<M+%Jm(C
zF2-zE$*wo(euKtfGOJv}20dlaTLxW>sjJeP5c1HC20d%g>Rz7fV+Liyqw+i0pz2FJ
z*;<2cHRvsa-ZN+|CfF*Jm_hd$^dp1*ZqQY|Js)2hG^CFw>w$*`72Y=n&AZH#{l=hw
z8T9$(-raM`ps#^Y{J4A0?C+uT47vgcO&YHG29+38Y0z4OnhkmoNQK-JosbG8%b*aD
za?Lep7?8?QzL6CgG|Qm*K&UXJ>INgb(a1I#*-wE~ygxVSG2{AABm2ale;d~>=q^=S
zh61TjMi`U_q*A}hpnDAZsX>ndsZgFWvNsHR&!8`WR2-erIV&Ii3@R|F+@NZMZZxP7
zNQLq+N=G545;rNziqCFJHr>c(7+Ir{Z8EZ*M)r`A9Wb&NjEwy=x)a24I>eq^#d{hC
ztHir)XnDWeG{B@&hG<#$0&$N@Lh>La<nBmF9;Hr_<S9tFKP92VG;{k)Lh>3UJI?e=
zjzV$>m(uCTpT*~0mT%(cXRQ$sJM`M_=Vz>O;C4D4dig;63rHQ#0z3XrX%U7ogu}(m
zrVdI0od(v3W0R+*W1=#&2*Vt7(qLmfCI5H~5Pv~jj!k}=j=z3dr<2sV4u7@4r#f7V
z7=vSzm!_l6L@nwfbwc>tG5h6OCr#?)<8Q|w*=P7ewIVLhCPng(pM?g^13DNWPxGrq
zIBE^qOUbQ}gpf@}pwf0fb&@1MgM_Q%37uyM^-uYFwS(mE9VGwmAW<7OR6r`6bA1J*
zV80HMVI3qBI!MTH;QbV==^$z7Ai1Z5<VQ)8U%~c&35%A0|J;1J_bq40@F7F2`Et`6
z@laswb|V}HsJ6M$cBM66?w=zb3>WToBOY#%e@m@o{$G;I(=G*hRABzM9G=X);_w8C
z_ZyxhX$i^`mPA%goiq+#0?hBQ9ObFBXCjj;j`|}rPe;iT<YnYIGqyr}Cgdk7Q_B1<
z-l(YK#`N-9d#PM{_G03Cu|Ay46XBCJWW)Hv$A7RcTd@@EXKGE_BR>my>}Nv<o}T?|
z$iTrPhLHTs$A0$0cX3d)yrnv_pIMkckH@_czDeD4--i*x<sV0sOUJ+Y)cfCLKdZpN
zGafVXq#x4Jp8c$G6jpLE!(Mr_(v<x&^#%`2^7=Z$>tBWi=sT2Hc39MF$9^`Rz5Oi9
znxgeCraJZ7v7fEO$XYNjDGH_6j{U3-5$&tRxQ#OA&&1n~{cJe~$RR87qPM-?Y1q$p
z+-O-(XgwrN#oLbkY&Rlmg<jH+`Dn*}##K5WWuj7to`2k-5D!__Xx#>s68=Ij!4|e3
zR18-(wMGWJgK}G&POcxAdos7}MDUu1=hH@vTz^?nkvlfc9X~J-D?Ju2i5~!E09XOs
z(qm1ntB-JXkrWDwHmvgV+*XBFnefwMZ@9%7F-FqUose1dN<3U#5?_x{Hcrj7V-v_E
z;Z8_H{O1=JBm4@uxKq<&2WJ$;X8_06r%8>TMnh6COzkN(hDnW{QX|V~gk%_5QX^Ap
zWJ!&X(fAhp1@8J#Z2ye%I9XC+^Fq)t8Hw~^`pZgU`x`#&i42Sly7^gQw@Xp{w@`*=
z!zp{ig$V7uhUYV?t+Hy%J-;OWuySjz1Zl(E{qFhAfqalJK*KEwHV2+_tysaw;dle1
zF8v&V*sb6m>GWK4!N+BwUMPu`ejZ<v6omhDdX=6x5Firud>|YjB~{b%!zE?$0l+$1
z?=*j@4`!97Bhjl*l!M(3{1hcUi{k;P&Ty~IDvEyzUWZxWvIxgN2Ab)Xgo@+;0E%U0
z$KQpC6gHiVWW_#n>#|Rd%d{g;GmL99isG%x^~BF~oMhMW+Eb<*4Z8Jd)&0xj_bD~h
zeQV^BgVqW(mDuXEgZY8QM9;-Oj=u>FvRo+IIRsxGuh3z~Pn@~g|4R-(li`o>g`a=W
zszj)6LC@GY5Z0u*;Q-2eT!vea5gQkB3$kJ*nX#L)V&ej_w-NEYq=+SZ6!KP(5sn`N
z7fx(+cARWq^WA9AviPe&s&VLaN;Zzuq~~F!DDyk)pj9E$lbn()CJ-q>GH&WAQ}P--
zB^3ckQHta9AZ04bRFEhByg50(44Hple7OfLmZ~r3GQ&N=?jcK?nO@dDs`B_rkR~B-
zC*lmhq~XJWY%!6=vZk|(;=e>W&2pV^{ADPji3Ez{`+?Aa(u(5020{Zup*^aCIXSMU
z9ZidY&S&n|FCM?2LbjO9qWB%akRvMTv;kIv{c18XKZ1|-F_z=g{+0UGs%O)~q_tUb
z0)%+ReyDd*PVc&q;sNN_SF7~x-@Aza2lnr)hz3HM<sj7ihQ60t+?AYXbVJ|<2=Rlu
zyuNTHbD>wh{oQ&bKh6EsVHW2Zpc^{)9YX$^PDZnkqq6uPaTD=2xmVSI*KfGx`Jg=e
zGkVOjtm1I|KCo&b$FYJ#v3c1|M<ShLbwPJFQ1m21X`Ybj79MJzdpKP66O3I&<t6bd
z=>fe|v<Tcj8`p-dNEJ))!jgEQ3d=1$R2FUy6vKJnQK!V66|@h#`I!x^{loFglu8q5
zVkBWr!E3okp3lF~mV7ari;LX}+2~&b(8@i6WZ|Z~|9B31N7c(9p4=nl@%KQ6CDZ&8
z!%1gHT6m}gv_j?a-@!>T|D?HN1L(%xg4f)$kj=-mm;G*8!0o!{K4gY;M(K@@p~%pr
zN{Wl1d#E`xA3pZ|&2c9N?ccebi>h`*vpilWy=Ruhs{v-Xa}UibDUZ*S!Zf!lGFntc
zCc@(QWG$<Isk)5;R$HL6slK2*o(l))H5>@B$kLl$MD64rIbIBdr8h5767Q<~qO)`-
zgpmDKbf8~?{E7`S9Ez3oi`9m5PaeMrUiRFI*p81!&J`htB^f0wHqn}u3s<fQ>Gl@7
ze&L$Xike8MYT>HN&<)Xr%a<)#2DU5tndXwsix;k-<6?OlrRS$ERI?(qN`2WMig5B+
zXL-T(o*r7b9NHCYLY1qR)kW&OJHa}ASPZIe4Q`q1RY+F*IB|=3Var%6ZyXuwUBb4W
zoHore5}G!_uP;-lJp7Vv-@8BNkgcn*A3K`*3^y8byMvagaXmELX@OUcN6L$fs|Ml;
zz9hFTz7?EcDB*(z2N(kCqCDONQEW(dydLH(bj#s*9S}O&?6UYWAoqK`+1Nafq&I#A
z=-peff@8ntWCKG|>c+JfT9KUGHXZPZA0bc8g~wv0yNb%u#Cstew&8tEt#0YAH7}od
z9qw=p#|j?`mzBhA<qkI}6h0K``JZbzDz-(_-L*k?L;n%0r=&M-LtKm}x|MCHo`J)A
zd2{`1>UKpV{k3Ey3z=}v3x~_f;}0sHGEbV`G#x?1cR9Ty_6Fr1D`=I;LjuwpbD^?v
z^$0660;RVArFZ-p-FOQR6vfH@hx~XYq3%~%7{_P9qq3_c$}E-_$1l{89Mna`n|U3A
z42RLp*vb*IrYaRpdHkQG7b|=SbYHQ8r;+yNz$CZuY4kB*HQQ6p2~go4cYILwG_8_g
z40AvfVB})Av_I*@E@1F&(PLFH)_#1O(m9?Av0KnuRDDL(gK%gYh@yyZ@CA_G$QQ|O
zVQWKu=B4hKo{=F4bl@I-mjlTK>5Z?$8FheZR=Dal8Fs$(9@2R`{vhW8@SMJ-;PLdv
zWeg1w7PZw*L0rZ0v!IQn#tL@2lY`f__KX!ijnZ_}>{!8pSm6^5_5G|!s*7At?AcJi
z(?%#yN4o4mM2H_wDSNmCh6I4)t+g$eHHkL%j3gEFk|1j`z3Dt8MD~9h>z}4a_9XBK
zFKy8$*jb%b5^p@6$G>76*;xO$6*=QzK_)lv!%H|^-M=_qD%CND98hsI{t~LO;mF;p
zU~&9PxFTzA{Q*=@?3w`U36<m)9*A9&<<_^l*G!3x!R)8!rZGVl=KLAycemzm8q-N8
zDZ4m+5=3D1jpDf`ZRU)&XjXCjZ;C4{c1;FqGj<AY4Xv5s;`r|%kL}gBCkVm%BPDD@
z-$f0ha;m<Tb+c1Zi+Oc(29!V#w@bQhf?M0Te3bt2e_;l&=MqSd_kwrd_?ykaw;<@&
zWx2y~H<iK*W~Q;{LERQV#q3TCHfOFv5Dnkj&6%&bBhwo{L4h4CIL3kJDXhE7j>fex
zL<BKo#{kt$CW({(&fYzw=EH@-a@;l;+p0Si#ZQ3q3_}P8-?w?km!fzNOHoGbAiVz8
zEewV+(JzWWM{=~n;EY*im>)@vw5mgR%&P8G9{(}yco^s&D>zyVD$(Nd_!g;wIyhSW
zEruQ0d4$X3^$?@~3(f@9^9|AyhO>*x<CRi9OFmF=fGevWULFstFucUe`6n{W=JgcU
z7LStvaz#z3F1onN>%&#ojfr`Jtr5LX!-xG5DN=|2J67-xXU7GHkT!Q9Ir}1KxdrdU
z3W7SK<A*;%k&tEXj|7}DMBjx5izh#T4jI_Z4~Am}hvSbZ4NRBZ34x~8^|iT2PE0}J
zf_1M9&x*~X^Y^{)6cu3-5_AK@!|{3(B8uiPNBQC~-Np}BUCdnLUN~;VyZ|264mW&d
zZ+HYjHhgS1wMBobf;_RW`H4O#0?VyG)YO*VGzul*mLg+E!Gu`#3RY)P|0=BG7tyWo
zXh})9DBjFI1MRR2WJ&Y+o*dTZVx&6qvDCoh4DQ_W=D=*XOg_cw+1As_Sx)xzF^52j
z#Al$M+=-zPZ$&17dGtJYOg|8Or=Pf#&lhgE--x#(m&OjE5I;i+mc(!4tvxl355Qi{
z;-TmTFF(coV&Q%#UUy4ihEBZfjlXH2dc@cp&ER+u9pTOhVLsXE#6Wj;KTI(%1+)0L
z;E0c-A7ftbmS)C#Aem^rf2F(=bUGb``rEkQ*wZU=!7Hvv%#`aa-}58d%grBh96VUi
zDvKC5RB6wH1y4&$aR?7sO|>Y$SZO1P0gq!<p}Fw(STi5tPjquj8(ri<xxEZG2#|`g
z!BGWi(Z3OO8dZ=PJ?xIn8Z|Z)>FPE!EVn2)YHa`La}D)r73q!qCJVQkd-FSp64^K#
zVd(N15zdNibMtw>e(n}Fmb>4V-gC>UI-?ILiD&(b)t4rxil{;Pue&=Dk1YZ&xvlOq
zOeQy`qbRaI`x$O{J|&jk?v{pPrF&qF6+D4}-CG!Utnek=D9r`CW76st_C!izg}dcU
zDCnLQD}153@F*s_@tq$b69vKfZY`b@?xm%)ab~P3g2-mO#c8fAF?34n=p?g@`j743
zxQ3ji|3Wd9mxr4RZV$(2LqXni=}p}8!eV%mp;QOUN{ZrnaOD%oPzHl~K|+y%{4{rF
zwmVX0_DbBB8{<7>C}<<;jbAb!&#Yr1M}sG3HJn-;o$Quwl*&Vk<0t-!5c!zM^1)KU
zOe~+cO;kr}{{TmnX1Kg8z8}!7r#HKLXnFhz=@Qy3A8gVa??xnUeRf0J;`BzYnYp*h
z;#-~RIt`~#qkJW`zL6xHjcYlspIQ<9Egntq%q~-go^i1ZP<6ULEov@&4KW3Z;!{)#
z&{>zo^A&C`pqu>1gk2`3ndR|b07woC??`&n3giIo-7Qo(tt^V$bZ2!RLY=7!jiqJB
zKlqT(AJ4Fi*)x~R8hjl>)F8q#jk#$s`VMz)f81^;cl4*Noou&oAlA-aq+p<1`gEsm
z-W{#-@7@%Mc}39l4F)_}(D%u7AX%{{@^&I8sD=tgh|*7#eK91l=d^t$mTqEqS3w<Z
zZ8&wM#cgH?STQIL7nQ|BkYgxQSw<}t#k)#L#_=)^wsJl%Q*aJbz=DZ2t=1_hivR5d
zgx7{<%yRE$?H3it4?!|B_MF>H`wT7_=_JH|376PDowiwSNmfiI1TAJ8TxQKwsVi5>
zbDv=(xJgi1^>9AU^*vMs#}hmw%R8$iz8EejZWN$gT$JmHr~!8@hM)AtkGOJBni0=~
z7VY=Ie*7)`sk2U6GtlCMWs7m*Keob_#8^JYI{CNY)Jy#Se|9~5%=rHiyPo8#3w5!v
z>F2@}Lo|mo9AF8K>@o^0b$A&u#AoTHdHLG0+~I3R&jWevJdQohrI(!ufv&w1VRW<4
zvhyYV9{BcXVN&`kh~p4)?A-1Nl}l5sT*=LM*$@J}JO-zzlJqz9dtLgbC45|=GX=6d
zMx3KK{m7}u+-d1R<F{R=a($UXWP@~In!0Z=Lh(`e4e^JPNWoBF3J}IH9VDZM^-5n#
zU>)wK{~O^E6OPmo>Ew>`1%W(`)_%H>GB8hvr;~V9B8irDbr)H<`CXtl<^mLKF^CUm
zbeYMArj2;VgP{w*(=!I@S786ogn^&)4F-N42m_smD<BT&_mS2VTfAjwB3eZlDBiZO
z!{E+S#Yq?_j@b2Z<MF2?3>5F!<NDDWO#PH$|5>~G2?NEuT9_aV6o1j81Yw{!szphJ
zf#R?BPP}MpM;Ivnrlsu&1I6F9Jee?19J6QlWgvzyP`sxj3;75G#Xsy)spcmP6z|*D
z$^_s<y(Gdw5!VhLVW2p!!yJx-bE|mnsU<$pqIQIV;)Iragn{Bidy*{1@rp1|d}2Q@
zlY)az3sy%eSJW-5!Eq*^YHvw|f#NfJcRF)70~Llhr<VBKo+blpPZ%ivt^F_X2m{4Q
zdx=!7;2Cb3Fc6)7qpaep1Yw{!W#1wdmnRVhiZ8Tk5@DeDQcEKqVT$4Y6JOa|WjL#o
z2?NE~+RM5Gp-RHjH}+?^{n`@-if^T#(-H=XHv2b-rvqUin5h3E<+s~R+w$d8D=RB1
zEAS<ku!VIgec&ut9_XfBc+RL0f(4Qw3>1zyh37>{7<i1$J|J$F3fpjGDPC0<)-7d-
zDO$Qi5(a`H`YahWj&WVhb4@MLMGTNp;-FTXB^;@ek)5d{!%3~H!z*i+t|TLu$Pg^I
zj)Z}tn^td67%0vXyit<~14R$<6(;pQ!a#AhXhlPFF7XitigUz7nL8h0py;VX!=bDT
z<;hv%JRR0iA7P+4Uklq228t~4DDI*Tgn{A$9c&U|ptw*BmF3c&Fi>19*c+UNFc9ZF
zv&jZime;IU8j^poAHj0;dlCJyrgLzr)cPM120AaY8}tzdvXX;=LezLC{sDjC1CVqk
z4mg*HR#*~*fljvg7X|=yoIZk;n)%mPMyhHm>Z~D7M7m4fB_}G&ft{@8Kyp@zj5FvP
zv`dmO(790zl>)FeD8fKzwIJJ_<ZCd5fzBGSP6{(Ldy%tN+$#n0tZ_{k=-ec@Fo(0o
zHDRE$PHTa3sdUBi8hrcY)N4@)Y3e{2=&aZ21OE~@nhaqe7$M}b1DEtmA`EmkYW4o$
zhB_@_AlM>Qh6kdE|BZr6V{x7-dn}$i)RlkWbf>I?FQK5^SSZr1EAP>+Z1Y{K@CT}A
z!$~R4GD;HpmAFa_!oX2Rm&K<7)WIw@PAo{}#1Ig}Eyn3F<3t1}dJYD@ZxmQ63BNM2
zaQ_XYot}jUXNULzID^>kw3?E$9Iga*CZ32RQaK8%#**nUdNvkA7>E;6l`M%c5GSN6
zX)yIehIoz)1Pvy&0kaIJr*i|s<gxU%V`^*1FO1+w+;ee)Hf3lnk}%LY&-t-bLQBzm
za-1yZc_~6$8MAmXyC>%YEkax2HYL2{QKxKP==?*fvX%G=1D%VUF6h$zgn>@T=_5sK
zBAPJJ>E(=-G7xqt!a(O@XOWZ)p+xb8IhQzVqzsH*KEgmJTSpGwE=3sV^mevL#e6hr
zA7P-=$9Y!DNf`Js3OyLO5y?*DjjbBc4p_Ug2D-AyeDz2NsI!=H&>}2Kp9SR8r!(Al
z8F!Y7a;H;Qb}Vpz$+)v{+WGgCK9owVB^Fmg3I4l5(9LFvbqu>dq-V+jljWz}<sHKe
z!S6)rm*tpngP11+s4TJM62Zc0gK>J)I1$0=Nf>^@!24luM;PchosK}-ou@9^owmW7
zlh)~<kYo^pFz^fDZgvXxm#Ukk6VvG|&gce-A`EoS=vD+v;-vmyw~sNr$*HP5K)F*l
z)%*jg9HpJk-B`|;t6H5#(q54<mthh2clKr!VVf#B4?Jo=%Xub4`L~h?1D*XD@5*R=
zgn`ZhtqM8>bBgv08ONla<P!2iRfK`gA2L3WZa5H85e7Pc)FI&T-ip=S?B*QGQ0c{a
z(3qu6ui<t&oDwYEUeVee2?L#1wNrb-K<7^xvR+6S*oXPA%$SQTcP0)v=X6`g{42sh
zr)RgRm;!L@>a>WeOENZ5l{oBNpV1YLsxMlhBjdoO2m_s(jOo%ZMlKYlBn)&`Y8eKv
zv0xrhUt&AajHuKEQHGB&&{>t?N^wT&BkZPb)K=3at<HE%x}!_d9l)B57o-F|5(Xpg
zesI=id@Duhk>pW{&N{7wu84$zPQA8cpu%*IbVknljBGiRMh~P9?cb1bwUnU$(S(7{
z#*7LnLI<P>1D%_70@3|Q!a(O1EkMVk2?L!5Eke&@2m_r)EgUatKoW$3PE*D&WgHVZ
z_^X~Ymhp-dkuZ?0@=D~ctNfD~_wp#?+^y@aszWJ7eFX#KAW7qG9t^Nng8|-D!2l~!
zg;hf@bm~e3C*D>#Jl80&KBNMqHyP=VJ!w}WIPHP~&uA$ielu#Unyz$$bdQmK>Pgj*
zExT3O7t#TmoL~n7zeOhy4E(|Px)5a`!|Ey#J;431QY!#Al^@ob($a(RWyXnhr?P4y
z>#CIsjM5#+N-}Ly#s@9Lw*>|c)WzR!^4Tkqn65hYtdn4%8X77^tUDF0?rxukz&mgm
z2Zw-$1xFBgeFPZRev^@p{vovy@j1_$dyEHhw@MdI3^ie(vrkKs2?L$yw735kgn`a)
zGx)`YiuQREtt1R|4tf#)_k??dfzIz`7wIDmbY3!{Ny0$qWfNL3@Fofa?FKOi1B@Sx
z(fFIj4oMLP26~)<UH_UeFc4Y|OM);k(2L_V`YJ;h7`RwTJi@@hC9G@|nMW8H$W{W6
zFfh<NC?E1AVPN3WuF|3j0|RF_AUe4dH#0Ek2%}!X6Iug<l^;zQ=vg&kU|<NF0LB_c
z7#J9;teP+|FjU3w5e5eOFf2_N80f1UJ;K01KNS&AUS`gN0VYBO{`Uz3MVegTk%WQb
zOnU@UDhUHcSG$H;KOJG9NVkW=O%eu*4EtW{wI>V|-E6knPD{{ji-GoD=yWDd6S?+R
zuy7KHV>QGeI|J*89H%8=AkJ7+rQ;C>iXnQTf`oxA45}yQ_b35|W(WgCvE2s>-qF)m
zfAOl5i`6baVW9YvqZX3d69$UcwF5{+a9Sz$l=C2d@uoMQPF=~&9CnUh#uVdR{t~67
z#|-h7R+NMMa!dTx;WvDoRD1ME;%{1|9busOyOv{o$2>ZEeRTQ4NDYpBJ*MRzVIYp~
z{I?7<qzMDXKea{@VW9X(OZ!=!cJYoVvGY(0or#0u$&_WVr1DcE@yitULMZ>#{<Quo
z<+1*>f(C;NA0?GHSYo=p2I>i-LGc6e0sZsALHtlIY_R@FG$<aFPvz{9B+;PQsqG%o
zp!ktoqhRStqCxRv(Q+vx<hWmnGW&_(`VPuWCV)e+D7C-P@k^pXu|eF6jrc11jV5|U
zG$?KsOJ#T-(V)0RYj{M1qCpE1M1!JHr&1nCt%(LjlNNSMoy&~gDpW_}BN`N&w2C4c
z6lL}gkuXU#h?8_LKif-WgRLfSXyYIn6pi+<zRV)d8P`OEI5$_d$aX}7I6zm)HPN8>
zj=nokTATrniK2OKk}F~;u~cl;w?xc-N`{^w8WiRBNTj8UK5M5!+-skYKCB(lpxCN!
zv;@(hxX<PqkxZ#38Wi_yk&kFld{4{3D<Tir5!<vN-w+Lo@7r8lYELvM9?%(7M1x|x
zw$4;b$UE!}>|2tF2E`9_LM73lc+lp|M_jT%6Ag+Pc0c4!6Ag-s0;N5XSB#b-6wtT5
zs?c6?^@c=)pR(L84yd?1qCw<ZEdhhmLJ|#%?0{-oIM=***;1SrWhCHzkaQKIcR=+G
zV0BSPKlcr6$Y$y?Q|f9LqAmB+c0)8ME|m|ABpT!ZZ>;@NuVJgZJn)sg-8ILc=&!X0
zcHkHkS7@gpsW;JQPT)a#BMeWyo#74)sPa!x42r?pL%!AN68e~FFGNvwCe9G0f!!>(
z6$LzXN|b3;D|HV8E7w-EV2@%@%+NAC^;lwlpyqPu8HzzM%YFvIX^KHH*0~*@iED~M
zG0ss*gMicX2`g)GEcbZlQF9;HSfaqu&ufNaP)yJonqp8~qq{s!F(|HeK9V8eA*v1s
zV^ywPS&0*>r|2#|iDFO`YH1S1pqQ$qNfd)(nwI(~2E}Z98#0uj7!<R`qVrgMav67y
zaAh<0Q4ET?y6Z@$7!>og*insgzP6$b8j3-&!0STgN{(14rpY^teS#cP7YR;EIqcy1
z5XTsa#ae);CPOhODnyYio}Q{BtrX?bnxGgIbL<<C2SYI^ZU{WWJfV7{frn-FB7>k9
z6sx@EpjyX`UQ6&O2E|-^uMA0142qvPPoD4fjSuOHMNr-_`mnA@yjJok2E|VuuC8#{
zFcgF0XU>;0$!V!LBg+!IbTiV7O5zb6OoCrf{M=N2f?rTPYU<wO7Zkg7qOw#8|HApc
zj3}gf*vA~z!)E*W1;yje=TfO37>GD@TH*<Zk6wO$L9xI-fSenCL2<n}JBv4hKF>_7
z5PH=@RZ5LegEOjMcJ;NU=J_-%ZqQ?8n$_tPOJJeR(-JxpXN%4$Cty*ddKW#aBPQ=$
zF_D(CM~(EU+ZfiFDP~r~^%BuFMa?{Mci}CDCDOGWch~aeH8<iYG`xsNQ5|Y#O4Y(T
zDe0yqAZ)0U3&oZ=ON-9NJHyIazUt_%gX*cexXcvQ#p%NCk@6dvu8>EXC>GgYASWJa
zqPQVtO9*9Ffj5pTQ&itCNfSk#4p%Mlh)9a*GSs`UXv%;qSRcuxiDH#bpr15R+^B`g
zq={m+78}w;u|`XhNE5|cE%lKmikq}7i8N8H(^4O4BG&(h%7l{q%Ogz$SB|O>KWU=a
zpoN+=QEb%qd_|flZq{~9nka73cDzf(cau2VU)v37A{v;A#!s3kno<_a4lIc@QQWGf
zNu-J5J34@5(nPT-r9kFsfuA%{+$NRVlO_r`r4-7^q=}+M>-tC&#hqG)mu-?XQQV~k
zc+ckXBU)mM7Iq*_6nATvB+^82Ps(f=J>JDtYSKh;udJtbq={l{3WxXhq>17_Eq*$Q
zG*R5I#U5#*_@116`$!YTHZ4gaO%&fx;Rq?;%=t+Z@yh98^f~QF6UFwFg);f?*lLQu
zLx+jCbCN4j{7|Q(9ao}wQ0K8dSEAUd<M(kTil6AB!?9x?SE5*KKZsk?a3zZVDI+gN
zA0#`ND|82==3+Uz*<%KgAW9Siv^0q*Q4G{lk0?>(YJra^Q4G?ujzo!Kuy*RC=6yp_
z3fWm+qKOj4P~8!xrQSgKuoN}R%TP~ySL$RZSQ5o>tw9PJ&5|faXf^QAD3(MqGDXe5
zLTU^drLEb1mP9dHOR=Ls5g>{@9e97kk|?gyBFy=;($%u;{Va*X6SZSW6!|F!WOwRg
zNfZ_KWK@gC^kWSacLg><pjZ;cmVlnEsL}jxZ6!;h_+j9OYS6IGQU`2`CH6fGOWDHW
zOL0AJ2sL_rr607^&~AyZ^@~l6>lh#{@r}4wj+h=xqWD%TU^=Z<g+-fCBd<56W2sgS
zshMhyYdflp*->)P652T{bw9^6$KmafU`Z4KJ!MR=B#IP0)T0LUfOUqW8UUVV{49y0
zvku(Hk|@&j++hfsaY1br-d~6_wJ3=tQFPVP1WTew*P;YVqR7x9KTD!GOACE0iK4rf
zX_iEh={zZOI$AH<iyjWwa78jpqVV1Uj!$Aq6zAxP%0xB4Iakkbz>@eNi*c#F26dW2
z?6D+@D!Umnk0nt&>%0UjSQ166W61{=#gZuYIb20DEQ#VdW!Ef;VFtg<J`BH|iL=G1
z)SG*w{oKwwadfKpT%bu3MP90^enXNduF?`L#w17*#nq{5yh<WT6!}`3k($ML$7rva
zsoakx#%gO%)po|Es<xwNCF4`sr%GzX!%SPX-Hdd0ChjjXQpe!MiG0TFrbDq*9A{}O
zCUDcSGYfMc9c)lF;2x=}0UKUKaZajwV9ZdxQO{J>7}3}8NlZOuo|~%XYUphAakAq4
z)NN|kq<WjI)TJ`H=xrn^qPRc{e58otI=cwTPLLvsS5kUmm{FvN;#EC;@<<WIpR_=d
zB8t~cf2&9l#p_-#t4R^X8@k&{OC8MeeKSR+(9ee`-jX8`9*<SadpkwVtdTKvD0;m@
z9MRH{j}KA2lcIB|GW=&b68iWMQ!dRxUJ`tW%$edtOub+tUF4h)?-uza8VqnjtQ{ZX
zIW4H%K<d;-q1~gVb}^~4Qm5%9gdVlIR%%#nC9`|f4zf~<ltuKY9c-l*D~n^D%|KG8
zlZP-E;EGUCcD3Gezd7tUP5jg5mLSQmC_XYvF&@97_?H%Gens)Iw_*f-MUg7F^R6Ag
zqBui#rwM*Vft5e3tsx0qKMMxlJ%fK)7~SO7FSV+wUrLlBz;1G*S3=yi9QQK3EQgy~
zjO9io^-31`l0LZADzQAPUXe4%uG~KZzYj<)ZoE=j^0gK3YN-l^15$zeui7hczXlZE
zgMx~kJEl$>myA$nBo#{MGs6V{S((TI`4#!>D__+hKsubyIRS4qsljNtM5dzQ0;Mk+
zCPTfb(h0gA?!f?;M1%4P883xG#OxG;av240!TH$dokSfJ6Xn{3=2sMx^vI(56~$yd
zCUKR2uMC{6E*M}}8VsbOe@)}sy0^%!_!Y(5jtdvnbsjNGDw<wVyrbg?sAZ-<YioOY
zMe(k7(DaJpFWT<WD~h9fc<ey0DBhO~<C^DC#I+umdE~OhaYwCFV9LiA{o;c}5)8ef
zIN?Q)jB?>F80dmb1p~|)cJXj&-|Gi8y`q>Y*P6U&XX!;cJqMW`P!EBAdPOluF9dq@
ziej!7XnI94PuoeaXk(=#nO;$>l*=D#l2fN6z@5u?1rcv41U{qiY3LQj%>mv$-lR*@
zD~fvp>=k|VisD``Ko$O0lL1YyDDKmepsMQo^}=478d1Kdm;K~YwqaKk+jNe6?26+1
zT9#l}6c6a+b83s#%I&%^(H|>zMX^Js*Uzpfeh_$6E(T>I%Utw2|5;f17Qx&~T!;t;
z_$YuX1U{el`)i(tusV(A05LP=C`6r!)5I+Kte%3if9mj<I$Mt|mYTuO(N;TU84edh
zQ<|&i!(P*xr|m&RI2!$%jF8WtGD)CsWCHkzDea_h<g7I)bBnDv5_2AM*7!vemaWDX
z0x>1E9_m=ySN051nEFQu)bh&IRQ1w?^@vr8X{qdbxN5#u9^fs)T7ZS)sW>0O5=GK8
zmq&wv*AYw_$NUQ-3s>S`DsO?tUM*~{(AdLru;rgGXY4hC@my3ZSM}_*f+Jw44pG|c
z1VacdBd(X-euyhQmc3pu42F#l<EJg*Bm}4STlPO}xgKv<GjL9pA>o841S-S#<xm4E
zMeg)di*nOeRj!<}u-39C3FU||=i=h;MFerNHxYpX8*~`*OZeCaJLf8EV9y5A<Ybw)
z+v%;h+K(BoTv>-N^L4^h&a!NK0W>&E`z6fg0f+$0J$9B{>i-C$i;<KpoB8MIcYW@H
z=;ycwLo=IC$d-Mv&6(9@aJBk8i9d&M6(^kg+U)G*0ZDz{gwv<EZb&%yx0!0bueADp
zfj^l*I^bNJ8EmAJ)$eWA0N_qsKg9Jsg1A(mK)!|LvJ3#xQgwM2%rOGrK=cEc4`B6U
zrSe#!!?@}pc@G{hpAX@abnfqQNG2VWr3$CJeH4DCK<#y0BL?EA;9o*ucV}sw>EP1|
zrffj%be!^K_n>epggDOE3)3s=%H@@dadZ|Ii0!LvS(af0_yb(a;o*J+oXbMLO1)oc
zu?F$A0<3bz+7cKnW4&5>e3~(|k6_Y@y2_P0g6S%P-3WXXbicwiDpyBPY9e?Uq1a_M
zT|ioytGTo-yIdBzXbBFIO=^a$9MO`dQZ!SiC}R*Cj6F+Dlv*-X0_VsCmIn|twyEJJ
zX`f8Bmq(SuYL(1<B=1pN_rTX5y=1OQPUc!KnJP^;=`;lg-M~z&lg*1slxeEhY06M(
z+91>P52mSoYE*@*)ZDEL4Jk>7?s@35t{$Wd?VjY++-p)Jqu;8d532a?m+@7@zcs{b
z1xYQ-vUh<;5OMJHXYONOi+BdfZef?~7QiW*Xq0$|u&l1ibS1yDGvI^You{T+)-8i^
zO0?{)elI)47VC;TSuHQIB~FIIu-Y+L9JgOqwH!o4<%5y^NA^B0+y}7H9pbd`9oVj{
zLx*eGuUrq`q9r^)_HeJV`~C*5!y~FcTOw05fAR9lg)5?H&uR8>XpF%8!CHv)3_z#$
zCH-U}kt5mr*kAF{ayqO7YWdpP{+iKqcdwO$hHnj6g$|Lc#Z6QJ)$9A5M(n10q8#Lw
zFH;Pc*`xt$P6MqH)Xo~}6~pDa7>3EdKi9JR>-Mb#gDm?BT@<6#la!sqqz*-3!|>M9
z9zdID$r#F~D0`rMh-%3kD({tCxrE=+b69P8RV4|3<-=l2*05!D+;?l)gO%sduoX32
z#kYqjd-h0Kx5Jp}g@{O%$(1aV-_zQ_sD?Akb|>VYH8O%VQc0Vvf{_epGp%Y!vqv!#
zhak{3Hd@u#lmVQ8jz<7_^zk(mM(avTRM%505oyjumb-k)vbRt-t268zQ0==po{rL1
z)m-kOXf{OtCcU!8<H`tQ&!qh?+un@o;0NmuK(q5Ov}xHg|7GhsQBC|`x`_t{^F5ON
zu^bu6l$4ED@QKZ4kWCwl;Zu3vkrOLhmcwWA&Rzujhz0Qc8mc{8<>71Tat}3SCcd$m
z<bAN`twoVo_P0_Xq7_!(TqN;vT-l2j)?t+FB1g$SNPAvIB2Q@6;ymOb#o@^anAGsW
zlma=434&q_IB|dbJw9vOA0zlK=}0C*?R=$I63==ik*llmSvlum@2gwPv%2dF4wg-(
zRhCsf0?7tJ^gikMENwE6&&e#k3;ST%g!W7OH*{YiXFm1;=_8AIWpVyi7Uw8fhcl=1
zJ2Z`V?X%JDayBBr+12O=r1vGz_hl6yDJ)xY-Ix^>?fSGn!p=aBxlykXKK3BjazyJR
z*p|_y<;p7TBTE}u9wgJ;N4;}v(HZV5c$2)w1nVsHlltF4lCu@bP>rU){C1`v)4H2!
zU5vR`uJk$qGW^<i^mPS1kjS!Us|gho$&c*0RdW1ruX^Ul2_I5A=yn8Q&y|s|a@aA<
z)9DTlit%=xFDF_Ua#Tevl##!P;IeTD*mah@NUF;{i5IYi>W)i(R<scNt~aZM*xg28
zMksHS78(16virVMPBt&9S&5yA=xr_gE*acaauRU2bi7Iqb@xbl2zSoCf_F}c)x1@f
z_|->{u@F8HupbnhMC6CCnGi+rBf)0@3~nFMUCmn`RrA)XZKOtveyv3L+Im1)69qdC
znZj0GoiE&~DnlWZDsPx9lyE&ho>X1HXI{z5qWoMJWk40>zjaXtb9Ik=QoE<Adiam7
zhm2gkFlnFC3Yobz%PY8P%>F`4da4<~m)e>&h>MN(SK1oNtz9;4Iq2b+7s^V)5;>A6
zTCyR>G}g$!(ei%TsQ5NnwX2aIc@J3*oAV2>=JEC^iGZ!BU`1r*8gK*4Wm%`?p$$1N
zpn$WNEL&MQKT@>}Rgfkhv_F8a5f)Ok2+?L&uBb4jmo43MP<YulVr-GyK<wV~nSM5e
zd05L(lyY_-xxr4f%*d;oI?l5DI()=)S{gTuVMG3XH@1Cbd4h9kJ?xF}eCZ7UI|(WQ
zeg%*-11gu_0o$9fU4B167kIq<#{l0U*bT4;V8li!hLG6HTOs)rlANuOT=o)dqGbvu
z`>A-!4&%C#N&?L%0~V_f*%FT8nga1<N1<&OS$!$kgtl?{XAtC255K+-BMC3z%C0TJ
z4BFws?^NX$3~*i9dId8wVJ!ywFFfJi0c1Jo1w3N2|4r&|^!J!Fqd;E>*qaA7<X#@^
zB`)sqvjNUa^|x#uFlxZHZ%)d)D%vt?K(wmkUuVB~>VaYJwFYyYHIbQlBOeJ4xH<1T
z&O7UaIWq=~8aQfugY(mM$7bYxXYcmyJDgRwteO>E;XELAZC=_iYQVImdC|L^RS&d)
zntJr+<&a#vbm=2iBd*HJ+v==+V{gMt&Y8!gW|-ouM_qN7Q}@8$2IuT0+W(sjAc_Fe
zmqhZe-P^K#`}UT+N#%P-T{UT@bKiRLT@2967tP)7Tsis9N1O?_M4uj+mv?R6$f?0E
zopU$89{k78^RBqonX?2$*~jv(SUM`N;l*Hd)PUfQZ{Kd&E3P=l=@MM>+3d^j8nraf
zsf;)W*Nc0Fz1c|{?L<az8P*te`bM0>kTW=ErZai8(_}|l8n$l_p5rubxMh@+KEqk`
zK!2ylQ}2x$;GFr?d!qL_RpPSl-wmGq-l)8{mpZRoPsN>kH@xAT{b{h*D5oID8662e
zD)PHO5?t<d!nU!`f}cB&Y#8nQ$%@Q65<KV1F)gE7_I_{nBhCY$?sooWMILp&w?Xu^
zo%gJW(`DDv)h~|9dt~4vqy~?U%4=ErBI1E9c(Jo;vokl+aM*bWp&f>D?Ti=mVoqGV
zu=(n%N93*=IdId`%9+p4ae4(Ga27leoaA(lI9-F2U)=jyuvc*D-o3$9&fFKGPQJL*
z-W=>R%jvmfX`Qod#(%CF3EuL&M}98)bPqPvE=8=t!H)!YJHNAnw`{Ju<LY4J$br}X
zeD$@#a;MYemQ_ylmPeL4Yjd33Tee(Q-BLaL+F*3n$o@AuciO>Y&)xtAcW2G$o1Exq
za-Uza%bB|?c+SnU%4dz58C>o3K#2tFf?J#}FF<2J{_rtXBSz&f%D<{PfB02bm0k7d
zi<6cHyMK2;@IPRd|I_+goJZ}^&a3N3kMh8vnlZD2vz_c2@3l-C5Nr$%ai)!K*xM4^
zfzlsP_~u@ap7-AD%x2v>gLgTntYb?@Ep2q3-4LAY?6XD#jCKxKZ@iax#na9o*56W@
zm*=GKY6)KJbQR-mXKnCUOZn36PJ@kCH+iF4mO9-=J2j)7ZZn)QGsHExk#WOYI6I@w
z#?xC6%;lSK=b~3IKQ4E)qb6UGlQAQSjeJ6aMctA^8vHE4^>jzS(?MnaJ*BRA(!IDs
zh_}(FKei!ot5cMdQ6*!d?wIa&eixBX&#?U#y8UqR#}x%)FP+lwwK*B3)YWwCp6*fT
zE^n_}j8qjTl)W@@VW7yTJE0-v*1&h1NjVvda;$6pMZlzu=cr-j<KmCc{4Pu{O$om@
zb?`gB%QZO}3sk8vYhL_(Ag?)X7|{-4<TDKDdVWdqH2<`IYfs}>rF}H?`Qsz;Dwtl{
z$2T}rb28R-W>N0X&#?*^*R;<2nO12XFI`OD`C!}~`S<+myf4nlnC>sME*o+}vr+PI
z=Y&wCYjQ$Ru%^otVDJoLsSW997e+PoCnW_U?#v05K{`)MnW$^Jh_7-&Xs4nyCnTy^
zFc>4{kB>%U&<5ItTbPqkm}A|T6AJqS?{1Inf<%c;IiV@O;3wc|#%t$%z&O8ScuRf3
z6tHP{^}?z74y2@A{3y`691AH<j$h;>szf`7-&q~~ibB<NWJ|AwJAa)2@l;eVo=K|h
zipO&@W}!^xAy?1kSiBu~%HkI>Uy8?cnVn;m!fkv`2=_+0vQ*}TX60lQ`3ho8m!cdM
z9S3|&4kD7r15J-ONV8btXpm-!k_Twc(Q=yXWBlycu*$DZ!10W?QPwnEAX2BVnF`{s
z`Sk(<*SKfL)W)KSeAXAk#Dp8p<@7vTLHw1!1^BxV7h|TmSm7W|)+jl(X>xw=Pu&8z
z--rvTqj3hDkvbsxTY$eSa3M)F&XulZK=Stk{QV&=_@(i43Cr<U{`TYV0bFpUaY#br
z`W~$RP_8sSO?G86f-<r&4X)h!QWb)=7cS<5<|PUTX)cgB8l<^U$pbVsUPtpmDUSwe
za?#gc9t?XVF65ZTWC_b?%*W+et7^A1h~-L7gG<Izjx5OEC<w}=dzh+RfJPa3uH;am
z7$VY_Fn*saJO5wcVv=Y+u5gg%n-WKZG`ZyLPxcG2zlh7RYVGX=hj97AJqqhzanTRW
zzbhQ1c`Z6OHV>LylJ<v7e;-NR7HM7%cd&ZX$dRyw#?`olRhLb(K#ENpp=af(gobi8
z?MseH(sLwG1hYipAk8}^js|JorQ`vc8n2_tg>FAv{BqbEaUth4Hc41a<GT`;(D<H&
zVH))BYgioSet}DtKFr4z4$|y``=3$KB-0^vXp-v?cpc4=5=VnHxkT<S$(InuTey%k
z8thIGGmWz)4AZz$Noml(uLAR7B_Se%q&ZIEAkDiajs|JoqvQda8n2_trEq^q&4GOx
zE<{1&P6<nB{6I-*(38J-VEqLyrh(?;3I}Og=$&QwFl~v^dnWKYVlIID)9@1fy@iWK
z0^=JAOK5bWPb*A=o_uNGXx<GM(?GMk!a<q~C5{GZE>ZFT&2?H%^JXol*`(z(xoGaM
zE{^)$aLIUJc2_t^vqa)(kmhtH576ZDxj%mlgKOBrY6;K`<3d)b8qs2!Yn7PBZ3=pQ
z1p~MY7rTF&3?$WRu~IKNEEmU%V8`9a0MA0)fHcmP$r!kuCX)oQ7oZo2!$26CN;03h
z)$e-9`0XAFpN4jx=sEKokCV7$H$(6hF6c@_MvGd9nW8XeJ?fVVJCg%dPxJ<YKc-^(
z2Lky-1?0K*f_118(VzxOalDr$Vo$XMZgZ6?jr%1m@icu+hm){eT&z->gB1?ad{p9S
zkmhbB576W}n5<HotrAB9H2I3aU)2no3*bmt8vQ*ebz9P&GP*7Bp?(S7f!pba`lyhn
zHzYg`+|B^#SvnB>0&^#}1DY@3LQ&F~fMBH#flAfD?Osf62zdhhLbm}1!vth#e^QVJ
zJt2fW8$4g_({~3#!KA~VItKARE+&ZPNn8k-#&2ZW%4sl3)bNsqK)g66Bg_RV-&QI^
z-XkL^ei_EQ3VN!ZtFUsnQ|meDTyzY^KP3#)_*O}?kph)tKI+IHqhT1RnmLcdWE8~o
zr3$Qt(>D409IqI@#D%=j(1p9r6b;=6AZNn5ayw1FLx8U5y%VfGq^O97_P)z_r;v=U
zwpB!9I4(3sX^vJnKr>I_AkC{3MoFq4XZ&nRY{WG0QaDJHYxHcCG{05y08I<Cdg!mC
z`IN-bAk9`K576Wb7Jq}@1Al+Th1~7c&c2LZ0nrd#5YhOxgr;(L!rxDEp;cL_1TV^f
zjQeg_AD5yq4f4;Tk77#q$biZcF`Ax>={bT+Sozy&euN8iG*6RauZS3%Qe7#{lTx*u
z;dfRErICh<g-`QLg#$Fx6%NwOP&mzt#n*sm!Rb0&zCz){(<jPDfaYfk2Wei?RTVEy
zzF=VW(d644f3Y(RzAWKwL-z+YrukD`h>pg8v{;%5!k3DfaH`PGKZCg&m#-5X59>8j
z6sDo#Puu|9a9pgMX=rEDz!~@)<xE36Pw`4V12U#wRy;v3T&P+vr@oPhNn9&k!_UCr
zI}Tqa_*~gd77a#unB5f)(v;uDp_S9TTgd}7HC|1VZ({t#Itlg?T!?~3i-aYfrmuMV
z!DWzAq#+LrK~>QlhYQt)UPJw6z`g_*!h8q@qx9uqzIGK>ZHQXSrE?LDH4=tt)GNq@
z+$UiX4F=~6iXs037uyWY#}y9J?3AH0N|UdisN*H@cX0m`E@Y3!e-!)z#y1Ljij3e8
zE;c%vJiY-<J)vptTt0{Q($Ubw7v8c=XfDCSD$AVaQi&r0n!B(zPdUv;B#s1V@_mlK
zj;11vg}886)2POUcJ%dnf~b<yxDr81Il)|9(5J!Rq}<EZwNPe2vM~~9jW{_u<c~s9
zHZ$Ke`M!Xd=G6$2BMx(*Qk}a!k?O<{TZgw7^|(-9H0TWxez@NACoNut--X6@rA*^(
z2}}6$;$d9AW=I#6f|e|XL=}u#SzbWW=UM;Fi!6Ta#q%K}D^Xr({7pd`j0kai@%WNq
z!!=tfmM?{I6E3EL<~>SW3%`6TgQvfM_jU$N=Szrq-T)wtwKDk;Y2Ku8faW@dgEZ?E
zMklR)|3DFZfGb7Lchd-U;hvI(%lx5mPnp{EJjnW{I#Z7X(D)}V$Upb{{M`8bAzUAq
z%3&H*hCeSMEP&q1l}3KDYbKI$0WQ=(4V|iwP1uj2E&Uponzp}V6Tg59`ZWHopchw-
zeAK3mG=SVsrcZHAdMhq>7ID*<cGU0tN)nsFxbZ95(YKLnOm2He-}WhPl}h%hqLy)T
z=hEpCB)1xAhvbb#+)1Pzl6Kl~YmFCDVv_@Rd|Wi_bS`qcgZA)WwhC}-fY#6jqF>MR
zWw>@|_j;KH&2#<mJdPiWycDL^wKCzNFb?#I3>#wcToo<Q2T;<pR@XW_&d`%A!8wX@
zCsvZ6)u*v6aegE>@_TyMM<bQ1EgoFwNmebXvv_)--_Em?jD6wqXr;w-lROFD@gtCk
z#j~M2*(&THwRjekCr}3!EnBgq#^NbYo|t;`7e`m(02Pae_IUE^Ybv715|0jRC*qLd
zi8`Eq#Djp69c%c>-J&&;4m#N-acGi0dx%H6C9BBfcJqm4w&wa0<xf8kznHkNuFB$3
zI|K#GE3dbB;?8`W{=j31q$|$^GOj!!co{03o4unj`NB9lc#y@zC89V9mfzMbgUKEJ
z(cu=4LLD2eTQhOtii+jfn7g-~ojcy~W%VQ$GtaT%(Xif|cYd>i9Rl)@7Jhx8w(45^
z)&aYw__2xpf`*?m$QStBQSWV^w|KsTJg$RZz;KH`4oR@Mfm?r5#E<>eXL$U0L4Tpn
zcl+GQ<E4RHyCuP^wIzi3WH(}Qr?<C_nI9HnyA!IOTdXCT!Xrhw6;pBWa=W$H4RP;+
z#huqifbFSc`WU;#&v?d0$R*2t-SQhAep^E@O`XBPT~R(OPh>%9@BkED8az!|w+i$5
zO@;5?<w*`+aqw$>opYW+qf40Ml2`Ej`cdU?@1+PA;=+Zs77x3SWy^C9R3Y+vIhA34
z(V**8e!9VL8$A0Gek#EejJ!(cSte@p#pQ{*Q(q4(^w%aoHc%C(9C>tuu1IdrAG<6f
zw*hf)zOEXjH`!NLJUzf)xeq3)lsj}(?aCebN0Y7mK3}y0o-*Wbqx`~5*QLcT=KS@_
z&;E>^70)e$-VS?ixA!nA$3hIcuMN;Df8H_Xw0w-=?_!}AjJZ<m{T@P>`7tgo194%;
z`(?oXM=j%0mG}Dy{op6K__*HE#gpRk5`6@p2E7MfJ`i&ooA={G2_LWc%ybBs_bWv2
z){M)0VDRLe<Z}v7IVbJjuMB+-CzsxY@j(>mL%2A_+5s~MW-cyHIxmOm{XBpFO`j7}
zzdrZn`~jCYb>p<K4V}*`FyF-G{r;zV?AQK+i?hP_aCyHU{};LGFue|1_QcD|_&Gq$
z3X9+Wq0jI;dZUUb^9?|rNRFDd`abuBdgS32*_FN!F)Dhei!d^OpW*rR#zB9BUV+`q
zHH%Hc)Nrd(D|a}W291tOpZ{&iV{NP@%NH)KOS-?-`U76JbVbd|%E{5|Yb~|QF40rh
zs(VZChp+SBh_zlnVdCYDv~bB1?1+x6Ng7&euUT0WtsT3@s@2`}TA5&c_RKRT>LA9q
z0P+LV+5%}LI%^!wRTo)V1Ft3;WY4o$*NhuCGSu&ysil{OhU5&*8O*vLj%y&UOpEi`
zT#2^g?;weG;xE-Qt*7vJh(yoh?@)=}!Cy?};2OtY%*}wl#b1V*X?4b(j%gXtl|UmU
zDgnY246-#qqb0h>$o3i8%RqV3^%RhbO`x|>aijsMRGkf^;<ym#D(PdiL5qQ|ma?rt
z%Ex{q>xq{T%5Mlrg?t&1(klT{ejhNdKL%21*>7A^(akB@03elu5eAJju7yA<wiU*8
zG5R}IF5JS+&Mnp20+cV){3wtrp;v*%NZBc%u@aqwK5?8xgMh|M#BKYk24@1P@EQz?
z0ToESJAqV69{`#lWxIfskH>(nk+R<dO_b;(Ae9yYB~>%$0VyAIuwbH41<)kv<3=DA
z#|EIuQWgVJWpEdeDzzg(*Gku~fTl<^3M;%Sym3JJQZ^H)P@*+JO7DK7_b$*>>G~DW
zG>OtNGN?3z&_kzr7LW>g0nj9=S7&7PKw&A{VPwBF=xHG3;{za7Z&zdFDUv>B0_id^
zXti<u36N?{zXd9mK2kACsXOXCAa&0S0xFTN#Xu^&89*xD6-E{@vPL8O36M(Ft44ML
zNTshE#z2L#fmF*G38Y%i1fc0M-l;$;-ZG$4DXRi1lW4VZ-C$%c&;;pvFHpHeyMQK2
zv>!-?cLhe<8B#V4NY%^+pqWy(9Z0pS_kfg-6F@5Gy)g1BANfG)UU(ZLrP4bJbd3z<
zOCS~RjBaY{Nv2f^G+VlE1X3mb1E4ul_AC&$b7WcvfmEA(A4uh+8%9Nixa(B;9RV~?
z`j}{3?*kenWxIjqOY}6*0*PJ)S}4&GAl1Ko1*Aegt2?&!O4q(XizV6$q+EXrq~bjQ
zq<Y(TfGVWkM@H|wOwUJuAk~^C01c9Q3xJg04M3Grb{~++?;_J9)f<$JvY#yVaO-mt
zg}#a9u1cK!h(fF%6c=27gufR_w9WC*T`3;gZqT0%`U`?kK28|)i9z2O)EPa4(i>+`
zu|a>s-KbnSCsc@Eg(!5EL41*;WW@%}Gl=(_a-C;Ty+JX9?lI^KgT6$YRDN$j`%`EQ
z3PqttgV;8djBP`qdeopogHRs|U1iX<2F)_aHK=nB&qu_dM-9q4+jET@RB(<bn{Ln%
zgFY}QyQil&*q}0l78$hBpyTIyKF&PPLnQ`1V9@Uk>VaoAmERhJ)*BQz=!`5+?;L|J
zF=(JcB?i50&^re8zQ7A5C*+|g49e@}$>tbzok5QqwESXE@5crOFY#o34Vstj$yOM&
z)}WUSddr}H7*x>P^E=(3#Rjc3=oW+SFz8`}UNq<fgL?JxLVm)a!v>wz*K@tjpxp-b
zy3BJOYtUtvdotIc69%RA_gv36=yiksYEYX&-@U@~@gIYx=XkPPfzTzOr@76bJAlyO
zA^WjGKLb+j>X$}#z@YbmR46A5`j>GP1HAAu4C(=-e4J}gj&U7gWWx<AG_EB^R&LO8
z<GRwwRvGji<9er&-DA-G#`Px#?J;PdLB9u5Y5t=@e=@E|4RQv0dS@8a1xS@?CXg!0
z3ytg&AlynQ@xewm2S~-Xz@Q4_dJ~We<u-%vHm=VADZl#+`mJ$&2T1w-)}S+UJz17P
zmm4$;NTt34NQGQw&~oG20Hi{`)1V(1wA-L(4f-9B3i(qY74k`gzBI1gFyyL`Lk0~n
zXe5vdWfqVMWu8HcjO%qkDwHk8b*n+!jNXro-s1*6V_g4i&<TS&4fayd7f7X`Kai@`
zJmWeRNTpzkk<Bq^5s>mxV`S?L`W}!9dAmUm8rNMwD&)A4eQ9LDA)f0s1{DFRQY$mE
z1x8kBWHm-sZ_w=qeczzp81y=jO6l7`Dn}m}*Dnl88|tMX2T1uCWY93<dNq*B+f;+*
z8dPQURvFY}(A@^z52VuasF6Ku(Ca`d1#cPjfpHCBqNiMk8#LOWe4rlk{+$G*Qo7cl
zCgXaSK@S@AkkNbG$bM_kYX*G+q*8DaNaZ7Nr5A4wkS;%ih8fp6Kq^(&8MMl{ZZfDD
zNQHc-(fht}{h@LFg^|4pq~bkd&|i#e97x6cAA>T7d$LOm$^la4ceO!FjO$8+zH89;
z49dmBuS&sCgGK<U@WukE6wEhhgF%lOw9g<?;wZm84H^!l%4MpNl^EFyBWo~dH;_uz
z6GpGqxV~u6s|LMk^o|<Yaf3cJ=qrP`=%Z3~CXh<=Sw_|iNTr~+L4%Cma3dRSP@zFZ
z2F(IeAul$vr3S4suC-|WDz=_L-Q~T2X`+@*H?kQ<)@Wp#jI7nj4j9>oM)t9h^|VbK
zKq}tpMmEF9wi?+sBYVxr4jWm9@WRUkQsHrnwaUkIBimwRT>Dab9~#-mMm8GHYRYdu
zkkVUjWVJ^2kdf^&ve%64u#xd;F&$Sb{&hqdrd)F58ZfN*ecOihZ9AgQh`_g){@-od
zf&!2s;*0>G1-KHDJ+OsfO-TL-3HRA2B=1AQ-62YnBj1}sgdZi2&36>vmv-+@PQ}8=
zLTy2DLC14Rm^q8^nY8|)2u`a*=P$HQK<ZRbwZo4eMDUk_%dz>UdSZtdyK4!{*0Enl
zI2}~1i?oP!>Dc2D<;6hBKYlmPA0DEiv+gWuY4?Y#w)}O%<=AzwX@QigKi6mx9=xHm
z97*q}Q?5mL)P_z7e_5KzKY4-=L}|Djn>E+*7tvC#ML70L9dvRQ*Ia*n<%$S>c9lBa
z2s`{Xz~@n13_zviK0w|>2?@W&*qtQdiZt(#gwFfaNs`#`!OiOlopUJBr2>fG6)*;(
z*b_QqA>o$Kgk&Zp+$EThTn|YGZmWdkc1XCXD<SzIB;34}ko+1F@2B9)9VCD0Ao-+&
zBo(>ze#-Ie4w6edNb)*JrgxAm=^(kOgQO)%G9NEEmg5W+@2Ar9lO!Fw?dc$SzJugQ
z2g!*Jl5aamdhjOJKNWlL4w5k)B&8iB)g2^jJ4l*4NFL}Qd7^{lg$|N;J4in1AUT5_
zPg1_XS#EwRrvp1k#&(eKlL_yqd{uUk@Z1>hr*ybd=>3$0Z-l*{lI-mu`9lZEyB#Da
zJ4n*led?bIxpxQ2hz^n|9VCl8NY-?aZ0aD{-a)dbgXCb6<PF$zDk>L6m(E|fXwk~b
zRh~_5lhH0XTcy&IFImas>pTa%2Gy`Ox@ZMl>U?(6{}}timFg9vR!_F!#<S+1=B&B-
z>NV_X4v3qdbW&c<VsQLc;@BpL{fFFXd9F3zcZg2TkP(<I>va5|&a{5d+;M}R&iY{Q
zZEIq8UON}x*1UEuzI}P^Tzs4IJeQ;tSe`U_JDw*^+KcB2$0u*ZJB`?c`d_x-d0upu
z_5M3g+HUimCsrF=)czVzHhvLEF{h5lF<_oV?_238L9s?EjT(2^_`OMcM-{#rZ?7h0
z$*L-8enl-wR#STwrq?9rLGRE36EBWrF$v_B3DikKFn<X*LV4L7zo?MZ9E)dFuB<Ua
zoSw!_PR7nKRHHE>sCey+hXH!QfxB03uk!4&-X+^K$beTajBuBR=Qb7F11c-jE(K4f
zwiS%4skv@hB8`PO9DhY*iSfu7##B^Hs~uuQIH#<Jtm#Ie3q!S0Bb|O@4dRQ)Eeu|i
zT5}5G^i?+UryY!E`XbGc+K=UVm*>AvTU3o>5tD;Odzv&3`!YO5xov}oV;YHUbpFbg
zA&;x6U1L;8p^QU*KuD^#ws?V=B9MD7{8Ckd;Y86G)j=jy@`3C9E}mC3|Bk6uJ37Nr
zY-aTI7+T@N>nf)#TvWN-NZIO(E9+{Ouc~Ar)FnAgS~6kb^14KIsydN`O<t&pO=3yy
zPKkBECQQ8%#q;ai4im0P6gLy9eI}<>)3AEpb-Rw%;sL8Nr)EG%{c;Bn%N;!Y%E3bi
zg+fDcd4Gou86p)14;egYxI_y&Pq8_}$L{ep>isc~uJ=FF(QP1}=*DAsuU$?XcB117
z;qpJ%!Ft+XKBWF<yVEK`xDnTYA<3?HBhJX#$ud4@49LYokndN3wXsg;;wkS2C47wr
z^|-L^`~3wo(5ch#jDWoI$N9a~8-gWW-!B6WSCruENUbL)cnojoP@k4%wc@EEZ+enQ
zg*OZd^8NCFzgdir@!H2bJUL#@+(uU5(~9<bBa-tQLU=DPv#d9?9+IZw&CMN5=>7OK
z|4-;8{bczK!pdCY_ayTBqw0iRBIx;_11Uo@ux9BtAa(c$dZn@V%F9X`KJ4$#O>?6`
zw?3okNaPIn+MZ1>MuN?ipU<8*fA0Q<57Wxxuj05Fw<Oq{_N<$azqjSS>gH$OR&<s-
zGjLn}%-E3Z-dMn}Vx_Oe4#s~B-R8n$E-Y!;#pNa8_!jyuIM#3=)YKaJN%g64bz50{
z1B49+GEUsPq9#-qU0fAfEcuK_hI->pURiVFvWoc@jJlAzODe1-n^k&m{_q{db+F(V
zbKw>Q-O`{N%{W+aRN5_fZT`UmYFM#?txavw)Qzhzv?A9YEZ9a_Zd-HdVPvT|-u7)<
zTWoZ8{68>fx~1ES<NpMj;nt^>$Nx^ZA=&XGFz2~*GfU#H0C^?i7N(Vy6cxvxfebl_
z?MJS56c@YsQ{2K}*d0+Ge-JLfWwEAp$Ypg!Nl|>WRL+VOY;wo-j5S4AB&C~>{9+VP
zoeHU`HN9y%9SVcx<?u5nA<lysQH%@hJ1W9%!Pap6YULO!*amNn3o$`<ZwfTEtv@HX
z6}j2m9O+{n4BP^5ZTTa{1vY%<7H(>KF}-Ol6-$E$n=0sp-@&Hk3beV!<70Q%!s3>u
zxy=$31Y?u4#>6I$cgJPKnycW3yq@byt%m1>n;(k3GPbETdJ;j#CXa6}d?>dy)|?GJ
zeoJh*&k%n0GX{vDN_V+u#|j>5dNuuyI2HihW|mIu(}M*&Sv3cnR>Mlv9GG;lU?b7K
zqt3yC%|x++#@M^zusb%*E!^pj4mKA&R35u~Abf=5L%xv};YuqDk)Mpa^8!sr((iZ}
zoj~r9+_n?xOEzEAus?Ie`at>}JTAAWNQX5(7zn!)f^J$*6<$&N*w;znMGuZxpO)VE
z8+dXHwz-9yV`+P2Fw-b0+=}MpjtRPjjcx$dFGF(Y28-NOoxbXGO5!at$dF26!znwx
z@ez1#I3>~>%Va2<-GZHC8d}q02)<w^A{o&+{kv%_pU+}%p!8YEyRe|eJ1@i{Kh+$#
zn+1ael$VE#;saEoV+YZ|seBF!Mf!`>#p-v)>KkKE&R}qJH^&aT(QRxWZs|tUMN<kB
zFfEYV+VtZ3OWpZF*Kq^4B8b>m=y!8lPjq!N8{Eu$pc*?4N&biz*8P)>Y^S>+6cY{4
z1!AQ;aijghox9nsZ**leXu|H8iSD%ldtY<djuq~Vm2Qsx4$`r)qKPi>-As&3K%_@Q
zt3aj3nxv>8*sxE;CQf9jN~N*z6}x*1)QjSizf!kc!A_maT;v+=8`pHV(i?AL+m^Q+
zM8)B1yC{CH^04uy5mtH=kBD#!GK-7DXg%ThH($!YR7g$lQ}Y?#msa}S`)>ZL?9iHN
z=WX*KivD2J9J=DyP`?SmjYM>wkES>l0Fh)><<(ZT)fUZci>9?jgYmm%JfYaWrdCz|
z>5Xd<8Pa68MK_;|8>T<PZF`b;T*J|<hStvEw&>3IJa}U;o2!S>I!%U>=}P6Ics{J?
z2hjf<YzpgSsnAd6r)`X6padFzExSQ91xytV7BtF~s~kqVyRr+yT_uaA@kT7asa%ag
zPOB}I4@N$Rk-z$dDtFaA$@@&_Jla_W@H6BeP4VOy896F(kB&ToWjqz~29#IZlkDJ7
zKC=+4iX<LI;In2b7e-bIyE{7rS<`p)k;vrS7h}=QvC`XP@5X+ABG}B`8`#6=7Bu2c
zIKxfbj;4FA+r$nE?b1G6ZH22ZDvqD8lI^YvHJyyU;zl>SrMH{B$?~qgh%tV4N@h>r
zow9O+Y)dLX>5ac<iV}Hh+6()})o5}}zW}PXb!k1xil{DSh(ADxvu9MJf_KL620j?b
zMt|K_^#deZwT_+fdKs(k6OJ!MNV#pQPh#6gx1@p%$EW*~$9sDxLQ$H{S<j-Y#5};-
z_jiH*Cnh`5<4e%KmY_@7b}+C9(Y77`9t4|}7p<RA?n^h-9|Ya86Z2zZCmz30-B-AW
z^J8Ns9#4lg_J$lhkN*a#LF;lSjgK{R=osV55hT{k5e2t$tceZz_^*(k5_DbYuuFF$
zV^cB$7$l0SZbe#)<2V0DmN@Rc<0}{*#_+;m^Mo|FIL+;Z{v=j#yE`twxVY**sN*J*
z-C|>WGQ6>FDT?RGFha5C8lG8=7_G<^;c(lNglM<AZJi4pRju$=OkZahUpED;^gDQ0
zV9cuD6pL;=Sg;i~3vKLR>`y1I#t2b(dvhQkL$2G+KICS&1)Gb*@#jyf#!?tWkQk+Z
z3A<am^_qs~GUaR_R=Rc6`apd)MqxMbR8#AkUm+lj3Z+}!Oay_BDc+!hII%bOnTwd8
zbE6x>$W-E=>O5q6%Ne{ZZjP}9x5r*+I503)xFcWZ8l6>a?0D5*VSW%R+|oSWw$X#^
zsIFn_J4eQaj%Y`7!AsS_aIC2x3Mg(Vu`6v}#PD@H%joa_Mx2;gO`M1jF>PxuveADx
zj~6!6Fm@u#e@Atl?zj-iWAHGOu{{icTYEF^vVu)i5|rM>@MOo;a3HgJj6ghFjN>Xg
z%4n2IQ|tPxa$jxO=b%Png<DY@f8za6u+=_1F6<U;!BEj0aDaA%t3^@#N_wBbRF2rc
z?hO=ZbR+vdw8Q&8Mr9UPpKOaZB1J6URZL7OJV3iGD$}=wqR&2OemBjWI9v9-$6!@i
zl)c02up-?koA~b}#AK6GYV@h-H8EX5BWAvl%5eN4rExqWZ|CEmqj4uDHhNZbyg#Ig
zeu(!?^$MorI(TlY3$#5cMGGmKA;SwHIZyItQ+ne(Jt>lU13f)tlYQ&|BJR!Ot18a;
z;d9QMb2&*a<U#^QKnVm{6hi{2C_z~j5Hzw03PMP3LNp{XxfcRTf&`R=(t=Cf#jT6g
zw%Tg7uAo*xt>RJzx1wSVg1c2wE5GmenK>sH)4uQT{p-!=b90_~=9!sio|$>(nZ2zK
z5Tax!u4&5x+#<c#9D2Dz8*N!zgcxC}Z<x5J_?$xzuy;F@%+aaq<YruG&%UsXRbuCt
z6heW~$XhbkK8Q%9-biZq!J8GJW$j2r(ssL0BZUe7?<qJYh3cQCFzc`s&W3l(+A)Z4
z4pKyk-q}_pAxtl^?_vn`oI}H>8)XchdmrXM8vchKAVWq(Mn!!6g+%!Pqh_rCf;;Sc
z_MJ%u9|&Kn!!z(FM#@Mq_e+RCkw1eFR76^wK_|CShYC8>%OnWu)J8POnM_%CM?=U#
zS>Wln%>@X#La$#6nzku$9(sVFp&!t)b|GB|l`o+T7tJg8qIXg-cn&>40%W-sL?+7$
zr040P3}Ta5be<Lm61=nRjn65IFwRvlveshYh}>x&8YFGM?N35yO5&VzSck#0*a>aF
zgrBZ_(#nHQeM{!g|B1$fj{TYuh-LrD&5uoDY>64`rKW1-VsB@=CF^ZxnKVR?j73~0
zZ-*t1C{8{zns`pMZR`43ds?nxG!L^&eC55h;z-=Nc1y!?7j217Uw;it#eR0WIz4)*
zfILcUZC`w*%UoRhZ>PQyChYB+fX#!wnpS5|3w3W}ip?N%_oYU#?*fpnmuw*>BTXp=
zQ!Or>$uKJ=OdwoidamK3p$O1apg@dggPMvhu!@?Ok3k6+QYZ(aL3!v>6s@qBN%WK?
z(4?if&?M4;K>HD9*sKqJ3RWK|V%Ch__z;-prxAn=nQ^=(h@h2u=r>rvIfs(hnF4+Q
z1T9<FPu$b|bTnh)UdSqx>kSe%ik`>FFD>YQR%stC!=Lm*jG%3S5QO$_u{Z-Ru7qj`
z@?1;i2ejAO0f$l6U>Ibwt4r|MeP8_`G7Ca%G?r&d1APAz${;A2m8kY>&qcLIT@_2C
z<r<2!<r^BKqb_h)t~mLEXyQDnfj6M0<?5O?6*Tr6<EN`LbX9BHAhE{wKQGlwymuAP
zNUc~G2}SQ2vmy8KZSxKNP3zZc;_+cy7-zgLWBvLvFr9N?iT-#9{hx5TUbr-a<U=wl
z(`li?`fZlP&|kW0!-D9ZwvQ$2=eA6QTqs(hep#?a`pqJcOVPqm5t19htEmY0fC`2#
zTAp<wtYUC-ZijT&NlXP=`Rsd^8aikq7y1x}R8&crT%M=7(bUZ=bG*zoPayX7XU1B#
z?@wFRkmDr=V?2yOz?Wu#vp=^OGDWrRlgjeG-=WMwL9MV&G$xtczodEP8Y_vm&UVvW
zbcNM8y}0<Cpkf5d;U5Pm5=@B<0o8@y80Du&8;35=Rua1SLZ7MLCA7JwT8jcaB>w9s
z=dRt6{KdX&p?VD?$i==IL<!w82cN)n_1nsHf*O4x%IMCva|9Js|9Vtvc0p40Sy|c&
z5A!d>SmP(7l0l@(IE<<stQZ5I6)PVUEi#sDdw)N39Hh1tI%XsP?5_4PepZI^d-+}M
zZZ;1lJN>PUj8lQaj+7pj@=wVal`$E+soX4E`57LZo(-qhS^IgDvqoZ|7=g13{j{@F
zCL+OB9DW!$4KW#ST=;{Sx@2SoF=a@^p))$bVu;S&?SawBSxl;nCzwo*5Mx=0s0c<{
zSNhYpn_&_uW7ikFeR^kyk!FynyWtkhklP-H9pUYWkR2h-Y0p?jM(2!Z1_K;<gx$_?
z&vpu4Qfq52d-nyGyj<<5d<cq}8yL-%7?1W+GLQWS+L!F+j!1Fzg(H+vzkK_&s22Xf
zD2rxHg!#xbp~1KVw)&fxjq{iclxH`zhyf;E;!&gnQ^?>PWD+vIgHwnR=dtOACq5Q&
zT!uYM5*~7tU6?f;jyV}~rTmZga1@-8=aWQM479so1U(Q@q2`8c4>L)ij2L9NVZb;?
zr1&D7H5POB(9QUBZ5-^)9dAzd+WAB4>q>{3HI`B<e#+1#%WLauD(Z*o)$HSk;{>pt
z@IOw>dBkH!N*9;ZS<0+;Tk5V-MjSY&+Rkn}3zLg@ycnmloj2?YG0o}Z;U!w!+~B-v
zUkX1yr&mJfTlQ7Q(&<MyY2>_ZeDTyT7T8XgGuF;K1{w3>b#+`jww!+&R5nra*oL#m
zpmMyDWTIv~c6ni;)Opvw1KZY|yxv|SzN8l0f^aI^a^5r8qr4@u$a;DSE@&yUoc9g>
zXuLn%kiY^~&C-%m%h_vxKbVp9F|XZQ&Icy3T(5RQc~yefM_A6k>`#TPzgLBoK|Eek
zi6}p`rw9Xhk-Dz3rVh`57>_pNQ2-t)Dv`=Q6X!^;TCWx2QB8v?Lc%qPlBxi|-{8l1
z`oy|(z`kC@IKksdam)GK?ji0;9^U#$#H-~LzVn3%Hq$Ff!G3A~5o<k8-W(Jd*5)kd
zD|@p9p68X6CMuW4i5-s}bI!j__=O(Um`h4Q`nCNRAuZ#J$iR%P!>h>O*v(SJi@gTC
zM<Y8pop0@zg|Lb*stZm?4;s>1yw@!yCfM%`HsLjB?0A&YA|8czzPH;Xo(4R;4xtk%
zL4GhnF7+A$e0!k(*k7bW_vWp#@$#jtCrX$fC5*~jV|xu6-5%tS-33RKRNgxHv2@Rh
z$IDnlEN7_Te|8uiH^4ZyQ!G9kkw|+8Nyu?15S4c|y!ddJqa5DXr}D0|Bk!=<yUuzc
zxXJd+Edz|vGuT^gFIi|gY0e^KUFF@0q`9_gIT=oqBzX_wB}NkKY!bT{WbzzP9Gg#_
zm_xa#y!$~KV1>M^A%DpBssoR+YZ0QG!-lHz9<{v^b7_jx-Qm$$mA3`4%;q%<P7fz0
z@xBVG*{A~52zi9V3k4OfruC`=T#kwDEzs!)WP6&p_5ee9&4^!YIlT<>E8AO?a*vMF
z+xY`p5sJeR{LIQF@tP!R<WVNttMQ&aSM9Np0WIlhXRXNPI>#$R>*NhJ$N{QrKZn{t
z<!yHY^<^$=QqMr6TaNEx^HD{v{KL+MkjPx}q_#~Hs!r`xNi?mB>Uddh3i<FL(j8QT
z4xTYZRGnNrdkd%UPDP2Q72%)i=iCfTI$>AkIZwdh)lQ2i7T1*3TdKdq^Yl=hcxw3K
zs>(zh@wVR*H9{rCKhlFSB}EQYvJK;_YOtoSmO7c3q^6#2;I0BoEptW)!uJ|v--o3d
zoP~mkvN_|X8mzNhYPoZXAY)#`jODn!My+suDTr*Z;dE%p8I>zQb&2z!AalG1O4m}C
z8miuCO4Zo50@O-_$^}o{UV%mbc-_)?nGVos`0KBu<qbr2HC2{sa$c912O)iI-KeS4
z39d5aLp<DGv9z)@4pj(+gZ&rSz*AWYab0F83LxUIAh;;S*;zDJ8e;6ifAHEQWpEG#
z+K)mJzb<T}U0CP4RNx;-yTeNp%?*hJN+ntVuS`6L8`4sIIzkgodFVw!YA?os6fO(B
z?hCyL!Ha=?_ok45QfUt>%)<XMVACE!0ClUg4{(gIowk6OZt8nr(g{yeS&F@|t}NM#
z$+NQ5uQ(eoGU8?y)!pD+Z%IRONn&v|w+5;n2J1%-GR7k$5<GMpSqe)=<)~We+3}b(
z_BKu6K6rJc(z+kDg<E7S)l>aSh)`3^o*&g){Y_A)D`QJbsh-qP28FtUol1P|P&06}
z`anooOOjPp?VR;d=}_r-As*3I>6CKSF@j<hsgiw1mg=j<3a)^-8OxWT&8ZT>j3CCe
zl|0oTxRGcpxVfulNwqN5-y~jys#q1rW-4`zx=IMgph_p}>adNRn#fWE)Z>DmfFk)6
zLigRJU^~i|t}D=HIJ>X}x=>^(<wy^Zvp{_J5;!zH1(ZT>s>|J>Kc%Am>D7gb1>v6y
z{VANEgb#@J3lU3+;%X;C_!tmfZAz?T+{XdiSvpM0Py0)YVTKU)3<*m)w)+8HA;HKb
zCD$G;yc$EVKZIU{;B`Mfj_;P$BzbL+?_Ljgw?GLll^gDqN_zv?EIvMNr*Ta}Mbi!d
z6C-T<?ze!u+HM9?C7)Ir`BbH`7%=ICqpDNaVmP33^=)>_@A@gaH!)SG<MuR_)|HGy
zhe|K4(z{a5uvM+J!HlacHji-;9-<zJ6=RSD)2*f&TVPA1J9sRn!&~g(+R;zN-j-xs
zulj6We>ZNqrJgpVzE=|Bw#RrWB$``l@LBaG6{vA9#P*3F9tJOKI4g;Y{i2B>n;7gG
zv((O*<~Ik{Y`kn{&FR=*h}Z1I?<GUs+mjpk#w{m<$t5sx)XT;z*TX)*$|dL(@S<Hk
zI>T3DQZ9M@tu(F(sd#K2vYbxXRY!Eag!!+XjcvP74PB?f1YqBlHkqX5u`5VQxL7TT
zb%v+bMb#!Tc3gFF>49ouGbAi}E-+P%PQX%i28YgT9Jtc^D^)U<5K44lcyqoqAYK}4
z6?80e2i4Rv;|x_&L+n2Bhe|REV0mntV4#tp4$-Ng+l&22P|!$c@%BV@siA=?nplI%
zvC_DqfndHQmq6Dw#`46Hh6d6`zG{k{Dj4V=ZDCq!RjgD{P(ZQ?6Frw<5b8&FxvLEV
zipPv&RI@=r^91&-rPdha1hQRSM!QNja;mkl2PBP2?EJMRZHdXnzIjuPhB*<r>mvW8
z6^j}vB969Om$hs$zRUezzB>+>D4V(OvQ&MSjmmdfh+11!GYGx95P}z*mGAP7XidQK
z5CUL%*R#g{D!_Ij1TWrFjlifWzPm9bW6^Y>7qAb8*v|v3?y^O#N+#$5N*dU{`!tk*
z@BTdubri%Radi=h0pPz!s1*D(V=OaGWjf=*p%=?eXEjW$iy@j267hz(6e8hGa2#kM
zy{qtnQp5kQGWKd`ri<a8W#YS)pwJw#>~xGq-97?DyIELW7H`1igQ1Fvs>freK|e$;
zLVD_nu#I6GrrIJtGz^pVax0tKYA~KxIWu0j<m~eD`Zy~5lO~vtv5g<vxia?uNy@<`
zp1%59>=$9O&xFb1VNe*7+k%AuH{<4}PhUMJD$*;dt5|B<`txCIH5}NhzlX8;?rRVR
z>J3u%U8e85|Hl6)6_Vl>Y0K>%!6~n7fwSG*WpH%AD876=#_9Ez+jlCY1YOm=6gzy+
zj4!v`ei~x~lZ5T==CQCLvhIr$^|XK8{u<$T#~YkbjqWj>WRM>Pf#nYFERL8()7)}<
ztVVK25X^Rm@nXL2oLsQn;W~`fy_RP+0;k(u4ivg0SOw76bgvbTPSDP1_iF9b>Bp>W
z-d*au0~lAp?Lh4b_hR%zmODr%<bsYl_gymKxOx;57A$)#j8($1kK=TzUtCj{$UTgr
z8*f8(Fii;Vy75L-r?Wgj(v7#GI$i8)X5H;{co^Q4>SWp@;Ma|}r8+U2w?;dTr&D0k
z-Ee)X)756JP2;q=Q(!*~nsmZZr_lZm4jO?Nk~qWcOiY2XpRScL>~J&qM~BMWS1o6R
znW*qh^C5Y=eGdsRwr;^?d(L$G7!YIx?jg?0ira#{GCZ(an$SbXSCpPeve0beGa#4B
z>Iyy$>-@ub*d8v)4Y98W_H-o9%<NJVaaRe7)2lXNO`qZHHiXj2V-o3Ib*50pXi7-8
z;=E@_vICU9w9t9q;L*Rsj!rH~R+V79gy|}S?;Q-a52$k_&Rnlr3-Dt@(O)A>e4iNX
zAS>;+sIATny9iQ9C+s^9c#GkPc+AaTJZd4xKhmGh2ffpW(&<{=!h!ruy8+}Gfjir|
z&DqEB95^_)%ftrDFV5n``@yUY&`3OHWI1;lw};sp3>huwS29OI={0cUzVmD6-QyU5
z{XRCkJHK%_zvJNUc{0GR*qLR2YtpAP+i7xsiBsP?`Bh=^GI?h?mpKnge6F`*rf{&@
zQ25>o=D>2A4I=7Q*CfuuNW^m17%pLf)#Dt*61GcctwDB;OlL+fceEnu2AWBgWn~x;
zIqM8bmeq|DptJ4Uz*q*r9A~wCEL4VOvf0+g8|wHtG|V;j&cRwnmDOgNWv!X4^u79$
z@_1tTf~xpZO5<{aPvfKzD(DrabwFCQ00p;BX2c+|$mcBS7CZe|#-43;Gsh2{bM2GC
zONMclIoH}fp~JlT(#7#5CFpBvco4+7&NMX3ODw7q_3B)2bB>6m2|HAyZZIgUMB((d
z#@%ReLr_UYbT=8q7!NmEUM!PKH`|<Ca`I++oJ3quUQ-8a)N*by8Jwf5&t~JCtEZ4}
zwHu{2o#&O7fY}A2u$|isqw~Bn2>lM5mXDLS(CWq$5|%T^9*Ep!h+~4&$DNsjyrQ>s
za$VExb%FMk*&95Ls?+M{>a-j^<;Ps>DPY&Dof<C(ul-$JwS3H1R#re)hnOfx_-43s
zjH`7+%uCc<#2PZt?RJcmhF4!(0{0-}?v4IgdTeK~3>clf{?fsR&OwnP*1F@|bEUZt
z@hYLxEN6(JF7PUahbc9vLpq}4jn{}sHACjRUrIw58EIm*C~&p>G5tI#uDKs>0*tZJ
zc93MQy%3^GCyZAq-9J)p)mo;r4XG8mpOohsC+fvS44!$TxHHG#FzT_K1?~=EJ8E^)
zHR3$`QAC#^j^55Vwf;y%UMuHQobgJt1_aG>jhvtkh3&Y;awaM>Ueh!)fjZq#pdF)O
zTh19q<;7$U(sIsJrw#$Hc^E|1;{t6gE^yL!s!{Pdo?a=zu%z5_rWx#!UYVQ%)7Y~N
zwkKx&puDg&K-#knwioh-E{u0`JLlUsB10L0JJ&hiDd|b^NuM^)X_abhd6mU=@$!jO
zl=F@1aAZIi=vL<fgI2myE-+5iL8?!gmvI&bDpY22oDyfBs1xc0=~5RtG)kcmFb3hd
zF{jiZFlxfsqNIvuk5lH{CIZgUIx6n`Mx4E^Zsu}oXP#Y)JY*PW)VbKbhj~KrCS8@!
z6p+Emkm=H(I_TQ5ET{>Hiq<SLYd<V8iL1c*jk>p2pc{W{3KmfX`u;9ckXTj<?g4gw
zr#QR9Zlk0U<FScsY<H{kq=3=-OcS`r)Fd>&YK)_u-<z1Sy_#x0i{$(vEPpO78UFql
z7C-xlvE?YydktT`wUF;qAB%W$wUYgl(n_{}<X>zLe^wKOlR;jI>16I#9CkT*L#%Gl
zh;m81v%ubhY-a@SY^PaG>kWZYi>*;wi<xe8tzn4s&82msQ!h6t^rWamI6PQC@#16&
z>ireQBLV}UGG2x9SZA{BYwlVMciJpLh*mX4*hL>3tOhK!=Yf?B<BT~=oIjAYU^>OA
zcFc5&t}Qi=wi-|`r4OnNt0af%&c&t^k6LN<luwEMFk(w5+}}y}nsG6VHa9Yixq*~|
zlYmato2pHa$W4r^vlp6MoXByyc-kaJvzPUkOyfqg#~I6Iq9tRV*7Vul;*xs7bTydn
zPzExCjYScI>Vd_~crDjpvP@JtTK8sqTKAeN(A`@seC1l*^m$5Wk-Z5y$<VHEor}GJ
zeNA!Jc|md3p{>`Oc=g<qlkh@arWfgw-foFG>Xp`1$=SXc7_>P{4TCTrF@wti4tQK<
zkX=1=h@}?=U3`N<cY`|NiBHQ}ZZKJ1ZAo2y+*JP+1`GR>Gqcm<=u<8+xb7M^xf-g*
z!Xkv0VGpk)q+IF!Qy7JnipkXqoc%-aMw7dd=#oNYlR=`pky2V^++$?f6=s@oPw=Wa
z>*uUCZY*+2-kXhks#ki^xDxWS#$bxQWp!9U(F?_Ey+xu~XF_tcVl?)0gPmirXVfIn
zUtD1#m}juFW$w{g=Y1-9S}2@V#brsuX%%9XhZVpQQ7#(2-a7<huKq>1lfc<z$gZ=!
zx_HI(ni>?_l?I0e!0OppTz9TA2(0}Pp?lP;4H7GW0n(W6*BGDQBI(+Y{+FItz?88*
z7;mVp;$YCZR*FdFVR^6~Qr2f?o$EZB9I`xE&&p)b*Bdm}0PCk>P1~SvFzBbTTsh-n
zD2E$mK%nxT2Vy4H(k<sEgV~9dLacckU3;?^t`-Vb-{k{~&N~QADJzDw5V4Mj1te#)
z$4drP-dnaFcHC;>#EN0P^pUq4KK9z^f=jDP>f$o{=-grQc!0~4m30ZIJY5ubn)E+|
z00WEWH%4?{*)V?5kz=~iDYZ{TtIROYNzM@O@BN^DM7JDobc?nR^G%J1(yhlFB*uRX
zKh$6`qf&3qx}tRz7;FSsQ80xD(TQWq`iZrRQK^R+oR86Gy=bRkKG+#<ywbESI>MVu
zJ(-s-deCxCFgh?AnM3@Ep0+$=dIWlsVLRKaom8?EgICKLX()2M+Axii4Owq46Jx)E
z<(%San=n^*YNL#^zcFZ+aBA2oGT1>hYGvcaXcPGmM6M^4oKp=7cBmmbO=R!njqoZ1
zq5w70D=90h<I0Yf3zUE~xgwNOU8%O5%j~yNEE$2jz`4rpg(+vK18UH#U1LFM3*#E&
z#7Z$npzaT1j9|!Ws%E)8m@BQ?RqTA{SZENs<N7`vFKVOl2ea4;TLV46<^0F_Q2Kcv
zrkZrSKN<oU8OB&R<Y-eMFfuTmEM0xJw!3YmWlSB({>m}ly(9NfV<^Su;pFAQ`jrG+
zW5)KE@u}Dzp0Pbp0;aF(q;v(q2&=3Nj0O@;H<1@W{gjlQU0sE7Yt+~SC<xX=YS+#N
zbprdtaDdyzU{CZe!u*-owwVTXl5D)0OhYwhP*CsnrU9bwG{}>I9B;PgWEtEkVl`M!
zw(`WvC^8EPPItw5WhW2Cuk8$J_`$m51lUd~=p&2)HAx#>M;e1`s+HD<EuzAXqD*6i
z?QTYuEw*!k%g`?0c|t9K(_3LVThv0~#L6jK4z;;eac0Z4`(TKd1NW2K-3P3>R@y|C
zQl)(n!lo1M?~IBZJplDbhEYY4V60LdUnX-#qa(WbU9YC9OfaV!3?_);%TQRlQ#vi8
zyDDsls$vmp>==WMVeO_=ieRh>jbTgsyA#ehgU!*kXnaK1B4e6Nh)}ztQdwy)Q#u#g
z$AaT@!b6-`<Xt#q1l-lc0+&gxo58@4<5d%|flSQ4uFc&ex;95WeX|R8ghcd+Hl|fm
zPDIyCC?0lfx-lOa(KZ`2PcWG175Q3PsZl+>BVC1Ks2+Ak*!^J;gV2hDuH+*7b8wy!
zxQ93|d3+*B%puEp*_ct7uh0YFR}2CrfkDr!q4G`CEl8jd{3B4g9v>V*xxZ#~7@9W9
z19MB*@AA5*+0-_dsaU(EZ^B4Y*TpwHZTus5P%(i8_NKw+da%E07gWi7z+0ZlrdGIb
zOW%l<ZY%A4R<kPmW#lKF@M7m9w|r1w7w>oVG@KRbMY;p7F^Ms2z`T7NjIcZmkgCy9
z;h8Y!6N8L;mE)id(CL0^Fv!eQJ)iWM!DPd<(1ViC-RZ`pgDU;Pog<FkR@x?}yTq;o
zOX-BCI#0QLN6D+y<MXFYOqL#~{>?bicZxmtjB!Jca`J@J6qd8iAgN0^-MZZkG$|)T
zFp*$6I}8bGKS%`itU={?i|UZ6=Zv$rSB;r>=XvAIg;mE{@4p*&f6Tx@QZE?iAgL2C
z8rKl77MrjFSAkbMtlc#N7Atly?KGq#F~kMyFBxZ%S2DR8*O(ycf4E~rSYt4&$8}8R
z=rxzCW=`G&$)T3;TLw4DQu=)?Z}4^qGD|zKx=pbv83{y=dXGK=!-JC~zRS5<-{puI
z+cnJ&C0V)gT~0Cj(oY7fIK0|Jl8rha+uUR3RdQzXlW=YiDru&SjXyOgS9W1p&S$|C
zq;;h4L>zAA>{(eq8Sl;2)g^0XNYP39!k(Bm#RvhHEjzx$Rb;Th30dELTeeFu3teR|
zp`NBUt6aZAgk5FlU^}|YY$##`d=!3qag00L^cuhK?vfDPyVpM7ulHOq$}U-+g#ARQ
zxRXy)$vP-ivXCP3Y<P9GxuNf;1l#}wf)n7SQ|A`E|C*L0XfiSzM7@~dYXJ1lLJn-i
z&&d>7`$L5E=tYB$s!=GI4Ch>RGMw>FNv3@tl40mE`1>yB*nOFD@m&rqeV2ONmw7p?
z-g3AeJZk1UlVq|hXq=OcS%BUTn$2>i7=wb#Mj7Y|eVGaE#raK6p@b~5U-aE_prTy7
z306_$Ewmix4YdzGx*vQqoU;q&G2b$2x_Tb-ZR3Oj;3`QRn|<|c{yWA4YDzT4KaD#U
zIgTo4kFj*J+fy&+tX9nVP}W^ERhyy0yn&wc+Nbm+SfGDCYEQo1l;0mDjZAV@*mo}y
zVK7_RBF1&2pbyheutlA@GLfkhJ<rVl8dLIoR}bS|Su7H(+j8caIc8*Aj|=7-M4DHI
zyU;A>0^?3cit{l?YNpq8dcIR9Gi%ybtv3mv4O6!yj0$2QzKD?Bf|ui*%Urgjz;@PA
z4RL<yvMcjeaMEy*456<LBGmC;7iM6^*s97B^nTYHjIRs%1~X?I)waNmW=2_7Nos1j
zM8%1Qn@o<fy$hk`^|H^+28ZdEV1D=(!#+nSP^g=YFwu$5s+S?mt->!Y<I<WcDj3VT
z%}o=dp+B<B`P5!V!Wo6uH8nQF=wjb_S(LG)W;w5zq+l7;)Z!8=^eeBX2#*o?E+?U|
zodAOlUlepN_P(6q30nhaz<N=WGzM75N-Ja~o$Iv%l}<S7oF}t4UR<8vbIvzbhNTB~
z^NiERc%q~ZR>*uaObROM1;*`zjn~i~B|*+e2pgTWo0AUW&Hxn$GuS;LI)WCi@6tRy
zN>67S3mx4lHe1=V9NW$*w5+4Kwr9_FXjJs!Oq*q&>(Hb)nntZXM>hT*y^ch49hz=^
zup^sW-tF^bIjv909FAq|^BvB@9?dbSJx_dcms<7(4yUjBazt$}kl=l}0%0$7Xgl_0
zv$jh#b)4f7FlX6|q%X;>wCqw1afoQyWd_ZeB|EMim>;#v9qRR5y(P)6km<)<>_tde
z_F{+SWA(GmrZTN)FfCt_tb+H+NZzt8=Rf@232Eek=aXf|ZIjhs1aPt#^_$#0uyeAQ
z^PBu*AX*7F0Fy9$ht(d%eJB%v9l)hdyNL5+WpvVfwCvFwIbH>K3NL1(kbSm&FVH-8
z@oRifJrTnSDUxC_^EO!nY3AAIut+`vL4PTV>0(50@&}5%XRyTkfh;eW%eH4~R$~Le
z_H4rE!F#}k#<AYPVHU~Wxy;@{I0tAU&yh;4$oaWqEZB3&(kd4i$mTrChPRFm5Hrm_
zpH|u~x-r||fRbnME%*&!<F@SibnmB|C3OJ{s&fRc5)`5YSio8{R8YDeEhOR(M3gSB
z#<ZDKwNgg&C6T)F$vl}|#%xbVM?HY2NH9f)YC*z>ff|hdPrrw2mlr^`&ZgqQ^=FN@
z><TtrwdvNT0knSX#SBpEBaRCTExVGgjdXE98((JGRm40-3}>t=@X+CccmwTsdkKC1
zCA6}^Yiv1svS2)7*U<N9WMx3*#Okuc{c7nqNBkt@xHy(P<6+Q?>3wAo^e3Km^n4zk
zgE3TO=euA@N&Q8ZT`wcZP4foBh)Y2yG<wbeGbFW_GJGT*e3>Dsy^NR(h>>YZj7qr|
z#$G}6pA7o!sxng&mk@nyhNeC%IOSqrN_3e)%TkoRlBmA`b*xrD3refvCDpj%&pyfd
zmNgzf>u)0%6I#q$r2Y)l)^UUI?;XLjp?^t_E>Yly9D!kBD+E3X4!gI#=>%MHwi>vT
z;Cp-mz?lT%02UIM1|Ugb41oIyi~z75K>lLHF!bkey#?3M>j3aktD$!SSVrJp0Cy00
z6u?#je+TdZf!6^HKs6q^7r^NRJ_k@v;0FNf02HJ{lQ^3u;3U^d<cJTj-3MNWRmx<u
zt#_^b4usZm>+tUj_zmZjv3;%B-Os{jm@W&;)+_IBrba=T)LZuTLdM-|R^iB)Wj&5x
zKQz)|m<45>oo-XPUIhOUS`E&ysRqf>G1;(W%JCZ}`;F|&?SBu(Egy^uodrkG7VklJ
z<P9?0{=Q3R%f=tj<WG)~L8$t!K9pMUCNG8pkSUy?&}SG##1^KM7Hf}1eEwI1OL5Lf
zLoh+0dC(k3+8Z~i=sjxb>P_*{ryV=SIX-){>gJqctD_%QofD(g%p%pNNJSGvPf3ne
z3vQ`byVaac&6_tj->P<8y84k(L(lYc)QTxpDr2Kc7L8Wv8~wF@rQdhd=w|=#>g?BU
zR>N)~a_FcEbyL$6wb$DCjlXo%Xq8r^mgcMUBGqfPikGWi`Rekfg!<09MU@q)-U$_l
z5C0E!hIIEoaE4@EeYNVman$Hh$x;4Nzn@yPQ61~Q=1)b;bJzI0?j<LO&OK4p7pcxg
zsy<&G;m@f!cl4;yzqm3vdQ`==CoMneqKZ)!%{%;ID!N^L)aXB~ZnFJ3>h8wX>P`C=
zb@VN&^LBspsG)B-{j=KI)Xy8s)fd1YT<PDVe&!_9S1UK-yAgzUs8gN(wkq=T{gz+*
z$$vWovefS{eNDZp%GEuW7U7%!>fimOO84`ffmwd?5p~r{XMn9T@||O|f00yO{CrjU
zMLdZd<nP<8_BJNev(_y;;uUJhYpSJbqx#0m_lK%0)IAf_iA8E$(FE0yuTCveXBLf9
z%WoMy&hK|h!6xVU9{yMU^J>NRJJpK(=G&b9J^U?d#l~?%N1b`|X#aV?!hft{^eGja
z{WDRxJN!rd*VSW}6sf1&Ir!$|TV&it+dhPd{JH+n4?a|DSKf0<a<f`GN9}0zyDeAm
zph&*99`=*|Q2$K7z|WdI`uCegRX9aGUY}esR{(#sD)nzsZMMG`x$f$3_xq|38{wFz
z()Oxl36)m<_3uIakBVl0=&k-#r(X|5_PpQhU!Z=u((k6eaLU!sS3=%SzN+)*JTkAs
zPoAYVt(>AhbyoYYsH;~NsRMwL&cL4j2mbkBX0HFbpY;_Iy1WV1;7r7|$^TNlZlPG0
zImg;+7-ZisN6mz&hx<iy=T)4g{(0#Xb*);h(sTXe)O#qWThwYq(6D-tT5-#&emhj>
zInL-DKRJ1Hn_q}(@>wHx!Xdd~$#^{qXruaTlfQcTBYt1MLTz8^=c<Rm_I9v_ufIVp
z1?FGYUjIzh*Z)Fw_V=oH8d2)W%PO2KG-l`uizlpY%f8f)x-QKLDBJMwazJCd_-mbU
zoxRhWz02Jz)SUFE#y&H4+t|N>d~C*q{8(dt?yP)7w8ezF7vD>uRDy7mbvS2Cer(xc
zVbyRaKi655A5%Bj`MJyReHY(KeE(zT7mz-YpL=nBYyqfl1vU@Z1^F>&y#DOZ&pi{a
zru^K+_<WL|J3|6g=f{%yx#s}&yZqd<@mYf4v-4w%@^jCEYkq#gocvt4ohkVR)%m%X
z09p!)iOhohK?G2F3721JKf*r0{RK|?{2rt6F29tKV<piQ=|2n?jQ^&2Re-hsrg_F&
zo|8Qd4$rF1j^xcH$UaP2wYvo<hQpS}Mgiz|JLd}O9C70xC43)#<dWY%YuM-aM6gY6
z_~kPVq~Vt)Wh$49gB`D9ZF2cN5q%S3e$N)TU^Blu+$I=x`Y$D1G$ma0e}qGCr~h6A
z4{r)T1)JOO{TM&wvJNW$KKvZ3VDq(*@?H4Z);SqSZxDV&^LrwGpgswo(HgulVp)I1
zj}-iF#ZOuF_U8Qn{v9|fkOTI*q^d<v`g8mUKZ-B6m?NqA=<c||8{mYlcmNYW8_zT2
zQ;#2_Y}!oV7LDiUcKlc=_`L%^p&@V|ehACY;{l$)c8&iU!vM58VSwKn{FJq6S0e#j
znx-9rz}|*bJ~5Kvy9@up&$iBe7XtbLKjvZ+OxvsQBg~v#D>*8D86R#bhro_R#`;O-
zif4j}^M#S(27E5lV367*6vsKbNcdrqFemuv5}C~p(*>5F^HB=meO(iI$Uxn<t=atK
z<0p6m1sZ<}J|zOq;D-+ZgL<JU8blZ{(O$O-HnYx-hq1@J@q3aK>84j335>=Mx#NfF
zBf;kz34Cdan%}SR0}Vg4xj^%3BY`jQW2F3^2OCZT6Zn~SyxK_MM*I+(9~xCc6j)ah
z70s;6QJ~^O;5F@dwUNN5fe(QzbkV-rC;-}_gi!$4xFohf0=3BL75E`(er^-+oWS={
z2>n%E{rNFjzp064FvW?eZfat6H}T%YL7n{NqaerP=UDYIetG#Z(%@&d2KjW)U+^OZ
zzkkIK6#V>6gM0DOHLpI#?|9+lTz>e11?ncBjDApxW(GfOi704(zR+M$LqJP@**cNN
z<B-u7{FpSqJMaUVAIcISrO4I;ke_2AP&C(|*#Hdk$y%y&QLy=8z&r7?t?5BxEcbvk
z2l-|Nh0xj>Suc&y+8P6j_W&Hg4-{5}fT7qJiZ!*uQW+j0E$Cd<-Pe#ZljE0?1MB=8
z6!2VrOcS~(Y(gXtBqT-2HpH@}N6=hSv+&d8nJxle-9%s;ekA6XZ$yCseoP*&4)c(z
zfro*u3HTwBZyO0vp5ow{(|7Q5tisLw^1!2b5Fpd^NY%EGhWw@SNVWoH&!kN3pEd4A
zB#ae2rbPZ(V+0X1a^M3c!YuvYq?3snM_PVOL-|2;L~8ptP5Xz&plLHiO3VJCF=*NJ
zNNLzVGzL|Y9;}l_fB(=(fDN4<DGmOI#-PE|Balu7BvPXbhaXcoUxih$4`M!ESA2eq
z!dch!7!r6JKNP{buq63<(a-RUSoJxPg8a>d8Dl4F(}6}Jf>c>1tk2|xWg`3Y0rR^Y
zKZu(j!_BHN0qS8R%SRh4pg))32V#DxTEWeujg+qm`DmDrl#mZKJ_w43@Iy#`Ovr~)
zLq7E1Lf+r#fjmQp<i~`(KQ-k2|1IRbjdMXhUx(z!guFL3<h^0YS0EcUXJw@w5&=<H
zh$BU5>}_O~JRLvrAwVtSQCZ|oNKq(z|G&limc%<Fh?f8(gOW>$^Q{hX24#5wWki@?
zQ&!vmSH0ifq29BOq7=7FWle{JQSoa^bbFX?4OITcqV}irW0G2z+83=$?Tgy0=}$sl
zjnGn!30x~N7V~3b+}W7YyX|aD>D_jQyxa@&2PEWleoV-xQ$s$T8uIBdWDT@XD}Jbo
zR6Or%9fYEnKbo4<((vtxBIqN<P&^nPYGz;q!du|fM)M|AF8vqakhgYan}Yl-WP-?}
zFo_3Ch@YPcIGdllFyjU+Kf45+%}<ten=^iz5UuzBf(uX<lX(C?T|=V;$uszCw-ZRS
z9X}R3zc1m3eDcG|O?0I{;=_~F!1B{a!0G(V7H|eX7YJC)&uWe3M`x^<pWh00dcd2o
z1{9Nh0N)42yO<xt;+jwiodV=!?Y|Nq9e-F7j{((&pJ|2!O$^tCF)#~cn5ngMdoE+T
z0zViht&lQ>PKq7){sX@hJ9QzPRe~z!$0X3MCx-%gqWDke$N0CmfIol%iXWo4A}Qt2
zPH|sIQNKk<O&mXjm8K0vcR<@u{1}DS?tdRF*9Wu_%a7^lzG`Ie_C0<``>Rw_wY|@I
z7UVDKko=gCyHZ2$N)5Ry<cTA!dOh&q$Amo0B7QX_o(3j(dJ`3ipSXabA$J@)xAFMF
zm!H$|<4Bg@X&UzVJzK+JqdOTj3c4D9d_sdOTK{#ehl@ML!z{co$S*{727zY+Ff<l-
z5NO!k@-ng=VXlec)g6Z1(D2fc0K=n97VmvI48hAv0z}F!FWemwp!HQxG_nHBQrxe_
zJ3dm~Jn<a5Wetj_n*$8@yU5{F)RO?W6idApPizN>N*=iY=jAmP&teB?(k&>}CwF+X
zHoz~@w<lcD5yf-40hNvv>DQav5m?fPdj`jdd4%_HpY~wpgfK5&IGjY-jisO^TfCqk
zpiAYSN7UpT8V|%0m{^59k31L4^RzrHEWWE#eR+=;PruH_mnUDjg2Gd;JOaiOuH0?P
z)2&?M!(molSj5w)lW?O*RlLsPY1ULXw+>(zu&kwVA&M6`1xr)hzJn=!xf6+7Iso$+
zBR7y>ZHha1%nmZ{50N!5ZcPaGAy_<xB^yP#87Mek#I<m<v5rS_^u|=~5W<d9VS>9u
z%vlaDg>f5rzz^5G^@#;;DlyxlxeOj`z2&xBy?)I3E`emnHMjlg4RKs`HY-_rdp8%L
zLj+D7z1!}#xZZ&Mc6D)KjEn5z(i_sa^-1r8;@Y?Dd*TsF2!<yXjbM2FnJM^idsAsj
zGv?8&Kr%eVVlvJ{qej>~zZ#SQw+8F%aVJc$gNCQmM9e&*6G)MVmb7eh!@P6Hh$(8>
z7Q?+Gfm=4J@c4017kCg+ij+G&f+E%XGkDZ4z*yYQq03Wy^4ygvUv7X1HhOUPgDE9V
z$1T%Av2j;}*$%-?dnrQZ9>ew$;7Od+`fy@<E#Lx@t`M@9fqNWMoILBID-Mqmr&e+9
z(hOEMx$!i$DsUfd=;l!X{(%Lf&qLEjOi}T~za}Vqjwm^hr#Zd{it#i2ICiC77ycpm
z82n<OAuT5@CbmZ@qwI~q(-7fI=2iIKh+ptW8}$FlzX=`X<@g0d!~*CL&L#%EEvJ;&
z9R`1)_DR)KR^@E0DDzRa_O=xGr>N%uC4EZZF#4DqR&m#1fMs71oQz8?N^VDOCrY%d
z_#hy3uXGuyg~v5@ycZde=$<L8nPJhPRh#SVtP*bM()*oiO%s)an^w8p@wg&2cD=-j
zoh0N<HV4=0IwZS=Q>#~P&}hOWSzAiV%Xtgp@{|f(dq!PNvUc2Z3ulYvh{p=b;4poR
zZS(qB%am47J5iFyDRcB%H3)6evCbGj{*>H7xJq-dxk*z>6FSGr#V^~M9YTu%p|t?F
z693Wm0R0F5p-}+wIDLPCGDGM{KxhE)?F$G^0}%JaphW^Y4bUKg<^qBO1g;7Y)6TY9
z039dLt$?6rfO`xObOj(>duKr%0LnpwKuZO55ugHr{tigf{Rz#XP;l=98Ya*oKsqeV
zo8f}H1<(kAejh@Q0>ZjAVm>w!_+Al0*8+ky2H$r>94}_mv78@56@X3>x_Urh8#5VA
zfJO@Lw}5EgWy?~F_Pqqn@)W_{2}tAq1Zb4to&Z!N(EET!3-s?0cOp!EjXNEXrdtk3
zhy4|xQzZm%-O`-?0O&Nq9SQ4dj6hQWY2O)u#tN<y&^UoE523$>(AR**i*FhfjSiaw
zNK0s7h#LlIg3!$bG*O^Uq3@j`^w$u2K7`&5p?!c(m$2Ug()<mHTGknY;}!|c!FhnR
z@6SWu--o_i0BQdA0GcFWBT#8NY!5)%_rwr4DTJy3O_mUsgt+SfX$f&(#T4=VQwY5f
z(j5$;eqDkPQvjVQA-K(Asz84Lq<Klt417ld(rGk>(C-0FlMwHPxGw>nB{&5It)cFK
zbbJE<>Aal*=xm`|1gKb`O9AN`aWkMXg1ZNhF1ObJ=~#|LSD<;R0d$VgZ3=M@1JZOq
z0Gcko*)$vlIu_6jfr<fXUJ`(23hs75vjln@&}@MQ!mv13pc#O4UAqpDPWNs=bHw*K
zKsw#eL+Hrt0Eeb3Z@@<+Uk+Rm$(M#$2T&D&yA%Img#fw{x<o@)LLX>|+CoEbg%D?2
zH14AiVyCTfKZH;k+N#El3!!sD=v}lU?fY>Ed8p$W*ENL3hR``7G(UvSK_+wvP77-2
z(hyn~Lf3@Qw;^;8HAjc2MM-OjOKTcx4xvAyWHj!P5V{l+*SJDRTtlNnXi5mp4WZT$
zN`v96L)3@RA3~^CkHGiC5Sjq<QiqrkLT`l7z7WcTt*PmTh0v@JDhZ*c5Nd--twTid
z(a`h|x;ccN4WWx+H*308A@qw7Ivy6E@eQHPA@s)(dL)FlhtU2IiXRokk_e&4LTFu|
zz;|nI0G-h{fOdw^ry=xX2%X+9pgR;oC+7vY8$;;f5c<4-;A<ZfK%GNqVF*=)(DD$X
zA)uwfTiZ3%Cxng*p~?_y4WX?ev~pk&_Q4R^7DBIt(4G+bG=wS!1!3z$Xj2GXHYD)9
zJ%ru}AsQB%=VS=2384={XkvaqR~|yi5NaA4_^uD3yF%!Mg24Bz5IQe}nnURN5c*XJ
z-4{Z`3Iprm#1J|KP)zjN*?@FDDns8TA=DJo{XB$j384o=x<^9jiO_dDARY5-A+#s-
z{UF4B8AAUFeR~fJ_!}HT`G9nMe27(ZKPiOH3!#b-S{6cAgwVAi^s5khD1>%|&^saY
zRS0z&9;7=mgia5kIU!URLK{Qqo)CI2gxW#~*X^4eof1OlgwWy;Y6_t%L+CC*y5IT(
zASf^NR$D^fXF}ZW5cfVH9pb~#_nXj{#;%rbS_pLup<W@>KZFJY(&-Khaic<LLI_O@
zq1hp{AcPi&(8VFNB7~Yl=t@AE`(K98J)!TP0BK$x0i^58GokP95c)WTz67M>`zC}s
z!xYgn$OEK(2Zqqd(6<KC*1k-$i^v{|+Te;q+{_Rc0fa6cW%S=5rm5r0mk}_W`1|n?
zwiDRlUQ~_5|9lz7YNw5lvbmCVY3NTN_0?y_tVsBiztk6>Vdnf-8U|@K;as8Nd(R#J
zt}`ePUuAQm`qd6Zw5s?=2`HQIJa=U3UZLRnE@}A2GgCeM?=j<q*#sKC@7(ckyFp=i
z1DetJ-!ZLShKA*$?5n_fN18T61LF!bx%l5P``-Y|KNwM<c}U=&{^R(Vf1UADHs5kS
z{4eztXVxcWcRifIxF`|+@uN8z0FY8^$DCkjNT+EgbinYiMDV9+xK<zhY0TvvFjsfL
z{H_CLYX{7$9WWntz@&;*r`|(<ge46Q?ttN5pWsh}b2?xy?tr<h1Lmp@m^(UPp6Gyi
zxdY~d4w$byU^3X$%%Aq`*8y{K2h8LSnDaVdxbPeN>6kC?fca$y%x^njp6Gyip#$b$
z9WdPf6a4AaqbW^SWBPW$oYDbP+yPV30n^k0b6p3_-5oGbcfjoKfcc^WCXFi1{OMfu
z>VV1bfH|!LW?=_RQwPlT9WZxyz&zanv->a%H%a7|#TO+j7L+Vn#2Z<SOBR+4TvdtV
zm<BGd;|yZpf!R<4)+QHK!>2yQ&GU_+y9AG9RJ1z}cVU__2>1Up7Yoefu3ilZPR0dT
zvs4;5xd?;xm(a;|M;`f?b&L?pXJllKwRl8GnlkTOj05rk?SgWg3JG0ixx&035YPnk
z&Hn}c6O;*$Bls8Lm{Aa3Peac%_qhdFGs9ayQ4Vtj*vYuY$J~_?pm?MPZxv|ya5lL<
zjCsPMX}r0obb86M5Jzs!RX~Rm&q&lw=B=hdydn`^(-mTnimY-46mm99-tfTnICXgP
z1j_`0pG;osd&L73!{R{e*|@MEKnWF&pM?n0Oi3=Oox~-BfQm?5tcBa<k;(Sl88mP*
zhaONvL~<rCaN}~Rn!0KA6=8Jxe)q{`hgFK85b=OSJcS>kC#05@%-Z8vSr}XUA`{p5
zeu562<Q3-)`BH<N=?$18USu--Fj7IaSI!`fsyJRoNewDT;ez#oRF7#T7saQREW$Oc
z0haGoK`_C>L4Z!J_sROjAvqZ{)#UJaPzi!7)q*%EBt}2Bx@<hJIt?QUXsKvI<aCIz
zq&_Z@{7(-YtP5f{neR{tatBR76tED6IwM}qD#?{&v(P`Db-BIv1O$+YER+7Esp4Xw
zT8ewJT%MU)vw0PiEQW<?i3^t>$zl(hQRpENV?kC_cfe{`<b_r;QCXE=Gc-5&D;$1e
z;qZ|s4L@N-ZtjR-#OnVijsOCG!-t)G(uo2sOrL7g&cv?8<$Aq=mjb1ZEa+DZ653e1
zme8eFX>##R9bFLr-~Pq`nL5JwZ#2ZM!fz->p{aj7BXBhbMX7(l4J{m*im|p~<hDA?
zvg$Y>!=G66q#ItK5$68_*d~)PVgKGTjS%ybbR#gxPx<=_bibX7O-P3BSo)Ff1SFL5
z*MjlZO~ok)f}}eU1D}+?=aJAcaV)b!#{3J@<y1z>ANS&XUT#@8{FLtG!}FVqFm4qN
zavM4%snabi#GFF=-yDGbL3h|6`70cDQY!9rFm&mEp-UZ&kRI8!o-}nJ43GFu9yV<F
z@RNoW3_o$?2_sHA>4cF5)`q{3V8f%BZNn`7U%TOd%LnH^LD%e-XTJP(=Cw~|Ub%J9
zvzd>-y!Pc}r_9HTyET6_vSsH53+6wyaaPL*vuCWI@2^kB*1nk-wZ8c}1Y5f$F?apM
z=-RJa#%Cw;H%!bvr+D^^w##tBD|mj?F23;4`m0Dgy{!^>yym(g{_Xh}%zp~cjpDIO
z8$U}&R@}x1gAXH^(RPBMVl5`Q<fi>wbT+`xjOGI|a&+dH^)vjjEoY9I-WCyZymK4F
zyX4X0^%>{1eTg?X*UxbAjAqMtpZVH0Ud~#rpZ~*-r#37N<<TDBc)z&qF@)MSp2Jvc
z+xRj3@EuMGa{mB2k^Z@}!GRABAdpzADjJyR-k4c*ej;A9Fp+WI-18~7qJGJLXFk5A
zW#VV8XWDCaB--Rb<R@6$9^$|KJvQk0)=kYiG-h1Ow$`Wu+13qphgy;cG9UkZRPwXr
z`<ahV9c7Q2_F3}C)@h%OA?f~CwoUwOJ|p;zmdE<!foI&|mPxjp<uwD3#IK(pZQ0%G
ztl5%G-+$(~v4j$X3*S5j^A}d@k*%u=FzRi+k^e{TO8oP(_lXzJ!Mo0%|5V}2ny_o@
z4J6Ut#-}w)BlkbMaYJH&k;nRpF(x`Kx^~NkIft4C?H?i$AX~PMNfI1+1!GIbz|e;A
zHr|<!2#2p0Zdv<gL*K$Jtxn;~tz8XsSCUo&U-llk8@y8lJL|6$A1h_6PBR%TvJ+j3
z)O}9o)mwz#ezMgmIxcg~10XCqK6B0Q@hyB4(f9m%O)s`jKXc7B_}I^`{W=lZ#<>rR
ziGRIDhP-~FU(0jfylKkEes+V~v(@z_=71u(4=Lm)>Wd~O7ue4NK0b5puO-IA(@7LE
zrvDLzPMo=+6awbiMC@nxO+|$k`4+_!H@Exl-(x@flO$gFzf7WNV&<A+#Jd0Ykc~Wf
zzHb_wvkG4}HM%!mw{F?q+V$%--8gQv6Im?ZF({H)fJ%Pe8e8=pM0x|*-Zt?qGQa9O
zi28a!tvR}$v<vw+!0!HJw^x8ZYrn7SYikT@run0SF>mc?nYEXZzd3R5J5M47DVgLy
z-`>SE@-x?bDUnZ19JT7Zcp|5H<y(i6&h9<yXGI5Zf4gV%)4ioSY#d`a;`J3^MOs+q
z)lcd=WA8NFn^HdtM1?PJ7;$Ch<FPRtX4dWeDbLCGTV8Aa?zGIG|A@qQx4rF+1nbQo
zfmvXizJ7aG%NNb>o!0zaX5$epuf6S!q3<U#`2Ltl-{$u+o4-?yJzHMe?M;Fo)J*dy
zF1?lZR%>5w%+>-i^=ryoJCfhOz3Ys`(sy?3I|2m~2wYfBBzL!Ia&Y|CvydBv1`5jT
zDJd5rLmZIXI|o~1`<{gYgG^93i0jb43hmst0AHz3W13$)wC`VVne^W|xbHT&c7L+(
z3Vz!5)gjpKw*7wsm<@1N;TBUrqR@D)3Qa)Qj_$fV$D`$hNYoF-7WW~fw{4<K)D<0<
zRO5jyNF0PdZ2op==FfM*xB1(XGk@_SfR_26ZJT%i01BpXN8y|M)5L2ny<Tg1G4sxE
z?94k~Qd{3s_Sg0o>yw{#J=n5s>!CjOlU)xsKe@B{r9<O0A9s&N#7)n%%s)_gX#M=p
z)+gK0xH^6FM)OP7H@nv-p_N*Cw4CK8$F+P5jaXE;rFrFntfn6K+R1J$yV~}Bd+5-~
z6WcO3YxRMrrlo4>{7IZGU+%x#$P2!OTT=XyH{=xc%G#F$aY_A4$<RJN5v^m|AU&?p
z&(s--%EC8`j!P_|+T4-oB8qMB?w05Ft8wrafo*R-I8^$J##5RPp4@ao;g0<t<kOTs
z7MV_Grau?&=7ZfDa|*UJAIwU2ZQ0p&1aq`2^Cq1kDD-iUki%AI|5b>3|IgX51A8Fs
z&!+jUHVf}}pfow47QGwJqJm^+lmD@+PA*7%M;!#kG3~ScN4GrF^13diC)L(HETzx7
ze%JCMi)ee-?@(Zwk4KMg-dE7jz4>5TQ*3<m_Zi9O&M(|@fo{L(zwnUz=O9N!-w%GF
z<@F=~*?h=qdizrUGE~SzP0L<czw*G^LkZ`bT@X}@E%`lPherDv+iHVZk^gLvZ-iU)
z+D5}~&|k;aPeT_K{bnn&b0~4@`icI!V*eq|X=mQ^tiN@iZ|K({IluY2RqJ|pngpLt
zTlaNp{`OF^4Q9YYoVgaR3lD8bezZSAF}7@5w=<yIzN+Q9b?&KYuWUHOPX23E{G%o`
znU?Qbqdlgq%NXDM-J#@Hh(=;)`T8gF?+@(@{#xxdTN-*vXR~dbOnkLCx`dzZF9BQU
z+Rb~K*1Xv;Kx<n=wRKOYv|TMu^V9twqDIiNC4cZ}e!nU0sn)URWEy&=#=Q0YPH9g)
z#Ma!>bN^<z5HSfA2#@MWNN!qs?yHBCL0EVQ0a|_}y}NGWo|YFMg28OH%zCxujh4?_
z=kGzIWx_2lY<;g&%lutwudG_R$67wJHM`T8b+h&~f18$k4duSO<@@!sUd_DoIe+WB
ze#`u~TBhwP+|fF1&-&!9v=>_b*)ptUg}cv2iY+g;yaUSpAM5gjv9anD9EM}J4XGI!
z>9PR|{H<DHTMhkMr`xDBkb&+G(srW$bdXQso2}>BA|&z4{L2XEi6&%b4071_o3!tn
zzxA6UEuXL1(Xf|k_1u4LYWtyn6pL$GbiZG|vE`Mt=MtUA1Xbc&zwu+VzZ843a7W7r
zg<Ft;`K{@#<J8u7bJDgW&r|Hy>CV=7W17*e@A+xl({?^3_8byLb!~ZR>%N?I#cG{E
zv2~MdV*GWJ97Nx-J@=<cwlcQ0t<U<TZ+{DW@TG6Z6whvZ>q~iBe(jdbHO<K5`dP6l
z(hsknws-B0#+sIid-i8;m~>Yfl&iC@%gM9$Hcn}IZT-YOFa2mg1D%t#p<!q9p|qu4
zHcZ;Qq2aFPgWgiLp<zen;}f#%tslA@ChbHkU%C~(^!m$&Njnfv+Chn_=`TnPQ8j<$
zy!6qAncbY1zI(=vSsUVCNx^9?Dg6zkv-aggpY_v6UiMvN`KZq_ui0|hch~-U@U5BG
zJlS_=^Jm(q6tSkzAH9Cu$kC)q^c=mh+p;qgS)(PeF$=Yrq%qBZDr|q2?I_oabn?^E
zGoqclWX8I7%gXNF<A|Iid-m#m)X{x%`}WK0f6Rb^g9aaa+>qn*hZYnL8$RNM6Hgj>
z@+qT=MxT1xn36@MW%2Tg#g!LcRJEkKruJey+Lc_otYP_z^XJXKV8O!w?SILoD;t|u
zUADS;&DzVaSl80J{%0G0{)>&9uDt5%Ykqm{b=Ti;<4rf;via8AZolKsU;X+wzrE{s
zci;2-Km76D`~LLj`ycqrgAe`n;YS{Q?C~eIY<=>nr~mfMw(UEfeeU_czwqMDmtKD5
z)qlM9`mWt?y!qDK@BDMmyYIcf_k(|Z*tYMZ{Rck&<kQbS|KiK9{{8hg-yZz#`yc+p
z^~~I{tUmufc-lU7_Q+}0sy!zye`@S_YfSIcH{uU()F0z#WhlRw&)4c>u$G-3mVWDg
zGRFBT)5?G^LAO7^Q{lk5s4QFg8Qv)wqvZK{Y~qs;ctU<8mi9Wq*@b@E=`#vE&BYJn
zNk{y~8|N?)Q<sd4Af~8996CD>uo$9CcY9!Tauy%2&-4Tn<6y0879uK&;%Y+r(>Keo
zj+8NkhPO}e?qQ@EB*I3+Ab;fc2*Zx>mJ_lgq(`=AEF+_HMl^!~dLCi7Gu*440{hHu
zTXT6-UvN1TnLaunf@0>#f3C#Y#|wpp!b$aK0gQ=|#lGz{4oaloh%gA9dHMEfQJsZ>
z(e^<7O(0~%0h`C<KtuyFP{6zgYM_aNo`_;lY7~>R+9Mg95((&zO$mlLkIS%U34=oj
zV9#$DjbyMr8Z6HQHG;fgwkg$FkQ%H#P~lN_Vb*j+JSStW)T?2hRVeHZrw<9~gRO;#
z&eWjOqAcMP`XaA5S0h+tQDaX^MUV~aDNHJ{f8fj;c3|g@H(RjvEmT8ga<9~ipE7jG
z^4hwZih6VN)bYdfPsrEvOjBX@^UqnZprSfix?pLExq5lfLSU7<V8Nm!o&l|_4t*Mc
zckM_i9-X$Fki2{fBQXmlmb&W}IK99*)pmE=XCb4J+S%B9@4jJkBQYOMtHx4^`=<RM
z{BV1C1P_;6?pt;OQ$KjCrqebi^|tYiMtFnW>9R-Oea9eiqko-D{95im4Jw-`nVEI>
z7*tNA1dr92i`LzD?H@6x<mB~^B=CgCf_gj@hi44mGuWddOJu>~biCbwJ2c(*4gTl|
zpDM&$b<NU}Qp??Izcql7^of|6SoZ^ySZ+j~Qp1`+mF51+eoe^wNAUbeLaz$AAKJeX
z1_niH`K~~CL!8@YJPN==1zvB5EukedGE%Ll*e&-XgDOJ8HHng{0Kebh$3*lI1owcw
zLc};B!bxGv{oMXWSeX>Tqg07F9&5*1iTi~KHZxL^g8kA?$K0utHwOiVS$NC+%3dXr
z&5Pin@yexfV#nhOJon!w{K5zxPA@41>DTtPLRuEV5dmO$OTGJz{kRnI;z&brU5)He
zalf_yEQD1NysscQAw6hFYa_T9atR(#5bSpbn~0cqV8^4B7V(IK`@OwG;%SKB;zNy;
zAU~KOmqx;OV%r1#$DRgtrt((Vky^ciCt-e+Fe-129Wk%ewg)+6a|58tTL(Xu?pb(A
zm^H+5VuOhP*<pB`esgW7P<%Ebk@gUhkmFDw@)AldmWM1?In%KXMde**cjCayb)9E~
z;3hj_4vsKJ&tPx0BgsO`O>@QzOLrn^E~8j(hO<zTya!1VBZ+l3iQNk_h`OSVZ+g2i
zhjQaXCsF`{74oiz{2@D19gv@0ixA!Lz9B<AYDY@UDKWRZGYk7nRNfZEG8@Yfc;wUJ
zfhLvrDyU}b2m0J2oZF#j_^L^yI>6<a*zl%FiQGc$_B3(r0fzFz<9C+Z%OJn9Ba2eb
z5W2mcH1sSe4oC2OeY_@#8hMn7_G*Xf1PAOAY)MBuJUR#QI+3#SssvBuAqS|g{Tylo
zm4^c%Mtzxss_L0V$gJz@XF%KE0@X@wfjQu+wyhH?{eq}a9roa7pb~>fcTf$wxV;vQ
z$9L0Q7IK<Poti!z|5QI`7cd!wU6tp22S=oKT0F71rmWsl{hh&`*e<bC$mrGuDJNt{
zsD$`;`a5GviX5n9gQuOBI#VRHiw1!uTno3a)d<3mG{_pNr5c<Y1rud+#=X(<3iWd5
zFM^Ck%%jXJoR<WV9pM|%@fmy&O<m%AA;_FagPeC%ml~?xXiC*s0=~#nD-9|aJaH`y
z%X{&<rSUQypwaNxUq{Ommvy)qRy8@@eCB!((#M-LHFY|{Rfc>>1c#EAR+e%_9SR3G
zjPmiBQi$s^Ls0+`4+V3bDb6mUu_nNo$$#*AUdmtu9NLdU5x-2f(M;C)%-it~q{Si8
z)gh5UsYExxE0*RaLt2VYM`)tCE%c%wwHISR3Xg_f2SP7G@M7RJ_w|r~QfUt>%)<X$
z_^0250P0q!KPb8qw$slgrkgqum<+;`RF+~dtSd{lV)Cpk^()S<XQ5iEyTQ4UB@M+T
ziN)N?VW}Pl>v#GEV?074!TY0~I9aK3)ZNmv$Dn;`Yvqztb)?d|AGL)GmzL_O_6QMb
zidphhy%qO1vQKWn`>j+@>L`OkT``Nent`KLu8^{p;PugV&ibf{;(=;1p-QKes}>51
zRisK*;VsoyT`IT&;$|#gf;Oja63hr<%roeD>d%53iME1M%QZ{zE*Kl2NxTSEu_}&3
zed-wXf)I{DmDa24)I^pVpbiRt0*d5V2tCcc51H=Fmac2r8*pZ_1TrbIlyam8$XOt1
z?qA^0^b}AEy{Rt$3jHY+?N6^vDi(z2HMTlDh4Yi}0nq><VkuEv?L-KFCJ^0hN~~kt
z<zX<&Py0)YVTKTPwS=V{+x>vPU4oHGO0GRxc>Oi>+825eg4d_`xV~FfljPOhY3{3V
zX9Y@dshsXtDy=&@^=#gYZ>MugL`BnhbgV03JEZ1?uXRZ(k_B?zx_YEDje#_G2L5-m
z7vR5cOuWj&Ql+trfXN^nRh_!t4F^=RKIyOgu2azci7Cq~zExURW(>Bh^x`VLE6V}4
ztd*Y2xXNM=GA_bH)FZLGVe7-R3pWT@>amy(Z?Ojq_6=C-sn|$K#*I`5?^CI#4XGa~
z331zFrwUy(HTbOh5^R1@FT{BEmJi+HK78zCvDAwuhHPTEYe4OcX?}BH?Z(Sy*6@{F
z+(9jVFB$6I5xJdU9N#>uPcDH8q+T{&xe<uA5--!n@k9?UfL5=>SZ;Wo)k?pJ`H#nV
z%~1wnR~^yyHRfMmO0IIc{uU+z`?mB+BrT7<M^eJYYDsJ{JhiT>Hi@xg!$U0zWUVH~
zvu+$gz%r|@=EG&G&fw6w$@?PJd`eR#V=oFNIygLRP#O>~jeQ{KSf>$GW6O*)R9OwN
zD6BIl4=T$jh~+WfASfCO>JpufrB=k|2nrgD53yS6QbPk(HL(VjW2JFJL&3b^H3q6N
z)+k}1q4elLHN~zM4D^%PTBcUT9v2i8l-|#zE;9^5J<V8-+tk%+gMeZ(;~dp&P|!?)
zU2Lf}204L!Y;_s!F4;7t*2ZFD@=v01pfznv>^MP9H5z0SM3gE2+WSRbu9!*NE^`Yi
zI@-`L<p0gUbfy|eb6KisE*n*v%R<!JXa|GPE0Yks*sRjr`$GbjhY$e!j}U7?4mubi
zct!9*VAPZ}cYjF6qRFHeu-)*{X-*BWx=R<e%hr}j4^YwoPje5U!lt={!cYxiD1jIN
z{=J0V3qmTEnWUI$I_ou|7t2ob93~bJZ4Qar4kr@c1jm6G()$GdY3^6}-%ZA5nISU)
z_bih%_vtW3mYq(Pk-@765bb6on*(lO2vtl}Js!IO6rD;zteyzl7<MA6E#kxGm8_SS
z5!6<L@gkKo<8@2Sdur-Q6U@ih#}DmbnJV~6%A!IREw_C2x7bHvvd@IcLPw)kZwnIs
z-;A4EP<-{AsK`i3UByz_^kk{$!`N#04xjpa7+acKh%`}e<UiAgX$R%lnF`5~`%b*>
zB|vl+INQs88IB%&=MCfdddus}ejK{0M`=y%a%``%ynY&E1H-%Fy*w5+MAl<*LZ03B
z`fG&Wqr4JRu9kNUFHM2r1Om$&yjUDD>j=bac|G1naybOEy<sQ7s|P0^EN{3DWA(rr
zwo5~&+oP-`QDS)`SOw76^pJbYy%V%E+M`++JVB=)v%2$M7vCGexB_kmYEQTqmsD0;
z-XNV2-g9%A^E8)CxUL@Mgayk%48}6y*vNG{)i1{72Dyh(WbvjLH!2fAS-dUA?QGYB
z(=6T?<94xmqa~s~JPdD<aWm~-z%Pq8$+$85bJ97UPJu~h;c6MTtIb-QegLv^3v79W
zhH%s^v}a*_NFx#Y(H&-A2p9Y5S{dUGH<JVCP<a!L<&H2D8NN{#ByYF>Apypg6<o65
zPPbRV9Sz(=+?UmQ>~V^eRo0>R(L>8ul%8m^&}`zo^a1a*@IeRnAI1akQKevC5A5wu
z-!e11RIg*DI3v|2tm!k{-G)#)c}z0BtNIFMjHZNiEAD%S1dl3el)k0Hec#~Gzr)T>
zF5x3Ic-hk3Yw*2;q4)tcP~yyuRBHi#Y$*C`go*DHgB@gLAssznpK0F+Nkjv8wtJfs
z?GDAl0fKwGOkl7a_y~x5hm5|dS;P`^?=)@?voaVOTJEo8E&`Pr{Tg-#yT5jx93;&K
z{WrFjy1#K~y1}Rs2H2&#v+Q0-j_K2x?KU}o4U=CLCNGn8mV23Voy6xxR?NiKbjw|B
zDEx?iirQ^92)yD`gAKr()mvk@ge4U|2kEXg$gZ8<XYpO`Xob)XG?OaJ$}sS8*BO#5
zD~l7Iv+bwJD8L+dwLPszAfskm8)2xc<Iup?*!RiAor{S)Go7;5OiKEZ`jYZ^V)=q9
zd7sX`+~CtV`Gbmfg{kGRc4)~7Zk^10L1LZ8kk1x-zr>zxWtq!J+;i=D;3aCDW$v~1
zXsD$~J@(ZuDM6pXmx3+#I@4gRNMccys7d#Fn{z=dP1utfb%R0WL=t!#MB{EWxFM))
zR88(p1~DdrJ4r5<Nu-<Q?LsGSW`vW43-I^{tV+wh#bj`fu0ETMbFQ8$zSZ6h9pU7i
z7b)c?;02<1-P;VK^CD#s`W-ec7$<L`mBk&qmOICug4{*LF~RNQu7uvjRI}ygx~BQ+
z0_`iaG)|ta)9UByv>ZLPXSsQ<p6YcYwS2M<%S*1VT0Z6_D=VOLLrfGTd>_R<#?@^+
z7D?1x#2PZt-3tSlPbJpZmcTv8xO=0Ym7dofECWMW)Y4IhPRu0-y2w4wJzm=GkVqwP
zmOI1*DTq`GBYaKJ#CE*#8qvvS>&$mwmDVs4bGMwzD{wiL=j36s*}M_#4mTmjSn0oG
z{h4dGKwue!W9}?>7o~>@W=eLpA+<VPL&|fF6SZR^hRRTV5Wc}-3}d+q+}nijsFkJb
z#d-Dzh%PFQ-tIVc|B;BiRvu7v$1BYm5Hz+ma)R0uw&ohkov6&{OVi8*>U2Ya)(iz<
zxn~#!7LyrA%RN)|8LSHcj~K_xv6R3m-l;}m=S1{bN(?f}Eq9v19vLaahH}~H4eVJ4
z+Y`+dDh#J0NPD)y_Cns!At7qZJ>PyB8Hxt(T=#sZ73WT&nmJ`Y&-p+qvlXc<u8WsX
zq`I7M6o@0kvp~bT7Z|kCRda!Hq9#&_$}Eh#Fi@m2Z{wCYJEdf)8Ki?;<j}<A=n$hl
zOl-KN27xgUMhYcWoaA%MoYf-W9Iegc&N^}SwzAB9TkbsjdgLK$oKg2;_aDp?iZ|)L
zDaDHnPKHdE2Gv2=j%7hjKvXhRbLZRdOHAS_aDSur;64PM?r%-OA}XWi-MdUdVi760
z+sXZ%;#>+lkCIA^t|qd{-K~z30!AA&ZQveLlh6qHvZMQZ6H|61cqz*LLs<S?NHYBW
zF)V)e6nuHuz1Q&7TMPL<^@4~eSF74TDXnVzM^dhUa{sK35rzguN=%P)zv5WR$s1y2
z1+(l6?N5>UsBy;JCC*r!77nK&+-k>6LumQbIJEhxh;=_u8x}r?x9-KJ(?mnlw@JB+
z?6VPHRJ*=)FZRCdgXpO*>pZP5tq7hVa_c=~*6Kxygcmk2y-t+$>>*4z8Y$IhV(R%E
zy}Q)YsuUIqCJ|{vW2s`9L3YJjBIbgF-lxH!yP=NbDOl8$<pz@#sV%9ikL!6ncZI>i
z#0gG=xR)4Qca57|jrwol={lWyk4Q;Kxzg(-jKUDY{9XkPnxM%wn%s?qq70Eu1_>RA
zlr49aagULeKUfgPJt0!fi6?ipabulL^4@IRQzNApjl-!E%UxqI#gS!om5I1st6b|n
zCe3{&B*zX`V=p(@IR-1QBe_?Y2<92AeqhaA=N%z=S}2@V#bs9AZ53jbhefCosqq@U
z-Wv#FS%3;J8FM!o+Ux9yAZt)|R~j4^qN-<?Kmb=61lFL4(7OI=gTzWyfHWrJHOA++
zNFPtZ8Twy($4l~9r;0b!R&mhbUMuCK@~})*4^ivO65Z=Oc8Rh~Reu(0k3nB=&{&JA
zpNh3rgTBF_pT@G;jEkY*Z}iv{RNnJI%*2{5tPO+Ni4`lXy&5fWvlp&f30A*k28+Xc
z18rDVu4uvN3me_d-f&?bYgdQe*XG`8BF7R|y{Pfq4MTfv^b)02C3W%H33jb_n9LsF
zx>;piB3V+U3+7J4$Y+pb(CPlh$nYy0R+_%G%`LT^Tr^qZoa7GiHut4U(D$^t$9vke
z(6&szX#(hb>%#{<-Ju4HQ9KUy)z?&EDaLXO3^oF+*bjvU(TU?2zKM=nKFr{JjCks?
z6kD?_n1ghO8?Q8NH;wQb(EB@i=`il7LQe4ZAE#A>xt7m8(bI-fOb>icGMr~eYA2N}
z<=d9-NJEhmsST4k*^u?->Lr%ZE%y{pTQ9j<`;Ics{>J`V!Wl`o$Y5bGO|9g#fIHem
zJ_M1Mm)BEYooZ09m<-WrQUXrih)88X6re^%O7Qj~7aX)`#(1Ag28&Qub*0+SE3^NI
z!ifg%0{1HSW0qF6h~#S5boII`yv8`OfQbQ<`wxlDwX#f2Ew{gCT-sIae&@W5_M!Fu
z_u=qHTQ@(LH9&NV=%Ot5KhAdPkbKw_VtM~)2+$jvUhR;h`>dchw1VDHTZp#OGN#_7
z4dWQ^-knC<=vkCvYr!L=Fw-Of*VtSAWjH0Br1yWAdlT@gs;htaoPEx{IU#`rxFBeN
z%Ot2FBus(~CWJ6ZfRI1{1(^~c2qc6A5FF4X%H<k`D%IL5)}f`XTHjagfTaZoz*a3)
z>pY;<Hq@awR1pWh-)~R%CeZi&Ki~5`&;Pq{ve#aF?X~A=?P2Lb5+xuv0UbZZQxyOU
zf(q((H#yu+GtWhDq_3R%>3Y;fL9i;a$8E1s!^0~UC)Q&fG<HPzGKg*DBrHRt&X?yw
zrf^1;sZr?iq0LY>L+o>F<R~D`sgceacYz#q9Y5mzU8Z!5mS6i_Jc=_#UyKWCn3m1o
zY?n>I=$?c=Ll5zj)y$x~o*5MLFd4FOx%(E%v?F1+v+mhexSs--u55w-2QRN5D$pj!
z-{<AY353(V;&Sw&`#mX8aeHC-?+*Lp%H9i6^PP4tk$sgr7JkzR_wz@G`4*F&@Q(?b
zS@oLA4N_JyHmpbduvUiXkJA{axUYmJ#8qmfx-hK9FC5cZ#WGabe2vY-o&ki7s4xZE
zH})KsuffS1UbS`n@fzDrRinbNsz!PqH6hI27PZQ0_b}tX(*2h4C!FnPhJW23@#l)I
zqvise4y}{MU?Rk8r;guQa}HE>?h;njIXzsrxOO?4{uyDl0>cibdNtJV7FM+roe#%4
z)u6kFRriYC$IN`s3jbNQRNeh#g-6Lqqx<3bgo6nh0a=N;0_$Jq9z^8RjXm4{OXx?K
zm&<9A<3F#bS6E`J#or4W;mhQ{X#3zg>|~)K{MGclGVUn*mvldd=8YnOI0T0{UJj{f
zs=1i1T(8Pe3hPc)A72ZpnJQ9;ZpO^aUf0-Y81u3kbxzEGBczk5I^8$raEZNoM~tUB
zLnnOB&yb*qvbd=}lPBb4F{Q^7bdfL|cqR%P09X;F`V^)47(r1*Dl4K=ew^x4K$0rE
zO(RR@b!Yi3a=QPK%abr+>MQj>wvq`{P^qom|CdJj@~nvCA2R|J=ghzl3m!N-tF^Xv
zKSg$pXIX9SejvD)g(y&*l<Id2_?JoOBu_jkVWF0_Uk8Sr<oTuqI^(~PLU_3YZh8|0
zklJYkQ|W^zj1p2uwKGhX89X)uzkilgJa43^<ZcWbs3Zl!za;^W9knIkF$EBGg_8=M
z2Zc@>mJCoQ<a`iiF~REr^q_)s7YXAcQ0_p0Asw<f#Iu!13I;=okqU<Lx};zdrzLcR
z?u2`)PYEG5da&S2^||)I{x=#%s+1?B`ds;?qbo+QQiEeNljR~kT%{KMQ}if-&JYxi
ze~}(vD7^kqGUxO^)n~Vu>YtCkvOPt{Ms_Qoq3-6t=Iw=x?gn4C!UZFCc|!-{E3wO)
z+KPdc!r4lrp51>-JEVuDdUpS9ZAW*aCdx<jSQkk|U>O(Snf^bdz}L{VXgWkmEzpm8
zYQ>HzoLp!8GZBTvjP3&yJW@(QR;oV+sY>;kwp71{B5Tu!sVA`0{drRAVuHO`3$65o
z;u3j4i3>?es^#1Zk_jysL*ms0ae+pphNY5r|59ylhcJg?&99{aD#XCAm4W~@V_ByI
zK+~mUyv_&(;Pa>O+1b3^?O)@w`Is4$VwLTG-)CnQPAF;jZ#4`R|J!T=w32rJ2O0yh
z9QroLzg^3?($$FYLoEW6vR$jC-T#qJQY37(wEK5xT$ixX((d1><IjmI`rlnTH_?wO
zE$#kYGQyl7E!A4u{U7`9NV!Nqq?z)ctWRKlAIY+fiEI5-pVRv+wskJCr5p6A`@cp9
zB(YrkNo<O;b9pE2X`td1F;zweTVEJEQ+*ElJy%q2<f9)@Wqh%aJ*2xBzIs7TEfklt
z$B8b*BLrBp45_K!Fk-0VUf@cyD4b^C<8L>7^xnkt1aM`qF%rl=P<%UDl1?Q}U!z=H
zt=-*0ZV9lj;j5zSAk0G`Yj6iiQ3JG!SJu{|S>kw}J4ntxcKH1^O;jRacM!u6P%sW%
z+qmzJZ@?zU&7&aVDO%7&xI?x8dIewGp!o=gJKa432fliB9Oh<*u3y!5r!(ILVqk-t
zu7dOXOU5&{z{eQ)Y?GuyJSag`-fk}3_!{*Ve2*k^UZ6QAJWi-wTVGv=G_H0Rf%-dq
zPvXnWL41&+)l3nhGC)(UVNOJF+Is-hl~>cUj25UXmzE#$9QZ(!&p5ClUs7>@B@2Ov
z#4p3Q2Vb4!FGbYuuT<g?o)io_2H_7_?6|)sWmgYjplGCJ4lJlT>^+l1ny!M{D}$;*
z5J&JegZ9Iup!T*6N+bMpraSIlCg&*zg>Zk*aH&d<;Y!QdesbETtV3m6g3TfKSs5Zj
z%LPRVzOuo%d5z3_mZ4E~Qa`L5R#B|yJ}YH`s7X@${IgOd1m*BmYnFo3bBq9PDI_JV
zpsso%RBOv1B>OPV<%1%ctAhB9L0k?*zZ$Ha>sO%>ea5p&VuwF~6Boz*H<^xvw{thC
zV;k-lIui!0ha&Ya$>~Zsqsn2=7nVMi%A*=M=VQR`Q;DNZj+-H4aVHV$mM+HmC%kJ%
z--`nH%*Gh!^r@&?Uqz9+>r0m|h#cln>Au{Y)u*Ngnd*VGaZ?s8K{75uBsdyV-}=K~
ztDEz5*_<B%GN(qi@9FLz&z1@712y+E<YDzQkm5dTsD!*kvf4m9D(FmUyN5P(1<G~|
zHpj+cVpZL`DQiXyLk|yq-J4ZR?m{g3BT@a*@Ys5ujmc&ilNCVbAS~Vipbus*a+|?j
zAuanrz~GeapR~!ST`65VrzZ!GGll5*umkPhp@PmuumRG#2xNN_LEj;R{vD7xkY3?2
zCwkCTiP><c+}Dn_SIOQbLn@&S@ldu+w8?nfC0!qaJ&_G1^>q-6aXZ_6T}31lk@zXT
z7SLTVgyGVOjRL(vZv^?e%b}20y_xhkBvY<E`=BpSHY#!LgBqx8$6y=0q<)#>zUh*o
z*s;XPV*S4e7CA(uCgOv9G4VOB;`0#Vas)+3t*L*6560)XE7zPmoE*gGxJxukVx!}J
z<#HWZ586H(S;bDs$o_$LMCfZ7*)M5B{(K|%?k~the&Bc{yxGcOW5ELIqsAu2p%P{K
z1n9>PRq^N}lH$=v5Uu0US1=yEuph~A`^n*~j5dVZU$6_?1{=a9nGIJZy%<|@?idwn
z4MO}rzDGgLM_E|_V+14n5xJoN#!B9Kz$Ew}{==4BUWdvuMaT@f3oM?)w+v*5bmXT9
zLMT+k;yFO=SthxrjiO>`7RACn46pyjcPA(!!&KUfg{~7UgJPLnq&*Rb$sF9ruc}5b
zx?0GMV24#3AN6tUCl?O7tA!qQb2#Xzje{M2Z{)ygnXofEBbl2NpEXjxbRjWFc(ruD
z6t=tzv+>LiIOii1+<Ng7FdtG5+*UX`L+Q$9wH_Z_rOQv~l89`X+{c#kpc$7r?vpC>
z_rb$Q_<jrGj>C0?pEMEfqi)H#Psw=jwf58UE2~<1*^F9peMWIT295*JxB{#)mm99n
zwB`D&<T@8LP8O@n22jeza?%-=igDV%Hl+zD*KJQ8Sv;w-6Ton1L|?cDowiBG^GWK)
zAE71W@r@8k-ipS#1cRM$eut1;_v;Sr@t3=?4t?efUI(EmZg5qsTwYT%cuCco!8tjD
zS5++;ynN|WjU1LUeCS||W2@>hW3r?g0S7+Sw+?NRPd%abLu*f61*9E0D-fuI0M@R;
zF2qn+@lzJ`jIe?d0<{$iTEf-50@vg6kAjx+)JD#V#SRjHAxuQ^*ZZw-`;?C>@ALlD
z4c>=W*3Di1^4LLR^TvKJxMyu}v$w9!iw1}4#*H04b;anhf2<fcb^X!0u{)r~K7G&j
z3#ShDA}@KX&^3GQf|tDY7kPE}d+nDs>>At4+q4WS>Nk72+lw!_aIiS1^V1g$p3~59
zLC|H{xUpl!zz+Gl#DLCTyScsRT(o2ApuxL>-h&7Id+;uA!%JT3{oaNgFLg}Nd)3sz
zk9n&<^&%H}t8%;uFu&X7U3QVze$Py=ZqHz^4(i}9^48^e?df!v7dh1boNEh$&vtLV
zIjH~Z;N`vMOr7(Z*KWJl{musl4fU37@BK^f@-d4Z48|_+H6`es=gomu`*Y`d<-xVy
zd1JiU!TnzLn4tbbZ%JM6&w@yg!E^4)p5fJOAHCN*<4`ZJ!+YMPbzb*6B-!hBkvF8S
z-?`W32cO+nQ&KN-I|qZto(%d1od?ZpI&W3>@Su-Z9dz<K9`e?Y@!I8h%kLlUrS9>1
z2A^JZVdao%L7!e#RkMSe%NJxX2qNC<F}>y$duM&RJ^zl4O<zA89P}c=GVk)}aBpLs
z=-Z_}ciud2`JJQx<c;`rdsV}VIj{VpPp#K+uD5QC*M6?IYOa@d|I~Hkvhi>5`oW`n
z4_X;?+kV;dm%Scyy=B*q9y`_R9*pr;jPbh7^;X{5P#<)jGdNcn7w`Qts7G<t*9S-E
zy}2xZ-VU$BT(53!{qkV2mpa$G{LZH@4mv+D@6Wvljk%|ycm2iB^&T{M(70ZrPv@~?
zmR~Yza6_Y)b?BDo^Y8k_dT-@R-Wg*CjU6=4TXv{%?CAL@GlbuGo!5EH*eTxSb04mn
z=KaxmsZVy!xT)iA+C6T;JPD3{{^G5b^TbaD8WYDC+{r)bVrCGe`~Fr`?0&%U7sWRi
zUqOeUNla=VD!AU8c%8rCK*7O+r$8z-pukybw%BIq#<vfRZ}6}4DswXD=0uCzJyCE#
zQWvCMDq(nhsvvDb4gxme9D(17N&Y7^c++z-YZ%581)YVZ<ND#8)^w9{GB37tTwL+D
z2z0z-DdUa!Ol$~U=U?w#EW=lEFGv&X7_)-~j1OqD>5)G)`^#V$zXc86)$qqK3ex5R
zQt_9%bx6)BeN7U5p$bbZQ`}`faSqDg5zv+(ZYDovK8crQv{V3zcyLx71-+!5VACKT
zN=n3d40<NboTg4Nyp!lZNTQ#VR<3PK#H2Kn|D0GhA%00|7B!$WaWY|W7WhgMoz7QL
zn-s?Qw9Avin2=`ta^iODY5Y!3@>`I0RjV>FemTiv*_-(3aF@37x;!b^iD@=pI5A32
zn=YR@t^6))?Kg^e^2g~7=Jd7<P!}#$xq>lGQaBFhE;&gw6J?1f+&MYvZ`@HA7i;%i
z?O#qilH7IL%5yTst%)jB&>6|MVRGajWc;A4musG;JUND+pX9!*9SMrkCbHOpkK*f%
zkLodLvVH;%Xik@KeL!=D!lNdtUlhhre9*9|5K7?@n=aJ6PJuxm0F5ijX5wQ&G|Lnm
z(7a2+^#RQvOSsObxnIKd0nNuXo+bq%LMn0sfFG}|d>>y@WGM5vN}*^_`~jV%>APUc
z-x2(M2OpzD^KS|cX!ds%dzzGfkcOs)H-bd{fb;PoSQ;UGAeCmIV4r5Xf&-dlfp`Qq
z9<0lGiU22Zk*5j{XwH>zeL$1462^n3hHX3+0k>GY(_E_HfaY})t`BHlukbkS=s4eM
zJWWbe$lD~V7WOUp5K$*g;v4ZHku-J~Jb`!cL2vL1ntW(ndLW=U?pR?slK5x%sOJ3<
zn0%ET3~BIXC4g_kARB<Eddl6EaJCf+%p4aVV@}gka6pqUX|jUQEK+!%=A{}>bD_r5
zq|7I|LZ!e?5fTz7%`SjZmuU=FAh}IaV1fZwDEgNUC(Xd8$tTvKgPR7)0Vesf8P5TP
zkEk<AG}kFOp!v3h>jRoc6uy<eMv2=I(7X>H6b{qCz>Z>B=k6l#hQgajUIFV?d`u<H
zpGfCY8v7JzD6fW9Q{r&0;)*noC*uOpP}2GiJ|=-?i-H51Phj@TT&DS?gzJ2o9N&_2
zpFBd+eTOs$0Y>iAC{-Yhbqb_$wE}7ER3MFCDUcx?P#}#L6?g>3y9%UnT!Azgo1}j0
zOB<OXiAD>OJQ?XapXP7{2Q)vHaD71Yn8N!sIVdM5lED;9_Z`xl2^f{1#?KT;<Jb5+
zr{?Ni1m0Kpf5G@ffi&<k3O&*|SAjHg@JWvZ9#?o8?<tVRm-r+Jfe@kxE;J$vq|sY}
zG#LM+#>wb!!p9a((}y$a(JY#s@ky=r1kREUdAn$;JlHYIRF-k@cssrh&Yc*h5<lYZ
z#^*ZoneL|)_#BKQ61;?2Fioc95-JbeuRx~nc?Es|<7){n_!b6Z<w6;|j!)b07`Jm2
z$q*RlE0D%Gd~K<T%U2{tFeWK*3XG`=GznoWSuD&WntVzN>cLHDGK<KJT!1GBmCJLI
zIrNnra(A&H%O!_W8gudaPVGKt7oo+<p#sKQ1=6UKU^$KT_&jHQ<}LzT6rM)21WRcs
zwH)O%cH#rIzl*>we6CYY<7W~qH7THibCUqVi4@pgnt4zLUrCv`<>ZAb`iw1#I1%Yf
z5|Nvqh}<QKNX$<};*y8qo03g%F!5;{h>2TUyoqO9yvcUfCq6IG)}0MS)vEa{GqPz*
zVpy;sXX0Z&NRzMT01jwQ!5o`i0Zm?%Ck@Riji*_o@iZxNPVPF$d!^*JLz-&=qr0cE
zQ-L)0DUgOQ8SGfWXAS0QcqPoW_~;P^!vL5Z{m0?6oz!Wou(baPU)U+V*`Il{|EcC|
z?1sCsGX%0t=3)3Vg16#Bm$8U+oAAl51SXYs5^rdK2s(z%8fM~vsD1_%69$kW&ru)^
zox}<<QhAqayY4&T>q~s-%4kHTuM!h=V2!7wzV0p%@g)M56U}=R9MJ57br8#jW>*Q<
z`7|k<PcAd^cv$+|A<YATG0M;gKnjq)&XB%#NHeO?G<s_^O)^dzo}K}NcO~E4T{QoJ
z55sW_48_-u%zp;zh;mI3mhcwl7ZPjdU5TjX?qZamkj`Z^o|5298W9<fGRB%wWZ}_N
z=}zP~*NJ)39YZC|p$ZOYJ}BY(faXIA@6-HH<7pn#c$(aGNY2w-;ATtr9nxG37-^@m
zR)I7=!iVa#g61a*mgY&opq7SYyu)!}GLWSC48tIo<Vs9VBumDb%DPO`v$E3PP54kl
ze+=U%3N(}n*O}jk%Mb8*&f1b)1QhAaUjqC!zBchuY0lk6Q>U(iCX>Q)psDgIQ4U;l
zcf`j!OtZ6s1DX{Qt`BHdD!fngCmK(a8!hx}Vo!dfByNXKvjm@M_+^0U-`EMS!iQ4u
zY1SsW5#E?&-wOEVB)bWZJQv|Zv%FE0FpG_|!C@Gs?^`8hDGf$EslAx+!G}RJIQXHV
z2yH8P2q?Zp!9>%1Siu3!w<V0ZI86CO2WV)vgMfh*lxC)c>wKC=G~UFPk5Qb!he)Ks
zsWU!+-C*QMuxu2JF$yezF-L)wFjgzjaQXqP|AjB?l-=x?-|RmN_+@E_WzNk$VTNwp
zjlY$^aSKv7!*<cUM#95)?Sje8NJNLmPw>epA_4LS-mut@1iXSzF8Y{yrb=1}oCV?#
z*N=T&f)lJ&5M+?b)ia?htIvoqFw~W~CeT#!sd4(Gp6tUosNCE!*F=Q&ccd3AIbi-x
z!2wMNA{W_Zz;q>y#UjjeHJ)a!#?$1!S#lQ>z<vfkr29M=Llrm{#taFT@hJ>?N*X)q
zN^zWUhU}tQES*bekXq(v!kf)c2&yD$Sf`fs<eZdxlVS>^*5YH`q*<@vfaXpK*9SDY
zAD7%{>F+9u+ab;C0GmciIG$v`5itE5_vEk@kKA1}=?}R><9Y?spwFbbLdn>V@i8(q
z?^AF<lMfm&%V~1wFFC@8VgHN9(R@L{0nN`PTp!T<x5C@riIOxIA9>OA6dcg}t%U0X
zn%v|g4NVPSVG>Fn{iOSjfF|8jAi4>o8rpt`4&2W}T4_9pk2Tlu7@?inRTTp+!-vl3
z78rLa&`{F1axK{m@E+-E>&7BjiB8JWeX#Dw$LQ01O2Glm4<%e5(B!sYa+dxX_7Cu>
z_BPUlPdVWynv~|h6&%pSTbE!_AJF6mKH1ScTjObRpD;O?lkj&Ya5|VQfc^0y0W?V6
zCIW{b{J~NiKdKtxVJW@erjA1K>{Bv=2b6dsDH*2@7x6Ta#+s8uJSwD7=D^RURw#8c
zhsSU<nLRthgEAT?54sG_O}6uJ2oHj2idIK8cq~KX?HLN5m(aMxc?O;?ND%5n1&2?A
z#2)`-$XqpTVhf(z?Fj~IGyH`F&Tf!%LtN7(_Pn{jt&y$wmbs67s)OAmzB}PO8;Y24
z3#qtz0}dPUrxv}0Se6&TZ1Za77NE?Nm^T5|;W#|Kt6=>O+`0rpKO}dz#SGOne3ncz
zSjbDza_QCz!RO2jBIzACo=i4q^%x`{pfZ^Cc!6_78#~`TvF`Ga3*R>}7#!S}`a%aK
z;o82T#P?kc{d$~Mm))O1RLRFiqzWRw)MC)2Tewu+1b!(AzgoSm#OHqusYdbD4ueum
z5w~@9wYWZ3=kPI)){f?p5kBzI+9lylzaPS9nOc*`=w6nDmdWDtMTRap{=E1uZ@2Tg
z3<5=~a5aUmX7IHQJ|!Yu`L2g`<%xH;G#)15yBPA|3>pJ3mh=4!UJByd7d#e%r!M&1
zA>XQ)jQ7Y^p+@qpi)1@b_nJH4JV1}b(DFeB9<2t<#}Igsd%_ZjC+YQ}exB2o2a|bP
z*c=UZc#B)!-{En5b3d79Q}ta3p3_$Mg?KVs-D`1pN>yDT<pFMeFO7#*&8;Wic*2oe
z)MOq<m5{vh#tRqf9ztF}K)9!|ys}nZwEH9(fm_MH?r#Yk-Xu`h3U~%qUL)Xp3P>NH
zFVN}Zo2R<G>}>(=n`)fH8`vg+yke`<!WSfTp7AjYla;)9rBd+WK=1&X2hw>-UFH_=
zE30hz)Fz4NuXU-&ljb~$ZS3;kH{TI4#m1KiWNGl!v?&dB)|t2L4aWH?oK;aMM_#$s
zMe`1v%%N!>B-WX)=y(aul!k}`R(A<`_g9tN!KD1<9UEI1$a~%yvUa|_${+U#)$ry^
zJO7wBg$W-6nqns-nlhrRD1;OgM4BIID8@AMCxhqwVG_Qp@a@27ezp-MH^!toWzb1o
zk3q@4v_{ttgVY_2v9gmi*T^j{sk<^b(>2OB2%I(Q%ByiyeXlJvn|H`d{iLh2Og?8^
zRbE*upX0S8%-+RXom=ZhKB>04zGnR84qnPw#dpqhV6DcgO}r<Iv8iI^LU}@Gp$Y~s
zrl7B^hF=|yGpVrfg6KfJ9DR;{I9g^eY7J)doFZ?=UyP$p#JLuKhfCbe_&Y-49<k6t
zK-`UuIA7o|=^_pfJ}JK!0#djEs49x{APbdPsM12WS?Ep+J!zpoS||!;BN1BI8E2tI
z7TRi|do1*Ug~F(r%5RZ{=31!9LOewbPY7d=#dSq(RencVXa*ofx7tE63*Bd-rvWLy
zFIwC&i(85|pj<avD2jSNO6DmW3>KkGFaD~~##?A2AWT5v`ZoTeGXwMzh!pfJ!cfqw
z7CHkA6|OsG1PY?0OF`#Z=zI%Ju+Wtjy1_zO7%r9Hffib1p;Z?8k%jKJ&~GesKhmqX
z{Ki5rTj*~V;@n=*l_A**nuVcWL4UH)3m9}2?kx+oL$9lFT`lyog&shkuUxY+5Gd&T
z7W#{Y#$ljQuI<osD`>fe)?4UX3r+22=&rKRHVf^xP)GFWir;VxZMM(>3w>sx+d-~;
z{LDg~(LF2N5DRU#(5|R)J#3+F7$KC8zgQ@(kHM|B&<z%PqOWm%!9s6aXh=WfI?h5b
zSm<2~eQKfaEHtLS@q4R<%FZ^pW((C}NL6v3kFHBWdo9%CJcFBVp^e$5^;}`0Er3ux
z&}Md8=pGC0v2?$;(BsziJBt%orJ>1zO9mjtuZM+3TGufa%D1lTE%ZI>`h5%CZe0&q
z+%pzBY+XOG(03L}!wOKvWgs9GzibQTTGu5Os<zP0mhM&y{m{BTYoXUH^bZS#u*y`S
zrCO*xAQhLM7MgCM6_#$5g=(zpH5R(ZLXTVMARtWVkoRv|+{YGja!t5lK#J~6i<<;U
z#dNBLW?0t>3telW?^)<B3q5F|zW`GF{%WCDt?S1Y%E&XZ>S3Wl7Agj$xRh9EmUXSN
zP|QNNTIfCtJ!+x90#f{5wa}Z^^&1Pd8)9PB%|d5es1lIkQe~ml*7XM#`k94(ZK0<u
z^bsJ%<r542+q(81YGN?hLSrqo6p-?}+(MUG*DEa)x6scm-GdhTZ|i#0;y$v_C)Sm^
zWmRZHEd*U0x)xVhXuX9REz}H1`P~6X)w&;B*I!uIUs~uf>w3iE-m_4Pbxp^Vs-vv!
zBLJx|F0jxz>$=238v&`_@%t9K$3hPQQe5^}+|%H%a2S~6i>qNd<5#$Ri<@BSwpd)F
z#qGAZ`z`LU#l2{8JV=%STiD42q{84`JB7=)xD^(+%HnRZxZ5o5NsFTpPVwVnMe*|i
zDcnGd%eJ@*i(6rFcUj!M7RRGUir*27>jt(8hiA=AIxH^V;^tf2B8$7i;<i}aLl*al
z#T~Xd9{j<7<QgV(4kl6m0m_7nqRWvhAXxFEMy2Jhz8auV_U|@8QGCce@J!b1OpNDp
zorj?}>6fh48QB4vBu5P<YjkFOPDex1A82}C(omoCslT6U6ehIbL!sO&rw~1?G0Yv$
zr5@)~BlQPOgZ*F7d=46}fm;8b(N;`$K|}q`r~Y2nD9+J6_Zb9qYFPi!H0>l!XGHx}
znlCjCOVe|s_<L&d!`fTAq?wDqr~V?ErahcIcj74lC2MI$VS<J|%BjCz@L2*h8K{^H
z0(hhqW*jg)^_ifV32;#>3{P>AL4sy2K;DW;V0faF2L=<ETLH3lB`~`I@}yP*!y}jK
zkdcWYTmM}s&;-q^0J-m-!0=2bcYG6=Zvb+OG=b@Wkhv9?!1MuzTTThgFktR#h2c3$
z?(!sP%7JlESP2Y!7H)SWFjoP?RZRkOJALV&0)KG|=C`L{o;?Ng)+v}{tuQ|7d`?B>
zlKSNf7cW`D*M+rBia|BZi$n&$td=qc<50cSfHn0?_{Q71Bs(t&Svyp8;JGzxZEb^i
z!hw`5`O5kKPa>toENatcVX}=oHmwk9yT+i*UX8JvjT&QbCAcw25UH&jgRuKH1|c_X
zk}Q-X8*8iW8iTZZH3pH`s4*CO>C$qt7)YfJRbqd}U_hldXAHvb%os#sTgG5o@5!77
zYd2(!Tlq9R^R=dKnT^Q8Wqe=8I&<3s5AGrBTI2A<8$@AkWnsqKgeBAXdfC#_#T&45
zv$Vc`bx!r*sQTp%9g#P5<oQE~kBCNx4Ixhb9WiW}Bp5P0Z`eo)EoxWnvX8|v+)I?y
z3(`zCdBmg}&k<#z)%mk%!^R=LD8A%T6V}uI@_|hrIZsOj<Q9CKuO|QcAxxgSX!Qeb
zaNfvPsMVv;U!(U~KU<-9(jeVXELW0#e8~CPB5Y(Jt^BdKl61o`eNXxw1N_g4INYr1
zIC4t5;TWisegn~yzcvX+W83l@K{;dMhv+$?*m3S}OE<E0xZhz+9Syo)wWS-?I=xZw
z8&!%vSkob?Dt>u+nENMw9DnA4uGJ63$)hLTI3+k%){08<qYmYU4<oTBnx2;$eCrAt
zK1^>e`h2BRvhrkUSqoKPH#`|_+E+hF>b!<)eD>$1El)~(X2bD{x(|sf`n;s&A%%-C
z_~z*+fGca+m4ry>5H2r^!8t1_kPVV98ases#*<t9=jAO+lxKuce*uD=Idi2`+Cnw!
zvB#lkdV+GLm%3+71O_W)bLH{aF)Dwj&Tw#>_W8^f>feUK;MjqL<FA+-NI#Mfov<Y>
zpFl@4NWd^-rGtOtN?P7hsHdOUzI5>#ytWiAFDRTnds=i^ZT0HthN`+1RcoS)quAqH
zvyQsws@FILvt|_(PL2*35G^Q+sz$r8V##Qyq_kktw1NaCXB|{ytf;MCQ(eDq?2L&M
zo$*DJrc93(%`GgRT{fk>Xtc9zds$I&QQ@rUfWp$Ef>}k;Sq0;Zi;_4Dh+c6;bY1-t
z3`_&j>1XE+I|mJZV(E-&Q8flET#dKADr=*2CKr_!MLE)q9e{m;Rh5X`^a)W8g}uiP
z(6sCD;s;)zfLm0$)>c>7)j&7PxLl`AJf=*aP&D^{i^qSA27-$gPnlX|lcm`89}sOD
z&g|(^X3j2({%^qz$@?FZeM)$(*!CZgl+RP9mlc)HLV&Yov`wCT=VTyr>>TF$fT+%s
zb5(xJqG(Gqdcc3o1eQf~Z1n$CX(Z~!1k?}I3mJ;7YB~QQE^Wz9S4Eh<(^Lot?a0)D
z|IhR2|2ST!MvQIb^zmt(xTq;DW_z}*_t{ZA48M@+&5oLyp3P>%A@elF7H!pt)>l<-
z7!aLNYTA_A6=uu959ooXv^5jP*xYj*t-}6y19bm0ryM<SHnd8|*QLjfZFy#3tT25G
zB;n}xt_(_6Ix7aEkDt?0dO~(jdpM%S)}<dP%yMJ1pJBIH)-nQa@!8Kn{d4TFQ~(_>
z4EB_OGM?|pie5y2839G?arCcG#tZ%U)PVis>=&D_$p5x^%vbSAerc@eaLd2G0-I?s
z#vY$b&Mik^ZFmxN&y>bzA1*0v`Ljf1?!n5%*|NE(Q<ukBfED5s-{6<SSIaLzb8r$D
z#?HY>av_R76)cX<Ko7iZ`<@ku72?wfG8vz}+X{O%?#tN9i*p&jhcfTOGiM^G3b^ly
zDcZRzSV?~4o*yaX!<s=x(?&4f!+8YQ-eIvEKK9(8u-98`F|k}vfOf6Ljv$uu3t%s?
z*eJ0a|A8&C*mlJ3Q`kQoSBc1I`WypA-qU%{mu%aShN(nz(R(GOC+lBChQy{FYPl73
zDi@me#it$0XxfI{DS^WEYtljNDdNK|HJWVNA(Yd~hW(=9tDycDB_${84}(|BOy$gM
z$Y^Td$n;@4oLWXD<1aJ#7h8H8{LykC_4vzjFM6@0#aE6;Z-7(m@uS0FxUPo-Vqu4>
zs_pM|I;#`9sl8<N)xK2yY!y|9655)n$vF&blA`JqrKmbEimFqS6;-#hnxUm?V(P69
z5^A8+m7?nQ2}RW%l%nd4vyrWtoe>W86n8X=syihss_txgNd?gn9ZBdhW+c1lNNQ_W
z8xKj`T6=XOc?osZ-4VD{gMFsaPJNcqPMxJSSxZhm62ao7vqYeH6ed~WH4gk4RnEAO
zpw(BWQN49Sk#nDrqS4Bx`wnYm?U!Ul`ubaC(BP8badr|9Pz^|?N)BsaJI%Z!+Tb}x
z-L+GN$*-KBVqI|>P0xDi@;~c(?kp$Z;NvRo&7SJQheBQRQk1H1ti`T))lJ1DIwaLK
zi`U#mkcdEMONi>4#p`Y@-0&t~i0Ycf8}1bB_wbSZ_K2}~Q@f^z66%`8TN;@e!pm-j
zeArFAtx*x8<YTeoh(>h_@s)l3@UD2r{eEZi&k7}}YZmWnY>!YYb<N^$8s9UNtgczS
z=l&Nq!=SD?q%~iN_jO>=P(od^_`BOvlJyH$AVb7I+_5s~fuYulnnjCt$VKQ>)GUr_
zZX?6T>G7Z1ItIZdDQOlTXncN1oedEmx-(?vO@KmJyhSZOak-@@`c4idDQOm;YHzbb
zNlKc<XYSpQ=|V{}iit{^#pmv9$!vb8wUTD>Z|#3kNGoX;U%0CzX+<cZq*;9F@;Nin
zcSXo5X%@%bt&(t6C|OCf_)3%3gp!mrixV1K7t%`T3bD49N}9#j?wyj)#!xFI&EgyF
z<%*D1QkU@bt$P$AG!IIeLrF@S#dp#Vl{AOiDrpuc-6s(al{7OBR!OsP#QPF|Ln}NE
z*9ljI2h+!P1d{N<$D4%^%n-hjACgL%g(v<A!9JBVhhJnl`{Ei&@FO>rP|_?y8he);
zf|6#DD!R#_??uoBRMITc#Bdqp{oqTC46MBl>>-dDt;>$c6wEiielH8aDrpuSHTiGc
zP%9<PqLX0rq>|>4QPM2B2tHQj_1y<9Qc1JuDh{BcQAu;iC}|dFhzn%uUI9z3q*-*+
z+};44e1}w=sd*g%#+-{2XKCc;ZYWtvv&a%ZMhl{nW{EdSnne%I_7=fTL@Q|)J;i95
zFSm(MMY57+(MPZkkV=|$r)BghALzj<+g3@lA<}1Sy@Q34>OU!IHXWg1`ZPN~p_DYI
zK<Ow8Iq)G-a8e=8aG<35W?<S8rjq7IVF@KGX?`!vW`xZc-J`Zu(oFX-j*d7`(yaPY
z2eoxoHIzem>qQ7tKlZLxN%Of95rh&-n#(07oy{3<$4V8LmkVBZ6n!&8R!Q>>5)lct
zQquf@M0N{VCC!Q|3r)!?X;!Ex;&eJC%_@HV6x+gtlICY6=Ya?x=h6~NniY9==szoI
zRus9&;(sDz(wUv@Wsh|d)(-pwr|V@I{0kQ4#!QiJ9oR-YFdI88z#ovN!ATL#utX9{
zCYlYWjKI&ew9G!mP_yCti;4~NLphNHLfBxPerlZv!HJ#&|9h5zxsvcJBMW!lKTO>V
z4^YzlHsDOcZt9i9bn-p{rX67_Y3A6gDoeyOl_gn8v%>kI)=HWcHVE@k6)0&|19*CP
z9j)EGWpX^vMDLSO(yaP^)E1+p`G=ASH6@{>`7wz?T}dcuRw&dJNP($ch3h@X>*>8N
zNm)zUC~0;u`@#F*U~82$^ClJ4-4LY&>`>BtzQpAcr<F9%kr=3xNK(?gM&d@It+Z0o
ztO6f{s<=ukX^u(4d{pVyN}3;$_z5VI_mSy=yvLW$maa;ECsNUYnb(0?mQ;>(06DWc
z@Ylkk=$RWy^mK;%kF7f+rrhb&fgKCndF4#`XXdo=Z;0NJL@Xs{SAq!s!$5R&nPaE&
z?hR~vIbbsXl)G#(Oc4Bzm42Cz2{)h@NN<cJb1uOaPIcDlUh6~%PCthstdi!yzX|qK
z%7?v+g9Csw3A>$4w`kQizYDj{eARk_zi|VG{7AjyU-1)2iP4KjpxNU}$+&M2slbEH
zSDk}V3LRYpx(}{q4&vGR2p(JB!q`GZZx_x({cG0BsasZrastP{R!t&%M)>-x-=J*0
zB1(y1Bc~a7lR2`fjOr^Lzv)RCHeO`D1L=Ym=>`yVB|O*vGl{$8FpR^U<Ydk1at>Vl
zzjTu}KY~a0pT9Dj9D@jk1w73ELO<zL9D&Y?+FI%=c~M2SBqHY=j{jFR@tlQB{1^Cl
zbic-5)mx;ppuDA-DOhkxjnvdaT?k9~BIaz+@m-AVa(1pYP%GBHoT5MjwaTKvNgYZ)
z6`3>0hcGoz7q-XP1!W=j76mj=EB_9M_XPTh%)>GmKa{M2T9F2!WDV3WNxJl8?^Xl#
z8`3Q^gvY-5qAWB}D-IE2xOD>!)GEH+Fo8c+1GS>g3dx%ttu;_9r)UUgoLg(4R&@tu
z8Dsh@GiM;l?Fdr?^%|z%YM{=SH4Ali4M~?}^6A!ggsFj=XF60zyvAlxk_PID(l3T>
z<eJeyt#BB*TWO$PE-5j3x7I*?r9@|jn^>wFGL_Z##~U;6mG0<|tp@5n5`*q|qSZis
zOrp>o8x7Qo2K}(sK&|ZPeld6Bl@Ms4rea{({aOvwyk{f&qVr8?pe~mv^uAUDwTdA6
zUZa6pA<*mUr5iL*D-^ojWDV2`If2n`t$}*C3}Z59K57_=W%99C(YIK4k8JrJ<e$W#
zKbW`+_-8ZPKibbM`FA)l>FnbIpQRf3Y*2yELR4MtVtS!d2SRXSlfo>|5-^&Q0NB+Q
zdz-;_AOxp7VZbwLO5itGGG=oJIsyB0i+#^v)qF*cDXh00=m1KtE&~4<^oD`I&-$Wb
zZpo{Igy;e8>?Z^N3roc^Q&f5;k_CiHD$7nK)dto<6P<5~wzMXaag#W%G7-{sFarMu
z{Ou?go{7kq*t1Lme?BNwuq-<jtR8C~1R^mfUUM1^)I-oegpVOSXrNXN+JPLwfd*>2
za8{hqK&>#LP#X=@%3FYiT^kM5Z9+De!>ED!S{v*E8?4bltpong5l_-U%`P&8r&SXg
zsBI#&25Q4C@SjFzpx(eo;4}QdZ^7Smc1WJQD;DbV6%d^z90^5NcEY$wRYqC^bun^@
z!(&1NwZgc-C=JvqY(HW(Q0uIT7!A}Xz!JLpK;VSVapZVuHBi^XjY|}2pnjG?YYo)O
zj}y@vsFl@^Xbse?0&>`+@~6;nWlfK04b&=psOr@ksOj0nc7V>Qh|xf;IU`?~^1x>#
z#OX9pW1(g>P>a)Qpzg%e5h7j6v^w#oooMgoAf}zDfm(EM7c=Q?G*EZq4Lp(I4uD%H
z-og`^Zj5xv8mK$rTAt|WvQSemN4G6<-3LI^j&Qojb3cNGGhoa)#1L0NRL^l*YM>TF
zwd4Z>s?<O&hG{8HpqmfL6N?+<0J(KCSH(oB+YJP1#-1&n_xg50a7h}d#S5OA=s0LL
z$r`A|U$ui9qFxWJms-567Z`rHl!<x8`!1I;4nl1-P>WYJp&aB_IpQ79&m(0frxJ2l
z5$|e}h(W2lQQ~hJkMTWO1GRWh<FkyM;X|*T<QWYq4b<WzP0>#wG{28EcA(SAN+V{u
zLy;3{#vTzr7WV=nS3lxzDV<?Ca4IP7k)j3mEOMeK?$!1XL{8K|E$)+o7UqJ~KrMbE
zZXL|Da{R7D+J7q4>@ibDfJ3U7?LMr-r!^w37BkV5RPbAD@Ja)<xJIm&{QQv8KrOD-
z6hTPo0~HM#ksdM{s70fWC1z4q<C$pE$d2Ix7T<M3bqJk6qcu>At(v5>(}}X%a;fP#
z4PZBMt^2->WP__FVW_LnKrI^G5d)cIN<@?fYSE<StU;)i25NDg#-~!Uwb2pR>spT7
zny58Ui>*?uhuRXJ&ps^X?i)nz5vP;Blqcr6pCc}5+FBuQb^nSRG@*4%lQmF_+jN6*
zLPi6%_<>77myD^_KrL?9sBWP;>><kDRQyomvQgRCQ;8pGM1II<pcZ$yl#oFKb%@7h
zjRtCQr%vEpReg48>pUg>zROk1j*CM}6B?++k99=nhp>JT_qb{Sv&iYhyMd0F>%NQB
zrAf;K(aZ1B9cjg=C!)S?zN$cbOA!<_P^+-|_$n-+<d#geT15CErGZ-X^HtRfAas=)
zs4XTPB-B7H`unPlXNKye25K?D@6cbCMo4O)76Y|C3*)T3yDQF-t6pfJmIJl5LP&1<
zB5|IdDcf##NNS)K+1g8PsI3NSF-SWN3tz%Yo8$jXwuX@qOyd^0$n{kzK$5PNVTz&J
zN4}H#C)S^NZf|5*JHnY_wqL{CTcdKeT$4KCUy*W-wxS*z4b)<;#$gTPh=qQmjCZ=z
zN!5#s-7CQ^O<J<Vc&`}OtwKrzwJ7vd)PS%WsKo^DQQMlU9Z}@z)t91y25K=;Q=m1Y
zgL1?q-GOCFajGMxdY?-USP~^PP>W*SVRs89X`mL<G`4#vNdvW*uCZsLxmpd>Vur?^
zg|uNnq6TVli8~(&N;CGTxJ2|hi`ge7((}cY9PrRnS`E}<f$l(rT%MU8R$Qvlo~oJ)
zwG}myov746Ef$%MR0^fUVxd;g>>1<$xkPY^sU(=xKrNPP1lB-S1GT6Sb7b~(Q{8E$
zSRk!gPA7c<TFiIzkcKpEO&4qZ)l3tLx8DD~EM6oK8mPs3Qyo<8*kEb`SaELZhz0Iu
z$w}IB#ZSGpxI3r9-K`52tdI$^*Z-L=NbHN5tHa{w9tA}lJgf$4@e40g4y$N`x<%cu
zYZ4kERn>?GG^a?&XrLAk+Vbb#n2z5sZSflo)Z!r>uPl|x|K;(b6xB`1uJ*q@)z$V3
zzt8sYuy;bb4h(74)8Y}2izup|?u33(>edqr-D{BSG-Hp52CqX8WGMTxMo;x+dN6I$
z5#m6xv{v@4*J%{SQ)n@-+Bjuh(OT%b#mJx?!Who0Dp#RAw(4XDDt0j)J2lCGk8K|B
zaG`=Yo%A(*vB>R#sHACYrdTa5gIx+n#2TRmBdWxz1y>;)8q~;CW2++<++wXB#?kcE
zRd}()y_~$2?YLMQ>d{-Lx;A7|4c!c4T}Vw`mB2;Rg=~{o+j8}x_l7Xw^w82Io!DZ1
zNOkU*GeKmkbYhDQ8rd;~q0Z{W78^CX6Iz|riH*1`-<?A>37yztlg47wWi(xj%^KH5
z;gn8nafQZq4K22mSBCy6BZ{dR#HmUrwzx{CZX~*Hi@aJR(JMoq<%liXo-emo9n4o$
zmP`mqo!H`9ZO67Ij_5j~LEDQ%S|_$>)R>Y`LMOIp3eA=s&@AMf)rl>x)7ZHhD|KRv
z>otS<8mn~mh^?U$GEIwQ%(PByu}u=oJ-;NK*diXHTukowS)JHoho-&F4H=!-;(Hp0
zeLtxa8~Z^_u-6w`en$PZBW}@1Z2TFdp0w`NF1xXZW_4nV?}svF@Yoit)H<=nt+Je`
z6FZd9i7jpmagdg~f=N2D#Sb(ZTYpJ9vBm8g{UmlN%b*im{4m6(K%Ll_b5bX^_>smO
z#s(n{OzVE>j*#6XOxB4l?hO4B{RVYn%Q=;LszdAwb(PV_R$(ih*y1kD96N?mC$_j-
zN9a8l<5of^wzx+p_Csz{Ch5c$_v(loLr$7$z)y7^LML`7{T6~)>Sm*jrfKVBksW%v
z58ABOi7f_&)MQ7^u5xq}KxdWEi7f_eEaVCao!BB*W5d8=mg9&#jYtVuo!DZC#sye|
zwbqF(hH9r&HIo|_Qd9GGm~OHQ86J90cM)3YtQZkeQ@2dD6gywXJQ6ZGvBgMD(Jf?k
zVvA9lEQ_1P)QK%F2&ws0RE-CtwY8s~5lWrdVvNRO3a8Xvi?Nz{Hkd1&*kYVUVGgH>
zE|etzo!B9x6I&S6$WSYt*djmlqD<fzl$F+rEh^ksQ8;PFo-1zl&%mZBx(H^;Exw+7
zsKI%swqn275qJB)k=%Tzldh@D-2U8eRkjjwLVVNDjMQJ-1(%v{eWSNrF-*((*SF#h
zIS2-r<;W51J57M`S&y?Pg&IZ8`0SYRS<P8pPvtTDP0p%>cFqd(WqILwY%LgrF>#au
z_<9D|PcHDN6I+Dzu#FOsd#;X1@l*xC5+zwDwrHoB=b|^#I<ZB%9!gOVS|_$>uTjH8
zD-t@fMF))?5xPw4#1<JEb-p}wGlfgyOpQX9Z*^jeP8vB1NOLr&v&LP3-S27);1TaJ
znbI*@qAt346tIfE7#GwKE$5Y8brL3E+L44lL(e@XtGP;dJy$7qQt_OSBbK`X`n*iS
zZYT9zkXYen0hgw1f%t=W39O+_j@ajQl~V<$8+Brf{T@X;zSN1`4fe;CUFpP59mZ0s
za+kwzJHq|M=<r!*v)@2{a>SUhndd{DFm+;!v0**phqO*?F-~J3DoN<X78i!q_=U4j
z37yy?Ut=?|i?NhCu|<LQjVXUZC$<=`vE5WPDh#V?q-S;$!t8BPtDMyCjQ>h^0HWNE
zaJI+{zr*-*4cSq1flY_jNn<b(;yW;o=&U&hsycTGtLmH{(mJul8DX_1#D=lbi7mQ?
zRqaIQ!<Cj=OLh;d?iIa{nTwwl{%_e*b@!7M&XSQv_ak*;iyj&Q>5X}lMqK88g2<;C
zd$#yX=)eH>3*1>2&+F+G7X4~D`hrIIGPy6>K3M6*7JoH8uZ%m&{w3Xyp?RyB`#MLw
z98%F#b1_}HUX`O1<Pxerz7|q*XQU3*!bmD!*Vt$%p%YuY5z@(2o$i}*xTH>O&*;Q{
z0SW4^bz+}EeH`I){|;0pLH7)v(+y{T2}D<dx#3}FL;ez3Gp!!)usPx3s`fdN#hTp+
zI%8(*oJlzizq7)q@9iKnWX^eV9-7i)G8}vfm$-fpcVsp)6_a?srxr+{!k6&opWn+>
zGge>5-&#?*XF$t(R7*3kfSpmJCNzF;jl&|ABz@f6^BE(|LyH$Lft1Yes|nCYN{sf`
zPop9A(}ew9wPK25X2jkC8cIe;Uj1Z$J)M=nAK<DD)qz-jsrTdjftnNg%bLP<*kL`#
z9V7kaswtX(t|l0U15eP^>Yt~1V5r(85!tR<`-}-yUnUWQv=5xtlc)Ur9F5S^T7R&%
zPsT|rZu919mc@wHVtw)r+D}w*l_-%=AvQVvAsRO;v~FV6vTDa4>fStp8OAxSd~8q7
zsb--8`$jBW(aLE;WerY}`NK7%6|Ec{e}p?(CVo|@2HV}|YpR+MMpl2Mw$+8|*Hqy`
zN+I6P^G7Kmc;AgYj#*t>pl;gu7iiimDEY(b4ki8bM@zIkm{(g_S6{nEO#%He?sNnz
zPv$ASj^<cR--7uYl%?twvp-IwG2dIfDG7g}ED5jgF?Gz&&zIszuP;uQX<e&aMfe3W
zyS={06Z2(%yp+dzeZO(Bg5r7wshfer0fid>ErMD?jolTFKSATZlm4q}i7V2$lWu5r
z)tWiA(2R%8)k>{=*q^AKw+LiNIeMUJm31pH^!byt!!<&l0QD#9q%~r@0NrREPrf<+
z6nSn`9fzYnJ$dfczev+=$K*yeaeu1&AscRAoR3?>DZ5{+X`U2n4)0IXd2&dg->Y0x
zS%D&`t6W{l!knpzpApU(Wf(70`WB+CcO{tV|CUD+)cJ)y`usv<4P~|dV|rAJpykp2
zhp?=Zf#b1ur}X0~jVwQ9XgcJgJ*u3PVWjU-<D|%ao*tW=lo4F|_NbYHEtZt?B^k;K
zi~W?5JRs7OhbB@+G0>jpFj^Pz#6%Bu0wQHJg_k|#d5M%UY~DT8wtUK1&LMifK@a23
z1s=WHSoCh#s)g(-@Y#(8KDRyspGm`U9EdAAv!6p(6iGRcCx0W=HBz5+O174$Mrwvh
zd4I|vbuieKr$$n8l(UG`40lonD~lJY$#YV2P3F`LaZ>V>1;;yvIw?bxB^@lClnb{a
z3KUV`kTsS0R#rq&4{H%CO4kE9!!;X`_CdmQ@sZ0jqM<5C;>E|Z^eA@2Tw<0K2>nZ=
ze0hq}5yxb0gILMw6^O9l0qkfMwCUm|T5Wv|E4N6Iv)Cwh3?PB4z%kT7@E`=Dz`cmT
ze<6i`IV5zHXMxpDlisMk1PnXMlfMachbhQ(c&UY(+TZ2LRCPop@Nbkpc=k52Wu?wc
zk!1%SsD$5pB^6KNDk`~^&+L<=Ao!ys;DOw>1U$e8f)7BTLgx|M(}pDj)Coxk(V0x}
zQ~+{NbdfMh5asqY7}DX)V({jKMp7^sZa1i4xY?5wOyV4&j?g-|BVn@oQO+3n6cYtL
zCt!gTMh8B{Wohj7_*!HjCQAu#sA?i^I67jAo(*H(D%T?y>7{@V@B1ZlR>L#dIw&`^
zQRIv^@UwtQ=l-MF2$YXZb`!68cf&=`U|+YAY9qscLkH?B8UCBviZxIfJ4c++S2E4F
zv_pERihY21TiY=cR1)?hdYKYQL|_@ExtZc0a`({CwP-pg%uYZY^;Fk`wYTK^&qM@p
zC<YsnOCcrtzyywTa!(}idm~MO&y)o|wYSPW6HY$W^Oosio)qAlKrhz&A6jO6i9E<l
z2_QE;XVg}3dvCtpV?ol@%6@@Hq=qW0@!Wy9RNFb5>I(6(7A&g}15qnw%1XqzP6vR7
z%w<BIkuSsNHu&sh-sKe6_-ssO>8n^}i|_lKg@!g!T)t#64g-r@4MWBMHk*J=1*@tS
zW8(S)jlm8NCZ&$JU2m79tEv1C^=^vXCakWhUxgt8eZ!A*k|Lp%)woj619IXHjq4Js
z(o-sNr;a}*4463Y(z%HV@a%QiGIqpWGQwQhF0Ee0ZpINm_Mem@_I^k+w-U~L5!ORU
zmaVrG(Bkw1mi}k5<#VPf-2|{>&>cxEg?18~qU@B*NqZWoxVFcU9N9Lw;0t`N);u}!
z%tbTt##duw#UH?C(OD;^#vggZaEt>rX1+LzR&=rv_PPEAst@<O@ZN_%n&S(4S9#_^
z9g6bDC>%~5R@PQ?rZ6@eal&!KNNx3os){M=AaJY#dYnRck1Vd6SXGNHHvd9}IWq!D
zkvgWTS>`K;vm$G7L>4&AXcQ(Z5wPYuUODuL)U2zluc$^@uflYqP+@yUDk_(u=dY}o
zR=vKm4%5jA%Aps|8*0)bg^2>Agc|-th3OqxQoXz$NF}fLC#gZNPh_>^H4CR%IM<r2
zlHV`F4Pk$Z+7Hf-tdUzg{zWSLaw9d$K2?dphefI=@bHV3=aCTzRCF-Y)XqbG7mn-x
zbdKwy?}Uin3h-wrhLa<>GF>Q-v-l;7NpVC@3rsQ2<QXe$(stolNWWA`{O3lNa`%-p
zqIw+0oTr%0kJK!_d{y=0in6Lr$h?acc2Q*UEO|oolJCh1Q4v|JC0_n~g;^0<EDL9W
zit;Mdx7RT_3w$o_Jrj|IBT*f)0{?Oz9mVX(-^BR#sNp`FznQ(A8fIREv#iOzoX(hK
z$@~iZ-*KuHQPZxy>eP%Q52sevA*#PuCk(K@qwlUDl^meL;Q{7eOK)Jh671$5y^@U9
zl&z{pG5u2|5p`TnWF7wlh43R)n3kckeyHq07akM$KcZir2U@JWf7~GLnMf+bJd+9H
zGDQdOsin)8yMXE};dKA_+pt8|6s@VNMY(@v!mrUy;e-mokErFp|FyCQJUStlJ<xpQ
z{tGN{c0<{_LDeMJlJY{9pQ`U&Ick#KPEU()2tmaqO)sO;5#>H8kHF_dGVsTPL*U<r
z%nN+RQ1&sG0x6Ty&FNjav2rQr+3uN=C9=|~;vf7T1X&*}lif2pTPXpikCdXjXL62l
zIqZFF%Ia3vIqq2`y@7rLe-Gwbl53IStk$13a6N(VE__|^9EIe3E;)Y#jOKhUIa3tS
zPjfzxoW+h+eX)LXvze<S;R+IclDb^JT;lMBC*TL*<I8As!2j$TwSVPKWG4(=^L?Q#
zeiA#~hsa@o;ZRzSEebw=;<#${umyqen(Y&0G>VMOo5k)-xlZ2UoXuRBDYwFQ_%dpx
zj9Q9dmQ2H&?2cQ;j^a#@2reHTcNP(&h)|h0n?1!m+Se^!Us<7FDt61sC?@@(dv@n=
zhWp>J4y;^Lv9NmCLUrHKagSXX#x2Qdm>V9$*LQVg-D1amjt%oodWMqvKa*1zA9)FJ
zZ_VY7`|@(6Cgd?~h#JQTB4kBKanhMoM+(%OYC!)%AG>4kTOxN<8DR3ABUPriQK-Hi
z>k#V(S?vF$P95<=-l0?J?$+fFo|6~+DH!|ytl#gu`~A^_i-WPjywQWFK34GCptG0$
z-tryw{}8VSXKaUB^RbP~gD#`J@40hfDgBf8=2eHhv@u>iba*e@F|}&x`mw#nivE$Y
zbG+-^Wz)R6F<$zZ$LhTkR|R8Uo)PSPZ1mt6uQ$Bf@aopLu6wQF^=)r@(K~|&g3iIb
z+hb3U9^CK%KJVtMgZnXDo?e?a);#vdc4M>{PiXL<AbW03<|3({_lbhEk|(I3H(yh;
zHEc_wm)fFd<V0uZWL}!%;O}&)wV0}Xp(ML7Z4T81Cu#VVY)}N~j%}Dwmpxy5aPlPq
zF4Ch8#F4coURne3qMXc?t&}8}<T%jjEiTJ(;8dIg!EsI|S+J>43kXfrE5ZTIITEf9
zXwFr5pXLgUr^)<C)*u2a?m>`e35{|ImeJR81>&#$^#ugQD#m^u02R)TRR+gAT#Juk
z&|IhBfF=i5YB-_!ro#I)k0^K}&95X}AJAmalpI&`z7ikeO5-&NmXX7k3dCReBjHwj
zNpZaq);lDsWIqfZ&jA}6uS>9;23Y}%zv_n!cJVO|G(80eG|!fBeL#~v9BF83c%xyF
z0bFl<No-mCaz+9#G#l{2dqDFg3D*ZSUsiaZCi@3woncEJ4@&pkT{M3s;k;cm_u@m!
z>Fr~Q&fP`x-x6IygHIBHg1yx&d;qV4(ImkV8rv220T{ng*gwE{PJw@g!8?OU(g!e3
zD9}woMZyQ{88FUP;2;=d6j%s@t5gtB^&)i<0^APcZUsI9Ln-Vlc?RHH3i}?6qY9+)
zwFFCj<OK5s988wHk3{`LrICipu^n7X%U?R8nTbz08+@ADeX?<9j;dVD-NmdUJ1P{S
zN!qaE@p+A1hW;ktRZf?ayjbQ!`5Mg`nmi358IzFANEwom$lXO#C4uc#{zyg=C^wqV
z!XY=p98s8f!Y1W}jlVnK_Mps|nFfW)1<3j1J6asuTMy10jWs4Q*pi%DToN8<0i($r
zN=+23Z>HuX5c+EC0*f(fV|Y<gGf-+{cvrO*f)^|eB1vrwB|-+RuBY=#oWW2d0`Daz
z+d0WG_H~>B@#ca-sLNfvrC=~xwC(UFhQUdtD!h4N5LNP8fP8h3cPb1zS=S1W$Q%4>
zr7MOPb=shKzTTh|Q-qIqoTRQ89=mVtXs!eBD1K{~gg1TCpBJcFlgQ}uewIPYWbvX=
zGQ#M(;Sp7N4wVPn2^3LR49~aoTs#l`OIM!2x2~Lf^AtPf20X#eDGpDs^9U$Us$WTW
zm|VT#P&#j2k5AGS^FSLrg(v2;CPk-^_efnalw)bx52a?9dr@quH@hellTsfFW9+sc
z&s)lUZHi;fNkT6D^&TLFVrt1rxh&R$@>Cf`VruW#p+G=QQYkspXE!JxFed|eDnKn`
zx$>8g)EmQ1Nwrr;DS+NDR67wA2v`Kp5>gsxHWaxfrZ&#Fj2mC4S8yL1v=qS?)YdM(
z+~F3SBu&CmMj<!RD0n6yPcKsPOi32y4_fp*Uu7UqGV2WF+YY)ySlRE=r1s9km?j5#
zu1#kU50mRc8Jbj9Jn^8ig<?V@UgUXISsXmHXL6gz7*!c$**v2xO;-UaGo)0_*rf=M
z*9%M?;Q?h?^pt>^qE~V&9=<gghhi>O?#huTF?BtlT*wH(C=}AAtLS(V#1uD=@aS5=
z19+-xa7)+}AUC>`3zr-B)=teST>3#8L;;5s1#xMvOPOmx4RSk!MaDI?S&4I>#Fi;9
zeVX=b`YtYnxz;SfvuzI7-PXdDv0R06JuCsPGz;}QmWx^gQ|K;h5PN@=lJ5PnM$td>
zPz$ZL2QV>_T}wh^3?)IbHONOmWL-3rNnNQy$(NsP0*w+J+$gG3GATo+yH#Ul=WpS<
zgw`&DGr40k<A2tKV^)$irhYD_)L98+&C%I4g>w7O1}n!GrN>4o+p#5%=4~5sjm!Y+
z)JlyG&#2TxY*y1&g-+WRuGHrwcb~ZFfsx~X)0`7UaiQ+w9Y_rI4r(-@V*KSKKH@CE
zUvyu9n($ZA-4006{SpwWF<hU;U*)64LTN7Mcha>dAaqKgyElZH4WO{|a~P;nz#RZ|
zj)Y#fuI<C>HS36z1?W8KItUPII($%vH+m&NRI{!4-3AEjZQ$;(xc|1$Aq%}_q0cSU
zF2!((T4;oYN-b0g2)!1<pkitjE}vOICj{It0HKQjMD5H&B=ow4jsrrAhAV>AFP`TE
zQd}ljXfmJ-d|~Ha{6$X$s0R6`pr2W2hi7nG!9uy-Vxi|P^diDlu175NcME-Lp_3LG
z85kdvEc6(<9mVCKg|gApDBMO1HCkx9h3>S_Hx>%gjo&U78fGEt&r+OAEHt6L#aXD@
zLYpnL)j}Uw=tIn^6u+e%4RjeMDhjvWLU(sIxCbp%jR8f`6=4`t5H+?bD5tA|sx0)9
zh3>`xr07mss6#h{+i9V{S*R<<CFP@!h4L-*GYqxL^;rvb214O3wNTtb2@N__bf@S_
zEcCI3axi8o*Rd9wZ=w4v^mK1ScfvyB(HSVeUt4H6Is=8f)k43r&`0P}lq=P>DJZqS
zf#zFig@wMgQ2N=1F3Um#Ews!+`z>_k0ORA=7J9=%|FF<U7CLUB4d|j&{EnY%pkJJ4
zpi$WdnqZ+43q56_!xnM}86Qh5G!NZ}3geF!x)2?S!rf&db}0&%XQ377QWWmhVFv1r
zse!_sf$>{GeJr%lLhkv-HPb?C0EJ|qQ){91fY2P!4{f#3Z5H~Og$@ByexI?>Ve9&?
zg+8@VCWaivc_1L=H`_wF*0t0^YppBR3);u!*7X+_`kjTIwa}Xu`rJa^C=-KjfK&{6
zSg5y!@+{pr3(d5yS0Hzk-)?}=#UQWHv^0)Ay22G(+zl4D-QpgyxJN9Gnl%*XFmUM5
z!1;7gruA{Eo(wDY1&#VGG&={dVnC4`9fzr?X@!ZwreqJK$&vb0fx?fzJeO0x{?cy#
zB)<wSB#m)Nn8`1KBY9F@mT*l#J2mJ_8ouLs>hB(nVjg)eWf;a+f|j!s{+Mr`%Xh#T
z`_{k5v^52$=N`jfB(2TwkhassbNT+~seE40G^vsX(K!vx-!u&dQt(kiHjT2zXBxtQ
z37RPWo|=52gHM+<eDAyUFZrc!)|~&OCxb7~Fq$+}C|LlvAWIV%o_{buMMM3F=BF^z
zPQffZ1;d$)`6*w#$7FsAv-1?p?o%-Gv0Lp;`FiOTnvYMxaFfUU6c{}PGxQY9^iwcP
zPr+<H1+(K6%zdpe`(VrYzo5GUO9Dr>f3wH8P;N2h4A09Q^?xrydQGNx^NgN@gvilg
z7UDi0?v5oiC@ka&W~(~^vcokv(SV(D>j6g$<RLnXz^M=1d|W6yGlRr4U~+A1?6eeA
zRLsD!IfKIC&9XY^a!BaSz}e5rI(d8zVQOKCp_Z#Na3xLc`b2aLo-1*=qu<H{!Z^Ky
zdOW8sEnZ=)Zj)n%KTdcqwo#Wz^(fA%c<wLquxM*)eOaPah)7OSi0hF>39S>+sL?wy
zBG+h~7$&t(7`+oC^M;Jbi}FXk6CGqT{2UKh-z1?^^-ef5Ajv};snOls_tBc8piLfO
zq}S8@$tT^Cb?Z*!)C#o)wzhgFuELNsVP-2b*)6u!J8}C(j`R2|Nc20YZst6;ZhUR^
zPE?@losaE+6WsE_PyQuc8@&^C!0o#q2O5wk{BcB={MzW9c%T5fIxwW&tLZp8O1cr4
z*d_fM0l$NR>={jG!)>E?f-A+!Pq3xbmhLoqC(i#8yKtJ0$(7-@(K|5`L*E?GwfZr=
zc|$PoOZ@(X2;HP|BY^~6@~A}zEWezK%}{43L1*<-#PhRur`LrN$|c^#L)>^&`-{RX
zQFk<NU%V`Wm&9k5K&=Fx4}VHIHtnl>uB2q8Th{Uj5Ksg`{SHspU(j6CQd(LPFN~D5
z{LoVN!`s+pEpZYSwZvzC81rIf{<4FGS-t~rA2b>L7iBHWm7k;4Fh6K--^wPS;_Jtr
z*m7cVU6(B<mei%Sj072?8Pt!Lu}4Z`k6(l6JI)u6i~2Jg-c7ITa?LxiIwd7D%UV(y
zgTgF?*>L2uWwF96=_~PmcUj9n_{cY2Ri~njQ^S|<$!9f>kyE7D*YT2E_l4MV@y<=p
z*L9B-y*G1aX-Ug{;1Dl*FZMOrkN|04S<`Z(VjT03abB#($Aj|nIe91mXx8u5_h-Cg
z@9%c&`|bAYyY3F^dp8^r3mT5Q-S;&dJK3<$-zuIsAlwB{$ox7WLJMFOP{#2q7Ax`x
z$~LxbDVdHrC6nA#l)fNi=ROHPvCQOOd_jO$*H3;cbE3JdXG<e81rMed_MCSKSk;|v
z<CFI^HFyLWzn`7HZCWOHKYer~Qc;Ud1Npk|((2WG-bm~3P`2nGoIOrf+kpehQS~k{
zbscD0c{V=UO1;PFb$)1i6XgHIT@8R3l~&hi?HpQ&Xl$)wH7Hs(vp9-)sKfK?qE&06
zHMQ09p<NS8r$V2|jINU}kVIE3UdLnIxL#0!ty`_Pf%lWzYC4c=4hHmJJ0Pe3I<4NI
z|GES_h*DQoGGm~D=(5U+3!)A$^$n_Cv+DAwbaODrz(5(Tu8l5PRlOuyS6v-lf;(H)
z^>xweWzp4@tE+L)>a_Lqnh$@6wvEDyPYdEstZ5$$IzMQ*ye=i4AK8{aZ)?*{KxH&O
zkPEUagSezPIH`_R=-~CoY2bHoOQz~Yo%oh}VQ<=((R3L)x^2z$9e<Q;Rl|zUscF9B
z4OnA4pTysTO~1ikvWPV|5_`u4{M~X@PbZ`4D~t?`*-ja$xsmv_T&JNybdNXF*Qjm3
zgFU11d34DIF^P)rCDUgA56yl<tmzQoZJBxdwjNHZ=DS5klLH^S{fx##4B=6dF=?0j
z@fpRjxAy-%ygO*ly0bZ}d+d(;;g-=D0eyV0q}ve0KHLAd@a|}H*29uwHz?{N@k!~i
zCxAz|&AuCJ`W>)aPTZJr{TT>?F*w<;X)-co+4fQ_XFltWtp`YyTr65|#CHhaqmcP5
z>4`4B7j{abj<XpbX=y(OII}m-k>Pu&59FWy746o(j`JA4kANd>XTXhEQjLUpE|xn>
z@ipRm0pG8?U_8fHhVLUt;4;zCKaB5Xe4l6Fcohb~U*nsBrSsMJ7@xnx90l56<J*I!
z(OdZDWBEfKKY;l;zOfi@Z^QQ(zJKGJi>bzDeB^Z}%rJQKdmbOt$+T?&`~berT~Ghz
zpMkI;b4mX08|pZ1zt3`TUK$ni#yo@p`pwyn^9jbo-7r7LN1e*o;`<sO!_EQyO~^ZH
zh5k7{3dx_tmoiYLZ6VA*<C}Iar0ej19VAaKOy+GIxX1AkW;tcUjpabT6@Zr_&Lt2>
ztjEW^y%*-6@sa*xZ4&-J{W_zLY{vHxzUT4%8Tpo|tL1)tQtrW`!$^a3u;@h^@vQA}
z3>O)V6EN;$6e($$Le&ySJd7-pGnytM4qLFrm(fJsyIVH*K+CDghquB^jM%Z+FGBA~
ze5b7AwdqY?WHkL39cRB7FFJe;RF<5)I^+7kk8zyZ)Q02VWnBL{z=nP9fx;ec!}Ct8
zFf&#bQQSv^`+>sl_<A`93+Kz2fioEGWusVja1w^`SW0Y;AHRc*wJ;_P)knyN-<a}^
zY>>^nK4-FI=W$?SPj?P9usrOc_WglUgO<y_lw<GFq3C%qR_qQk8gG;Iraey#;#U{P
z_V0fu+?;-m`&F!&P4(z9Fz2wP(>hHmU>P68rxeE?-~Vp7IdZN0$I{qN#<e9t5b-+*
zs+{K>#N`}hTi2sK!Dn}7Mq^h-_6`|lVe3BNUIzE&*C$WP@t3s!geBfAX%__Xg7o+$
ziTJ%5YnC1kfJVkorkh$qe)St9tNi3)gv);QfeTRNvfE^rdo<P1&t^*gKtagC@pUv-
zrnXG_f_an<9b)K6L(I;SmZ1`dISc7yo9oK{Kt3&53Qf&5$Cc(98Bx$2aL<g-%Pea-
z@o$q4h{=|{?AhJeL_eeHTQrfe&L3|dopI9*XlbgTRsO00fQ5dy6Ca-$n-qzU_qWdI
z6`RzpRq-GFhMByV-R&2sAQ_Es147tyS{e~5!aMpL2~^&puP*T8Yco}WWnCMeRO~*1
ziQ4W?8BISq2NBrW2x3gH%33BW-)t5)(4{D7zKz*%^u7eUnPk`Wd`9CUbPw@6INCH1
z%isTZ588S5yo=!xQ>u){$)k*;8VO<x9zqsg^8~puBa0r1E%;6R>P$64&MA#Y@=90a
zqq>%~?EjoekXqF;8nYR&97UP6`6X_1(L?dQ3>2lb0?eH9IW0G79|s$bBQKsBDT63)
z*$A{64v`}bCsPiLFF`AQ4K;At_NJ2=O#?ZZOm0<2?_=#$ty(re<i2i!`(r8lzv>m6
z;UBFdjf_G3`g;*RE7^lGmZqjo_Tz=Q@vN;)uV*w)By}3qB4sqaiPGM3Vp&GxU8AXL
z=Z*66l9??pd?pJlb}(M_hVB5i7G^<_PNwd@CI*vZO>Fw?CXP~noNhn$LA=b5Pt1)^
zO^;ty9FJ^|9ol~++?=)5{d&tLgxAQ8cjQ`GOSKB)=x^DeRO5qZ_=Nwg?TE>oIVJI-
z<t>vyCnJLVLL`#<B-V(hnO!P##s@&$_!}T}+>YL#aBODjAY5c#d|uG(=kGt_xv#`a
z{L+@cf2tGPaJ&)<kYxU=zQ82%Xcxv&&P6!KD)Hk5xp9AcJd-u<EA*^eHZm*!1*mz!
z;gXWF(v}^DDNEw!PN;W}%05VTqstCXWCt3KmHS8cz>{thsKFrakIpw<9~`_+9zsP~
z9=#PLjCwPh*36a>l65+kTtz{{zPTkW{Z&{E$5Sw4BfI*b`A*qF8fZgPTUarA;fm%$
zH#Vsvqq!cVW_;4B=Ex<g#(;IRe>grPJ3eP%4Ao>>5X+43VCb=uAU<<$tRy`?bAGHO
zGd^=stRxaUBm;fu6PasAPe7T|96hm;nH=AcSsq{Lm(6Tx)+8^3MAe%z)oS9?GiS!j
zeJq_;YLZ7tVk?2FLBqDkd$P9P1~*w9;(K=^1E9n!KB*h}jT60)1v4U8<n@zWqOpUh
zp<Uv$-)MTizJsh|X^MU9;K7M<6gzr5YyP9m$Hyqz{$gSlx`o-8dMMt%K~LeJ^8&Iz
zk+NcKxnOKY<8YM9wjXtSdpZu7{*9B}cr(lMi-N5DjHVXMUmCs^8I9M|lPu`i+xt)U
ziuH_Lg|^DVKKeWca-G7R3_o6&zWs~w2&rk-FdY79czi<BzN<fuNw=f-k=XR4AlXT~
zspY12Zy^$6keZpxPHYaAt1VrR>H2*1epcJPvM$dK;>~QY&`uV+s3tbPE<P!UjlUv3
zi7FZ+(0f)AJFEwnm;NRFv&PL1N?Q&pYYhEZD5G%~d*J$@;i@{f`^koXR7^U0Ba05v
zFhfmzrs`?7m$lqrys}>3h{@s>%!V?Wz8pvh%Y()`ObFwJBjaUb^yEc$aB^m$y11i1
z<nXPMfR={|2U;E`Nu$wKHeOA)M>*ntF|kLG(X?NdqfBmD{<cZpR)K0$5^o|!ye3i}
zpWF?V<;#zC_QVVGn@%3U>Z9oqo4s2u7?9C;KcqtF`0`^#Z?H${#$eQ_RbYDr4@l;a
zTwRp4+zqCt5y;X-?y`ouZpWEEhrSmuG^^&e<?1Y_u3f{`i`<MG_Y$khHMxUYYdWZ7
z@wt9kOOc8(Gw}wF@a#SF7$Da52f_ScLophwoJs6KVK7><8kM%BfoiU*+H+dI`v_i|
z*o0K9;WM5Iopz%N{fwJ9qqrg%)j6Z#9L7mDkyuwu4UTrFy-nYT5`Y9Gqw!k|&2r38
z#lWUH-Jcl`11N2|k>SY+5n~yRyQmql!T>qjv@ceco^eZIcWAsb6U>ap?^p_V$l@!s
z`FxZ}R9+Oma=NyKjZZE-$H#8DrV+OM*fkQF@Kwoa4thuA#G{ho#$sI!us~d&S<>?9
zhagZDgDrzKgxQhr$C|b>gU08^Q{!2;#hP!SEiKl(9cI(h8I5V+96JWa9M$}Xn*9{i
ztayI6*rQuOQ66i02u91zWWSf79zD-FI4>scmo{JdM*LB_%!%#24MyzC_)dC7cM)%5
zC@Y;g<>(npz=9JF^l2GQrRhlXm2aTZZ#{^{6MvLG<IVIJ-$`cWoGA5>UNV)JUi6|W
z@M_lQwiS3h=OL<C(Rj`5K&?KGqd(hn;&O~_gBcieM~%lQ--)*CU5^%(HnZiYAIR~!
zZ~|hB_LLt+gIdb`pZx~MYSk*5p4S<Xaf^~pZ978-um~YBfsbI2KP8I0h-@=;_YngK
z*?b5(C{aARS$b?_Ml`YE?OBQn(eec1q=w6QL6#J<K~&JRtRGTiDi}g-d=Qf|)0++<
zqrI}Sphhh8OZNXwl&~I*={Bdd<?(;Q6?L#6m+j5(hCrO7Co%47ezFgyGRUifGCjFC
zzU4$-#x0ahg0^{9sVHrp{YEKrdS*)<xPgx<sPkD6MQ^AXx9l`p^?wXQ*5T$WUpZLx
z3ImQ`ni(HjQZlFPWO+Bs<{0B&^h(3iCu7}oxgwW}f|m1<7c#M|1+!m?mCTBFig${Y
z%sqM`dGD3IqZ*PXWyLSbO8tKr`x5x7iYxAW@7$N%kdVA24_OQl7FjevA}C}J342(w
zKoW3)kX=F&vp_(Bz{?XZ&nQu_T4ix*wN|YgYFQM)CSYwvrGScx3i@8PR>cCMZNC3G
zGcUpR`+mO<eo5|}nK`qaedgXd{Dj_kn_P^9cQ;QKn+~2o2*>Ah7;aK<ly^?uWNK}@
zN5Smt^wi-u^$I~*y}Z*ywje&fua=o~sqLu-tZhI24!}D-ajKf_Av87<nawIs4tMj-
z!u@$ggr|}gO{qc>^3y5JoO?cl(km#<A~Z)zE$?<7(P}5@!d`w1QEDc5e39<IXSG~1
zBknklU<=}_uloke^=r9JXc3#n!xW~O8VRf6e~2-PfZK^a@}$Ov)1BkJ%`7bN{l>@3
z>HjAbuaf3m(3|J<-eB3=n9a8nn|gamN#dP3frQC6Qh$;Mn_yOkd0BdR*ADm2o$WcW
z_G<fR!g;oyw;)VKVdMNk-mDnkpD-vp=H+SbLsJr2l&t%LB^|X>;OmRtv@JO5ZDSe1
z&E^&6=XzO$b>&WQztIooG<Ql`V-Pl<f5{^t|D&0ij`^U$L=2&|f&h}f*?6@J;_PXo
z{00q{)r5DN85$Jf`3}lnG0^mG@qLPbkS{z)>1atUnD5PT=0V=(6#B|#<94V2XC_Eu
zWA{4H(49L_JL0aZi14J6%<M+&CdB`xmCP+288LbX&VKnzxif5Wb4{`)Eb?BZ=zw-E
z4D+W`AxZg}m+d0J-nt4o?$4Z3guH%9By@!wl=7wA&W-VMm~&4th~BplotIpJl{x<g
z2y!Jvnw%K->CemUX)%7X&m{?ar~k5@{iNAH19OG*7<uHUzbm&hWBhDUu*DA%_C)Up
zPdk<UIt=#z7kGe4(LyEw+aJVw5uQ3(Am7(V6<ACK0+tzhf3VDAwn(=xi}JGO!#N<*
z(Y)~;8+9@wy!rF<x(bGq!)2in2=o?$!&bY4bU|Pl{10@?C8}QlXV0>aBK!(+wf8q;
z1tAJFX7M&SN|2~|v-P7nwugw)*LW6<2c#*~tTZMTf|G$P-?sqS-EyrE5m)bcd-v_A
z$X#z;glKB#)H5V=Iz6NU>B*ZtgSKGWh|7qFOJID+c*e$kG03JK%umd}F`{)k0)5`w
zO6~om=*f)i&t@Z~q++(Smb6WH88c(=CVgx-RC=e+x3g~aa$|%%9ZQ_>uHCuW`6|tg
zz2LO_5@Kr)Qs9J@GBNi_%vYPMuYSSa#zq9|X)>C&Lii*cNH}kAzY*xan%@@V;Sn%{
zdZ(TSX0yMS?GXLY=Dx2`6TojrM{Im=2v3pTndgf?gZ`r7H=O!GbYPnOt&{~3cZ>!8
z<o(oU{bSzkG=xsmO)Y%&!R6YD)=dikEVC^p!#mA-{c};MAMzdl9GE$W?kkon9+B(K
zv@&wwo9FpnqI{OAY<+qsli%IC0JA(JqV-ww5123A%_fL)G;tDI;%G^ZZ#C)??M4yn
z?Pe*n29_N&D#t^~t<IV4osnZlyASGiwrS_gcE6+9GjinSp?@=}c1TMpVJXmHdc!t(
z6G&9mAW!Ps4jkRIdB)wB(z~^=cVUK`tuRMG4}~1u6y35a7ADK9hy#1Kk?J^~NqXf0
zP?<7)ZaM{*UYb7JiGBmV=UP{xH^FWz0;s^Z3ww~tUh^_2!t)Tk$&ShWHSgq%j>(9m
zPG%nz9*62gV{iG;7~vTbi`H&B1$TGT07S4lr=Fq(^KU1!V?R%m403imK;!d$W4T3T
zMZ}}6mfMDaPd~uv#kMuL_!*ihR2IQK(C#(Iw1~T(LlFA*u=STX(6{kXr0fN!yu8!l
zz7%Wc^o!W|_%QT@ecSTRj2NfkJ}}&#jJPnNuE3n+<lUkb_@4h%v8b%vkug~Jr?Gz#
zSW~&UuqzkOmLVW>lXous8ey}Y#;}%4x3-y^7)BHj(Mp>i%5LN6Z9czfotx*&M0;`~
zKs_z#2oi1}&CWfC9RPp59%&F-j<2um8qws<RAzzI_G=D?te_Nk3pO|T0hV_jSl|F!
zZZl^h9weq)-eyzU=?U2SK{R>*cuA6TOS1r#%)vU@ACOsf8qL^;;5_djrIRNa0s)E1
zP8k72OoU_+0)cm&4z$bk(Xv**6w&$;5VvIw?aZ1&3vFj*xVzw89|Y9h1%1!~Zt`?B
z-9)T|7+4liVBk-D+ceES=>9C&eF-~YH6WBtNa@%P+jd}6e(a{KA+7H=Vo0<GE$j44
zjs03N3q>#p0%M@2XCVDrC|Z?F+0u-=#~mDxM{9+?6Q599zl=8@VwltK<tZdJB_k)#
z5|c>!oE}Cq{xzw?|8_M_u#RNH0OQKwj=4p~%=S`V#{9fIkSx5>sKT7Cym(1}&_TSu
z*muC#i5g-2Pd#eucCP7vhd6`H5AKPl0eH~;0$)GX)un`365%w8tF`_E8$J-~9UDns
z=>E*^{LP?+X;$lpn_iFD#*!<-a|WAQ(&pJ*5Hsn$2+wCw8n4iClNKJW))@ZE45V6*
zG&){+3=a?w6prICyb7b-{V}hZzp#7yX)!Y_=_0n79uxh@@m0!V><hHc!_2BqLvKT?
zX3w^dvZuKP@iN|(WC0X_v4mqVtx3WG&%0~m<g6ro2z!wyBp40Y=FTj42Rt-qA{&J3
z&Pr1g1v<@*=!XXXPHI2IOQ;DY_hm$nu2(N8+?**c51o=D^ZSpezucum@L^amjt=Ty
zfRKkP5QErAWu~4&+gJrp7`E6XheIUl1>WuCx)mT;xCF)Ql;OT2{6$&+BV;46s5lS)
zityY+Mgj5nM8d~b8;W_2&`h&4lcuuU=dcZb8C90X)2(F0+Vcspok_4KN{~)KP~;sH
zJ!s46^0wa5f~OhweFTv4ZT|p9rHGeS5Ze}OCt;-6XS#92KKrD8F~|4lDeg24aIQ<!
zaw`dsw_uVaVEw)P9AAqp;(wF$wqhBYk=8#FK+bb+DcJ{40Fa-b<DFTV+x0F@#jmIY
zcRt|=`nx$>c=IirWi<H;QhUN<_^@%*FFb}Va1x};FwNIa(@OpV3EFjEbjyREB3eU;
zF%-`_ZO;}8fMfJ@nZ4XefhqSa5<1MSC-4_T!_$lE$=?1Lo;p3JR9ec(3(?pmZQDjT
zAPA|=!n`g-kXhPdOfBo^bii@!+al<JLXe}QB*_&Nco&(NubdBQT6o^M1S;8+ogI_)
zAH8kV7ECP9^N^AWU2VI!BJK4MCE*}afv*o$<@s8ODC-S!ty~+xpWckw1^U6j*5E%r
zpy(LSNP+J(5@>@~qzU%3{|<`T|Bvx3E!C}1oM4#TTpW&i0`&sh6BO_89O#a8WDUT6
zMMUcepbJQ%ZvQ2cfZJ$zIBj*4MZA@#L<5-Kd)si#$p83%m#ydP7~^IBpIlGxj4-%W
z_F;S51k4EJ23D>JPqcD5_$ycLM)d^MOGfy@+1Ll!PFm3Rv>?mgJ{!LgE1hi5=-26K
z?XI^;J+-VBSi8}@r$H(%r_Dpn6&65ryTH(RriuJ8!t)QrNoaji2t>m9w)Z*DAKk-L
zm|__)hT)fM**P=(Pju^gb!=q1>75mbh#rQ|NNeOqp}airN~-|-9}=sIP!GoThWjFP
z_cLG{D*9Xe^*a$5-J<9TERTKLwQ92%dynYAw0Qj|VkYz=T6!tUY|oev?+ENbcC<HZ
zij>}P&WEl)v<dSGGrot(;)sTNoN~-AM%}TV9jihw`zDeubG;t+3G%U@M$!{@!`k^^
z6l$caFqZ8Ekn3gMS2N2^DoduV|6Q`d7g!w|2)9w72DXh>k@k7LGffyxy-y-VG2#w4
z`*2tl{{vJJb1ofv>HTGudh@Gi*jc5BT(!j<^g_ItaPhra7Ww)cc_-*1Z~E*#f!bMN
z#Ea955CE~K--vU6_VgwGb5OfVtbwManL0sj;E+WjgV5)vlWF}Qu#X~G-p@zmBhS0-
z3H1FI4d(;W1hO-`!;F(%Ir+X!G_3Y;IGF5z2bL`{G_#PB>@#M=Ns-(>VS_h6OsdWa
z32m+|Z7GrD0>W27L=U}-+2jqjx4lTy#TewW;!IqoK=i8*@x^)?H$uzwM`jp}kxEbp
z1Baa(XHOnQhcHk+-{lQXEHrNqUFS&7a@LzTRDnRH3Oz!5Meyba$-G`z$b@$hDQGmj
zSIBh(_Q^t$hx@dZlZO~9=)vXPP5mn@z~+oMI?tDWoOlNT;r}|B0TTDf+2_@NnW&PS
zq2iA*I2j?CfpeM>tvLihh>|5^n=1o5Ky9w0bPiDDyHA_>*dq6CrzZO!$oI0D;6D8m
z0!IVf2l_%C-Q5brxn0N62fu?*vCQyh-AFtZLX!C1uR>wpP;zS+w#k~OJlgyF{Y_uD
zyuu8y^7Hl0bwJUA!zN#yki9^(k`^)F^tEGjR5Jtg*_Ja@266`Jc1}h|Ml51FLp1-E
zkI<;p2&jW?l_OogMW{wrctmS3DpIYsj5sMaAe}1*!7!-Ay%E|iI_*gOd`wLtRrneQ
zpjvQ33$CETnrp#=w)1EB8_C>;s^^)KI-DpI<df^ocOqW)0uXuGL)pw{>o6yqG6(y=
zfsU6<04*j}`eG++n^tZYo|=CEFms4n#*n0e<8%FurjtxKZ+=YRFl!jPh-o~35T^&)
zi2L_TWyr<mg<(av9g<s-3Fk$>=sNQ&<D--A&oUxBPZEEzg=7z~>#+fuNgI&4)H$9$
zbZ((3`-jeb`5sLQb#4vu>27XinhEO@v$V-1OIZ3yb53Q-&~|=qo_C(5ALiZjCs3XB
zpPUbz)%kHSp)>4RftIf#yljnOyA;gONxF+7S=Fd3$Bi29@m&`X(0`JYw;U?AD%s2e
zGh@ML%+AZx|B4MuX!!AgKJ&4Tc^EINmlz4A)qM^W>OY7xb4t?fc#PNrI_duIH3Izy
zg8$c1qf(S)Qloz#3`a^JLM)>RYTEL;&0p{bGh23G79M$5O``iELZK6gJ$NE1Y5<4u
zR){qJ(-bn}sr3Ged-E=&0rf^U43UGg36~#Xk|&t3NsKkkhgm5tJsAhdQM>=Jlt#$5
z`Se0HG*Dm(yGK_@KyD;I-#ZI5EJ+gwrg8&n^(cj6eW%_DkU~B2n(UV<jKeyC!rv+#
zeB22$Xu+xcyj%1f->yJi%)Y0D<`W*pb|R+4EGXmmprdKu7+iH1dE>dhT2zqJQM9OX
zC?=@TcO!w|AMzyGcTl-DGtWEc6r6MKVoN^>GQpA7M5{3jCxZ%oak5Q9%JHSwB2gp9
z*GGc=AMv=EU!<PNjPWi+05;?UIL#5Bk1aYi4Wo#|wmBel96o9tN(9f!$eStUH)oTy
zpzM2@A4pe8-t{i-=dJ6fpR+%}Zm;_iVk~oj7BQBeWQ-*pskSVmTO{TARvwj;+(Be|
zGsVHUb2;8s{R+J^UAYCm1t=l)rTwk9u%C`IeKZJ)#?9)N>s{?C%<(0lOous0>zINM
z1<<ryb{ydX_mPZlDV^-a{V4vuRO_4`iwV*;O&@Hpbon#LJdm8mv<kBT{sold3a5Q^
zvzIoMDVn=`6A;P3>Sdu^Zy~JJ7Rq5?bjp@}LMGW|kJvC9lGnSP3UspRMD2F6(IcP8
zl95jjsi&`Ev8^w+K=q5#-XdFyy_<*)!wDb9L}3^wBLuUbaF4#^<?g+H$&dn-dSi}0
zN^--}`HxdSdf{ZmtF9m%fq&|41TL}$T8+`(hJK#&Yr{Y}`Mxjy$_pYlQu)N$F+l7N
z+Z^tD6Hg26PWuw=<+EcPxs5tpl<;m|f$u5gdO5nQA0(N_kJLbfC!q`a46H~NT_D(a
z;pC7G8B_KTMK&23%pi(kC(m~uFc3#~AJ*;3^P#Dw^n-mm8E4}>UG@VPF=K0oCXn!)
zj`$y1S35#4U|^Um^dWJrweB<>`Qg)98QzsS_Vl`G_R5^sN>SPWDH(8bwNXY!T(OzY
z+~eKCrUPDVfXu=yN5RX)F)n*sCB|U4RpU3$*Gqrl`I5VruOR40{Fhwl+Yx}1@uQp|
z9LUL5;-+0;PY%c@YGW*P(Qd+wKh#VC-Xl>5wA#!=-uQxBLc9;OqUZVK3dc%&=6r^Q
zfZy9hzOd;wlYutb=0E;D1eDw>-G65Jkdse<-%o&qsH>cv=lkbdD9Rg)_MsyCc%koO
z1{|hgVl8<qZgWJ-kJ;EEfbebkadt%OmvC!aew>A4XL#7m2EF~geKO+dqwifh|9Whr
z1N3)ku<fY>5_?-CeoL(=W%x99nTRjFZB)X$ol4l@_RWDqLQj)jAv?bN2`aHL#ydC0
zJ{)q=?pP0x5ufAhz-TqNz9IOu$ouY3VH|jHlvZso@#&71OY^)D*unP3Bbph}x&@t&
z*tiX{y5-W`h}LE#?UNygBU)>L!u=DXt{u>y`4lcb^=CQu4*SIA{r(*Wt3q-K_A2ys
zGT9S488zh8{T8(r7kPuc*$`e`2;Q@9v^$FyVFT8dDE&i-@UU8}P3+7{X-VLOUww5!
zuCD~8$Xg=++n!t<;aLoIQNE?^0a5|}{ZQ-wzfvR@+HEV%>Yrc#X)vst5W>8jAo?Nj
z@drh;KAg6XQ~&&L@{kid*Mv)-ECY;x==J{$_HHBAmBBFk9edj(q+r@y<DmyH3jw<=
z1<zM*qu<hJ)aCvF=SJ=(LE+v{zp((<BTBfQPkczlFal|nxiYM6&9iRKi(N5PZQQai
zS6B!)Zkp_(j1Z1N1U9E2zt9&Cs9Y4H)<cQB@3gYn%jZzk`%T><t-z-<lCXq#5eCf5
zX)_1s_`W&9L)Q<<pisj*Dw4OGW=rCcQ9^_S2{ig-fvmWjDt1iK50Sj#@JYjQ<!R(7
zr>kerPrgTi7#@t6HHbRPK6`nh)cEa%*mu|vMAR4?v2hh1>^E_u)_rieor~jr2(o0M
zMH#3;lXRfYX-H?;)72QG0${ve_B-Y4vtu-ij>Se}_efUin1=0%Tv!FOBJNrYPYi|#
zeRNUloOU}_LG!;z78Dr~`!Gyc`uZ(hu&e%hnC7RScRvM|BqH$0D-5MLktc@i3{+zk
zmG9fplT$>7E&B(`waAQdpMEW@g?4sZR_Wlm$BCy{`gdgM3cGij3#ahugiV$y_b%^x
z2x^`zJ&q~EH+~3qQqF6TBbslVY|ei{^@0t6Twgy0UP?v;_YAwknEUA7Xpk3+=1<rB
zliA83Ggh8O3j<|sE{tg<s}zr~Ovco3e0vg6>epc$+eR0@MY6j~mGsG9#6LS}s$%`i
z&=)1%3x2k@o&FDu@PB>P4V(5ej#m-v5VS_;G)N*^0|be%1|NUhQ>@!^-44Bm0E0Tx
z5p6r&bHkkehbV@TIp4c~3OfHs7&{2ic;gceocq0`!rZpDQ?z8#)<(pA{|`v!z;c>T
zyVB@@t`&9_z)z%=U3hcb?lbtCXLlC(KIj0T2y)>aJlHYAeMj(@#S&~aP>H`5wIyP8
zzI>kLouA-3pScJs=^JQde;elD2~7CiaNcArUY!6vO4b6-zacQeZ)*6%NhWfL8`EnS
zx$=ECptXRp2RhG$&1Prz>&%ShDSE>Pg+KKa$2b$H<N}JStKGaiuA?y5Q5yG6R%cct
zw#_yF_n1HIC6dZW=<?@a0Meo98otemR}lV{f_HaP@%}7+=*18xxtXvF*3D164LjwF
z!^uOYjlY*L7CKY1|8|<l9GKqE{Rs_WGiK@;bfIS(o?U0@a@ib0pab0n6A&dsS&aI^
zS5>Hm9Uc31o861`pQ3MFA@4-A(r#(noTCMZcUZnWpa)`<Mb$%g(=m9u5To`@NA2%J
zK8WzFL*eK3gahubl8C#XLO(&at&ia^pZ<l537rVpaBthxqnIur)Fnc9m$~*y?@dR&
zO~=04jae`B`QG4`{7=ATiFoxxWk!CWJoD8wO!-zDK#yVcz6yZ+x1cnt=lFi7s;`m&
zxp;ZLdjM7kFF)Eo1Jw$B>j07*kAZ#UA>d|_GB2Wa7F2V@#sYLc1^PJ)srUEOn-b+-
z5B+&Dtlajzg@^Z_rr)3Jr!{{6X?~Yt`!PIw+Xy0c`rTM+*6AO?75d)_h~{{hM7B{y
z1Ty}9h(~WT)Mn@>Pg9AHPJeQ`<;>KUA3(`zKq_UU6yxjAMJe6fUsxY4vWQSE4d>rU
z*MA+B=i4f=`adS+%gfxd8at2Jq|AzSf2$+P;y*-L@`w@(ZY+DA??%-ddhLL`BNs6U
z*GFJ4;H#ei8xg<oCVQT5l&mB7-2Jl<UqQ_s@{pl_5IjI6)f=(?2$|feay6M$N7ek_
zk&DVIz;1TYc4Lm#nGp-})ckiNdJHl=?mncuk24iE9c!C|V*ye@B0^Vy9l+^cE7y1b
zL7LH6w7T`6|0bHrlV4f*F+Vzq@C>vC%iscE9hY<Z_dqe{=0c$_2EZE)+VBtf7)-|7
z?AfvqVl!JYFgYumN=b`y*civXz5V4x<ogB(%6bsbDni2%o-042a4`-b(2@9v)_G(y
z>?Z^Fvd~8o0r@1#c|Nd%_5K=R6Low?*An?8NyLV9a=@C-BsQIn*f^e^`IL`zaN1n^
zX`1xo-XL1G=U`Y$|BQ~;yiHumo*?!a*vRp2--JHo7J4T{BYI!)Iy%6|(E_nFCt_);
zGw{^dQt)QQw4C{m`|uKag_~xPE9CjEMrBMHCg=dH_ij;#bH%!U(-*Y4lJKs78d(oG
z{?stRd)o|1EO}N}c_?zbztcmKjo12BaI!jok#NAD_)n%bWev`qpWBr;3JuaQmqQ#w
zo(JgiW+c%wx!Y0T+j4+<76xG~kG)}oINx_0fUqZ^Luj4-=pa1&1s2?F8dKhExt2Ir
z%x9&ZK$m<os0!Qlr~;Fom)74*A+?*V!b0y0<o-yL8)|C+x9aroC0`6ESp^pQgaXeY
z;{afGF>-xhzXnP2&HG0_@H4Yh1Cm?8^@?X&l0XncPovtmI!7;2J=gaFD$)po$?qg7
z`iKOC91Ya-ACPQX;M>@frQ(%s=9O(R{rt8p;mw|q>syLKl9#+3mAA7d+4(7mpnK&J
z*Zg>>)Yf$frofK!7Pwm8((U{Sbh?g?kpEXi-2WY|4BI~PZ9o44*eCSq0`F~cg}(Ez
za_6Q0dI_eE;)#_`3Y)ipcxi9%76Yf9;_`flFDu=84XnnFtXN#B;6F?iGhA4`a#%*2
zGm4TnP{bs{{g;orx;F8%{~#Xm(ui+v;H43Nhg=uAWm(``#>oGRND2V-?x#IYn&RP~
zBgF?D!0kD{MA;p`8~PtJ5BVnnM35#suw=u6;VI$+0X99Bh#K$g`4bUpM2#HZ`TY`e
z{SOMoSp|5AEVT@1bJ~&RYP<>TKaagO#6mB8;QyWmUEqYPX6H|7%XHw}3Xb(>U|*Hr
zGtV^r*I~#YOz-YD&<(qxE?|jNVg>lniGMoTibOLtvRSzf34r>)Jj+=HzI@dq3US!G
zOMyy-ai#6BeF-6lWx*zfT`<8v7fKmOrJ)#*h`oVDt}P~##5bbWo+AO_7zGo-o(vab
z6p2VWjo=>(EI2W<=^(P)pCM{F5C9dU>0xw>fXqQ3O}73Ys`|kH>R#`5*1Wq(^V<Au
z^Rv{q?;rW-(@#!+^#1ubrZxphHKSar3_e&h1SI``tEE_%^>o*lm;}~P{vYrt4RQHK
z5e~Qn<kU>qA@U4pI-c5^@V;6>*LdIQy{N&{OH|iDq?9!Ur}=gNPhfI>C)Ix^jeN~M
z|9C9cp0{Cw`JW*(6k(z!%YFwh>3UbpZVPMIzmta(<jYY-;F-$~w-a5emxukYLU*@Z
z%E1vOco8j^aw9xTA#UvtLf(vMedi*czHi$II&29!*c5Ib9&$3HDfo}zF)iUk4p)pp
zmuY1YuJF$$Ii0RW+;IzV`u_s|i=t5eIHZU*=Hu`GSQ6;~f@t!6XZA26|EcduWB8X!
zsg~z^3vd~oMKggn3H<*eCg5``k_rmw_{zf)1-11m^8E#vsx3s39APT-ttV9cOsJ;I
z$TFX&x~$NRsvqg37%ob?Qyw$^o~loeaUXX2|3;e}#Q9@Y>EFSblBXYJ&=>}9p)XQq
zQh(-9e|%Un?hkJ><@>(-qa5<0bEwRR@5#@)ViR5qNTrQN3hexa%lwygdPP<AqL1F}
zQg1`0-A3wM1vbxK0C>N&F=$tp{7alJg+#^a(j2^fhIc9~@9q6e@INrgog;Q#?G8j;
zFgY^3gi~HPxdR)fpIX6t$V_0w1zjtFg+rF2$jbMPP(7+6TY$7v9|gDwo@twU#@j}^
zo!@Ky=@lOJW&X+=n9U(4hkSo|%+5dkYshUG-8*T2AMu-m@0~u6=pF*H2?u^ra1aX0
zjoXm#L*ADWKbvEFet|5q4{0j$y-laQ&CbF~5~{c0)KhjG_CL@U;+swxBB1DIkT)0m
z8zfu11uB@(eSqYwzx7A<{_s|8u5Y{?2h5%u$g7xo>cUC9tmdD4gl8bn7cKMs)6fa~
z5(1Qe=!p2kJ2)u(t@OGsd@38YPuLy$+x`e12K5xdiHq>A&ZEzjE$D35t<EksHGKzO
z=Be|SAP=jlUe0||LZu9U3g)_d%_$ALB;aR!*?@Reec8ZY3JtISHS!bxBhWIV|Jwf(
z{{y6MvX;Og^JZ1c%>@5-a8Z|?pF**~ufxQxvkQDP&;kP0#5F<cBL=M_NL=uD5WYkU
z$qSC%9*uqXsYmO>@I3?imH|7P%F!$^?I8aJXvwyzr$GeJ|1SaKg41>faQbJXK{VCo
zIRl-S<NE-41pc?wja>=8!xBQ%yITU=GL0PHa|)a_fmrNU*uc%}YKZSzfsY{FNBHw6
zz~Tg^4%5(NqGJla$mE}Mfmr1-jRvoJ&M{kRw1R*}n@d<dt4Ouee0pl}^cn&<nt#S|
z?r&Ga{H_9Jh<a8c*I$fq4hE9%>#KU!37gs908y3#0s9G-A_emGk?*9%CzTC3ct2<0
zr~rh($3OZlh(8%$kp4_pf;tJqHmC2^-847+Mp{6J?!maZhg&E2w-;LWtzrHMFce;b
zF2vhOy!qkV$ko&_Wg8XfI}%fmCT}CD0jC6NM4mS1*Pi@O?#EQ-!JFbZoZi(C=bH))
zu)1`+6DMZrsO%fDkkZr1D1{&BAzvrg7b~0ba?<Ywvnc(!z*?4JP2u+sdSa1{wDptY
z`|3p+lG;2Y!GjeVO&vg->rN1vf0UZ;Tb;hwWLf5^#094!+=JzeE7GBJ6hp{s>*7}x
zd|SA<dVen;E9BjO@jo>9)BZ28C^D`>2P1NFFy}d{)*{uR1!t&<4S&Ou+uh7zqh4N~
z<VUQHT$NF%;Wx2zA0P2gM-1&_zdwWiyzWoLANNIw(06`Dk^Pt@L_=^Y0?Pi}3%m?8
z^zKiCw6>r#m-CPRIp|lMu~LUjsV^G(NfO=nJP@F^d|MJHhlmOCP~SWCjQ?3_*SC4L
zV!S!Njno#uOrk#9@D0#*W>ph9|4S$<rHPt=g%Yv<63rEB4=hwi<{-VR>10;{eaFkc
ziPZkrVKT0g;~Ob!$cPHR_>;`x>Ie^iA7VF&wad((S*XoBZ)~70tm~XCLuH-&q^0mz
zbPL$kINy98rP+x>%N=-`&EG|CI%_<yrx~cJ?1c69Hljk`gD7slE-3=rhmt08yRKJ*
zyB*m94&n+Co<ub3^$=zFKMAbYN~AinuGIbUr1j@mY8&Jwq+X+#sXyyo;Q0|NJK!4x
zKr!vGi2UJrW?%v|a{zc1X=zrK=;x-Qn64(vcm6r*g_B<A_9S35&+2euMyWG^@-6Y#
zD0+zZ#BqKRA0pvU;^Q>ymvBbiMtsx155LN{z~ONkkzinXo0&$gsD{#pVIV?)zmbuK
z1HVnp2#eGq{tR6=G|Gy!;^MSOhr`i_|7mgE|BwlhN!Q!aW<LICx&?&P2Yfou&;fOz
zCM7QWXVO0nO`riZfq(dI82E<V<^S|Z{VFRuR9IJ9k$RNQcNPuTLPOI4!na<p(1eu~
znjA`3ub9!gutFV3I&>r*y=9(bX7nUPM}m+Hr#zVqjsOyT{+9kw<q%*}*_zf1n8HIt
z1DHY?ad$Fo1mE=1yN^CHY-Thy74Be2#0U(+84W}!2);&AKIKNKPNHSRZo6@XQl3k7
z5`Caf_EDWw$t$}1!G-&(K5~cq^$agGw0CG&DAn(e#w}`mfUe7~T{#3@8;6m`^woJp
zjA>v`v$(#yr%_ECtcvjz#`d&<t;=YMfOCe9#az?Gj|_`tjKdsq{<v?$CtQ}es;4Ne
zAlws-djyKBg)`u6j10v((-$U3q2^`q(W<UvB#1Fk_i9xa^GS8DQ7x-vTu*Z|qkAfi
zxePHTYV24&;j&zO9W#NE#gEm~!vZ6_yne!E9Y+0YyUU?#mzNuVS?5r0f|?2H9Fo^v
zUahBd*IzaSl$xmeszx-aCyDQZU4{^YPwJ(JJQ9<a97w=$2-O$xM5p#trVgYLT+`C!
zeA7x~^dQ8Zd`}{V*!R9!0j4$e>2nvvX2nhzd)?UanvRPU>r2M*$5BhPvZQg#SJ8L*
z8pg@*`;8foQr8npYu_P|LjQ2(IzGx*uL<=DTuuD07+^DyoUI%0>lYzs9CZb_(8Tya
zpNFUpE;V%2;G!erL%o>f2d;-MrsOI8#nF_sf`$_Ak5q105XHTXk5$s?z*ljzYD;m0
z@+S)9BG8=ThGm*@T7mjGit&M2^(9#2Q+*32#TXXj;BOQ*G}hLm`ezC{(6PL@8s7t)
zR*X-{;zs4q6?_n`gKy@~#;zzX(Tp>C40ms^qefl=WSmuv#X9Pylvg*>l}?)Rg>H|c
zwuT4Ircr#UPvoXYIqK@GYU}5gt(5n^7(SH|kJc-yfZwmMO$wsVd>emP$rLnK+gMzk
zC2wajzEbcEhrBY(_*&n?{hH#as=+rQjqmh{oSxyRncCb~R?|>bi@T)1SJmb_iZ6qn
z(;vbff-$TJ3xsdtYQ_)x0j_+bLw-4upjkD*`Y%;~iKBUbeQ^njp4U%s(Nf%mO_0g;
zxS;xiUdc;Z>1fWWujR{cjEnj?E?DiTQ!p<2qbgeGsFUl&&`S#1=xCPEEUXQG^V0Z9
z54oB;+w7>zQy;?QDnF|#w>z2x@SaNl*3UvtieW7}F43;TXC-An|HE~}uvXpCEWtfh
zy7X~qM-1D9JX+JaWo4yA7n+g7@H>A2#}#1EbhmQO7BtdRgF9y!G$CTxR%A`B$MxsJ
zID?&UG3<Ulh}5)U8g*RYA>E;F=^=~`1>L1Pni4c4#BgH@#jwZFG`?e8sTrZhE^hKE
z;3Wt*)>}39EQ(>O<tH@_r$O^3hP{ZQ0Vo%bRK;J>gLY6?q733kF>IgiC{|bZ7=4T{
zq3Ol21E^d8y4Q>=j0En>F_bF6%GZFg`x+B?P$zXqO#s$UVLOF#d`XZoK;b$K2u)Ld
z*{zy!r2_t-JC<H{f0_|vJP5|YDi{o(U$wjp-{91YfeP(bgQN!CI8Dqm$oMUf@qWWm
z3RawruX|zypwgiRvA!5~*a%1|b+e!72qQ|h9M!co75E$|e&J^J?n3IeKhb$DmkRDF
z)dY^Js3|MGym;U$Kyiemone9%8?|85GHGosa~32)$OZfoLyZl9^rB}|3^Vvjp*non
zy0W&kK@-D`_aMh1AGJ^=LKk0lUEl=K$oWCH6Q(Af2a=`D@(bHyg+aFhkvMJU%cjLj
zqdx+u5U7r3c^$QAHl{KpjJUX|rUdMuiB-lD209(h`KxM5G_l&ajR7u4Gksl~zx6F{
zGah1KKSwjot|o3*rDDKAH4vWwtx=#@^r^C}WSRPcc&V(gR`qYVL`#=*;p?)RSZC~G
z%%jkLSqWsbY_LTYk8|KMs1;QuWsrc7GmT~SRSj5kOxJo<A|6xxK87Af)7hH^)i+3n
z(=TML;5DGTlVl!E3g?9rYlaiehtI|@6s3zkWudh0Li}`jp()6Uu*|{uBg@kCNrVbb
zc6Sy{q|71=Xra72>%Q(RdO{Xew#@b21!z`!>T+k1PdAB%6rh6GW&9P-PI}fu>If1g
zP6N`5o@a<?LCRJVi%U@RL@W)f=i%yZd@^11Q83f7yg8@1v68-~3)@>kt)SmSB#6F@
z1Xq*?;l%<?^b-q!(-`K2(5aJG&x`&-ihNMZyt=X)O$-p5xezF2N?A4Cr!Hc|lMDi_
zOfD%Y!`IElKm`J=;N$FcSGDZGAn_&_B`RsEuI}mCVDV4R0GUjwmMz7KUcIP0L?YFY
zuC*{lhKLaiizitAs^#E0F^wS;2%>mpn7D~ylfWy*HKn!7Yq(RxRpTij#p*JAoL^ie
znz>*GNV=)MzO1H^B#|aYh({Sd1xrHLR9WT?=v~+>%#tLERwTn|1;S~{E?Y;+Kyg|S
z%UptlEKd`3S$Rb+Te|aUR%AY9g_B@G{b#%LX>$InexT4%E<~$D)74W5_5X#eNS$Wv
ze{nkj?ag|U=1=A`$IyUKHxAH9o#wG858&BcjXFs)*Mk;WCEZ!~c4yHOvL3)6!!k>2
zoA7~Vq}L)H6%c~*W>X<TUIR3mt`MAJHqVD%cQt9|?Xd|=+OB%dT*GLFS+3Hhnz?ou
zbP{OQwOTXR(R>-hT&^0;Y@xmx!}|3hGt*qZOqzzS##MD?nz=z*ii2Ebkc6gNrUtu+
zk~OoHYzbpntZQ|CCGOADOivoOJzNX<J#dMzkR>Q^1w9v;Z~qC;@cq!n(KT!mYJEJE
zddJNv)77Av?|wCsFj{?%QqFsKbIxp6RfD8v^O)>wj*IOI&HS4*F6Z~mO(|WJ*F<7-
zF^@p(?M=P3%&+h}Qon%TQgnpejV45iQ^1q#MbBX(I5HiHpedALMV^A9XWKlltXvZz
zk+Nx%%@olqQqG{Ig<!~<D0OBN9(s-wd!6YRr=tcU9i8F(Ud4W=tgn%-?*SijzRAs)
zjvBsxFmshA-cUs?M{zgou=6OF3%k7ff(E(-QvB6<ob#NHs?z4UO<?i26$TeUaMgt-
zjyh$3`@x7WE1h3Et-h>mrpkLqm5y=n9kiLNsDn+*VdIH+RaUG6(^|D0`mr>twgG0r
zdrnDOSnAtJFqS#9G2~wKY>K{-l}M1bfryMuVzPsjeu&cL&PFOo&pBeb^Ab*BNSR!t
znj!^`kC2m?taWB^U1)H0sRqhW6ZHxPC7y{s$xB5=le3shLXl6YYA6X5Ug2EHU}w-b
z)b>i1>=w<<&K;Z&(X0gFD(8y~fn<hSfO3WUcmAD0kj!)80728MG7!mAYe5=oR2q^P
zW*jag(ZpJ(lN||2V(H(Ab<S%T0y!)VY)!N{=>m3R7zA-<Sw$79tydj{7?!5T1_gis
zR?eGnD-a}bz`WN)s{&4;Zr7BOec4EUj_^1i;WlQF5hOK=?cC3x*-FxqSP17|J^Ft%
z!N`UUzXiep+>^(@#{m*X;?6Q@RV|a)31$KoQA+I_s0w9;(-X3Yp)7M660!iT2NwXe
zq8oZo02)qD$hseYP#KhBnQOX>(b9xd7NC!HLq85crRl=zg?KHTGEkEI3(Nc+M5Sf!
z>8{labHKR5`H3nZpM<Doe%oD&)=ZXCM#&Wb$dS<6$)R>P7On~<bQfCv%R<~YhLN9%
zmRj(~GVj3eNOnDYIuqzUt%+q8poDCe)=oC7)XozC^q9wdc{S)iAa}yVtIjw`hoDO0
z($~6qtQNZb0Oyc_+|)q#0BGWM1#vj4=9kqkpI2UvYjHGjP*p>~Q@6V9eGYZ}SIaCw
zmaft)@h9i)-OYA%Hw)<ugSs=&@c+Bx>ZWT;{Fw!$qqx3eh2r(My0O*Lr4QmS-PkPi
z5GKPiQ_-?zQu~(q8GeV6I1+S`t>)-+4uEKWb~$28ab(%GtZY>lZlG<@97ASdRUq?S
zCAdikcf)Fqp%S74(gYvIF-%Hv(^c8nKz9>4hD(6uDzB=CV02vd15m<1L;=k)`VuFc
zT3_0wa9mM~<Q4Sja$MU<O;bcgbBvdDG#73}TG5>}U3BY%=9oYv0G;Tf+iEq(but;|
zs*y?AzEg{)ySpvN2*MTU?MRu4bS1Qq<`^X#GBGbSa?7Mn7^d{*x)+w5HTZ1ZKA>R)
zH;{gh{Y8l=x((b2<9JpS-3V^<)(4`eQFJS~5w71rc7z%H%Q|#ZxDlZbL0%Ny7H&9o
zH<dFSvIS~73fBP|kvdUr2;DJe#Orh_y%#-)83{VQ>_Wyc3=-p7{b#BUL%xn(`0*<C
z0d-2(=W50T6{oQj`%v*7KL;~F*rEcrOdEN66m~K~1L-*9T`{l^nk%iUhxU;!^m{^D
zK^oYmjP4D_{TNWCn(;T4p*tEbgPsWZ6+xXuTqi|U9QD|8)Tp{jXBh9Rf~?{ZIr~)9
za!Dr{60BB?&r}gt05q8bbqLWZIJ7(biKgXE)x|J?5TjG@m_W$kYth6wV;wbe0{@{(
z43_|f?;8ajrA47>8JL)_kHJiY2GTC$VPgjX><Af;aD0Z=f$T)%QI0Z@WMLc3cub`o
z2s+^sEzS51hg#Sb&stum8NW4*YiL$Tf5Wmg9yg?E>EsTON;MYfPpkGR=`z+C**Ib^
zn{VlEo+FQ%vEDd&HQ_TItLKv)Yiv*@EXQgZfo8ZBAk0xy+c+1Vm1eZ6Uc!!Q$f>Vd
zPW)wf6fiRAIikfo3@H$zP-aF|X(=2$W0NWptwmAXwm>gH$3pSg&)A@U(%nh7E=@4d
zY9<)0ReubD4eDZ5jS3riRHW5%G!&PYHLhA*UABT|;|>K6q1YA(ZKI-c%of>k4BNzk
zJ(%}Fd#Inbe$8mY?$V;vb!JAP{tfj@B}<K8>76)N?~pgjEH0_7T~>vOx?eGj=4f16
z&0^AcK&O}&_q4QGf_|+){T#R+rb5CVRIoS@8&BOs3XtKbLuiYGW!rTMmKnq52hlB!
z#tt>GB1twoRdS(>c<<7sFS5u{Qe0A5wwML3@v!RPjSe_9#-qCQYL;kGd_BBTq#whm
zLOC(T7;FaPB{B!Joe^s)wv`Jx#8i@9wl&n0Z5c9RNu!mnh3Tl9T~?0u8g5FGvJh^q
zs(`HRhJ>LAVlbL<l_`1K>1eE7MwBtqOc}zf;Ap5TMtYP=$3VZb#x+K><4fUjQqbK=
zgvSFi$hgL&yGO{YuL4Xn;#8G*M-_KuRxJofVjH8fCIrzHYsOg9#auNBA!!O##+!2X
z5ksF*CdV*d)yU97W>A%dI$aLZi=Lgv0&^+NUX7gD0##HCBFo+=R7ue9RCS@fQKVq-
zTr^{``A_b5m=-1JVUb=7bfKJxF)~Hk03ffMR$seZGqQy28USQuOW+g{%l#)VuGNgG
zLit>>41uPp65wL6wPs9Lg3HMfRn5p2ix~qPp@u1C<=7XY$n|U`sQWpZI0O#oqFgiP
zC}@92DTiq!bgqI90GmQ|VON97&Qs7UF*Yb7pw^5V^tl*NXdoSH++euy%{z!>+6lPP
zSgABsRZe|b`BV~<Hz~nkuu~S0tj5g>EF@_zR!LAI3C}5H6c|ea0+i!YMzJAXYLW=7
z7?&DkT2f>R{vQH2Mu`Hz_ko8XFIF^4je{&E`$;icW*p{Zj21PsRFd?K`Y?<kR3*cV
zTg}BZCiI}m96g3wzyN1rPFDoTK~l%c03`qw*`ye(zML^}D&BZplpusA+kHYUEKp$*
zSla(iEhP5BssgYl1;vU;X%tt%tC~tI_j_@hQXE9$uwjj-6eWQPYv2nTPb*9=M{SLa
zA{ftfuRraIss8<;d-+L2OfJWYKCAi_BPaPe5zcMJN)h|KkRo<?&`rcSFNiYE9pxxi
zD&|E&&J!3{i-J6ySyK*zU92}?*r9>6%W#W-1HiJZRY+N;l&D8_h!jLgJxkO(6bO10
zG*s0*vtjD3O~s)5jVdE3=ql>VCN*YDcFk5@la>XFZx+kAuTZanjg2LG7;a?>RY|9@
z+*pJ($3l!6L&ZYma@88-dXPSl>Zq=p7Rk#tZdJM)e4h_Sg41r4=v9PVC1)6Mj-bI9
zblp@*WMdpsZc0Ht)*%Ho#@zsC9_AIH7^k3cO&SnKudQA|oE)#9L4dMwOi+MeGR_*N
z)>VQ6u2nD#W?TbpZLSQ2RgCc}D?}=V2@a_gdO>5=gF&xzj2}xQg@iAxETc`*>m5=H
zIHff=QT5#AsGCu|f^HNwCaDtr9Ch8zB&uRDwBv+rPt8bjNYNZCNh?_;hb!f>oPsPy
zih@EL%&sC|$4FJk<A7W`XGWR=K^>?<=?-c3PjFNP3I#xu9L1%j^%O0ZQ<LFH<N>B&
zt?EnUYLx0%U~xhN>3HK_b3UzB4Nu8dQ^_&O=i5{gyHA?&h&hb0nOc-$#&Ufr;gYEw
z<B~!8P*TxP-8P#P-9M`h9B@4NPc!~)SWKgqqbi4q|39h#7DKUYmmwK4!0K9n)usB=
zg`8tp#T3Fb43&*lm=CL^f(%h121uTUBH~s|rBQ~np~zyup~L`|fwyrqBUnf(fT>f8
zfLL{4ntQ1h;vIC2-aOo*2M<ZHCRT&!5y4ucw*p<~s4VWWG{Y72ddD(2q^xEl6lfxE
z-_InS;Z&eWKvz&z-^lDArGTKbhQKC&w1Oo$>cG^R;SwWwq$wPiGx`V_m&<U}NS<dc
z71-{W0wH!8xUZ6AGo<9}uO#1Wtg|$9D)m`d*if0WjMs#Xq+_*a91!cdRjps?Di}bo
z3vvrheK4d)Kco-J^k9-ET1Y90k6ZL@sN0L4;|yoeJVd40ev1rJ&McyoB|JM(3IaJq
z>!}&hL2@xIx&D2E<obs>8WBD~Aj9YzB<(Tm*C>AO7bI5_+)7rC<beJ`QXYX&0($Vu
zpn*)<ieF=b=5Z4II=h%yb)W*kW9p`@W%^=tJ~WVyGv0AbfXVORFr4wOBj64+O2ze_
z0+>A9W8Ffl5s_>V&EEo|iu;baJFXZX{2(<XHl9y7WH;e6V*5%h&if8!h04|Yz#;V(
zu|e_DfOqhrg2p=N7Usp(Y|x%^s9{Pe^^rr)?<h@VHp21Hf<{lqfcndX-ZxGMb6-6l
zASXTQeLuz`2E~;Da0NZa2Tj<DXIIUfCS2L91zi^iPZTS3*Hbo;!T|D(=;ule^wJA{
zI?bHmLm9yXU&6D=&pEm|Q2#CV3`l{RgOoD>%>o;1g=P-cXG(#@{qIh~_nud$nX$@~
zfblr5PI|uP5Cww)NkxY0PhLwsg2O$#cq#393{wRlR2ZV_4Od`z+N$7Hy0lhe9mO1*
zFh}UmGOpn);O5fyqB&BRTO6Zc`83rdY@nH=6eh@)x~v8OM(Zzey?C4@z~LhEYE@tY
z&Kpqr8ifP0eKiB(bZK{_IBJ(MV2rAPGctU(#vH2vQ^5QXNai?|o`Hi7l#W*@XQNwC
zn0(&EOi+b#q&t>{Z3XjM1)J}{E-LIBbG+W0J6q%ckJ7!|IFV4YY(5+?GZ2a?{YBQ4
zvO1jKFt1aHDu0ownb+$F8DF)d4*O3NRjE1$w6i%$r5YVgHC4AZ@xdH3Q3jrHDh9@W
zZT(~!2RD;c+1tt6#^$Q@xXok+^KqE^vc{(R8t$%Urs#*!ET4ywaMjIJRo;h#9k4<q
z-)Ux=0)LH@9IG#br}IjPVc*KbEoKIX0K_mH?x;htrs~Fgh$V9}Pq!F$QFoLz*Hu%f
z&dg+ASPc7FcOZC&i(YZ;Xdd8M3jS|2wG?3{SV86#1^W-zN2m(0sS4JmJC;|~@OcN?
z=blzuk6j$ioTjo{3`|G?B#=CGp_$WF#(IO#U70h~&{`3qgBX?Dz2;0lttC&RkR;&K
zX67tab_=Wl$>L_VzK9ri7>=jZ<lhSZnXSsaVK`PZV2+xT!v^GD84i+Q3FK9{nwhH#
zzh!8BuY*Jh9`+n~{R(<?nt!CdLb;*1M{Ov&YA6<B?v--Ibb<3I{aQ-`F|nlyqVC|~
zv~3z=29IBf?ZtsrTJQuaKd?><=Gf}M)mrfNB%24;%|uu;cp?|Wdcn{Ro<#ezI82JZ
zBvPY;JoK1ETbKjoo@8(`1r7!sC3p&PH$G#F$5c|cgAURl(zXE#kwz!sER(!o%On|Q
znG|cpP9;B+dlXGV4sys9d<`A8bJf<B&?%naI2Fop)lJ|4Tksfp7Ek9r+~Bb?+i=xg
zrv;Cb3E`?s(1POwGgEi17Mvgx2rQ4+g0Gc{Frd_e)6b&|a2^rw4^pRlINEQS6wbmn
z2^n>2H+m*c*|BdEX8c2^V_A->DTp<E!%N5RVcE+0?1}wTflNNZq#55bsnNO&wu~U-
zMbyPr#4{l_>g${8h_a1fw)t?8b0b{eQk?v<j0dm)=mG`*ER)`dv`o?mk$n74hIZA?
zNCyx`@?pCkaCjCb9aTO;p4?EO!(ehp*fM|Q8g$&PCq^vKD-g<XI?RN+5y+3!>F}E@
z#d~KoeOwd;uHyo92JXKL(BT;rC_t8MoldR&U)$ma)j(FF&;T0nOL$<7h*Rh~x$eAQ
z1ca0^U>0zbHNz#S8H(@8W+=LPSu;IncvOczMm5W%c&^0`zGag4XPIPuSsVqjO!8Ah
zN#xBbuG1`I28UK0RWejFQ(3++`cOhMW+|JQwi@U<TZ^M_1Bf-qVejrDnS++O5uh*%
z_y;2I2uD^UeENatjS!NGUVYddA_@f0PN_ys89e()CE+npXuS-_Vr4MlW0eu+s3HMi
ze4^4Y17&FIw6f=2Jsl{gFpAUolEd|Zaz0g#4%&l3{6fkdc&d!|?>!ypaa_L&G>&mn
zFw!#b<oTeHS*AhT4FSt@aTNp~_Ba-D<SfwWA{BU4e$x$nh>pB(+GSuD6VW9V+{DnO
zAAFMngg8oTYv8xutkPsktw+l$q9a?hjCu~{NXM)}H2_AYU5&;-U<Wn-g_=>BRgKH}
zaPfMRm?_{WN>p*ieI}Wpj@1;WT3XzIwtp2sDDmIlJ%H7dtE-A(wLYLA2(7{*)r?=O
zIAxf$;~!LEOpeRf*3sq$$%cp2kX(*i5CN4N4cis0kE1FOliZ>DPyRTp=ACLbVf`*>
zV26DdcNoW5V0u)On9+=f&2b#t8jdkj3~xX>k`xN)rdx_%3?QB-1CyZ!%03A}WSQjq
z3~?IeK|5$7V3-;eL4n8)%f`wc$3>lS)r_hjX|!2n+8DQ}5{RLYe3dc3WkCyoP_SM4
zAQ(wx)`CmSk;FLBYPfagq#!6eoR3lFWFjRYhF#RMnIxsW*=IKB*Gwi21o_L`kn)^@
znId60B~(^lONK=1AJHg|2f6BNS5}qIY$!nN5a2Wk?(ZsYoW?t!X1at7a3S&{50NR9
z88YKaR}HpV0E59JAu&A-E3BC^W1y?9p{%L27Sw={o|z?~gIuL5ggd8pMOh=P%_%Zt
zFb)W*qEjU#77!UEFsDh#5ZBV$iY5SMD9xNM)#6asa>g}ZdWhx>IsD-++M_XN$}O5W
zR}HU#IZIAoyi1<-Gqa@&H^Eg!u>*6qtUSqu0EKF1jtmNB^dZe}&Lz!n44cx2qIBjw
ziEW0fq3qTy-d;9yB!=02=v4<Zm(Dt1v!oB5NHX(e5U$8oLc1YkB{kv1)Iy2m#y+`J
zW06cPaTW8nmw7`NuYRekScNFe8zrRDRm>}Klk8tL$aW?Z?>vx%2oTTWKVj`-EOQl|
z>w=|ZuBQGCtfP3hc^e5osdeTeo0(v+77dGwC(APTk=f;vCfI(tYpwCgF**ZjzAAV4
z;OkNCEddOg))!4^rtd*OuAs+$rvCyVs>!de#hUzG4iN+`5Am8`Nr369;$yz%*D`JO
zp%a_tKd3J4#}~`$-~5}?P7IjZ96$pimql^5kZ#O{{s2YubC`K?Arh{dsW_jDMgB3+
zex0KGOR@#iB|`z`Pcm)M)+M_@ni;HD0R{F>WxAhfv0urrM3^D!%?C{y+`W{QgiS!%
zmr&(Wg`vxTz<O9FS(TVxptQ^=48k(0hb)dx;(>?KPaC?JU+f@4VEaseO4ozO<Mw$n
zP4%Y;$#6RIr$0?2(yl75tE*mx<6}5bT!Oe4y*;r?)4#wZYTCo}3;$N3{s@@DCCDHI
zM3^ICHE@AZ2zphMrKkG{<8sQ&4CKi(i~83z-)#Wm-)L^Jr>Rg~e-_{&Xz@Ax{VUqK
zTDBF&4pM()TtmCCdT*U<ogzG5P5aGyI9rk{kk;ZTz)J_Y6%Fg}=`>OC$h!kSTk(Sz
zp)d$de~)DMTL6q8Wq~yHn%+nrL9$XNzejRRT~@QEA0sq+jy9I2cniR9;>T%d+FYO;
z_Y(n;KtswdmZm$|>)0N}dj@sbJi>gw$;*2bb-%&SGpO<#)K5^Bz5XUsSG$(LDmIWb
zwQB=t7xP3e#x&D9$uo}nH9BMc78v^g;}`h31gzuhAXYWx(h(@5U7NrwA19srcD$(-
zK#F2bWjMiHy{cz5uGjTg;GwVV4HBBR@Vah%69f3J=f#*L&G>e6Jg-HfN?JXArm2|P
zOhogo?C4P-oI4lSk>hU`mU28+<2xCvY1byg)7Q`OfPRhqNp(<o`VY)76QLV*`RdJw
z2xCr!Zq?6o(C2I<l4!rSlytg&fjbc#1t4T`f~H^OL61~`YXg80phhZzx4mSECmApg
zZ&v6(a+M)2l&GZ_MbrXbV$}5@`b2t5MAz6wIfisnP3_|4FyQp(qna%w**{-g+Eli<
zv6kMlkZuh~AZi!9iR52oFRyBV+SK$tQAsN>TZ=h(vAD9h8Xb8sicTy`xQs?<`eRXF
z60EVdcJWe#KK0*6y)==UtgmXUTwaFv0T$PDd|`1_184=O8}wD?`qcmK6t|-3uSZ41
zBCEEJ%x-MIEv7e1^zVarh2kYU(6lxSxD)9?*P_Ue&4e#9v5rGnx*kP>U<n{vN<4l&
zNM%Vb=#TRe+O=GEN*SW0`V)~<b{8P2a3rKK)PEOAr|v}ivD*^EXhMG<Nu2g7BP;@*
zk(1C^m8PEwCEhqil~-su?Ld;mXrD2$E(^jal<EY*-$^@wDybN}riX?}W|}{-9{ej)
zzebUXB{*fI(n<Kr<3!|!g%P^5NTtQ16N$_z6T_&x{{|5MQYHaDc@hnrs4$0@{Yn`0
zT1pObwowj8H1zQiWELbMYa$Dh2@%u}+Df0e8i5kffu>&<LB8GnfTfb4WsRv{A3+wQ
zXn$gzmQn|tf8o|Jyq|j0@IFN8#4Uj9Kldi9&P3!uj`ZKX)kwAU2g2|TPW<#uq~<mK
zA<i0$qC8RC8PjAWC8iyWX?{1Ro!yvHsHI$Bk&Ahp7qgP^@Z_H0^U&J}5wF_&ylMxK
z*3y4K`>DM(t(N*ghLrxYlPsx^IhS(o$4`gq;f;K5^GCwOgS#o51{Vgin|pk7IF0=p
zBu6e(H7Bwus_7-+v}kF_!XiA2?tY_C{)1<{0U3!{Ku!N9f})7Ks9^eza1aX7a1t88
z1Wo4VUqBu=m&wg_P*v_t7Wd|Tq(|;iHRYVo;Ce>;e6)QSZ9hl&RzTFOWZV5BAzT4L
zBa?A(p3~FO>}>qpg`%lApk7@|Z#wE5gYqE*9fB@#*G4u@hNi+#D&E5glxPhq;u7@5
zE;RQonma<x)!^H9+}aYL*HSFV>ho$?zq81|y$^8AmI~qOPcraLE=+>`>SSbN4k~!n
z2gBv(IjCeJxfV&{w5r~U)3lT#)G1eW?&a~{5U8`2=WP{|Y0W4l=jef+IZEFK3H=3r
z?osvIEuz^+xIU4{Jr<G3ZltyJ#3)UB89x_P*~gjnj|JL#g1P-mB;^|YE|e(d64E0V
zsG73<r@0>1Xd)Zv`ZJ;Av4(R*F6Dl7^TiZ70n@nPaAaTtAP%N;3lou+EzIB+mT-Qy
zrq2u|!SDnn^E7=Hi=q#ZN;}X!^o4<@X$lv03#--SDCjqYl7yH7A95m};?!^C(p~~o
z<KU2f6Q|#$bi-=tM(H=pKE`5#Kmur}S1PixdM?hGh>VHF)wJ=rYHBmKZy*8taLy9S
zAt`wUkLqb8)A~WP$~hXqWtfiBW1+?J@iRhUZtO*C^eHN6=>&fnKV_6xS5Z@|>5<H4
zKOj4CD2nJ&oQ@ts1;~Pmj(Bl2ln2sUN<12T234iB7|GJ&Cge;YPe&gW$*xX&4j358
ztNEpYjmVb5=bFfyK>xpCL^FWMNW(kb+~k!^{!%2x@blYLiw%>3L8zonMY+^w@a3Q&
z3apCuGiy_uq3;99U2C<JO~APcI92Pc<7!b)wH`&SKaTW7KFg!WMbWf;4#3E*&?h-i
z5VQ{0GB|t~Qc6ILkD`#_7=p-6Abmm<Z2~PNNL>-s04vW{Br(Hp1J5`3c>z5ke4Cgn
zpW(7tJ)61mbt;?kgn;>+f!WKY*^3G$ugz$`aUx>8dUP=L?ig2t{Bd#e%K(->!6Z)q
zHXKc0rvlRFieREe`znl<1zz7^Vx~JsP@ma})cXaK&v-W`Z(_iW)cZ4RKDZ!}d|7<}
zci~H<B>`W_t=^C2r;)^P>Lp5XTu9Rga;v8a0&kLRgF(T>Q)O3UwHhdzrVkF5>vd{P
zdMbok1%5ix$sR0TRb5+LN^eCXJg-j)Ch?@DjlxV%TuldY^~zxKYG>eQ;_9h2r87#Q
zaH|-04`8Xa^5lemi<-6~@EFSEuh#Ts+|e(nRPhSD|E}rP43T2K4ozfX)+Kc(g%EX{
zacDgKE{N2__*qQ381P%nRAVSFWeaM(uHerwLuCNY4Ecv%v>5qFrX58o$&kCb3<)h9
z?bT)Kb}Hh;Iw?W6rxy+S?}Q&Mj6z1zWZCi<CYq=*s)eykG*=-hS9cui`-MoSLd?YX
zmV`4u-9HfCHYC^(ph>Nvc}?#Y`y<~5P|pNL%usG`B9{k%01fBh@rY{p<q#sfr?_E|
z-7B2@8ztEY`Xi^q#v;A4ep+=gY}P#tx{g4^3wuLI0l1NrGGbo{P0m@)CTX&t=X>}#
z%)}<NBt_2Gj3X03bY~a9pHg=)Z?8(dNEzw3#cJBy_=&|BBun4P){KqZiFA}q)7v76
zQ+EI$8^4PM)O%Dt<rSc9qv6-&)gl6+Z)Y+01yx26g&;d{(-h(bFn=fBqUk$1pN!#&
zbmC0YcQN1w0$>IoX7lh)O4Z5yM<R&ycLSoOPr@8*!p|OR5Xd|nKK_hL(`K%IhoHh2
zsBp?r^ej3H1wnE$&N&R6I+6FA^_?6i$OIs@q!C=Pi{EY$?X7DdjMy=J*rZovs;LTy
z;Smm$9!3gAKfJ4j3h`f<qDEpZm}dXV6g3S=Nl|YzMU^5g$@eH1Cx%Js2P_8(3$WkF
zZ*8~<3p#rfr}h()qi9dR*-3*sMY+=BmjKuJK<5`brIYZ~?SalOaZ=~gP(n*@gS2`Q
zKOds8Nu=p61`+LODH-U2m?GQ!h7FDts32|9f3m@06M_`_801q_P73%!Hf|rHqE)#~
zWeEG|MGQI#kffl6OhM7`vM1K5B8%9&$zTvp(|`zXU`R0_lB#ZEs`4P6){GXV+PZ}?
zKTp*#Gs`&j5v7#MsE#C+@iQP8X)vZ~F@D}eXQgc$>?GTE&~-G7T|j!(REcOL+g=HP
z^RkU%`)nSPa@j_+UAr9VkzU|?8$XkzEt0?$CrL}?TDhkMCIIT=gj$9^b(?*oUom>N
zX*M(9&jgUh)}8E9buj=8#?Dys^{P8}h0y}dMKaxh$e)9s{e*orae4>8W43|HuAaXX
zLb#Iw_YnXm3G~B^>vbfxw9_<?HH#3ehOA`xF@kF;7m+b;8tA8rqQ#{^5->(5R?#Os
z^uwI~l90-;eduq7Q$#2d4(!MZ)cg!TQh1%@qEnH9{(8|@+Izc!vo*b#<#iD<G11_&
zr7YB!QQ?$+*zbE>l^f3G)^?Y>ip#YlJ(<4fg13%KW?>=Cv<y^Al@?ZNKo<~=0{j}`
zf<c+=Ao+ik+DO--1#rexdmnj|Sk~Ua@<vN(L5=>?X%N`mFNQhD!g3UOm0a!$PEY4_
zmOTHj_hnceU|P!ks6QU{C68`l9z9Gs=>s9xH{j=X!cInqpBefKM%BQ9S^mg@{&y$2
zAtnr~k=3fsB*?(;oxHUPuMJH+4kTD5?qVr7Ps)$|#xm9k<jcazLeUe{-fDa`M$`Yn
zJB-&ME43zb6(Y*|H-aW5DCb@??_Lu!%tB;$rYa9p2k)k7`jr-$1~;RY5;QRuNuGNM
zAcOq+K#QD&IP#-v*mM{q1qTCUOM|({-xwlEFP6*1k-tKxbm%=MeF(!A5)9|ItBR{t
zv~H+HT6ZPEnVI4>eHi!R5QF$YnLeB$z2Kin1M4bARzv>E>YgCo2#d7wuc*{s%#l8l
zOZll3WXUK_CBy1YT}_8xG<~#1k$j3Uq>aM#NLy_p7h8>DSlPRf9|YD+#LUTc|1&F`
zN0Ci9-(r3A5*1FTa$n%*A)006on`*}8<%96@CAzi9|1@zf5}Wg9OmuFdr|Fm{7hno
z?_&N|%&zq&+L(w^So93^@*trH`GzymuO{mlLPDklEJ7`<5~ZX)a2+eLVn9<40QhfJ
zHIWZnyaX^+m8r2ARP|ewN(J&Fe&t@jk@Ds9apb4PQdg>wU&a`&XJZFN$~n0fN%}W{
zw&2K#=g_;Qg;7wGe_1BId&u*`g_;9}?$XA{m~T&H@r|v>bcmd}s8ESVZ3(Ix97osn
zpTc`<_=+3^1%hyz{5F-QQLJz*6pg0Is51^vjODxO@$ITxtFfIt9!dP8a@~12bXqA(
zEv2(N@{uudRrJB2I^wLZH;xm|Mp0kX-fr#MX`O9<`UeqXodGnY=!S*2h{hr-+nOyx
z8eiToo?mCB-1}Zah1I$<d0ck7m}|ujDU6>pXU^o9x5Ns3nj%FsG>YCSV%69z5xybK
ziXQA1A8RR%X-(phVJYI{8&ei86ur(28MAQbVDYkUY!~{g!kHrKQrsdUMcg_|MC_?f
zFIlm3r})?4<6_5>a`D;Va`6!UZXKK=zQ*6h<-!xYLp-~#Tzs>n{82F?MJy`E@10_y
zwLv6Xu@xfP8tbvr;`UXYjN6wWTvm#BE6RA+)R#@1Jm~{*)nO536`=*!9y~-@`;xP_
zi7R$wXTP~uyu7UFO|fN&wP9y_;UaN-@lzgAWQ@|=lg|yVSSSWsPkD^t13co@bpTpJ
z#gDPp;nbvsP1a5^Hzh48ZSX>outA(zvZEq7)f#qdx`-|pVNX?5mQ+-vCX2&sQpDRq
zR_r-(cYiCYqAc|-@rTvMc<Po_b)u>ytvx9<)w(w^!Bd$u+iFT4*WO-PI$Ino+aSKv
ztu190$rU@r*L{ktG;4?_{*m_Nlc^19*%!0L*5INqOVW4lY!~0H++Ynqm!6oK-6RfM
zn2#fC_UuhQ(GFbVvD>U!)^j`eCXe$}lvRjF*X*$R91*WLio_5j37uGWUuxB)R4Qr>
zd0KeZZNR7+=-1IT8?0xHq0!0Xo_=5azHW~-ucGi#|C{ITJtsP~r~dWm;8YQE=A3vv
z8u(Wv#fx`Ji`vUllhZ1ith9YdzY)4cJQiZb-jj4sMe;cJuAL%e&(js+*G7@`+z%&E
zWnAi*)GFT!x9F<2W}UU%;`5*l)=m2ptv*&X`XkmySg~i17$c*_T`Rx0p11av#V5N9
zQ?s*ISBM8{tXUOh7MAm(vnW+GrHEeT_)`vAOs%L&tQM<NFr$gf+@g7dxMHlhB}GJU
zNlmUARJjm&jn|1)vCEAy7@Ow>3q<XH`kZ)ZU6J+dy~c>>)WYnl)a=su`qub+#do#V
z9?TnN%q+4N;{O%mfnIy8BNfR_Vn;}kHA*zc-f{i}P*~%HZ9cV3tV&stdMzfTH9axG
zigs6sFRS)gY1tywDk@vH^yFQh=@pe$Q;FzP-hSV?bJh{7y6U1^+!=*w+$mmjY^W?v
zOR6mMyik^!TAG?VbKDs5puR_Zxi-a}G%Rt`S?lTKaaO$bjIeLF%B^T|K(}TY!!Z)E
zYb|;xK3)w(L$kBR{mY8b@e|?%I)2Z-xN&9K=d7V`irz(5`?fblcoFJ4t*CS2!G7R|
zp%2r{@jT9IYELa}S}q>G<+z9{PX?0`tJaPck;Jf~clo_f53WFc(C;oRQ>%ODts;Df
z=)LC-5%LtcynWN&<g}!Fszl%8R?SDLV`{8>&W%a6Q1s`sB6Ne;EY9q^Yu}*wMb_D}
zaUV4QORRTT<;J+^3i0WhB5UZbikX$5IuW_!oDq*<y+1c8yD7t3_#6hZ=YG+g@~d$~
zP7m+3{+tDVt1PRi+3DLQ-mNa$y7YrdTNfqmtFqkI5b<*;ULmd+lbSl^?EPZ(*!xAu
z_j|MFSYNg!JeJ&)W-Wffn!B(tb@DlJk7+fE7cec+)?RU`V#7HRvc)al=!0n-_Hg=w
zgq0=n6{$%TZt+58(K*p_1!k*{I8l41Jqz;gy0_a!pA9FEiBF?ur51{Rt+vKiCf#!c
z(_&R6-s>)Fx1#@O<s_~&l3b<nN6vn{>#SRxT)yF4yLD1*kES*FZJ9M|@A`@gu}d$y
zC3RxPIgtMf@%q3G=ufmbT53hLCS`)0D<_u`G3*k*jY$z7mZT&NEqLMl*-a(wJ9k#>
z{EZbaBCWAIts#4pQ|DSYe^D_wb?}M7<4Amc6>06UhVDF3F*CkCC#^#KY+AEyP${~f
zvOG0ydcrlY3cr~m?!S$2K3kcT7FU_pzVp}56)#)5YUj?!tZ~*I?c%5E4QJcMd3^qS
zpBu7doA}rX@~bKlQDeoeDIz3AtQ;#s%8TE+U$~2BiGL3&A16LDQpC<Rg!TE<<R&A|
zMJ(ThQoF>j))nm}#%mH^ui21Rkvi!IcXDdQ)2Yd4#je|ntY^*}<6ZUf;@IsQ+RIL?
zPpzhfpW-g70J~&c6|*mjK0B^ic&+G#H^{|`l=0cwE5XfarS~ivlr|_0teZ9?O>8i&
zvDR6T!hI|ESgD?*>}<#mkp(7kXIoz+#d}2m#`fei@o0UKb#7l$ny{}dBKa%!RuZc>
zw;NaWZ->NccS-Oo4Mpwg&~L`D=#xncE5v_R7oBUbOsW)Tv5=K<@fgll@l>g`!Ad<R
z9*HSxUznX?#DRqG5nrycNPeH#xfeXXZ7n!<G;!?r(6W2of0;Pmg76jL)>u)$MTD1I
zP5avm#XlO4TOXcqTNQ55bCop&vdYQ^r)Mv;##NQ1Ry3uiiASuW(q#*h(h^FNmX$n{
zRC%9>FtT)U>-S&mG?HCM_F2)bgT{f7h9p-!DsXlE@yrUbs(d+CzWUslitOYe;{3pJ
z;a!^2@<M7uYVz!bVq;X1H4@DY1HZbTn>a3erS-4>>;uK$S!Z0OThD@L2al_`yTW?S
zxXN|T0^QyRv2$eaGZhs{Q1XysJKN8nds;ky<x}l@%f{U+zPN2eYFS#@7X@kJ$vSK7
zL)*nTE5$m3rHpP^X-to{Ub_#}-EL(kkK5dS_c$y2Y(d(SX>ryz>+aMs&(oAOq<%3j
zxuX56ohQmX4~t`AMJtjQiq9+eV2#dM(3KSx5AWPtA$)_LvZA5BKQG;IR(!H%!@0fU
zRS4)uEmwiHOW4o@FZYE_@OZP80?~czo^#?3tLTXMhjUBXle6b`U?CUWn<G}AnSfdR
zel=vm<JHDc-7U62N{S;URCjXf*|IdT`L;cK#r|bhx%fZCy?cCB#q~D6&)(;R0|^iy
z2r6O(M5qu!K)Grl2^YB?5=c-$49NkaAqmL|mxP-FN<3nNw^~bqTC3PnOD(ouD=jEs
ztrw(dy<&?Rina)-)T+GCv*vPkINI;`{k?zuPCk?M%$hZ8)?D}O*|YboKI^deeAPkk
zcp!ZIqb;bxMUCFwtqyysb8#h_*Ozq3RpDQq2={x_TNK_lai4dh=J<bL_EK;CvT*wk
zaK&ilUKDT#W^BGa-2LKb!rMPPF@NX?l<9_4jLh@BqqtV0TySwZuwuHmZgKd@zkPJb
zdoXx-!#wZZ7Ek^=d;um}KduTR!`oAC@_v<y7IaH}c=#{F7$RTyT3+=_Z{O1JrhWH#
zY2jG-4RCG>*P@+e-u={4?`UfHrbXUu%eHwRENUEa<=_$X7UAj~JnY??e(>{OdaG6(
zMq~5#S06;rj9$%=WM@ivy7z30@L}&WWIz0L=_6ha%4RV}#2<POr=hf-3U?beV%Uf^
zxBy&{@3p=P{q2RCC%vsL!tGxe+HYOB;|bKV_sxoJ(eWR6zhAn|dvjShlgYfk{GfMV
zhw$7DznnjGUaj|oMVS1wf$jrk;r1hb?ENFWZG`v7K<o;XPI%B$wcf${>E5xlO`Ilt
z;_UVQSdZ#>Ynj_U5FY>i@!^blNchyE>9=g~ZeeG;vV(hJ2k%bL%?{uS`NP)Jf9n0L
zKD^2MUB#2$$+I_MzT<7I*c4v9d0r8&LiL-%7d{x?aKigrr|I72B?rBCmp6KQ7KWen
z9-v8oTNn%f#qHV7JK&;6crQCBif-QOmD{|xmLs^yb$bT9BQ0RipV^~dUI71yVe`Dt
z+H7<CW(=Em&5(K5obY~jJ&McQm4X<t@KxSh^@qa~+}`cHpSKEc3V$}F-~3^HQIH$F
z=UN=Z^&jQ_$PIhF8z6mO3pAM%-V5RIHq1KKZuag%uiD_PPHCLyebMqDhVS{|7oU3C
z`}3mXUQbK~A5DQJyFFZFhK*Q_Y0G%;k(C&X_My4PQ#ak^-97KPcM!wV7vZZf@eZX;
z4@2vlH+s(o(3_y&!wk-QeEIS4CFA;e>z5q&uEW)&7LiYOf-#MA_IhuIk$xDLJZ}!>
z*N`9n^f2$$lx^PHns8%HjrV@rm{)OdA9C}Iw{sEN%9f#bV3u+mI-U$2^lG2<p6U?3
ziH7Z%d(it~oA8rQo$x-Xn~qw}p1$UF?~WDW%<$`BTy*~G{WZL8gSV|3Il6ttCT|`J
z?pPQTK}@@^=sV)Z`Gq4!)Ox>ir@MGa6bPi_PUkd!z{|pE!QeXFOZDLGkN*7xbYz?G
zT6a|IQ0{7PVyovMv}<H)ZdSS@OL7R`4!5wm+zcZ(J1f1g)h@(&Zft5qDApDr%U?gF
zRS0VIk6s<RIe3dVD=WQx*U0Bb?itCn5N^`p^BJr;DETq1LlH@2Qfh81>L0BsY@-))
zUEuh81@W-9Z_~-wdNUb_-!X(=2x{y=K4<RIi5nf<3)I=j<hBk?(mI$2{<x)Q1#Vi6
zj&Uk4-a#)b-5ch%N@Qqcsy8l>mFbQ{z*H|Q^J>uLpzg-3boc(O%o>nI@ZOc>xKn_i
z0{t5FFImpD5UmKn4;k+s#;FEa0nYWnIl%Y2S(&AvH&bd2zyyMO5dAdhXh<Ph_fJ`w
z-un!Qg0Unk{W`$q5I!2rataZ?3;qS5ixC_F|AJsvCiq@Q+PwqdLO07P25pDr=7VO1
zvz)1*&q81sXf61Qp<q;2W)!3`D{~RJ?=t$$XgK(>*jy(jpQcCA5r;`L1lNX1J1TyV
z^e37RVt;8s0VhI&1tmZ}qZLU&Ao(#hrD#L>1Yo6TL%9mY7B(H8;;4nQCGf}LTxY{|
zAo61a|1}&9CjE`VVbcAAYr~|kDSnVNj2ya7ZJ0D&a4blgsrjVb>PMXrmmkyF1BXnJ
zyehDO+72o%Nee_m{#t^ZuOOK6OGM9SoHyVCPQD6Ly;Lcm!q9(8=oAymcHAG1=8z6h
zI83@$aBY~Bn+W|TGu}0DFxjsvPgpi>N=+8l6q3~f+4beu2=4|s>LtBb;V|h|!L?!1
z-zt8PRKD_p;w9aw`J}rA*M>=-(|po>nor7|i~c;^1OG#C$OBa~*q5DG;C&U2F-Tui
zI86G1;My=L_cQvn9)tf=%_BXbaF{d$qX`=aDR(UT<7L8sf##83sBoBcfZ*CN>0rgT
zjfW%9t8ii`=xYjxNsnO}kLi(qDmWG-<t9Y(O-&R++akD-v%yK}UPU+?fu6JB>3V`n
zIJ7+yZt)ZTj{!D9mw2f3+E&^_Py&Y-B%4w-pI|Fo3#v`&9@tFJV<wc~Nq;Ck1?c3G
z0KvbEhk%={P+KH}v0f-b1l(o?KFOc)piKA#`{BSRxvHJ!6HJB!pXAZ@noq!eIN*~s
z89u=$icgY?!AkTKq{Bg;<PpOs_>JO|oQv^D<O#Uv1o9-qI%z&ZHXQgQ3vuBQd4ff7
z;FG*y_ypWN0Y1s1Of64P4+lO8w`PbQf(~%tlMFC?0zQBRpX63t6h)rk`*7fsbndJ9
z1bh?%KFQ~XPw*ebCwXL`mVXLh`(W)Mcnl7aNp@q=UJ@hN2M0b$2dsAspP(}w_#`v2
zm@Rw)E_j1avSyU#Hvr`2Xb-_va1bI1=4w7cOE~aJ+T>|IK?gYSNxX@gPY{L!pM?EK
zjBxaio$zoAcB+1xN%PS;h)LOFi0=kvr*WOjH=E8wK06V2y1LGg&7^;Y!-?1=-0bQ)
z{Wp{H%f4Wfu(!byl11nwR6@EE4r~&3H3*v?2gts5DLM;<N!g*mCYh-q$y0EYApO0t
zBP6P`6_K3ZT1k-hheLuS?0Qf~!VjHN2kBa2M@a4!SVZy>93?&jeZP&uq$lB^kA&aW
zggz4PS_GHmUvP{_dQ!1Tu1HsG(lKz5z8YkyW|Q8l*dz}LEczWt8}xeWBW<S!0unVQ
z6p<W&qXa3p@j*379lAf+q$|~kK%xeXB9g~CC<)TNaERChaza58HDVNz%z&dh(re)$
zOj0MXXg$aVj1!a~-Kd5RlKTY~af8|$aFihZyRai99nPY<B9c~}l?3Toa7cxO`?w%M
zvKfv#NFNY(grw|j#U`zXgEUE>a}=BO5;*81nJln~WIG)7k-jDD$VVUx&sFR|7xWZ3
zijYo+gAx+%EJ89Q(eso9>0&rYki4$hq$d@-pewd-z(Im!j=&<4wdX4xq<6qUg5+a?
zMQt%iX2Kysk~{@Tw!=vVKz}Rj2+7L=i%1q;pd?6_3huv|^z9ysPulN7(M@s<92Jtz
z5_W{7PGAv7*=0SI1SvOoz$lVKnoW9I*b$OnUZkW+x5FW0BrgdpA~^-e6iK;_0um(L
z{Xq5}Q0{^Nn}jb9lTFH(g~8?~g_aj9Hfd)#uu1reE9@hY@0}nb>CM89kaX>%B9iiH
zJtC4^quHdh6q|%!e1krc{ctpd^etgWNKOhYA}Q&sBuE#-K{W}V&qD`E?<^%jngs_5
zlBi~rRw?#TkQ2flxta7-e-)FIk9$2QT)LTHG91k!Erx^2c_80ckc3Z$kv>VqKqX9C
z2?t@4l>&=M!j~%v(k_B8+f2&08ko$hpnnxSYBTAq!HQ2B72JO_DX*lIC;bx~3?RuI
zqS&Mt!odKNF#?N7Zh~V((zU{lklZP-h-4QWB}ln<9Xd!p6j(&^8Jz13+DzJGsFEff
z4af2Ui49k5(p%wRAIbMMoAjr`jyw#qO+gYhBPb%dcZAaMB<QnnP)+ioW|N*$Y!c2D
zX!cv6hu|Pha`}~tO{!)OMI>>}CcP657x%B05qzDk<VoqEh9o#r^3WFKVu6tnAbARs
zL<AO*Y=@&Iq>sZv_kraE++WB5?lH`RBPN{!hjd741QwC3gkvdlqQg0k>kQjW`UAoJ
zHj_R8hnOUs)=(koS#V&JWC<)H$%Uf?=@?;0NG8C+#2qUMI*nE`q~C)>y^&lhFhUYh
zT#~!ssF3sr!j6zUFR+N)icY{$g7kA?M>>r`Cxj!Lln%C%tQ1&u56Djxm*fwMOTuk2
zj7NG{u}Qj&RqU~#Gc+b$1qan6cW5^0-HQDnNT+csW)|okjY$u|A?qY#u2LeT+^qnG
zBsT~w;!@CUic7Ldakqjzsknat*{vYSs{)HiYR4<Zq;WVXCUGVxHmL^(Hpu{iMI^t1
zV=0inpx7iIX*Q{vx)zaSz(EH|CLCK7=~%)2HaCF&7!D#NI|LSy44kBrA<Y&%XfrA2
z!YCV9D!+eVCd~UsG$AL2K+lyQuQw83Lm~|UNP<L%-(thR1T!_n@B$K^yaQzq)D!Ry
zR6H3i9j6-{gh+<L37>P~?_)|R9)e9WP0T0xrGg~0FdY&Rf(PM(4mQYdCW?2}K?LjJ
zU?<6Y7id1g`*7fs=)0T;>Uo!=??N7^XV3g6?l>e70(G~MPcjrv`0RN)`w!Uc^Kdqt
zxCiwGBs%+B{Mp}9zX#>;B3!_k!W?TGwulYCxl+_`sVDdy91JDVwrvsHv<+M8eKu^d
zHu#EqWBp~ie4%C@U^$#l_AXV58|w*Jb^)i5M4PkGUnCp-$!_!~yYbtS-BEu6+51AW
zm`}nAN1^SgXMQ)UI@(cB@QkV>k~SA=A%gaBSO+6{tgq%1JPQXti8geH7+QCk79v;!
zhYXYGF?&Zn!Sit73qci&MI66d!huiH-tY;|5q>_2F8>|=g4iJiQK=flj(UQna426A
z4hxb3!Fw`POd(0ZxFCFj3^i7e=(e=O7U&Z}+|t3dajNhN@Yo(>d&)MeZsf6!)0}E2
z!R1ZqLAd5z7Ch^`IoIEr*~>Wq{SH)j(Czh9#%Qo}d;Jdpc$>?6SzmkI?r$L5{pGUV
z-$1t8{M^|Jt9x*0XH)D%s?gZ7#fBCzv>Xnd$b`Ow`A{3oP(n`i0VgGekQ*$a%1Eq8
z!w!EqMB?O0&5~^V7(yB)G@qf2?^|VUY=KD|99YM%z{L#?kmNsbt_+DPod+P*2Ze)F
zI5S!+lcWNYw!@^jw$_ip{G}ESWw*7S>Zk+qkD(R43n%<fa*+%i_`J}mi(3J&V&A}l
zd&@ZV4LGF*%|l%?3htk1#&w&wN3>0>MH;mqj+peHaA?^iG>~lCHy@6el(s^I=Iw?9
zG{#ZFSVwHkBR2Ly{J6G`Y-1j=shKnFV`(v*RM}T#?8Bvq=3OTy6_L<F&sn_EXKIlt
zNl5?SnOgKenK}`vu{=_of;)qS*pRD#kJ^eUqzYcneNFEs-9b<m9GN*N1Dd$Gskl#u
z1B*m0?i5mpb2Oit_s|2flpx6!aH#!lE7_FGq`^iQqp-R9AjAeptbCGza9B(hIz-_h
z=}?7ngsajF8FUBr3j(QSqypXrc+zGH%p47k(FnGIU>`Wwsge5zB{_wXFT!EqGm={&
z^*Efbll=l-zU1rEM;4{1&-}WagIhnikW<5+PB<A3<&>Dq*-n4rY&^U}D4P?5Ux6bg
z<$TXq4I!(jAfd?StYvGAk#H?B){gC3<8;IK9QAJ;*i+zqS)q3>oC|5visr$Sb+9jW
zj<QSP%mXXpm2g;1A1hnG>ERUsPq5I|)bBsg)4GjW*e@lV4u=Bd-6t=9zOw9skTDW!
zTi(y%{j;$0jmqutswFvFhL3{v7955-p(@yx4B!1-C3CNW+-%3028UEX205<ajku`Z
zEEiTAryt~JN}LGeOc24y4Iott#%vsGET?-vQgKK)<@21Xz~;o<FT$DF*KodaJ^KPI
zN5H|Pb{N-rHw|d!#DJeq#Dr{;a2@^2gnW*~iI7|?a0;XMm*^3anF6O!(;zq`NljlV
zNYYZ2+6F&A9rt^1zE)BJFV`ty1#i&RU3mfLkm^3p7S}Ea{awX<03+}=8HH_??L&xK
z(=1>p2R~>`+%;J>54FQA8O~QckHPyS92#nnbiV}K7<ujS77Luu=<)Dw6_%Bv#6mcK
zFXb!C<YDH$u|CC=Y^Vdu5DxYk7QJe%w1DdbYDJ(Ranof5uY_PZ98)1>Bn*G+>P<B9
zFd}cr#A9xb#A6Z+BW`OtH0N+`S3VM(kkV~4S<~TKD)wTho4r2u2D=Yj*x7Jf{hdKP
zQKpaSw^E!9tH3s9_<6<}KhGHD=Na3Ip?3`&1~U?!#Zz@gH!^an&L|a+(Iy_FW<KJw
zh)~hKlG^Gosjc-sHCyX_YPQ<>*lMV_Mbs3LXls<3AITz4AqlGt$^UOOE`XY!iN=Vr
zwF`=|01np%wt8M40ej?O=>^Vr#bEMrI1b;WTsKDsNgh(r#HR%3PAx=1#ONa1q}mNJ
z)U&$+6N_U3BB|#?1tyZOrS`#kdp}uvFEDD%s0}+fVC(UDstH~J>6;`*KFMl0UV2Gy
zQ8-8%S2%2<RcM~CpYjpFzeTLyW>U58AK{|FAK-kFFWAt6#FBwE_(g>77d<sXm7c<c
zq#gA?KMOV9NmO?L8K@vH=v@3mf*+#Vk4h_u90U1M!P6iuF+qYr8<5Tlo(IxRLC#Lp
zO;99p-(y?DuaN4aa4G2I;d$q5&cvK_5M0<<<lPk@#}raM4B8?_<&#7@OCxNo?>!#V
z12_y>B$vUVaW>jU-Js*SxH)3PXW%eMHP)vPX*KIajgGsnS==Wfg+@W5g|}K^Ut`&Z
za4KY@+YkCCoNp>;8qWXK<^Ex<Q$5G;LG`VWZQt^YNwqaH=NsD+2H1x179#SseBa3a
zzGd0!D8ZcQUN~RI%Hib$AEYXzi<IxNI<^YlT%fRz)p0TR7jWX?S}hl6#lw4@;FS`c
zq&J-Kx&Fyj74dMnk?$&shpUNPMidVh|9HnC9xm_kmP0(eE#ktSc*ddDcd42`R>vEo
z>)|BiRsgnk@o-s;HzeZWD%c;5$Fwr$mIc6SB)#WcDGVVh=Lc-gQAoagAE;x#yQ+L2
zsAImFSqPcj0h+u4n#=$)D_pAtG#LRj*#I<|0HoE=zyTVYABUZM97mhwv79pWlr>Z`
zlc=FnVyUj7Q+2I%wct8C&{r#`>Wtkety6Wza_aI`%Bec$<0o(oAXODq^Re8w>Iynl
z$9z4eD(F-l0c#6mhRLL)VX`S6))kj8(e6lewVkT-RokgLQw02Ck1B#1p?oX}Ehp;;
z_*_yvrpcmT`YP_Ezc^0Tonwom-)3KNob(sRNhyx6&`_a@B#8FPc?zj+yC>^>#dK1N
ziA945zLtAZ3P!iwlm3=_vd&i;C+mDI_oTlFPTC@9kCu84oafXW7NE1es@|8^RrS8k
zxvJimzg6`!kq^}gp}=SRs(PQntLjY)MTxGeXZ01qp^`|V0wW~X!-<G58>{Ml*;rL?
zYSMQx8-xrLNtY`WqH1oPKMU*pSy<=K!n*o7i7Yhvv#`#eg?0WctgAQnp<;a2C9VO!
z7PQrG$5y``TkB1;LGkaEhdX+3+gk7IMqBHB<+{~x)K<SyTcuoe32wC(qBytuOK__#
zK?yN^VIF$R0_ivrlGOsIn9yY?U5;k#u5W|>LzT7}yL@#q0U;$48X@6RepK^~7}xHF
zgCLtlK;2W5s1dA)?Sl_JAiErd4?SSsvE>f}=uXcfzehEdhd?+yLmeMbn8A6uG4~eq
z-#Gg)9-kz-a$~*e%23_tua!oBtu)q~QCP%$t-aA-D~<JLa1$|K6*bnIQCdQL{h-lb
zUyc6yYV_Avqrbiy{q>cYps+?>P=zZ5Z60N3IxQgUW`Y!X5wpOBXK-2E99{uUVNugf
zqA6d9>OHsl%jY&JA8JF6Zu9q^+v<%*2{AfZ^|y=8Le{K$lw~K47b1yyVsHVURsS9i
z7pBDHMSG3f0-=XRFyCl?9o{#EWg92G{m!F~DZI&e9S)Fdq{k)GR`4VQzl6hVhJ@eS
zg4J8=8H@8&@$hjn%T7F0(nCGL*;>zX%Yl=S?zns8y^(m>Lf=tMHgR9%ARgnIML-k7
z_)U&>!;DwOe4EJ^;8hz}3i!lbJ!UW9R7pMaE-+uE@m<ef)M|J^p*j`6FcH5n5x+1I
z-&V>SBT+C?UUpvB`g|-o!XXtt27d_-kdL#u@Zw859YU)_u#kegM6i&AaWHS*QlFBD
zW|Qo2KK2K|p|%)JJ*JwH5VRF{8H8#?u!tlE$2%m_T7`q8OBD_$jFo5aG?ot?Oo3kv
zF>2&$25GBIU5(tBz<X$^Q=>#Y#wPLb@jSbfc+AsJ@t73yp>-}C#vc+UfYLJR0jc78
zDeMBHz*n5z5Ql~#IukCC!nU>Y3_{*kp^3OQ^jf4<Dd|N9WaB#pa8N^%tDvKQ_hsUa
z7!IprXrlV}|LKNfJ+x38(lL7C7vS+a99SgVyO}~oYi5gVR$4!X#BY@_3578{nQbS&
zk%|vpKY`;_=xfk+B56kp8XpA<YoAj|Yv8ajI#m`%={fVpdlq=t!NE$Bdj%FG61JN6
zBC!|XAV{LK(^zjrk)6cIJf=IAH{npQD>s`0DF9<89F}vik~BC4OT(M#UkaDvEJmMA
zEF`@P-oN0O&C{T*dN5_%YfSJNcW*AFl%zHLFIthl6Qs^%qN|8xIUIWt=?aB|q^lGT
za}ji@49!K|N8#x@oUbnSLm4gMNDK0@zycEPa6^IYs5c74!=+vO5Y_0D5YAY5Z5NLz
zuPdP>7Y;);Z#nq<%XJn8P4FlLsZGfRCfL`17_kVBLt!G=j;;?P=utS-CJ8szA?>a8
z%<OtN@o+;BhXC=IWVb>5893I=%b;(<`D*5DXo|o=G07aI_|!5gzDY_lLZZ_+waln}
zSgSpwM)%tkY>gTN%)LD%7D<9d#&}eb*~{dsttTM#tO(jJx(D7jo3qAUguw<5v(eoG
zrYX<UD+#!dP)g%+6bsX6Rx~Cq%bYrN)Ke>bQE#jFMZK-wWIr3?IdCX85}nREzi?t=
zeLf_pAJuJ=2|6{WR%|xfi~zX1oy|U(rxU%gFBDuRN+KjW#YTUMiT=!-JqyQ5r~PB#
zh)Jix!EBQ@MVVg)mx5Np`PzpG*0o2;O(J3EVm*7QPh9yL^9^9d;m{L!bFe|Wp>4|x
z5u$c(7BZA8`@RHgbX-1@p$;WkkdU+u>kEYL=q-`iJhw<|ExaQeJsS=xIq~7cTA%i>
z5$6$!Q<R8Pl!#N5h+{LD0eS8vm9}GIiO0kfkBQl=iFt_IN7AzsgEV+kp$_F`lmQx5
zfJTw8Kr<kp3&*8B^CNGR=$S&2Bf+sSsS-^*<s7PczG~k9E1nX=Y`rj#b3{wO&7=$9
zP=kTXkuDsdNt);3@XL?TM-o?%f?Y%~!n^A#IA4PFE^p4d5AilhT&sCAynj^cOkyv=
z`<LcYJT>PdB}Jlk^A>!ajiC%fHp;DPjM;Bju=OglTg^6{cQ1xepTsP;AqQ)EaAubK
z2=IqK{}Et5fHUED=ix~eobek=%}fNj{<byqK1ebb4#B)IT_Np0Lc*z)uc$78&`1%?
zC&`ENoa&XE3Hb5J7PtbYv^?EyGd)F$5fldXW{a|X5~bG`?k<R`eaMB}49VMdU)Si_
z7kg{qU<k=*1x?;AhIg>Ath(`8==gAm!1cdNn~y8EUxKYOa0n%7-%k?z8`9)Gs4v}T
z2Vu`590W=BUq)EOHFfTX0OSmxTatX&hFQ?I84i8zR2{)@M129t?fofQz+G*BhZB*v
zp!f)!cnDfZDupDS;DXK~47Eh(s{oSza1w!lpT2|9BoR0jfoO&bFy+L2(x6t(rm*4B
z|12DoHP&AR^Jt=YjFEn66U%7gz?{fpKC`Hm-Busf%Fs8BDvGy84*7*a6az^gW|%j@
ze0R;So_6??rj8m2`+4-UXN$e2R>WiKMLd4Bw3cRUPnfz+c1*E87+{10&>f_HCqlAO
zV37%>8md6CXTi`xa1bO}EU=K@Dom5&kC3#6<K&REox*nVH5GaaMOTDGSHP({=2++M
zRGlw(r|NvUORT=K-Ic)MdFiRTlqyVs>7${rj6^F|8}pc5@P()n+)?jKV@JI&jl|x!
zo=`JdH0IN4rQBApZxkMCLkoRLud*eLa`Pp<%AfQqf6}Y$tj2UJOptvVxB4_r@oC)Z
z*SOWMF|nXvIv$FF-HtsBjgo|Y2au#uK~oyw`kTQ0QWix+Q0L=S6Chzh`v!#F@bXir
zzPN_P2KNqvnwrOGe<_wa;Cuzjm)`U~z(aMDTB(;o(Yg=Sapw|W>lDvO#Nt~L;xU$X
z27_mh`V8PV^Bxjbgyc7HY@Vc#DI6r_hc&?ulky9zz-dNnmjURIaOO%w{4+Qt-Bh;^
zm!LP{#KX1ti{OkTaUVDdB#8I|iKm%Bf~YT$nAcB<X$<L)L<_|b_0~C)<EJXkQ$FHz
z;m|R*V#feJ=*ToLYsO(hvzl>?_Fd3?3=S=J_AtkpiuDXY?ndJo7=WLT!&Vkt$N{-#
z#f@lyFHBIo#Q|TOh`r5lfJW&*q3~Svz!a?11hJ=$xVz7PS1y_ioC)VATKD_>pTX32
zV-w+K`@NB8a{q!eev|GAq}yB4!7jR@JA)SkPx1Mg?vs*^3V##$J)fU%0(6vgRd^?0
zuGFSD%1=9P^7+>Q$9?|wz+B8V^0bp1c#PlJc_T`?5ia1&xEKXKUJ8B2QWW@dDfAg#
zQQ)f3XS|03KP-hl<3o_63Vs5js$vGK;te<`Gy30#?tj6V@*(bsM2w%+%hZgYRruz&
zlqdBt9@^vHdJ{=Jrqab@l3fMhiswGqKM4i@Uk~`<X+B!u+m7ntu{<Vz@}WCCWXFW!
zi;Z$-4wHT<<hLOo94+OX3L4B4X7Jta^B}4MXV)su1j`wqWfu83b8#rFbJLlO2Yie&
zo@x`DUs+n?@VHH#^6Uk2hVua*XVF|NHJssp7^9wvAtx6({EoBX=re+y=X|_Ud=0+3
zwj_r0G2~3YFMMH(aHODfB}Ox&psb=ax&*nx(Zg4^POvFAyF{IU$M0_%@dcHowa9KP
znZ<o$MoKA#Z7>99@y47H?amCuw`8N$bCx>Gl0p*EX4lpf&x<<azujEV$Chl3_Zj84
z|05)U6Qt%lrR^2SE63OI_rNoIe#|*xLM#2D{0?pz8bc0fEhxV?TRY%V=LS;DJ{L0_
zl;7s99qjxFWK?a<(y=&lq&!;fJamTN&A|P`ym@kp7>}sMxtiq#(S^<?g>hn#!_!G~
z=QunbR-Y)&!$;+G%@$`XAZM%3foC+o4a;M1N8^l59wo;k7WF~vvk6(L4$r@Zpd`wp
zN7Zrk4$mbmh?Yl7aLaN&V0DS;oeHdu0OVQc>frMRA{-1qFIruIGtC_yW@-*&=W*id
z(D8AC^l4!{tXSA`eDTQY>f)sik1s!y$AcaV(L)`c+e^T#I6SX_M;GvLMlx}5RiP@E
ze<sT1a@-{AmS&I6E%x>3Nxp(fLuPfpf0-!jzP>7$WAn|MR&zRQr77haUm-5AMavU8
zR1w{VNV;a_$W<OnYW#8nYI|SRA22m~Bcz(2S=zy0$DbisRi`==w0oj@FX@Z2)aQp@
z39PG6$(`k^&$2`{&-PW@-DgxO&r7lgWb$x46gkg(l#?-ec%iOWo|32Gvlx+BNt3`b
zXBF~PX<Lie`34*_Ks7>`r}0JDqj@r+_3-RKIj4^&1`6O=d^!4XD<1o2Fi$C#Hp3Ae
z^`fsT7{K-K(@6&5<^=3vaJ<lShw>U&{TkeL;LU{_2{#7L{H_9yz?t_oxCfoDa8S0~
zC$|RUGpD6|T+A&zW*7f@Oo+Ib+q{>+okN@$n3n>c!u>KI1e%vHcq`4h6!$UlZHQKx
zpm65*2+|q(|B%lAq~F+SULi2)R<*>!9UM1D^1T4_W7%y%#gfN;b>>9?6aFs3SY~FY
zzS+EQ!kZ9w63*;*=WcoKr8hr*!GRmfSy#LVG(YYD=az4?OZ($&_4;fs=pAt8M;X44
zXWo!A{4uyL@e>Z5aPdi(*^b=~i<5k|kd6+)UDxJES#FdzTcgcxX%o({$?en|qnsFW
zv6OXdey{xx;r!eSx0jk-uzdW>6*05z*610BOUMMc?~<E_FzPWsV(v0En@K-M9dUoD
z*>Y;+`ap*JSkL5h*C%&qn(diJp1f>~Tiig|d%UW9PMG;nnjb>pBX8b9vkmiB!R*>J
z@k<bwn->|En;coz{HlTZ$@>)O%w_`&AL7skvpb7V{`q9wY=AJkBFt6^vwy;Dbul|F
z%=QcJisR!Ov#G)C-Z1I6#MsL1O8-;3Mlbbo4};NX^iap`aApI7d4Jx7??o8*3Ye$-
z=0U#M55Td3Wy)vsOv7v^F!2xnKgKuuO}a)eZQ@gY^Dy5$-#3r^jhu^XORG%PhxiDT
zE14`4^HAG7={C=&O}t0Xh-dhD&{Yo?%Ep)iXMSuOd^BpFiW>e?82tHA@Orcj)|Gks
zXC4Wf=Y&R{vV6E_9^Dx}d3;!B9?h9YUIiDar!Gd0r=d9Dg)we$%&<T3C~F=<@%alM
z{g@x09CbS*oDY7?qb(yhyO(;BVjiOyKA)~|-Jj1Kculz@TRlB7PbQ4qy51OT;daCE
z6C38oxLp3{g8$#(%rgKJ&b55bbj&I|7Zx~Xf1R!B(#Z81sr)9~@a2mfeekY(o?3F}
z7{D=?4|~|=&96IT`1K7gfU~Wb-&XLr<Zafw4WFOW;P*1PaLuwcKk~Tn%Dk|zbA81D
z<&J&Yz%h<v-m%NEIN(d4ab!sfX>+aGEc2Q5MWcTU<jk@t<;{=lNnF_Bx(ds{tnKjI
z8BELkD8o4hZ+&@<d0~PYv(2iAStv1!6})C}?BW>8MF!3RIF@kiWZyBrH?>}~Snyr(
zjl79(Zo$9H4kN!6>2a08$QyoDA#V{YM)D9~JTc;|+)mZ%<iOIoID4wbsWP*&<~MzE
zCt0PZ+~vhJF?IHy5mNWO{(A}&!h7Gc!f16(S!IPI$H_?AHkei!kG=~vUNgt!o%rmz
zmDLN1W2my~%G#<?OPwlCReAd-cYSBxhAiRHY1NfWt!lZOH)qQ840zarr1jLdB4>Va
z1tzc+qsyY@rMRild^`2U8MhTYo2$l7?;YQ1Yff=NWp!*aZ+)FI+ynBy&wtx!GUUH|
zt;(scff4$StpbN#%){}aHIu7Q1(TvnVotF+X}U_^H&&UOzA-sDLo<7gnKZ3;=D@5$
zS!huFan8l@BEw-T#%KV9_UK?t04m0R^iH6K_}^F1-T04Q2;K?&zeG^S0ES~hML_H~
z8BPTddJWJUKrMk%oM(dujS3kw)*`N~C^;U4rqEQ2rdu@AqU$UwwP?OY<reW&7o{&|
z(GrW6S+vTcH5T!3G!^$YiyAGu%c6TN+Gx=hiyp9Ot3}%^+HTPfiypV=X^VDRwA-S+
z7QJZED;6EF=naeBw&;*Whb?Nd=wpkHS#;8(Qx<(?5vo|1RnVfaMQIkLTa;l@XN$U6
zlxa~9i+Wkq$D)1~4YX*mMZ+!1wkX%4u@+6RC}Po6i>6yN)1vDvDz#|7MdcP%SroHq
ziABpST4m81i`H3mn?;Ql-DT0e7Hza>i$xDuwAG?*7Hzj^heeND^t44gE!u6-UW;C|
z=oO0&SoDTPZ(DT8qQe$7S@f|*$1FN&(J70*vdC#++n+^Yi_$Dgw<yCRo-L;Oc^8W^
zE$U%WFN^wE)X$=U77ey&xJB6(<yth>q6rp7EShQ&&nr{*&9vw`i%Kn;Z&A5LRTjl8
zT4K>Mi&k0m8z5dHGMt;kCfyA{nA?DN5=dPQ9)n4Pgtre!g&qRBOn7c9Oy2}80a90u
z-vX(t#uq>;M}txg8V1C9TZS_iXb4b>vj7O|BH*n7!b}CIcN&hQ60{x&GbZpJ1H!!$
z&{?gqO;ykhK-q$x2O25pbs)|`Gn@%+Ftrv`3559<cy|Eh33>x)w4hIc#t0gPMFnN^
zhd{hiW;i|5P0j}ashn2<jg!z2mItm9bPdpWLB9i<Am~p(69s*0L%*@80?Px+f>s?&
z+%lj^5@Q>X3Vjbqr7;aR^NKeVxA6T%ZXM8MLC10X9uZX32@_R89{}YGI=eG&W(3^>
zG*!^^SeTh6=p!Iy{W?q<REa+Xq;mNpZk!86t|x9ymE35cBH`TxG+ofl^Nf8j0jap3
z0$nYkSK-$48bMD2%@Fhf&`d$|&&LBwpcH2j(6z#Q0%(As3o}hi90H_T;$fgH3BB?H
zQ*RS3Dzs<;kcx2^&}@nE8PG^UQ@UZHP*5$<2tgZxE*A6vkZP090jZo{-5s}-61ogX
z<zrh9+*%9oBOn#G?S*)VExay3D#lcxQsLd$)AX{}fuh3u*F{)_6g09IZtDa+2&CHN
zlR)!@_e^htm{ghY#sOU~XbI2_f;#rWf~KIUKnnyl0*x2652!-WAs}VnHGT0EUU*A^
zRJsR&s)Uz`;$A3dCXmv%9!QnYeLyP47NBa8dj+UQ&__V3m8`u4w?D#r2&h)jpDa2H
z&3cjWdI2pKbSaQ(e-WT1!g~n_#eg0<8WYiRg02NpJ-IcSjjG?S7G<IlEETyzAk`~s
zfC_~7L!dfACxBEM9R?ZnTcDVPz6ew==s!TpzBZQ`-WZ@|68Z#Ct)Q&SP0i#2p>kmJ
zwLr@S{Sio&+Mj`tG(rypsg~GxunE1)qCATVEV>#<#qBo4q;WBjYJUTORQ>)02+EPh
zpMX{fN*ij@NVh1%qRtj|u_)7`@jzFLmY)Ny6!ag9GSDy<39rDS>w#7YZ@ES7hnt$2
z57bXWw*cKJ=m3z?Qi?)R<KJySs)T+Fa+ApY8fdkkcYqKHxxD)dJPr`FA84ka@+<KH
zB|$d=sZ!ekq<Y2QfNqx1e*;Yyl%8#D9tVW(0L|9`sTNji(S1P36hc!Fr26zgpvl5p
z45Vs$1CX-dK_F$pE+AD~2Y_ZPEu&0ooh-T?NR`IJ7X1qdk&teeTvHztfmCWQ1KlE_
zo%4*oen3jg3?Otq#I3iyEmrO&i;h~kR8)Z~10ET>R^sLYseIfHv`%;jff@vT1f*gF
z&^=YFyAfy>LQ|aeK-Y@gKA;-~9RX4?hL1I4Y(5Yw5ti-%Qni&b&eVQ4AQfXE(5)gj
z9!QnsTp-mOKLAoWzXBIk7zTZ{K-q$R2c&Fy8%XJEholth3)B*FDb5HWRnz4_afy3B
z&~1Va0I7VmoM7tXDxjEz)&ePgKLuJZyuVo9r4zB3CA?ywLP4v5R2nIh%p4>IA#LGO
zq)e1mXa?Fo=BtB*-jDwm2>P`}^8<$W6N?%=!^;R7v^ZqYYK#70(XJLI^ks|wV$u5+
z{nMh0!Y0OL7PU+@ylEB{Tg2I+vcBG;yDd6p5kDoR<l0%(&!TLLCRmi++QgV((bX1}
zSyXG$O%{D%(TA7`s&r?yGbq~Lpel<tqB4}+R*T9q4DZU02L0ZmUS}CziAAqiw5XE_
zz00CcE#l!bDz#fI`in*3vrTA*MVDIiqjOB?vlfNUHN1#L%Ps2B#e@#9Xp}`SS@e!Y
z=bdL_^s#8XMJZiP=;aozv}o}8CbZh30~URnX+ry=08|;=YSBFw9kA$<Zbt5?MHhBA
zysIqY8(K==42$Mk^npcldm6d3FEZ#MiypP;_ZAK4W#q1~sL-Nfi^?tfvqifvHgN~_
zG3e(OrS>(v8!Xyr(Px;EsT|G4C0C)CMR!~DQ;YUkv;ng(6=S1Cf3>LoQWJWsMW0&q
zl|`8Y%y`wqqFz8~$Qaj#TQt&!=2<k|hR(9QVvDM6=xvtQXwh9Z^kIu00a7`7!t(Z6
z^Z}3>V~<$$i4Fb6qBgh)D(la)XdsY^JJ_P(HgudtF&nzXqGdMp1<QNMqWw1XD3G%L
zoIxfv?mk!Pb^}sY4Fghg+*+<e7h6<s<$h!lXTB=#a~8d6(NT-OvWQ#2RgA6{4YFt`
zkg_1p@}>eQTWT!&sYSoDXpcolEDBz3;+|vC`9K&F(1v;esniAlbrK$rrdMb@kdm7U
zq~vDX(1jMoZRkCgw-HFieZ=x!u;^tQ`ibRzZBgoAV?jEQ($Wz~S&(T%dHTEx9d3D}
zEU(D&=2=v4(LGk~Vat02NTu<F<-G)?%6`8^hi&Kyi%tQlxZV(BeP<wL-vvM_w2uuP
zZqY~^I>GYtfmFJM7F};ct1K^O(aknA4y01M$MSw=(a(XD=0_~rX+!q_DVzUldG7)#
zeMc<sUqDLB35!Cwv*{#li1$YdoeiYoa=U@z^#)RL`&yI(q|z<4a#4$}w{jI0HCXh0
zi|(}O7ZyDVq%`jaQWm^md2d_Zrxtx-LtA1Jt73Gv=wcwHZ-nJduxN@6od=|Hd4ol~
zr&IdYTXd%l{eeXf+t9}?dIm_9<X+4BGmuK-Rf|5gp{Ib9rLBgWbkDKqd?2OodzLrE
zqA?at08(0(S{~0CQ2DseqDL%x3`oV;V|nje#Lt$gxSv_M)Db2hZ7sS0NXcDfc^6xh
zZA0^bR6Zh>cb!FZfs`$kR<6#5uC%<{E&8Di-DG(WTi&mLl)lGp=*u?rfaSesdEON!
zMjDW^v=flZTNlf_$npkTGy+J~??{U#+t6Z*YAm|Rq6Q!pcfCcMZRjHw?Eq3adIm_@
zchH7@V9`m7LRT8=TLGyU9WC!7i-uX0ZRN&W-VBS%EULF?y+uC-Qu%nuqCG(8%SiJE
zkSfWKEoz@_c;5q3a#vVhE|AhU)}m`{=ygCUMz!VLXwl6!^a0Cz*z%sVygypr0n7Wl
zMNL4e)J|AlXr!^KrA6H=>S+<zOH_V`0Vzu-THZ{H$}L)H(d`!933P$O8NepXd&HvO
z04dG<!oUS0x66jUU_;-wyuSgdGX2n^e*s+}alZsoHm8m<C>=<Jo@;p*0I75@x4dx{
z6<IXjqD2<1vxqA|%9cAU;?_iE0l(9#5VtC-)c$OF+#04r`DjF;HWp<7sTe&iZ;(Yp
zfmDuoK$?ns4UmdaZh3VUtprjrZneB0S@euWyMR=V_E_{bkkZU8M=G^%EDB;xONE{d
zq(b{x)E`KtJKXXnTU2b(Tr0QG@)iLp%{N;fH}I%59<=C}K+5J{Tf{euRJzYuxjz9Z
zeeYP_#}<7Gq+)z!d4W8mIb=~!Af;tEkg{c>Mb}zXZV^}Wl-w#HW$7A=?zN#0TlBa^
zzXwvOy<&N<Ti!R8myTs7l}1M(mB!f?^|qn?EN`GiqitxRMf^6LO1HxDR#>zeNR`zF
zE4S66C#~F0AZ5#Li{7+y$E+M56)5X7EIJ2BS<oFwrIuww2LdV0gDo0wLrW~0Z$ry1
zS`MT%-*4r%THZ63_lD)2u)N?{W9eBIU1ZS^i^f|t+oHu5-D=TBi})!;mCJ3G_eYEN
z*wFo!cgUhIfK-lJj5GGN0a7K@-lB7XR2n^jREcwqR-vI*?h1<{HniBHDvN5Z+)|6~
zv7tW(Qda%S@_3+uN^O@7-3z3wdd-HuVMG66d8aJ;#)fvr+OX1h9*|0{kL3-ss1c~8
zTp{Z4U!l%G9fjA$^0F-tgMgM>VtLCfZ>!~Pv%Eu=ci8frfJq|=q|)tSdA%$z*Yd_%
z-dY%^V*JRWUt6@tq7<ao4lV_M$td00k|o>h;KlEo(|D>GScJEIvPu*u@&8s0VTfpS
zoGn1x;S!u*!PgJo1m{_B8k=!m2PcA6@`TJs;Jnw2^Eo(8mXj6Z-a7STEHA*9OYR}G
zzpT>YSh4oGpkA|36_7Qjrp83@zC(uLDLQUYWL8i#>6f8pLJ08!e3|lMCfn?nsbyIH
zUZ50f(#b~k(X19C6N3)cO!MCmEfWUY3;c2<Kd^A-k1d5iwhS+@2LCmKO#PdxS*_sr
z0{dZlvP`LFVc{M!nfRZSEvH7yV5uH5gPCN~??x?yOhe{RNeN|@R4!N$#p{UpwGkP%
z)#Tr8i1`W}6(~!74tT5?=Xv-t5txv9ACQN)COF3l^-t+(<I9+W=O=N7CUM3kajr|^
zEKcGyCULeUadstf4kmGqBys+e#A)SgudXv2TWZUr6(;Mt49{&Q!@!G^IN3>@NlBcU
zNu25=4xd|@pECAGNu1v#arP#0-bvydPvW%jbqtkO&m>Mx5~nDMb3+nmc@pQIB+m9E
z&I?JLLrI)3k~nQSsOX={MXw~zuq4j(Bu-fpXIT>G&Lqw+k~q&Lao$Pde3QiKz+tah
zE_x(!u1w<0OyVp`;@q0Vxi5+H+awP6N1C51)en<6UnX%{b70m#73;zz&WI#VK@w+P
z5{LW#%ui{)BZ>1s66c8|&Pz$050f}wCvn>GVxoU4_1;OGp-G&=W*odpzo4XQsZpcH
zmg}3zFmO#0=SNALUnX&Wm&AEFiSvFEhlk3UpUPJ|-}OmxE=uAIP2xn7ICGLXi;_6&
zk~o`^IFBZAxOdb1l!dP)asH9S!FP!4Pv<m=^SvZab`qzk8RrK0vPz?KYUj-^o-?O9
zy2$wCWfC1yURDt`{JGV|3#^Clsc4z1+Bp>nsqy*w1qACauIAet*4x~Ni<UFHxT>mr
z>7?2P(dx32k><q;#r1jlZcK43s$c$?jq6=yb#y9H;=A@)CFPYB(X4*X?8>T=%F-y_
z*r<wD$CkohJ-fVeURg=jpi3_wjI=6B6aLGM&HsOwfPM#sZ?sGn`|<8fA`A8n6@GeS
zc7-Y^^_hv;CT8+iIcyM=$|pJe47{H+skVG-w0c2V1qv0jhlS;3vFLztHK>O<cvHqO
zXp(yWCa(eoTUIg8291nW@@ox#NvO@oR}PA65*n#M*u~{#b5S40V8t$oRYT>O0pluS
zQGEU&QTe_|qpPE~4QTenVz!NIqScjFy}WXy-U%`(7DQtzH7k@?jV~-T&+6FX@|X>u
z7=dxIxz^8D_H&TdoZ^xjEOT~rNwg&4n+x--PppWbZ<STn)>y7C5!iz&D7S18o`9FP
znsdfglvEcMm(<oSuzV^QSGq*K<Ylra%!*hc8$vTld6BFZU*hmflF95?=Clg*^&3W3
zl;)!TVo~$K2@~gxVD+sF6R6(rs$3L}olyZwmrWzTw&GiIqB``%=FxQ)@lsVz<$|i>
z>gHKOd(utB-*Uu^aW&&A3StWq858cP=)AJ#Y=0R}z_htpUUI6V=oIS193}v1o@vS%
zh0<J}FR)Fh^feSR5aUc18<a}V+CbZooEj0&=raWvB#X;A>?K(}tqQlsh=|)`V>CW@
zQC5w?Fv=n<Er=nU_hN~*D5Zl^E-0%@6tQ7iHQJzp`Rr(mb1E?vFe&JuiN!ZWi>fh#
z6wkqzYW#uu(Gq-i=FFm#B+O8*yYcJ=(vNLyk&$|a;-xwBqyEBFMKrata#UGjM4~aO
z&6!VR_$@(^vXwR0Kf0{?%pNC=Wh$;yiDHts5n-KqanY}qT`31+USc58hS%T%bVg#u
z{6J7r;i-|yiZU^=!E#1c6qhfpDXW=KSzKzFlFFE9tXYNY>KKhty*#N(*&NSkq$n^M
zA1bSw>y->Om(87n!7{ftA($VniN;tz)ksXg25AZ=ca9pA^NSZ-#o9KsNnC_Sl~>Mb
z7LsV#33f5ZUuoyFXXEwL(y{?IEO$<RRGQ1=YF-g6KT?Y!kkKrM$tvXtYsN)`$X$xL
zOIb<MFp`T!re=L2A2wGmsK860%~a5c=0mPji@YOh$^vzyOv0y(3{Rw(h~*^AguLbI
zk8#Pmn2D<-W9q65b7s#jEnDO-8>JjGpym~rUs)OBmtfcl&S*w?m5HmIuBOq|l?z0X
zwMBdwD@I3SC5fwv%}H~1K0da@>*PpW;aV+16%<#MWmR61DZl;$F6%#F@Z|$88<?3n
z@KUnW|H}q~f#0BkLoOd6=(<)D0$er1XTNu;z0+6|3;5Rw8Mdke-YUY>`0&r@Q*ZiY
zg8J7A$^W)rHkkhP!f%ryZx!4n*xTj*MR7;J8|$#mez4<`{)3ybUc|O@9%K69R>khb
zX*}fy^lK*PLEmR(cs=|X#g?Tk$_>OuJ>PE~7VS<gz-iA~?hb}gZqOi~6h6&@h3!>|
z+cp(Oxy!I=%lCT@cf)<}!Cq~YF@HAQ!Ohb>h<pFz8}S<bnQ}v#=Qk5N_TG=L8f!Tu
zsqE{|4=5&nT<dOvT(ckT>woFxe%=<y^?Sh20fwA^ZIPiFaIfe#K)?JTH?84=!h(if
z{dcZ?tG31Z=&2dk&f3**FuwX@2&{hIS=tu7{yWKC|69fx^2g<$#B0N=KTd1=tLN8e
zq&K|sheIjrgN^ZmUV&F4r(cbCSiL)a?f%$~RdrpR*dx!6>gx30dGx`C&(}YF5#uAh
zg4G{qtlb%F7hiV@jJ5k>EgD{1y~|nJBcA?vKQvdw&X{t&bN$)*4S6S<W}H5K8Y<&?
zC*!le+P7;+BQ0BTpy3sGk@P;Ky*?P&)wq5~PtpGb8=Xz0>y1ltf7<%^GqEoD(AY8V
zM4DPDg-UL(D2<P;TDx!QJ8So^2n~x2T+yk3smH@pn%@0J5`W@s=sdc=;Z<b&5AUa}
zpSj`bcw}(kHP~0s^rXn7!N9qDa=HZYe$(|%ymLX*{VHz%eMf(|KGxGo<iDs8CD5f|
zS3ED=aIhioP&_ZKA@A*YUV6jJ4S9#xz7@Nn;f<z&uo8t7ULQR<<J#G?cC9@fJK1oI
z=^sjoj~^VL_V)VN_NV*ryfyD|e&D4@JnvAXsIVzZ(#&kwgQ$bz10vTuV4e+T+-q2l
zRKh4pt?`Hp_S{DJ9%qS3BJ1%%^@)d3BfH~XettYV9M8_UHT&ud@kGRl6gIu`wUkD~
zo}&+(QJ=wvT}Uxw%9MB{md`@|nHJ57NdZG~BLAyDMs0?#cOy+JA+=98tmfg<!q*4#
zn`VDY_~Yz>4Ijj(h0#vhu6mNTIc@LWDMrrPh4!`j<1qBYo|Jt@&Vz>jJNNBM*xP@n
zY8>%dVHEX+DA9tZFTOf`dQY$iHL>=tKV86<_dd9*cW0WGr`o^t7j%HNpVy|Se(@9y
zI@(dUzlJv(jx{Yts%v-FzMnJX+JVbIIr@6@`bX^tk$OC*%hvX_Z5x2lu#b4Ca1@i+
zGY=^v7?rj9(ATT?rq6B2=@QS$kfJ==y3zlW{HDhzqP(UwU4nSuUY@GF+kQuQc;Ate
z|3UI-rlKzcrJLXMK3My9eOr2v-|d%|^t~xfzmgcLpqkgGO8@)c8ji}Eb!&E4sX$eK
z8S%V~_{4Oy>TrBo+UlL*>zyh2k){Zuqe76wX8lRkH>A+M_Z_)d8|F_R`oho$U3;=4
ztS+iNjS_>>|9okb%J`=9|E=;a<^S|8^630&4S)Q@m*?lxWGIg`Js@J~-%)-_O6;wN
z;D5`{jBg1~E+5HCKWo|<<&!KgS#kdN@*cDP%D+uf{qOW|`7U|(Pg7s@5c;qAPYP#c
zPD^WuL}u-p+o;=rUU+`sh5Lp{(f5{QQS`b!qrau2zpc+fwX{Z9Jg4)X9KPS~po2Z1
z-8G<ws2%G1A){f#2Qo<aQG-OcxW`vsoQAx;H`c4mN$2>)y#)n@Q<|PW#WFF2>aNDQ
zzYjXAp85vTPVHL_d-mkXl6yR-YVFRpx6eV_TlLge3~ak*6g<+~mnszv&#(TbG?p2k
zT#f<w>{TlxPHl&HK^iVfY3Tc_26t$?=0-%pb*wP%MVfLDD_#)0dUig2gR~Bew@-2E
zfXl@N4acNQtv*$<vST5xN#kQv;vMpvS}|fxjDyQJ?b@y#fN|&a#1~_QV#_CANOmxI
zju!u)rHQ0JzgmV_llxXu97j&^!ZJ+fw(XiuP=ws$JNoY-K#zy<JH?#+ZP&a&>1li8
zH{A;nl*XDTz(69ArZ5tT$4`RYuxI*|rZU(N&)W+FS1sv^f+|CP_N-<we|vKH0RiVo
zJ=4(R<>kuihUbq^=c=c~*xI2?WIa<Ia~($GR(ozS^Q3rDIW8WpSjKJF{2bb{8^&C>
zC#Q<~kIZ0<@v+|{RZLFWuKfl4NR*Fek8EaGb~+Wu0N3XonldF4@08#4*ypED|8@Dn
zx$(S%JJQhJ<~HOVcqi}BUl$yBYuYP+U2rg-_ew+FD{tk!^6rs0TE{TSd873b`M(VR
z-}^-viM@N|oi06^%Ap83$3TMdJ{v>e<f<vBi^?(V$pyP{{j@`oNPhhC!lqHplHC2@
zl0*R{rwZHNdx{Ceyd(cXZW`HN^7D%#O&@(GMl?vFA8CiHS>pPMOE1RjxP#fjE|h<5
z1(!84W0je;HPK9dVKjyhCS_h&lUY`g8Ji!?td1_M#W#(jrJ3flNM~Lj3JVH(IrLWV
z>=K#JwfXCvrl?qu*6{rGry~VTm!p9+VA9Ec#u@67(FnHJW4WHnm=K>n;q#pHf~fiZ
zwQcs~aL$X_r*!Xln6on{*pRv>CzJdsQ!v5ljPd^@bmwG1x02JBSv#MU{KhAy#UnvX
zlK0oTm>=)`L(}=SsY9*`u1JaJz7U>;>9d(1V?5GBM=h=j>G9>bDjkkb%UJt)+jU!z
zY<zZb?OScv@NOqQJ~-s1W!FU32S4L}he$zucISp^Zxl34JkS({RWOOus`#`w;u8<V
z<~EE8t{)x1e6jc5KOFKfV_cv6Ck%vdPr--~X&Q(Km;^FTPB7l0!DF=C6PyNhicdI^
zhB2irIvez3lFrN`IPY-7)Dvk9kTSE(xsB)-#~F}kc&Go?f8UYmoSc~Jqtt))1e6}f
zU(To0WGp3q6X)ipB-TF*kK+qZkKd{%{8m!N@4^CBKSuO7n%+I3hlIbNaW^~<&PLXB
z^i;z!xdmCI?pLh*BS!u+BVYbs<yRQ_4~+cqWO=kFOtrK{6HJWPj>Doi-kH_Z)Dlt9
zR^G{L+P90>AD{hQjWovtvHxw<%Nh1d`$)4X`~!+*7+lB{kmrWin;w){nD94zX(r~0
z`HU~UM@-!35JA!_PfpJ#zd|R`lt+0f)8zS`PkxfoFY>I9wEwEVE9A{oPRw}+1)}Rt
zUtgc#J`giW=Zq{*o>uNVQvE6KN2Wbd^&R2)Iy^Z(N9uh?F8$8<D!jc4m)Sq&-<{Po
z0@K2VS*VPRJ$bU}2-EQyGiDu`hK$H~X!>)P_;U2;aKo4JS?TfGjHbJw4HuQ}`QS_p
z7yjXIDFyL`gVER5Pkr*~!14U1pB|GQjJ{+#*MHTQ`z`vew))=8Zz}jseKP;$6x>ch
z(;`!v?nIYW?UUitX#Bn-??Q>bFeloRx*z$L@?g2?^2mdE#{Tb=N5vWWjy`$a-fMB6
zlg8Vl`116oX)pvs6NdCOY2aw}%jMQ~#o+b1_dXpsCHJZlcI4`Rp$+-g4|w~GIxy;*
zT8ggP?(u2q7}Oiyj87Vj>cAb``l<Il9e5$XsWTLC$OA_$aQNq&iSf&ej~Y1ZTkdzn
zeksC<xaVBinzwzbSK@k!arIyQcMh8}aOFSZOS9LWuDv3Dby|F6M#HRQYu{QiF}`$o
z|F;^ZeSEaNF7}*;Z-&h}7VEWoC#G~~*B--VC0>=@5c|PbM-S7i_`>1w+<U${y3x#^
zrhU9;WHxK!=tl@Udi>1(O8fN{XCjLP23;9nn7#J%SS}ZJVwc934qSVB#l`WF!y9HD
z?*BQ~9fH3>(RYYXJB;FrG=2Grlnz)$qlbL6?EU^bO@meTFgI&IUy;>+e?#p7s5shk
z)Uas>V(01{9FI>A(&#1WqZ*cN`U*j{AH-)J)<z#$!YfDgB(7XiWE?NW+AbXbaEUC)
zz46PM-W#XX_Kg=B*dg9QX5mB5iuE(L2;;^tWi98>(IbBE^F~JOEf}~xFsyK3?eqO`
zwO+Ba|7k2_6buf0nIA7?cM5#DdQWbCQwW(x*F>wx9+ER~<y%;zx?8pHM0;@KxYj#o
zls76O>6eK)9Df1Fw*g48zT<y!p5yEs+3SXiNr85O3&R~!z3{o=c7gVRbSyWzJ)G3k
zE5O38!LuAMJT!G!D!;xQ>=5w6sUdhn0eC~LRaj_ThryUMrNG;UVanU0EtKGEu_TP#
z5}I@{zMBh8ZBkQ>rc_aEy=gri#%SF!a8cU04os>|NH}eIhm_s{iiTs`V>^a3w7oVG
zDdT$%R#z&+GPIGffkt-JMr!X_)(#Qwq-_*~J14T2n%X)wEtT=lM&e;6eoi2uOgr}i
zn05(r+ND!KawMA0OC*c07bg<MK4>i_MVOgL1N*GA0#~L<X@{8aOi|P=<SRCu4Wq)D
z(H>SjH6ebX7MC3Kgol+U<#JILDvzFv(v;?2sp!<b6WnnfSpV56EVb_?QgzWFE>0+-
zw~x<@GU=PJilJFPFG4RlFVJ5!PfxuXt+QXq>ED53{ZrBM+QWoP2Wrj$U!sUOFkxE4
zutCi;od~#0M@Giwi)-2l?ZqqQl6fhXAqfu+8A=251JhDqpcMJARCw@d9I*?AjPT_E
z^?U_$fN!g1>3pdY%a(jWdZgdNgngrQnQ4P^5}7kKo!d&+7QVff8elDqwyLB-B$SQu
znJn#SY%AE*4uv^Rl`3OjMf>pu7{8K)iU}wL+Z`t+JS@CPJ}(MlvN4PaMEpt1hki{H
z>w>b$_a|l=6#DF5JY?a;nGcBY`PIxE{r%NI)+II7C6}0IP$f=u=p_r5R^gMbHJ7L-
z&wU5rL#>xdR6a@K&kdxM%*P{LPd}S>yoXD{4jS)-fcw`#E3~yxRUy8i>%JM7g?(FY
zcPCVV^F-XY0yPM8y9YzX^u8VVpf|nY6z(Q>-_fCIp~RPK-FG!JJru33&cPNY$9+$;
zGRT@(Tyult9@4DNq2k(DC7!A;z#b0w{lKHJ+wI;Zgy;KJYG;(={!Mew3#kX|ql@vW
z-crZ?yXJQdRbadQNa$HqT;jNg0~5u_^FtNtxuN@kPAoH2l{>dQ#`9Ag_rn0ce&%-X
zkrHJ&eH6G_lI|6%sxGUno)lfIwxzgDI-nm?$M!47J)*S@PT|Uh`w#6Mj^rw1#pUX8
zrsE#f{OpkWY_a=s;HcP@8!F?575CG?eDRMBRpc#+MJwdn#qMz(ZEC34$2}4FJtn+v
z_vxr6JcD%HlYvhq^2`t(#g{FLlAD8v#qMW1{&k@xc=TTa(a!_n?=fy^s7g2^tLHiH
z7lAsd*!iI)*q<dYRJf-CJw&iPRHb<$`fn{-6~b4WSx>_KQgdUWC5me|6uJKi@PJac
z`;t(VeR|3?ztT~bg|OvEJylIa`Z^H8mBQ=3DiEqt8$cwPZzPV_eN7;=M6nZ5P6w_-
zI$rm62xFa2ibhM>E*$qp;osJbkMnlifP24$G$N5i3`xj!Ss-5byAXu^RF3PpDJXKU
z`@Mmbw^+|X_a+h87zpVvJX2#xbGHOSwf!BprOOj+z3vYnX*9_Bj+^SfDoJjGUUDR{
z);h865JOSRH<=wb-DSCX-FHCLa7DbG7JobtYW4|dx4p~m>2-fP5GvMR&2~GwE!&f~
z6Iu$<0UY-%ca9i!08)i&KZx7OEySmuyzXy6rQvnf+TMnod_LPfN9#HS4$F(D4!P%Q
z=E*>4j_=eWw~PA>dJw9^75>z+1<^`uRB+GJYVUG6h;Z)?dr?>Sb;<0#Zm1M}l3O~E
z12oreF2?|``(D=!TKd>5@A<B5vf&VRNY2ZYf7~9SM>ccZmbWKYq*^4TYSFdkRbWla
zCvMK-^7e7?bA#xUF{ec^9AqVjgA-BXEyv)W*UjZ8n_CeFz3%RB;R)fZ;OamwuZQ~q
z27L^dPO91b<2$cwpcj+yl(VR*R?2}x>yn)EO6)B37P%={9p&h{1p6;a9dEIFu`t4+
zC9(<0@s_wn!bxLy#(Ew1IC@LnYGI~_mJ}?-C)T|>cfBw&LQ6(tY?KWjUcLK>Fgu5q
z$o?&FnU?B;uB7&FdCN5`6E<;Q61T!sV^@WWutM9{L#gFA+p8<f9dD(}E!=MRUPvD&
zK~+|(1XpSCJ|TP<eNkBn_gi8J!oHfa8q|4><K3tw`k{!AqTte4oULWVa-gvd{~>6d
z)B!)@tHM|)64r)&v<=&Qn``k8qG<?HLVQM`garA83K7&c9PDppS$s-XtC?kkSdc1+
z8ju3Nd#h5|YJ-Rn#K_^`omPOQl87tDB76t9Eq5b=x5YgKoK75Qxq_Vb-f?hR5s&pc
zc)a$i#**PNc{Y}sy2&-HRLAS6dBM<vC6VITeC}4pO^4=&Q_jIP+3O@q-0o>9E9vd*
zl|ZN4JsqP@Rh4Yi@y_<t*pJpS8DE@tymP#JMW}NM?_Iqv-s9p$I~iG0!kt3id76cG
zf?YjRadB3OclF*7QMM550ZmwSzW22Rpo!#`t5h<*&aG$)n@2f@*h<VwF7O5luOE2@
zOBbNOc~gZmkR07lx_jK@?RFoGev;U}<n_>r4@WaBk4CE;??Ufp5zIz&uC1=d4ndAW
zj@Q%sweWLM9emdy94v!%Y3${yYVUxz4NJcbi_2Gs41hQ*BOI)NN6E8*eDb=faO=DZ
zXQ`-g2DRa!g809;;Vhgp;v1oNMTj-T;z|f1z6VCT081=ccUN#*%f*uAr^2PTFhhtt
zRN}H66JcOqBhhFiOD>@nK?`lrPiznof*t~K!@<(ZTJDkz2XBMFWec{QYr?yL(}@G^
z&5)>09`wAH?;)%McB?tL!6h}A0%z1Z!DZq8tXn6e+6gWf#ofahrE{F%iacDQ&~h{C
zoZw29pxZqoqrwTUqP1@K&K)@i4c@q3%@{M}w8G#`Y696cBZ_e`xLWzn?|3yu*Kmg6
zcF)YHE0~Xy6rAANo|1GAr{yMO%S&sy5;mPhJU#gG2f!VNGTtkX$VAcU*aIQKS9gdn
zm{H>d_n$2|oFV5#1Yg@J-U%6HHL86F4=7tB88Y2)f`3tS&Z&+qn={W_^qy)>GsD4D
z{BIZNg#T(FX~}x@O47T7(~3CFYte2tJSkIPq!(_-&p>m)sL02eeqPIVD(RriUc6TA
zR0)QimRZzOntlWI5clz(N}t^tm$eEE@HH`Y=A!pZx{B}c%Aa8GO8;1r35F`<Bnq67
z;qBI<;ZU*V?M*)}a%ukP)8s@(@1^up5|$n+D_w%k!H)N`){sFCx3YV$q$_(nV{RWU
zom$Dgk=QCOVXtcGE+K5ljaHAs*6NBHyi9-#=zblP8NySnvIV$WV#hA_#d@!$tEPpz
zzLoiprt?eRt%!qOr*^k8|LX7(uXDSZ((urvD=9iR{T_-EN4y2;T@a|o=n9<}FX*z-
z+VLvW=SW;!(P2~tk4f~ZH4hi{QLsvFIrnPQSBoSr?73w%B}RBr`VWPjp0a_px>$Sd
zP`xC5r-b98t_R1Z=?8^_(HfTtTx>BNNKccy1&r3Rfzw;2WiU*0horY$`!PCWTE~M#
zycOw}N*s*N>c+=gnLbfC7@O71+woSVR|^Y+v)b6}-KY)3(5$8+H)#e2WqnuYt=24z
z%4Xj0cxyB>mu6R#a=yuDk&d@EeYd1BmXjiNm1#(SPgoQ5=*oeijr>c@2gZ}fIc*zx
zWiT9^hWZKzr+|~jAut?dt%if_P~jjeQH|8g8HGV@h!Dgs6%Nj~0;~@a0Jp(%cNlIP
zA_P4Ng2-qo;oxQ~#;R$<AaI|zT)r_aTs4)EOAdQm8+nyF9OR8hIJggkWjOe@jn&7-
z62u4y=P()$wnv!C59>_n){~UMHi&hnvT74+qlF5r(8lIMVw>=I1B#UH2MGta;(t52
zCv9VmG1jwAFl~Z_vWRu3lGT@@7r;nNmwDPK4!^WROq%!m^hp>WQocZX-m|ukRpR=-
zQ$jdl#^J8K^mu>JoKUEYF9A)SI~RMo9q*4iS{V0yVLShqm5?)1mLX)$QYY*^m%hm+
z`@BsS<1;4MdrZRLZMZ&fHthXLhR9HH^}I#8ufJ%uRdSib`?J*+4t{{bK)XT8;ULow
z2ZOkMOXGm#$+@$kjvc}1AUGqGc{4m2H{f*=9FJ7vgf5tfQsULK1TQmSPqP#1rZ@p`
zYH?2!>aND|V8;Ad4R_LqdMHLXW3Ie15W4Uzxq_xazzOy4BA#^l7=;r$YXg$w-HVeE
zy7UN>=2D9j8ld7h8C87Y&Uk|vcyXiH2@PZuz$#G&4-;}igOoQdqe6LA`sq#wo}e2J
z^`tIi?L{gO{`olj*9rAf2?bFu%y~FSBix|6yR#L`n>XCU*?U6QZBfHZd}cF=_I%6B
zO_SxW_B@x@Z5_A-mbT~Fyl$Joa%Mf)qIn#i*Xy<o@F?H*JhRtL5B!XBZb+rTq}$^V
zU$<R=t+wS_4BKwMz&^;dB2IJr2U=op11HFslDL-!y28inbd}uO573JuxS;YdC&wMA
z7jVM5`%pY_--8mMw)XmzSjWu|41_<``1`o~J%0N)REqayN@D7k`ZZ6@gB*05C=Zds
zt7^EII__U|Kp<4(<Gyb0Gg7W)X5R4b>qCpfp$Z*WUo+glYC*ZkV@d6OZ;ME#b1EU1
z758siB*U<<j~=gFx_{SvT;FkzQM;hFycqY9SiIBxE@lbhWA8!HnHj231^9`U=%E-|
z-#<0Cm($)ZR7?#_MoFX^e}?-L_gOIH#>l;27H(J%oGH3Ll~o6hEHaODAJF~~R-<rB
z?6^OZH5it{lAHxqj{BfH;9{0aS_<cu?nADcT&7F<yrR0(0x#+0>CJFgy5;CeD)m)1
zby<<bij~_^)CEIzd?(6rZ_*OsP#rVixT`fIEmTpdUbu7DXd^L^!dsSQ3)sEfwVK&3
zg?qW&n_V>?w1>>tveHuA@44%=NC&4qS9J>mi(yzQU}yKH0DHbNa&<t>!O&Dkp?|Fj
z?8iC>i>RzZuOhA0E3n~EP4V1lZ0YRs=%OfWy;<{Ha?K0v>=xa~G1=inPIy?g!<82E
z`;=K6!WsfId()fYwAZiTxJ7}suq9P{OWhv?j=>+QDVZN#P>f4P<qc&hsC#vPaYC^<
z<uXdTKMZgQOe`&3qFDE7R_732)SRbyKhnHDXlqh*8#N<4gcH*i%G%kF19QZzsUfbB
zn)Bh@O*(_qRqNTTy;rMs@ht&$Q*uqHq!`A|mT}kpi8gd*2zNK`PXp@q<~pZ6&vJI$
z>4C4ATk+(&=Lh>?8#~t39XB(md#|d{3uJN1?H*8RbqlJrT(zRfT&sJGV5n+BbS~<x
zM^H7bFqUJ>=3&USoHU4FX~uCc45}`k9*R}oz!q{*@cIj+HbOOc$;okhX@3`7X63@`
z_Lh5ME}wtF>N8#}pPQk`y*Ri{x^ACP8F-G{M@Q)wDicGlszgIl+WP9CfhqIYXtRQO
z(i;Y2$(k#e{er3%u*N<%s`4;E$H;bC?xz7)2Zp1-S`nwa(}Ho9UWF>zLM`f~@HG>+
zNPE$a^Yoj0?sUz=EsW#N4rca+9B#DQt9Efs;9jUp6;Bs;ls6Brz=W#!Vv*zKc*-;|
zIM-IpTyKi)&6SRu=jod-B{LPQ(OLq%8Qt4)$LR4ZT^3p$cf8jq8gNHcgEQLk+=MIJ
z6ZCl9IaDj}Na7x2uH#PB+_OWa^3JQ`PSV_S&|NWt;i(5@Cu{Dx$Q!OlJpSFC5m<~2
zr5b;xJHs7uE{jhtP&3^h@_L7XvJCHE&c)l)jyp>aAg<h<nE}?lR<k|TG-qosS|Z0#
zS$uM@GvlZ%SGmQmy1C}aAlJt^E@zlru)@tA)^yww&A=^?eH+j%bx(YcQk~UE6?OkD
z-Y!mieUQC7GcW;pNY&mncVTcH^MvZH4f04DW~gEu%5;%w4ytu5HZ1|FI5kCP1NVp~
z@%3{b@@~W1NGjc}x?-UUg&?E;!@45z#LOJh=>FW}G7_&H#bvm;%43)Ng||&A7=2Lp
zfo-}ap%dcOc*p&v)|3&dtWe7d?jyGT`P59?_bXfdyi(v@bI0AT?dqZm`Pbf+l2)b~
zY9IB~P}?KrWA=yNc=t$XuTZhR)a>wh4~3OFr#;3+ewF~8BCrwJPBs1vceU61JQOI$
zvNfI>%k;H$tu}}kijry>S#Q=XTu#x3%9f0)$y-=kjCOyE4oJb(Tu#Mw*XeABm30l;
zIyJ{Yj9a~pVlJ+<=8?yBfx$2(ReRIj1@6u8%eshL;p%k}Rb!PdZ$fx!P*<iZ+Z=hn
z?Jm@paddrsW~N&bxSPtgcdXkdbm{rXcU7JmI{Svy(5c4itdJV3k@Xtf)?=cD6#(}V
z&BaYh4OZAI%lY1-+fQ>-z?Jc_zh<=HG_5ADYCamlrJ5JUgsz6~i7qxvEbagu)KXm+
z28PsyzE!BIpc;L2P^c8EI~c`6RYmioc=6o5ETk?3>1tkgxwbqbR5iAE5kH9F4%QN#
zLsd4JAzG{pA4=iLsN)U|snI!8wXR{>+e2Sp7I4AE9j>{!Ap9TZzCAvw;tczo-IH*D
zK!U7_h!O-86hZ=sAPMBoHINVz5JfH$Ajl<<T?8Z$Sb{8TXb^90y;oaXwT;zUDqaF8
z0YwXnmMXSUv2KcOQ7Ix?^F7bZoY}Jp)_&h#-~Mv)zVpmG@7(9i{Y)$ui@O<0`2Z-F
z!!*w*1>udLght270l?6>a!1I4hR4mBH*W>!l4a6l#w`*NOh;a=xJl;5JTn`a)6p@f
zdUjaV%&ny&N$#{%QzonWUCM}cDZ}%KHC1S{jPq1|oNsQUE@>+Cob~XPC`-{dy89+u
z?{C%84l2E9&Hv*WA<C$YHdB=U@00*CL)F?AkF1kUZO1y6sB=E~1~k1gjnO~mbe_kf
ztdR@Ol?EQKcY>_ecozv@EcH_9Bl?V@C5Tfk0kT0X@ED$UUResz>zRkivBgd@cThg0
z#$hgN-sGi=(U(k6wG+9)@`#CBPbURk9k-BId#FxlXN3-nyO}o~@J*AbpliemKW=}(
z&`CkVp{}%ig<rG)=P7UmKxZF7SA|`RrM6|LDn9Qt5z}-vN9Q@;%PAXA@65QRvet`N
zm9rF*i<Zm<U#Ob1v9kHQNHu>Gk<+rbv(Q|HtnDaGw&!K<?_rEvV|W_8zZL!(-R7-E
zFKD-yLqyB$iT0x#%zLD{C)*RFeKH%6Mdn_(?LdBjCn>(_GALpvu1mZc*kaD|CXqhp
zDFiJMbJXy3jhESJ%Mx&Yyet6;aehoCU{b?#VZ7{=VJ%11=x*^cFHv9F)sc1JqIlUN
zp{O`7!;9l5iNdXFY>)VAVML7;_jGtJQ2<6yx^&%a)*|p79rFOs;kdcz|Hp|bInP^h
z&e*^&dvI?nz!K3tqMI%MidlXXn|GYXN`xJ0_pYk?s1fqjiOnZ}ij%>__z_E6Ds%oE
zr@Ept_uh+>FE3VvIdh$%!utwMj>F-Fidl<Aul87+il%I*K8Ta)+t2XI^WgFQmmxwI
zNrQP|8uBdu%8h`M$eI@}BQRhGfD6c`#t+>C-nX<MfMe`N{M9N)eRGt$VYFsZ=+1!>
zpNlW!GyulzOgXRExzX;D<KQj97n;^3=8-FqsCbK7m#Pr~-Yw{8tu(Bj<{H@~iSTP9
z#^IAI3@cd;C(whOTp>rnRxgF27fF%J%x!}iA`HGK&Y6pWnblhfpji=!a@R+}7<DVb
zzNYN5B*)DW^Ay(Q=AA-UAJN23;?kpag((+2`l0(1Sb-@7!|JCrp>?Uq!KbIK{^n1F
zyHxBmz&<4FN+mE9dl6{9O6frBzD588OxgKJk6U)L00t@-*hnKb;8-aN$VKHxlVlB2
z=CRlWL3657IT69aD^uKZW2GsfLOCYO!6Jh-SYcD+u)>N?jy1&mJdFu9Jq~r0cNJi_
z0<M}s1-6`NnRzi*xn&jD<Y8T{6fKOgG^}Cf&qd@H$5mi8>KY|g5r_A)HC&neae<}f
zICaC_JJtv}35BgQ=<zRGktOHEt!tI+S`NLj_$r6r)<^-1Ju@rH{DBp?8HP9dSn1}I
z@K$V^k+=$GhLVq9(+Bz?vfdfiC<T9pT^?&(_-K(6-rgtW4j3y_%m;XTW8+5!!~%=`
z#b}nSERo#a-e=6XvQ-s}Ic;ZUivh8>_qS#oCh~A?7GgIUc#guc+h@*POgW(+WaTRC
zJK-MFR>1NU)?&utVkfZ|f@|RU^7HIgzOt_NAVGM|h}@82SYwn0HX5{`Z)=TJQQL&+
zIy9qlIoKK}wsgszDt^pIh%IT>cqLnh{(!9F)&z44D{gOWU0GVZ9Q9|Sl6l1ww?+U3
zDoyr#(C(FClL@jw-c4gzMN0Uf$GC7RLesAIUs2aDAe&_UflG&Seerp<zUW)Zi4kj;
zY*#EFY97rm&l6?RHoPp|?fP&LwTIPi$m39ONx9K(DCIAyFxrWE)=SnH?S`>!zNBIt
zra0SOBgBwj=xw(f&h^_%xv1H01U<c!E1K=D<%;Gda)q+pNX{NyBGxn8rL%fpBA3P5
zW$=xA>Bn?1Y9Da4YTPkrTO1AB7Mn5K;?$#UF=|*8#(1GC+c`8vzIIn}Q=U&=YG$+>
zpr$l@6+^{*Tf2dB&z>n3b=###YmcwuYNOpCY4G|g(u{VgPU2JyHrl001Lm2B80`j2
zLjqJ9?MC-O5HN`3{ztX>M@;_P7N@st(J6Em0(gCt7~>>({$X<aR$Muz!aV;Jx#!_9
zvFw(qVnp^Y1zBQ)li@ijN*l&?Mo-%l@8RCa<Z|5GghjX&feIFGPdm}^OU9HPhQP>3
zkL}??B!a-nKqQ;kjlfqz7qLxG&h&DO0?V(Uu#4D~7lk{QA<<#i83SIqzQRpoa*5cs
zt_0sjY>SId8OtpVRN0w(o!~Z8NO6;#l;Y?ux)cS0`9gqu<ys4fleo5Z8?2=7+}(Cg
zzl4V>B9B9;J0tul81Ygx5ljx@#qtq+q(yfQVA!D%5)3Hk`=mFVY;}1P-QuGHln8s<
z;`A=I4`H~D<pPY_Y>OQ*Tg(R87RRd{+3FR{sW5EMSTV&CS1zY)#;NWv`hAcvJmXcz
znJW)7g>n|d?yMagxa%OYM`&9+0VQz$-<gQV^yFepr@rSMg()!6Rl#OjJyqmPq8(G7
zT5=NY17*apfivx8*gh*K75<_u65`6)26+Ce%;*WqDXu2fsrN+#FrU*YNuE!|?7brw
zQF2B+8v#$VS2jHut_r<>j|Lz*dOhKIj(BoX(zad{>A{%URv)fDIGxW~xHxMGmOQQ#
zGiZ*dGt>m68a!Pu_SkU<&P4|?&NMtXs7X#lT@Hq4DxiJbJY0xqcy3f?_NIOdpViEc
z^wIXL5R*D`bXKW6Kt<*vhu@jtfy>J=^K)Kyxqpe+guKCGWpYM~Qq=&@-4=VHacekV
zHJ3L4dhT%)O8xih2&~CkTs{XK*B>hcQ>^He8lIo1`N{;@mH(-l&J^?X%PP3m!M5Q(
z6(wKXBFu!!b%*;Ec79yBGdKBw3O@(s=r}*9QWG8El1edZe@Fxv8(Yx(Sj=X|@H}kI
z7IR#E5NFQib+3St^8vctauTCEn@sjG1?qw9Q8Yxh#o>=vbRZ9+xO=mgp)6Zhuy}V>
zfvT{E|1%Zsd4<#O8$lx)OCQ@#>sr-HpI?R=ZH<&Wt8KA%C^r{a=@P@{9^7`wH-1K)
z=<9a#typ$T`MhzJxQwbC@F)pi<eTG{H=J3cCDPr8NfNmmOsUM278m=LVka6f^h_ku
zBkHlznk_9Z@l{lo1?DY7o?$K7%8}@$zIkfGRo&%h<w}d5*w>>(^CXfCM2_dJe2Mh(
z&0V%208mbRS!3kO>oVUGaWCLhIh3=;%INp;ab?9CCl^)*od0_!*LazDsXn<~&zc}d
zT0?#19OPRQrPJX)%p@pJ3giS{=J|X(Ta);9_Vmv6sTnnEvQ#+MS6Q|^M=T0kg;L2x
zpLn@DnOMY~3ZC9m&o4sbU`>$|XVZOR5rh4j0Jc0`CzajctC+KTF|KhFTR*KC5}oav
zBUZ1h>raW|FwZwfO)pqCNMxaJj>wvsGRTWj+HMhLZaHeA*9pk1`%oBq*w$)p&_W-_
zTEp;OQo-qJ>sGc|@?|j$)}rk8G`ga%Bxaax>jie0e6sWOqFj46&gafX>m|A5gb^BD
z`W@H!^un*1a*_2wE+E^@YJQ(emKHBwh79_<j2=q2+?H#dkbvbY7aMo2&!pKtpL;N^
zf6y&v-h6YU^M8IQ%t?qW{p`-jaG;?oqgM_-zWNWKu7Xdn&Sanm?^~LO9k<ByuO0s@
zR3$hoeXx9T0B?OG%{Esb#lXd|+L;AVfz?lG?q=CyG$>9xSnbuJ219m}JE)Eg*70Om
zI;w$C0)o65d0|`Z3fk5~P-$Cdk-2DBz>5~-1u!Bi-3$ys<^8LC|6x8Hgqsk|i#);y
z^J|D+_7kKL5c0h%N|zXBcMlsOsQi5gob1vnxS7CFaG6qY?GQ)7WiAE1r2-6NmG5H5
z;ViX3(Y(cEpUcFpdq!V0dxm)nci0%M#nA?%$81)K4FcvpTDt0-(xSaKx5;?DqJ_5!
z;b<i0mgAycwn&EgBd-+hGSrE~kGxET%gbrUEbfhgp;;%{3d7v)73tDS8Lq&@=o`HQ
zCvEmAy;HT`eL`<<sA!ZbuDD5TP{VkdeIN6X*EF|5`f|b3lYYGy8Rik?Gn#($9WUn&
zaOh2Dq!{p<&wEVK-vYjXmiQH1jT3MpM|X(~xdGT!lMM3((ebULNv`aeFM4J|_Mboo
zpy?Lvg!z)37u{|Q#6Z<B8$48>fbuaALD(&FwG5_|rG~jjh?<3iSlrN+G%&m{%zd8J
zCYXN=p)>~^{27qn1HrG82rxbF%o2<;#sI5GvCm@;@`&+k1uXaDc?a&k)NvXl;?x(%
zv93ZU4H7}ffoY&9x2Yn4b71a`0#|96X+mIN#blg&Fb8|+<9gVp-44Z1;7MUY5WZgP
zp(k-(UZI8<bHvntCB{l6OIctHbC}H2L$G85+z&0|hanV5mSG}GKLo-s4HJ3BPbeTv
zm{2jV@zUF?0T}(MYbrPFm=mPF3h259F2}<98|afcH&GOq7l2V?fzbF3Ojl+>i8;y3
zOc`Vu#t^=r%*n#uv)vfNoeyTAS2U{ItpV6bAum=oi<F4XY%CVxy$SAB2&ak=K0<)y
zy+jB%z-SDWg-u?$$zxsttXr7VJZ2`sJRi>ms3bYpIN_cqa%U1S`g5bmjm0n-n2(8R
z2so94y*uV6Q5tw>K@iVYh*m?{FwrJ#V#P(Q&gs}Nt4&S?^E!i{;dv8IcWI~9ZJlB!
zM9gHE7mGSy4>yPKoQE?FEp#Vp%*Cwz@bVgjz6WbztoQSs%TLYzLJ1Xoif25Ol;EO5
zsiePBGMs67C0miSzd-0?Ji}KSW{PM+T#;JA+fEHLOQ<{vsVkAw{2W2OR+*(#j-bkH
zs(cIfX$A!Q;u!(8`Bcjj8t(MEiMPkjVxdF76xE?v_>l@HWq2%<qGcnTU>7@npu|n3
z7h_>9JS?Fp0MoT>D2Kx(f98y#aGRO|=popR>;^2IUpi)*85wMV3n6+P9`pLt&tYtU
z*eHHwInA*c{0&TR10Ea?hw7sPt;@<>Ug&Dhmn8+-p2l+)Zk}V%MM;^jvYXkqfR!ya
z+vK}v?rJ~oiZ_>wBxrz+xABa(aqpzov%GDwak*uA^$XWcaQP*kZE&4>trH5r<9amT
zi3X}q0-m=ZGYK-8{Dk$n!o~e+<{F_l3G%)0a5woDt#^&q%lBm}?9=f~g3QmUH~c+%
zWfjBGMDsS0beV8ejAt_(exjA%<|uES>e4xS;pSH1d^Vg`;&~0u`;2tryw!0&ns4W7
z*w^9djF)>hWHNWEu%T?L>W{*XY06nLPwzG<{X0DQaPbhe@?%EkJp*LT&t7Ag_p+_?
zY`3!U#`!S|qG!83Otf=9k<DC!(MG$|&3MRcfbMtjY=!=2t^XlMKkh$AH{c<$6MehY
zR*{(VHOxoNCg|W?%^v8vHr)y5qmCYg^HI*MsBk{2!udT4S&)8ZCPCe`c;Y)6My*!)
zE0@Y&xuX87?^P+vPraE5Rdeu+hq|}5x_U=lxrk}K)N+oPs;<_vW(9QA;MoQ}7iTyz
zeKuClvtqPzt`w6UtDR;YR6K@fAJi0UH9M7>wh6=HhCYf}4>#}N`3~-$*6v<(yhlR6
z<Vxt5V+usW_ZA4}b+gZGg6=r9lGzEEmmB3ouhFG{zbn-b#OQzR2lTV9{ZZUOaW#C{
z3?KMOTUn$JxqLY6^5Lx*AKv}}A6Ola;+6xn-*{ew5ASFn{_OJMJ(myf$M|sUdwmcs
zond}tRzP(Pp3a>NqvvQR0v|c*(W&8w0L+hM)jvmB;tYbU;D0mgpy)9?`B1h%EBl+H
z43+wCGJNOIBWfS|)HsA{{@tvHmY49XgQnkWO@DVZL0Ft^H|5aqTxC=0^DkRA7puGG
zzsv?`JBH^uX#7fR{Fl<$wv0;mOP4KSFZJJM6P&h3<8&6zhh;kH^l!&`j%xD6rYSSd
z6fL~@90b|Pj}uFYy|K(_#*1Y}G16!!gmTL;LRmH+r|ruiS!CwzfTP|kCSeA}yh@Cm
zFglRNd|~Wews;OEPQ=kVbBrk_q>X&t=1M)wWeAcG;w#XKjp}R|&!RgyM09+Xi-90s
zPoe|3LIh(YBu1v<O*Zf*zM|x-ZzsTk=xzi=_>a=WIII+LI0NGtCdC!-WGq~otIVIm
zkJLh7shG+bSq*UT444XG8e9fuIhe5(U=G90xC}I+^>{YJ)!;jU*28-I!(faw;z<bk
z;2IbY0mpCTPW&6l<KKMEv1K?ZEuyi<&}PLfj$94%r>5BUnhGTucrL<Q=AZCr08;s<
zrju_IoOBzv6jh=;dJx8Z+%&7<?0GyzaJo1fPSvucVgAxlFaR@3=%xKiq#<4iG$X;D
zFnN{)FRzI_25LSf0;@v)Yq4e(g1sx(<}AP|^aYrhL=BKL2IliJ{0#^|H?)t>z`-E~
z0^xsNd%rXr9UTIyUJVpWN9HausJggIj33y=Fl$a=l}w$(QhPEq^CdD3qNzD3AmWvL
zSnDs(!qoxhVMl#IA80h+GPz_Gx7~=xYP(LsS?JhC^?zuZh0uE?TCJC%`&+I1qgJ{<
zc61LAQ%2@-xmkI;J%n>c<|lHW^7e#*v=&oL=BFmrU3?z;MIt;A5uR&co;+V(PGNdH
zN$@#sBZ6=Y&p@%ZXUavTWe^;=RE~1kGBD{j0^{(M6I0RB<jxf_k<vxZgQP<DC_F!g
ztL$8vCtW;FnHtR@awe>&;yDbFg%HW)I2lzgougy+3`e(snGK0`c-nWxJD5_vWFIPh
zpz2FS!=h$%WK&x%X9B9>^eH@9aNZ2(vU-<`aT)v=fX;on7!#vp4n+AjOxz@mnztJA
zu4p={WuLiH#<3oHKfv<{Wb^VI-IZ?Lm9e`0!ua0z>t<JImDJt@&7IJcdVLttY3-}r
z+E>MDUoDIyA>TISP8YDsBU;ELC?1Vx9)!E)J3+5<E3a~tr-)=(Czb`x>j$wj-v>?y
z;xX5GQrVBckAAlGRCL8Q%IIW5d<mZ4Ky-!naiiPEjgF5pBZ9*C={cjLx@Wg}#8g-X
z^!^-A()qa8OzXbQt@}1dw~Wme4|}iir8}%?JFG&EBR0eRAw<I5;z{KYVk~r>BTBMg
zcDqLmw(H^M13cG5Hh+whinqJ{z1{Iw#;MlBLHZ8rZc}cN%<M;O$BHl-vL@)|2N_;~
z?9a6B?QY%MwQf0|bBDMP<kUHpJ3YR8WVJ|w<_tWSa7qeqCRr`+acjRvYZv){uc#I!
zly4JqIn#K*%4n!9$FmNi0j>Iex9a;H)hXq2mhAxnn5Ba_YMKJaH{dZJ@T79U^c?+c
z>#5l0Wq#lhFOCYxZ^Lr{vJKkP545M4@B6^<^xUdg^FES^QwK%AW&kck4IJkr&PQ%#
zAAP^Fd1W^(mI?Bi3|l=^y@_W8)ZL)fedbp8*$=B@_&%56I|OC_#Iqa<pVA6HcPsq-
z916umuWTHb$jP>oP;xQ)2fu`(-s7E!E)|n)s&QPVCd#ZK=olDgg_vr?TU*YwEmyV)
za;9yCnrTaNC9&|;X?<2of0N<o&3Hb9zxQc>SGxUO>G(T<V^Y?Om0me4wMCcg7GZx8
zCRtMOwqGS?@c7P%mQCTYY9}_S$wm0N3(o*J^G$H#yUFeEChadri1c@pmrVttEc~qz
z_Vbj#oBxZyhPgrd%Ja~F#d8ZBErze`o@{XYxuK1p4q_XlId9Yi*I(fI4KzFm4Vj!Y
zLTocRi-Z@~cupIobIRx(Ng!LSdt_MH=ei2dr_gl%L?;FAb%*B1PH1F~|HLcDmnz49
zs%%w`-}ikv?zA@#OMg@0=k<7cUWCED_V*FDzdwuh_tDsr_E@aHKmR^|RU`U@^maD9
z`~{wA@RqyJWi$7L+uJ7`ZwEL7xhK37bu#=(VgCy#U_pCIXE^RZfK&p{K({J$(c#{6
zG8FX)0q<mf9!fUrP(0@j#dA6o7y&v4S>k>#tiDhI*r@|Bnv;+G9C;T!aow@&1FADQ
z{fI)KCmvgcExI%#o6m?>G@r>(@id+csL7b*q*KHl!iW<>CPT9mib5{wOn}P>TZeym
zGjEpuk2KIT9lR2T4Ny6_8qDv(;P<@&!lW!Vt(vE0nl(Ttd!b*!)weoCr=1WD5rc-)
zs%%;e(^pQI2BJ@QMuc|E#Tb7vgzrFGH};jk^?nLvsSM?OSf(Yzi+OlNP&We+L9GYF
zu^wCu#0*P|@a97SMuU%gD3(^@+>>iMxsxS&$`w%9u`33`aIs@DD?E4bh;QYYoh&u2
zJfLFgvRDYQ5IcR$&X$^LPl1eKCMu)Fh$V@=7NuBPD&pL?G~%7<4AN%Jn>!2p8Rv0k
zq@N{5p-Bh|?-UKdk*omyoIqf%-;45MR3N&h`3+_`O#EoTpSaD>Fu3T$PfEczOyG!V
z%W+HnDGO<Yh@8iS5kHD*JM6w+D5d6d3!`KyAvu&;Ozoq4`%;`aeb5l^dE>nme(#ZW
zDc&c|`QD`I-tu(sg(=>O2PTZVcHvi_Oz{3?-TpOp;ozwg?JRHQ^cru66z|G(Z-;d6
z%4Bbc`QB4zU7x874}9rOnC@NSU$y<f!-Gcdx}$8tE^jA0xz5H{PrV(-djlIM3>vv$
z<b<+8yG9Nw*i~P#%DX(>n>gLOYGc5ArpnXb^j|%}9_@X2?ePVu>-_iQ^~WzOO&Mhm
z@^(y_KgydhzQ+yT4*PpwHGkCP?e^18Pxt;iKHYoI>iK!zKg7T5ZCqXFO|a+tN39t(
zwrcyRYcm3wcE*CIKEdC@o_8$RZg*YS)7!pIAb-oq=o$2OOfI)~9ay-%=c)Ol%K~<<
zO^PhEgAfLc=j(;`u0P^=Q$4RK{8YyFf`xWQxqs9hBLe~NSH|<brfnQm;Js^oiuZ&u
z-FxTybnj-fF5+!jS2xb??M;62fVcCzcF^15`CayC`}$A3z2<Mf?o02F*4KHzFw(u-
z*88_Vl6C-Y?eo0t?RU4A4GR4GLGM%Rk9)7TQ@kDPZVNnOUo^ox@A=UsL2t_Q^?&kA
z?CPCkZ~T+@0|O_$y<P0%qcVC9813!s$u+OPBxA;F*QRb?Q1+~UQO1Iah<EXTg#%aG
zeZ2nZ-h}iwGlyr68aV077bjem=1tgG_i0VWr#%C9*O7xB&anTKF*0M-mw(F`H|3`j
z7OwCvO2LI|P<`#_tjh+ZjC$}G|Nm)$cds#i`Y3zy%3ael><P|)e}?z$tq*u_v+5q&
zF7dhy?`a@m>q+mwZ%qMBnPFe&IN7z*o+$Vire}CRhghBUz)ElW{$A6jXFPQ2DoMQU
z{juf^rav%p`<Ejhs>__Z=(-7>-WMFyoVRlS0($|XxTyRRZwEU?2zuK;An3z&i}EwC
zo4n4>tayLpqV05PU(V<Ryglvn>K0BI{EG<#y$hzVw*P!paE5o)7v4+Ky-UCFuBr1T
z+v$C-+*t0NKHfXj?_HHL!S0%2&zm*KTll=aYesGFF<ZP>K7UQtlDb7tJvC^Wx6^p9
ze`D!GCEmo1-j&a14D`02-haX88D%dcCwdJ`$yngQRF#Q0lYwiMTTH`TYbRLN7F2As
zkNUR&Tvlhh#*^JCE<0##_D<}uH)~(ks}RlVSS)z3ua4<>V@lEh<%$i;beFr_ptn3F
zX>tcT+MCs}XfIvBzK@bW1bUYvKc-V0<V#YLiXC}ls*>aKaHAuK@Z<;MHe0vh_AQ2}
zQH7~2B^i#Vy0FX?V@$_!3ZU1y9j{MeypxsQOteLpyY#~U$q26qt|L<c88o9hEykrJ
z<%>k<YHB@o|3wDPulUtNCK;SaQ^a)|mB6gi0`}+_Ykww)RLJX?(@O3n<gRt(az&a=
zNJ%P9NtVGj`oWGrE^l598k2|PMPi8HcZ8kJH^^qWWRVU<G84vj%uPwUfe!Y<J{b>x
zTsQooG~w#t_sKYEVjuw$pw9_ou8M0iJ;9GFfp~{&`!PE0Jz|>$Ww;Xf-*jZc{`<m_
zOa=JO{x334SgRq!vh#gm<r-dJm;LmV<Z&XQyGFy>02z+c9UTR&;@brKD_!<8T{@D1
z^T!3VACloJSTD#r{!C3tl3~Hf&xsFLxXu+8$DT`9=dw>`An@Z7RbNoY4|jZ%DS#iB
znSMwnDgK9LGXIN=6W$8QoGZMJeccb(*TWvkqvJEaRo*nfp1Pd)qM=avYw9}O1eyLW
z8Pp>b*%{QdHw)#!sc&3;xR7;@?JL>>)t=2sNs^7MY|^qjI$`HjeJ8hG6*i}?b3R_T
z2~K-ml#(>lX|d4~I&C|r&0Dq6vz-QaIvZ=zNN05%qZ(@`%$yK+m%BpY2#tCNwyaql
zb4U=zOg#K?lKVYSC%sf0t5T9Yepefv({Yl^gm7lVosKsuwmVOp_QA2wguT!418w0X
zl`f9`Y}jAwvY*~M-C#e^v3I50xD;c8lXOlRbK3WRm2LVTWc$Eh{x~N)2-Ha@w!JAy
z<5P@@qS)y6oHMCE<o^Jn(J(kOI?Sb0r9JdcNHGecFHIe{|3SACUd~Xu+ZNF`xXwu}
z?ATLbNJ7T_P<S1knUHnY8=-SfRHu`l6_C^UiF#AiD!=P~z`p(m><@j9eX@$vN!VZI
zN>}97jeAA+Bl<4oEY}2=j7s}us9Mp4hrQ0L|54sa1I{b;bm>Q*NAyP=d(IkRB&y3(
z>vl}c1-b0qaYzQvALnhpFP=_2!buiPP-}lwJZHFSb5_Uc(I`9Rg3}^-E_ZqCTi&cv
zr&WH6c@9Sw^?QP{chZg%7~38DXul9`nC=(mp*b;z<Kd6f3%>ysbq)Gdm{+DGO^b2j
z5w*WDi%nX(aEUsFME$AbHtJVwA9S`-Lx*`C=d-iv<O|2+FlxV@e4%<1kH_#^q<Afm
zw@KM=@fa8zfwG;W3@Pghane+Uld{iF97O-xgENgn5_Y9bqnH}5kSrT?Is%IS`iCkG
zXbJ@>0hVN_WJ$0k#pr;fkFPK;U141IAkCS05{OlPX2uJY2&)3z<G=n%?M2i+8INfc
zX)7?a^%$uSl2Qa=C%Ig~q%ur}B!vnly$KJbNn}E#J_uI)+Ts8IZ9>r3?@y-xZd(Dj
z%keP7NGm08ld=FZlSu0&ZjtU*IO%?cgNPsX?ZAWRQS^Dq;=lOOb{ig~Gi~YEmE`~3
z?Gq5DBWP~aZVSPQ-y!@zjEC_cJt}#dl%<vNAdM5e-y-F{V0R&;j+1!c1Fd`E0n6p|
zJjudN{3zIr2Vsv2PNCpPJYHkPdYzvc0HzDqy4-S%xEzm2a?nc2+oZn`e847sT;dk#
z*9s?vL*bS*LGS^aG)dv4+@kD`8vR^{2k{|!RItU=d|I;KfwYGs)UQs;y{oFx`A>!5
z6q3gTTT16INtVv(&Yhcpq?;m=p9{fhbn_?4M%@&NRK>qrVY5!y{yznCADn(5oR>x;
zQR*na4>rG+${7MFSV(e4pwmeHgU4fRx9I*N5urkos|7oagh`8JbhKu|n1zSANtz>h
zo3u>u0h^SYuPNhpR{{*GNahJvml10He%lJzF2^HE5NM_3ZPJZ`57?wZiCd(KU+ef^
z2W-2tC*2`=oAeRE2W--xN!%h;yw*_<>}h3Bx>NEt=^q6jut^U|T*sZ}!wMsPTk<w3
zw_da4I$N+A$B%*iP2r^6!|hJXlQ4g-Fw%cZ-X`sj*Aw-Ta-+7}U3-`>#e+QHwrpCv
za+WVR!YB?-qKUbRG=cdo(jk(!NwWkW!1OP+lt|nn<<@O?UF3X6y1>#Nr2RO>bLaJq
zc)Vy4bo&t%PIU>VKIjO$!pn``Qtx)*ztkHIJI&PZs@Lbx;z+q;T>)3i@rd#US}A#(
zbc^5vHff#2Ez)|0lRm9*Cm9=H-mNgwy^^;{-x7SlCVgAt7OCQO*=qv!p|U6aSn@XM
z7lIGiq+d$hB2~QBVW32sco;8IujFmgc7hMsq}&(oE;nMfM`2w+yGq_BO%{B>ChaA0
zi&XKeoHXEUP@1wQ9U^&~^cukjY*OwWcl(_QbC$wLb0lw*P7!>-CM}k@MXGom@7ciS
zD0|YIByW?h5PZNUt(3S$s(7uV8rTM9Pa2fGO?sQ)12!pVo7~~28Jj%?M!G}tHtDm1
z57?yKWlndbiq~n^0BpCiC*3P~oAi+212!pllDqwGg84&*k$x<Bo3uS<fLKdO#ezEg
zCRM!lo3mP7gsk5p?J9YjbcEmoHYvA?({ED6YaN{R%2M{EIg+<YXA3@Hlg^R2MXGqG
z_!yiOTdwR$#qL4$#!0IM9<WKdH{6{DoGsg~Fwz~8w@Duoe848<W^lJV&Z0f7Fw$ov
zZ<8Joe848<W^lSARlJUO6R;1JJ?Y1iw@EF`NHP6Mx#62SNENSja2BqMvM22-d7E^o
z-~%=(w{%knsp7Q`&eCNmd(s@q+obaZAFxTwByN!^UhCj2-g0G6S}A#(v|8{;f6y9<
zqlC#HXZN-%jC6<OZPJGXkMsw9Oyb%dXZ@a580j;Tw@F_Ve848<mTPyuHNd=EVWfK{
zZ<D?+_<&8yjn#BVs(4-3n}B_&>`6bCyiICj#KL?d<?d?gAXU6hFU}-(QTC+WByW>W
z5`4fW<>p4}AmzSi_nVVCh70?=2XjHk;K2)!WU^#Q=Hu}gdHNOF7iQ@y^}(opbjU?}
zs^A-s_R`nrdvlO-@8yt@ij;7sqYOcypUPdPlhbtf-}E}p;csR(M#9(O5q>xdZifP1
zFAx1B+;D9gr6iw9_D#5W8xI5qW6<~;JP>f4GpO_f`lq|XH~oLLuY>08Qaj0uf}Pe8
zdBT{Q#xzF}Cw<dIR-sb_Iz;j|={17Ks|=KTxZOpQlffGlMjDj7P5L{*2W(Pq;C8!v
z2<FG}FkL{N6>KSql#FH_r;vB!p=;8;k{6#?`Bd-$n=~SEi!>4QFf4SWNrLxVq!%ij
zl)JgzAvy$i7O*%Lk=_%@cE*FA7F}K-SrR%_LQd*&y1Ex0>Lcwfd7E^I-~%@4P>EZl
zoGW4&N%Iv>I!@uF+!O8&Bd58G6h>Msd7HEorh%!Cl)J9!j<lD;N%`3n;-uUY?yi{J
zpdAmagR#;W(x=k6thcSJUnT5*f=5Q%dI)Si9%LQ~T_KqqrLMjyH-6KdYu1Gh=vADt
z(lexw_8}EI(nN?*{y>LF-X^_9@F;(v-0$s95l+fyDU38v@-}I)-~%=(H-Wp|ak74n
z!br;`Z<AIDK46n_Te#a@HOw0nMjDj7P5PwZ12!r5gS*|`5A%a~kYprJ2)2}jl0coJ
z#F_u6@z62pGm^JSj|o0tlX6qI+k-b?{v#f!B6(l1r6iPedC&yohj{3i^kd1}qzRY@
zW0@f3zHqk(|ABoA9;hPe2x~M{B$RY{z%_<0c<7k4tK@CcQGyTHq}&_s_JA9{2jFq3
z;xa^*5+lu#yiK}T@By2Yo4(zuX2Q&`kU$j)zjA}Hl2Fp+0oN{;<Dp~HO3B-#j|o0t
zlXB;`+XL?8-iF7esvgFtl^E$WlDA2Z2_6{-%FWzvRd2xjM?6qP^1fh8Nhs;^fNLQi
z;-O>Gk0o!Da^Xr;W>D_vc6)FN_NVbc6-kR=O9i2HwCE+l*hM)e?J9YjG+poko0OZn
z-5v~tc@Q3`A{i;zQW8qKJmAVp79Kh#&5^uKx=`=|o0MC--5zkab_pJrstOpFD>2el
zlDA1if)CiF+_3FdRR{BSg^}JXd7Jc?f)CiF+?(xoR}b^k3M1Vqd7Jcr-~%=(H(|To
z9fJ9=!bp!w-X?7pe848<UTe3zlQ4g-Fw!q2Z<Ah-NZEi*%B|IIcU%zar7+UolDA10
z2|i$xa%;5PT{_IX+s>WDF!H1r#Yih9Z<C5Uau5Vk?sj&ox*g^x@wilR8ELl?Bi$=`
zoAfV&$7B&Gw=la^ae3)Og^_+Nd7Jbff)CiF+_>y^$F&dcIU+{tmAp-Qx!?mfDYq%R
z-Ek=@O<|-%ByW?J3O-<ya+|T+9hax(D2((b$=jrx1s||UZ<Dx1`iR0wxqsNL?^c+3
zG|iQST*-P`iIMUk8l2dqrvx9cNx2Ewt*Q~`Pw}`^acRcHLow1g$=jq!f)CiF-1O^K
z#Rafl3M1_;d7E^k-~%>kro=5$?)Y{0GN!;>F0j-GmxJDl2OWkVgZxagPl8BS(eC|p
zV00z>A3n#S*QoG4=r|Py$FUN0UaAdnyBiN<L;9-ZZBia!V+cvPRhKfPOBGJaUBd2^
z_z3R46gpBL><l{}9#^lOTY(92G|~f9I^XVuMqopQed>c(gJ$5ttouZe>5_FsFNcwm
zDn1mx7LSN4#Y-H6<KQ&Bjsw^Zy|}^b#W@ySQCyCP(IBmqyiNKG!DGb&^l^z>q^~QS
z^pL_yx$)SYsqX>%NZ6-7=z$&2(YeYS7bCj}C+HA>o-cWuw5Q+$HfgfN^>A4Zc^QF&
zlku{+27x};g(kecq^*UxnZ$vei%59uh=b{iMR<#d1Il|rcnOGuw7SlNcXv2e;v9gy
zR)P0ow1UMkKHhV24jcz<c!x!-jXJ=>iz{L+aKJ=dP0<F$MNPbpA{LjYBIcHf3n$KH
zg>BosOrn()zqiBtBOKU$X#{VHXoai5@_vU_HsZv#xUk_|7Kk}7UT9^-81e#zwlJc|
z8xdMrh#L=h#X&1voI~Li2Is)xGcO-Frwvkz*9M%^4#~v>|E=ug84w=TZ)KrRX7J>F
zD?53ZT^z3GY5H^8s-yBe8-GrFc@+M+%&4_EYR+Tjj(qg=HBVYAwDrkqo}_jhxDVLM
zW6wO|?AW>wET`r~arZ%EPi_=<YvXa<Y?qxn<0>yi<AGeq6W29oJb~-L&Y4(VN5iAF
zt#MJwcrNx_7Rd3RwY5?umnTwNIbtbXaZVVekY_$y$&1p)GnuV$SvGi}vXzB8u*AcV
zt!-HSc#^RdE>6(!u;DpyM2{y2TiNKNfjkEIJ$7)(GkuP2^w3`K@vTsmSUf-%BaNg&
zn(%yEYgimVivdMt<&m-&R3sjchqXZwIv(GO!DW&r6|{nNW#f^j7zfcqNV2T);L`U9
zh&1Mjr0=nphlY4S$Ps9JEQd#M9NXyW7{0pR67%Ea_!27tRdQlgLh|a{?t>tzfPhS3
zep}m7D-nJb+(Gy;F5}MDz;iCZ^%-{FvFtcpBJS@0n+sVvztZ4GxE%?ac@LpuuJkYQ
z8$5^R05U^3FXSN3jR~K)u-4!8y$}-zj{HhoENjei0V17|6u5()gLb#vtefP``urfI
zgD+V&FM#;p-4^-;-CajYDn;0wZ~F2hld+c0$1nNe$yl4HGxc3del9pxL<G0D3l`Dh
zOoJmwzzILU$Tk*dmJEKzkxbs=vLyz;=E$!=p6}RhciZyXAAYluH;nLmjl3h2-)iI+
z&-h)&AJZO`cdX(Qj4y)l8;WDa0j(7VzrpA>^Qz*k1q;Mo-@K?i2jA7hcis%%8V#PG
zZ{i)*xpTz<0rhDKUO_GHSmxEo&OOHlKQAV}xx&lOoeyX6qFwdH4PHS#PMo;oE$Fzn
zRd~t^sO5J_4Bk$yJ}JbTc%2W{@MAUdidla2LVf{*xACg4aEQxYc%`-TRgSs65k;Q=
zGI)z>wqISKy2XLTJ@#2ER?Jy#>^KK@6j&+Fj2XPWos9Sf7cV2^C4~n;2~Mss_<=yA
z3%|#w(q&<PozMCL^?9x;&QFRt3B#{5sd)2~h$^l5aYiQ#_@x~g@0nLYFJRtN$*-=7
zROY9roJ8cuxMb3<(n<6p9I2ee^(BjqQ3Il8aSt}Xk?CYTKeH!t^tX_5a#UXa%umQU
zh{3y}Wp+wSeostg?`&8(w@6ojSJ@}!_yr;-Kl$k>mCd!TY~wd#+*!&iR*}keAmXxR
zUVp2yl6S2tmKXmsUwB1`a}^1{D4;WrpD%anp3^4r!dc$wS~zDxnZf&QwShO#irZd!
z@2p^Wqic@3{e_puI{a~`n6NEJR$v6gpC$hDUo~o)^W#2_QFypFq!5qu`##)Rzj9X0
z9QiBICJ(^VU}I>Gm=6S<jR&{w8<*pu{I__xPQ|q%=lB2WZas85esP7!`EkB;JDweQ
z?!x2zcr14Z9**5PXm@@b=GUDA=g9aN9_LJ~BhSHfC$xGC@GQdP{B#@X<fv#~%S+2v
zRPsC7JWh>&PMvjxTyGL_fw?XZ;*F`rD^x9BJg3qxug`WAsCSEF<l9j5uIAjqoMNU+
z)lzXo&Qked8AnRKb#=|+1xf{#3k-f9STu}tc-_6c3Euf=-qIZL-4N}$cn!~AJZC|r
zAwIMiQ-3OQ{Hvm^UxjGJR^^J1AsTb$W4K%HUv2PHQhaUF!l)RtVp*U9U$4iPJ{R*d
z?V=TRHJ589@e?=h*9Y9;O}dOu*d-W~lXGoyzcG_a`X>)fxjJPC^X*4?P>hUt<6-<?
zh{tDqp}9*<2g?RmE^KFL>`ics1opAU2B4xX7T7d!Hw&%`+!Dd@Qdr5wp`I-h*u~%~
z1a}v><$`+y+zP?{Lvt6S^7;i<08VOIqPZu*$*`E{Qb{gNbJM}C6mAb{>|4zZz^b}*
zaf9aG2De(c_!qca1eb|AD`OM{w?<%p04GzeQQNX_Cb2{$?X5y?2e`F@dlg)j;KsDa
zl9k~6-~b~R)@ZI;b9La>3%TdPNf&?DwkI`rT65=jKno{a)Pa+l?*X?#VE+cku*4fC
zn%|8Ay9ZoQaQne+5?p_@9hHI$gOh2$qO+s#4$b{mb8l(xx<qtvgxg<&lWBh(T|Jqm
z9<&-Y!uBh0n+2DP7FmY$EJ~A1=f9%7EETr+42lZNaBwm#hrvldHt76)7@W+l4ahfc
zhVU5=>%4qU#oTB73}KPBuoNeW;>9^f8G<}uk{bsOK}1?ThX2We<6dIP{YrCppqxr9
zgb+yXF3r8Ixpz=Dr0s{A<K_a1eW^KmFR>At8>_jsn%jvONx4@v*B?13v8kH#Ypz;z
zw`-2ezS2cE^o}LhM{``_l~|$XxFjpF#hROqQlc=;vE)eX9?d<fxppWo($?mC#$Y<H
z*W7JLc!}MixtCB%B=(x-!sseVYz{hTlB?I;Uo|%lT|#NQNpqiT?nQL6q;2<Z4%c6E
z^_u%mb7|;%Nf#NKyIymzpgSpTBbrM=hfHFtHTQGP6`-RcZEw)r&6;bEj+wL_r@85x
zyG3(@FLmT@(%ci8n}@ER)bfDl2uSSuUJkcYbFXO5bD3j1Q*#&fcCcd2t<qdjb0N*$
zskyFw9JhB~?r>wSaJY9g*QB}6G&iT8Bez&{_iOGu&Hei-M{fQAhkIXh=>r|?KFz(M
zxq~T=?KguQj`uyvv<hmjG|j;Rnyc2_i<+A?*pXYRxeqmW*$~I}M$O%>xj$&`Z<-r5
z)N%0$INM<D`MKtP1rCK9*fU!0C5;`_++Q?jUhTL@)Lb8MQgc7e4b`?IG?t;cd~Lf@
zV{0_GPTSrFPNw7?8hc1{^_qKAb8mx_VfmBh{-L>qVUBH*=6v8}8eFcqp_<Fn+zsHQ
z=GmH?r)`&jlObKDvCWzbYumdu_EU}hN^|dO+fOxjT64Z@oDg)=Tn}&;h#c$-PKF>=
zW1}=T2b>IjndZv1?Fw+x?S0zzA<aFi<(|@VN3`ux%^lNnpJ=&@hCBXVqPbq+WSFl6
zC;iRVw)vV{thox!`N2uIRp6xCJ2m!WEqA}>ex+>>Y3zvRj%wQv!AX5zX)JDp<6CEN
zGX2g2ho%yBrkA$8Tw^1&T!!YxYPl&IE7jaAZM#r&VQu>(&F#>(_koikeOuf9NptUO
zx#L={%e7AE&)3{V;ABc(22Sd`THB7$T!xk_*Vq!xE!Vbdz)3B&+IG9<?$UDmH1?Y2
z-qf~#0w=Y^jda4?UUQwm$uM64PRjMywgWYnrsb~J*euQ6q-__2lUnZ3+%7HmvgY=J
zll~sma^7?&eC;&X5uB9sfs>j`we1Ye-KgajXt~F<?JqU=l$Lu=%l$*!ey+KHYq{^V
z+|Udse8V-D4o-$I51b6&Vr^TYIlq>x(sDo3+(9jONOMQPNzET<IqxXPj}&mS_6*kC
zFmTevXf0Q!xjHR(r{?YjCtW<O<r+2jFD>__=Dq?aT^OUCu%v^NVae27E;uPypyf7e
z+pU`0rseL@a!0l8G0in;xn?bQVW#8n#hU90PWsyqT(ZGd<qdE$e1|pn4mc_I7jVf2
z<-XF`x8N=nSVEQ~*Ije{H8&WX)I1EFbdj%ZCunS{#%5}6J~-+2X3Z_r+*&Pno5sSL
zyHnfV2TuC?l*SHexg(l8s%<-FJN_nWt}8g18k4~#i<mFaSe=%;Q*-xf+t)SsPi^~!
z=1yzd7I0GYr8y2a9-K^rNt&AiPKM=rEw@#3ztpzB*4Q63wjZ3-_lD*UYwja0cUp6O
zavc}_G&ca848a(UP0-wAZM#Hc%QY9!wohuTUUScC+ZVyf)Htp&JI@JAg65LI$*^1m
zPP)j{*nBOwNOMcI?JeM>iw88eSIaeO?saW@1e|o?$#=pMuetNU$*^3lu@Rcf(6;&D
zq?RQb+pgvA(%g@=?IYl%i+8l`pTWtJ{fU-qKgJ1FC(U&MCqva8oYaz~u`(@JuDK=J
zb|pCJ;sK5A)pCuRdtKWe0ViF2qp?fJI-$BubC-jYp&A5Ex|pSHZ_?Z{Ew@8s_h{~?
z+V)X!QcIJzJ+8Tkmit`G4Z<XfZLnP%qPc6p$xvm2llrQ)?Iz7_(Q@0h+yQO-hUN}y
zx%af(Y0brrcl_{aE(@FtRi5U?fs>({qUE+~><?P*Ma}Kjwy%Mc@$gJ=v<w2LVy?Ms
zwC!?@1vIx>+wRiX%bMG(Z4ZKzzC|?mmFD6nI<`Z=$q-zlxsl*xEOWKoY|Smx+&azu
z3Y^sPYt8)@oYb;Q%YCV_)B?xFP|XboCtYNLlcD!(EUe{zq`4j1_AQOQtGV~I?Z@Dx
zzNATxzdmrX*7nidKyWey!!$P!oQ&H-%`Mip0dP|DCe8g)+x`}ubo(4Q>DxYS`?|LM
zqvnok+YdDt0Vmy_)>!gnM{^&|^#dnEzfp6)(YDWM?)TdE1#mL-RfeOl8#o`Hc(E=f
zLtm(|samdDW1BSgxW=B;m|;5lEO1g^AC2|X*jSBC)YxK;@xlY?_I8ccY3x~z?bO&Y
zjWub^_Bdfl04Mbg*I2s7ZqV3lja6%Glg1v>*rOVIMPvIlc3fi-joDru7H~2w12mSZ
zv56Yv+M|@K(3oFibsD=<W6x@Ar^b$I?3l*B)fksRr5`=O$#RgaF`j*vSf<8iYiypz
zHfd~&#va!g*J7j}2Q|ji!4msSV<$D15a;;I)4oz}fW}faR;aP58e65YwHkX|V^3;q
zzs3$~?3BjNXpE~tG7VC}$*^!;NMf@!_K?ON)mVeZUeQ>S#*S+YJARcueqv6=S7WIf
zo361NG`2}&TQv5h#_Bb8RAa|9X2UBPj|6bi-=P{CuCW_5Hd|v`G<Lhj>NWPP#tv!h
zh{jH8?3Bim+B;$Kfdg#B8>t!_s<EjWo361<8r!0=XEnA{V@EW0RAZ+!c1B~}IyhnJ
z0ZxV`U1OOV^J{FC#&|eVrs<;^<1t8yaaBg@JE^f#8XM5jkxK<9<rZtKLSra6;)bYr
zq)}TAOIgZoidZv;5x?(RutIOH#B#g5tXZP+|5jx{!znZx#@*m5@I;Y^VM^`lMt%e2
zP>jqjnAmbhUA+n<6K$YGQpCnVK=={yn%sARm$mDcB0jDo0XT$=%Tlo^b1N$y6iwMV
zWoZAN5<<fQnKF_#zlcIm;UU9)eizc)nBOU7VrqL$FZ7%vPzpljg3K1=)g3W9Xy~M5
zn6qB<sUB?v0CZC_D2$MK6<)UWi*Hf>P;emgE`r`xX1Ib75XdCsf179-W0XvSkl`D-
z?XN_korKIoZDdkzTDD|K8Ft^|*ICGPA=~CR8!jtUNsu8~38XFt*$SjS2I0*`hhmVY
zfSim$UI4=PCy0vU5wLt`Mv(~Eh8Tnw4K>9eK4|6pFzV_`AW1Pu29VSkWC{?z9iy%m
z0pVLRitsL=>KNp1Aayaw6F?ebkUc<}VvwUi_(qIsW=dqnAQs|O5rcFGQWt{^0#YA?
z<N|4mL9Pdqq)Hz=!H<29%owB=NJR|tGaz*_$O}N~V~{@qX^25i0cnasnCeNWO3|2J
z3M3T;K8o<xmg*Q}91ym(Q5p78c)&Y~tOimTgKPuBBg|2mUjWIBL0$yHHSVYkcN<j4
zAb$hG6TnfKZ-F$$AU>oq&)7y~t^&fNvQcC-5T0#~A|*h0L^X;m0>U$;QKTA35-MO6
zxd#YOZAKCHekx*+-9YMMkfT8AW022*9Ew2_kXI*Tke)zzd@<@5?*OTYLB;~%VZx})
z3?Muv7)6!<5eEQ4WT~qL!lQjrnY)1S&|VbzB@mvmiy{rwgN7)I`~^sI4Dt;S9xjW@
zT!a$GvsO`LC=ecjiXvm!z^k7OVM!ZgaT{b~8|02Q$Wv{Qm)juR3GV!)@7xLQ{3OCX
zh0aeR7x0CneiG^51{vK3nc4<f(gvw%gWT5!VXx5nN#9>@gB)vv{Id=6Z5yN$Uy|x4
zHTQ0Vq_sh^+aOcgAPZuUS@?n_zd7yvJO;isx#FfJ6%L@v>gpI*wJ@d3E1MfwFl)}-
zxhu+6IwrC2T-huxUs~qi^H*@ko@24>CWoyE%;h<UN|%`*kkaNk_|nLNs4>=rfEwIV
zjLqR<L!jch4R@CMn0w0AgRdE3%wpeAeZ5_Lvt%kiG3$uWS-g1JP0k0+|38V9vpG|o
zXPBi9=*()1BDd7p!!q?za}DT&gc^~j2(_`*5kieiKgHLwT4Ul|)44!w^lt^LBRZ{6
zo@Hta;rKu+P{w#}*|~9S6m2cfgGw569};X0whot)mB#~H3k%d8HzgetjVR`hheE|E
zqt<H0Sm9jYIlO9{5=yhQa3_VbkY`|8tJi0eT3fhI|DD@P9sN7Er9Ahi?Zlx!ZHk`w
zbD-A8{TzIj`*fZ>>!+>U2mLhYKINxDw-O%l(-yLkK!uM%U5EQxOU9Od<y?L?zKtj=
zg*)SvbnAkq;FzKl#oR?lp|PbzfvqyvC3=n^h;Q+=4zD;@b}sN73iPSH*7A;p+fDSm
zo|blh0WTJm$Hv-V(JT{AV{4CqVpBy!Z35CNp@d-DIw0WIhw@@W6}62`xmHfa=Kg5#
z+n&YKTB8T?90*(Pm*G{WnsOclz&mUT_P)=ljJ9eDE-v#I^S!5pvntB-R+UGKI;G_9
z{Jf<&(ObTBffg<0NByRXH=oO={PLyvwDFo)f2NeNPvH0=e4cZ2*_5(5^H#^AWlL~y
z07tsAc@kF3(<6R*xH1YMSa7~rgdqkUx76PjMD!8Q++~5euJ$dO0C3}~FHw9_VDaJ@
z<<OI}tfEbrp?d~COdcC(gm7YcWi-}P$|_crA@idtGiyE%bLm*ZLEfsen=~-F5@&%{
zV7@?ne0$ccS@X+R1(sIMn?J8y%jC{Q=H&(|G*D2u0##wYHs{WjpB`rTTp-g9y%de8
zI2SBiS!Q%tiICva%_++UC5vC$kYQ;<hF>#e*s$c}p@Rv@|HFn3752lf88Sk0vpY=W
zwLJJWeQ6k51!tM=xhz75`r&{XI-v<~2?68xAjx>#^I6iS?f*>5x#qOmN=T#{WYEx9
zTi#LXyDAoAcXUu1wzj!`)kQdgHV7ZE`?CbO`XS_oq`IUGV+MNJuU8|U|B^6AK0<CN
zwx+s%Lov?o8#0VLmE0oQ(ci1F1=IB_9Eh9scDMktlp8iI23(JL{IUU;^B|4+)BX;R
z^|uA1(SENQ#-7%4BVyy53>{azj+47ej?oqVrlk!b>-_5B?-<C%{20Ep!Pwat{h7eN
z`eW2AIAHGiFJeACXATS7=s(Dnggyy=X4f?M<4<Q=R={&$Z}78(!pJB1uvYMuqyu|P
zY8pbHlotCh4ZU6S)_Uv21)-A=m{41hTNr7OLN)KN|9frOnd@(yxp#gY^i3-*4t|yt
z+8bV#RBPR_yU7!Jw=i7n3wx&&MrxIl27ljBWl|`|H{z?Ri~E09oA7e2@3~rQ%kGan
zMN<|Tg^_tuu(s^f^*7F%xi@sW_Ju1La7TZSP~P!yx0?6YO-ehR_Wp^E;k@HH!F}CE
zcB{$=d%|l|t(q4934}CM(ljk{p;Q(wX+lKbDJoiIO~be4T3UpoSCZfkRwKKueRY1F
z<6&LxvzIIX5SxVXOnYG=^1e9o`gbB_peQ+9d_$;P&0BtNDBB7Z+KrjWGhDKhb3<ch
z?qh#{;qvgzZx8G}(W%b;L-?W3g1(yf{oTU_N#T-&!lEf*Z((G))Eo+O##6YhUCH={
z^X!@7YJxg_H+(i5#@ZL}g_Cf=4$n*wp(~vh86cEMV{vKZ5|?pWailZl^X+i49V)d$
zIbf`Cz7;C9LOE7=hwyhZ|A+1t|7A#a<T5;)`5#3hbT^q$kpG>;s`X!PMDwS#7_kdi
zCWLd6LSKy7SCyV!Ydse#PCyx`wKgKYTap?xF)ae6B}w}-O(Rrjg-d)$!Ei~pP+`Kp
zAl3xn#YvW^+Ns98(9y_a|3SdL)vGQw0&(HugcDDuoxVPF681=+;Ag&YUP8FQUWD^e
zC_6=wTadR0_SP|2j(t+NAR$~LM3CH(5+Nbem+nh^i;Qqy(iAC0i6K%4+^hI>tIan<
zIo-lJJrJkv;hba?fp(2nJ>*(Y{82AXwlKuOhPYavvAf9|D(*3*5ORg#jzy6>zZJzM
zl#_g-vGzH}ul8mBXa1Jh;cRL{91_A)5`v$%gnV0O>hO#F&rHx}QNMc7RRMB7DV&Xn
zC763g79}PA=nbfZO=DgYm4`h{vBa9k$d6A52NFUBO*N+zx7`V#)(WMyuy*DhKhYn>
zA@QZ$UEY29rm-*IYlQL>8uMiy1&)si?(>bPN(cpxuPa1g!hz$7FHPO$36J${wRV|r
z*1WYPKJlfAyUfreYxQ$|nR%g-W2j|jVdVaAM6|;t#}L1t1iwI)Yclu1w-a?T6+|==
z!ZQ-g*F!TBV5`fNtba(7T3;4?jXVNX&B;t`nS8oEVCI+Dq20mV#;We9ju(u~PN?b<
zp5g=Fq1LKKB@0d5XrV00^6<aO+y9sH2`+i$OakJ2Ubv89=orpSsLieZX3NBl-kIlW
z510md31~3KCj|EztIiv-dtGN4{B{UF!fsy=<uW}=($F3wzmfMfZ>{#s+&i);q3Ub2
zv*9A&OjNHn`neUskcF%u;q9jI)+7Km`*EZ7{?JD9Gxy$HwwiN4{rb)`FeX`CS+=}i
z-;}|rmHmyrl>k8&FP>+>wr@(>umuLs%U;{J0)GGouQFQahbW%|*aj3&40}WGhVqUC
z_vNA?4n1=QVcB^;{%yE5_h+5Hc+qb=*&Qw(8#)=;_BE<`PDQP+Iy@l(?}AXl(NM{u
z6Q0oi+Og)yyrZEB6^XSU;I*}N$G6b3rQ~?^Sx?}?@U5u9hqn4I3|AcrHu|d1E(ui~
z3cMCBITGIbDCBAmB-Zfb1GVYZXoRY(j+?dV&nIsB4p4ZEwJ-ltGqgJtzx(T+wfVUy
z#Pb{TvF#u{&7R+w2_|$nRGJIReVLG(G`9BcEl^p#ivchbH`PJO{Ko7amzlLI`fMFz
zh9@Tl8#<?VSa}0{-Lwfy2%$Im9$MiGl^iUM+<pczEIG)AG`rir>`T4-vU{3agH)Cd
zZTp~2)S$*3F|UXG|LSP4p;IXM86<Yj!@uSOXvBp~OP`uoFsWL1KKe!{!SF2R^`OfX
zy;jiz*pI}MhKKL6EUPfwzGz`zOf;7+N=C3Er@vw~O-8_)3sJ+07G4>(dr#QmJ$0~o
zDD3Dm5w<6q5??l<Ex5Z!VbQ`%iTpO4WkXxxLQA<W*dMtMu0uonMD7F)7wl)e^Nyu8
zgo{vop)zq>f5bQxXbR0d6e>9ysyY%XI35lh3++9zR<z#?Z@a=s3DxX@>sl){c&2;e
zkJ>Ts3Yzv=X#;8}nRt<-l0h?ST~c*=H^binP02pX9#}icgV$|swiymI6`F5`M<amK
zLIwLvBOZpR<e&^x?a(gag5x<Oud@?tx1dr`;o5tXYFZL&)*#Zs@6KQUSM(7Yt-%A9
zmM;$OvrZfeXZ7gYg2wJ~Ph!noaPqj7Sn~j~=5af5Q%AmbnbHY`;c<4+!huMT<~jwM
zNUtFT);m%%KZMZDz*OGvEMsoJ&lksM3BZt>#)iG8@PASJNbYIoSOQ*m#gXBHPZBk~
z`3cB}$0V>wqUi2M5i?PCLz}n2U1;0w_+NYXLHutXgIB63`g@R$vdHf~+Y?@eipJKK
z=7zFz(;BGd5o5zXI^Nojc^i5C-y+#U*}jm~C-R~+A!AsUMUn1lHva-)s9lj8+_R8+
zFY^?pHEbQ@6-8qdB0eRuSt-fy7Ao~25P0wOG$D&#jjRh$*nA3FLV;u9lB40OBgnq+
z%tPV4WBYPFefmq<*JyquDwB6ii#0-KKuSu=iMPVbea-72voE`k(HsDS_ieO&nlLdu
zq%lXdL^TKe^R^arYs{%YcDLAJR!Ef(jXA4eFdBmq68su-)}r)*2$zjP3%So<W6o4^
z`+^)Lv@`~}gN#3?jpO?#oRf^!DwKCLoRcs%aZ52v|I8!mechOMjPi|n$4O8J#@D5<
z^jqn(10B&CjVL)@g+x4_-q$}ay}!RCy*#iS4(W+#4yH`u8~3VHEEq|s2<^gS(6L{Y
zF=5qgG>Ti>rTYR;r@ggxnwN^+fT9!o=hp?-TU`SU!S%K$@cfCV=hq<!RCwYk^}a#s
zqhAxYHipL7Cw@1-F1?38j4<7nep6s;c-l#*TKl^b)!~^(SlrRqi9GQo%12cbg3y?g
z3{3{>(2dX;E;z;(v6w76gH^{vhr>C(aiOZF)g4dt8W;S!#eZI~!B;)Jf8dLK#sw$-
zA?iOXVlirV6FPwpQFRG>+#P~dN$nH2af}zPV%M$^9TT6qA0@dqfiKfqt6gZ%?vJcm
z%TsHawN?!yRahG71QiHcC}(2zI`)j(qq@}=zQ8U*$?;I}#L(H$gt5Cnif_!xgacd}
z^?Yu)<hXe_T*XdS=+>dI3r!fl`%{m3HdJ*S5v}!g2^IIL^*zrR6{iC(P8HI=nwC)U
zfOS1XufdphK&59Es}#DtE0ThHaz}g}_!s)XHE$(ut43{no`FPAviaVDOa<N~xg!o&
z{i}H{Y~^dVF=s4BxW>!;*O-??()=wVf!2%ZRM6D?wrW-Kjuu8P{erDYGK84s%#*w(
z8k&C%A*X-L{w?~39FQyzdr@!_ke7v#k3JVk70wx;p+7p%R6rLq$BU=$+iW7(W?{>e
z9+KrCL0Ao)5_td)!j<!;mqzXc7n*6qP7W2D(aUW?|62_l+l=oLLi@s*sqkh}_{ISk
z=8eH1FA4JD@l#P%FUc8k<A8NTYSZs$Y{I_bC=;Jmzr>Ij0dzg5lty~<U6r4j!$@0V
z3=Svj-*D=pYkY_HAjDB`q?%50CZa2XbdPu#+0PPcbEX$Y-aSd1#n6Qi4G-Tsucl>P
z-?Wyr(<i)yA(cBkAwSsI4doxAkQ-4sZ~bv;R~WfRVoa51*nT(WEM~YHa~6`6Hs<iX
zZbT{|))=G!e~m%*miQBiCda{ge9aLl`txDYFJONur(dLy-oTGr`%SA&e=gDs#?YDF
zP4S^;*m;<7U9GjVkONIy1}Bu$53xx`RC-JfcU9$cvMPIpEPKJ0mcT!q6qDtzWG6Zp
z=ue79l>P2-l`kCV7Vc2J8e_Am;h)eejHD8OvlrFU+#lM#`@{I!9vi~h{mi|!`JUhz
zbLB_`a#717vlJuJwf|yrVe}K|mLE7DgDX{B`-~3m&zv91>5<mp1i<MJV321nYJuBK
z>Gs5)zLf))Eb5y&e7d32XCl*Q2rD@TX*qro=%bMbP><3Y+IBu~tw1ZaWdw>(ILDv(
z+@avvcA>n3iFfAh50xAVp6%f8P+hg(NZd4v5)%^8j%~ZiLNWwiK@--PcL;GdP#oS0
zy?Nri>aXWwj5^kC|Ho`JXCuDwU$E7#{<?qQQyL-5GCJamz~94xSK#TU%b+Kmcc`Wz
zv1TyXVAYXMi8Z&-pQ=N&=XNCVW>?-czrzHc;AdO<F5Tv=4W98PZhDQ5&v+6yC1WP4
zw$!f8w<3T1rzjAmkqf}=%kN>LBvtSF4@2uu4KvcK`iBb+QPt<@sBWkd5lP&19EQgH
zbjn5FZb%svmky`%6Os~Zo`ghrLPgDiRqev1v&V-@XNSAueOTH5zM`~->NRLuH$8|Z
zMy0%ygQ&m3vz-z*{eex?+4hN>>cONnsF+o+>wy;eDR`=)egW&_I?UuGZp#N-E2>6X
zOJm*<h71|Rsf^s=7J}6oMXIo+<dCSLf$m`pIU2iVV&s7_z=%?7{X5MTHK6?{_6N^)
z^;<P>1>Osn91P|7F;GR1<kV*@he;=16&YQ_t{GAg=@{Ai50!|AA)*q|ogu+>v(3bs
zaSSVS#eW{NvLkcj*0tWm8WSAe%tmQsyYwQ|NP&Oi#gC~Mu-o=S0!3%${>D6Z%+RdM
z_`NOq3;8yy^u%sfQKV2RKy<qYTTH|(@va6rSjaobQiXwa$&oR^z1>Exv)1klBYkG>
zhw#PW{8b=6>RIQX)*=%rv1TUoP^upb?O&V_DNsEed3O&&hmvR}ZmVTD<KZ-vx1Y(q
z3R7qMAsL$aN~7$iAk|dBncP+T)82=4apY$Zx~{gQ>G~;)tjOIkphJ%Sa?5&zyKu_F
zS24Lz8d)d&Ob+cuI&3<K@DwgGil;>u2pDZ`;92@S^I*8@U@bZV1^Y2eGxL>&7i2<m
zT2W-QaxPMo`^dwk$k@bfEX-*Kn5NGn%#C?FWwO2?$txtGz>&}&LvNqB0Ko}oW9I2d
z4ob|(8CGKLY)08X+zNhU`agyLrIA1VT_g<>@vtyAN^@v863hQmIPVn(pZnPw^Il;_
zFwh0{MUe*~cVoEVg>cEv%%X5XJ*I>5ju#b1ZWHc(KtlV9BCD15(}^`#K}TlVTV~$Q
zE+sEC&p~pjx`E7SpICDQQy}i5*L(my+6`3)J7D8jV$E*YqQas2$2J&`LTK7FmcT^m
zQ*cs3Qu8RFVbOIBmu8~m<fn&9Gn+dBMd(`s$0Hv#i%6e-1>+i?fIuPk5PwbLq8N+b
zoRa^oz%e3e2^?$*?2kMG^K|f$A4>;28L(hWT;ishv%-_mt^U%;T4||Tz|Qc#c?RMU
z-oef@@^aHe#!9xZ&Hn<=Ts;z=WWCIUMh3P6&oW;-re(zbs==a3=*A}D@2qu&k&C4V
z0NzC}HPqPbkEUw#1N3U<k(vYRhKbHsS_?FG3>`&L$QhAut-D016D`c&5zWHL8xf}@
zymz8r_IgVrJ0%E#(#VsNZ@vn?yxbK*Y(5X1u-dMyk|cnt6he@mofcUIi*Ug!Y`ZW~
zQH7=lt)2|e0Yo<RHhQIB;ngyL?bjGId6?Zs8-V5uJ)OeH2&tE?%J1M|c$&qT@Y<Y~
z5r@_ug3kyh^X)t#maxbSeW!BB01|2xdGzm3WxUW=pUTF0on<6$>xqE!trks$^PnzN
zQePN(Rmz7;>a$sGO0Bi;HJ^k-)pj*MDiZb;u~V!$i5f+f!2E}DSWqvjJoEcaS>_n5
z<Do``HnIRhB3L&{>E;H!x1oWhX@Y{D0u=fR=@$+hX<iKjLP?PdE7DJiJO_U{znX`s
zc|TGHQ(f#IaCt&>pN14i-ryuaPK9`Ftf~x)Hw@CY5E7zqh7r}GmhiTF;kYPr=x-GE
zqq`Ey_eDEu7@0hW@$A0fck}~qK{5BA-wm%C^lp0{;-s*AdCp~tERAe|9=>b#F+asy
z^@ZwPV$R$DjFgxUiAJjr^(``Gs9fO~OIzJfL~xo{Bd28l3@<a*^uE%I=GodJIzO+v
zZnFPaj0SVv@U)g-OV9NkLMKCCzkTL$GteuX`;CosxF|gJn*{W&+ao;+Ti#+*4+{os
z%!pg9^{=^J>{0!}&p1T0F>4h(lduviN|>iw+#T~&P59?La}|FG^l`;M1WMd_C>uI-
zpm{o0qr#q0$*IUBawVtaD?1HwgCXSW6Bz~^fy10X0y-sfg=56{mgWniW@r50gZ)FU
z8YHm;Ta0<y#7&zKFWF}dtV8MCQU^08;A)3%OnfQd43{QhZYpvyd{tB9!Im#D?DDT=
z|LG@?4Yr(3-1JkyeC1z>RgA>j_rMh3n-@-tB0oAVf{8+2a2)Ti@Wtr=0>Y$wODI1H
z5pdEIn*3kF5IPfjjq6{{kD(~b@i3<iLh})b6K}D95So+(=U<$7RrTMc`Rs|`IpcRP
zr!6_Hf8r6*pU7e@L1=2%Rwqr1{O4oTBH=ZHgbY74Wg6a3p8|!Gvj|ahIlMwJCM9jj
zH=A#OK`D;rH>y)|xS$&nv<T}c==F0UrLd?ta#AEaW))%GV@fFRR1qetZbeMOd8b_K
zTNr<0Q2|rh0gkT5hBJL2Sv9Bq8MVGUYJ1crzLaBzi<2S`qmnn`1<5*wE)$6;ij6r5
z(u6JrW?#G)1o!$T1rEfnM~VUNX>>9mf{Erh42)&>YZJ35jMXqKKb2xqQmp2MZ}ed_
zJTN>7UHx_4(^^yz#zZb*L$ud7VqL=e6A(gD7DxW@k;v6>{_t?=(8%jFp?xV$o)UQw
zd^mq1k`XaV1d1_LVI-vFH*=`Op<8~x$X&`+e!s#<Irv%O2e<-P9Jv98#{As<d*h#j
znoz)*FmKL*1=<g%#DqID4n;RKU&|~)!HCHpA4_|2?uN7Mp!-K|I4dUKhsde;vuv;Y
z@ghg+QX5!2@=g^;_Q;HauQIRX`h$q^@A(2p19l|3-rFPXH2kQ(wWkqCV8O-W9hPn9
z*G-#NTXh_rk8owb((r^nXr97dG5_}=6(ooDp^JxEpv-;9f}B3#;(lC{%tJv86(=O#
znR5}Qug>3>(-S#;1Ja6-Rf-D>r-esOi;NO_n7V%s?K^QB(nG9|u!R?^V?{kSAer#3
zqCIBds?&R{K&lwNp59{zdW5sOo!)2rt?)(W(cnj(#Jl!DmY(EhC(O7`tUYqR?xOH=
zD_E7_U4M1x3(Sv(Fim|bly@>*a4KAKGVSxU_pT~Ad2zw1;Mc~=D>i)1P2v|d1RLT{
zydc}-(9zK6!6q}bC+)rVhXXGJ8|)L0h%Q|4?E01W!qqLW)q6IaZCQ`&2SYUOs`tVO
zbK>Te$Vx(w*IR^I)+cVh3FO4RvH6SI6Fk%LmQGu%pYMlvoEQ=84Mq}X9*&6jooes%
zFiuax+vh#z>rDH)S+#{2gvH;I5j@k*UlqOp{V1s+O|C95bNoqLrg~cvpM1^U-E5By
zd=dIeG)f|GW&H5wIMZ=ub9i01DbvFFK2-2u{Z$l>)A^U!{==a&;Zf!pOn{AOT;D5<
z>E5&b_mtLJUePtHmXar)K+#22J5e2KJn??p^>Pt@teA`0hJvKvHyu~@ugy6XD)JqU
zG-f3u%ZyM~x8TPZg>^>PeSTwBk0f)3Dt|3~?vFsEZg4O3tntjoQ-^0Co_3evt*)MK
zF!P}tpWq3*F-x>Ep^K=|GG?STNS!d5Mp}dPA@L<oXivyQ$&gZ^B1>ei<3H?oH`!aK
zn6hw5q4tNA8!k#2a3ZCdtwKI2?ftDY%&k*AyFa$2yY@$0yJSPCU8cQ{8TRg5v%R}N
z?$-Wj)OAv<>)jvOQLh=fsDcJK%JyuX0S!sJo0O6`smnqz+8<4PsXM5SNyu#fwu<s~
z)=tdo8!{3INVWwHs3Tjm<3wQ$?c4pgr1k-r+X-`fTE%NCTUdFOd8<b<ja#$L-Jf=o
z4!%QLgc@aJc7K}0czoCX-QYLz{z2iqlMIH9GGK?6C+y@aq4_&B)3SWh&SN(J1Au&g
zmYfVNw?bWH(53VtVJX`;*+1Cu8Q&9Ph=JO*wb0s9^30aImZ9>6G4JqbsD}M2yymuc
z+wd{ljL=^~Gmi(qS)X{@lgLrbQ6n|Ghh{bjXfL49$;O&oxG^D&rP~pWSQZM^4giuE
z3;`T*KW!6(Rp1+IGQmU8X#NEMP?HZw*twqryV|@vi!g}9YTPmNB>Mgzu<!gzLa2sI
zbG3IB;(z%6aP}tPRaIBt_&H~vo1Bn<7q|#2Vjv7!AcRSQB#@9Wh9OKL2#O)O88pKs
zxi^F;gCGt?D{-z;f^)0lP;G0`w$4+nLv0;e+hU#Yty&yjYX|H9_gj0PlM`yc?|c6D
zdG=jvuf6u#YtQ4^d(P{eXAZHk{`+${@4k%UF4>ibe>B<?ADJ%UZcXRnUFo-@%PvDh
z@b%Z_BKq)$zt^>Q&b>v)?79abezB_&uCOeJg=!=KcVArq;%*7mer@+<lx;s{|8n}4
zcaFL6r;Ov(jL+^})9CQnCE6zc(^nlj=0bkQsr4$pMAXA7_{2x-e|+0{dKV=l2&D6y
zJHJGVazHgbm9=RQHhs|69CIO;=}e-e%8}N)FO!sg4kZuXB}DQ5I=pY%HvNp)F&8~4
zeHjRu$RXgmp_8)3X~=CL`QxR<-p*&f-o80v9kc6Zh{0;s<}~2f0>9VJPh}mm<5Hmc
zXT*+s<bxf+%8_tymM=ei|L-K>E)o4dC_^Nqyj`~V^>Q93xypB@ejn7~PnS>hr#k&F
z*>y6A%MPCd#@&J=v#1=m4W;|$KzyK1wfr(~i?<!${wAHjz3vYI{PoexR$ZlqEk8U=
zhpOd$FtK;cKX_OqN3pU}QGtg0lQ$3$i!K62>3tgKJWLV3u#oj>&Y@+?5YgwzcE+Jg
zq&$Na{q+Z@1oaK|2c0iR*O$%t976YkyYjL*M@~nP{QR;~^)<#n6foxqyt3Ph>b$@h
zL$U+s&kkd9_OF)@KkJ{@s916Shu=p^UpD73#6CUeFmP;pK0SxyC+qMGh!Zsq@7(es
zhTM08c+7Y9;-6`ox}}11IE<tQ2%oGqB{O(n=XIHwt$GlOO2j^S9V=GUm8#CinvMNZ
z`QbM~>`}G~`)7OD%c9b-31D5s=Fx+vyktL9ez^Sa<jvZBwX_bG)qvrW`R*lA+5d(d
zXc>fy#r<P0TFYV(|MDR$-&k6mJ(rb#{__9)W&eNdhtweXSqiqq%FQ0m?o6`)x9sp~
zS~ynNc5Zpc+S<&BuiDG)Kt0?VEbcPgO7`m+M6tgC>+U(2(3hettU)c*C!p@diL_M@
zobuT6-D^u%96tOH>K?l!{jxcG%MU;Inu&=&7CSG3$ZXopo25}-zUVC<<-v^Z=NDa4
zUSPj`$^0T5X2HNUbbiNsYC9LDZ9P9Hf6+P&KKg_0sqJhD?cGI~j;219^ImX2W4HCV
zWjo4E<6Qyh(Sx7e-yY=+%v9b9UVnRl%}+(0kyd8rOpx%!@v)ZjW@P4PF2K@^JJ42M
zW(3xV4Qr&Yc8e?+I1SrsX|VRAo3^GO10nc;oq(P*Ajvr6gJ($Umzn8H$`rwYHEXm*
zAAJYeW3m<uWKjJgLOEtMRL5t0s$W4CJ`1EfT?ZH?5i%ak3}j`}EoPL24pefGQPNnC
z4fGJ^!A3_>ct}t5GBf*TW@Xa<aR}UF;K$pxR_%o0P;CNYI&`otF%n59_5_PdV0r?@
zV{3*@k}$g`3_R<Xi{xdJjLFItAtNF|0^_xTDIv?qOf>1EdiWO%)ILUM+KluV@CIpp
za;`lqtGD1&AUJUUR@mJaG`1%+UY#(mCny$@qBMpwzDGR=r6$+#WRA(|;hA7~kfP+t
zGh&T(Vy-=LU=Q=8Db_?`o1AH{0{4_aGss*JVw@V13hi(_-Y=vMtfz&&^+=x<kdeS)
zY12dTfcF_aiAR<5Gf_hZAh`>Al7#fau(+O3W<r=rTIzytfDt7iMJFPv%Mq>0%r#io
zEfzY&%w|-Xnk70MqNQ}i`ycc|$@D_{TuC1Yn-_M$BQ~KhA##DSGLgZ&(8R~2d08kL
za9tFNEv$>fYBJ0v;b{7)hFW+Yj-hibj#k0O(*xNh=IsGHcS2ih^#uQvezg^!F`;R5
zqP3;2ZG!#~WBg=1QlQU_KZTBgKgUk1uCHpfl=)P{Qa`8x+4Zf9Z08NT50WjCsK7H2
z&hP9hob7RPtVlE7f^mLtx53THaU)f<zG-KFi&igf1ZDrhxMoFK67lA_@^FLmM?;K8
z@I_cjOHJHz{$xlok``CBontwN3~5NDDwS+0!37BoNy~Z5<}*J|&d^9Q-ju)>q%HVt
z!uhkIo)~EgzOjtgSkBvqJ}lCVuThF2r@gA$a^A7WpF$xgMVj?<GtRpvu<S^pw6-x>
zf`f&Y^PasQY2@ULOk2XZyl?X*A}8nMNTRi&rFBVslYTS9IcyyA5PDq$<bPnKO-oyk
zvg`bhu@)e>mSk09iGI_<`HP_!MfA%U&WHABNxaes->R^jPwbmT&-sz&IUUJ(vpo6X
zd}_R{j8uiFpV>dhY~IPKL^k0o4a@o59w)-qMXIWk4efDKOYo_h^S{RbS&@#FtyR@v
z{lYF0)|yB{D8;RHmh(5eQ!=(b(ox>pBA1{zU)t-1u`!Y`G-3U_VNFC5I-i944?|5x
zIyAKed9$Ia8hQIqJ0)^DB8lZlY7)iEzl@jjA{{=x$J1AKI@*4fv)zs)RweLBU0nS9
zTl}b;3+zaTCii&x+P(qdsGN)8#ynjTkJqqVSkA*jzqA(}Uv@dR^9OO+gFt$GNI;Im
z1W`Fx!3p0{S&nkjkmM@oIy-F!^VxNF2*X}GV%|2P#E7Bpw<Ea9+{tkMiab?0w;*T~
z$a>4kbh5^hau?*1B7yZaf!zx>By}CWxJ2EHI!rf}^8i?Vs<8Jr><`+JX5V3H0zL*f
ztez_8VLMV~UOsUKIT-^;djwJ{PysCGSm%49)NjC5fg;chpM#x>W61S7MEbNLM%tU;
zljl{O<BhCCpfJ7ol9qFVA%1R0HiTZ{a)vs5oD13E2%TRqwWLrYPc&k$a@dHhNLD3T
zi-tJ^Bwem^A~mR!i(0DBK@3n_M>uQ)R1WS6GmVycKTbV0j78RqG`2L?Wy>Evc?y`!
zn{w)DwDI6d@8QD7Qw?>^@tW)q`($6}vuykv7j-gerMsTXO!nNxXc98UBiq#o=PFS8
z5O-CM^J7>diN*0`eM?Q7rA9jMqFX?7X=R!gb$#ejx+y9t?r9f6oJvVLuxafmX>7q4
zd8*w>!$6g-YX`rHv(zSMtPs3N$LiLGBv?9})k4W)bxt)`qh45Qv(qZXXryDs=H_Zk
zbvl;`Ar|SFi&yhj@H;$pu5-5#heSG<x|TZ6a1BLOYQ|S!AZ;<EZ0J-UuRez#?6tPX
zYqW>0M!%6-ET4*M#mif2oAZK5J{jTTU7eOz9pHAuJ}!c1blMxL`2iuCpk%xi-@`Rj
zBe~8u9C=9MzaZhVn4Ep3#j+r=AOGNVvE;!KFlaX>in#S-9qq?5-;Zwxf;9_HnyEZs
z5-iMA0jFa;cVfWH<kJF;m@@(=CZu+v1ccBLIDJ2GA_gaV_S`E22Bu1nUr`qB4}h9c
z2@h(&a|n2pxSeq>DFYOrzUf1Jz8a|5_v*qDQw*MkrLA*m8#C2XgAC1$G<B3$CF|uo
zQgy7MdTFn-ybcy2PEJ<ZPzEqW@ty`JCyLf5k&t(r)Nx9;{U|L<(QjMoc(qrUP*Ti;
zN@}QjSV$-<#nshpp45qkgt9U(o?M9zS}QP2y(z3LCHQc%N3)ZZ-G^bLn3Oi^kg^rW
zyiN{_NTdE-RSj1h{yRB&q^;Q8ggU1xg))T{Q&)0Si_oT_uHZw_mZoM=YNQFg07bDe
z9#2?ml=`+X7NJOozN1v5)sKW;iY(!cAfDR<wX;~$bpg5t)_%-^eoV4ZKGFf~%n;9Q
zg+=o-fkOPIxZD)DGgY)Zo%*q1f&a$>cP7qJ{(YuD3lnpR$<@OI|LGv~x0z!9DSHH{
zeWk->`e}EmF>+Uj=gt(rOvfHKh&)rgQAws;k61XR0;gL8Ct`5A6TtCY^Le`G?twky
zGdQW!y{CakiQ5DGW>J4ftyIR_a2tpZYOPYYqXUz>SjuwGn=z3kz>2k6?iLZ8<Hc$=
zSnk$2=%rA4W1W_}jVb8l#A3~syPeuPIYS0<9O|CW$09LmjLC=U?hZYO92SeCZFF~P
z+etBb6U@DU!we@UJJz|P9uJaP?ygD+d!&`|7?sb;xByBWOT5y3@qOT!*dmOVu9DHB
zHHfP@?#tJU&5gBL?yp_Jy+I$-<(1pSwkX!nrpvec8?9^kpzpB{`K=yxuC#)bIr<e*
z^-y2x=(&CI-`_qC|GFv3xD5fQ>gXs?`Vh}j>HVu<Nt;Utum8XMGin&RFOSz+Dx<#+
z*p=~%>eFARpJ!!2Lrc{}n<$6)IQ3Ap3bBkdqlw3DC{@x?{w%8fTkQLL$d5-qlwjOQ
zv%Kbp_tn%BhSiHy1+-_Pp9)`A*!!xssyeh}FGRl-w`ioHrejG8RsKaIAw~*6Ojj>O
zwZ20zx{ueaY?+IXrWY8umksyOh`eq(dovYGHDU0ler=qxBY4TJp$YwEO-Tzr$5yXI
zb-_YLKg@<Q9&JLD`w(~4;QoAj6&(&7hV)-2g$~8}e%foJe1x?R@p9D^9STR?MmL+F
z*rB(^rDtx5ZV<od(V<c^ADvUJhK5dkHgwYOTB=lZr*NWUFKuY6_L<wG-xYE+Z6uZ4
zWUN6`-4W&eP$>BbKo24|M_&~RT55C?=xi|@h-S%b0WI|sey6X_GdyUb=d_?`Y%zAU
z%ox`3QB<`xI!XMXW!4iPwJo|>C}@}U$lFreqpd<h!#q1)*8p$l8wJrU>!HXFLqLOU
zW_4<(A)!U~$NiSNzz|ERc5@BKn@PTTsCGr4kTB+RP^5d9OQL@g(jv5OER$>$`pI9<
zc%Y0lj%oYxQd88PRr0?Klq@!Xp37YITvjK~WhQD_Tj+&O{fNPd70Pq#0|w@YFo1eV
zKz+cc_9F(Tg8=Z1lH$4D0UNWXADuvbDxh*_R;YR?Bi#+-)sGI~<ix{se}#t9bKeYn
zjSGAUMh|dj6Y9AG;HKllJkzqxAZ1$M#Jtl{4Fc<Dm{tT#dwVm9ZbIV(6d~ON;JM$&
ze}9>i_6wBpwP&6{FK}p$n0Go@(+xcbLeFryxhCF$8&!e^CQJQ1x&*C5+Rdy0zX<AB
z3;Om)#DxRqR9hAAbWo2PN+i;-GTz#>w6>NvPN>I>HxF|@FBt#JO2|<mO9QfDv*oEL
zqx*tjp9+FS>x=>R(|*AJU2*e<vZsD24P>OMwXWUN_2&a=EnMbMzY3&zE?;x@Tt3_E
zxeVWPT}<Dy*c>T&OF1%#4<`>4JQm63)5<Y?C0T-JJ=?6v@Wsd#_MFwYp8`*9T9FZ&
zVuQk4Y9cwzY$RE%KH0{3L1d&Rc(K}sRy2%}QO8Q}nFR(ba>`J#M6JR6a42#t-)cUV
zXe=`60|w2d7ArDY`>|rU+oC<Nx-q$#G%|%n0INhXKK^M%rfO?etXW%i_)%*hUxoG}
zqbbYRc8qp}y&k=g6**Z4<RV=dbI+v`j;m*PLB_Jb!W=G`6FN?M8+-TcUK|7X&a{&y
z%UuKb*0j^t#ww~cfbUH^{p>A_x|`nH58t46j<HMNHh}L?J5l>q@;MP50)rlahpC<Z
zHcM^By+|u3&wds>eTZi{6YY!`k`jYs3`d+v_AuDkODAM*KiMpbpgZM5q?R+qEZ}&i
z`jEY6-h&jNv;oEDjcaGQ&3BJ8efv1)*NX36M`{{c(fjBr^(#t`fh<&;IG<s~buQ>i
zE$6q!!H%?rsIU3+jI=+paJ{a6JB}KAk!Iu9^cl_@hEckBEUCSv_)r`t8yHAPx8nTS
zu*7^)vD`o6ylv>{-7&vNHKiJ>FptFIouLo)mmoe=Z;8z8NV87Bj||61O)&C4Hq?`?
z0l`AWN}JD5XZrS-bEESJ2r@BpZjyx?<^xBG&dsvwz?MbEkj^c}9>Ho9ro@(WtE|B=
z6*@|AtDSS3(>#`OW&e%0W}Vv|J+O?50_;+qRrZS}d|G49HmB)WKltrI@UkRnIp;g2
zBF~L<uH+?T&JM%jMLHP+%h_oNS&`<Jq+C(sTwt`sII0a7z%;RbIlBz8f7%~e7B6&k
zgD?O*^BZbvFyV79HY@|J0bJItusfhwCeR_y4%;5=E4kCwLok%p*{EO_*iT@ggK5;z
zY?hIBnI%{+(pFU)Pi|h{7;k54TxjSST=YUgyU3Jsq!!0<Lc3U2{7_obj!@4_>}yY<
z^q4ikJY4LowxiG`(^zYqYwZtUkF-_S$D69qXSAHtfP}ivR2VCg+|Ve^r1M>yYha>j
zO@}63Z%9KT$<~HCO}oL+#-XrD((N^bq6nT0-YAP_-?P6bYOPHBH7mnD6R}ENY`Tqg
zjb0GnZ|j-J>5=LxD7ju5T<1ok;JOH=G|tVop3|IV4d7$RmQ!he!B~o=)H%r=a~$G`
z-p<K(O|{h-Ib2qyoE%$+HNw?lIcc0%Ag+31;YJdR;<d=Fk*+RK9#&x+>d?{#lq|6D
zh9YN_t7~>Nl59DL<zkGxZn)$@qz$(*S<cDEJ`}yH^ta9_G7aXcIlJe;idA#J1#-r^
z?@Nsx7ij>^a>f}id65QDWMK=6kCryxI88}=iPCc2?NSG(VWpZ2mwB#Edn~QbkLx&0
zHa?21jP3NY#-5Di>O(y0ta5iS?V5GERv1<*jpKS}wXve~&M}XzJC%lpd5h(&ch`;w
zUrv@aK$nKo?aLu9Q!GQB+3HN30gfc*wzf1`PKna0fxscQCYGv8gF4(|IdhbmacQ2F
zAk8%#sKcn#mNU;ZTTxkGwVX2bOOb$SP+Mud7TYCU&|YMk=^>Gntc+u7QENGi4fVK4
zjl6=bsY?v?cvMm}T-fX&?@~iO0dYe&1kskW)^0|GGJSitv(}k%0+UbrrFG7C+0CJS
zY$$Jy*Wwm1%Q?d|8;(rL{C3qj(~y-enCp!dC6P_1tT{Pn`OT-SQaM$Qo=&qpkZy5<
z!+|Bc4$S_rjN?=r0%ktJ)nZPKlPk$HM7QB_XNp*dS_2l;=pwz&E<qeJjWx^J=x$@2
zki9AQYRO(iZ~@Y^-7gNhbZqiV0z`2{ipbiRi6pV*Ik&5wSWwg9e&1v)L?IERt^a|^
zNNkk(ubVq}D6Sl_%cyF=oN5lM+@0!uQ5kj6)PcK9NkS!T#!T2bU?jyNEzNob!MQug
ze{Pl;{q6~}pZ!B|Epqf;qt{TK$oHvE2`gJSus>9~fgPE41#8az>Sb{~IZ|ahm<JT6
zPFS3?2B0;RN86qC_LYcsrf-iqJJpFNB0<@bU7&PJX1dT_Mj>_&)veN=UT8?@MNx(t
zIu^9e*_f(AxxdIbq@~qSmy1oDJ+0a$Mm0UI0Q<MqYoaSUSAU!1EPEXE$TZfd)8ur*
zE-N8Uvtw35bau5koOrM|(4A2tD2tq9I~z^Uje2k1iFc~)ODNn}=R4yfqfbJl6LWMS
z8z0f_rf#NlBf6PJyxTC9$KVRHerJNAVq(&URrQuetg53$Gt@LtrE#2S2<aS}warP?
zqXbMcG!KKgHtu+C@)uQ{$;K%|cL`G>x^M3jNvvo^1)Un{&Sgwdx>nc6xp#VMME3$w
zJ(fGoXda6s=2x}zRzGK&;TRH01i?%<Y(u#bh22ognGw-VbG9y8`NlfZbS_O?VsQ!#
z6}`ct2HDUpG{VP0xSpChGYtvdfnk~z(S!aekp`d1Cryh~)zq|d?N}#GQRG&MU;*-~
zwOZ#!jeROIC)2m*Iaj(#=2o*L$yKgt$8<fv+E}p{WjQywmy0yl8el48t-XV?w5{Cv
zhr|9*m!f|LBR1W1|I2LWpvFs6{*{xIGU}nhl*0dS!+^{%RrYH~S4h9AWA92TTugU=
zw$f>gF)<hL9LG2#7gl1-QpaJaQWxqvjgCk{aZQghQih4r3`9&bfNYRW9m`2qx)flb
zQ-kHOMn9SRm=N+JSih=S+T4iYW0t9!$PJc9EYv!E4QXnmzN%-O+0Rf<jhut&sB|;O
z7}9C7tG|GKM%0j|L0m;cYf`HJ07IM(qQCb)(9mXJd#wdkC8n;Bm=?&YoHIyqk;cg>
ziZtswFTIq%`B92SEJPk`TC(}N<vY%_e2b9JdZ1HppN)*o)Hcugh57-kkxt8bM13To
zT0?3!V*vE1;-t{EPeSW41op?Y{Uo*~Rz?fQ6=&N&g5N&G$2rlo7OY6i=&gU6naW~~
zvRYDSfT5rrVt!iAz%-qip3eV4X*&P2B1tSBU>U<1oTkTP*u63Jc}SYhNz_)3a&!$i
zE={*bC@6kEctYAGQnXEd9h&x#SW#aWRk5m`Xb6}u1!e0TdmEI`^zGxEmm@1N;E%{6
zob&65KN(2s!P_f_;7W9V6Es@M*7Zpgn&0|OmFSMNd(~8Y)Cb*bVjKFkh*lFbMqJ-*
zGUttm8HMWH`&~r$TdW3E8~nM!?+rCO!n=akH_Cwa&4`JnZl(SZ(dm1#rDi92=Vsa|
zRfy1W+F}oGwo$pil>{kD)E*ooVcaedjwPCxHst}}vF61oTo-GlO*J_ht1{wFr8A4d
z@thgaoG^kDf6UUEa!Sr>q@VaIa98kh+da|##TX<iI#73*nF^q1!5FLEa!;~<q#GpB
zKd@rvy)<FD*=8Pr!Q;||p7*-L4GjZGvW&2wm_&^*-Ck6+0W&c-$1tE#5sL9Q(vUIF
zHjJZeJzB|*RLRPOJKBCuWQ~*tZV4}5cgNUzd*ft`d{V7gG_c&0jU==!iIO%DPO)DS
ze|b1rfRjh=w+zD+oIap^tdW7Xy;BI|Y(4HMh_sv|gz?4)j?T!D8#mVwN>TaIAh{Ea
zeLjvo(4J>RE`nO<Fy$DEJJB$e>&aLNHWl1ShPE<-J=NM4%bjeG5oIeQsH40S80QnJ
z&smA-m+LRY)bw&HjVExd!<}jb)%S9=+*9p0MP6ehfxV~G3|At8-r1dIY{^KfxnW~U
z&g;0-^|Dh=2hT>ev=-}CaCe5`J&$v3Y_;n7wwo_xIVIB?Po`R%MP17+u>Xu;<(Q17
z8#N0J|6w~V0|nZhY3v{3Ku0HrCAuP7?kvdym2*TNc5#bj=C5*a#v=i?RAX`l+9S7E
z(plwvX-DE6iAJu_xwB;otaAQkN3dpxTlR4bX({L>hW-_T+JMz141e5GL;JV*#|jl_
za}4ckJJQt9EXN+W-95LZ6`MDfJJ&dGcaRblXnOS73(K8n9B`(9=dj%QCTbU8We)A9
zzCG7nAg8zVp%gX&a{A0&Xn6Nv7@+I6TV{8%#^&IZO7n`1s5pxZ&l66hQwWPqnmps6
z!HeTO3DO?N)cCNEyUZ{@?^uI*VMcn+bExFU5{<e)<p!bNMLcMB5o66<0&ySG4T>8>
zm81O^*H2{a^(@6=oj#I#r9<8H$=`v16C14bDdayfVWrEG>WQ6J`l)P`PfRSpYG(Rr
z!iN092s?cmw`p-a7P?Glpu@OtnLdO2mczbB4fDBPFzjPe3s|Z7o}!gr$X<5Xmt>fE
z7pQ2-crFf`#F#63E}JgT<pLwtsp0IooD~gZ+lJ;RmOhq8?*_e3N#o4o#UOq?pFUon
z$+Km{Ha%CnIkCi4D}92ts90j6m7eFPNMe$eK2ck+jy%~)pQJ5Wu>_(z>lg%%*&@$3
zn!`P^xGya(G)bTTLoo1JbjwX&a%rH{QlpfFRc>^OF|1|U0+kTfa&1x8U`j||xex+8
zmkVQ_j4k~=gatUrC-bB%=OddZzakB#m>7L5rGazj=J=+SGOPQmA-Qrk%5siK>19@*
z<T+^$k5y(jv@Jjr)Y_U#u(CMmGJed)Vjrf_H8@=6Io!d73S36?Tt0N-x$Il|%LzZd
zNNo04CP83-InUQa?iWW+!pj1<>8%-_H`9B|o*Ne*JW<!P+N@7P$Q}@nNx|>A!o~A-
znoD-!m@~o(h8u-}$Lx+~;ISMqJO(EnIuFKuV^|WPiOAbvKb{dD0dDDCZA6UA0J8H0
zfpj>Y^B|6lgoD9wrBDaMb=pucJ*R_=LJQ&Uxm+3cWU;_=Ig|8Uj^uD23`;<s%Q<f*
zTg$~&3CnZl%Q8)*K`;9(Fr#P;Ai-fd3(feOn-<rJaF)8`S>HJM4^-sP(sMrpDT`YN
z{u(|OHXE@J`#ZH6%V;v@!8zPuxyfIMd(#B!>V>#J7%OHUT%?cV<gH$q_@i;iiZrlI
zasFiN7*gtGvO{KW5bIH(mP;~G=Y3iD_xTPRK7NgWy7z(7O&MmrBKLoK6zG`*|HTg+
z@#M0m=YA>a!I*jONN!yCquBL0?$(6ek~Ojl=LdSaS;RDRu(fhLk287hSIBhLa@Lt;
zQbb+Psn0Nkj7Uujo{n+OG<FWlK0?T5bx4QkIjyoVq$hc8CID1q?vEt>MI!jD8jo$4
z*$v4iIlp|q%gW?WI<=^A&NVKFvyo1&d2QgO`_8q#KrR2eAOfAmjSW>80e{y}uuO~5
zt>s*A);zQHoZtqtBq}TXEeURuux;3Dq7;jqjn!1WW$`^j8x(2q*EjbW{W-VC2)x^*
zCPvb$+GO&-Ulhi17z|??+00nZjqVMIDOPw9XRZexe<!S5RtU;1*FuhGo#$Xxs1A6a
zLqp`boJT1ciLwD!vs+M>-7zfQ1C3G%cUm@jxmdy<Ku)I>jb)5&r#nM8^X{M}C}nQG
zK9udrwxd3m;1*~a&II9ZdyXIqe+fNsBqG+@vZ<kFK^xuyXaISpCLb58O3sy?PIs23
z93R74i#|kVL>6g>6JmTQ0yK<tG-YT{z((q9?Qmi&(H2kDv>?y04egd_>abXiS+wPi
z`bms0OSQvEI1Xf3=V(ecD0*4IovSIsV;frPQXuNZGk2cut473{MAk|@Cv@lQ=#PwX
zPsUxKw`9h}nq{5UU8s{UFQ(7>xn+9NHYL`;)dF{s_B<_yB?%MEV!aGlG>DzPyM&#-
zlT$i~>vHZ=Ep2`b_wbg;cCuTpB`g}m%M;yYJlo*ptQ^D>NbYjI>{c18=I#fFM=6|-
zTBC)mizTWyH?~yO$YD|UbWJ@gRwdhA?%L5(3Tk3iW^uw@rz!QZD#?*Ew4RM9WDQc(
zHlhM5zYwi|4P{`c=Wga{E)132PU?ALf-BwbxooO*A5jlyDY7S712N>1MDyH-Iqr(-
zG1$-aZnY)n#o{<_>;7Et>|vHi-*@;D@C+t`u-wBx0)^Yu))4oD{uqYGnpZToAaDLh
zM-c^EALe!cq6u!SL5};nA8NZdh$lDQkLVX`cd;t%{o}!6k0Qbh^LR#xlND1Bm7c)-
z4SUztK*6)zFWX>=HP690U1av({qPf}{QpCT;KuYKfcsBv_qb)LAIovm?VS*TJyUHT
z;(9Wply4;54D%_3rAOR-%$Nq7e_EGJGnvYQ%8w#HJeLDYj8P!cbH^bPI7JCu8jnwb
zNK}Sc!yB4$Jg}h#ZJW-|wxwL;X{c?8*T_t}&9ZAFwp}zC!vIX2Vd1zVr@^x8WbJTd
zPQtPqBCHD*E{ASt!`x(Z`4r2pa%9kM510a<3A9U~aE3ghlangiSU*O{6pJ>dSWYK>
zZV;Ez&m%~NQ>&fM_OUUnEq0y5>N0W+2h{dC4tw~KIn9>cB;3$t^dI40JMR={YxF0S
zDCN?=Saw0I(F)p)`55f>cO9k}B;wDqZ*w>r$72q*IYlX7dB`NIe3E7FvTb{%M2t8a
z<5TXWBD*ACMj%Oj+`=4Ozwbo}D{vsYs*%-h5jOqoMd`wC-v&{q>|wZz(pk4gj;)fa
zYL}<~7*1JM=p#quAzLTXB@Z*LEPC&yC}xZ$qAPOmJ<qm32ZQ9^dmeM|6wcb<z$CZE
z@kta}ZH%{8HF8Tx4ujeE$TgZ)Hdy$ZI2GT<>9o7YW~DACbzG}{;s)c8;?~xx&6fR^
zV`sx*2~0Iin|LFcse1z`c-9^^2K^#zR&HyYTeVnK(f*rk3celYuQ0E``ver0CMNM@
zXgvYGo9KBNEP2=f++^9!<T{u3mPXyg*)3$b9wZd|0!$7jvdG^H>k!bMgh@XY7d)JT
z^6(Wb0I*E~7~>Gd@<UISne&DANXh1Gu=5N2)nF`xjH#>>Bblg9mvt&M9YswM2dqEz
z$UuIqz{J)*)lR@Ki|h^Xe=YsP%c=AN?^8R0bL{POxl>U(PGuyVF0V%)K3rqjvurZ$
zhm^ZvUV)@viKG?DrX*Zxfi%SYp+5L-u$La2Fow40+B_XI2mUe@j@q6^Es8<*)kw?^
zEbggE*423&VW_S>Tk;Ys#ZK0x@O)~g*ypn<r*&Cr_;lpdW+5%0@<PHJ^t}?axTa<)
zW_tFwrR<kOjYnWokakE^fs3z63&Q@kP6c-==BU2Kn~Hg(Z^@b}(llE%4=u)S;!i?g
zp0qocvV3^F=;A;1$g}KQL=WoldzcfzH)@*Bm|Mbn++y_j1|d-Fb`f$20=|M-4<Vb3
zklVvTZVyMsSVH;BCPI=2vAaVgT8PC-FgHWut487-VTpHyB^rxP9%ISst?=TibK-j0
z(SAWf$cFSJ%=-vo*mNE77fc9D%oiB|-+}F2l+4DO5%p(#J4D<7Qwz>EBj(S(q8*m~
zXQSt-Xvg0s9_ez^vb!y;%=Oe0bU}Q52}#gu*>h~sZ$E_I39}D=eh9(SQ6}c-#aa~d
zUfw0?WL@4~qCMXWkM}d_;JI#w_PoURJe^Cs;53>|=Q1v=<U_5SAr1OcaXlUzA^GW$
z!`FBVkSJ?}TnKUwhI5vEy7-!$jZ`XN(Of6)YvEpySc)&P>@#c@!e$Wg!!iQG$l}@v
zRtZDV*Zm8MQ>Se|f}lQxxfFh$F{*d^s?QYVIs?_E!||=2HIbd}5qKVocs~IFUqHaD
zi6Ek3n3XTkoi$IO_l-KBeqL_d+3>yy=3fx82<tIS`^$UlaCvVXeCsz$ood<F+jco5
zZiJbFRf#K&)a!kz(<Lg`>ouA#x3_W&Q%#Ba++4M9v+eB=@dFsXXPZ`_mAlOsqZ8;h
zU%4VC$hX0aD#XevagVUU$_kRhB+pT03g6qXSgdj+1Mh{1mtk%}m`hBUs~l6zb(pK9
zZ$lH_TXoFv+RWz1!;XCjGF&9;=a6%&k@K)GXF3Yl!@iUPne^H}6Z<$1>h~)0y0rhz
zk%*Q<;t{m@d@c9$LY*RC`ceznQ~kqXSG5!FEXDs6p|{Y6MRHqjtM*0TGUH<=(^t}G
zZ-RX?`(%`4B*Y-aLEIGxrHEs~C5S*hnNL&2HL(9L947ApVbXTkDl;vsxE06;KxRJ(
z@_wi_sSA|MEFd=k*+=A7AkP4q{1UzX5VkjIJ3`wpV8g8p{FUTGSH5HM6N-5o4!LwF
z;gc40dV%DZL7q+WY!BVsTO_&2eVz}uCbR#Z^aVIlS|TnezyO3t1j;8>@X<Srm=p$g
zKc0yZ6QZl6K#fQ&u9DL-*!dI&?$>Z^>PoujG{adtMKnQ@Dow`kIcAr~PM2MtoSK$+
zTd;f`9Ll#n?Gd}Yfula>Z)b?h$T9Cje>+nuhKzJa2pz;;Z3x?UPH`|4yF%G44gW+;
zyI~H`(k0?bWy<Sx*(9>B(kn$>?s(bZv9A{U+wd{n-)XY1F+5q*u`_M9AM9%lF<O8Y
z@VjCe(+}l@1?_q{pmGMR`3dAbbtsV2P4?ZwcrjdxSVrkugiNvTQKdtW=(GCa53SVX
zO6JsfSRMfDq|<;*MbVu!AIL5uD}lU6q#8&@6v+8N)&QBzLDr<bu>F9xi)s4-Z2tqB
z{`E>Ro{BVcS^E=ZTL|tVn16$NZIMp0Pl6;%;1vjPaax5co}UlK3YZz3lG|S?&dIsr
zGGi_Rvj43(E3bmVNV%Hdj9?4UOta>6RAW1fdrtU*97|RxR>!zDUpxO2CJ8@}Bk=Jk
zg2%Ybue(5DosG)6(sQs)<_NGLQDWHxWt#W74yOcfPB!CtLVE-rq<}j2z#KaO;}Roo
zgos-L3dQA!xJKA|7bA>V@o^AVGND(#Yu^hY-$H_11IC(SohbPt2w63g`&-~L{pbwd
zWMvn~1oQ<4gVIqbjvq3ZUd<OLDlLt&!D+A7m5I-(^IGT$1JUo8pjP`qP3PJmIQ=fW
z9lM%=)tiY85nA;aI*T(6&DsW8(!}XghgZU?wOk`w-Uquis-55Q>)R0QjanCbUWu7F
zZFJdivdXtg;5p_PuHB}sY(MpqWe&fYs;oAGQsO-N?Ah?lRU`WnSEkCN&kHEG8p?M9
z%6*!GsWmT#upf2#X{5-N4}I*%beNrsah?DtQ|!lOAu|W|hGzL*)qX<KAP3Es=6KSz
z&`{^J=z~D^Q?j!(S|N5h_$VEpbXxXvE@z(B=usq!s_%#zBXc^n%=bkmI8F;Vj?wde
zD9WhinpJ?_Sv<e05pG*_!}t<1_RtVa{SegSb96b{5;5(OG#p!HePL`&7td|7#;}<-
zeOeK{{wwhJl(@I8NW`l#pVnvf?DK_r#2{3SM^FR{nwTm3gt!F6IS-*1I1WWH8^%5%
z%`HXe^gd`8z_IvEAlCu0W^+YoCfo|J{lk`2&gR%Z5;=E*qoARuiMH$?3;iwe$%TnJ
z`eeWva^&Q=V_}ul>66BcKMi(k_7Kbw_8}TMWPC>?6tS#xVS7H@Kr0@E;;<0hledE~
zDI2!m!#3$#KrY7y%cSW*o+eTXWX^Hu1z&>uyD-0j3X@tuy#!QryAFn12yD{jAngTd
z(q15kh#Ua2=6K7R`!gW+>Paus0rp9M0x};f&?O_0S;a6XQ@}K2{L`RXCHEp=20n}A
zZ-M+fl4l=wa6vdppTYk}Bu(Z7W|9YvRj8bkPo`}UY!|SqLePH1_+^-j>FW&mIzWf~
zlOTICBX>SXk7!<N9y1VkH(3K=?BmiT^In0YWZq%Tr8k~fM*2xb^IVp*UJX8`E|`zw
z=n4>QucLKJvsozr3iD4$8G^=}Bi+I@Q!slMXz`Afnl$NukHFL0NXyA5TGm;{<09Xq
zl<382Y&tf<y|)_rdvAXw)c$^&eFSpmBKdCu@9U5?b1(eBLB4qHvZm{y;P>@erY@K5
z_YcJKJ9x<V;By*Gfh?xlccxLq-x(|>99%w?l^!mzJ%}+l7(a#?I}GFSdB|*T6~loI
z>*Jt}=bZXM`E+0~_8jtgIrFbzW{65p+El3w4oAgFuR1Xd%dwAue-hI3Oz^#nFqo#6
zKOCJeGZ;%opa;P)U6%eVeO|Q78;?#yJN_Mxdgy7(`r(9ZsB;KqYZOG!V3o6vleNIb
zaG1fhbNhIax(W7zW<Fx<Q+9*$O^X0f_lFYmB8c1q^8+xRH($?%?>B{DY75kVz;rya
z81W-*(X;IzYl~it_=&ber%I$A)csLxfu!+IwcC(|k^piH;UntRtBC4!T-maug`xf)
zlO1UFM;L23$|*EsTK>NGWXD_>gmE1DJ#Co=?)>k<+wWj>BK|?<F=xQxs36Vt1NMWc
z4B-AP3QhuCix=p?9t_GfO5IPT)ICq>+@4(sqoqHU#@WGNM0&4|J~&8jU!&{IA^4ez
zf;MCX+FcXIH9;6`7q68-l5p=`|MURL?DE)$w74RO`W4I_VE@X9JCvq}X_&sC*(ty{
zAIlITG%bgAgrTjYVLd94o`qV=9-VHpYkUdfe}uw#I=HV~2<<<HCpdCplcS(tYpc#)
zcLw#g$E4G`kHMippDebgVav~kAPOr(YUZVLe<5wfm2SnAZb8bjC#JI__&~Ip$Yth7
z!1*Vb{v$2xF$6v9JP<iZu2*O=E`cSY4nmD@j6^xtANJ~%=0gzDm5nhe1nn(D&TdH6
z(or^e(8AzDII){Z=qT<rQS@{a_ew0BuB;h*7{%|&iuJ7!SkTBd?S10>0_>ByCREUF
z**8giaz??1=-w<0Yhf#5-1<VD>%eH=nO@9jCEzfb>o&dO^^GyZ+}yH%rDL`qV!Ry8
zZQ*_CB0pv?q|2F7<c{e2qUef&yN=jPe#B-!gYX8xmyW^-vNGN>8qq7^?Z9O)Q{b9|
zvFFD+E|^~ZRfJiS55X^8{ua1=sa<*(+vV|UeDI0^raVY)&(RaUC{$jEfG&eMeF@aY
z{;2+L!=CHOb{KO78;DpGnkQ;O`|13+QwTgqfwd~(z_QbP!;vK%LeL!1Mbc0%^kk2*
z3v)DhFY{QeUq;9UHQ?3OMPrytH63tYB<{Bw0ys3`SQNCfw$AxAt>9TKJWkiT0-=CO
zQ_ckwGkb|>bOUU<X<jP!=jqD&S1#5glvt(Xw9L~v<_Q7vmK#E}tSR1v5LbFU{iM1s
z-9`c!RvE%GTPJ^stSCSNVobQ6JM&<#5(NuS>Foe-8^oa=4vSd~Z$d_#?4lUfd#4~D
zq$pkq$NVo)l5G^KUd2&L?%i-HqL*4v*ndv;BVe_Vq`laWD!upsRCd2*59k_Q5X#|a
zFU$uJ@*WEU)5Ef_@n}I+*C~!x(Ij}|qS-crzRp<dMWap#sH8@FJ<~+gPu>oDZ)H69
zL&(hHE>f>H+E>f6Z`C^Ohq!Bz{d2x$S$|jxop^A7u5xSu1+$gA{v`1D8w%!(_o>ru
z9^11g;YsrNcFE&6Xq7U85sfI_cPt8pMB)cxA5VKNQqR6a?2BP9!^GrHlfQenm7y*1
zZLe>Y7>|K^*D=OF(RpwdJmpUS@ids;(LOq^NZ+6~K4T&bPwNnsZIE(ZxkT8qpY=>P
zBDD+?C5ew;4Qba|<V}|z=9iuv=0)=;iSa8*44yQS#CSnGr;p<tOA_-%NlYE@m&7p-
zj*R!qCf-+VvnF!ndlnRHhbe*k&!OBbPFYYgW^oP!b&eWA@XSE433$Y_x5Mk@Fz3Si
zKNvS8<`K^y;Rd4*tnT1&D9%K)nd&)biLUeCp1lYD?}fP^G8Qj`3@-KjTlN&8NCCzq
zUyH=Qz};FBUfM1Nqn9Cvt|@?>)sXR82`|G}!m98P6Dz?oVE?mUU;N7^Bny??z=#CE
zB)uxtk&Cti`wX&lj+1-2^|XRTucgC^A6Wx8tgF>)t_?hks!?)i3>~OLKk9B}*WEbo
zVRg5YJA8cEgbV(>S?xM^&z`)(>WR;$3Jc4;8`Z}d-he$by}CND>xRYCXH9QZKTds`
zoOz%<e?r;J!c<|qSDY+d<aJ$CFmqUa@y|D${m{Gb7S_$oFD#rHudAz%*XP&Osfk{0
zWzo!QhUXX7t=m{Mx3I2ZvudtA@T`jFLhyuComaM|&Z|=+3Myw_adX+G{57g$Vf~Ck
z)z2AW7ZhzQnpQMZy=f&2W}P^z@yhC1-k`#^pB3g8s`k57pInu>W9FJg^Jc1K^1b+)
z!u*NjChYW{RsFo&H`G~PwmR8+r=Z@e+utbv=lJ;DcY8w?s;XL*ovY3&_)KLd)d727
z&e+_BvhfE_DpYS<pN?FaTePNomzv@%vG){BpE!2b&(y2dtLlf_c6iT^hXT&nW4*z3
z3kp@Vws1lFjQqy@x}6JV*1uS%4s0z@xAiShziTZ}&tl8zQhVQwncncS#cJTIYua8{
zU0e658P0TDWxS)#_9|7Ich}8oy_fCP?aZ%p#t!=I=iT0f{a&|fJNRr$W$jqgt%g^A
ze!)&}nQHb1sJ~lYLF%R%?cSa0q<#5y6BfLu;&+u*)E7-F%r6?>SmniDTQF0du%{>=
zX^YH2xVLP@C%tN5!5X#E%T?nM=D;251AEUNHK;%}6{vo>o7IGcr)}PlN_DrVx>G6D
zXP?^Jd2rVBS<aZj-qa<FmZ&~Sr0BuAyt38mxJtD#`GxBLscQT5f+dA2W1s4CP;IJJ
z8A)$~cVNw4^@Y2q-J3mq;+mSe3%+}<+FVf5U6@}#zHnx1*UT9+r_Vw}k%Xt`7mhFV
z2G-5!@Cxf@s0L)%h39%n)&A;3>d}bzOl95Tx`$Ig+dRFnebJ2%b=Sprez_+v^?K{G
zh0k_P8+rYDmGSA_YhHV(`?I#P_&vY4EY*HeYEAdE*X=pm8<@&pySnbR{KB%+zcak9
zaQYdl@2jI$?6~>@@7Z16h*V))*F?4H8TCEKduLCf8kAet-acM++k4deTX)=FmtTl%
z9r%v-?&+&`ww0^Sq&g<K^B%8DjXvm|t*%PjqyD<Nc1@QWn*2<?6oJA&>P+6G`gj9U
z9plbDrF*kFvh^<SB(*kI{SnzeaGx4{*Zpd9?X{<+%2F-f)eoceKD_N6^^3H9>S+;l
zVB0~mcB_3`ydB;76I7oa&d7m<-pt>oR;r9WUhE3h?=CgW8D&qLKI`4RA9g+KrSd22
z@&<WdOq+x{pxTjieF~t$GpfDzv$8dxb>&Z3bD$kU;uE^gSHHAhMHJLe5$H44!RLOe
z-mngKtM-G?zIJt?y0T-3SLf|K@R@qwK3H)z)El-(o%88y>Z&aV)d`g<UZ95VQE%8u
zb^F$WvQ*g(>JodOdJguVZh6P+N|jyqsQQs}P~EWw#q$kkpW40E8{iFmO*I#&QC@AT
z>?i847BuYIR#2|`yy_KRp|b9JEmh{7sD8ioRrR#>jyisy8tc94jZh^JG2DAcJ??mw
zh209(D5FwsDwsL7xx3rj$%;Q<pE@Dg)?SBXTD~yljr?0TYWybT!s8Zlv;GQHqbpSB
z4wX@>b|GEr%G3!vR6JJ=a0*c6a@D46)mhp7>;aWka9UT9YFyZbnxV!n-1Bp9>V<Xh
zrgrT@<ym``x8}ft!kKE`4mG_}%`Z^X7OMFRZz+7CP-Q<;_;{Ua+*cSctD}m0Q2NIg
zsvTRr%2a+KYQQ2Cth*|^?p{#;kTYUn;j|L<N=EITnLASlt}dI|-qkjI^$#CD@KE=A
z-oS^RP1UvSRCPO4g_lgu^d_yo2=!>{Lv?ENL8Qy4>exN%?A$_iY^_Qh^pL4#bzQ3q
z%a)aGQtkT=sA;c`Iwe_n<yzIha`n2xHH$w}4f{@S@E%&HI=tL>*LJ__O;7{T1QxEV
zA9nf)#V1Tgdz9OiU)WYS3C|&Ze_JJ5)>?JTwp_NbWo4~J>e$>*R7>u<!iTz^SGC>_
zb?go`$jjZ+1&@_zUfX6~*{JT=wnIIEk2>v#RDbA|jiy}P4OuT+wG+@j)^^8ds^_gr
z^^<Ko-i=>T0j~up@B6%+v^)Vzajo}R{NV~Ut3b`Gb#nT@H*QkREH$-Kt*>=X?e9z-
zbY@|^LG}Aoo&D*~CUqK0&VYj}u85yr?_J=%UO2uB&0x0LzV#h-y;FIiSBQ3Q-G;NB
z(F31-R&CtTgqn70e1dAry;g1Z3e@0tRP!_5YwG<iJG#_$PGy<*nR<82!K>7@&RuXU
z%-{d;_$yS^KJRsv<-LQV6x-pI)lE`0&!|6bK|%bs^XYpPGsm5-rsH0fWD%NXb>EhP
z3)S;Zt$JWf0bnHvx#~ryfDVAU%@3%Kf<iQVx#zC&)_TKPp%<#nd*1cR)HU?`zO%#I
z=@srQRIPhdzdfq0K=rLuS8PeDe><N-?SdxNncb;6b35yPj`&Sj_Unhd1NjrW3RQAn
zst*0$n*|N|g=-!`>B}mZ`E1*!$>@Uf9F8NR=-hG5KAx1Y&-1cemzzQ(+2fmEHehi-
zZ<jN>Z)8cIC&5viS(+PN0OU!GRpghA|6Ca1EA1PZz0<u=t;~&<KVJM)F}=Wz10Vh{
zz_M1u_%i42j9lnmq*modQ{;YH_>21m{P%*Fqn4xi&&iD@dide)>zob!i$naSJJka4
zQj5on2ijIP-1y^G7{*zFT=1>PjV>2HE+_G~A3Xg4{jf_-T=K*fBR;ra9dciw;{rKO
zYmah>41T^J9_vYj{770k^ZWQoRh+r@@sg*CnY@9nkH8PtjD0<p<z~;ND#Zhxfaef+
zuyPdetoQ~V3$sA1a|ArALOelUf@fujNAx>8q#kn0PaiI0g!Ni&(#Ln-5BJQFtp7+q
zxMN>2(8rVo=hoclCJ9lOhWVKbaxGsbPk*p1`DsyqRG2*6@qcp9j{Kk9c?M&6Nd6f{
zel}?QZHGH%qCxn@J5}}LrjYw(kcS}x8K@6srrs=)T*cuNk%S!u@X?RNWnSONS`!wg
zE%M{Bh5d++A6Jt;=Y-OxIMaC_#qFBh>~*=(X~rKnw|Ro?D1S~%$m5($=PY>qeXiw{
z<VG>!HGXB67r5`&uglIEK^Z8@wdQA*`UMuee%<CK?KjlbZMo5PJ=Gz^FT1dzuu63O
zSr5G~414h9bF;NG#Bb803jB-0{C-{Ij%iRok-mQUD$dQW4<*H1mQj{@{<skr^?KrO
z{Dk?D=7$jE1x5rjwKUVYFV{jtqpq-Xvz>Z4m*-|LLBa-kjqMPqAEaxU$!kB|xn1&E
z$X(JM0-JKPPtUd12Z>*txd_6Ga<i**qkg(@d!!=d*XZ1u8(kev7OMa}{Be(CAE2Md
z<)(aY6F4Vxd2V!NA4Y3-=3;>*nTsWs;u}Y4;GgRgzJEVm+j66|p>!>V@1F2cY8GZX
zOcKj)Yl@IKg&{rA2CvM`Mgy~miG$`EZJJ-FwuAS~5U*}GD=1%5a*@&P5cvK##OLd_
zCO5hy*FxHzE&tWMHA8t05sFbD{IunAd^lX_SSQK!_-r&w(WQMJXUfdaEHdG9z5TNP
z41ZZjd`Tu6-mQi}-^H18nJhuNa6$cDUk2KbIqXlji3i4Y4$G^bE?fZ*x9Lkoxw)C8
z6b!yR82-4xeIMXac{V@SbLNC}o0qvPH@ZiBpzX;<eMTM}<!57vzXVy@D<%tj*-j7H
zN;3UQMAhbGwuan_Gq?1zIdgkip^qOAt_#lywQZ))b#6l4%W#Y@rV?tkpNCvRWcl#p
zfjpd_8*SCuh(SS7<^st@zYKAC?{6Xg`Aq+c+-QAn_DTtX^2Ogm)J5GKGfu^s+L`!l
zWRl;e?8oZa!y$R5Os>t1p5;q4<DP+bY34jMm(q6hPS{ntDp59yxcs>Ag&p4@UNU-t
z-FN58);F~|zB^Z~vP1sYNlohU&jl%TC4qdu{|1T6N?4If;wTOJaE*I}JZs}vDUT4x
z3517`Wt4QnY{8T0*?N9xQXsS3Cu9Q|4#OY_M`_$6Tr7CXBV3~Cfv9ZQC&EA!!DK-z
z2xe$1!8}dHzx=ZC&o14zmJ`sQvRb!w1Imv|ErX#hgex@e5#A<v$|Jm8(_KP?1Jggs
zsDgoB1UCyx0rI2k*)Y(6;6gzw2yTFJthOkC{Mzt;ISk|w80VO{;g2m9<zuZdO4urR
zTa@rt7+c2PK=h&i`v4g$!uvJu5e~LVPkDqx1n<eLd*S|!@aA<t5BLg<ZLP4u)(-|K
z2=XJBc3u4j(8DkuG)il?M&!7(X@1TI<d+Ta!%b*}IU4r}&k{W45msrsOK9-(d>I_p
zZ#3?NZ5sCo_X?i!2>Gc2WA6Lg5BrUVMtHNvJ;K`sPkDs=upsP@Q-J#njqrYrdxWKE
zI+==u{HTEb2o3HBZT&BJUC<*I&)s@N$)c@+hMYJogP|0{6&m*ly9G~qg!?t!CH#e<
z6Fy?-ez0p{uYu9QWD(s5V_Ovj^o=q`aEqYJ2@VR%p@#f6!n#*TEWq+(D38KWOF};G
z2;3w5o!}{tkY5y#htS|1zKlbly=B}9-`2QC_%Fdz9w9#{pbSET2Qt_u*)Vh`R2ugP
zhY6nY2>A&Cc?b<2$jAn5xN#@U(YQyrOz;$zSaGmN(_KP-Fu*+b<1!ZZd>Ea|Lx^(E
z9jQz}A1<bY+1<WhIQU+-!|{9=sz<m};~wGlf~Pz}eq2Bv-`{@NZ!|Q*n>Fqc-Yz(b
zG9bSl2>avK@_mLzc)!LyLhd9nT7;aD&>tZ`AqYqJQ}FV008^;^F9RH_tI}6*6rA&5
z&=hq7@WX*ntCSDx1|co?Jy6I<Ayt$B&{HUt9)a~y7-~fLxW+xgzX+c42>Hc8IJTT8
zeqv~ZpK079JRzcEMaT~Y!v3;hA8u%bIU4r}%LGq(g#0=n?2q%xWrjw$LgOA`LhzJF
zxKY!gh5l`a{d_|s+^KPo@cV+NJVGA$4~NG&=zWGp_#=&bgpUZG@(3T*beHf~hEDjh
zq5FCqg8eN+BRs5ek5HxQ^djWp{jeTK;QlWdG$y_%PHUGLHo_Ge_XsZ%JmnEytm!Tx
zr?laMRtws87{xY|h-T>Whj7+ypnV?(;SyNsf?kzjS^Htwv;o`-qpXeFx`{jl(?^=%
zL|VqzBf9?$`!ECxUV<qwVP`)!z9x>9*G)~k5fX92pTH=~tLY|k1LV<xPzUVACE$CE
z1L1E4pV&>Pqm&nnLs}u7QAO!zK>Z;TD8V#A%L(FwF5d;fM_^p5^$AOY&p?}m@dd%P
zFv@CQ*G*&wLP|&dOv`w4L^mx=BXK1{JrD@N-vwPxz@&jJg5xBGDhQZDpq2ov(Nu!<
zFj@;@yR`#Bw>Y#zJz{sm1Zq4E%b&soTK)_pdJ$pTAS^!<{(<z+F<&i7Epc6agNYuR
zpGAJm(AF?ATEW$R$mH+?CC>145W(nVWstZP41!6Agz;05EnH6!6(PBmA-R=)JmB;F
zAc&yFXAo;);7Y&<Io75qA@dUC|9i-c*g8p^{}&~glvKpAHpc#oLb^D3+1-@PG(myJ
z=V|80o^F#QML7Xe97(Z~@F^iz5WFquGJ>x(+6Q?sO-fM(0h12VW3ur+8K49|hM_b<
zreYfKv>dye_^)BWM!-Z3H7`_2>yg*p4{`^K>=k~Nga)XK!C4K%MD`;@pP#^>oD2&T
zTg?z(lwgALZ~#pA3u8Hfj@NQBJ}Znt+02J4Lkfp75%$S2wzZ6aEMeysguERlOk)z&
zz`zRuS?J8jGv`3|qrgo11cuEp;b$862+zT^l<g=Xzc3+>{~b!WeWi>naqsdP0iVbs
zZ<j}SM_-K-J|p;yZbE*`LLOg_vtVx!T3+`?!1H0CCc#xgp4fdgAjO2LvW?Ifvb5|(
z8eovq)Pf-Z^#j-dWqzO)TSo<6g@FR=J^<9p^faF5!FxB1Zo;#qg{S>(7!(PDcVLv&
zwym4U0>}k@JHW*-G9e^#iO`o3FlfYwp}q-&B1rHSOgIo<S?bRK*#+DW_>|yX>j?Q3
z7#06FAf*xyM~Fcj9ih$Or93^<iZKEdqpVG_?zxar2_qIi3eb;QcL_Za>%IZV&A!DC
zAv6^09Y8k2GC3Ud<UR}I6pBYBA2i8@K|Cs{i-}WZC{C4ri1h2H(SMP*G9+(hNZ!hj
zyp`W1k2?Pn22m&Y4Gijx^%p=UHE}|U2MaZ(bfCUMvkVEG37^IlavO$KhfrzUBkT}7
z<q>YzbeHf#Lnq`nRN)a4Kb0zj2?bjmkb+i(YwKMw^htQ7#y!Hn37+x@`H@suI{oc~
zfpmiZ6*Q<pH^F)UhMDjn;LpT)#ajSJH0sBiT-tT{(?H*ZiD2fk$r|BvaH+|Lk#qr6
z8utkA7Chw<^1G|BhV*v~3^XLTQ_x@$VG69pFw~H+RGceT0i2~#KYZ>E+y_J1g!gOQ
zBRmD|JDWE`ey$Y`|4X=^2pYmCpmQiI{zNH4T1}7+gIcw%n@E36C!kNz?QS9?G~HK>
z+Yl3B7$_lMzX9$M-XVC(BfMABT|$276>g6y<5Hn@MehvUyMXE61;A*7=8qWXP$Zf_
zx>;OT_?|=E;7f3M8HV~1zM^rD(Cx4FAdCo}bP4%k9Q7ki2#$UPke`c$_5LGdd;%k_
zIgzhm(1cS)ISf#OT`*vIcv}->?1lk-KRzA09VXP^PXgO=7#4;z0Bc~-b+iLe0?<S7
z`;quB_x+RkqGK^)gCXuG8C9b;q*0w8!w~mXAWl`ThCxF%zyCn&dccrQ*?dTYc#rI^
z`Mzu_s^v}W?(sKK{Jk&!CI))sfR~>}LVJP*I=Dr?8X!{(ov=Og8~=MPYT$?J)Ba0}
zt%G!(Vyk;nY;`!9d_m!K_I)u4d~d|R$={1m^i>!XJ!V2CQY%ynp8$#9J%&g;&Ts2H
zCZJ5nUc~R1&X(-zT67=a7chvFGZ=?EVSug!sMY8ufNNmraVd&lJq$PqE|SvNwdfAO
zpJ_6|bB0XFbPc7~c~EGt$>d)HenJJU)h}R$l?pPoGXV#~pawk#y`B`^R`dI^4>cNr
zGBHsoubay4fB`dgJYdNDMC`Ykd@K~;$7B>e8<0^zo)fG!WJcpEA+PXN4re<P(bxH9
z;9tWqG5j?06UG<k=Q8~zg*UI8a2pKrhJfM_?au)y4O9YtT*!b4B}J_AaKfY`QO-As
zM0lYjQaJ%L7OBj9&4-~7!V*caass~gf)JV8OjUC9q;5G=R~LfvaO(0)xB^MWazC<A
zwWmPjb$@fBmpe#JB`I1?FhbDPewsrMrj;%|sNle_6OM8M7A9~IJfNurx_GT7cv7ep
z1k5h*{@-%#CrDi8oMTPw4&`8}A1UNusjpl(=U+pzyaN-eQR9#|r%67w3p7=#C{(42
zm_QT<u|<riX<Lf?f<YO6X=kRgv`g!}%4DTje2HT5(_Ac+$?8W{nM_O+;(px|rf*6U
z2E0;~&+8`KKt-$-7Xe%@XgR?Hno7Wui1Z~e5iRxAVwzE_ObNWJlu$=HuiIA;=|(+G
z{7e1#vsYk`01@jx0c2B5d_Q1+$)>J#vwMPE#}-}pE?w)`J~7+KA4=zSp>$s7heH`m
z=RVfHVA2#y?|Zi~F033#uzR<KlK9?jehk81{iF`l{8SFp{NTqT>N8+MrROKm{3)0a
zDU=wMp~R>RB}OIl%A|i~C^0HSiBTC!jLJ}ARQlSSfP^?1CS8vzb6i?Bz=YcJP(wWv
zE_21ToPggkV=l(rY?CN0^X1-w47&#=G(jGX7*6UPOaJRx%>ORHc7p!-#89v-DsRDX
ztVH;>#y!H11y6Z|f7SG08JEX9J~1@H&ou54*5ddE$4rEEf+t-<emxr=OMOK@prJHa
zX++{M(9P!!smT)|pTJN}!p}7B5zfI@E5#D>qgwL#F{VF$F3Z|F9dITL>X+|KCz3NU
z?w>poT8zl?0zMG81w`KmkD4rlVIYJnH0}{r3!d@_Yc$;@yxGtR`FSn<624&QgfAI7
z;U5g0kRNH2pYS6?C*&u+;fPYNGhk5A2{yneE78`?@Ne=h4D=4)@*<Geeajz#9QG~Y
zxZVyTdT;u?Pous+P<>xOeLo>apL7KNK7paSgr8~LBfJ{N?U;9j*9e|;32!rW!g~#!
zkY5>xix6dJi+h(#m;-|(poseonebtlZ(75k_jb*fMYtIT-U+@V=xR#RfpVQe|3(MS
z6%<V8P*HsYq(8$z4#9gcj@2Gj;2I*F<-VLFbdm^d44O;&rWX{_uK-4gkD$ErfKjpd
zNV<e28utj#6FlV+^3!G}H=)5h{7}yVEeQkteA0GU&xfHGLf$tH+#~#h;3<!g-zAeL
z?2jKEqi^sCZ-&8|w<n8HKGSO;@~h;~1nm&4Z^2L&;oBPb2p`1xB<3*TBZ4Pg!lw<L
z@EJoV<mb!b62Z@uM++^lo1f~>gbCGn-`T7(k@HmHSV5qfSNN*)tkhdDq9@?n8utkM
z;Y<_5C5#H5bO}#3bizDCC*&v4VLd5(fY9=~2~UJUmYf1G-H-|CEtFF{ja4kpC;)&Z
z8utj#5Ip4(o~7w7;g1cS@F#{&$gilw8m)x=OrdqHyCQJ!TIZ+6Hqb7FfjR^?30gr(
zk7<;ELPPq#1nbK%OhLlmYTP3{;UpbCVYc8&mylmehxK|7ycwXOl^F^!R->l_G-%XU
z@GCH;fn@fki5@E)K|!AnD?O%J%dd2o={JlRoNxCfJp$UJFjSlHagBR~zZN{@5x%bJ
zF5#PoPRLKV>DQNc2==!Ojqq)adxX=ob#w`f1W&qzU50L%-#@`S5HzIj41lE?-34%&
zMlJIj3Tw6|5#$M4u@InI(A5NSLCXmmHA+Bfs4Nu7;6oYN7uJ(u{FE9CoRWR}Zs7Fh
z+b#3+l|g6Ja{!6LOjLZn{UF^4!&D=@S>qnz9|T7e1b9f(UBZdOb;=P=5<KY=&N6hu
zB10$ST?i~#gl8E#;ci1G++*m3PZ~PmQ-)5MHbToG<X7X=nXuf@36~i<A-`4+7wBI=
z_t#;NyuX9<UtmHh9R+uP@sV^12Ws3Sd~TGMMEH{6NtcixmWM;&!#HbT(B=}{BxuF+
z0KbJv!-y1Tmb!^A8p%UUU3YEeDW>jD$a);6hw@9<j`X4oLs;LE@VeF!GVD<I*9M_F
zycHh<{mg{d2I<6?=<vS3HH{R8_X926P(tAuie-L`lNP+1pi~QbU~3wdY`brREkg@3
z6ka=EqGBi%%@4K_IYT)CHbw!d-xHIdv-M-b+1*wKc@YA^DB|9&X&|JH=zhxt8m9Rv
z7^eAg3e)^poe8;A3SDUBa6qOeao>HQi8TkXOgrj;F80B#+&830?V)GQ?0n-vH-aAZ
zCL1Dg%hs^a7z9x$;cytF0p(MFl5aD~2QpLfEf}CI2}cLW5H1yAT`R8#<j3-0B`^_N
z>4!_!Uuo9zHvm7<tOSNNXsOA1D-0wN+yjGTDJLuQnYb^NAw2>E+Da<;h1QkeXa#t1
zcA2CwM(=<tH0}|037+x@uh4Xt(BS70-XQdpN62sZ!)^S2*l#p6!kabj5q>Rr$|JPK
z7=M5UKaX&e&{G~^hu}$<@H>W1xW~{5`MrL)&OZv-n$~p|B+KtJ(9*z%R3u0Vx`Kd`
zLA@M+o<f7OLB<uy+2}hH_hpXkajy@#*Zc0L!F{QS3?>EqcAq4O3A`Y1-^YG9-6+mz
z`vGs(xJUR;!BZaLzck$?<k@nh{&|G61y6Z|C7SLMt~GQ*e(WF4t;Zol(|YRK$DpNw
zkEsPvBxnTzrG*sEf^|%9(pj)p!7vQMYK?n@DZx`7VY{Zge%!aie!ig*?$o$PD0eNO
zzar!Z{bBw0z}{tOgjZ_ZBfLlOlt*~4rU&7D7xwSL=;mP^(K}!eIRbKr;z{d$FbtUR
zevNyCKM_3T5gyd^Adqu`ITFL|ShnB|+~K=#TjRKcUhdQmQO(8KyeZpI<qGUqdh8YW
zhJOXGwdOt6A)j&=@MO7C`e<sNT=0A}b)wwZd^B~E+`1g1_S~P$%aTJ5xE74pi0TWG
zc>{9D4L3am_ZssK<B(I&oyDy)dO4V@v?j{szabBXK1uHM{ZIO2xv2L)=~LyZ-4H#v
zOP6=&hUogjTV8G(BKF)~%iC&04s!o2FG~&4dafYlm7^ht&`q0P74>onT{p?=B}0Bf
zH$=`W>E$993%)U@7ftSF3tjCtWbS`D%QbDG5PILkHf3HfA11Y@$OUF0Pm*m@<dU!u
zRdbtbyZ$=Amn3t)*5U=dsKLEh*Y&3Ny5#Ds-fp40sdx`nDEuB5UM=(3H#zb)sJ&(1
z;ER_j@#3VAxZYP5oxY@(qkmfrL;B>Ko#fJ(kUV$^UAn>xRzi-<X!B+PZ#N0K$nz(@
z8?P=gZvXYF5?)Ob@{hYm`1@xh-2AKp#qd~t;G*&Mc+m&%xlQOHq%`HsfHK+eTpXg*
z;?+Fss-p=%4iOq!);GnI^({4R)^F1N&?c{MlGiQY3sKr@+pJHIvhyB)qwD%MUh@B|
z5CQjPr{Y!z&Ug4M<~c>{{Sd7t-j-}lRVQ2ULMSdqlCvN_e><+9wW_ju1T^sBZA7!S
zMQ%+F^R2JeZ%=+3M|FI9Q%g+>@xSIjN$*B`xU^8{21RgBY0_HX|7b_tj}>p-u-V%8
zA1*!K)~DL4>f%<@H>*1;M3!hZg_I(}*FR$b?mWbuFxG_znbU|jus(ogeSOjz<hyo-
zU3sff14;)s6jOj33GoKZWrPz?wZ2PtKwhkrnr8hBV0Nl)^L$*e+K6jfpFPUXH@NT+
zwLD_SXZ>&yZsUshM(Yuc^KElJzQ&t#24hT$XMLKgEWWMAce|`H$7w_w;2p5Yo5Xx7
zkWYB<?H#@#W!|LaL+tv+Bd*<{4oaY0^wKZ)T6}iRJh{y$ru+w;lfd=cN$W7d)o;Y|
znJM#5EgM>kZ?*aF)^akYFF9`zOt)fIr%#p#AN4~YeCbtKL$v2WV}EY(twSP=ipA@`
z_|Dl60ZGIy<b2Y@pnM-tqmmN5Q$J+ob}JGv+LM4cgTWNs;0eK+P+QO(N<ltzZW4&6
zAdo@Kl%=7(;*-@nfvy`1x!~X{b(j0u!3W&^)aH}+IuFhc((+4qGDSe1p5x<ezP*-l
zpAsq~U-((ihtyaG7-9YV+2n9x;A?3*-?d{&PdVW8V*Wd7cLF#0toitqx1aHRgWZ&e
zZK3?-bIakpe>4{(_=LqrwB)%lz653RoKFrJ^lh|O%s}2j>R)%tH#(V5lEW8-8Y;i>
z;=4<H+NhkhozFZ47Cyuzj~?;)B|-SGQHgmriEk+RI3H+aAZ-0DWQ7@h1_M&-DHJLH
z_X?1&VA5?&=V5FZ`Rvay@cWG6F#M=vdyfctRp3&z^q0fj2IK!eO4Db|{Uh!^eF+-(
zWiUJm&f}*%>&(N)D*<@~+W-B(^6|_q56w~@Ps#ef{h;&sF^}nz&hx?K^M6OX`}D7&
z!yx$e59j*yBcRjGKZ#3O<nezzUdscJJgmqAl>YC((f5PjKh3!S{`}wHLC1?nRsl?y
zes4dd6$}sU{RQR;m_soBFWMi6E(YjhTHL<$fBqRIZrpOymOI-#-{k-9grEChj=<3E
zARrI-_&>Jx^vjK1%H_cf9?9_!>~Qm%XQTYz(ft152Kp;I${!E^_`m<Z{@9IBzcZm5
z_47BN{|ebWOX43C@WbIIHjfvOpZm!Ek300-l_!lyLB0!JdCfCVMNq!~`)_=CNAYow
z;Q)-kr{MelC7PL+VYpEK8jSx_*?Q@C7vN<u{;x0afiQz$hQj#2|3?1_cwUD&gm&u)
zjQ``3t54(7tN-JY5|_BRV9JG|Vn8l)b%GWJTn%^*jQ=D5?J%-RML*`p^`?hmxYk5D
z{*QMuUJP>`%=Iu_FuEFMH_RRw|F;7;`HrS@m4u5Y{^E|$pWv$jR<nLoJR$99&_s61
zjrz5XRd}t!AEku`b)gP2Vfwd5Tof;NQU?5bXo@RcH96eu`yx43ZK#O1wl%agTcK+=
ztwhkY2dq@qx0nH=Z}ppej-uDs>c^)O^IBU{iP@X2mPB<+P25Vb1Mxk`7?`6s8MHNH
z(r3EnqX!fnr5yIQYz}<NK)n<9#V>BFvp5jekxNXGL9ryM>9m^lgu}vx`timZ3{?z0
zh?(C5TL}a%>0QO=U-iqVq%~R%My)EoXA~X^`Vk3_NE4>N#hYdwNvo>1wgE33Z?>9C
z;*E_MLs$tj0_5GVGJKm?QZgg^<atY0osvBzcWUlr77Wx^`5ZrHVVZ8Of{9rz_^%M`
zI{dE|>|Oj<3ifyWuMun_I=s^b+YM~3U@rk%C)l3??Bf9A?Zan?D<8Z%Q?LZOi1mW~
z0vP+FH0y}~dnUl153rX4j58zc<MjZ0Gr$f7*gFAsIKVy(uzv<v8oIHwM3=$r3`Lg_
z0c~nPn-^fK0_?1SuO66=(d_~D4`4c7YS9I1$$ThBW4i<FL10y)!4tqX2sRN+)q>3e
zrX?qUX}|3NHRAd*IzpYM%g`0B6xv^b={)))x>!v+9-UxZT*m{e73@r4+O<BwM&pQg
zowzOwusATycWHqAKEOT)rbF9~iCn$-eK^1lpu=qdEzNol*xBNG3_8wpgyx~!)bSk)
zOuL=~tWo&x0;bDfpBN6F35{c2jjaKuwW<ZyEUq2EbP8<+)*`g4fh7d{8L*9ljY2o1
zB~Jy`Dzr0z>2yv3YZKbefc8gVIvyVZON#69=r~h?O#;>~7$0NUB-rV|Is~f*wo<U|
zz;rCX4@{@QTfjDp>)(OtFeadib_%T&*tvq013OQ!bAV|n7XaHLw8w#IDgOg(lhFPJ
zOly!n#Mj_7U|Mnl*jC}Y8kqL6FW|c`z<vWvhjGGjT1uKV4%jyFn*_F9uxkSBdja1A
z0pDwZYu)jF9yJD7BEXUX))8Rm1=#igyCA?W4zNoDY)^n)6=2r|*xmqp3YgBB-vT>d
z;_+@kYr>pJmx%4abX)f|upR#&b8j9WWp%cXKieb^WFP|!7%@N~pr{xKi|iT*VH0FX
zNWcXlWPw0PVrB*+f}kPlFr_b8ZEb7Swzk#Qw!Xe<-5Y@yq^oO%Ditl&L8xC^DcZW^
zcirbc&pk64?C1A>|9QU;OrGmp=RW&+&b}zQ{`ub5T{_6KWx1fRpsxwKU(g0LdD@jN
z&jW2&=(j_>c*!mBP&p8nAe(`fD!D(4ZbHyWL8k<r7W9dr&jcAmJvZn`5&mXeL4H92
zK|w)*;h60=sMh!dh|SJJgXUJntr4^v=r+auNzmVc*hCJRF>GS2pp}Bcg0=&(i9JBK
zEBihGiYb(HfoDsBpm9KKVhzx3O76db*z8|`*zDMmp6(4&{yimWlm&Ar#!zz2z+bkn
zOwc?a6erOA0sanC=z7ybKNfTcYCqPE`8;%&pjQRGp6%(rBj|lW9|<yCPj0fHxq_aB
zH`%op1zmy~f;rkz#;8NkZb7s^jCG$9bXd?p)G4fczMye}$_3FjM3!q3v<kJ5<^<g+
zC@$z5f*uf*jg(=tbczn6t%7btO~TwAf}TgM!Q8I|#gSCZRipG~bW{+P+01na`n#aJ
zQHrwe6N37oOk|E$%QGq#^dmw45Hu3yAIpswR4(WllsT;XwxAIxX_#vf^c_L7Q2MZL
zg`ib}J{0u1py|ljY+`|+b%M@EImEh41>GlT8OkQsy+hDxL48m%u<k-ZKNj?apwogD
zL7YwG6ndyk&{{!JK{pDzRge#*58JX7<pHCug2rCpah-yGE$9tF3s4GZTLi5Vv|dn~
zAevug6MF=`B<N3quDH;XTPkR$pfRI7-R}w-aEZrl6!eB5x5(4Y9_^vFF&?^A(2oQ?
zF6bx4p4=0HJ`!}-SWou>K|dVlasMUg6+s^h@{RZ8rU}|2C?P0!f>(<66Lby`J`t3n
zqXf+s-T8v96y24Angn%-TujhT(Y;sDPXs+9=y!tt1jMEMyMo>m-H!x)0#u;<Y+ma5
zei#s&Jzvm8qPt4CdO>SN_hI245%ieoCWJdF=#=PQGSTxv7>IqaQP7Q|`x`-T3i?#!
zx&+yiJo`$3*uGhU=8Ene!hK!Pw?y}}aGwbJOmxqk?71-&h~2ncP^swNDcs$H?h)OW
zg?nAlVbSe1#mkd<KzS;)1_7~aLj{c%-4Y;9)kVUs6!aA!HoHsEoud0=ATAGnE4nWW
zdR^oKQ$1UPg7Sdae?>rSOTFl>71ShhKNapj1wAghzXoDk{v^8Z0&&=ePV;;)LePak
z?1RgJ*ldI7t`~H@$lWjKm!i8@&;ikXU(i1UInzDYdH}I&LE+8?VxL|p+*lxv`%6W4
zrs&QQE+pJlg02(Yb;3miZ4q>f$i;=*CEPcK`z{ds<p+Wu72PL=dsfgv(fvIThwUxl
z-WBeIaNoJii<g&y*tORM9R}jm%DLP_GX#YMRRXcus|2kT-LP;Qf!J4H5p<Wx-7Dxv
zf*uj{l%PF=4gj%zFA4X$aDNicDe?U03i1PS*ouXlAZQ8@=a({(n=f3Ya5n>S$U6kZ
zMEBc*9uo93paO$xq348q35acZP0%6H{Xozsg3g`cnHVH!C=iEeA`tt2wxGqLyF$=*
zAa?h5L0=KwP9V1BkZ|t{Iw`sz3s+t0*;gm10f>DS6Z8#14++{Q=paymK{0e#xOair
zr|$_mBf4FJe6u{WLxI@c$$~By-E!ep30fn%+kn`$?ZWL6xx0kBSGXSudPLAuf}RIr
z`}PR>z39FU#NmBcxD$d-3v$Z55cLw&7l>^hAgEAuFBI+)K~qGx1c=>TC|reb*9uoH
z+*;vUf!N&*g4#tlCfrUzUl-l)3-=>I|0TN53i_Amej&)3?Zv@3AojsTK~qKd8bMn{
zw_VU}qPq)-^Z1j(JtuN62zo_yKM?LiL4OzBPl4FJtT~=f`wJQf#C{$us1S%v6p7rG
zqFXMgN^~26*u+NR?iBQZpof6iwVw)l6o}0}Cvtm)`>k+q3o_<<wm5=ZApW*i0I_}R
z1#J}FZvn9n?iKVs(R~t#&Aueu>mqkp&~eet#y|+$mm??_i2YI|Xq@Oy6f{S4*9q4w
zC@i{P6ZEv`J}+pG=pF*%uO}hg$ASjU_k223&<G&yQy>ocbU_OQEfu*sL2H3}sxq-j
z&`#04Tey1!-7mWT3B*2qR&?JH^cO+Lf!Ke2uJHU<AZWCpDL^bYU(g~Tc4N74>jXuB
zdMe+yiQIP4jR|+B$UP(ImxA^JvAb^qar}KC=$}CBgI)_fxqd+G?m2=c0I^)Fa2o_|
z0@7{(u^Xp_vln{0K|vz~%@?#x&~hNQWsPtf1$6?kUk(fRcR`;5vG2P?F850D0TAov
z2`Us+Bxo!UyKxy1hpkj}=LjknbfciHg4%)D>`#F>M4h6$4~X4(P0-t-o4d&KX+J^d
z0I_{DfY`nT!d)Y1y`WZ++ala8!tE69Q6P?&CxF;jdqnqu=>A&J9|X}#e>Up~a)H>V
zR|2t5uM%#JpiQFNA>4O>*uL)y`hn=aCEQU#$3(Yav1fL;ppiiAm$`!KM7KfEdePlt
zc(#za0r+L9Wk>9*65-Iu&^~Pxu0^<egu7q3-w5}TaHoa)L^wLdTDuFx?oJYJnsAN6
zwFq~=a1RK#Pq-I_O9*#TIKSn&8vxSo3O7x-Wx`!6T$^y4g?m`IM}+&0a4!jWQn*vX
z`EBtF5c_46aASlE3AaSJHsLl4ceil&2=|h3uL<XO#9bhEcdl>?gliLSvv3az_poq>
zgnLUkzfar%VmE4qTO-_d;b@sM%XJF3PdGZZmh;PL;l^Zn+;|{1+a}y*;T{l<PM&4C
z-w5}TaQWGueFZ=)w?Md%aJz)NQ@Ce^>lE&oaLL*KJlAt0ABf#}Shz=oJ1X2U;Q~E8
zvq2y>yHYqhgpxU$%jdXyR=7jLy(Qcy!hI%O9<0#cB@o+(2r@9WfimK3C?MZ-ky^9@
zC7v(3Fo$n$z?w$B1e00*yF)ARQ7Rj;dkUxkza;Z0R4DXPm=~aWB#k)<)vn&2%!<;+
zy6UEA3msp__N=JK1)8|xJv7i`U_c#mPaA$%rYJ&-Sok5vHfgElFEqoiqT1?6wPx_~
zLMBaHDT-Ew!ybzd?W{7SKTw;+hXR?2^vZZfY8hm7$j}xfDwooq@mhvb#5S)+9?A4n
ziKdVZAw#DDuT8fEs)bqx7C<I+NrnK3Wm*QA1TtIU=S;WOXo_--ZFa%ynKEsf%26@}
z_?r<d<2EhhS2B;BHGb~WGQE_HnPEv$P4oKoby&EM2iXJu=|eE%xgYiv;78W6C3H&w
z)iX(EKj8go%&Sm6lExf^Dg+Dg()N4|*qO%kgz9J-GYBedYfUjV224R3GaJmdG-d^u
z`_q_>U>-?hc7o~DsRW4Udw88nV}1dqK&KMRP^}e8W8ML?EsZ$?=8-gp?ie|m#?UGL
zA!N&BY>Wm&3y70U85l~MBy%koIxsTHgu&1$i%Dh&7&;p<$<R^zN6~~yGQR*rXZs|X
zgT$Ph%KVuaT_$kYKLJycpDL4s*xHuH(2@5?(-``C=@^WpTU2+_5f@3O4h$V4kz}YY
zrSln*%-6}DG=}Qd`wLQK_JE<C^+{7y*V2CABy*Zfr7=B_GWTDQDpLrC_If5wO#wr@
zIFk$=fxjz_iGbm~m0k{S2je{)hr2VF2h$jAD_S4M)-CU0Q%|SKklxD~%wIDYi;6w{
zSO(c#({h7H7;JMeO@=f_r7_r`)QUx;-Av6-lOfG(GnjQ5%$77}MYyFE`-bX0tJy!h
z(qu^Qp$z8P4Ca*#CXvBdRKV+p-5QX=6lE}%XE4h$m~|P<jTy{WGMMjXFwbQ$zs+Ed
zXE1a$zV~prsP*JM%#6xlre`o$WiZhU=JpKchZ)TC8O)&!=41v#D=@u>{p_cTR6oq*
zXE0+jn3)+&Wd_rb!O*GY-otL)mB#!Gs-oJuRngTes#mRQt=r(K)TTPE)7a2d=kfKe
z)$2vk*j(fBEzwm?&<UrgX{oZPt6Qs^RwtF|DtwBDYOR&EVDngAYjq<n6OYhp?G>$c
zXxD}7u&kQ*V}S@aY{KR$t!!w*#=-_P(du~Nb9hk`mWnsjH`LXtRo3C6n#Sg)x}q`0
z3V?7O)}d>`vbLJKmdFgav!RaGsE3Ue)fKS1Xu^as6TEQzZ^w#WflaHqOL^xxZ7gqy
z)Quwwdr>Q{Z!|ng?K$@pN}o2IrxJR%c?N~pNwHQ*6=zao)2QSQ^Hj5G+sjim5bLtH
zJe60DsXcM2EU#+ErD10w)4ic3$DK`bLK-PM$y4p*ZRDv;au0bbo8iOc?(tNyl&#~b
zG!p8{=z1)(M<z>&XxdAx7v-nYYR7mg(S5skhF+Sj=^MpUWp!MQPZL)OkWR6j-XET7
zf!-XRO3BXfRFXfjh0Po4BF$-zC3k**2~FFyQ*B}cv>QB=rLEwpZ2CU%RGrjK;Ai90
ztV!SgohnZ0rT2cP(rFvNJ&iBj_3a7J2Z}wPo>CQnq9RR{c`DyvhlVFKYgKt&bt9F#
z9-|7mdEt3YOHigJbC;sA7p5gy-ieV}s}?FduC8lMCeEx?6_M5}XQ2b_*(`1?YNcE)
zJb7)A+U<g^Euq%tmbzB#|L{z$2si2GkH=sa3#=9a1PRK9rq#l*Wom1RXGVFyl*(()
zNg|un5Q_XmJBnxkAn8mp0#hAV#>=tiWmR>}x(eE&?z!lZh%e#TG4v)I;N=uqsx2yR
zz_wS<uo6UWoQ<79R1JzoIrdaHuWzcu=zu4?FvP7xPrWESqoyWRU{QEcOI;Huk(lya
znBN?2ZK`feb7WC?X)9_3kyWL|yrxJUN$TA=N!Mo8ZD^>eLpE-$u7L>l<~GzMeYYr_
z7O+KOl?Z9+zbM?T6iA7t&>Ga$i_l!~-0QBlWMeYRQ8bpS*cEYBdVcTzt$C3!s{tWP
ziDku;zh^ast5-GF)rx&pbm#!*IN^{Vn^W=$Nu-5u#rm^+Vcm){<)YdE<pmTUD?Hy)
z-I@$LGDKB1B{ntydty3UmUF8{Xk{NZOi}woNG&_NwRyeLH#Q)ruWD>wRn$DXfS%%U
zmlltkG;!RelL`vPk0plxUOIj}DGJ6;ymazJg;w@lVA5C!?K8%yj0!ns>gX3yW6%bl
zg=XR-S1SPn3o(rX{8C52SSRyu3CX35f@MlDvkkA&<I{D23O6Gu?NX%+ZglaaG{M=^
zu(cUOLl0cb^keiQxp8CC<nBgicJ*Atc({gX>f0*0@f4!uGaMRS^KitZmZMQ8B{u;J
zEK{BW^tlQ#lbH69yO&;?Mzup#it)N4#4$bM?xb{g=fJ-Gkek$9ZgP5f3t&gDW!MI+
z<=`ayueca%Uz5*+fR{in?NRYJ7V9dL4~=HMeipgZ5i^nw;`eQx2gEe&tBn0+X;nr0
z$^6*fc$piI`eV_f@f(9X$GcO*&epPcI1q~-d)|SO_ASSZ$guLo@hjYTh2MNJRNhs2
zw0&P7w!i%oCo(cNCm1g~7Hf&bV8<4BXWi**u3NGE_&r@+UBFLLyb-at{iGjqp+q}0
z4wPc-2R82uoH&SYs%|xos%VO$v_`YI(HIdnnwks3(V8^{HR||-DFwqugohcsYO0%>
znj;0MrJ4%V*3!CKEm43ioCO<Ea#CHCDyB{<DQK=QpdL&?ip{Of8yjk;6pU!ZM$4U%
z^L2dOeDYa%cz?$lc+!Yh=Es*KaCx!2mVANG+|`1=v5pY_9_Y9he<=*HyJivlom%`Y
z?u<W2s;B6q{OBj~GJkwaAQZ23cXp7`r7>m0S|gOW2}+8>109{Y+g-$Ryu<<g>O(fp
zl6<B3OzhPYIkV$)oc6uJ$)|1_62FVAU%a?HKF5tad7;E*Y`&v2dKglZ_vdbZ6ei=#
z3p(D6l*Q)+Iyxhl#hzOUsn~(|Qm5mUn+C-fxs!`?w>wDt;?5I2CXc^4cRLMkmP~$W
z^WWoJ3p%=@ug8^<T@)XbT$OHl;<eA&ryXP&`Sv`R35DVd-S~<H6^j#(DSdzZF4A9P
zpwwBLQy$x!xJUEKTm^-B2blQ6g7$s>j)N?odspWOip0=bqdc)L-GCWNTtx=vEPw$P
zkGqT4n&pX^ps!+PSw(qb97&bIS_C?`V*-K~-${N6tu@!$ixWX@?b2Xed8K@<6-sn{
zrULaOgpKlw5bJ~z2}S!6qa_>@p|#G^#4BJC6>wnNrol#T$D@b<ik<I}D{BongMSr?
zpD4ox_?Wh}kr-`gjqjw46TgeH4BNQ4e66`Ou@$n**n)~gt1=j9|D-mz<0*KEgSOLo
z9N36;P|C+=j)^0S)W*j@(*8wG?rkyH{p4<FcbtjjJ{bdO{~|l;d-Cf*JHJDjH?-zW
z;EFZd@b{OHHWE1$3>5|R*$rL1hDux(Rst-WIQFTEn&M6baevwSNViv*i5-eZ-SW`V
zs>BN*5FuAxv$Q<%II#ZY)fc{#zKa<ggz}hDC3chiayNEhSw*5lS?1TC)NZyYGSJ@D
zC)%t1IkLgY{p!ytTDod;w|^bpFYfH<%I#=Cz~HT&>htV+oZ`0Yaf;hDpCBwD71%@}
zEQ@{8zOSGj!8(2^L{xsJu)u8B<CJQNFaE`$#3y@v1Vrk0v6qp-)>`F>x0N<BLeR@g
z$VtCqGf(0}Gmh^^wkkez{1$j}@#3|4T~RmjW7b#YDP@636z=_!iu(!<ZsK-GND>_X
zHarqn<wnJtd&$mbB0Adem*w#h2SaPVO%`y_=CTX0HvTw?sdTGK6f=#W%q1Ht3m_2d
z#{uG;W5i1Rp+paIUVW#;sv;$JV}LT&nz$2)mAbL<!xP8;NmjVAQU^IXR*K?pI2BZR
z6n{Hr4&IIuU_V?r{s{im7o#Ag_=FdY<FgPYJ2x0RpS^&Ts9#XK6d>K>6@l`^PFNeu
zA08_^ow$WuC_5cr{@KC3Y4YtS-S|Q{=*BDkF_bS00|&}fHGc5;l`ymOvGd8|r2YR!
ze(>4kVe@j7vwKy3SOu$A;71P7uwFHO=b9!iw(m*PP-Z1^-4Jji@Y{vQ>|>5_`{mf~
zd2S!GuNgqKZw)tcaxMdf$)5p+?M}&=nlrB-PH^dG+HQ^yN}ma(uNUk2=JlI|sgo=y
zdy^h3vvXkyyg)B9+ygdgZA{w2rrtR@o=rK*Vp00fH^@Y<{^kY#dHu+#-af_TQbYy%
z!6G`)qz~znZeQ(5xQyd1#I79D3u;fo59G=I+LKy2K>VSE&(VHV9?nY!FDIv0jz5RY
zp9{xba(tj^ve(WV3a^buNb}DzRfv>LgObkTM%bjIh<h!jqOc(823n0ph+c{k3N@ug
zNfw1*m`@^(<`ghH!cz14k#cy7F8ntlMHkBR$EOKjP-I^2=k!c>W282QfLkzjp|(^j
zFVeP<5>8&6qJ;3Mp6o_WALOh{a?DEQ>mmZG6|GWT8y%D49~dnb|8xuU*t2OM?PsEK
zO?4ZcCWONp3QF~94QA2kaBIzI>3h@|byG&KzoDhId3AU+k7Zpl4(B>>Q+Sjf#<$F@
z8gwxYTaR`b_Cs}KwWnNQT8GUX%<TADs&G1o^+$6RIsjIo;cLQ}i1nsPb52&F<Etj+
zTjoPWq;#_;A|k9KTG#KRX5DOce2DcYO$K~*t*xbW7Kin=rh-H*tPZa;tfQLB^HoP9
z&ARt#y<^g~BvxU*FH*O@1ye)K=*C&^YIcy1dxW#A(Y>!VtUqghu&)WL2WG&Y4b?S<
zb<BJL^XFFK5MR?0>V+ECU$kQdzLr__jWpEPXjt!=MM`XV78Uc>`{rWh^hh6uO`2P;
ztlP*(eOL*tF$S)$Zh-yAwQZBKhEXJZpq10$Tyvzlkvq$VbwcwcK0X=6I%)n~McynQ
zoz!7ie=|oZ^;}<5SzDy8Nu7#f{aqVd;;T+!KQbRctJ^AEhGatL)38pPk1NC1`Y?Jx
z1Lt5%G1qSWLz`deYr{xX4MfkFzfq#Kz81yIXkBesADcI-gk9rn!_bjhF=BmUCX`^K
zuSIi8^q*R^#fMW$XbeWN|I%#4*T!rqdh0ZrV_2V>UnqOpd@VAXLvDVijcoR{d3@5)
z=O$f0X%}uYeJzzOG>@R1`9hho3%8rTHl~wCy3FCD$;j={qcpv;uCA8yg<+K`{wrxb
z4%)L!t6u5sf+I;2$|1|52(b(Agce3749m7oVj|owyxYwB8)Xp3qRCdf@E+5r4}>8b
zeVV=B^hJvetB2KwpxcEHz-eU2HHMXA-KCs-81@pQ9P6bWdjw*L>eZM_!M7K%DBkSC
z#~|vlO1zI2f70|dc^ZpaV4|-@pQl~;tm&)P2lH6{Ewe9iov@_}AAn&Eu+CTZz6Pl(
z9-g$$v8Jie9fFk}m#1xe3v%jwAZwtu>nIqCFFJ0}I!}|QP2Z}N;|i^O>v4QRNDfQ!
zOB&YKHDkEg8l<hg)1pG8B2tZkF2fpZeOtxL-IlKw-{gYknso>Pvg<I5$^g6YMawI+
z^Z}ao{vniQT_5I=Ru`y0=zofkK6ukUP^P4^lTuN9TC1DT-%JtrPUW-@QsHMg_$DJp
zw&OaK$gXoGQoP4({IQ2wv`4=uVaG1CegTCKhYRu1oc3_*J=6dwE{z;rqOM3expTZ7
zQTkc5l*^8)c%Y)SO%3K5_692(#Wa<!Z5U3jHSCQRmD?y^eQi9HXt!B39c&f)>2t<p
z9G!V=-(ZCm8Su5KQ9^r@^;Ja#eQh-KsYb8t8?B!!GSAmWv1{0ywNySnr6!DBgW960
z0{Cf7UClZgvTWT@SIY)&(*7IH*3vO~t<8;wz18}?vUw!jucI?U*}-jEe3TF8D4lI^
z)4o|tj6oEiM8x?iI(w-S%Y==+=?}E%d<56|8w6O7B1P%-rf;-2<@w$#@CQP@pv6LT
zMji_(lq$3oTDh(>R%9vqSXNteooG=+vKH9@7j6)(heV4Iw8*gQ(CS0>0>w(wtnw`M
z9|zmxk1$~0Z@mK?AZ+%ym6*OZo#)V#@Lao}O?5A4mY_|}Q)UToS`?;4HSGSHbA0RD
zLe-HqYV6e>pjkI-I;tc49AybIOx6!bnP;z2^?3lLPfN=zT0v)@YjfF;+(IMVhCR^!
zjuJvn(L>61zWtn{kXQ7uxIIWy$SW98U4jalJuuilqC_c|U>qpvvmrJ$w5&p8lUa@I
zQh_~4QItg*c>vfRYEM?&7~(2!SdVYcrc2eW!tuoDZ>7+tGmosoN%&ThgZcJw?f5ig
z#l|`uFKUml<4UjuS(>LhsU$M&^KEr+df_Z22_2{5I!*AlpT2ZXy>CF-n^K@RMOjKZ
zk_N;nL0l&c1<O+erO4~-@_o^#SYdtA>aCXQxXxbDr^xAM-V^$>5~5V1=t>H~eHTO@
zlVU8>?n1D=RE0_L$NK7vp#Z@wogdZ5q<Bo~fnK4EktZqUlGZ|tPM6}){!p|CLF-|>
zEZ3=Rj#3-Tb#_DD<08s)SG#oNNPw`}*DDtJ*kRl5aSVF>FiLOCa@uY{l^={6&SnFx
zR%G^ItKn=>78km~+Es>g)5WNztinKWli_To7_<t5!6w7mM!vNQ^ZHXe)VaBXTa7_=
zDw}f)HzEfI>*zGtc2*4uQr<S4?bOV$3JZdpD%RlmHN)u`tlS=M^mrQKvi&{iM3e!9
zmpQ*D;r_Jn(s^l^YAqW5FNBWs@<^p}f?>mXW#=fe(G99I=bTr^E3E~=hA?Mv=QZ|h
zD9ES0Ij?iWa|t5tZ?M0Q`8ob_Y0-lc%B~6YK=+Fd<23wsb|30UXKkjKb^9FaLvEpU
zUXBxc?H+yDYDYCu?4Er%id>_|II^cUKqrCqBs|J~CQ#N3bypKg@o<DsRJNZBuz7>3
z_awbH@QQNA@inRA>2R!`y-$m}zG~rK3>;E&{#4_Y>bzz9cY!}Cy@0QwwheRchW&eO
zLy#Dn476Vguz&N=fUm1v(oEAonDkY8FKg+1Uo)NZJo5(fV01m&clIk<tH6iT`Wn`w
zN~|qy4x=UTYJl?&(((=pe_dcPg4~m^W1rKfg~HFrAli9-W~!WpJljN~^?}VKN;qV%
z4_MITg1AXLMzuCC{IHt?bCp?C+wfEqYCywo)f{T>neY`K+-pYz4N4NVH>SjDJmC$2
zt%?q0{en_;qgG0J+!pwu(noo$OTQZe&ngDRG3o+L7aI1az~2>x;#f_9*_*Wt%HgtR
zWR5Lbjp7$=H#&*fzA2EWx)CUTxp!l44UAI^3SVws8}_!qGDV^EomscK0mg3D9z@y8
z?TuSBfl^m@-RyQvq1g2r_lCV)le5U%O|`O`$nFTJ8@>zYQp<;{kyt=o?p?S*7dZ6g
z_f~(Bm3}dC)Nt*+1>ZlupDOitA{alFajrwD>N@m6xeg^F7hW}FgtU4Sf);&JXyu6j
zrH2v#+brz2JhnF>Xx)z&3?rwwPKSt5()1=Run!CSp2u=~Mb#<vwe=<qNK)^@b$*A^
z&~^5RslJGMWmj*7$N==IoOB(!k)6XsX~t5zB{CQUYf;*9P{py{T4=He-I6Y({H8eS
zWx}P~@p7H7;%^_-@l1Ng^F5`B>s$v3c9znPoz->CBOsD(Vs$_~^1oN|`0eKd<550j
z(L#Ltm-3A@qXO?#I@Bu0(d|^X*e__t=WAF}*SdaDeSH`!PV7C}n2U~`D~)_L+|kWt
zRfOQ6c-Q{#z;<zVzc`E2?rRMDfama+dt9F;@7ljsMWnB~b@c}Qt^Y=BYepa0uzxGI
zxz4W<8OS$q*>%W$*ZBZ{{Zt_J=tVKGpwFiu0)$Oloip$2-wWNiehLSD1vfzvTvvBP
zDGpu@8@{2`Y@rIXrn%(?I_=Xpj2RP56kQo#A(!k<a7`pkli9xEOt``NhE^1oz7f4u
zrRj%&;kz)X6ajT0sNowBgLBkrF@nCa?~v0p!eaQwu^A)SLQ51qr4v*;GkoJIQ>cni
z`Dg+w{lO+yvikv}ADx)*`pzf2Jl|fxnozI7S^tJ_Bs=6FrYPjDL!Pi4?$k+AQ=bi8
zH|YvmR(6;w^@22szH|n^<yWIzed!#2tCu+jKJ80q@msykC<WcgPB%m6^IN&*ROt1k
zGy1K7`5lt8eCz@_-4}=UTYXH*$31?6l(WW|FF>XzVZT*unwY<(HZfWu)>v}@R8(_g
z!6e2)#_6#TRIzl>t6`1T<2J7Tph!H~-9ZeHZGH7&?}k-w(xuQjo_dt^iaoJEoU3hU
zMSa9Q=~r!T`WX0->gcRlOt7MQHLTaQhUp8Zuy1(Xi>&Pwm_zn;#pGkx*QCwrTEsf6
z1y!|=k+gU0S|u5v#)YbAtar6Y(4(-N2aBbwKWiQ}KDrgr_0h&^bRRKhr}=zu<l&^f
zR@qtLYvKs}tCkqfgtqTP&5kts%J{?*a}Hu6$5RKb?^;iSQ2in6duqIf(t#R>*7wz5
z1C=$Z>1aKm)jkYDp(kuuKTtz2sz+YBzQwS9Xnj1IVufmSG$*YeS=^osC=XC2YgL*D
zwELtCT3f9;d`j&6HgR5!L>ku3)^C-4j&IWvx@W_>MN7E8O%wvdYS)C{hxzj>X`<cQ
zu6>EN6&8Lqtf%kG>d<7LtS}|ttriyueIYZqp|%$NJnMEX($DBiqq$XP3p|zsm}lK$
z(vhR=$##>QWyq^D@qukOXOE;H(-?^!J?hXSudXj#U0)ZuVMSxz28xYaHQ$5Ax{%Rs
z)43e6MQuC9-L3}u(5BC#)gxBSEGQz|gGOJyM9Nxfy63=OT3Ks-!=zg*eBm0p(E|4#
zG_PwwMBS}F7{eD?)u@U|>zgJGeJP*TwlVcBP38Hp)@?O&-`3nHWHuFb_h_QTheMUG
zS7T=1F=@=qDqP~Du~F}oY3p7cz-63$?$gSvcs%@mlRF|;`)aD;*%hkbwZ5x8daVyV
z8teNecWG7{ed$DK!&+w2MGZMhG0Pg_T!>9F7*98>0!M$ooS;M1pp;c;vRlI(cFW?C
zObRu3D;!_Tg1UO7+i-`omWyH7hSex@h4DiK>&*;ngu~x>z!zy=M>*sIXYdG>8oqE#
zHPj=uIv+JJkELIz`oUJ=a8-3%o)W|6URh*a?6jzFca*OIoMDa9M#lIWlt<<_BO|eG
zmuRi=Svx7y7CAk}kn@u;R81q7V;oKejIGbD<1mcVCQ6JR3CcfLnG+CUJqZV_N@qL8
zUK7V`l@>L!UM0z;T8VsIrdKms%QS~xjbW{DjwyfpjlP^Ot~PhWx*Vm*w`STa2g33e
zS_fuWr8avF1U0{zoMrb{{->|G*|5rN-5+BaqGoFee9id04Qq}rzyfN3)v&Ixmna+1
zNy75Jdd!#5i1q?qVCVUwYG@qYj(WpdsM&LUwOGc6h4+fRQnLf`xuOWeYzN6M((HK%
z8!9Ba@5Q>tY(ao>JavI}jdkgH6n(0Oy4KoF6&^~;hEQu=eHj&(%XI-_sScZ0!dlm9
z+UBgeLMxFIsSs6zPS#4VAXURuR<*_bX(}011-Z(iMkk5|^fBm~7^_AT=oQJ*W~<iv
zg(@!dxTLDHo>R(vqp!ZX#=6!lLl|<j(r;bw+)QCY@<yG(V>v)g^AM*SyzIcaW22W7
zU=_7i5m@s-lub%C#`=-nk?)m|59)+f-D$4z9?}VknKJJfck9PC4INSCQQd(4RvCSA
zKe1a>0^=Lh-@wB<C*dP(LO<F1skSNTYi{BZ1nXy#{xn;r{r7W8eyS;E)FVY7(f-Qk
zNd8aTR&Et=QTwRPMeXn`i$1phvaeRUBYoAns(H+&Zk1Iy%IJ%7Q5_m@tuXIGuyZ_h
z&}z4bVY8ho%eLEGmg&m0LwkrSikencvfipG)ThWp4Q=znW!FcsOw77XYh<B1R|n=>
zx9ecL?7Nuu9XB#yVu!s_c^5UUH`TGyEQVKdv@&3=x3)s9hDxj^OAnQBPHDENUqV#_
z*Gw&v9jOa$U9YQgeEOm4)-bA<Rpw5zn^m7!*ZYcx>QJ}(yim8|lL-5CLz`!bB0l-#
zd7>`ryKEde?Dy614ude3!6NthxNt|C2`gx+Rgbx%jhgJ^L+yce(W=5TtTs*e#a9=`
zV25GdpqYL?EOZUm>0Gi&vuJeD=xli%%HA6_*Ppq0P52@WYqMqt_^L&6i*J_lD4J#%
zU|n6OjNha~Hwi_zkXtp0QW-8A);6s!Q4_9c(`fZ9UlWb<S+{8QT(l%9?Cn~;z*n<w
zCe|sViJ_U0kJbU!@f2}~uR#?+OAvEZ<uiM$W|wJpPBV5kShr~luGOqsZ;S?yZ;1-i
zO69Z0IyJ3f?NGvYA!Y%q)i=m=+*b=>H3QgMw_4Bs?$)w*n?6N0!~b_^4l{vGSXgXW
zU(*C80g2$+=T1#xD$pZ!qxCMW^B~-B5&5tC)+*;QQCQd3(n#GP>l-Sa>_W^F(qJNA
zsAb*lqe@!M6Naxu?$Pu&HI2!@@B&=Vq3LgFdLQO3E3iq)`nHcg1-tM!AeLY%-LUS_
z%uARu#KgBQm%ihZX+y=L{X}a$t$TgB_z>+vOdV323KM#mNwV(qwJ7gn@^BN)bE4W&
zd-|>WwdI&Y46BOed)h<COw?O7jaaEo3((Or(t$lm6PFFG5tI|0Fb`;toI*@`&43^2
zI6Q5l-H6%`V{lfDS%PmgM=R%AqkM;l;hSwK<HpV<K5p!A>#9h90w}D)vuN=>Ho6(s
zXw71zA&j{&x}X!E+ZfGefmJP<VohXI&nk@Fa>(UlHRqxa7RFq7^G0u+)EcL?dT>i_
zypNmaJ<;5xB4mPZq{^kJ5|*y1qZJRA`nc&9;I7z2?en0oWp4EbS|)2v(h_;T7I9{>
z7R#sUW2|8?tSLTjPZe-|FjXsu>lWd98a1`1X%<bm1r0QGVNKVTkAmeq)?!_zDYW6V
z(B&!xFiDfOj!IBZImuUz+e>J+hohy$M>maFh0~Butu>qywdQdoOpd1>V|~rJ08^+a
z9w<8QbacamE9Sej60^sK^*tv~+2$C1buO(pC(!IGt3uYlEI+;tF7rQ?&K9?|KGPGh
zsG?Qd>vQXK)p~Hz!cn!=7g_)bq3hT#i)&D?ZZ^ESncJ(T&GAcRCbg(6t(~9sLuzr_
zHhn3WY(S$?IpFBl-*DBrQ&qN4SJ{aDQY!QfE8FJ8NB5+*79RDIpr^Kc3`(Nv+C@!`
z==Aw@H98(SQ*GMB;D)9q_}0+2Al*Cct=UU`>oAC<nuNKUny8lG%%k>QKvO90!}=4%
zA_GlM2I(!->8H6Vm<w;l7ZSA3Qz4zE$Jed?HVwC0g{Tv_dRCvlH&;0eO^y`$9Nq4i
z%k7kNbvtE&(Sug;S*y)Fq-lV#*;kipYs^vLa#-bBzqHpu>Dy#jo%ROh6C<zo29%&L
z*fhN3m_tzY=Rv)P)kEMl$LMh#<=h5yBh2<BJlvX^b@BOBW*|S|%gFND_)T>i)yT>8
zEM43Cnj32sbD3r^Oj5TIsl~O_<yl;JVP#Y!r6IE=nhju1qei8{3~d_C{nbra>_l55
z4Qr-m^EexoW^p#st-4uRRMH|>89hqL|7*>O@N!SWqpU#I-^l;ef9#`efl9m9S2Jh?
zVM`iHk$&1{m$P&KEY8k;U!=NqHC5H;WO08G)5p4K%FE*1iGqjfIsTx}&EldJC6Ct*
zKQF5<`;v>E{HzU1iK2(<Caen41V(PiFREr)XPOsKqH6Uh>t){`K&U2?VZEZ8R_O3^
z=kZldI4ZcWN%<SWouw#{U-wE~<#(k0A9NXp&l^dC!5OTedBexv<aU_OT!&Q+g)s@v
zkAL)WyBVQFw(weIZ)&!{hc;QuibmC;e#@tW$)P@?s!Gg&8#eD8%DV8+2++B#Fwa?p
zG|Rf^45$D>^Bg);C2LeR##;su9FsNvQs7{dy7bb>n&1tSR%`1nC2h*e18Izge&-ED
ze(#C#LW((CwL!B7ErW)maL9B9nR7=WQfYd1upW#+hDRT7gW(J@xwYyj|BDitdr^zw
z6zGu*bY8LVTaD;BLp6sEEQt&=cVMdvqR!XEH(NV}S^#CFVzjy8n#PEq793%6Z>a#S
zA}TGM^UYn#uHmY@rk0N3TwwC_>PYmT`DR&Xq_zp=WlL!oGsqX3UsvYFaP!Q$NDGX|
z@+UOcoQt&`sH!$8VwB1Ko@u`3b&9w|o50#VwdT($(u8i(I-|9EF4kS4iR+BfRxW_I
zQ1`2Ka89un3h{7IDW*J~v6@@r!=jG*X2Th0{`FFdFlx`L7L#gEEx`xuctgUqX<D<e
zS$>V-OwbmsNz*i(OU>`8z&H9@F!?=EOSSk=vpSQsD&mVaHC!K63kIFZJOEzUMvF6>
zTW9coe`ku8-Ato?=uPm*pEFg_YMEYZT?Bg|x%uZzGarPrYMmbQ+MCn0d;)DZG^qHy
zGn~sbjkaF(rWF2il@fO0DPDBvl&GOdyAW&5(4PrM8za<%aAv6JwhKQ=ww0ZkYAnt!
z{LDn}iTWy74!H<R1xhvlIh<OB;chhOoLQRtLYc>qIk+;-b(y~P4NYqK6)n4&&G*YW
zv$gg%3lTyMR$c>UICHed&6ZjZ>de(a+m5LM6r&Nf`ox*1R*~}JxCn+qRfXWp*Rs3N
zxZzLSxx)O6KHNgAmTRKsy0bvb?6bK2?kv=C@}h-uuMX?lkOUDN*MJ!bXR#K>DMIH|
zpuWs5tiZQEfMCFRiWVyHYKEuvYKCAFjmbLC=vpm^FOSr}T&eP;YuJ>#vxn1~jeIA2
zT>d3kk<wsfk0<#-Ek?GQ;~BKc$i9@iy@OijVR|Kdq7p-Tp`)KYiI$5DrX>{FlgZJ+
z7m~N8(E5o%ydENZDh*r?QmZGjr_tv<h$rc@r&AkZ@IT4GWmCYTR9lSF&2?xX&UL65
za~+!Ya2*O7=43Hc(T~bG6h*=8i)kHjP+tg`JxY(J2KD8A*_ZG#VN<Ok$u44TE7&r@
z$R5oKJBWeI>@i;Cw2U>fi&=ri9^;Jcv8?dJN+bL7yWs_lUtuybORqOnQ;`FH4v#z8
zSN6wvvUp~Zcm@uHv`2#Ez+zUwA8??Y6}E8>S(3fvB?QQIXr$g%EoN_;Q*I{qTYoia
z1*)%s2KYZzxq*i8&^B432ABSirX00K)38pd+>0S9V~A^IS+u;npaHwsvBaP?+M)&<
zvQ?|N0J9GmJHSkj<yy4N0$!kb4cDRjid=`Pm_BNyG0$4*Y2asIVIQ@wI7#<jjzol!
zSD?qU$F%O17r?mAhsp%4>`hL8@ro?6vNtW)gjomreN0;C%Tj8g040YKg}_BhfR_7q
z7og>V5V!(b>^d#bJ*!*FK^>4r2o0nF{{%o)vL-x0qmgQI92Szsz$;-lHIS49IYUzy
z><mpDr8tvZrKmmhD)e24rm9>uX6ZUK<b*XsXwYHW7$ecHLql&lREpBI(XKUDjTZYF
zc=UOm?jWEY3<<-Uue%mBi#imIVpmNl45Y7(#vsLu)IxTh&7k}=m+4I^svD;BtUuZo
zM#XiD_)Qu0_T~fL(vCVjA8<q~(WjzW!#eB$;PKHvX$`-xK@AGMt<`8*@_5Nn-R%h`
zJy1_0!vX7kH52K{CA6H8MTLrW+~%ST{di^X2T2bkyY(kL#}Q7NUqJ+`_@I!vPCm_~
zdW~7W+uCnkr6vPBN3Yg%DY|EQjl-jSj+#JK9dN_CR?pWU=sZfWToXNfwK)04u&&c;
zYMpI>%X*NSU39HhH9pN<*RXZ~A2LnYM!d0VnEU`H`+AphTQ@uOF?n5SwrZ61b%$ED
zzD+drzDkX-eZ#Ym?Y~<BuxUnPLp2)0-_#6di_pk5tZ(V57e99mzO83w)Rbd$3(eco
z$jCi9NI~CPOzQ9)>UT8P-`C(xv)rrwPoouRh~KAU6AkLhuo}*|UwN2%$~Dc6RLmIG
zcb(yCxPCaoOw$qrY123jlt{j%(Vc<x%~P9Iu@+?M5+}vd(4S(nSxuvRN}U5K8YOU*
zH(ZChj;=%fK3g?mOYni%>V9(P0{S5O>0q=tljs&8EaTHH&&i}j@fxJk)|tY!fzzM%
zlQ>hUrb4-@R!;C>qBD&-tY*ZCAJpcUek=ThWsJdA+R;2OjA6?L(3dfNZm=3BS<qq)
z=W=ES1~J~m%U`vXC9H8?khWlhL)(a%{G`L$)|sp^DA*FNi`F(Hm9e(QDP?wWuvX7D
z=@S;5S*$Sx>ln3Y88Zc7czDE_&CJl?s^-;EkUZ+|%;DN?Sa7{McxDNACY`w){NX{G
zR(9s`tn#Q}lbRrM=5zFo3Gyms=L-JB#s?c{=)_sTh9?CvG^3qa$nzH^{i%iETuChi
zt8i9OPbfHx*uuHNaNYIlWEjH<u_X(FsW<mJi)rl^rh5C+8cU~~=M9zxYiJIa+E!64
z^1O;IyEfQTeM4h&b*)<Q?p)36%3!scymziSsWL=uuv!n=IM*_>CRnW!XE}Sh5&7)|
znt856!vwaMpH|#~?2wP;UbG|??JQ>#`FBtY&DJ?LQaQ&J4DIn!IeCcD5A8J-f3EW^
zHQIvQfP0SD-WY1pE2ahw=XqYIfSw|mZt-lu6~Mou*h}09W&puF=lC0BQBy@D2D_aP
zIEcvOyd%Lm!GsfRP<s}fldN|8)ADoYuVfap9l>fg{^1d&4j`!H=0FM%b$FEb5p?bZ
zef&>Q{S@{)pG-ziBG^=h%?3#Ke|qk>=uhEa?1B^IfduDMR=czSgNK}*Y;zv0zzPsn
z=Q*zGm8y+iP7l4G%i!jEPu(EGQU>-*j_#28;pNRp57(h4sq5SWD_!UBNMP3?AF49u
zNdOg;JmZ`#h&*%PUN8d)=9%Y>oP_o^txz`ey-+mGyaB0U4$_g>pT<tj!8!_2vY`KJ
z4&h=2%}RCJjafkU&?0Db+0CIm`4ogN=!(aobPfq61gDOfW2*4LeIrJH@Vo`n!#c?w
zze$*uT@-FIOkOFzi&Ra9*;|?057ltxr(BMg-NuME>d_izz%(br8@rwJ(Uru`P4cq~
zThDJX%zkDz^eRZT!7zhr5P^=6J)eBsUkx(+7nJbx|3P`m%^|X_H-)q}eFOZ5axH}3
zg)h+(LQGy@dh5q2oGYlmW0)5xw*#=SD$6i117JKl1yuvNHB!aSZe!#ol*s0V)OLf9
zM`E6X3On;6Cft$KK%&(-=EcnTN74kXVUAL}fp!NjRH=4}N|)VvBU@T#!g<3iB8RNq
z`4=_Kh@i{W5;08GJD6k{#zi#kYnZBoa6Qx)lV{o3%okzIXVU=-7a@KsslK|0j8IHg
zks}vlWBSFkt;{f&(#>J^?xQ!2k|3|3eN^VDp*U-T$^e7zAiFrsQ<LVkH0NpWPHetN
zRov!s8ngT>?7IX_9Ag7SFT$W)n_=EgL)lYdN6}npT(s6OcaYO9V8E>;j_NV<Tf}~g
z**37FRo;1-Qg|=ei&QOdzCx+?iIQ?1%2orZgF^vT-$PHs|0J+#4<GT!t=-eJhEA3;
z%r2FnE0LJD;x`n|kDrPiy2{-yvfJ8ij6pUtR5pV`WkJsAb&xiS)3XVUj~nJx7N7$^
zAH}Z?g5QL-!<DsD)u#ZfM&L`B%FC2?J0p-Ic!a~+?ecfvDgE6YQ8Sf>Ig?%KgbVND
z_Xu3+5?5xXx-!$GhCZ?*xiV9KUfLB;={Lrv2W1tCi?CrXU{_ATg-`KIz!eV10?!4C
zpM_rh7{;CWDlB!ywP}9ZyO&|&K}6was(r-B8QvjA$b-1#S{-JHeqYfVQbLALH-r)o
z$%-DP71prSDjLaPND_>Y(~-52C3jiou17B4v1V!0dsD_-JH4Ud`fKbBFFs@6a+CEn
z)3h&o+OCSY_u1bt|8C#CwchS|%-$HWdrVV*>)WS}w*9xb2i-s7wc)*}8?Lf*-GXPP
zu5SNJ*XV29q3&V)8jibfxKX=@JI%f7BlqjSaesQy?)|j;tKGZ*>=sr&Vn4QZ*|Syu
zX}@DEo3h}JH=eT>-ZC{BUVYWn(eBUP1@@3#_gNS9`{M$4jQzycU2Z?vH1A&fFGl2<
zsiSvKU+NCE@7?+byZPad+{<<^U2A`6+<W=t(We{!JpHHJr%Ye1ygKbtyKO$9t6!XC
zPjqjIl<fYQJ;5zlJ$3cLA?|qfg7=E1T|Ve?Yb;VBfSAFV6<x^7n_a)-+>XdDq3F^N
z71}d;yB*fdUcTAwzFVE!>~K+FWzW4c_Rlyl<G*2|q{t}CnU_M$$eB|VDADGrRGf|6
z;n^{d?Xaqg0`{wBQ9)x-z<M>!u+>piP*+6$8m{f25Al3p&yHE`He6Urj_;k(&r(-Z
zkSKjw!&2m~CJCr92%{eQCjOm1<z_5wPr9SclVJn{`8VRw8)X?`I^$X$`(PPSmyUm^
zW!|B8i^5Tt-q&lM-V~oCkC!~XflMPrFRBYoqk?Q$&(Jdj7KA(~gdkXsFWZ=gA9;t~
zbXX9upDZAg5W!!0P`iOzOfNDCN%ht?I4L%`NgEb>#%BR6!Vi9>7ujqYRrFfUkX|+T
zS;lUMT;HhZ5WOhe5XN8iP&EHfgFOOfIDFv%y~&4g=~^#_2!m43Iryt(gY>=*Khs!B
zFYQ5PyqRgw21tNV59M1rTmez!(7PXFm)_+L@i@Q+?+S$@4!x=NPfc60V~H|1=019_
zg^X?Ner+>>Cj5{T^dfVL_Z<HZ2!Br-{65}4#Sf8JitlJXewH!jK2Ma~pmU0dqxW?D
zkUsSK7V;;oJ+#??8&p@54Eb{xeoBMD39UhIazJUMx^yeZ!`jt}@aZh}?V-&CILPVV
z@q)YwUi&KiK+e*e`~$E3126KCWfb2>?|kh6db2N!@1yrP{E#45;KgwjiU39x8=}_{
z1((u`15tb*y}cMBfB#<lo8BCT;`_$vFp#$>2z2OLO2Sh!@eUQ=A$onF;8J>>hd7n^
z%z{g4Q3Wf=#e?{z*!CxFg=K6EkR5$g@+_qnSx1tvh%8GnM1qJO6>;?Lp(I0eS3qxu
zUh31a|20g}YmSQH3Y^@ck}{>pxCYd9%4;Edg%zxz*GBxP9H8i-=twc7PA5`ctD;Dy
z;2{?#1?6j|0=gPM`dH{)!`P*Fhr&^p-qe~R8G36>4LbFN!O?l?$RQp@<@s*>$Oyf^
z#@MCzPZf^3^rqGn$#~|doPR-c^xn(ZrS}nqqb|LveUxgB%75DAO&q;HV(ilUV}+wG
zy{W~MYHlkWM(pFEg9v+}U7FcRpf+b3%S}ycSEkXbsYuPjG?v?T)Q(G|xiLl#mntuL
zUZ8~0f(CUU80%vT#v}=SL;-CZ_w2=>8Kz8V!@I}OdUJ!$97rQ*qr69?oG?IR?;g#^
zjL_C*kJ(TkHfVo&s+u~Do;pm2snQNKkKj$ZwA;*M^rWOgJL)`cLj(haw1dtg8r1eK
zbyPX+jq_-dTT#PfWwh1F<JULWMiEBZaM_KbeNrC9mco5+&lqi=O4szZb<vipbe*Iz
zy<>|u!lsKT@6tY7k5<8=4Wp@q=YQ(AdOY>Z&;!PneOk3i`;!QiHDaoawkgr}Cfd8D
zbZH}%=+fW^ZAPLYTiS?3T`1aw)Io1-GTKf0c+>D1_7**k7i|uji~a76Sb0aAi&E7z
zZtX3)r&%!cKh+5xG=-r1w=`jaJ{`>%>2(V<AE5@^X&l@e^fqXAK`l|DnKf@gIE}jM
z<s7tzn#cTTiVXvDYH={lM({EogF2zyAuS#Xw|GS!4bXavyl8<J_rhuDRUx&ykJgv)
zvI`o9)k{BkQkh0%g}{>Vza`ZMt#05o5HyZ9GopvkXzo<eYBrURrl-{u-MIzeXr9oZ
zIYa_#5jssG(j)>6027JPV487bs8+gAA2&rw`)3fnv|U9<FCFQl^NCE#)uj{<wBp{2
zUs}AZqwhd6$>yY_BrR>@NTc~1Z{CMCC8)%rmDyfe&{}m)AzB#4F-nshI)kXm9GdR%
z)M{>p_K<lwh<2f<j6qWqUdG@F1=?ZZF$T>)aIRoYT5hj%2@TkLGZQpguhX98Xvv?K
z8EBoR&LgzST90HP?YyNw6O&1;b_37~Ey)VB-jqh>kUTX0tVZf-<W%PY8luyX=B+6~
zX~@$XD5VK;Npafi?|s%@QAgvHG!z)BUR`I<u&5|#;8G0|(r~2$G!R&-hZ$+i(Ze(w
zN{$#bh(!a|s?4CVK~YfUf%MZgnN+5RcXAi$Ux}6pHRHbG<MvblZ)zHNtxB(@NwW03
z3Hbu58etu^>AZ(pIMkHs&Qr5>8SE!}sSWBq<R;0|g>KXaEy9o5anu&M7;o|e`N?~v
zg!AH3m8A_;b*<`9tK`?NPOnnmnkSi3cX*Vl0VRoA^p}Mt@)4f&@Z@woA~EXmRP70l
zq|`xP?n?QBJvlG&C9Ruyosy@|m8*ON`UEJW#ryoKX||Im0zD%t$-TWGO{Hp0iug-a
zz4hwEG_`*ynY&TYNpaSqqAD%pH|Uv#>iT**M(hTI7GP3!+A^oLIog7w8nA~=t%vSj
z=510ds8TBsY+*#@+6*HzsY;tuS~{g*B+i_>P#-x*$$JBS=i?VNZbBx)CkpgD5HdK>
zNMxW36`BilkwR5Kl=rfXl|UCOt`!L19Zc*7LYWHmec_%K?jR6KQ0OLrMl1BW=mwE3
zQKUilA|SS9F%U{5a9e;-=m60TRVWXD_5iV8el6&ALGK9q8_;-V!h$%P$is`di-1t5
zz&;v2#kUVM2WW&s>qK`W5I%9}eg%ll{tgKL5gUhv`vQpV8-$ODLpc_RLsSk#!wo@$
z24W{G^i?3X<sm_j0kIpu7P*gr(DH@ZJbb286>0`z*ERvMeRKmO+RpIRA)x6Bt;F9E
z_yxhz5<=3QiNEabY(evZXe=Si_#ysM5te1NB1bTy&CiU!hB#%k1HNMPbwRHQ`a`y-
z`>r6msgX^b7G$~}H$~7qLC?X%Y~rAxB9!jTZ4z{=pgRQJFX#(FJ^h~9a|B%~Xttno
zL9=^#Cdvg}FKCOP9fJNU=tDGo*{5}VJakIXXM(n(ImvQ61U=Eu<Ms$@4|?2H{XKL@
z(98iIw?)tgf}S|X)9sh%p<#j^67;d4i_kt`UtKC_iJ<4u<YC=+1YLke19Po{?h`Z{
zTC7_ss8*1L76a?f6tq}Si=d|j9U1DG=snCsRe~NBlvC*GmI?Zip#6eAAMVNZ!Uw~C
zIag4lpf*9h&iCZ<1&tCkNzevCFALgvfoJxBpp$|=7WBCw7lkwX>NY{{#UA&Jpn0P_
zZi%3kf?gMNR8XHwJQJ;gUKTU}MK`<q6pCp^7ol)wbe|w9rkPtQXt$s}D7sm99EvSQ
zHwwBQ#V>Q41wAF`8Wg{*yH?Osg7yh|NzjLa$|iYb-8?}Hf$*WBgsTE#o2!Lu7PLjs
zEh6`@a8C<*QP3NLMxsdOGIo@pF+l9@tw8MVW5Vqd^hY2z`@V4h5Ht`~0qYI{!pDbj
zlmW5L^M$)kxEkSFgxe_Gt-|dT?hYXK-#w!Hu%Leeu@62MWTIMPAM^xbv!jIz0kMfC
zf|iMHH4vNFA?OK_ds@)*K<vf=kvk<Qf12k;fuP|)Y~n(od=*zW;V=6o4+upx;*WHg
zyH>cB!rd?21H!#1+;4<S2zOFAnoMUm{6OqR7Igji@twcj5lOS$+3)<N7HClogyh+w
z5gdS>^n8>4WYahxF+~~o@KSeVEXl}|dJBmK)+VFfp41yiZ0Ma$hKxL@%~2?9lkOkM
ze4fyh4{zI~A-~5mg!X8L!epCw!$+B(`kj_RfFMJ6j!=B2KW}QKi??kSa1^DB81HFy
z4<*x%znN~G(K2X?z#bm*)|9-mv@tX}$SwTM41RwtLq4@lFSejac?z`*8WWJ&pW&I*
zTSchd_GS0*7QrM<Z;%D-lNo?35eG?zPFCNQ#;gI;na0p6s#9sqF0w#BZ1epY%;Oo%
z!3^eb217T>dk@=er9>jbybR`&3}$8qvn+$5MIGM5@YW25R&{s}!$&fh=QEg>GMINW
zm{S=H=0oIR&HfooVFq(q215e?-oy5+O=Gq~RrLSH-IP?IB^NuX<v`SPEt)W9^7#K(
z{FvJP=LJjNol`5w`+WPQ+%3hNnuSOg<0*)Aj^`gdZbnN(SsS+NdTKRd(txYRQtz(9
z7%Nul@))8gSP^NRM~4}CYBH$LHuNYSb6KK~n($Z>oKai5h)<76WqEYt|Iam%Slk=t
zf!j>;XSwK5TRbk!vzb>uu2_X}Bt7Bc*^A@jF_w~4b-xd91qM*kBMa-VQf?$$fh`d0
z!^!LM&U#&6`fY(KV5PKfbkT;o)_Uv#7xyXdDsatPbt5emO}$-F8B%LFJ-;djS1l^C
z=LVRp$9QD-+r}o2@$MNLKehmmciY&6F=Lgwpnz^0qgnyWl5(-iPod1)#$G}hnvW0v
zK^9fTN&#e3>v?7LEPqN!?*H<(u~~5UWJ*b+tcO3k-!?|0IW&p3U;A$u36fm5+s2*)
z{WL1>fe0%-s%jv)Znuq{g5E|{-ov#V)zQknZnuq%g4xwdlLYib_I0~$tQA^cLj`?%
zcXzwpHntRUxKG5mqr2Q$ZX3H6a`$LCILZF&cH0=b^J)%_wB><tYJE>Uh60S;I_^^C
z_?8zZws(3LW>jzTJwq>CKeN+0LJiAM;!Uhm!u>HFosn~5c?U|Ujb<Dup{5aDs_mri
zf!U=mcY%GlrR4x=LqAn|`QGF$UAVOjcM;*17+et(zs|*-S4-nJI#Z`^DTrsqmV6qB
zE%-E8GADMU6U!=w>-n)y)D2{~YzF$3$6^bQCQ9M2Us5X$H{*14#w(A-7aong7MtzH
z+Yp))ztH}9k^-)c1jNYR*lY))V(uOoI<Z~(@5wqcz*nn{qRVe`Iu1rIh*#h?9sj)e
zCO01WS0KLmU%}Xzc&j@*2FF_6;?7vk)K*9CPTL!w@24w#u5e;y$I26T)1^NB5Q(@x
zt>cyG9}kqO=-bH`t?k{Z+P2ACajGgPZe}~U8_YS;KX!<23tEQTe-^_UN{Kh4Ct^`t
z(}p-%e*7yS>2@3M`Jdc!lX{zs&%3?`2i|%YnV?IMer=4aZ*jpTCv-<l5ASN2p5E0k
z$@^{8<uHDI(MwMHB`m#s`XUv+W~KLdagk2L&Xp@sU@Un%3}z=hf00z5RH@WkWcsF9
z4!M3QmZLcuOf|-qV|6xU^xZ#n?Tc|M${O{(;mCk5xqL+x#sB{Dm3_KZ+U@ccT|Zg-
z*TSWYdkif1%dRZYw-Y1}+s-)d)cU_W8PlQ3XxndAk$<|KfSGpErO)}0MAA1lW>JJW
z30f(gO%NLgXwSOqZ5+6Zj1(HKY#d<1alMTLtae?V0CE0Grm=Ov^|lUtTd4zv&lv^O
zgS<ea%RPSqfNqSMfO9^k^P6%M#@2z4p>SpEfae3*I>0VCuD5l7)vn>k3U}2|B74-l
zpE<xJO?u|?%P2v{=%wv82aw$u!ZCVNDa{-A&5)7nt=^^To-CtDU@S|AmSHsFM^W7d
zi>QPJPY{cc5kv}EpYEnZQ7kYpi%oK@1wR@X_$uCShz-TshQ3(30ZEliyPbZ@Q)4Lv
zuR#1P7B^$L@O))2b@|%yE5L6IvOoK5zGp8ED1ycF&w(zMF0;i~ki{+d8Nu#8=F5N0
zbtd)s=sTcAU2Nq#Z6({$NOt@Rzy2!uInou$J-DY}yTxlB|IGsCdTJM`1<c)6EORSd
z)+|#SN))m}xxX2C^P}kKXmsOmr%iXKuitgY^hKL5X&-XM=+XAZ7k^bX{k!%?x9{ny
zc01@66;|GI+1i=YhuFQ{daTJEZTDJcM{b!ub^7jSH@l%_m;G$&^xC%Rb(Zf-R{0hn
zK;A=HDrI%;RYif-YIQ9QF3}UhkFY1ROs|X`MVfdhFWiHlr>|EEx1=oWokhb6ltJmC
zG!Emf<mbrB;z)}8jGTo<fopl0F_!WEx0>K1vy_nIJ+oMqJhR=o)vhcGRFEwB3k#Cz
zffy1jbH(l)#YbIwQ@B%CazSbI#}A9p=rvox3j9?M#lm9z$OOGf1K6eaI)$Syz3ID3
zwUuJ$dd<<BLQdxB{jkDOm)?&s@6emRtkkun9pHB1=QDO2S%ogahw#H{y`SPm9~B_I
z4l5X<*T>9$ju%;%va*iiKXr9$o^mbX(z{aOs7voE<{f(9qIr7L_n8{Pi=d{p0qi>^
zz8cDu)yI@-yYVAa^!^%Sm)>;sAcd9Q^oge0Ol9tO@zXXF{62mNEWLiFVCd&~J;5x(
zs-6_VhqRz&wD`$DH_0Z*qxix@4f_&6-D6HGGH=S{RbfaaUpM&>$}%dry3t$`kvp7k
zJQt}1W>H-qQ<+H>AyqO`{!^_c3M!jPVNhM809i&KC<jEfb%|2ZsQ~_<)`1bRq(v2R
zXPslmVhzaCFKE=liD3$ntBk02rO`&7k3~>{=v!elABdXwS;i$Wajrs>1O?zlmJ15X
z1L~vXiUf@VVzXC?+;TzHBDYrLzAd`<38FcDw)tU^dr{CUqWcjL`|4vspNg&nE%wV$
zL9|1PZJrN={|N7ug33jADG-~j6Vxoa+XbzF4N$-q8r!G(lE?O$n<iWd5OdcGw^F#T
z2uCFZ%e^SvZ-k>1qym}8@w=md$en#0zn*J3NO{j@4Uo*RGjr6QK5Oz#@=5K@Bcd@1
zoYeDBYEPa_pG}5jzp4%JsQs+7*u>QniSejCed@!sspRWH4JmePllt$OR(WIn)Zeqs
zQ}~OfeYfWYt#<LYP3pI2K9m;p@TfiY*)!dGOG&T`wn_c<Oqr8fhSJbB3-CA7xlh5;
z<Hyf7sb))mQhVt1<$l?SJk1b<pijPFSLg!gmNaGz7^+^9GL#-v{3n^K3F?RKS)0bR
zLG`~e!i&X6#)^!l_y3wtx>X>m>Fy25d6ko@gfd9fK;1d6emr&s-&`qDJZwm<()D%g
zy@9=g;&GQ2kDD}c+{E!`AK4o>dHlHI0(xj<ueVB3=RbI75V~S!YB@lfNBd%VDiZt<
zO=RLJ!mohdwKx|7?|=7{Kr^*G_%hjT&=^ha!<1(ezV_kWvpxLLePnNViDBG};`f1V
zY?$gV%IMuk_WGcp*|W?r>c7HrB&OuLjqGhhLGmh!=@u<_nJ3q6WbZhN`-&R2Oa79(
z-A48<M>wXT)%cb!@WkD2BYXdiLhi;5hVfo^xwDMym7wT8rRCrxhojrb-cisiy&|4u
z=uz=Eb|NeI@6GT~$(B@x<x<NR(xrj07jzyVwR&J5M(pSwW_4-vnUZ`fGPwBQj=4i7
zzZ~g*^SfP;idFg#9{&Tz&Um1zxbxuN5si(t#)zRs#S>POd5l;scXx(|pDE3EqKjy}
zs={9$FLgs}Cc}Ky+JeM4)F>j|Yh9Iy17Cer{mob853}}{4l!e;d9g5VjrNBs63ygH
z-6zGJ7~9eVV`N>a6N=|7UPC#IY@5fnop?lz*kSaIhwC=efZ}qu<CREbe10B=?do=x
z4u|nr+4fl3!|~EU{eiN_Oe0qIU~KtYJIi*(Dt8?yI|@6EP}j@x(jX6W_L*F^Jwn5G
zp~O2p;<ht-_fypBh`s&M56+YhvZDF%%A*~x<lfaeg5pQU@%Vb{I9w|Yo_H%|L=^XE
zJ2aG7nvbi>(TAXM(a8DniUN4G<jg)NIz$CB80vZjemGD{No5=;EufbgU0u95-mknO
z(Ffti9o&hBRQLlYUZ?Pr(JO+B6XV&lCpu5`@&*IdyOQEZr4an?=5D{0EUn0k+vZD8
zQ(o@qyvd5~35Ckz;Xqa5L)-x#+YetnNp&r5r@wkJgpruRP*vh(XtwWzb9u2-@qXru
z<!doO{4AM(r-JZQ+@_Qa=N-T|gSuxwg?Pnj=!f&#Uo1ILs@ll)vC@1vP~6Ewn0veX
zSEnW=W&Dc#*sqWa5ou@kyV1?Xoj1R`4W5onjo+BJbB@*i$&ihg-+ZtD*%;ZcK6XWZ
zXemWTRpNa3YQJ-tv47TOrUBRLZ?4JT`UQMP&YtGcWKOTei$m&y^V7HqJ}u;L)VE)e
zzfvc|i60`KD-u6PB*Rm%(DT>vH3+vJ!u=(MIvL;bihTBa?B(`%hPD6Gie&2`b10&8
zzkEgF8rXT=vUq7;d#4qOUlCZGXz1>h7m)yY(4&wofF@M?oh%9$p;>4m#7he>L_dx)
zLq)K>>m>>@ykDTbkANpXD;_z%6V7`12dSGl{izyWKJnteOAjwZlp5<*Y9OVfeu+}#
zN2E+BgtQ5%{B$pDO^emnQe$=TQu1w8q770Rsr8xi^l2&!RxIDEqG}9M6|suIal{_K
z0g?YD{#Aqb75TB3)HnB_liTqqQs+T8vhql&d)Rjf)#8!kZyzl_L#ejy%)YY7gu}kK
zz#cw$<ej&V9yv_Z`G>dsp*~*rhsXT&v9i|=uYc|BEiWEk|A%<=#rT%roajmMcjV9s
z>&PL*K<rfPU&^b+XNtQX>>D}R{wu3KR*@eHtu-qWcl}GxqeNd*L3v$$OPE)Q?%P>*
zRAs_od7>Fo@#xX`mSYIxi64{w@o|_MNwq#RyeMCS^tB{I>qhe)bfP&A_KoHp{!kSm
zZ(pol^}7&yh2XmbWz>{5$dd=kP7`Fm9{;EIYb0BnR$d+^UOv9F?3Cx_XIc12*{Ks>
zC;#${QZQcW9+|1*`Eciv58ggX@!3yD@vn}&izxmhsOX5p2a69r1Gl&R5y`RbSlPDI
zC9$5dtDUH?zI}ea)4nfw&GNlR4jtZd1}SmoG5_ICq{ZpO>rcPEC2@HDnfSs)eEG@P
z!bEKO$+y=h4j;ta&l41u<ctd9CxG~=NE}57Vs@;;p#rN0ab14^RhCiQsbYkUvHw~A
zetaWGu5n3vf|hnY>GblwK-u2{dCpoKWF#VmIzKbili|<oT@+tlcH@voLWpYem21G^
zip29AyPgkKev_C`@z9x!iLykz@?@+m5v$ZO@dM159ia)Nio`$QHFzh*qO-(L2(FRi
zrm??tu<t-A^@>#~v;4Dzdy_MKRftekJV#-1KFq{Uk*Pq>_ETLj=)CaB5N&qoDOJPo
ziP<mwYY1v%ih5Pi>VgpdLwqkK3-c%kNB!|Ffr`Y7pTN#>nE&JSft@D&E~U(4=VzpE
z@JN~e$WfJlV9&PCN}?CQk4Kg#DiSxsvLj^)j#OA>A!1=0C%ME=C8WMQ=$xUF<vVhB
ze187T@2HyTg}#w<xBbP9&&-QB@t)?3(~Vz!YijO&+&WnPW%Zj5Z$<3w#Nm&-x}Ksw
z=|?|6jS0W$QX7Rx?-7?%c^?h*I7RiQL;*5FTKeIeMjOtr&h0=uirZTO)c9t!x0mJ|
zZ7~QUIgj6o0PF8n#eY6E0hjyH1T2Y;;`Yvg*q^w?6Uo{c8XgM;IfAtBJij2GG0hoD
z^g}2pUdxW1=p>7i{!{jkBp+4=c9aF<Tl^KbmmS5dY&@Emc<YQZwxjH5M;E4XbGOs-
zyV#Avjx)L2AEWH|MOW^2n(ZOSON>~!;P%oX+dHEdP)>`XA#+7O<+1jI0jmFtJGcGC
zjFx(SL;ivozWBUpW@K9Ht2kI>5LG}Hns2w?LAKMk@lP~S;B%D48(^EVBJv#KN!xO~
z0U?Wr^J9N&KL~^5%njdw!KH~#YTNt`M%xb#Lo=3ij&DMhL|)xy9IpV}Mc6Qp&mm0F
z!f^;+`Cz@S+*D&riPY~}ym&3@IMf9-uw2#Quo+GqUkn>kzL!Y{%8nrbMtloCo50fe
z^1MVbOvD#bJ2tkb<6!RguR$AiaoMq0<!hm(iM|}nc;##Hh5lGY0Ijl}{@zm;9?ShI
z#c%r;gLD6bItV)}hLb19Q0ttc&w-t>iXhqeBXY3JUtSej3Of^>A90dbzP8^Pi?-HS
z6V1uUIk4%bzA9V1R-U*=%apw)iBfh9m4~umt60G8D8vsuJlhJDCu&(Mwuf7yuS7b@
zQ!QS*`1lHn4#=a?PZ~Ix>LnB{$v8z`F0ZOkuAG~6WeJ&jEUo;I{zE=;=#EN1CfIYt
zt5|V>Ht6qeeviKNkJY-$=)3Lj1zz~V?(w_&SUBI)F);2FEo*<zirmEArcmsSQ2YBI
z$NsRiB60WMRXnx7=SH&5lm^Y{6qWB@{)eKAUn%a~Q88rlzoNIJoqeJmdbd{|t4PeG
z<P59Uj&goS<*^g@?ouY-fL3e|61un(Ik{sYLUrO{uD{szs@NM<<rQ#0aV@)j;+x6x
zTYv9c{Av+KAigL+K3f-Ns<9ONb&tJg_L|YEGkg7!A<s}R;X!|-$8i(r$RTd*9O5?g
z2BZDYR&+*uX<mGGUVLjXz9ATUdGa1~DPEX-@S`8*eq(R$9WRXhb?)<TB3ci`_Fnkv
zi5FtOZa-?a|Jg(&U${5M7O^8%<bn2IceTG`Meae@=*K%|54pYU{T(x%NoDWnZl?h*
z)!~X&zEx3y?#N88(qelLa4(LQbG#MFf=6OyM~gcbFNR6TBIoDn%I_cqkU{PEqC7-n
zD2|3#MJRr?ThUeSZ{L?!{K}5X_hWm@VW=u`3~hz0A%9i*(!?Qd`5d<q&+y=x7yP-~
zKZc#LJwt!h{;m@p|DYSa;_agLciiaZZ;z(tBT4Nm%iaE4NF6>%EgMqax%cKjBOe*Z
zp9USTa^iEGc<;%3;uE*@g@NM_fITwDJ@NdJ+3tx)w>p#m)|yZeGkH($f7}Mm&F<vC
z<=(ahsQAs}8}LFXx;6&8Hs*D02zG7A>uPmXND5+mk1vI`F5h)^y>?bbqW3A4<q!$I
z>JOAqMPD-57hA@)p(>xaKaaX#p`VKD<w3}v$KH-D48)cPF&;oGPllsGMD{0p>N~l9
zjQs`fQGXZ9dWOM+YmK!genv&&yNEs%tL^*HT0#wU%l|<Ew~OmxSk$e)80D33QU8w0
zK<*P;RE<CrXvJ^t7~KBpmdGXTpDv4xZ2xp~q_F+d%G~X%NUyW~)0=X))AU=sGB0K&
z%Y#q|8RO+dD1K$|_R7~5Cmgtbb!<Osy-?y1MI}m2tk3C;jspd6BVx>|#GgLw>RJ(x
z9;-?Whv#7>#8iQF0DaD6-ya?2gD_K-_!;C6IKxSAtyu+wYrCov55fA_CkXbA%Gai?
zieA!wVsrbaxNw3$)y3tg_SV*vCt6_^wI^ISUINGT_sT*yzfbulRK65lgQbbNNy!1^
zt+KoW<RT44B)d!Th3?|S7u4b<JN@zN^3ZB|`9%8(yCOb2NS)2{MAu)T{l^zR7~=Wa
z*qJ}@<xlZZP>ntVO$6nkg5%Wj<?;o=WG|s!(Y{(*PIdbRx2hs>nTkpDMWg4!<i~kO
zO5FC4V;nyE@iOPgGWYmu=tJZ93bBvd+mv5W_Ig7k4+bLVp4sPO9aJgWNoah=Z45)0
zFDa~}Z81hfE=MMmaxn6`XZ*z8`dx^QxA9x?KUool<xXynZ%WQopV<$y7J9jpkC!`T
zLD`%1SeZ>Lrm)b&TR7E2FPwrlCJ$ucl(H$gE=no==Nlx{tG`JLqsS?o9z#qnRZM|?
zaAz8(4f>Ei>Gn-ssnt(;G6x<}YpjClYqI)lPwFLF1H>On_?*<mU3tmi<>d6r@#oN*
zu5;nI`~MO5?%`DxS0C`cov=d!Ilxg-QG%d?AP_|%giAsa?qCvbK}C!t;UbWboP!ZB
zfXPv|yQc*;t?et-THE@zwzaMHrqrO;fLiYtP^qY>Nl}Yv6|0r+_ggc2=LGEgJ<s>g
zcb@Fbnl)?I+}5nQ&oJ;)g3Vp02AjJEoMdK&!JgI?EN*A-3e+$LYBEV_ZdVvs+tk~^
zB20CzMCc5?TT3!+u-=CS%K*$i4GH&Z!Gj_{Q*Qzj^0PwsWA>Mw-F>Ur(C$0JhIQ@s
z!eQku%K#MS@GdKNf{n;B7r;0-4T~%q8HS5^b!|`^)s+-(P#c{E!Rt$nlun+$Qw@iG
z19_r{^AU;`FNQtlG&8RsIaFpXmaM!WV&wIs3s$M~B!kB4cp*24A4eY*h%tTOjIYpx
z@%Sz>oCY4L*%oF{vL>WO8Z0KJ2a3zQx_mN*lU0)Fudt`uG8dsfF8ZbvLXdL{Wx^WJ
zf89sNg^&Mx8y%M~_&a7B-T8+7ztuoHdcDS&ZCZQHo=7(yAHvap>ov0qBPwh?i>$@v
z9M<b5?_J{4e^s=;VLm&IR{hT4KJAK^dT?LoR5_7v{aquYd=sO%t{Rtjzo}6%qSSLf
z`!%Y+JfIXjjr5jzH*(1uJRrgwLa_-Q&-xhF+ZuZsUKHV8v#EG^4L3kr?`Zt#xT3!)
zj)&9g)>q*nrUT|!iR3{2aGhbjs{_l8$jiaJ>&39%Gw&J7u!dxmGoRi!sY&qM3|?Er
z`(Jp<O<kB^b!dmt`aKh?Q*#@a@o#$khqmHHzxj3Xs?}=Oy<r{Hc)Wv>z{xPf`oMfy
z;#Go2F!)l~$7Y4t@w8uQQ@m!aT=!rd*52kvs?xBZn7@iLc9ke5EPNT(r{?S8`O-)g
z9vxX<Lo6QcFsy%R|CdLa@a)JkkbY(!7Sd|mPEL%xCiS_wK?-(7q^Yc-PHv5`j+njA
zVIX+^MB{|?3r$+jr+?Pqku$;mTVvyqCWQ^(Zn3^JhX|i0ygP!d=7TQc<ty#w+DKD?
z@AC8?^Iy;;@;FNU0(q!a{Cq8b<ZYBDh3@il)SQWM@GgkSIILbhx2C3=a$#6k3jSN&
z@VFbuGOcfk3tlgj_cN3a3COaTA@YJ@J<c*1mTi58r7nB$?PkU+EN2IAG188g3-t{a
z<QUP|yUa)e&pTvVKSW;JgYj@-6JPQ(tSsvx3GzM!NsI*6O9zIx37P%N8*1<{y%n{X
zZ}K)F3qY_!-ba)F5f8xx4j0wKM_)XlNgsH&uu5NLVVz)ofmIiKa2uZj#NidgI?<Xf
zk$MSK3-v41Cs|V^b$EzyZGh{qx#1bYD!DwvIz{u^4@_`Fl69&^;$4|5(r#F?23WsD
z4N}jv0MEBuc=xV#nr4evS)fFCDfmj%($lS-lGxj=NOkS%IPWt;3Lvg$SkwXbU~GM{
zyX`fypE#W&>#8^F!-wkwB7H%a-CiP8|7}CCCO=<qV6t~p`RQH4Jsj6zA-m2Tlz8U(
z_-CJC-3Clg!j3)I`aLXox2-0=qOQ8pu!mUhLjOZu;$;bS>Fd(88^*@iadAf%2%Hj<
z4^*v9#d3GAz23?|gH7$)#FJTueU&v_5N@PN-AQdXS&IaNw|?h0;7JD@NHXlJtp-8z
zz2B?XE;H;6R!R`^-tX!fxnSMC#`={Y`$w9XyM}$OrWz1wTCf&+6sYSoDi?9$3wn4b
zsHOq$HYyL->-Y`fGs3I+Mlx<ZS#8)Gt!ISuP=t@yBkLMefSWY=2)^&We&w<ns6r?l
zJY>N)B9|e%@Xn8T9E~hKh>Xi-cJ>mD#dEa1`43K8qzrftQn@ix#H}~$Xm84VZ(a=u
z(rh>>qOy=kpmd^zaLU1xAR#TYPchVNmV{2sNaaKh2%#x-x;Jzp1SfiSom)c!=1P}e
zi7eb705+2|q4r(Ye!x+}X67nl`r3zq=}CCH-Opy*tAr(HGk6M1<A#fHyE-nZu}{!A
zC$grgtSY{OuiqN>i5lx>@DQ|pk}$zm@Qll8?Qbs!Pd*J@UsSJN2e41JmF|bMT*OPk
z?NjVKgb0#Sg8OeMVgu}l1qE3tTDFYp$v#b^AS=^q;(XUiMc{P%4I!nJ;30*sm<_be
zo(vmeQnFfwlxq(V6h&k;)GUsS*@JBMpsm59iJN!z8q_(vQZQqP(RF38T_?D4s4KYB
zt!@q8^JN9pflq)auCBqEHTz8aW+5zuNGI?F_*(Uflzo={px{eTB<~^9U1trVoz0rA
z1n9f4_GSt6W|pOuBOO4_0&$%NSQI@oD2-l=%iW<nb49t+sW%l1{68AHGjopd9}vAQ
zL@Xs{R~Hfd_W+`g$s9YL_Zh(Uk_MCcr`)B+FhTG;N&GS&yWD`jOuR9Y%(*VMa7u(u
zKM9=(!RZ$;x{g)2&Q{p_21-y}hG^TF&jZ_!*NBxkO|@v?V+q5#_M_1(ZzF~`-L4Zh
zc<Q4XuYg>C0oo*9*1y4UHZs4g!Lb;gA=|{b;i-=kEQqwT`8u=@=p)ADGIi$$)nz<A
zRs&7wG%MRcdAz}JTG*+u2Is~$%v*s=rVJ;UokzqFBa<UtJ3F%h1Sb-%be??~@Cid1
z#&fqz-_SVWM7TK5|4?jB43Am7kRh;p!YQPC@#kWjjb}ZSG&?V;xR#y3Yki!TRUdPH
zSI$)P+NcDT=2D5j{ZKE)(RIGW|2}39j3JfcV38U2vS>eGnBzva-J{P%u*gI4w%g|;
zH1kvt@_eeD*+&KJNN>gN*+=D{Yh>n<Pj&PX@*zCJekghoS|mKT*L6Xpy(6mp8*J&r
zdn4_~qHjnr4xTM+sIF<i9a;9{niNm7hqztQw}nog91pxNXsp6DaP~9N4spZ#H`PsZ
z@l3n@tmc5HJFD?zJ(R$6Q59djbckNu{JN>Q9UV9Ci`(;>dH^2dlqfKQi8biz*)M3P
z+z7ID<r+S$Q_P2X?H8j;uu#z43}n|tFF}%f5_as9`fOnO)k|r1|30%t?4YGDA!%*&
zMv@XPv)4qk;iz=-S{)c0aGW}(nyiafh+nkeh}2p>rEE8792)T{h?Tln&`v}fg%S-p
z-d0)`5U-DVf{tczBcXkjwuY*?DazxgkbMN8It^DxpAZZ*Gnxf7u4w+FUkM7Dc`imm
zXz4W#RB~xuEt+|4hbGpSTiVx0&yW!XG_e}!*c+o01p_^-dfJA)DSCyVpopi`EXS+b
z_GTSHsA1LhxIrVJfb}TOZq_Jh;Gmyx*ex1a!f3CpX8$t2vJM=R(FY`q>Ffll7R8G`
zE2!DfW|T^*h2HY7tNkw^j(ynP*Mb7|XMy}L0w$a44v!fDguaB>qniL&@mfPKbm~nA
zPOMU{QyCJlJcIz)t3&KP0k$_GIQ<+3JVR1k=Q|-8i>5c7fc<@lJrrP7*F~BarmHs{
zK*@oI>pX;7?mAD0z6Kx<gja8Y=mG9jqON1XO{Irrrl@qMWN7HbvQtS71M97cibJAr
zbtjUz3629!gmeoG*SQ`4`^XryD>6asSthQt0u(AnEISpfZg&0*L|6A%?z@HjLk(8p
z24ASPzeFcNKV%$6c=jV<9mBp*yG>l!K~6NvD<t+#jlm=1^J^N`=nMVqN3}N>V>~y3
zq4aXR?U=g^{m)}V78P>E)rM>THTvx^*eAkZp`X#AZVv)J)_YgP_2sy({gkN4NL9n~
z^}4P<9dfJVo8b1}LT-5R519eELCCJd@LlIq{LiLBvgOv>$O#e5-SiVU7Rg-?OYBO#
zJB>RW8;!`IImjipoy+R#uf_$6M&t~IF@Z@SJ0pWx*vPWjig+V$Gl&dP2sc(M?_ovG
z%#ijo8w5sVShiTA#z~KZapc6!2<}9JvB-IQ88oL>jL7-Q51vTkQ@4TDiOFWz$QX(M
z-|OO)jz;7HWzCMQRaO;#)ab|Ceci}e<Q2sBY~=|13P^(y8L9%}vwKXr>o5}kACGAE
z<;fH)Tc)@A^3GtZmx<{{qc86bwtAaunDk?gZuaF}!d8xXKHU29K4B|rwvrAnlClSp
zOOfr13x=&eCZ#sB7HZoXZT<-~Jqc%9dFB_eurrJfiFKaY8~YO3PRql**7<r81Pv;$
zlQgU`dcwxl)raI=;~eAwx%DktzFe*iwkpgaAPC+W#H-aW*rTvrI8u$5SeM1s5c)-1
z^@0pkn;KrOiFe}ojE(iOb};4by#V`aFs{g$%*5=mH;rJ7@o=&BTddz9+^Y$tk;fF;
zTlS4Yi3gwqlD9Pp-Y`}ubrq=fj>e;X$9N*KhL7N(^KTu{csymS^6LZpTf#FpvQ{BJ
z)D%M$Li77bWAOww!jY?+t@-9;<OH6sQudhjBkO)3WFTbSEfX~?2lf-KAImHQHH-AZ
ztb4RQ!e{l+rdmIdITz+a6Yu-5erlaIoVmjGy9R0hnWegxQHcQGL$Vf_kLd7ejaeJ5
zCFnk?;5UWA%M_$xZMHr+hy0w#23~4mST|@2S6-k*2+bOi9l`UVb1||qtQH+hc}XyM
zo<6COeKL3pk#(b`6hdD-r8s?Mbu|Wf))r0D&*;l(+=b=}L@Wznf9nSG<1muVrs{-2
zR;OU%rp0^&6B~>oo-uBy;*;M=J>`lQzp83$;#V(SU9+CKaihj(a*_*zc9WKJ<Q98!
zg4-f9eCXb1%%BeQ%&Ei3J!bUPx71pTOyeZPOIxe0@0oAG9%;m#AZw~{3v=C-E0IyR
z>k5On%&%B2YSQ|?$vH2HX?2rA{XnDoN8)%AUE%&m<M7(G+yQOfp%H}<T>QFDCd;;)
zoGinOb`egBF0EBh7+XKo39MA&bEmd0&ft*5y315!l8e=A)k{V3T0hbey_D~TTR%3{
z=;m^xFR#KitV;7ErdBK^)<9<<j$UCR-LP^UU42!74sx`HS7DvusIaUIjxdmBHN?QX
z^s{SfQEEdRC0KZjvSQ_OXxtEkx7*c|^JhA$hDRgux+^IkXFH1qkyk9zSYHMEP;DQ8
zR#w_wYnTjwIa_|1g%?;cTOMkr;m$2mb4Ns00%uqww3pG5l@gJec;!-aJ6Ai6$(YVG
zjC4jx-5RIg&m8TjGQgDj^ct0h^R<scBlB;Jz+!Vava2WIsI|b^z`R?l@^zsmH8Orp
z%0=1=DK6DlTU(VHhY^fnEp?o8K{q(t=&PjSV)G`j%M!}~Yl=Pp6x8DXC9h&zMGO^$
z9c}e=Y>8bUv1d)LGptfukGvEOQBySqYBH3QVNKJ@3-7**eU`mJIAA!`i1!MyNWy9C
z*;-lmk0fM190QD6!<wV9Cr7GfszzbwYV0Yfs!(5Xg}q2)Pesbm81X4Y>k_jX$;k@r
zxz;7tIj1u7WTyF2%VT2)Ex8hp+Sis+RW8xW1CMHBXclN!>oSeDl~^v-R>&b0s9e8e
zT^=Y=nVYhzEH$jAR*=T=3X9!K&Q4*ZhshgjnMPpzgHeLIVaTes_KB+OuT*J`^^RBv
z7=88K>DHxYKGLAyghdm)&Pgy$DBOfINeUMUoPj)D9|(hzjjIAV04w%Okyx`?IEihv
z^)vhG0f7p?R~IZ;ArnO7|F14cERO}3Ra-x|IbXzvql)k1m0~n%{lfmPZanzT9Om+@
z`?MsX3d-Bkzto&!k-D{NCc*kuSpHR5+S2j+by)m-hOej=C3?S(*8r8tzp;l&Sh-5g
z{?=A%c1Xtil;Gdlo5Xb}-i~Kc8rB0g2T<1F5k_Bh*HkBCsp%ovS%E!fHQOhih76@1
zYq6Cc(+z1-M~IDtdRx@GQKQh7LWWj0&1fuLm%vR3)=k<W15NqL8k~i(w&-NLDt4ZZ
zo$6q~$IbSQ5?!>i!TQGK=9!2}mbON%HC7|+GAUxMwe+Njl9W1&BM>$Vs#U5F#gT(;
zYn^VwQStS)-_|no1~S*y>DGwIz=242eW_BM=SGy`RC;=3MCoZHy|L@P<WU-n5lSPb
z)9Y4aIvqVkjm-d7v}2w|^k5&Yv9x~08uS%4&P8vokxQLd1@kM``PwN{wFzS)b6A>#
zd!pgOLx|P|k?A;~#@<Q&q7^k<G`%pQnt`b5)Q#0Kk45UISFM+KgU4wKJ}j)KcC36&
zhS!D5xD0Ao<0DEp=PKzc(AFWkby>sN7HfjWqB)qol0zPAqGmn<%xh~KYk-=hQD_e|
z(d3Bg{f~(RH?vy-YFwnMy1Idr#wu$HBXcEz6HrzS%T#Gpo1;)T!TZg|XzNyI4NGgS
zWXWxgR%NQHw`waEp$zM8XPj_zjJ~=))|%Ilm$H>v|F+m5Dk=Ih?7AuK{gqzFL8V6x
zGOYhtgGEO1c6AvCJl5Bm0EMAz?NLkB$)L7lWlQQ@OtpWet@0S1;|l6%OFN?!f@}9J
z+rB_m>qxz7r5xR;43Yk#Xo85=1Skes%`vPVwvqz$c&e$ogR<zULl_<5^?4VqU5#jG
z>)MIZpgdyE*6O8E7erQ6H9{cPNcwtf?1hmlF)o!>DMzEm%5pwl6~MSjqsD>V!j%ni
z(ExolG9O4iU1assxbaw5t3y?Z*+r7l33`IgI>F|AjWxJ1vR2i4X{v&Cj}mCIH1tVY
zolRHj?_{n1W}~E4UuT6`gQCq+HrIN@z6aLG2E%Hz?~rhf{?%8b546+f_|P#2LVxs!
z{ZVBfNPS{t_ND?^W!?|JJqeGnq8Y2s03&wb`ef))Eha3NN&fWJ7-%AvsA2WXP{rvg
z2{<7`NkDcaj(G&umXk76mkbLxx<>cUP-Thw%8rhz11D!FjRa8%8pBgF&J*F*HFiKo
zwOCPOXX6<NtjB5uhEAb$U1@GW<g)_%2<!RCMd<rSWIoP%Arg!W;;Qv}Q6n5l?n|NC
ziepk6V)JsKtR(KpyH|A8M~#3GqUpp?;?;<XCI*jK$I^wfH=;YDs`OrqsK$#Gq3ViY
znDDyB=0<o+;nLMuUBuRuh)$-`Q~M$+e}@{jx-l_h*riC&$;x7$G!SK$aZVjjQG(`4
zWkihF1jLC1M`w)rHQ?A<c?`$MxImX^tV*-Hkj@l^Q#eTCcWPhA3*V<_&e^g}qsM8_
z19k*1Go91Soo6Fc(TX~!>(Kz(7Id`M8_q!UGNqCv{-G6v@QdmVCsz+8(1X0FUJZer
zK^li%BuUONo6cj5F!G*Vbp-}x&R|UdwIUepZ-_=?$gK&_G*y=+H&P{&6wX=Z^}=h2
zsJOXYXLQas)mq0;bbs_4?n5;vXcu{X*%@ZGh`-U;RDh{B=NwHi1{)7(AFg>oyKfN0
z2vc=FCPeD46vVmO2X@U=Eyq3qXQW1ypz=c{Iis|FI(9tJK3cP!jcB3C<Yp7Y!JD?C
zU(3{ZtQac{4jzXU-2C9N>hsOl^O#|k5!6xM-7GIB%|``xf;pM$ZcZgN_1MwjT%Z}P
z=;mlR7n)lo@v9^Ci1%1cRUbk7?2Oa4cqFlQ<+_Ay)p7FG4AkHzZi}jGC{h#R&Uj6G
zEr;D$WmQ9Or$ErML8hT5o@iLB9(r;nnBPUPvO`AUbu=ex`VQ>yKtDv)JHwfz(H~$-
z$A&cgWGM-I@FBI`#VM4z0DCZYdDMd}u{u5vYRM^*?6wCVF(Wli^{Y8&=S-2ous!%I
zGlE&Xwab~hi-0fI`2QfND=-U%evnh5abJsn%vk|fs&Pln$eNXFW#a=Eyr-(6w=-2c
zZ?cdf3!#D3?hC`2rX8@WfIG3A={jjGn5%;tRqMXa4B5Y>wx#gRUD<!;%+$17(H~G%
z+?i!2SaAnqpUT>K>rj7YYnsQc$Ob{o(Rs4Vg5Ima3^R%V8`ZGHY&hkb_-V^HsSvU0
zG5BfJ^%Dt3oj-BWP^~QfS+6X{)^bwBc}NMR6GP3T{gJsMldfS?x_b=a`so0t$N9H_
z0baH5F^2S~)f+uzlJ&F=Mvn`rn@_8sf%(lIV}%Umh2D0Laa^c9oy(a$@)_vqT+8e+
zo@<$>bLyZ+0cQ?Q=Q?JO39Q?vsRgkf6WQFJ{&!MOx*vF`H13Ua9S($DhdRu4IO*s*
zOc$0(Fj(kEB?mne>oI&RCQxE^^~<=Or^g6Aml3NUBQtG1&ZV<8*p$WG9wU{r6|29%
z=rKxJ>{xxC(PMOwGxg^gJ@S+VGtB23J<d}Wyz!1CPws;#U<ApXj_K3>uETjPEb_Bk
zr<bL9D}@YjvaJtIZq$nK(QfM_DLM{%*VbG$Uxs7<)F?-`I2qO<5j70zjDfC|VR08^
z?#f2oiiVn-sHbFGJ*3x{i@7?Cf2*+<%(b`#i70Ru&~;ww!T)Rz`pAYnHOI>V3eazX
zVISFk*M;uA0GSTABXCnIE8HHY7KdFY2Dp!Gfa{tpRvQ<{vNv}%!S6Xj#qDs4N*2+W
zeL@O?G9louxMK;piv|Si;G{z5KDKWRO9IphxdlY0Fu~6QkQUKIG&z2kg(EPe!zmoS
zus0(Vk^z_sQ^9bWH7%H~%{)3nU%;E|aAFtR6EIfC#taPET!+0cS0;j7hlACu;K?`F
znlAGzk(Fw`W`^$jqSGh+_nEra%r%E;2;7zFw^LX-IBE~0$nGHAfXe2~e=r3vufz4X
zUbD}_?3bRvdOe&c3g*w=(1AK?{%oJNV$8rf_8M%IRWk~I*ACf{l~e%Mo7x`DSdT2T
z_Urz9tSk6h&ZI=G_hr^zQFUl4BZIZy>a>;4!8lcT{-Z1Ku3_uJAYi1CGm)<IGsz34
z3ev_khoIM~-lWU67R$t$3i4t->!`;}m&iUkj=UR@JQ-dZ)}?x06Ny%1;3XQ78L6&Y
zi!tkE+RjeY?Fd&-=&0~qt3l>+)S#?U2Y@Qfg^hSHuLGYwG2zoUcuLRO?64XIgG9w@
zg!NsAozKVyPE%b`)rhda7cf-(Zx0i&p=kBWD)d*suQ9GJ;~(fr%52qx{~tYvDO2-x
z^<3YeR=7haDHd6U=})!RuwCO$h^!1IB!8&m&#^fA%XjMBM89`IqYT#Xk_clb3pyRE
zsbCE2M^1@MZ4E)1IfZx1d{{XR5K1iPE>2->XV+4&7HIzp734Y`_1MyH{5=HSmWKeH
zvnkm9bfoH?aW9RACa({=d-=3NO~$A-o$*QwJ13MwFr5Omd)k%tLbaj5nV@jk&QsG+
z$A*4lT)MdZV-0mzt*oBWi0d&|0zFBgPmWc^r^*tgGg)CyiD7O;?e@|v3zfsEv9(wa
z0S+A!g&EKlu;w~NIh+=&Z>&jF*J1pCc{it6VNZ`$>v`5Wb?a;5b?BHVhk@A1qe)8@
zCKnhrjCZCg%%Ip6b;}b#s`)NwnrgPrh^-M`^VJB>nXZyQB*w)QXNFo!84+76Q=`sI
zm3^aQYEzywOAWEc#8z^Q?aWr5$Hg#(po5vCX6_14V9V^xWy@?0E{W->H0L74aC)q<
zW?iu?1v_Pm$?TXk>_IV>bAJLBI8GP~<=|AP8MDgRGG4vT4ow2PoE9r)m&WR=u3lYN
zRV^Dlor@Lr@>rEDSvi-yCIV3%tJ3od&ZP>oB331ZvqVLCHRP>Yq^=5e(GDWAbQ8p3
z0J;y{lZDQWvw`tFt)BDL&Nb9os-YMFXOZ54Mn80tB>!CJVfK__s@JqbtvDO9>x=sr
zoxiBnISkL}`?7$8VVraqbFX71Feehk&AWdkqu}OUl|;z6+JNgER0t;)+`Oyo?g=h)
z??d{<v|B8=clRl=N0DHLc?uK6QHHLP!M(fh1JzHiIK;iXXQTTbTU&~~wJ7&5g7Cw8
zcU1^ZEVy@9*<CI>%BaO~dYEIu0_&d2-rsR$D40>slxFJV3x?_=_tYI5EZ|A_PL>`8
zWh2U~P#)OXf{b^ao59j`_M?DZhcOgA@>2kkl>Ww`>beAK6rVZZE6nC79(=+;`b&_U
z(Lg(UKZDm)HG#k|$BF|E-SM|^F#7p|9w%tTlfO*{4mjZeQ~JHQXs|HukkwD~FQ#dZ
zJRhf7*=2=|5jD<Ar^be33_q}HQCCf^X%3UrlJ^+?!|yxrf42A^Cd1in#!&3|;5dY9
z9p*5}{%y`M4BE_dXz3mRqZ4lc@0GPz8|Kr(z7RwY<152wBOJy4>3}_#o6V;+-*d?K
zZ^CzYEh6{~!Q0?*_y)s#mMY-SupAd=xE5ln;~{OJsYE91f!P=ac~}Q|Hd}r3ur&JH
zoZ$@e6NZChs|H$CoXlDlZ!*k(aVwF%ZOcZS%}UQiq_F}^OKcTQ91rI<;^*;A!}m*s
zH43*MN7bNv+wn0)9|5~_`LKv#R!R2khri7h&XvME`GO#Os&rgOe+u*lI1k5)+Es?R
zjCt@FaKqP5xf&JOtY*v)0dag-e9A&<si<~yvjn#lyh>~&4CYl~aGP~-!`B+-4dghD
zK_btasiESq9GB;iIqopRDiot}w=gdQV_vAX9UlG`GQV3hAHjP+$n@t-L?6%|&$Z-g
z%yz9@CgM{pJafTsC%ze=A9`VsKgDSgE@6a!0%!6rWrXFTC`@vwBL^ILp*Er2OCY9m
zR7HFaEPn%kpTgfuV0)ej{hXlS&gZ(dIagv(0@5+8+W!JD6@JY5<{#kYf=7W{1KjAq
z;lihZQFZv}#tYwpMgKN|=wkT13*T6^`PW=13ZVu5ahfkZt{k4~$gVO)O|-$=Y;5<x
z2gJk129aGAM0NzUkgzq(bwWQH^v6goGN5L8O#|k^dAbUfv)MGu!16_WWg!1)$hJ9P
zJC12y0{7`)X5M7xGrbYHvv|biK>c5-?Vci386Cb9>{e6qbw615#3+gfNIJvdw+6u<
z$AbAH{_jx!qwqTp-yZlMHZI7OJN~PGY^}vn3o5326@x-}{ujOhh{)3+gL?x8V;k}e
z^M55nn?NzP;k>}=!#aK?1X+qu@`<CbCg#(xO_7Tqf@H+j|F>K!FraUF$HOpuzk!#3
zAR76DfaJ~X$EqD@`is$3RN7;=X^w`c>+t;x9>?Ve8L&Hu{{&R#-ICMiB68ov4TZwC
zX^&}c0-N9BD*|Op$ZAi(Y7}IabZmccRr@#bDv|ciFyArFHZU53QFao{{t+^Jr#rKE
zBxAvBBJ;ok`9OT;yJndD;{;%SUELHc4nWCEsz!sJ=Mi2;Fq6kC&3iZqWb{<HEX6k#
zx$vpb_d>M3Asbf6N@6kg3mT?vnf37VAihzc{*iFS76mwHg>&Bjf(NX0LgYs^HY}6Q
z9#B+6);1R%f}g=Ln{z+i>NRSC3Z<_l@o7USU*T&+NOl3^&yf0d52<eu(s;I0{Ung%
zvY(xF!yF8qg+9dse9waAtdQm4?koc<Zm3FEJ8ZjaFv*L~$ptEcmxI$U(FpcKBp(Ae
zr6Vs4xQ&9k9jlg*krBw|aX}W0l14pWZF$(1JxaEOnd8-Z^0w%4;d0_ZuRQ!)1${q)
zJ)DiZ#S!$@3CtVxiqU(rWQ?`V7*(fMO-;SphzL}zK|kt0VHB|TW|(@Zaa*>E`cWPA
z=vW!q;x>Jm+xQZJOsZOsW3#HI)a#4eE**=d2oo!d7!Z^pFGk#pvLDNGP{)s2fJ-l9
zHZb$KAJklLn=&2K3z`kz-5`8jQUSeASMF#=4OjWJUM=vUT7~5yqOzvG3M<v-bt*>=
zfzKQ8_8xfIlb9nQf`YnE3y4BMMFj}wJkDamN@~cZMErWmpDD=Qv9<8LQLO953a`rg
z6s^nZ*5KW%n(C$MA#rn)P@aGynf%M%Xw49lzfS~R9hU2)Yxs<m_9PIDT@TLBTFihd
zv4XR*evj6*aD7g=y(U(;D(gqE8Y6Z|9)so%nIGgMQ=)m5btJ6pa%Un<*_>kyvrJk{
z=_B1?o6O(+__Ctt2*S%eW*7_e4z)XDn=uL9wCy%4wON){pIC%JE%>KxM&Z8%-yPub
z7<sHW%tK-6LF7MH(?SqGREEPg(~PWE<@$*(*FgS1wPnx+`R`Kf439ei4f89A3_?oc
z`v9RG(V=}6gmz3yS!FokWSIBcqD{8K<A%OCdymq2X0lH1Z-V5W$LTTiw`$@Gv6Tw?
zI~_syJnoD%9|+@HuU_VO(B=kwYg=?I7JbY=NK)?y`>|M@f*Ai%D$jp_n55|cq~m&N
z;o7>TYcM@$9<clNfv~*7e~8;yEPKJ@OTuXbc%#7yRS>g+ecDFD%y1-0o8aXYd?`?l
zQbA<MVSupeWH>Unu+3p{_K=|&8&0DaI!bsWfNB0eUid&1N1`$ZclM(-94R-Q9rNDD
zdewhaZdmAFp`a_cTB1NwC<q-Sc9so$s9C$h&N}d2dqeJT?XBkF%E@-G39H<@eqA$t
z;^e#R!~y#R_rRcYZ&>l0qOr@zub4P_{KUk>cOQOe<x_9k*@xqk-c2ldB(dI(SN_U9
z$^Ps0F6eXZD@V?pcz5DguTESv=UsPJ%efOL){NdXdHnkIqwJn;<<`Pa&%NnaH52X3
znGemnbbQU^QFg-t(k`~wZM9FchMI$i&zxkR?2fco#c$l^P9&T41<i@Jg^9v~QTCNT
zw0m#0Qybj_TMPG`YxljuZus*gw;vfK9-4JYLCs_kt*Nwcw5(y~*2#Ca%(81I+}U`s
zn}>tHLm>`{nX?mazt7&a;|J_$rTf$Pq&>6kteK<jhDy8lNV`66M<>{c%7Vm<^=|A!
z`>INi_WX0a(Ei=V32w}tWj|%aw=W)bvHift8|>!|Yn&OM^vmWI&%`HfYhLk>_!RqF
z8*AN3_P-2w*Xso}lWw(d+_=mAtNoeb=I(UQj89y?eAb<9iwl-tdCsc*Ipf!lo}MU}
zSTOmXt=pC_UY>9-i%)Evc*#Q(mrtKG$)5MaZOdob=lsy^Kh$m-IdbBjf{CMMKjogX
zb@`xk7q72L%)0m%cMMA5yU!Pu+PL|4)yiKkU$H!4H{D?Ob6?r|aKog<?nx6{Ze2ck
zV)K-VGwcEJ;g{N%-Z!hz?(@UNH@X)NUp#r8ePw0yxwA%XI~NbR*ekX^Y&RWVZl5>P
zzG#A-H_~pZ{Qd4l6YcMt_ubNP<*7v%SC4LXE5=Wp_{i-OSI(L}uCUpiJ8SW*OHi=6
zcKHo<w!7=0g3*iSEVtJmo>*fKtwdR@t+b!TW>gbmwA{{}Y1iE6p7+qJi`~U<JeoH=
z0cZDbub%sbeds!rsGYgBU}DY17hQhwBKs9%mpyBjJ-X5w+;5isla00Z-;EpWyEjgN
zIntgJUo^MC?p-;HLA(75M!67z_ubg0(RV&%KeX|Nf?IEyb>8Ch>{>)D*PUrMxs~(y
zV9n*V_GEXL{hW!#tN6s`#PV5_QHVdRe8?SDu<i5s#93~?<uelY?>8R4b={9|gkT)_
zp56OCJG0VmnsA|AS?Nw3IBFYmYS7Gy1+$jlIdSs}`{EmBZF6V26Rk62b_3YjBe&Y~
zCfMhWwCgJ0A3tgQ#RHey>#Pe+YgoU<1+&hbxXI3cCBEXJOA74`l^c-5Zn1s!NUJ}T
z0F<K)%uK_)*2TjzTTttVu%hZ82JYdDH&^uJ(=)TOiuKDlqcu$-%xlx=<h7cmBXeit
zi5+?EhV;|2Dn{l)+kuY1Hhj0^lh<)d!q;&&jEq`^X)okVN0S@IhcgQ60zY^ar=;1g
z85vz9v3jg1D||hNGY3Bk=)hazQwz@Pg6DJed<JMZ?0+Dj1yB8|&$T0?mv@WCbkOj}
zk^D}WLA-_c#bGLovXE$Nt=N(1zZPYcgl>4VXGYevkx>I39{F(uAI7sQ?4@Y|m-2-m
zYpTX5j-h`J)!z!@(&gVuq%kPUnhyrk(%u-tZ89o&gQMqfrTIsGE)6mhK{B-BtZ51;
z%DQ-Dv?74J%7jDZ=I%VKIS8Lcjv@)mj$_($y3>`6j9x~v$BOz{Azc(51@t{anM0gF
zcWFo$$Pb684<1KnU9RKb&nn5XN+bzgagg!kaekJBycsTk96rv0DP@d&l`@_=GI~vy
z_^A0X&~SWsUK*{IA5dSS@?0{apEUwB{Ba0a4Kv`4^x-9{OI5T>vX<#6%R@J$=U6T;
zpoc79Nq(>g{5UEr4cxnAV8+O3UAORqeB;=P@|PAqBy7IUw%*3HtZ9-T5Y{jZ89b%=
z(P`}dk`)AdK4|#k@Mw<N6^5o?2tiaerCo_fKdU%vW16fY%u*58((dwJC|nJLW1lI<
z^DPJ8d(zlIoC>q7E4uRt($80WI>9ffzdCMn)BHnnicw3|^bUjO2;+m}!|kT1;Au*?
z5E~Jz*&}l+VEhq^ZwMLT$Ika~m}&Vxb!0S<K{M2k>|m$sUXekil2|@7vWmKdF^~mz
zlQFrN&U@a-+>2D%B6Fu@l}OoEG9vh~XZ(+ENY|{i%qYsb2q~D^Eon<e<}L?vMmMBY
zLiHZX47;ccVNXlvWm?Fxz#mC~ZbU5s2|JqTlpg<z*_nb*xHLy=8k(3E0e!-y$vjGb
zOREs}B8{V2tYDYs_XSS4H185P?$CT#-~?)>`b~$i0-t)1Yrqcx{=Ul!NPe^MpDmba
zEF=Y)0K|X!wc-Cxe2g2-zbe?JIo(w8r^!8oq@l@~`SkbD+CW<*xY2jgoPiGyoY7FE
zqwfTT{4NKs3Lja~T&7@`=8pwVxHRukc!wq@=hK7R5Bpo%o#wj=c4=-xGf7&SoRm+`
za=vlJw~P@r8uJBQNQ3k9DidQtM85>H4526sP;7#?;UiC)w<_4Bc|_oZOVdEpE8)WA
zOnrLX{{;7E@Tt)H6Z{yTX)O8z#!yfL3<7*IbY0jRE+>j>84X1k79tz_a(oPx<^lz~
zG#dp@xHRJm@6bG?@iafyc$%MUJWT@{Tv7s)%L3^s`99o#gb%q%<DUX9q(Lq^H@^Z%
zk7)wO&cq<$6?bT2hbhBwY0eTj;nKwIkP<e{pK3hKpJ_bJof;ox*gV*)@afzo_!E3-
zSy~P2YC)CJ;CwvdMuYs0kpcEwp2x>5p!uSLU7F<)l^rxI1dcm2@7H*mT%M5Z)A4%`
z{*K~9mXUM`K7e<?__+dubOg&0Dn4O-=hB4=Yg;Af-09OYwgqZZ`bj$lhq?^&F$KFc
z-xE0D(tKax9hx6%Jk3KIPxEt)r+Gx<X%0dEh+;tVOo8JLO|EXFi^tobRpD$~(JOS{
zMs+1W_Q%S_4@4H`JO#Tne<E<grTJ5ZcW82{BRvfE)!x$XG~ZFMOEZ%bIfy4su2HZY
zXll4AhzI*|eY88xehPMJjuklJ(&Rb?dC=5w$b)@6&b!l{X0d`@n!gY@;nKWM;T@Xy
zE4Yc~rvfKjnq1CEmzgrydA*ZqToOe223WTU>e2x94OHwzn)t|!rmbL?=1_qXE=?|6
zkcOs)!-TPenWx=pp08k+=CuMRT$)_NNRKrAEfL%{h`ai+1G-t$(QH<*OY=7ZCtR9b
z#2_!48V=*bPU%kVPV+GZyEMNNIN{PX(0P>jz#J@a!llVIjc)OTJx}9kUZ7x?=H&t>
zT$*xaB;pjLWj1gX__UrOcriXy=756T-F5gF8qG!pyEGpVIN{RdLIr7PYPc)4!0puT
zG#^v2OS41ZgiEti;T@WX6fEZF0w-LWT&74*IlIboc@@H@Y2$;tOS4emgiEtX;T@V>
zmq@RE>^@g%cbdx-?9zNg;Dk$apTavd_ba%G<{9WFlON5q1&%v3n>C(hi^kLBN=AD4
z>}LN)yVLxgf?b;HvK1}O27%)aO$|5Ed{yuXm*yUU;||Tk8XuJ9N8rbKa}=*kp9@&A
z8OBzH{Sl0xDv-v*0#?v?N@2<MJ%tUJz6z#q;sa9}9|~B(XeE>%8k@TNDTH;Ia(y2L
z<C!LM95HaRoyANO*Ax?WX$}xL;nK`ic!ws}Hqx_{BZ!Z+JIzlN?9$}CG-+uT3LJN6
zCN-YsjT%prYaQvlR{*ybpJ~jihtZ(GzMwi49}+@?%Mu_6a;YDPMhRirL>RLaNUv8Z
zkOBQrf%LjiapJW$8x_c_Yre0*<C&I|X{mTGC(~91lG9xAQ%+8s6?hvA#i=~tbQ0*#
z5<m0EsaS#J6jxwC$Q73z_>{sJNRWY`@m?B`JO<oL_>d7a90_zDjfhaj9h$gZ8ouJx
zaq{Z`>DS5^jidPBEGFMAr7X}iwKtlY9fU{yUWFeWnaTk7IdBZhlsA?II}29c1%-x)
zd3uWizXyYva!gN!Wp+M35Ytb!BBmeaqGenaCV=D2w*(h=XuhLhmuAl>X%j9@E(9?(
zG&Ou}5L=Ex`)GHX{S@rd94j!|aF~S(@6hB0LF7%73q+Drnjy!h<r+tGo`PMPR|}kQ
zX>L+@hh~e$)8rCRIzNtIw`m;BTNUimd|%*%OS41a9hxP5RQza`3LJN6zO3;yxhlhO
zXmaH!y|(=xJoe&4Wg@#GkN_ly^$Mi%eSD75_?2-dSsYXj=YZ36d}-B?2_Q4e7=0(X
z9o4Xy;;YPpah8A!8OTxv(x}3RSc-Xtf*qQ*3U(iZ`H8@z?_}62C0#>Cy7lcI9}e0#
z<747!HY?br`4fTBd4%~>g?DKFM&oJzR^w@MeJVZU3NU2BxC_4_h1hI>v3uGsq+|Bq
zakE{TE7o(nHqUXVTz9u{lN)!mb$1H(qjCRPcbByNX53uX-Ld-yG42NI?%r*S7x!~@
zcTU@@#f@2Mj#x>P<yhHSm4@%y*~DE;X%2dKP`EpZyOGkIku#ct+jqEEsJmmZGl;u@
zy1RsXez?D<yHl`ll3Q+$a|!p^a9_=Fu80iw&2XR0aZY+047a^>chj3!xKX9M!@RT&
zDEA%bDmzBFJEXfO+3~?09^KJ;>6)80x;u33u;6Zrz%AUcz|9F7iM+<iW7&Gp8*9+%
zq+DI+N_sjj2=N%StZ8!%JDoOMv*!AAx`SHwWu;N$PeQCd3t(zGgC}+rtgj~KRaF|H
z?>6RrvzlDf@TS}V!~1GvuUR()Z`chGX;%~TG*W<8_mlHZ)Bv*{SHbgQ+H^awrwi@O
zScCgV1B^aGX}p|<JNBx}9%xeo`t>+>Vesm`0I^c;g<H9{w$9+CdI6erOP8thro1C9
zz^|#RP9V8A9*^P$YXOyFinulE%jS6RT6f3bJ~-aR*4?Gco4)FeH)wVzk?8V*&HydR
z;!Tt3h#>yFqew0yS`VE{pma6%5b%OCUW~?D-^7&~J9OoSG+txILoB?)j2q~AeHrfn
z;#FlH-C=T@0B$AwB@A9GHXWOASJyNcyp}B8&T~A$g+1I|f@4Q=cNULR=_5!yyj60A
z!P9g4z%?&nlC2m#7eqjgp7Y8bxru<M0)y*hcn(FML+9Bnb#8*k197N9PTuikmO8C(
z@Yt5VXoCk;f@>XkU{9UE;8AdOF8m%s*ocD-o^nqN&w2%C)p^=l?XBVwgDG)+x`1an
z1udsLiy9iLt~PkO`&b-L!*BzwvGZ&N$jvm|+Xh8p@N5iSaZrX=W+7jALzT{#ieX_n
zhbIfG(`qy?+6gj-cb4dM^O7)~*SxPRC<5L;q0-GmXu;t%-b5t1%nMn9Oym_cDr<R_
zfyyGD*3u;_C(?LsE3nHEF<u)N6g@AVk`m=9tDr>H*(hGC6krS<rBcPI9C^!*E?%BJ
z3JzKE;E^sqMaO$Ng7V~rD!Q0?$3ReQyg8v;k&ZMB<T6j#$XTRK0CZ9AA02``4$E@k
zp^o4v2+!HFjHKXroo`V00-eN@7(DDy#@lFl@FTSFXoehvcs~Gm)S*}(q!^n9KOcw*
z%2yWkR39ju@{sq!>Biq1_=-%mD8L#1;CHQ!PAoojDrMR?z;og-7n5?qL}7sE-sGF{
z-HVTtd%^F&;W^F4*{|Q?dmCTy`)~M6Xs%WGf>Axk>uvagUnvF|9N`6n!~h>;uxPuL
z3u_wW=?Zz7LJA>pPt)lEN*bxKwCZ(D!rhi}b;2v4)A~KIvO$ttFT%o2Zx{lqpuofO
zt!ImDtW_5u1XQZI3pH#g?D|y)gO^x}uBzhEOm%iKxZP>3>fst{)1X`e)=i4JXR%8M
z)k|(v1zXa2y$Ktw`e_YyiF(|mj7#TM^UC03b<zg8aUorA%WD+|wwa<KtGn8mR$M$j
zcj&aa3x?&68F>La;qqI8|CGxNqXz%cIl=4Y>+pZFK)=9$<@!57%Jo!8XQ8<63ZdR0
zDiYjqKvM)N1XL{0D<RH>BrCdGL+E}$%7+UXFBBh_0aA1=fRyX!fWQbb?FHFaPzq3q
z_$Y*|mkP8LkaDdLp$bU0!qtY5jcPwtd`tkO())ct(*(y2pVI~U2cQ{>4st$IpvwUj
z3UnQySpwY-NX7XbK(ht+5o*F5fsUYyF;}3|`viXH0=h_W3p6gnxEWBH;2sE}{{Si%
zTqfH2LO>bDS@=Iua2vpxxEQdqZyqM&q0-AdQ4rIBh{5$I_>Xo5&^j}KejY-%pgfeT
zhul?AYY4p<Lfm4mT;B?z_e1ED5aO)4qRS7V=^=C~a#y)7523~o+89Eq5c*jNwTF<4
zgefku5E>Lhoa9rkWg&EF2$l5;TrUlwYeMLz5V|ddJ`W+5s^VOSGE&f0C?f^k5JJB~
zpGx8W975NiaaFi-H0cU@E`-LT>!5In5PCa=euc(Zxn}hbpi@F<SP0!2LLY`uE?R5l
zcSH!y459Ca&~HGb=w1$?Q_+|!Tx|&58bagI-%zeILZ~u?J`14>(Y!0V(h#Z+p@F9d
zu4N%~dkB@Io1pyqA@pGgO&=7v{v?Ec6GHzCp_yj{bQyyKs4#?TLa083)`!sM5Hf}Y
zemA2!s#uLVJAfVyp}&RD-VmBQG@x4?Le(Ku7eY6MP)7*8IXv)t(ue?>7(%l{=>8CT
zB!qI$4SZ}0q2Gki{pdldbPO6DKr2INX<mR^6+%A?p&97<D8H2<bOxFkg)0Z7^w5G3
zS_}vk2zuy>knaA_^??xjV@S6%r29C;eH}u0)lP?Tb_n5}IUU9rKq@X%LTGX5dKn;8
z5ya&?fK*Ix4WaLabkByk7enaP&~-l`6~;%Q>){ZxE(qe%FN7umQlU)=p{b$kMSv8)
znh@6zLjMCu`MooQejK{q2T1w-Ga!|=_R#g8fRx`)Lg@3*)wnS5dm<oJMuS6WDj?-|
zW(ds<T^9jT;ns%Gy3ln4Am#V^5c+oLdTWULUI_g$gdPr|X8@^KeG=k651}tZS7&Sx
zmwtd$9t;Mg{LTcV;xadcDni#w0I77W4P6@mDK5zn+8w(7Ergy2q{4U&km8a#E(onx
z2=xJ^=uQEo=w^nlb3>>iq`M@fi-)-85c)14m7*U2>M!#A)6n%7A?|rVitgnQ+8fgK
z%nw|9hfrTYDyF9bQZYS0#4QNv7KhN1(6ttj@^N?Q`qL2lc}VxWknZKsb#Dk|jt^qh
zD}?$0Qn5Na#0?Lj{Lpo2h+7sy%R|?VfKHLT+8w(7Ergy2q{8R~bc)aoC<x+`8$v?>
zDY^-O6y2)Ob!`YWgml-0bnk|)ogwsLNO$3cfL{e56~_7yx&}~xiPg;^?iYYm`TjbD
zeiyoa9^$?Xp`)SeIp|iZ*cSs*p;d%XRR~=hLYo1p(2^mvJ#@V<gdPf^Cqrm&2)zkN
zrQ@Rz_n#0Niou5pV?+pz2BhM*I>gn7P&{;fEyVpjgx(HaPeRvUaXvMK1_Dx?F9f7=
zV}1x-AG&@ggnk7`ars>c{UL;Qg>?T2aUX@y;n4Lul%wLpoan7&EyNXuIF5M~T|C4!
zg}8e|+<hVLxe)hKi2EwUVP#758v#g#J37QQg}7@&+#f^S!y)cSi2EwUO+Yjizd}GN
z&eb7qMTq-Wh~u6>{Gla&AjJJK#C3$Y4?<kj4#J250vdiNgt)>Gw>rethqyaJ++88=
z;Skpr;yws*heBK~Mx-ijLjb98xwlT?=7+d@L)?8K?t>6_D8%JrY^C`DQv6njxcU&s
zjcSVS_7Jx##62D2I7g)Dz6x>kF-TOnN<b<MjvFyahFtq5i1k3xjg*-fSn>P%s9`KO
z*JBQCjhq-$Sgh{xRzz)q5E!<(AETg=fwPz+t8s;r#*nj3!ef3TufWqK`iBhvMjATb
ztZ9&mpxHpu<9@em3^D;ULke-5#c?6tqiL7}wy8E)YE)?4uc017vk9b7BFFr8XuAv3
zHaju?KmNB%qp*PpG?NkM<Dw(ibdZeYVw-<O)Q_j>AOU_D27@LS|CyWJf1hh>HcXU7
zcSmiDXx13kf@bq^0gc4LSGlne?vx$mkM`N!h-#lSR7{2gEQGBKQv$H98|G4AF2~nJ
z(+F^XH%tmP>V+;E&R3M_oKs;v0Ss$o7Y%uE!)X`hUjW;5UMgQ%Ft~BDi{@-#_IJY+
z0TV@`chOV=Q`ikt4~*;&gh9|SZi2yGdtJWn28Mg~x-fqRhCA@OFfY;<1fvVn2@LnX
zbzvN&n}<2NF#Um{sB~dQ0CRaa%oJd_zpIPp68b`+cVX55!wpMam`%WNLrE8A8!+4+
z(uLtYBi!K8h4}+8+~LrL`5Q3YW6*`!4@~ew67l<@8wO7~H>|E%8<6N+&0<B@KjrJ>
zZWx}iU50B5f}dp&(};UWgP-zsZZ}_an{XUv#&MV{j>BAa942)f=Euij9ykv3)Nz=7
z$6*d1hq0*A^iQR$?{S!OyJ057HnO_rip27zRaacWYlO8;)+IH(8mHU?d~E}-@(mp7
zmIYva;tF2E+?ZzPRdt~q&$!}VrO?{lhN2Dp{r?<`rFx2=>kG$hMM-zU9R0j_aEa3~
z4&f%0WAMQalw;6XJP58kI>x2@-jib-yKOu<#w~5vNxDn8<s=>1wcjKid+cVDbT_0u
zZKugGF2OdFW6<FqlVk9~29x8_;qH>-oz&Kn<MDc5$uSOkQ^_&d^c^L~ILUUBV{o#U
z<QSaZ)^QBBYZpoA5N;s}Fv!7R|44ueuV(0mI5r4!l5Hd1sKPxX-LPuINQi<wBUrfz
zn)gZ?fy2_qwRo+5ZM?P%Q_IU10{4<D=J4{DWffIdg}9=49XAvNB(P2mEvz^QNbMe&
zf~B*7YC*g<??OguHk5dPlw~WmMvH~<Zdfd#O|6M9TX7t=JAzmFeFL4`@E7n4(m<IC
zeWU))ElJde_L7=)iMq6mkrKg!$E&Xnw_FAMrq?vhS62-6yoyg{jI0}#tABatUzm6P
zxUuJty)ZX-%y~qr{}+xKBNXGtoi{E|pv!yCHrabJj7Mjg#xj8%Grhk|R9h)lw4lmk
zXRxJ&9bYcK^gc7J-}oy8Hof2cjYL3h!Z&J6cUP{xIn%r2*yN7N8`lk4y8x?5v$5%P
zn2H~J6+(CZ=x%gt(BW+O5za--RCMy6{KjB%IPLc^!hQ3XI7qAMhR}_47hp0n?N@lQ
zVf@c;(+~tncOfSG(teo6Fka6#jUOP7`3u7xcTBiw2T$r{8uuJam)||Tx#00)U(@)N
zrbCb_+`K%@J9qt>kls%~*X_sn<(-Eaz^>mdz+K7b1JZxMrT4Mv6vOwQLC4cA@ZMdt
za9;BV6Y^fq`^<Ya`9e;M4^nT*elKyrdu*$JlDDU0IsAF0Z+Hv#czgUsv5rNwKkq%^
zFB;(O@#Z|<F;xg&@)kTtf@sG=vM7DpTd<4v{vA_c_vgHk`HVm3@vJ#}vJx+4&3P^>
z@pRUlU71g0KJS<A_ZJ+<Je2vQzcJS<-R~_pkUW}b@t5rP69<|fpMXFPUvk;fC6Co^
zU4U>^j7La}+mkQEmu?#08n5*$vb{Mkb-a$d;rux->F6Hu%iWG$0qTIyMC{Kj1+d32
zk7gpMBORVZ?j>NoBbf{K`{m<0-uoI%mK^XC`!gTQe5LvE5n&8`!><^UY`gwo-e(Un
zHwzXy@i+5!AMBNS;4D~;g8AQZ;-?hl@7nk;c#|jwk>8q%pJjN@0KN00Nb`H9_et|7
z=8NyV_+H37wcZHIV}N)q-Gk&!@GYbUVV>`A$Zjt^z+n87kb;hXBAU(Z+1^gS^gv<e
z;mo}rQ^q8EPkFE8mmawG)#k@pL@M_f{(|HS-n;YSlW(4x{n<_@G1jllPQD&@{Zl?G
zw#@j@=H1Sgnc4nKr#88}=@kFsXwD<MQ?cFttY|8>?dF-iW^9?+t7Uh5=Os%XOZ}b^
z3F4dWwI|!+`F?#Y`Pubnc~9iMuH5~F)ks2i^9R`#9b5l{=sq4TZhm5R{?gdS13)h7
zxJDsUHJ?fer}6XaUB5Cq_iFcG?%bwRnjahTS#h=*{}jG_yR4&F`I~$7d;ZdBb9*fR
zO9^FO$2r{@9>mQeX+Oo^d#w3`0e+$DUz44G<htShHPO_Vw$zwEq?%0c8rM5<%iL`5
zvS@AlROjf?AZ98(2tDN--MQa}jFx$G_WO;|jz4}S>GF!B$u`KbKWBe@wttP={DA`^
z(4;0D-TA(?Xkl5$w?UaIjv*63m;VGQ`-0=bj)Y<X1Q{TmZC-J<U+i{PQFiU-w@lx7
zqVRN6=j2o!Vq-L~t@9F)c%P*n##&&v^6*|n&YyF$bta}(4DX5jUGbg=2j{ijZ08?J
zoa)bWy^kUMPm}*8kb%Uz&5vhG5y13b^N!^0rmgcS$QT~AMms9<tMYI22Ry{?B}-UO
zEbkRBRR+jQR?<Fh)5g<r{vpgaXE)?%=YGqtaJ=LMP?&qX*7-tTP5S<Rk~V*q>pkhE
z3ITSUi1c~MaR3=#uXPL{FL^2cHy<g?Y54<&xXn9gEy`*60koYzFIzF`c;icON|CQu
z6!Xgad#`DS$KXI2_mZ>e*g75mb6U0`Yjp7Q#<VAMfn+YWCx>XrM=CD|jOthBrx;H~
z#k$``RZ#B4^YV5pP6vAy%-`bVv~*xVUsRBy?`uE&M&7Lq&rdO|%vMG#GsS56Ny!(1
zRWb{6Zj-oq({ue4)9nj+b7zTHHlVh>FyrV^{D-jOKL+W|UpP58-i;`3+94^*Nw&fg
z<`^$#x!ImDIj7|ww6>|%6<|1Fg4fEJ=Cu4A(e@?HWvS8wW%Cww?D<0E8}+-7UmW!d
zv;F9%@s&9(%h1+tD!45t*@rPI?%%xs>*gapbCMRU<*Onq&V;)^FILg<y?{YZ@;%f}
zFlioV<s@Gt3~rU#n+jTUl26g<syw75i~yUC?0>W5r935m+WEDPPr%a`n!(~cSe!E-
z%}F+cPgz;{qK;gUv^&xRC|hN$8osEbH!y!<55s%3`SD!uP{)T9mxWO!F)61l<=o&+
zkNHw)-t_+dtRc1D^bCL2P#CVC66t-?-%e>~Ru>wzUZvyD%za`?FLTq(Y}c<CfHFd%
zbpD4`eLZrLac?hV`)jlp_NURg95K}Gg)Zw>%KG54n4c6;S4nN9*TGZzXGv+~B$aFw
z0ttEdlA{55t+Z|$*P7Gv0Lx9RY{Y-hS|OE5m9Hw@P5H>@fn*@js%^%ln>kxvhtDz=
z^glmWicG>|EzU`D51-_iFL6Sa{TU^aY|CjGfCM7zkZHcuerBEG>P>fispu)k+B7}e
zeWI|JsU%7<VVPIBUXoGwTA2(LQ(ux)>(8)i{W7c8OXYSs6*`;WX6MVF;drVBNaDOA
z1f@8zS}<hswdvijec_KTg&=CZGD}fzev5n<!lw7WM&Coyh2phTB)lovH(TCJcS6bf
ztmcl==0jF<Tj>@{<*bque+s0cD8ruusVH)N(N4Z-D=M6#m@mr3SBj=Q*DD&J1S;<Z
zu5w^YR`b6L<9+Vm)co(Fc+b?#hq)SIytv<&@=m2#9X*l2T5n3v&U)rEs$DCEPHC@N
zrM}vwoG4N4lJSJR?aYVraz90V;%~p4|BJHySpSMe9XX#JJ-XO?tkM@%>X*5|efcjC
zNXWXX%qxS=y<ro^4P}cu_Q91k<xy2@4s|?y1d%xGJ%&DqX#b9btcO$4J$PMJ4}Uww
zwAQ<HtCK=~kcg>h6gEEwsg<fM(Q4j77<ynX+aQVe6GgqOR8lfP($?9?`dOGw0Z(od
z*rDu|ptpT<VPt}t(=rU;1TYcG(gSo|0Ya~p>Z80IDLh$HNGsdjnX%;VoR(6M<ov}X
z^>~0ciw@i(wI}B<FL;t4`OoFFoF;UwE8$tyAR=9bTqQ_mH<6!EQSD&b+oj-H7<oqz
z_AihW$4@Pg1jYO1OWwz`rrjLN&-u%v$+pBkZwJe2)4z}U;y<V5XW-Q?)ty|%sc5yd
zQk_C|qW^;mG#y&lmj-v0p%M#IY6etYWm(7IPgTiD@aUIFe#FP6ro_t2RH-z##Zbau
zeu5m97;7aMGnh?9{cGEctU{xCznS@*SA;g2g;h}jAG_fLB&uDcmPkP2Mb3oHbY!u)
z>uYE}W{vpx9>b7E*>7bRK}%YB*{bOk9UFvQnusliltRRIDp}ED)&kX}nm$qOrR1mr
zO{H<HC|fnHykqFG9D68^QUamio=1+VrcRAgW#&nX!ep|?D>|*#o4pkpg^4=`*E#{X
zCrYBdtj;e`CGy(xUifThZq99OIjxVr`1XtYJ=I>f4gpzbKTrhvejZAV-H499C?J)G
zo;2nP?av$6vEne(%0M%BscfTCk<86}6e_0kY(zcar}|Ek30`tF{G^iC;y-$DN|7X+
zVEYq?u}THEC+mTrT(u|TfVd#k@q|<nRfZ)%c07ni(r=|#Z~Hj>?~-Y6M<KB<dJnRt
zQvDGBLGqlNa$Y81^Eq_(JQ3fNWBW~R&Lf2xsxX@m9o^Y6FsFqVq<9}U??mI11+cdH
znx3e_&%txfBgGl{s>)oP_rlG^*;^j<XE~oe>gFWxfphcQR^nQJyNVd)ORF+bI-iyF
z&vtWKWIVT>RSLb@jY_eo_*46K&VaV5Ex5)_+=YHM>QWg-CZ8RmI(QCJ4M9jUcQ(z+
zj&i&-H)qQPc*E$Ub0Iu#RhfcOk=M%LMJfn<R<bQSn$xldG|l_}xurP!;9sS`>`Qj}
zl8L^`G7-a$eh|{m+aQ=q`TB)JYLz}W(WjV_q1r0lfAb5`(oAs^xte5C(3gw%=8BK;
z;@fBur1V5_DcPy@X7=nn2ublo+jia#A@t`Qfc8sHL$IB%LCN^jhIBpv6Zufq@$o;U
zUUwElFjdwRx=OQ@b-WBWr9zNLIe%%(M?Y%`lHK_d{wdMibggL`Ik!E!`E40*NX_b;
z4OQu<C><&zW^~I55wM&srz3+sDKPIr=4D=6T6^}Q_sqeJxlNPR_%9m&6m6T$LR-{P
zh)Au1n9`5dX=Q#-)PLZ$^03i(VVrmHFTU{ig}>+|8$?<Utuo416)x)d_#>u27v0?I
zT7RD9&l=PGw&_hDQ=5sdgBnsyk9M_$zx^1Y9IK}GN!6tek*-mf8o5DtiJmC2dYPR^
z&;dlAAAOLN9ZeE&wDWCX5&GccWhOmGIwwNLR5RcCH9MJV;^Fx5pMSCIy)vt*x3?G3
zJkl`*QJZ!3;b4@fy#?d#0p4T&c)!%eOaq3Wm`Av|2d5F9nNWiE4&^feBdt9UwTe~d
zqIn%pe24^Y9O7XXrS!lmW6`R{vX0*pH+6!_!KT6rZ|VdLlgs?6g=PM!^Ez&YGh2<R
zg=}<x0#^RQ3C-8-F;ka5cf>1**Rn1m@Hq$2S6{TsD(|QgAGuz!L;Q6IpxlcVb<9$H
zd_?Y$9%6Q$jk46~A(uG^$~%Sx!Q~=OookV0dOl*#8yI1iFIsh0MTenjik*Yo{Ur=~
z9@@_O@{adEkhmWFLG9M|sZ^cD!S4k6w)BmPGJj(>GGV8p>RiY2IClI!ff<SHL^MmE
zWBeCnd(U_ap7!TN(eJAD<~)hH4bF3+;kf|$i;;iI`8^b8^T$Vbb`JDP+q^k@s0<5A
z_va)(V|IbhH8CG7X7wL*WYCiw>iive5V`q>a*{6quJwz1)+S4z%xQU?J{H8t{?`Pr
z+mpoDjw-aaxos0h%|tR<F~7h!%FDgd$Nec$e@+`}OU_?P+`ee&_aBsOfJk0l;V*dH
zpO#(bU*wiobhIl6uk<Cjt?^4^c`x|Wo#gK8he6xtkBy&^*LJY4%I{PxiI9x^F*n7t
z3-fnf`%jJV=fuj&{Gt*5gs5No(jwn2?^qWEm*|Ot_4deQ#L+ni;{B<8522=TJcW2z
zP?iY$;Ej2&AAI>6=XWrl>AlJlSOA$qAv})!^cRgof-#4Q2}*Cy)96E?aQp>tc%={f
z(_$zW7SxpKsWQ`B<fh6jZ^29cf<37c%L0+P%bPMC*5nJ<Ux!dLiu0H3xxNuX=qK9z
zDXyP=yFbl2lkF;`qxA7Ie*p^p>4hC1vZ6!kpFl>Hh=jj{*^e*EP{F*zh)&0~sKK@V
z)Se)^cXQ%i|Dpk$04jaBytrajQCY{5e~5pCw(%C#o|L{6OsoX+F$?EmQt^XqRNy&G
zZ8_@6{CORN;nPcGdrMr@$W+adOD<c|nFHK^$*%#J%{9@gKZ`7DFWnE3KH6S-fCgqh
z&dM*xe8z1kN6d6)<a3I1c~Sn(YyZ`q5`p^{dWko@>-MC^6ngDD-?I)5gtCr}=49m*
z1P&=5v<vlY(38ziWM@8_=rgV0x;L(U1Cx|_ZBpD@0m>jrY$)&U9jpB>zU}Qq4Z)<E
z_q><~4tj_LWFv@f=X${Kc#J+A;k}3nVoY(PRQqziSY+&w1mkZQ;$3$jzdi9m^M;{E
z6Yr(wWtWwCdls!SJNAJyiUz%Ol;=x%FVz0UG;S_)DOAyeJF4Qje0)6j%<5d65nf%>
zn7eXqZdERySu^Sq@!Y!F+%+|8>hP%2nT^K$qA9aWa{-*WA-8Cr1{TejKRtKG+>+8t
zjaV>m#@uPSWfe2#6jdzFomIM+<O^q1%wJG6J6EyL<kjO9uZt>5N-J`wEbcx(_cS|j
z3tWiA&87YQB~c`POL94dtvSEYYuyhh=cfL{*b7_%n02)Ix|k8q@~?~elf4~8rjpFq
zKNZ0ZQ++_>wfQ?}wkKCZuIcBKU!+nbLQtt>6Ob4>@qcOs|0m=4|0nFZG`!bRNjjkS
ziT~2)tUz`5uX9;NCof!>^N4k2+wA7H72XaGc%gl+cwbeW<QCY~WW-HpBT*3Y9YjIo
za~?50R9zHC5AP!9=z~mE$2r>Hv?wOF2Z4QU^LQhtg`4o;WnM>5<&IV;c`q|*38s^4
zA><Qt9yxO5n<M-OnV!5h@4-UEG<Dm92bjD>wm&;#Ky%v&uV?e4PX3<6Az!&WlRU|#
zl%(4)&F<L1ewHLcMfwG-3owzAj^?%j=yoHT{Q0MN$wPo^ldtD|``Lahi#@P1U%lkx
zfN~yriiMKXn*0uI?a9%I5r6H;F(GuH_EC_c-<)rALC6=FDQhLNJ^6+vN;#OOzgJuK
zMYfb;`p+q9Pi_rR+c}q=a+=$dcWG36@^%fSnw*;pPgb+ZJ7S2yy*+bU+r(bvB|F69
z3tq~Bi=Sc%rJO0LlFij#@+(?YH^mp9{&rH$@+Is1js3mtAArQ$F%(!7#gKv>%=Mg>
zICcu<?e_kCuvfutDTRt6ebhZ4`APc8mn_R^`4)B=K{Ox{1xfP0{t`dMIOerA?;PRp
zU<^D#_zyBO{8l>NJmmzxmDG}wyxmip+h=dt>7|$!PaHh)nfxrLr5O3%f}TqO%+Gc1
zM2&c+za%D4AsPO5maD&m8Rtv!`K`=4KgHY~^ra{6Sbk}8yt1e_eO!BCA&a`bP<j|S
zEgP{5j#W0rqW7=M_NSC!;9clVDe(vTtt>SpFy-8WZ1v}F9-uN0xphWCtIC=`V22c!
zqQbno7YNC#_GA;h^VgodRzrS@qT}yiXhptA1*(xCA$J7|`1UwP>Ol$~Mn0e%^oqZO
z!soY2EQQ;k_U1=tdqU)iqbH79BEPei<dPwnqE;zJyqIuV8ttA9UE-<g2?;w_fnJH!
zD);ER=)9x2Rjv3PQ4gIH5UK8s1V-O}iZLF9IV#3=&~ur)a$25dG?WO;$i_MYtedXR
zhi2gArI^Zxoq=uI!Ma98xFqJE>TM@p$&Wt}^|a+fEX?{C#Ao@%j@LR4uITrS@pr@l
z<-M@g$276zL@IlCD*HQw*Twu9{RgKQjm&3qZYzvT@w1xSvh$z3_T`;#*_btiLq$18
zARP^FBcN*ru(dggNm>RYWzb$Mlg91EY6`h{0Atx+oU4o>Bk#QF?)KuLznZdUzTfC3
zcgM4mpT&E$7h{Qp9GFbMsIa2KkIpMQT9GY{85W(6^vFp*i`{$Fz&*IKw6A!G*XZus
z?$U$Q*gqpP44*9fHea1<p8Nu4V2wjZH$RHKc*efST~HqTk|f{P`R4x59xu&lc>#)j
z-=6m5bId{f+LJG7XkYS=fE4-O-P%K<REdQ*y~IzkGW+7wYh@MMC#uMAB?m7>>GwoU
zc~YsAN<+aJ2d#a3{0CWMSxdjbc(Zc}EdF*%Hwr9y7j`!4Ld|L6TQ}&hVm6n_G_Ww`
zB@KWq*<0u)CFQqLd{!B%&01xbH}5`L;kQydb(|{mYUmN<wD5Yi&k8wn(H98^w?aX0
z0s3`gZ)7VnXm8uzC-=Sm=Kg)JF@uu7gVWxQy=@1by-)3Za?ehDy@c$keeXyf#^2xf
z`o2ATcmI9&UpPy>Z#(13$URAUD9%Pl8?$}$f%KAP`2XfF`9CN%N*M;kJ0$iK5a}`%
zX_bye9ZO|mEZUwtfV^P=F%@^f{KjPWPfzxcZeA^VjSo=ex#xm=ky6dnG7)JdL)~IC
z<oMV;j{&I?$8L-^r&R2$fKf^cXm|V?G~ZZ}@}+O#w-Sp{zZA-en9vYbImy#dib3A1
z_`RmZGuamvNpjyx&--pN9DjG;o_%}XNHGO(DB+gW>`SsBLiv3QCAt?S8t<(V>pjRg
zizrINf*JHFCp7POn~#_$@80~@CS-B*PCNO!m)ZrooR(`?^L7ySMf^6SPXdy*>~E?&
z-VW*@Ozwevt3MA~=LjH-?7saN7H9T$v`gF&gpv2zzU@>f2T$K8ie*o)`&dZ@Hx)kf
zU&%>*3v^gmPEB}_KCpNJdOv%dFA8uTGL*ujg}qD(PRH4p>QE(h`DW25Jj?>gH{<{7
z8yZsxW=-Q{+Xkya{5!rewGhh{;P$%we<Q`HNi0;1a=sNugQQZUqjNBmS~bb^QP_9;
zv2k8%0K9pv{qg_JU-G|V)K$i08<z3kGo*|=e95GPDCsxCTBb5ZD<3K8y(;v-@7{Dx
ze<R-ibCr`wN+LV|LB;|r0AQ%$?<|Mh`++!Cc2VcF3`b8gh*7s1|6xSSTu(I~{(q_W
zZ|wg2PE7wGMbZdR1?&;Ax+Isn>}xpqt&}w-J(>T`+ueB=C-PE^ZAC@7AFb#Z`bJnA
zzQrD{<Q@9%sW#BuJjKo1mH!|!O=a|Tz5UjE;DAMp<OOJ-{S-6VPd*J?^Umx-PuV2^
zPq1E!^oXFB5B3!mM;~M*Jo+Gg_^I3Yzm>wOWV_@0f%N1gGZ`HTdtdT?p%zizozuE=
z^IOzN-m~7E14=t5Ur6-SqMeJo<dob&@RCR4Jp)@VVjGj#%KsTd{HCFv$k}Fgb~fhR
zbUm0#onfLddS8r<5A57CTyOiQj6?Pf&0kEqYPk2zvD<R?Vu#MhM^${AKRG(+8Bd}<
z=*_}{B-te%_l1uye6n^hPZQA~ZmzMX*Zr)1-P%aKSjiIh9%MV|iMsQ)vz=4Qq%(&j
zj$(8KrEW@F<WCqkPq#)B%Dpdi{oJ>`623aNsCle?N!qB=E5RMDqI7;#S7@GU2v+si
zRT?~WJdw8@)4DT=N0mwsQep;bLUhAC?~7GKx+@4B4?UmO6%VE_U}71HY3D;gN;j7Z
z+}|PplPd^k`h798<|QdXUh5tFpJEAlJEZV-=Y0ErP#IC0(0yBY7|EZ!X)+cDS;tiR
z3Kk8)q!_F$Viw1~?G&?i5nD(CS}BSyA<TEoam&gUm3MrxC#Wth+}M`i=;VAm3qUGc
zsYvXU5#je^J+Ti8n^C}_pgcRLWh{uWH2}*Lu{?j)2(Oj(ODP^d)<>xpf8)@C9rS@x
z!GBfpa=!gEV&Ly!g~{K+B<6hk$B6aRf<|W}7K@o&KObpJ<fsO&VA_zJmf6&n7<Wp#
zr1~`PkknwwNl&_CyV0vuWjQT%=m-@QJ2}Z(0A*$WcNNv;cc{A<<Rs5wZ)z=~=eyY5
z1yeFkG6O?U*!k-`8UNB_)ybt$HLmhx{MosTv*J>qSUT_gABcCF_diqGr9aj#Z6U)z
zzl`c`Et~b-aHW3H;%}^)j7eIf<5o2@#$h~{Gnz$^knn~RWt^X)8d0)E&sYzqh;@9Z
zl1N{D;A`(kU0u|!rZ?|}yxqDgmSAD5%b|-{JD&;XK)?%)&iz<HMDML*@9xg?kq6|?
zDgZITo62TkT7NhU;2kcups73RkM?%VM-;sW*`v$TJ-hU_eQ!tSJRLyiOaSN(`HlS-
zcI3Yz^4s}0cG0+yGgJ`S=-QX9SbmaWEb2H>lbpoR797xBEDOpM^TWAVBMLfQxkhIn
zSY-+>?}g3>Sa3<vt=l=})7;j-T~wb4g6=u{GR<@S3^k@kN*em-y>PI%YVW4xzZM_X
z+%_cVk?9%vA14mg{y&6$34ByV68C%E^Cm9`WFSEfQ38n^8YT$|LdZc9&TxhV33y>3
zlZ%jqWQH3-0<JNl1Z3BBh3KlNyP&v=3W%VnfQsS;9(bcBqOO9Ay6$eie^vLJjP8El
zm)~#FUDefBb#--hb-(wTCq|St{%rccC~JInO;GRWnXje47dWYAdNXgj4zmeE6~T`)
zPvM#)vDwO@+g<`!0s>Q-*<+BgG$D}NbiC<5sJ54Lo9G<44udMA0UF^;#PhJ_`b=%u
z(s_lzSuOi6etf4t*QEAhYO$O#V?){tR5iBSP!k)*-k4a>+^w+f)wh_{O@~O!zK0E&
z+9|0SyP+ttsn-Tqe$y74#<9q?A#<%$C^4@IR#)1HrpTrhQB4gV#kD3DZL;NVLT$>n
zNO>cK$6HB;oA%RkbtW2a&AbfGv8sT1I@_JmJMeW`^K9_+7t{Y~*$uy}G5qg0v%=hv
zwz_#gH3b(NqYo^#Z@Sjil&zAQX4w<+6th)%D|a<>P0d`Bn$6fx-P)ZFxwg^_N;wY;
zLhXhpM>U-_$%ES*(VRcHDeCaeh4xJ|54*4|l5Pro*vvWF-^Qt`ax$fyU;n<^%S5lg
z9Af&eb;md|OsRG4V}VFH`d@qaro(XY{@6iY-u+9_{iY4%xo96p=XU=?pW`CrH<)vs
zQqz7J6wABT?WibZFV+4CM7nbxch2qh`=AfV>(bBhRrF%*wibtTdQO+K8Y7h(s_vAY
zZ%@IrIn0(T$xZtJfIqUQ&oFWfe+2vS*3+f*f`TgW$ZlKv2FjUA8*;d0jp$qHn7MiD
zcPPDc(x0iq=?po24s38u*bsX|bG-+rCUCP)n=*qog0!R*w2eebC<YfM!Ok_;565Ci
z34zGwX}##O%Szgv!fnb*HjkX99Lr#97rO|wxAD*vDt1M$Cf+=*d1@DsB5*_Tg49GA
zi0W8uS5!fhbnLD}!EJ|MN7HAqFX0V;kHUhAhR(FVA`Oj!i-dH`gQ&V=SV6_gPJ){q
z0=m%!d(PiuMnT1a&h#pkURc$EgTRi|j@>!vRn<c6-JQazaqaAty(0E7EOK!BK@2ri
zpQafMn&z!Hp`{p4V$2vUU$mwYZCT@JF#BN`5{G&3NP~QMeIim-j6{;?nzztU5Zm@s
zgp{q=5W8lBt6)Rg4NX5aU)#620B5=%Bdv*d>9~eWp3E(@Su1F}?>I7Vpq#j<2TU`&
z+?#UgHrSlPw)K?EH8gR{sFisM%>wSci1Xun<F*5RnWLHA!_7Hk)zFgC=}8v42d8aK
z8`v`i<+NPTQ6dldtR`LtXThq8=Nd>3STtN{1F4y=*tz8#fT+R6OnO~8XK_XR&8Fw*
zzC-$`=yeiSddhiRX(u@IZ1lQHaCv<Cxz%UWKlED@(tla?E>2UFqn8<g)s;kVdh?9f
z!YXe;+XJtmcf0?Ex|=r;gJu<1d1th>5SEQ(9P%h9S>x)yW^ZgvXowp>4sUFW#0Hd_
ziiZYZVp86MSu?8U7q-nrX3EBEPV;W2f&DgXM%ySVwkJAycmlh|VB}A2<}Gu|dDX5n
z_ITWqPfxji_?ngHT!#Pq<_R$AW}<MyZ-_mpbn%ARjf&xICwcIQAU$RE%L+*Xz|%%`
z>2MCc*}!NjNS@L5)T`7{mJ$qOZd%YYJ6Pp#{Ijc&<5&LK8X)LV0oVy^P?-|Ibvo9}
zLfO29;Qq(eO4q!B=x}oqEb9N7ZqIIBT$r)SgN{oZ#KNt9{3j*ePP;CaVjST%J$GgX
z+>DAd{eM=Q&G;2@;jab8V0k_0cc0J2lK_{fg`&zXo`D5$M%!D*pjswJxs=d?+s%0>
zY8o#4$KrH0<><|mqZ&VP`|qFD^xXRMtG|Y*tv^Py2xkzxX-bWcJ|LSomcjd>=v!&a
ztn?j}PZKM?_TQm*8=@9J`-xB{H>81t)cgsTq!9xA2^7s^O>B;+cWMXA_jYf9{|$HI
zaQ<1K=0aP4G?^O8Gow8h<o|1xdA8|IEHT*LH7VY1C4RTBW*e0%Lnkm9+UqemECM8x
zg>5h3-n<&}=KX|e${mbbmIYO2mAAO<K}zIN!O?5yFwhA$M3M*UOiz6tGCrLNqi=nK
zR2VpU5O<y)bO*j{9@AHk@8mdj+#kT4BP~{C&mdhLQ&`ZJjhfI!8kjS?wZ_VGoqyiM
zC2Y*uAGKFIj*gIMn{o3N`tRJ(p*eg0dAKj@LuhT#I@^gYr$BxF`MBuyh0sRlar0+g
zOs85>3NmNpj4E8JCmq+Zo7L!UG8Z;%D8+xYv#kn;$+~HUacFE4H>!#KWNY@*ktA+$
zj)x~p^Hc427h!KUt7A8fx>mC9ws}6`-r`7yd1yqhKZI=LV>^hUY5cf$R^vgdV>d}m
zF?KvOE^U2ZrUKO5jP0nib#m1xo&K+vsLWpI!iyU76)-_5Kb)6X1_5Z?Pn<9Ubc9c9
z_luw@D6UFtI;1o0=3-)Te?+fWew}caDxZ%mHgX)7&3Rc^mfW-`t^GK*SeRhVxf64m
zawp>QG2K-6>dbRhhV~y|?W;r2W?n6tCPZn^+%Xb0K3Q~b1!ykLh-zPoCZjMJIxM`K
zBJH8`PyL{y<4W|X=}_C*qY&fwnp_Fk8FLG1@IH7S<tu1T9Ii`|&MTT#m7p8=4DvKS
zA3Li^_c~GIw==%iEaKIji0gR{9X%!y`!l2cU6^WU8_MYvncueU(Nj#*3;0kn+;d<(
ztb5Q5DonGc!&)f(ZY*ZM;FuFmbNVt?b1Jri1v5Gp^T2gMSxwK~?8eP*r6q8M`1fib
zfSz~o$xUI^0^N;|@Z=b}r!)xMTqNYG8dG%`g7@(SjR&uFr0rqO(5oYGntFaWAbS3U
zhP$m%jpZ}ceYmiuvI~S#U~uMP@bf0(F8Qp2js{#uEJwzhadpj;InHlqPQX<=bVOI&
z`+VaUqVdJ?P5;ydUrGfBZJ$JLfkzWJJ*PO2HI|)<jUSI_T9Mp%FsZ31t!YeR<9{xQ
zUN=o`C8@!GKg?o1Feug^0s#gTsj3tMFo`fRd2$`#<X%C3Jp%a3IV|h<agwL~JDi3$
zt{97r`Do15f~xZ!i*qpWMn`?$s*80oOPMxqK}RB;lQ($QpKl&Js&CVnSpVeWVwRy<
zOc7P}BN$Cut7CDjYD|@5^QEaWn#a3xKtlsnRicaUt(r1phR%zQx)rMZ3+#u<xNnbW
z!$1_d&c7(5*Rw8~JeDlyE3v;P-Y)9Zu_(5n;?JE{>hmuWXX22jeK=j7<@HN388S{f
z1B_M;!R<KRlG`|wC#PvlTKh?C5Y)_ih@L8i(rsQeQfX!&1Xv}S*ny#BA3J5`!%==x
zrJ(eQ_BdN<+qRDPs8P_cY#xmnye2alj6Z=%tM=x~deVj;7p_ii=zwu=0{$K5Gj&98
zVx~3ogrLILE|%t;IAt{AkP=Hc85r~xICX+b`r$C&1sH{x^1zs98~1+=L5IG62n&sp
zCEPfBm(?*hm95COWGEXn-<ilMjcmn{fyhe@>-c^h_0ZvDS~eaW9n|udzrdrR_FvS7
zM!sf%&fiMSfG<^<Zc)3SsZJwvs6x?-B#+&IQOd4udd~bFJFJd6(i%!rD2uV}<>zVK
z$Tn2Xm{FChNB2=mVPm7LIS&`Q;^?Y5&G5!g;FKm?qV0MJz#84O^((;)aPKxh!XSsP
zWPoHGjei%$e&^Jlf%18DNxIwL2B8`~8o0eQgzZ_dA(Tv=&vj$5{tG6bI?y3k;D$dD
zxTOLOQBGl)aM((KIZ-#IPZ}J(eg%_Liwg_&=<xchR%A6sx4cV55?b<_Ps>%EX27mP
zNV@{}&3ZN0PaLn8?fQw%GS0;`y_?rI5oMqw>||<BMx~ug_$OGxul>yuK8K3s`2|(f
z(GXn12kC0lk&Zc+1P(O42)4IRLy>CgX*JlXtaBR=4ugJR?PVe#n$cc~wMY|^a{W)^
zixb+nG0xy&SU(AY+LkCuz++9J-QM#Yl6l<oP+aFtg7)r|kJ!7bs89)6sMslyY<u}_
zYQ_Io>}FCW|5NNn1*`vGVn-v@76!>__mLzzhSMLZX>5Xp%+7QYH%+mQUbzEb0}Jqf
zPu2A&J36k?eBARal|^DRN85qU6fLfD#t7OAy^L#Q_mUB~a1DFC4S#odL$H?ecr0QX
zdcK9$qWKEKYR_AMNZ$DQha$BI+exAGWT|pHc9UUT6r73!by3=EyR-<ln$8i4q^7<J
z|7ED1JIF1Z1zQHSf6kDzj0QE($0O9tp%rv_a#LPn)1<WaE^rI|e;vucd`RO*Oj1+x
zAqW_}{m~oL=^al>Jf>xnytsCy=MIj(-8mBDs}b!>k>UIpH#`H|q2R!Vswhk>UJUE|
z29;D>qUwf{$HwbjqoaR!A5H7L!Pt5fCN{ku{wy99L<!M5j+?K4HU7*u%2UrSfxM<I
zq*>eJzJnc5P%(#=J22y&1H>B7yWeVu-3K3Z+K(iBY=5?$1!E6$6cf>CFT<)htDs^-
z=aSi?ilHS_z^V4z#j#!`cj~(mg-|lpxW5f8gSqknNiH*zC>QC)ptystfaozE#5o~t
zB>h-+{(zu;4gP60>mTdLUxr$&$SCVvz}m;cBr2}TsmRg{IQa}SAf$IU!En%1C6N9<
z%c#?4)#Z>hvQ~Jcz|3YYE3UmO)_;cu!*siAoqD*hzityf%-YGDaZDLC5eB20JZUOx
z`;+iuf=nqY8oUdUFz3pqcMF_7nu{37>Pl(owmoms9zYwnv`k?_k{I+pSlsw=OXESm
zQ^)cB#D-pql*&H92v0jb_2#U&>-W-*hAoi)sV$q4CsbQHd+heL$VcyY(C?$b?xX2B
zdceSFuESM07cP89A2253;&k*)<VM9Y2Jidx=#uuzwK)v)-MA~>+Awx)U%W=*OiI~C
zTzs1FQ^BmZSgLkH8^oB-ex3kt@zROLzfWmwOT-m(5J%ti1CY>o{fcI_eepC=V<q!6
z{&a!Ad-HV9jOOB~LX`6gQh;ur&<n1TKNl4>Pyg49S#3`ceQ_^N=nDtb_(@HxPBop}
z(D(Qmb2^$Z23F~;wv9wJ##PW9Iisp<R@)6+R4-sAHlBeitF2Czy}koJr&Xt#C-lWY
z7PMWdu<gSjFJ&8x3aXaRY8%fuy7G-TXV^2UR?KQk1*&<%58T0}U2q2+xPB@tuBOv^
zb>*zKu0X&*pVelml=dGna$sO_F;3io{&pY0ac`lJGQ0%%`jO4oyo3APjfeWCbTqwq
z#*Om_auiGL2aUZEj|{9?I@}0^HBW@6+21qzfO|svPpjX<eQ)R4jQ7EK)?4fTK}@H2
zB>3Nf1LIV4QLn<Peg$pIsm>w~>cs0q@Wz6DU<jIY3BCS~o=bQO&kBPa-i`uL&cT*u
z+^GUw>2J#gNV(M8Jn&q=L_2-z>F8URfKg3>SDIEGITNul7pUtmZG0}ac}#42o-6S8
zn?<JZ56K+pzp6R#7Ou*Dn7JbG-izV_B3ylPV{_n@=2b`9Q&EP#Z-2Zw2g3I;JhP9{
zBN)qVyq6*)+n<+mko==Lcs^s*o#~l32L6F3wD1soQ=aS0%?Mu<X^6J3L_r13lW?p5
z)QqZrg>AR&<wm!k1LN_O#LE-Mt8+5C#`kdEs+oonmy0h&j4=}Y`Bc8bF9bd($1si{
z%@`f>I*W~FH}euZCQ{lL+TG0VrU#a|NH8KJvw^~!6)(U?g-1nZMAA2$TrsA!BQ1cI
z2@oG0<uoflW+c4yZh&1WO@a8dWF#&r*%VObaFnEz@n%4j)HO2FDJhZ*4uVkw4a(7_
zhdC%JKZdI6YB45yAX@K<K|z_g&DM?5DYd(9Bx=ToA(3oTa%`~BNFwT?TZ_g}YcJ5v
z;kNY*Hit=jb#^Q=vP)!CBxUH`)8qy-MW4>X@M%-saV`p9U*&G<YA({bm|+)pmTMUO
zOjGqOu0Q&g1XlIuRuFr+jsae9n>a*Fh+|Z|6~e=Wv>^NO)tydaMLH0qoSS$uDAFVr
z45mv7Lo{XNpeRLosix%SU#4qdAQ3eLhiqtP4f!!7DLHN`)7#l30nth7td_v!&NdR5
za*>%5Q)ph{o*g*{yTW0XkrG4r)JWhA124o^@bJ#MI%~Q-q$Z5Vh)75-z29hLXNNk8
z({(%052|34ZifalI<tiKB~#a+sj_tUHJIJW4JvYUNY~IDyfs7dyBnI68`@9eQXcgb
zU!UO)f_f|wP-}@1L@-YEhN9z%85Eg7)R@W_A?RdUeh7zA(j>1gNe#zjW-0Jfyyobr
zPWkEN%+%0?PP8%a3Vw|gCYZ~_M|tAL=&$ma-lT^5`AJLoHDmJ)->9U8%j)WD%Nvr^
ziwcLP;^RG+BO5+?J&prInC|%%CH02XuQD{`L-Ua0a=<C3c-QO>0kG<3;hRX}J+l&b
zE=9ay)!-d$;(c=k(nP$=Dk1Qcx${y2ZTE#JM0}uAqpaFGU(NXHl5&*rp+<TvUw!?U
z+ESk(KGLXILQO4cSYU{cHL90Y67bjJ1$YZ9{f79&+|ZrM?`!#e3+wQb&)Rxq|5Rfy
zvKI2&=f;=d%Y>zd_)Oz3wrcQR;arrnxMaQ|PMcxe$bMFh`u>^tTvrxn)r~Ey_R|;A
z4Dp5OA3}8{Se;*s5?`8W+<?Ir-h)?Lj}JJi&q#?josf(+lvkpbc3tL3%lU?r_)4QP
zQE{!mq<TyRz2(vnXEZ*?QlE+vUz?9{3&&cOHPr3z&18lrS~cUA`h7M0`73c&XPar2
zgkaB^^!;BEKN|yvx9b_=2XhZ+zS=68@2_0!<Cj&|pwxfp{MT7a@ut7|AU$s$XVOxu
zjxo9Q<%amtT+2gTVJ$7FujRKmi=WJ|nXuZb(>NymS(DaT_<j_P7-Rpbv3_f*!j8cx
z%`2IYQU1jgmr-MvT6KkBIw3jBzjT(B)=~%Gnd#r=_Yqj_;@6l~-4%6s9kh@0{D<?%
z_;seWRG~YwbeMxtkBq+wX*9aie7;hW5JTiM{+3_i@p(gGiYiXoh)Ozha7988LuCBz
zNE%mPZwM(q!Mpin{2iwIW@r@Q5;rr!U8beK@kJ$C8hf{C1yT$VE>?ntGX6eP4biMH
zM5Op5SGfb_5{4`5qAS}4GO)V5-iKFP3y&ba$@s@X>R_3?n<jtCv}&A$>2=7_UC>08
z@lTspiT*5@=pjzyfLO*KL@Bc{6%28KxRe|97N}<N>mLo#Q>1Y3-a(NLu9q(D6zKSy
zW1^2P>tkS?FARzcHS!13niuksNYPi^fmwv%5R9K$xzL9v=nQd@F7|do>ZHhD;-{H(
zv1sMa-XW|~%+4vb^B1585Z3{Mw1JF2A{_Olzfvk+#FA<V+p4auDUaiScxh#jNPpc_
z9-hKfVVzU~Os(=7Unw5#3zDZgg&rj}C|sD6ek06fyJ(PY*JLQVa60Uj1H@gxL{Qu%
z<Ha)oEPS8MUr}4yV8{gV4OSv3P9sw5*0~{{M@^G{PIteK;$(pNKuUJ$nCjXFpCK2E
zuJEXno?VKUrj{CViAZIHZ7nUXuf&@u<x(-1F;O&~12yyMy`6HISk6d~wX|qi&3r>H
z7h4z+Yb_lQEm>5#98@dB6O8O-EhX+6a;2u~i>XwD_jv-fN~7Y?rV8Ku1%<u_U;ScV
zsmgG@ZeM~bmcD3MUt4X+)#3z~JQ(%k%X78$s=_szJki1@<`!4Zr?=-q1^IpTl?@nk
zu<Hg*kqj1}1LLBIon2UC*(k9q{X^159)q7ipwfsboYs}*XjhW?u4VWK(pV%ZqS-+r
zj)f9ki==4Vl^&!e_NfAOF}`3DF;XQ_38-OBFlkpXiDF2i%(m-KK?34RXI^eB(w_!4
zd>t~#y9K>a%tLWA`~|{vm;VGNg5ncpjHFdq2}`V`>Pc7{mQQb>K{aF#jdNKGmll-x
zE9hm**dJ)D?Op_bvh2x)i1;XX52~P-tmT#61MO2+$FD?{y`|Fqke2CK!426*-p53c
zl(G1hAc<IC`8=Z_E4lOMlX{XDX%u8-g3mt_OSNji#qu<hl9U9ht2<lPPliLKi+G61
z*lJZ%oJ?R8iAXinY%Oe*{*qpJCgPI`SF~&)=A68aF=>R+b0uCbVcbZ}6}&9Dc3}-S
zDnVDC2~n)}`RWXLiQL45IS}bUeZ8;7PnyV(1Lc0kkHwID3#Qwy0Gb^|GhGSLHh^7e
z1iBK-LdKC2Ku!Z<yOsk`^u(YLdMz%038oWQR5~SfCB=gLF9p+yIlsy85Pii&G)ly-
zP9o%w2BMou9Q*IGF9o&>FPOwXmCiGUI)uFAIWO_CGY#l6&PI(S&UF@xq*cMBoxvoE
zA?Yy$!giI`2JqN4;5z_!ca-2_{<O1{;qL+)gO>qA;OQL{GAjHGFdmAVw(Cd4yP5Ra
zMKxK%zedq=z9$-(2#QC^ux`@<K;^2hUP`;$yI9`XR4w$C88W;ZH5@vWS7{m1jra^(
z)d;_e$}06-MP*SuQSS4M!nV{+?@*QdJu08!-a~YUJcqehm-|jieO{;9RtbN)6Q9|X
zM?A-vB#PET=UdQMG|=Z@<*S}IIn85LmM+Dct_}H`E+LjMc+s#Sk9$<pdckn@mCmfC
zw>anPwAVFtUyHvaowtl?2rPs(Bj3<TaTY$?S-B7kK<OAfv2MsWJv;>Q2?pM7f;Rg+
z<I%eaio0abZax680Ps{hv_Q8JSnX+<3jdjUTjp6rq!cfZ3qADpLZx<UbY-+g)%$p{
zsr6)WUMx~*R1JM;RMu-8)~P(SN_|CG20Yg?CDy93l@0S9;>8|6qdjgvv37|DgW6}Q
z=TDpt?W5=VGS8!of%1Xo!}@_0&hsUspnRs$=S1X6O#`hnt`>5zO2be#uv7vIq1LYV
zbYY_z%0}7qa<ykLW1wo3F=@y(o~ew2uF3P2<EejngKi)+japsTY6NtQ-m=I>je?SK
zOj$#&)5x*Z?3z+Cq5PG#C~>`~mFt*D>%3B$O`g4snxd6S9D3K4|8*{L0|`fFTGw@u
zX-u&q{+|d;6wPScMWbrFX#QX>VG#97NLeVU>umf(63rmnH3onppz&Y=U`vD8+Z=3H
ziXmwW0^3DX25K)zMnlt;l7PJ@h<)F|s@0h_D62h6043Sdw(Ah)yX|^1m<ui{RaRGy
zQ3j-c#8lq|sc6i&#;$tZjR8XSgvL&FHCUNL<P8!n`85%@jd8T6LVc?c*sezW@5bA#
z&c<}rt*0>o`$3_qrLj}hYR!5-5S<oaO{s4wKA-LA2xzfqJVT%#+yiNz9th5{S}a!w
zIfZP%Km)yi!jR8ujAd2M^wlq%URFlms*um=Y&NzrcF?5dZT@d+c0NXL%NIP$g4Mnl
zthUtG0Gsi!Q}O@3;rfg9wtShjqg7I0zF5!oSAwP0(jHzO3zlZP4uTnw8`NyOsD6wn
z{zs8QlKgFYSC8+2h~;>!E3O0&sP|alTQ&w;@&?1ze=<e|x~j+g+PY<U1-#)JpfDyd
z0hsBoc%`~sJu3VSWa_#S6vFONR#^|#=(^;46bTy$1cqzKj|_N>3ksosTo+UW>`BpB
z*RbcQYVso(u2hxB=ut<Xz;HlU4{SwC3|AV70G5>=^j&AeHC%yFJ!%xF>h~D2b5W!1
z8c1b1tsSHi0auhjzqkggid>+hp4%>Jgm9@1OK@OmKZ0#ZaGN7USVINABpvrFith9h
zei6mKobCaNcQHqxrQHLm!wk{YoK1cWSJ<!f1Zd+LZC;GD?v)hxnDiYMAuLq`Roy)>
z(h%KDlG^Z5kXn&!-UpfpibshQ^E3dm_ptjA!_1#4J8acD-ma$VeZI@8p|4LHB2D`w
zY(0I5ywj8i2dK2}&S&LCp&1RYTciUgiZ|p1cu>PCt*poDqjrgJO64;$Fl~JFh3(3k
zaxA8Xcv~l!RznE(q+>d}dtu<kJ96$&YO!tA=)8K(5btV2UgY5~`b7Ge(&K)TGJdL)
zW8wedRYrXjTzsbSSleMP2NnkKfd$yM;<U#1b#~NW%LQCsoK>Tk_l>4VPzYV#w;DUx
z=pNj6&ol>u3y}^SEAA100D|p&@n`l!&=~k=NbcoLG-(z30*fK;)362S3U+vgxSw4L
z#DS$_7S<VJyZGfY;s~wXKJ@zmLGBn4@8Jf}aw@Jcx9j=|j1{ZJSZpy=^=pFFv#-q%
zH;C7{JeRe6CbwX%rm(H$)B{5_YDAP(Q|rg4On_RaTL~+wp`gBUA<ZqZUL(7?myjIZ
zD3mhj4w{LTrKQ-vh?_J?jM1I^m9xz0Xjmkoy~JAconRvyO=W;VPV+Fi)|uM|Qx|FP
zue~DcwQte38cNE1{$+EkeT#`3H)?!1`EVd)zta*9ZjlwoxSQC41&+DbP&=E<giERP
zSfjiCJiRD3zod3)uvGlPJc3het6_eHZ(#}6i`oU17^*w;WHBuNylPgF;*Tb|bhxFZ
zOBL!)jp}9L8#Lt#_a}`@gs?H|?$U@H3*U%e#J-@dCi#Ly{7j2{esjxe>tRtEVw>*Z
zY$ZOe8l0m%zIU4yJi)KD=9i$cb6M$%dvrsuwo1YDdrh)lMErF|cYMwU5;og>8@-EU
zV65op`VUUx;W0KuoJ&t#HK6_3*&^aiRo4KQs!O=L5gX%O%3tep-%Il^!KK8?c8{Y)
z!U3b)<o_0zxYV@vSpM1tBp8ESe}~PBL9iO|g&ji-)^J}et-RQZA-t`FKbY6%AP7&e
zqkhC?u0=d$6Rk?%43Vg_BwLk*mE{%wNqAS3E^VkzN^{c(4Taa$C6THh>8>U)*`;_7
zPw_+_<upX9&X8k-e?a}4V@BW_SOmpA;tJOs0OTDee$LXQh8w4XhA7q`q<5V9dJ0&s
zaoDvOVy^20Zg!N>T}i{0W*Lf$WT3Celf!$X@H+Z(j3LHI)ifZ;yjIAuvNt!M=5Vbc
z#!0=kQZ$4buPHExF{uqPL8~nfy9*65S<dDXunB4y>np=K0QqO9XcgVd3b3OW+ln$n
zOx4)lRw?@+6n2`%_Q52D;(`~SXs2uJh3FfWAQWwgtIToeP^1ILiK|3pA7US`NmmQM
zUZW}t>V0M7NJ(C!)rQ~=nWI<5wHhszK+e^mOQ}wFp@{1o^~p{bQ6ega&_I(u;3aXM
zAfpn>0DA~Oyb@x*Mqt+y{5X^-75i98_EJjJC!S@nuhBifbP9ZChPc}7gFZxRFiI?P
z&7wYGcmuAUUaA2d%m+^wJK~_EV~HaPD2l96bk;28k{C)B56D?K%u)3|s0Y?iYurP6
z5OMlb38t{_|BECi2rU;SmDo#-qqhB3`gw4paIT;x(+({~n140c1B;!yq*$xAMmc-L
z!@;qq6CmBTM}k97YXiQuV~Ab4O??%EAC+NTSDaF=f0IhNCb-Yjta(gc%c+B{61})Q
zE@{go;uDST(1iIlWf0c6W*NF1>A<m~QJw>WwbweSw3l8!*Xst+(lEcCb?J>7g%uR?
zQ@J$1VceoX31t3vI>C(vywX>VvA9Wh+g7b>(ydb_1#;XhOS!pNTOFtUb*8|RPmvn*
zh=pP%;Gow-)CleMP$O0=Xx~8#f?AL2g5pS9Y_Ui$-kACYCH3$$i+SceDqlfAiA9z>
zPWQata(Z5mDbZkQ(^{Q*_^sfSSI15P>vu_1ag;T`wt5<U><!<ig7jHRrF$&e-I5)T
zlaD1D+0DY5F@J%x3NF>??wEBAaAp`{na0Feb<|odDa$n$rWW}c3w=<%D>SZ$!sXY%
zm@&jkjlIAs2~w`IHgH2>kilJ8?&Iv&>)wro<_;oPYb3NXYBt0g4d?JdA}kpVkF{#Z
zj|EOE7U9^A``)PGDc1Z2c_q}IbsAG(Eg>hqI{I91O<@Hz6P%-kUSV(4*x4F8q1F#c
z{hco0YK`UZP(iM&t=y;UxMkHocGAO&qV~vmoN1NtJXGjrYbS{LJgeSUuFo@DH0>Rx
z#mHKW-6oC0xmL|AoEeMF8i6A%La5c}c8$crmV?x$>K2{yAnLCR(*NFijH}17mv3oZ
zHEn#vA9$Q(JWjnD!0MT5jlRR8HJVSo8c3ov`i~loqpgN1B@KR!zEh*0$0=OVB21<~
zSu_=7{3}4r#1XN9^BRRYjsq|p<!aru)uI(n#^Vr-v9OxT$q?RV#b7eZcpQY0C57WD
zoQsH7YY#UcM`6q9)DFuIf5leZtqaGASOYICf7T5;ZDQS;UtLn~W0#w_S9kVnI)<yP
z_d{2xfw@mN<U4TEF#{gZJp93gwTRUZJ~lDm?14ENslkaN(fUh&QVHYK$}rSYwvMu?
zym|^iVKu<_hTRYqk)*NkBsAb;r?wg=J1|2u)(tEhG$|SpMtiA-adj1t@?jchW7pMy
zlik`SjvrK{>ZEXGzol8qAdi5NNh)Nxbrnl#l=~slMVDL3V)Lk-*9hJ0SgUSg$zp8U
z3^7tu^m1<^!zNu*^rb^koW>hsl%>q5IJFjJXfOfC%Vb5-`#TMhsj;x!rd0B^f-GHb
zqE)ATC?Z><V7h6d(ad=fpJr7$L=I}CRZ?17Pv;hjB{|j-?pP+qsD8d0g;H}b1|`yg
zlf`D&Pc%w3%!=Dx+UQV=@)ix^9Mlkhc13Y%E~C4a&@$6K0A(qtK>SmDfO(<x{V&1o
zm9n$`rH>M^L}S4;#J`2fD~fGZ7Vv8IA5DO@S+B7jLam_A+Klr-ULj+ZscK5aW73yo
zO$nXc*Zmm{ij*`<M0^|!My|l6Ex!cb&he6M=_MN@z-Nhu2$O2;u^}lfMME79N9e+n
zp@m9Hr`J?tn-`^*Q49o$AZgkz8a3RiDCyh}cGcL+tp#uyu{jv6Q6u<TNj}+j9*u&k
zZ_v{Z$K@KC4y1GWBu3*#@nUO;SlN$znyG!~qK8zzbF2qydFE;FoVtyL$q|C?sqK!5
z%1-I6?UX4-_z{{6<z_p^)I)KzyVhtG=D&f9RFEwW$V@y9Vl6ksLAjh;V)QCq2JQK*
zBxjDx?1yE)7vSd<+>guvBfN%2snVQ?yb%;n5E<@Y0H~currR;^YkW)CO_Jr-3%yla
zUCNkjje$?Zw*-Tw7O2r~wQS+CPc;pp!sckK2geojc?fcKZdm%|HMqYsDL`I@JdN$8
zq-cy=Ns%_{#=1$#La2=Joz(m)Gwc#HpW=za<9-GJZy3AjQUK}Nx@!#VpP5kFhKSK6
z+e(^yxRo?VS^kpxa<Wi*y46n5qqI^lx01|W(5Kj4sma{ityC&Bk7Ivd=yt0nD%I21
zeSkrz9$J%dw?QM|r=f=Min73b6)lf+;6(Adb?-pZ33Oa5-q0o$w)e_tep4e{+}F2)
zde>h+*N;i?wxeyWy5b7j)1J^e3{xB90qY$1Ku%h!nacjsg7q%1OxXM?S$xk@HZyt$
z72{ZA?`v$F1zW6cZZ+>ZPFcE}s@EUz5{YwMBb>gHE~?E((4Pp3SBS4%V+KLYw$lKf
zab3aeG2CAe-PbO)5@1o9NgMxfoK1;^eMJq{r~vr!twu&!m3hzxSbP7jG3d+`<$n22
zV`5=pC|mw}R|(gIi)4m4>ndlUuMu8K^)580qe&4IpCS&qn&9QJD%F<ud0mpB_I595
z5G`ce?nMnlk52KG@y^~5hcz<F-Jf>xM_i5~B_9H|-iA1;DPnPB0TeH3u$MKj9{qV)
zgMF<U_?g8k8jOQ+M?T(T8cu-I0!(^UgM(QdUegfPFx)P3pk%9VSSOSQ!*!7%j%(79
z*bqWYUe{ozRgzybrIw0*+cll}l;ggN*mS~0$3r51tQ&p;-15`lL__i?Sq*E*@4>kk
z1>mrj_$YZB;J#=VrEuK5fSx;X$3F**hoYt=R=N}D<hQrWojMOY<35#!JB<`hpE|?M
zzVklI4fo}=x#&}u54W{@1e3wa$Ck=Hl8%`B)bUo@olaZpK78#>Ax6~zaUpq!+!^E?
z>VxYzs4#Q6qQkT@+*zcv`;f1m<;9)728nPq(>*`iMV=2FL!rgCi#*G=>j=kbOB_qR
znqFtbx-X*(g*|HP=F_z#ccOM$^{7i@m#TZHx^HOqMJB`TRmq}9-EhO5qyX6igXT`w
zina&F%$=eD93!L}?qLduLXn1h^qXh``CD;!Q(sr&vmNF*+T)&hBf4O_$en4kk>Q;B
z<l{CW_cBU+W773AtCGB+-v<4N(C0IGKmK=(a`6Q%Lwx7BJB^EM;TCku^Ww^ee3-iR
z^?^Fxn}x9<aWP!9*lLwR25mv7&S(NTe{I((zDYsi(2cJdDz`ov;7B}x0=x00!cKJ8
z91H={P9RMkrqQK0b^LF;&T<aA*4KGHpsr(3kzMJo7V_Fi?`F~^KSjmoro>Dp1%a0d
z=&s*y3FvMR2&N-R)lRqb{%2iWq3%c>i26~7A3-GU-#D)^(ExJZ@L3@Wq=bHxQ8ukB
zOhMI<e^*sQ-t~}bI<F|{2AxE@?IM4^%`P6><&L8`ErK@t0dZrB+!ruhun5-~wwTDy
zHAl1MYnuwD11JnJNn2xd%ybFt2%EjG{b<6F+a}mVGAeA>8la-+u*W%dfjhby?(_Gg
zgmO?u#QQ-Xq2oL~rR#Jl=jjI;g!ZIU6(8;aEAP>VIsrPK)$B(a_P8TSqkgQ-#MsW-
z%gBr75nu8-jiPGPRM-M3A6vUrPB%w+f7Mxi=N9OUQ#CqC9%$ROo|!@2vRxhMJbS3g
z0GNxt`a&FT&0)u>s`N_jZ`OABReU`V2A8`hHT-Jr$wr6OPU;$s2)9aWYp}RotKkUL
zwFEV4N1m$57WM4IQzm|cE*i6!j<Nh&ebexLhMe8=D*X%j4)qN#nnBK%Llu=Me(xd+
zz*<i3$$9LB_=8iRD*q0r>DbU#SC+tN_@l<yYIyI|-svc1Lj6hmuK6scwvG<8X!CfN
z?oq5opGZ)LOItOrhkFyPE8BF_VOvedLe#2R2)pBo2Hx=9&26R41cZ##iXrZCUF0S8
zmw@h)*S6nKfPK*;EvJ!s4YS1?yokALsirq|O|YeE>vFMKGsIgVe53rfiyUdTi}ubo
zuW<dyUZI_wF1jBn4)SU-EI@T1v>9W`-NM)~1(QdG;Yd)??#$-C*)B5KZ5P?w7oZ-)
z9DE#<{V9qsDwU5+MqkK4GAp!w)Hjo$$`L8lXIBq6xax63s>)d$YKp4inK2hQ>qCiQ
zR%bD-r$>ptKx-}>!<bm(0xx9I95M#A^rxuHG;gi~(4)pMn^h4;kIJQnc}tP1&$!?w
z$}uGXqMj5@FsG&<sV~h&bDFY@kp<pD+@3Sc>1r42>QN1wNS`&B1q$g_NHx*T8479l
zzzXWC=Oa+FP@U&Q@H%N0sihGI=VK}=;Vd<0Dnyqab;V;0^9pJQRzW(1ulFtD{k>t%
zQo<42cRV$)SV4Wk@fW~m+eQ4fUDV}%^pASUqZF=2ZN3AKHU?lXz&jW--ZZHg^DZRD
z^Jv7IG#v3H!bl~)B~%(_0>_L?{PiU@4LHD{!=9-n^$Q@#4TgD@FwOUoYhc}2TyiDv
z3Q)wqfpzQ()Q~Ztww{I<$8^&d;Dhtkm3)uaykBtXX3t@iV|u*-3^5>n3W>-4g2vn!
z0CzKZQG-jE)BSh`1V$%5Q(~CUOO^QsWR9ofFY^V~mZ~=|O6twP%JF<5!aU4saA2is
z)e(jg*sViten}E9i~$+}Yr||XRq6Lr(_lOTK`cQ}^uQ`M-lNG*IArQjFk!x7{#j+X
z1nxg91PkdQ2#BC*nwO`d!7OUGn8d3DQ0Rf)zz2<lAoJTWZ)JGU5adVzxRD>;Fa}e6
zGv~$ARQy~FT+Z-aktJl9drWf?GF-|6wU_vL8Be}_H2E&$v3{DE<BUpv!}L1;7~CnX
z#8nTpahV>K_o$sb63ciblxQqtgD9SE@_>@Xq@=7&HFtRs*8NckV?brYRQmq%^fJ97
znmM|TZfOoLa#?N?c_7CK+K3th=D|U(ofpcBV;*psWPX{`ha(^N>LBmA26AVgby05z
zvLDWT&c#IUp&;`RtJnBV6n~x%NeAkChPb~-myS%e6N)#fTQBnFDv{1C%_F=jBvNzC
zqpUv@usNoifDpl#Ty$xY5sr7zeAz{}Bom<P>0+e$ii<8rCPq{KV=fYCnpJ9(gD3cP
zERil<nreHK04JiUHZy}&zIRkUttH=O4L@i!IFQIv^ffDCW3Yk-@b(zh*)Cc`27rZA
zYRe6Cspi}*$Tx5r!Nkaf>e_Mu%M<_|xtwFhCG+|AqZ0Dr5Zb-OaF(6nA$nrClJTJ=
z<H}LXvs3rIMCll`#dw(h;jcHw*UQC}a4{o+OR6g}%o3A47P9~*^D=MFWBs(6GI8;t
z1y521??T!JFzx|__XZ1|#05tKpM+^UiKodlK)T$?T<%&RQb;i-BSL@XG;`Q`z&`>W
zwhR&4>!v0nC9MU}Xh8VmmXNI!+L~h3nvKXwpA@Gz4MvY}x>?Mvxd%9YM9nNVNwg0F
zPKF%JX8yfNkm~guZrwQ`jN#;XhHR>}@m9C_9SW!GM@iB!s!_q^yMQonbyM6dpzD4F
zk%*OpV#Gxt9YH16vD!4uEu6L-X(SwE1q^51L3<~<#bKD)VVIcsGzNYfK=vN>;_p;R
zb{NH9pkk*Zk=9IVeoh$8|IY}09Z(H~Rt^d?FN`<WE~*T*kppOCh^87-?ZZ)vdDNu3
zKEaP(3Yi3HNau-sl;-htphlsVm#C8E1i%h>nfiB#ip>ZqE}zfF4f9jx=XWUYFdFqe
z$o2=z{FKTZj-t{b7N3&hy%s<w?Ox4Ksfv~OWib~&qe|`sIErjh^E9RI#BW40N~MxV
z)lH|h`wOBwhy;g~MOfOPfjy>q98~o2@Q;w%C7ooEmUoXyjYx8XuRL`<ES>WKC(#<?
z;pQ&}NGfwm<pSUI`U%yw^9<9a_2qFCH4xWLOiR$FPc0*Ez2w&5(F5!{VD^LwI<6jA
z$8O#_exkv&8JDo!FeCW%G;tjDJW{D$x?JMKSp`S23QmA3>Y|kTe6oaeyry;xnb>Am
zm9zv@(Sn+mNL~rkgQwF`Hg5+%238xE!%0iz)|6B)!<9wzkT8?MpXa*al{e^cdJgf3
zP7TcG1-Z?R5mT6HFR)EO&lx3QIMj4_k!!9DGmLB=u_L@fH4)6(<*1+)Zn6!S8T}G>
zvl?)+vaHmC^|GLa|7Rj&)9Mw52Z48^JDGWm>ym+2Rwjq?^HoMa2HIpAyVn>z0x)|!
zG4{Bi<+hEIX}n(N@uEi_a%$`6!ksX;uC}3}lGmO^vL2ntC3PerF4s}^FU0T+Xd+Tc
z^zK_$Ne>{Bx(2DNlHLM@Tx9;-ja+vFFuxW>l<SYcg-22<iQWa^+!0D$F5gFL-VEUK
zM&sYGRQwwWx?zJ6sYWFAJJ6;106hXItrn4E6j_1Dd5ZiFk?<%)HX|~GB3ltDq{u^v
ztVCqYQ;5ixk5{H0LgXMYhB20Gi5#@!HvG(cWfTT!*iXQHh2#-VLYfQKz`r@eI3m0b
z!}$;>vu9H4?_;B_TNl7Ax%cyaIDuf6UImW<oXiKDyrtMKX^PHbBwN&u0rCKwe3hLE
z;~<=dsn9n7J>sNpLG}u&{b8={021(gG~J;*gm1#Bioapm`T$9)Vc#;`6Vo%7tjA`I
z?MRwlXT>kn?SsHwgT&O?Ku&lW5aLS_=Vlw`KUkFOL6KYsTiGzrb9t>mjK2e9nN%@z
z<R=!nzazmIO9tqTkmJD+I5S+{0it1F11C`X2qz)!Ct!L4lNJu%k40oWts%byaoWYe
z6a!<V(&<dvr2v-@h;@>BQG;^ZkYGkj?!hfcOEoat)2Ih@y`TQZZ3o%C5X{T6(MVP#
zz1S#!5(Knj^yWc)2hiwRJiux8k@-2;w#zjb(h(<+c`h<5j$h0i{}H6BxBWP44_H&E
zhs1LNIQ}}-!^6LV$+MBHMnS>X0#2^O<0mPGxsoXsIhbJ%riC#$DJKyC-72PgIur|9
zg?*2(&_bXF<@Ma8pE_}%Q@HqUXk}_I@F%%;fnlaI;WQwL38NU=Mi4AO1@-EVhO<$f
z!KsS~=DnDLp9Va-fwoAQl6HMG!Lp~I5;KcM{5;ZgX=iZ|Tp3API7coT4I%IWw;%?Q
zD-pSqBGVCh7!f0vwh0>{KC_8_n%qP5JAi9L>ae>J=^Km4?TE}qB$bx^w5I^w2Po|b
zBF`aW7!zp=co)ifipnXFsUIU$qd%KR|6`D8>7K*P?cIYAEZqu`2ZS2OE16&&;MAX}
zn3>c^AM<2CkP~UcdI4DH!2)ZR;U5+n+Cq~Y@j_!7QR#?>t~R)-VVK`zQAWO>@oPgt
z_khMr$28_ylh&KK3!L@l952$@fN8MQ^W;|pGKP~UoNql<`j@G7=ovR|EI<@v4C4-v
zT$_tRw}aF?;3oBd3OHq$9c1I{!k&QHY<rf?wo!odE9q{I`J6h^YXM(oV-4i<xf&!V
zFUID?P5znvfKmse$H_jvQf$7;Sw0{l@<?J0Vni%%Ig%NMHONf|9$A24x|UVel&VJW
zGfmQp1!(lM7@0*#pPJ|N{%P+0Zs5G+V>0)%P4X7OES}FWd=BvCytO*O7OQA6@@W-3
zsBX%(*q4+2Y(8u9Sy4-rTBQ$hy?uM5eV7!_b4e2brB0+?QNLedgQyX>Y&Ip1@s4*V
z-~`M%Y&5ZBGAE-uG;?0#0=^|;=J|1xc-{-{Gjx~63gaF+T+lb}FwS!v-QEWwm;l;>
zG3XlS4-2FGtASHvWQUPyy$!H3M8d<!dV3nM>Uu;NSr628Tv3ICgvT+GZDP@4C)25v
z*@eOPk%tDdYZwjWFMzU{Kha^tp9?Pp%*^&Mbq2xF=!DrVj0Wl|z|`OFoVt!ub7^Q|
z7=9RVY8^2UJRQKOV?aS%=LO(l;*B#Nn#W5M%=_KuLG=22`hnyqdY*(<ZD;Ws(ii=v
zOaA5qEJj5Hb1NToQ!C2==i}BC+h`9t(n^@I*kc;zUo^^POd@}d0ntB!-$rCh91Arv
z0m!cb3@bvU|3$FQ<{=_lTxmEMGRlD94Ot}e+=Sl1DU(OmPabW?QXd3{t)Ate!{1PP
zxPf*@dCSz*F7sL!kL<_DPVYS12fFR3Hi@0V=3L%1cL3?#gzV;Z>;$;zV!)XMm$=AY
z91l3ZZeAgte=+B|_{JyAN5d@TEp{oAl~Y1{BbqJcjhHsx@kZQYkq9Yo#0HDRMSCM|
zwK}~Kw^<}N${VqfZ~F|a)7MnY7K;iSSf^eqVs5gOA<we3nE~Y!*kX}nB#?(BpY|xf
zw`hzK-=OjPgGF2W#1Ry~gYWk+-87QNKQf%i(srjxqjxQkbo_~nNT8>G%)1mB$&tBL
zk#Q5YsW>jv!@N@7fmVf@Pq&cFySeH?r?8wWcf=m$ju=c{k8qZd1UL`_)&5Fsm2m&e
zjBrz92lYX($sZEKG}@P;ZYd!3Qk|N}sc?Y7TU_KOE>fPEDo+B~FiR1j*)|_jV;iL(
zaM45drS=-uOmK#*P12Al-$pxo4dYqrzv3&m1C{)!V-z)HU-Oza5d45KX_)E(mVsJq
zzU7O;)Z6cP&7$_HSRx&nnBOa`_T`*qNR8+@N%z$gXtVGG-^SHUkSu#@XXWCj0TTRR
zK6Q(oPS^{wa3`{Qc5^&|51@2%m_n(W!8pg}Gd*L9sh?FYruXWoM?cN`!%W)fAIAi`
z6)Qpu1iqsP>TWy9!FE=UP<NN}viU$5-)?AedFh^;`Cu4rso&-q1XpgUuO80~n-7Ii
ze$f(@Upuc1Z_0t12xEtLi-#819jvap^n*rYKf_M;Gc*7uZTT>3%clsUiv;E)Onr)A
zzB-^0rE$pq9<^{6E95Et9rgJrtIvA@k0$pDT~{^#7Dn!J+49b+(X?-UEKFHbr<P~u
zQ#T$Dqj{P>07dXRy_?s7d4QAE6$<kSZp90PfzMRW(<d3377rv1;8S6=J6{Sgo7K&p
zF!K5w0Gz{K3ugDUS~?6gABq^6qiwh0SXGZe)0r=a4b6w9B-_oMfC$-c!zn_xTL~h@
zSn}fy!O}-(`Q}$)1)$H{3EZ%I@NYAbjBi6xw@yPFSe`ALG{l2Q$>wS8w#luLehHe)
zQ#*{|M+jDP*|uqBdIkakAr9x{O9-mVV}&2V1<nK}n^jFDQ#?o%q?TCSL@_RG5NKF6
zb>T9v0?ag%46`d!8~}zUb+k>BI=L3!e#7)|Qp{i=9QD}ECbv=<P~$6HSQ*i~<kH${
zwf;h1Ey<i=_TWs%K#@!O|2zcpI4I2#cJ@@TsLwe3i==<QAa&T^@vmqIBA+4Rx)hNU
zi2R8nFHt%~de}3FyoE^Wbru$(LCAX@7@3xe$Zm>^LF94_Z`yQ3u0iwDu0n+F=cFw_
z<Wq_)L1Y=^F6~A{E`sJx+l0s!6!{AxnOFhS_9OBjMYbWb7Xv;1I}3YPSUYL20fRS)
z87Ws_aOYqG#JSO>!`84Wf{~Cq5{NWEplU#AHz2Yf5&Y#+mbc?z=TMfj)=elckFup!
zI9Vhh&N34bB&?x?4^ZW8l<*}YFCa4Rj!O(<@j%0Pf?CvXJnolV4(f5I6AWV>lG+J<
z8PG$4P8*I$F(M-bl7{1#mIKUU%3+K@?#2P`6yQwY?glQEUVM@k1?VZJ$eoGk8qC{d
z;PIZflOP_pAGi}p9`-OI{h+3X{TY!aiflpT4T>}&a^XlsRv~gFMHV5l50TWHsEU^X
zbpT3x8<DHh5%~y_Cn<6Uk%&=<{EWz4idYj2<1s{1k5JZbfWk8nxd@SI6d8iZ28xVE
zWG6)?BhniNMcTE9EF;T855OL%3%m@{F#Ef^Kn!`@o<(|UFCcl`L>3}6ZW9sFBRv@k
zBbjpLyVa0Qbf_C0>bIC08OC3Sw85AUiKd`>Y!bi}I$ycuBCwT88DQr%0v@&y|N3Mj
zQi8}$6uAPC4=IAz<)J%hR~yxI8=!T7(*A_VdlY#9k>(sko<igpMP5PV8;ZP-$mO|+
ze2K_RihPgAFBJI&ktunIgrR>AB9huG98e6P7YW@Dk-lTlhlxP<Kp)bE0W%&LOgf^>
z0oX(!{jr(2st@!llFZ&VJIS^pm7QdlVz#Ez2b0-c+yKbQviCx0SISbXvb>5k&hj;7
z`Pj+QbsT3I{}T|4r$ce^IZ%a7H%P}K4Y~-1MkOo1bp+FGBeROt&KrQiM%1x@;Rz6>
z@${~ef0LpD*%sDshk#DT{_OWm^a~(kTq~sVEByMR%4B}X+PvGQTU!YbC1YF-lA7_m
z9LdUh+rXLOMndt)%cnMAZLPKGM%f5tz?l?X<}mAQTFyocfPhcHFPkpDnJZa|{(;Ix
z$CpxmDELRYydA)*y~y7fj-CjZ*N?}z$9Diurh9zm<D8z9@AP;#!*2mjrbpuWgv2nP
zVC)r>fK_(&lZ>bbV*GK`{6qm#{8%og!_4jzPD|2lMBIRjtEl8c#=JlncySojH=Hcr
z&lokX23~lDpl9UAxxt}Q{N_@r<jcwD{G>y%9HP3Vlt3HJ5#eO6_$gt;Cr~PN&>oyH
zh!eIUfeRSS1?*?gS5C(yC{-cfr_9E<kHFv+DB(?~&T!5$1}e)KZ$x6#!*!0s;eG_w
zSwacy?45~z#DTz^9x-4BWRbQz0n&7|<#`&BRC3O;9REa_jPV74Pk@xh>l8E63vH6D
zJP02!Vg(Rtm_OuUK1eXV@x}az)5Ay-OY{ld$2Of#t^z8156U+`wXK<k@i)NZm!hhN
zs49L5gJJ&6x&MhIBXuLvXt((#<N81(M{L8w^$mUrn*1wHqBb7{ad{y!=phvmG{{$x
zn6up>8D0lC`%lyc7sHPd%)4BR;d4Y!BkE@GGVpZVb5JV-!TqUJI(Z+4aT*Q2F=9Qm
z>pS>y!XQqlrvxMQ9csO9%+)+r>ye-ua}C2s2*#Bf+Av+qn2U%L^ZW}5GnX-M5C$|P
zx7RUdGc^M=otSpQIKo}RL{o}XHud<0IggPq5E3~xay}zdF%pU+r3~LgFmuGm@P$_(
z6LF-B!6ty?dqqKKQDOX;g!wY396-v5FzDHQ{Foi@GX5O!;No>yLB7TB9?C~k<940_
z?pXja##@+nARuFWGKzn@v-tZsDF;a-?!q#83_mV@2jeR#i!tIfu=Q9Qx#;~|^h#ay
zGfa0E)6s^FY-C)2LO-ME6&h22wL{^l{#b;$5uG4!@e{~47d^O~Hx7?Q(7pwG6WTXC
z9zkA~e^M>jW9;U!A6^XZu|@wx1bKD-N-*zZo{XS<%twI7Wn&T9h2KszL3z-gi{LB6
zvjJnu9pa+K0W!uBoy5ZN3enPoGVn}s@=8ihod{N`9mOXRq=N4RR;?tTM$k%f8gS}$
zAR-?BlQZ_2qiRvmG=lITA(Ws(EF%Pq+b<E+@%sQP&HS$jvh3R_oiBmlc~^d>#QZmx
z+v7?a2ypfS)N53tPGOWFW}3fr?SlU%l!HMEg5R?Wx4(YTDo|>Rhzqga3ZekPA{=n~
zQUT%*Po-3-gn51_MipI*>%%GrzrG+c`LQrt@{{eD&rjM(=kDBDUOu@sqeO;plh>Yj
zcw+M8t9NFUw`P2vkrl|u8k%Jfkkj|dAzoRWIoaMLQ)bJVnKE&bEI1*Py|N%vCZFE7
zY2xU~cGA|Yp_B8=8?KQLN1W|HG%Km`i}J?LAC>o-8#g9Rv178PJn@I8Wk>zmjVX3a
z`CAJDPs^@$*(0*swwCgwtgH%Ib>jQ1IT=~o?Ur+>G;lU4qde*9EIHup#>tcI%6%hd
zJg{J#d|aO0E5pm=60ZzjTb?Y>z~_9&^=n%)8hsT>_RjqB^4njwHyzF2Cl9VHlh4XB
z`TWXEd&EAG+HH$`8t;L&7t4*S_R8<X351yl%Mg|!%*-k;mm3gmm3a7H_CG7%TXn*|
zu~B+AZvMPuSJr0vt~i}+pFC=BvRly|U-`bkk{f*G(?(66EVo~8cb8H2X^|XLo>5-D
zMGWa-$F^jY|Jm-}Sng|?yeWUOY+7X>DfdmzUvg`OeePdXlS>w~_$Idu%_@-Jiyd}S
z!0vDNms?h?m1o3kgx)Kcq|0{Um*Ms{yZs+YzVZx_8EeN3O*)#DQT|uCEK^2^BvYPS
zWlzf5oPDF6^vLHGqp};tZD#D3@-<=4&K^~s^j$?OM$?{*;q<NlJfpnA&K8L=c1(Wx
zP7a5bzvRnmw6p9idE1J!@<}O%n0AZ&WQDlg#OtSIhpSBfd$|{%{6eH-`Hoh(#@aT=
ze%fAAxyTN*Qocv8$8*+u<v%=L*<73Hgj?iaP4MKQ>rqgp9V1^ccdU}1UVm2JZ!&xB
z6Y@WR9$&Rlz9KeGmXCq+$I#oyR{4{Gu}|C6<<9GOd?(*E*S5%;SFg3RZp)IHN94Dt
z?k~d5l(qI+*{w`m8dHAKK5Adp0`C2^$}bOen<SsD$;`@-&0<o^$^7z%eOV`ekQMf9
z`|89`<+fG!+KtJhlC%CgTD}y1dSlYiipn9^tb;VQW@Nu}Pyc?|884@gZp@xIIVr`y
z+fJL)AglMv2>Z0GwEglT{7TNsp9A*kjr-FdNuPRZj9gZ>5Q8z|s2$k%j@_OumuC)3
zxhy*?Bg-Cc_s__hCa<>l$^^e1YriV5-6ngUl@Uke_6Xa%5mJ<qot~W~BQvExGaJXS
z2xLTNOL;pbW!d{OlBUS(GG*Ls{-4>pQ!d*!NG{teBe%(p>(9<kNylVr@yRXA?aYnx
zljUC7YIza*AxuN%1C|(U+HYT*k#x(|^6lko<$kxwF*l~>$>rWT*UIJF<lnlSm9N!j
z+DUWr8|4AF*kYRdr6*G^%&bh8F=euDlJu07$cSy_f0O4If#ElI-6sFB$m`3Q2jRH6
zYZ-tevbpQFYqCcrCEZ%ScvQtbo72nZWIZ|}7vgz|DW6`wO+IgwAuN-d8tgb!xz|oP
z2{t@+w@B(@=St5u*|OT6B+nRSe+KjJEtg9(?=P22GPk1M(W@)vttjHG5r?o${(#$<
zro08QH4T3GLzgndGl4}|UpCo(Tb}PSTQ0NX?9rEvo?qn?-WZv3cHgFb<>m8l8j_Wj
z6$q5uOXaJJY;P;H*+*T_rMHlI2MT-(RqR;3R=#PVF*{d7!rny6PR3*++zVF7^u0#|
zfq>k<+Ap)W$=g?-mM_-ZJJ1ljyS?0ACm&yCA8C}o7;Cc<v&yHGW@p(i+-oPv@Dp-*
z88QY=W;HIi2LxK~7?mv_waR>Rk|x@N?5$g6_igsVPkp83Ri&k+AIf^$E5BK8ACa4_
zGDN%xF|(GJ$;h>0V9c)jUzWR9c}0B8<TaQpr={O3qh`x4Wnxe-B$GG=wl(4{tV7KE
zrtE305JO}4v_fmP%G*`}NBK(SkHYra2^gdy=E)D_GVekeQ6`)4`!S%xZvv1-a6#dq
zhr}RLF0teGNhC!1G4TSe<w>oJ12W*1k#RDBHb>5ufiioljM^yQTZuWm?_8<eF736+
zcK>H(%-&Y{^vbhh2sQgvd0K`~l1~ty+l?Las5~LRSmKx6Z0JH?Ik5~HuYY-Ig^U!F
zO!>34XSd$nI$1_-6A3-+qgivrWzlv)W9vdW5h^BYPZpFwvi)|eJ-~O5$cSl`&#c%n
zT1J-1XP~*BTv2wJ?CM24Q$D_;tP*(p<|L8XbKfK9GRmP(H#cUKfAxjDZm+$vQD%t&
zrd@zxn=W$Ap{=E|BMkHZ$0c_6_vHq(TMf##v5od$cODf(E=X*>OEzQP{e*$~*|lTq
zc6n~a4tZiF^xt8zF>z}VDNT9P3a|VKJ$+{-G4d1htn7ilcaT75v^L5o7oV2@h}kO-
zHI&KyQDq1-5pE+`42o&I`}u@R(RW|#<b8AOhAeyHUu3jB+viJe$jF|!IX&gZ8XvUK
z<rxb`j;@BRjmk<HIaZ8`X>1MHSB{chywYDr`lU8bc8im>Wikd!;n9Zd#zk_iiDqET
zGre-USEiK7*B9Gm$sO{PWp9(U+ps{(FHOJv%sfr`y3LlEJLEAJWb?kIBps_aLKE+m
z-(s}q?vrs~UDD?^7D0K9T_y(fPT#!QZfUir?39uA+D3bdyqYHPQR9S7np56*eJ0+*
zyA8rM*euVI(PgqWGig)eXxSxG)|HiKWkIU#{=RZM4XPpUXM17F=8{}{@@?fL1UJl;
zOD4%kzn#=?pFKxp#oC*S1NP3v8>ZS%7F1-Emj<%r_BuPRRm69bf9Y<o6@z=0*q7M%
z*n#AGFuaTHxOI2MUnV`1<SQ%J%5;%xJ}vjIijyyjwPIw9+*5Y~d^i*hKKx5yf=~8k
zy#suUoo!E+zsJh8cQq8+d#sWk03SA)P$v(Y8@JTRrDbEG#%k=AP3h$ovMUz;ELo1!
z{$3e<<m!<*eRJ$2`}5+Yoj<hf%um{BH-6C~Z(X(asC-@8{?8wm53D{RpICK5B=j7Y
zI;S}4WQ#q=Uc3*sz$B3nV-HQTV=|H+PD);%V)qw`u_7h*q^vkA`_7)eA*FSv9n<#G
z$*oC^J}fVzMpFe3+b7S-XRf!scT11Gx4bxz^spGv!+uG=wZz^i{}twc=3&f8=<9MH
zc((C+`}BfUx#ibE36rtKohhSE)j(5ZE_@XNR=sDdteGwQZ9{*`8(J_-jrQoqWA@Q~
zEw|B1ec@T@-}X|L7<9oc!|a_9fs7<y%hfUl@<Hq0hSm0tt@18&+quu}FR4pAvogS5
zyY6b)eRhyP4M}qS^=oAm**TvZcIHw0WUE|w8uK%>R5^6p(Z*x1qGv~*uCK6R2-xvE
zGm>E4+M8NFx9{F%Pbmc_<nASFLucw6VLQ&X$ZL1Vhp)Hyw%Ysbq^zOY@(siG&c8~w
zEZqxx;*rQBJ9o-gR-Be?!rp5yJeg5`6pfX8uwL00waRTPPoI;2mk@$Q8(ZZst4_<?
zVY$dU8>;q4K>G!zx*a>K!mjA=3;2@ymG6^SMY$WNVIFOSfqhk#TzW+I2H`$ga{?1(
zr#)cFKD+Vg=Zi)!I%cPWaVJ|}I%)TAv(F_x{k%+Hn_Vxb%)TceJ!fAToqpA2qmTAW
z+Lw`qb~R$KrtXxBGVRKv_E4<C<*6`(X0MfTwqK0I*1`kxA778@Fv;l@<#OGGO~hc@
z6X?H(5$1Na*NeO^*7!#2M%VA8xaUyri@Aq$UjVtGym#1?f$jr`c5El@qKHo7+{h&w
zLe3Y)N6t}61O)5ci2AQ~$_c4+dS@|49Mb9UJJ7<(q}qo%a~q||JEYo$?H2##V1ol+
z!EgI8&+91(DG?q!O;5L7;Wzj#{amld_dn_BChN%%`Z0<}bs^oJ5Lx8)r0MeM)+z1k
zf5X$oA@sSClRB$fr}NQG%uQW7^X030=KU(4eAe`O#7eKR((5Vo#?9~=vMVq?g!>TI
zGfF%Ln)BYc3IsPWrqt`XMp5?{KsI;{vB`_uJEk|T7V$}52#F&TbU_C$&)>HH>dqG9
ztVFk&@7-XGe$&@#)Zz2S&GLF?gtR`#YfOopKvfyZIzL^1S@hre#dFm1kgU0I7dhj1
zJk~JI{CE4rdgRga#&YZQhi+S>gwW?Tx^9$3-nc^Q5K*FCBXxWD!bAwIGauH5v?VVx
zUqd9;V<Vk*(XEGT{yT4RNY>oQE4`ktbzOA8`wYAR4)64Mi~Z=wQy9;3i4pp-n>P-F
zC*Q(IA+IR%8npoLlHRy_fYZEjQxtakuc}$-^{nQMVxKo|wbwJ%YhX+kdW~tIUg(W0
z@OqYb<1j_$dE>4E>I!dM0L9KhEn+O-Qm?TJ!A}5ZBm4?7Qt0*6agly+T(Q^F;EkiQ
z_JCrh*K-w@FRB2cXfeebcQt}m5;>2<TXGuFTypyB@D|0$#b!wJF&^V0kzex(;sIxg
z-$fy&7R7A}cXAv{KSI)BM1vsshZ8#ZOA07x<tUtHoqsB|kb+J4nMUy)2zIC_{s;ev
zBEr~aI|w5CGk(HoneE_qA@V5W{4NT2tGG>J651_{fK6dC$Neq}t2Ca%I*q6B7LBKn
z9;^uM7S;0>e&`kjUL>R8RN63(7En;BunQ10t0+kMkFp=b&ol}tP$kWv?8BL`kb(&u
zoxvIKkMewoUnmO*{un>EQLx!nxY<SV&+rQ~T4pkW0MvrRHbS(3iXi&xH!xQNGkY`h
zfch6&FlD1ZryasrltAq%!w-$7F45|RsG?Jp|Mw14Idr2y7|E>^&f?57iV;xNCa(ir
z)JA|U_z|}$+^pg@g=aV(uqmX6OF~D4@@>ZtBSL{nZYgk@N6CDhtFy)TX%w~TeZ)V;
z53)onBL6vALiys*xs9UDu32C>^3X+K2X^v)2i*5up5H~`KUCbNFdb8m<d8ysnQq8*
zp?p8#7sA*?kkOMXA*dXHx%g54DIBBXHifrwJYZ8u3v4KlDBqR%fkzbF%2Bv_)gL{}
zLTKU#eZrVNXKWh5xjG+UEq>BieA>yvHM9W9qlIv@irW-^%<+It;U@|oR14Iy?fB7X
zAvns>VhTROPZ~?ANmKCOHXw*5%&4>7;T;2733!017O!rl$U*!}V-^L^I(UkFsPIlf
z_W-24!l?65_z-^5Xh>+KjE5Y+p(X|SJ$}?P3eTyyP2mt|JsLp@lQ|Aef{-4DA$({V
z{{cOENx?uQgQ1sd$`IaCWfrFvQtAX14J}5c&ge`H>V>W#9>5v&(Sa&Tp@Q;1Mi(oL
z1`icaO$E=KD#%oN9Y5+Vg>S03O<{M88ug087>@g06vk;hh4gSwsH9PO^duB|PC+*$
zLqAfkekw`<WdcEH8@}T_L8U^)C{(b!WSphoN3~Iys^T_<B^(df6wXt47lrg#P3X8#
z8DsH7<rGk|G+Lfs>9mB>ujKSX%3h<Q6wuQnVB0le>S8~lbnkw2SH@DX7DqKGYsX58
ze2X7Q+#bW|i65dAjKz;h<|Cr(-tj-`o<U8}=|_U;Yk|C(8&p66H3)^BTA79>72*dq
zL9L_v4~(Zs4Swh=J&v#&KgQFe1@wUrsNOJifw~cHEcUot9$)Dm&`KaZhQp*zR~Vqq
z=pLL}Nj<n)aqrYhiY&)3q!<Eq4^I862Y*D<g|XO0p(c1GNU#n_>Ki61heYI}KDsHU
zhM<T#NsmZi7EwT5LHpiXNi9$3@hGA|kH@Z%@hIvXkD`$A*u}lkjoB4!%wJIDQT(u8
z?pn!fDnUdRp)eTh&A_O?e<K!-16^l9rg#*7$o;&^P0;Q5Ava-K4&ood)Spn?GQhXs
zXB$}8nTjBKL?@JL4`AJvU};WUoToy-mV?3W>_P)y!w=#>f$r{G!Sq5PN$!ME&!Hwb
z9weBl2_y*IG&|II6n9REVj2Q9C5l6)#8V+dP~15L#UVrRROk>q6|B->8FW_~l|30h
zh&cts4?;VAc1Y3ZS6CGCnYMreqGfz2@fBb_EqD~p#ShbgF1D>yQL2ryh1e%=BZd0P
z!bXEcGz>Un!GKc-apy)>8b$OZ5D`OSNih%$5T&_9(<o#$pgcL8r<n50#g+@olLB4W
z!Ihl_6gvf=+RkA<hkW}u-wY=`qz@y46%<khU*HFRc9t2`zuS@WH%={ZIz*3aQsZbL
zaWYffN&gSX*Ko}R6p#>-nnn5~?q#qbYGMgeiTe~TW6I*?2sW#zQzXeFNg5evR5h`m
z;>S<|afIU3`2XNXai_-=cgmn%&=;T379t~G45Ad!I0$1&f<s9)=n->JOEfC9pAwCT
z#t)@9WGx{31Ae5pD7+WH5Ux}5D9#bIsk#HC-h>pgA5=&2b2Nxk_%7g{2*FeQDg2;W
zPASbo5ETafK$w<y@XyJ87HR*%kGhXQaGk+nJ^+vw2Z)fGrSy~@NGTx3GTxc83^?V!
zfSewzF5pZQg}*B0CN8Crg8z3ZJ3#T7s;5&E6`{Cm)WSspJ++6bPpzbguBLNM=>ud6
zerPlW!#P?=fzJ0%Xufw=QfIp22YL!f2chtHf-2{7<Q&U|6gXWCskf8v9?(31Uzo87
zd^h{F5<soPAl$L?cELEOgk4Dc6u%Hleh<I{jG94#?pG%hB2iS3r%pKmAY1SYDdz@&
z&G@;EVf9b1P6!&$wA|D3NRk_}Og<m%XeU8(YXI{@nFPU3#{-q5rVRzD91Y6NNPsyi
zm4dMxok2k{M}u<yCMNVLp42la2&zn{N1f@xvcCY`InGi*fzHx7;yF?3Nn4B{J#c#^
ze&EOdVeU=9tE#T|;d9SDH@T1i0WPBq(SU*?G72b2AdCtU5+)ghKyDzK;hF(*Z&iXp
zB@Bu~t+lklp*6MI(rRl|R8XtfS_S7S)u>casiIYjitvBmJ*;~|^w<CId!Fz4z6(41
z-D|JC_S*As_SuJ)VNDj&H6Y%o{BvpDqM$_dI-CczFRg<ueQ$^JZtY9!Hww<C)k>q!
zK>S+y=hEV<yJ-EiT4{6{W+wdXQV2c8to{vzSHmDJnP>)Q!MM)Q1`Z2fzz}c6gyUB*
zV0q9?ssL^NQ658LhDqyW7%bD)HV|+c=bL!~Qtst2fWLxuH;m#YxL4B;!eZ25Nya=c
z8M7=LPD0Ea<k^eU-UWk}^wi}9U%_B2;;GA1vH}fsEK-Vr;2ZRx@(=pSipeigt%5;k
z8m3*Ok|DDN42Vodxzceyb-YdG&itf~val^faOMy)jFy=a?)NL9r?O_UldNQ9*9DW$
zd_7&Mj};>UO9_KEwO9?KR+3i%FiVjGhc72!b}Aoc=qJ`eb+;>Z^ONdIW8pl)==hvp
z$LIVRm7Fb;y$$rlblO%2hqO0f&?0CVX|MaGz3!KmY%6>LmPLpBwFL%fi>qa>+vsc<
z)jiu#%3;GPhpo=a;Sc+;iZ7obnX$-Jo4?4q#SP48Rvgf+JYT*8T3Kfxe@DTfoM~|y
z;A<o8AfmexlSeV9D_`jaY{{`6Ckqb4&0FAW){<zkQM5=v2bAL&RhGH5#wnP`h0nE`
zYPH*ikS}OKwD!Va4XbP(JLP(o_G=o4zk}VrrG)R(5ea-BoUC3Ur_xEu3MZRxu8n#c
z<nVQCFw@FYa5gRK*&;c6LD&aFb!fk&ahUcIg{#A~`Qk8nY!nRl9t@(O^&bVL1txv-
z==+uOl|JMxI7v=*D)bHy9iJ$kd|IEvpeC$sAox<#ZM=N$5rCmCw1XOlX+NcKb(r>E
zP4{T?{bc`k0A*yrKzCXz70iDY)<+tK5g-i)b!{LlhWAxF1|Omr^Jr=5$t`Jmk5S&U
zX+5FfJX(7c%w<Gcq~u6DkSL3*Fxm`=Vp@<wFb)O{kxKPZn#`wCqcx;;9*p9)nbgCG
z;4F<2jEXWj&IT<<NzJ9z1cSM=QjD<>GbTnuY{fFzZ&a}POaob=m*oVsjFs@cMlt5n
zqI~2ZGgpVnPlgfUd>}PjMOfw0&eu3hyCFhFs>8ImD_rH#=KI_Jf~Ab5Feq4B+WUq%
zRxNt-G63|Fw2ZerOQ3h9@}5oW=MawJ(8dF3<y=8u#h6duMi|xS6Wpgl<y+QTVa;O*
zt^5s(X_FI!<zltRNr%x#O34GQFAPdi*?GXoWU@Z0p^arcoH>e=OY0UGl-mq){!x=@
zJz~hTwE)R{hFYk+hcwVGfk7sg!m82GMwJF9l|p@+lS07A;Mlp=>ZKf(osSIn!Km&9
z_DdRvX+Mm|gDgGTd>y?-_X7U|Fi?V)_D+^0#lEAw^JqPU(7x(N-!w&<P0IwHWOe#C
zyho|{){LfY{3SC&poL)&H!XT2O%JTK;puO}XZXTPJ!+rykNEtj+3=)|gF%g21*<~A
zTw1@;RLeLBP94#ZhS9(}Q2w35Db=huNSQFG*|bcGW>`T}K$`)RikdX6U(7j$j^!}E
z)hZv>?uKD0(0)?mFzrJMSBGiy^?83uG2DwV$SqnQDVR@7bKYQ;aLBn|dFNRgNiQhU
zY+4^HIFFVIEaMHI4+mfvHSM6rVcORzTpgypRntA%+YFudc0;Gl7xVqy24xS0L2l6E
zZ5OCbw0;i59*{Oe`6?L$6=-i|*8<}?MxcRU3k-O#hxIc{w=y8lCf}I>PZNh!9||50
z!<h-~F)+~V99U!rWQhAUd=i#U&JbAxHiPyK46};%dm4vn2fOK{)Akgu@@VtY0DqQH
z#y2o1ReDEY0IlBi{Y3fZ(Q=e;zLnz}DwASn)Atm`INOT(5@8t$I?wbJ`gc?Qd9=ui
zRyPBi7y8GC_WNL%D%vk;9HzZ@q}HDHK83*pn{RRZQ$-np9;Dq6{&g?(f-uCi|E%zk
zh8`1exf%@VHg1OD+r})CBG|7O+y!B}!=OxPt%QNjcg3$f6BQ1I{NKWEJD5CqAHeEy
zmL^vW!x|OFH>}*<9aC`_WHhbzhy-<r){{sJ1lPuyC@QEN)RHMw4y)?7Na7U;9YQTj
z$x0_QJg>(sPZe}Xz#t-8zt++l6O_*P#~`pV!58MHjyH}Hfcvb&&4v;%iY-Bh)~GQ-
zjh0x)6#(~H$IAdlkH&;!e$>_G#}+7Zz1E4A(P^t+r>zMpN4=P@KK-^Ps3>)$hfmk7
z2`cSoYY*B+@2v>}>dp|pG{6Iz>hd4b;7iZe1QW(IF@!H|hyz5Xj~>2sZk2S}D#HiM
zJP+pJXX}EW_Qp_*2B;Ir*zJiy!yV_ZFv`J_;hT2K!QlKggZ)bw5Dz8BBV3LOi{<KU
zfce(35<=oy(4oXSfUU{_HY*hkw$0hNs1F8Jf)+0#1+@p>T<QY@Dy<O;=5596Qa^?P
zmDX<*%+oqy-H!UY9wx=P!Ar^V8lLNk?YWcGRA+M{C2LTFpOFm-bD-LIN>;B1wk9?q
z5O#tvqro;KB=BI|wj<A}e9mdG*{8g0TSCBtDxg1#Er^08Lz`_LA@;`E*b4_32SKrR
z9E}q!Mw3-+?ifrYV3fnwG3DryjTtzMa`>ZTih@p?;|(#S`ED3wqfHo?57jV*)Pp*;
zM?{@rd_Cq*x?@Cu0k4xn@GuOz0a~UTI9TKB1`gKvx`Bf=Ruwj_UI@ZiXq%wT{-Dh@
zC)Rb-LYqa*gk;d2{-8VkvF>ce&LPg~NNiOkwm&PH5Bd_SDpDKmvi#a*L$C*)rn2{j
zWR#=(pwhrFp|oFzLEb$V&+d!e7#Mo|Aqx+{VU$Oofw=Dk29D+$f{8HXS`2%w!L--I
zD5kdup`pQ$sXvNq2#ktvyzX@rlhv{d6rfTm4mJX7od)7x!l3`B^&|}VZ;ccDS<`nJ
z^}zDI%7Je60bKcgvHn0d?1@|1h;vW;d!;iaR=nc+-UxhoTPqzK+f*^yH-hbr+lCIu
z(fA@$%axDK8q3ZY$<5{ghONR)k1Laz^jw@7WJ+{v+_n}K<iE(gwUx~8D+8bSTm9m1
zjsF+%8(N7s<+{hO@&>=m4XtFd>mS^3?H#|Jc*PuFcI*(@eg<E*)Fym-@9@X5qg5Oy
zWc7BDeL_|r@aw(ZFLV2Ullk)Z%H$rlPtBM8B3~Afr=WaUv(V7Lh^G*3fx&bt**a$1
z8cdCC1tzvl7u>e`l5A@)u`R`!sBF0~7_n&e(Dkl4PQbAVB50ZV*sO+!Yti6Q)0*SF
z<%FHIa<KWE;h{P18y=eDzTp9avt@W_mc*u_H|hWbLFp+33-q9KL=8IESO-75bGvpl
z*ASS_>PVa&)g!u7IuidJfUmSd+L8D&=x7u^q7>e%wLcPP-^GTb*nHX_@oRs?ul<o0
z3L7086C4<gj*SWGXw+&<_|$4l_|$4l_|$4lFdvOtjR~JxjR~JxjR{|-ViG!Ddf4Q&
zk@;xU+U!?rvtO;vezi9H)!OV=YqMXi&3?5u`_<a)S8KCht<4Er$*fv>(6ZU3T{ge8
z%VwB%*&Nd@n`PQ%^Gv&JrfHYWHSMz5rd>AQwCh9-ISgC<h^=<SRySg+8L`!i*lI;=
zbt1MJ5nFwTtv1B=Hxh+70|rg<Ggv({6&!d9hGQ5|x5Bzf!#(}6poIaIV>HKQKx(ua
z2G9y+5&Z6CJviTuL6ze^D*kivWD4~#PZ8`Ok|`Y0kWAr_hGeQ*j`+z`VF5Bex#sXI
zzzd4}JvZG;VFJ#gyI|!)Kj_qyATZUq)?bZlr5gLCuw0mU1g%ZjT<|k6Nv3nC^;h>M
zRo!FAC_gvd%shzO5hpOcN0Yxj)T;LI<q1LQHa$vhf>R;WAJ+QYNRzY?f2{s&;{1$7
zK%4pELBBwQ%^@s{efhKB-$U+iQJTJd*&nz0qGkDVWWRKm5X^#R`Wd?~ADU}yK7hwo
zapcc_)rT_GTC6Yq`{S(g%meM^%Z>fgze3s%Rh93lt9x3c&L-&pt-5OJ-*$if+b;DF
ziQn$;Mz{Ox)pmb3y4_!Gw)?x$?f!0byT6KTmnx#-@z;%CqTOOmbPp_Epan?ld>F7E
zit{QiY7V;X#sGh6#w0-7i2>Rc4rm)Vpe<fN+tdMV{{?6pI-o5)K&vAcd3p_Z!(uKa
zM`yD(-LQBGY_4L6?HY#IhWjh(`M6A7Tigbsi(t4?a05;Q@f|R#&JnPBC<no7Fsuf&
zztkR0iF43FvZDl7Q=&hz%k+3n2`+a`={EUGw<$3r*^@LS*hc;U<F8;UN}EGUa*HbO
ztK?1o^4u@;hAOB>l`*ZNWz^W^Z^XOQWX5!8yW+m4y30R**%h}@LzXY%T@n|wlo<y-
zYZJa4tW7WnPtzGyn;<aRS(`{j-VB97k4%gAi~-&ROIN%_%)Bf6DWQ#V-tM*v1}v<2
z&uDn+srW<#45*jE`c^|)kDg`%o{9=-(%$G#d!tJGY~(ru+xn^Wx0w#QO}C;m<uhU6
zXp9rE%LS9IrHaWhKc-G6X`U|~I}%i0t2xi7=8l9<%^m)lvO_g}t)}#c=*)b|>_{Y)
znP=laA0@((ou}ex&w}xd(Z1o(h9Id1hC_v>9Uf2j<tpToT3FX8xM%~cpJ=M>dHsQY
zSYW?w3QU|RWl?J>{j#l;S2FSB8pa<3-A7;o&XS|BTvf{#(dwe$5?dtxK#uvf7T7PF
zLBmGM7`@w+44Tx%-vfLEcJ=@$iyxWx59n{nHbNUJDe>_54^3#)nH>p+Uk8J_M9Xv~
zJEU9i2ed-(K|NZns{4FP;w6aep;MgMH+l1K@_6GRduyJdPAJNWoa}GTHe9~S5dw*1
zy!(L%RTa)DmIs8jieLpDM=}OL<rJqfoU+CN(m!^OOd^DGA~_GnC!Y;smu}dL8*W7+
zO#58iU<VRp%i;#x4wb{#?JRDv(X?z?5cI!mSvG?Ii{|80`AFQS@(HU(D-kLmiThMe
zuI7A#wkLdoP8j@sg0}mociUy5V+CPAv|<2l1_D|UfL0Sgf7Y2Y*sK!7tb^Lk2?A3f
zoBbW;W;G=I6*DjtC9S<MDufje$7UH4tbSZ>SOtl#hQwAyVk?B${_ZkG%6j@Ebm-Tq
zPJMNtf#5+HlpHN~_E0J*Zb$>gja8jB*lqtvIac-vRKVph2uI5dG*87(jMEGxPsxBt
zA(T#`*b@Fe*`1OC4@>6SL>PhFzE>c!aGQ)Resyhjg5i+ph=t{mc#5yU4*3i0ki^h(
z*gn*%j39Jt;vQu7<1k1QEmH-y`Uj(}{t4z*f4xjTX7MR{bNm;k01<)X*Yjq-o;Qo0
zip^F8IBphAsS(qO6mLx^Nh?&D&;J>$-@#}Pj-pdxkOo`N0Bw;|wbx)!<h%{ITuI1H
zhRJ1^3Kcw;)-@X1;4VtFkFGJaOpQ4#I#RqL-di&Y!n0Kbd9;?nAVK%m5SSWpZ;g#w
zJ*uGICe!b&StHTs*}A5JTU~r{HN|H`=6o1zOVcuOHN|~#HN|aQtW>_Jnp8K%N(}i;
z-<OudemRHZqoEnYb7J9>bJ#B@nJ2t+HiUeE@EwT;GtKpnXPovvpeJFp%-VT}baNEY
z4C4<&_q#9wXYu>6j%!Hi4DRQ&+0|M~zwAQ@_PGkWsCCeO*)}LAahJgO#nN2`gZT&V
z*S=E0MYXW5*Hq5eIIZ>v`eA|nvMI3QL@A3}OG&E53w60ui>GaO#Z!h1l#N&+FfTZ-
z6~Zalr{wBO2<*VQ@DhUEFcpH;*~W%q+?KFgzRF=^Q4Sk}a#-ogVI?ca_egE@OKnW}
zq&6meQX3OKsg3IKF;{(%n%tPQx^f_~suEk7#8xD+l}K#WB(^^*50NzawQTZh+2q%<
z$**OTU&|(`*Jq;qM#7-q!k#-3OA`aMRT<D~3`m6s!vNCChr!!3${u=#l`;xwG7S1R
zTK6fKPpgX_s*l78SO;{pHtE{M#M2<S%?Cthvtb-moCSk(a31Y7FyN%MUc-wJ(WNTR
zJX(wfd6s-mwG>3H(|n&!$-W{7Vz$8WtqIzEh6e#V{Q0~iK`EEPq#*gLol_c!wNzRA
zSoPBR?sB+aA3T`H%at}Ej7BG9NJ9nik6_SqPC%9}RN0CbqhPOs0eK^=n>B2NwGW0p
zDD4k5`6F0gXc#xTkmL8jJ7FLrfSh2)1JW7}LynoSnMue+TM*!|YT88bBtA2lY64&G
zkAvxE9LS}u3C7Y!iJMQ$6nS!BegOhLRYEGmw3)q_KfPeO2|%W^EyPhd+NK0|NOh)%
zts1Iitg?q8FQnw<Qr>GYNR{=S4!O))1UZyo-bR%p)~|uNd!2QxMU+gDVq^9_q#R(g
zNeen~SgHO3qjX(h^OFT8<NibNeF28&dTHxIj5#j@H!FH9oi+=U!&<U5r1qbK9GwP3
z5%zauPu#o;gBgbJ!Qu7<_oAMKL1EH519<}$T4sA!@6(y5S$b=ZgFKjgbDtmBr2~_%
z1d_`EDr26U?W~~&Ca#?|e}vj5uAMb@a}9aCv&OEHmBVhZDTgnL<U@W&(Fns@K>Lp{
zm|6Y_*25Yy-d9!1XY-*LJ1sKX414$_oHT<$#!$O0Fun>;UvqYAXAS+SxYEWS{$+4c
zChd2Wtl96vdS62ZtB3K&`g>&UGcYK+4B7`(R?p)pCSGQadVk+|9Ik``w8x78ZLGN4
z#i@p2w{$ZC{2GQ>*<(~Fo=$16U>>b=VaTy08!v&w5L;>cM1x!^!ZT?|;|_JGiubFd
z+0bIqC^~g}N$HkL%Y`^ar=nFb;HSl-P?{g$W$Un!@)VqjsWH(NQI6K>=}vp6R-sX;
zVB&2|FiAYz1)+^{eoHx+s)SafQI2D2wq)GN;rLT%{T+;bv+}q}g?01X*26H?ZFOci
z2hp%3V7VIFQ(nIExd++xSDkZ?`Hex6=D;9x=E7p>0j`GiV-0VCb-#v8C<_b>V@;X?
zmmoS89bh>urWepLzf(*Y9GQH|()<U(4kUOYjEBLXCoLWY1EjT7Lmn)<7zR{(G>nzj
zo(uyyc`i(<;`um}r#^V&tnNkIoX>0WpU=ZHA0`92hcanO_|D;BpEz62-ZdqdCT^1}
zHtv(NN+|~`lQ}cklwf5tCz6u0mzjus4-Do9JRQdi&;i%OqDp`~CdbokfV`Lf0S&3y
zOc+qFfOX$k1y34>rTTdaT5Z8#)dRH3F_=*e&?*LK%izipXwxw0RcKKkBxrMj2kA<*
z3g@1K*%J&(lh&i>DwZ$e`vAUzK~P$}wOs|Jawapsh+CcD^F=(VRW7yK3In0EOx}GF
zw<;=rt7I<njo<r0PtLs488)98_7|n%eCATV%BA_tC8`2ms|a8+m*!iIKuzj1KbcGO
ztqNeU3d}>~tUYNM%hI_$*mKC>h9B_EY~jhGd}tIqv?&d=pN2tArN!<Pkjhe1a#)eg
z@II(Gb7}EHEMK?Js<BHYJeSsM3g*-LyQb1wuY%`OdMc#*ikx}&ie{vx!_24ki3&5{
zYUIm+ZqVRlrA00+t-4eq#&s(U=hw7#BJ&w9Q|62NJ;d@k4ElFv^ZO0R1DozI;q@OF
z)CyXe$~VvY^2jY?#!_RkZL!3*aEaY)-Cl_k#Hd`vwy241SrgmBCbsc(LDYS;7PMG|
zJ{>!tH#!4`Nw7bD5`u@KQEQtL{GP(UVNhbUPC|`Ubl<^P-Tjz@vB^HdCuV02#h9==
zYkXn#c}5d9In`j;Dj0T&wAaC4s&N&pYc!<5PhtEc{UKy&`Vi8FHt@6QqhL_%FT#3X
zk%u&V0Q(a~p4S6{vXroSZnn+mp;Bup>`NGw9xZBwgddGFXBfG1FiA{}a#$${VYBi9
zgxs%%&@w`HBz!`4Bz!`4_`B%jCdi+R7*0+p=NlNj<#1&K0fl0V9~*&fj-AqAB_}CX
ze3C*%+rcOi1U+Dq-j4aPgJ*1rHG_6rm2dg9n9E3}i*O9<YZJaeo-fJU{7K&CPx3Z@
zlD8#H+|HMX!9~i@3d6L!Ykax&rv|;qgBn76APnmD>97WC$eiF8K|r-x;IAxc=y1Eh
zAQ`kcR)BLadKlf|=GvHMU?eF}gGw$fGpOL4esY*d&UVQBM;OLL`xzL-K;8_9CYd%r
z48mGUdn1gm%G4l)9>a2dW7swo-3Jf@R$5dNwJw=qw;>$UghcR5MdvG+ORG}B{1phn
z<blB^Z6CtCr!};so5Arb#U&Zggy=X<BIY?5rY})LbuKM4Fg7L{v!M|TSZI9$1Lcz0
zavjDo<^jtBeP{+|CxEuA1GK#xpzYiMZQllHyEZ__{3w)TI5U;@5*U>w6###;4gxdE
zZ%YtR4+gmqiX4C;rhO0weGDy=u5B`VA`ewG3EP$+(7o|cc|U;#YBeUdDz_*mDqU(c
zpnVw(Vx`3|lz{heoZxor@T<(c`vivS(9S>^s1O7<T8GWn6O=w2Pb!^!se(*NrS+>5
zmrpce2{`v7lg;(^$WJ|i%HvmCYGE)o&{_|J_kzMUevoa9fXQObV|;qLl;@XfN@;(b
z$uvc<KW?QVo%{V0u>CRtQ$98g%HhlT<avl>6$ziy!0cswoTq$<=$M;92OhnVi)AV&
z!>2XekSy|MU+zuu75Nlj?oDYpjFj;UH_)OvZqs%Liu_R+WCAVLKlmT<C-aCunMeG|
zJmOF0k+?6JNBq;v<O4>2@cua!+iY4Uw#^A&rf!yc4Lvsd7Xq98FAr@__+s1aUkD_R
zTQau(s1d9ov`rZvh@V((O?e)WgxcC^mLLcG={(?1=K+5@55#S*zJZwk0fR1wmPzMP
zf36;t$dJyX{#-rkkL{>Gwxj;oj!JBIph`5tAU0Y|4F)|Hw~OKim6j>_WVaUt>p3b^
z9;@U57*qnXRjE*Uwt<0a)71|?XDMIlfbFY39RBUQKK_j;wnH|)Fg8So^~00+Q>?Hk
zisX72$Y=RafdORC$1uKF9|hC1icw;<uN^T~``(d1R(@2e9qMxHSb5X!4KRF3koHX)
zhiNaHM0$0Yc2waik2XK2<bO%<SKxgM1}`u<DR_mB_zdu&|ED!i1-)TTGHCL(<lljH
z2Ml%#*ESG54uc}1^=Ae1Xnh02i8AdDIqE5hehZwAPFntA+Gi>}q=EKu7)&YiU{M9%
zqQY`Q;at8)Wx4g6QZ|5g+2XkuQ8QusH9?P1=fe#%EXx8YvjnCM7Hh-%t?7l0Y&w_2
zgcS+z5jW7a0tQubE3BVuXhqC~lVUKH>Q0;7xJNGF3pSs@ZiDe9=y5ooP^4U1L6zKm
zD|95B7s8}t;gAv@)CXJfc+HH(QQnGLh_bDOX~}CPO)!$UKWD?Ev>1rSz)JziVMFo5
ziSNK*?4;FJan7ct1I@l1keLYv8zvLZu`uj<CcwTxdFNVA|0wro$lRmE=hC7~)|Dh{
za)EU}{Qsm`Y4J;~Xjs(mZ5Z@CJJ(Xf_m!g}(m)+Mz@P{sGOFGL-`~M-tB|&daGEc|
zX*L;m!vEJW$QfFOb%u{sY7f?z5XoQBT#Rc|Q4ad!S-uZ0XUu6y<wwr=YYO?pvfxcv
zrxScMURqpMb@m8nRFY7wDMdmVZg{r(C`H93QD@tUgvWe@;_{`X(W+JDg_X|!R2$py
zrKQzX(HiFyA7yn>rSr`R?kC$OL#!?+sg62t`zZWua}*zs45s<G@Evz&mXA<eh7XuQ
z^P+O+ob;A_OIK7^;LGn$)JHEZFRVtAE^AHN)gc*L3q|~uRTTxuC+8egXOpRji!rJX
z2rrL2@m4;`U`wkj3sy#*Mc=P(2OoJglQqSs6bV-U1BhZ8zMke3bktyS3BK0(6dX%e
zRXK;PZ;9V`L?^szh63juB-OBI&>lX_Sw(y3*-jPxVe|9a)uWwTVNI;Aj8DTys!Q-;
z<hxFAABTIw%9YcZ&0QmSb+){uBtLqY^AnA$OUs-|U2vt)a_4ne`72gMOADMmUGbE&
zCRX7b>!!hs;>s%LqV5>pE{Mj}x2UI7m#vr-EppO&Vo)wr{__Z##aMx$<wxTx(tiWb
z)MYoP7v2gesHluODVc~XS`uAR<=k^JV8se0;Rvw)py)rc44P5C;!@{Ry2>w&mN{el
z0aX;QTp6vvcS7Oyt)CE$Igj-h2Io$kW>KwBDUx%Vam|RXj+Qv}IAAf6-?MY>0-A@<
z**Omyz_dAg;NXY5ufc;h`r>nseBff>ES+Z`B=c+tJWWNLURGSCqFnB4(UW^1_e`d_
z$Ow}sze<+FslMXj{6gnM|3Q$8Qkz*2bBb&U6!|i^P_q3y$)>9j$dvlh75I965Kkwp
zyNIdl&{+u1E4H-PfQ!Y>vRI1m|CKsz5uv3x@4;Iawf5|pEP8&;dtz}FzrOCA32X{f
z^F8b<;a=F}m|ixcyd2lVwJeX{wJ5AE$qKSuYR&V$vQ16m{3?|DG=Du{#o+$0D*T+1
z0(>sf;pgC)l$quW@t44@{O3d~N}cK!uDvIO%{d_~iq(Nurr-DIRKEu%TZES-0{Y7Q
zYS`;xVlWjj7sD)v840rp#{T}d{J{`rEHJ!+F9yR4VtKi%{rxxp?cn__46l7X0`n-$
zE|}lLJP2cd_Rdy&_b4yCOv%u<MDq?*`}@D;+kugU7e7)4uPfsfZj@<%yqfc77+#(E
zJj^d(ehFiL|IPnDC&=gZn|}G>Fg7@0Z2VR(FTA`5hId)+gR#E=bWMfn3ey9I7gt7L
z?5_;C5~do47ggHd57Bp_teEB%NIS3PV;(SX?T`Mi!+Zu4YOim*dmq^TcqiR97#oh4
z%klQNJ7NC{<`*!x!`R>dmY=dIV+dsC!%!yg&7(}lVSm)0cP(B8!)yQSuPbm*nBFkF
zgw6i^^wWHF-U7yZvog^m4T0GU%*(UvZxiqhFgwsY@-nBRz`Tm-C$MjWu|M7!^i!DI
zV15N-e`)C5+QDpxc@-uCQvhRs|IL3Sy1?-;<uGv=zRtfK#{Ql~zkUFwN49=FhU->t
zsCZ-aA$LBo=UWW+Me*ry&xJV;W(rI{n9(q)Fdbmnv82G9f!>u*@*}Xj!31DDm`@Pb
zXE65n7V!TR|7nPu@!K;B_Ta*2ki~a_{|WnJm}Z!FVaCGnti@oMvtjJ-t3Jqkm;#eN
zrgNz;oi-kxcH>zH#>Z10JmJDK1NQxo_&|MzkgqPSf$0vz16h1?u`6sI5Zw&J<Ci?E
z$yXiuX7n+{9RRk!|G(*DU+-f+@Qexb;Y%2%m#-}FtRmBEe|#5&Z+KY#|3-f$6PxKL
zC+n5v{~>w;yw}6n^DeeL>>Eh-eM06pPvP49=KBVBBfsy2&H0%9y#~zp4fyKBPhqNI
z_*TUdm>3MhEr!h(Hoh<1iTv5%CBOaEBHT4FC+chUvj^NaVV-a!4ByPS8isn`jKTlc
z2)hGjGYr#hf7bthE7u>MM~-d&S$%lem-X`|Ok;T3_)+M>1N8RC^RPUYYmeOiH#!f&
z@@Q+msVkQMhv=!j^?63y@31YhZQ7Gn_WY$i;mEqjx@ZqSvaPZ0*;@x}eElJp=hm#;
zACmX~lz#x`$vj_qqI{k;V_z{8_PH?j_W&?YjafY`ok#q5WNaMF3>f>n0)18;j6EG?
z4@}(%8qZMK-~TP2JyFFzjCH{Neu&P4Ks<J2kI^idppOnM$<}9Fc-qJXwx@sifSO|k
z4-fI2ko|pN_^cdD?`!z1JS)fg^Px8nz}O9XyTNQ94kWUX_t43u4P!U|?E`Y2iJ?w>
zw#S1L_Q$8%q}zx6mL50H@9o2TOXu;N^B{u<a`IuOz~sW%AD^k-2Ezxve0XSoKSbwq
zUi!J&T5tQn(LRl};rUea7!03i_Jy&(4A6$bw9D4vUD#omACfa-1o~~HpS#{nv;AFx
zvLfxj<*&_G`%u7!{}#K#=bo1gZ|Qur#s_KS=gzVHaXXZ|fOZ?!(z%_*eJQ&qW$DG!
z3u|(!E1a?kB_-u6oS0hPBrYr{jXFgo1uH9CEQ(@aRx8z*T7Spv;wY9^yb?PUu~`)=
zcyVFPh0!&3d29Ajin*oGVl5s6liD`08!mb;2~rB96%*r5aplb7vf0(qintTg`v4Lg
zE4YH3<gSesz^$j^dC`i>;_@=5th_2OT2P3<CYUIsHeqZSvr%N7b}uS6wW7Q_1}(~b
z@g#Q#mPaeArl|a>h_0MifCXa=>+k7Y1ak*RZQR5rf(bdMvrum%6f>`DCc&ekJT3~U
z-M7T#ii(+)D;=_MH>=F%Lu^L02$`!Qci`Z51hgvQW(@Zi)c%87{j1%NlJYeWpHq%4
z7+H%`IbCG)RrwX<mseCN`A#fZsH!kx-12dtfc0kzicNI>6|sLCDOM4!h+c*&BuVn`
zYsJjo4YhDk>e%WlC@Lz(wg(Ew>>(xB)>CtG&dD4w^}@LWGe-;_IoP)K5*M94YHh?>
zC+Hy{_7M^1MWIa!;+cS=l>wnu!uMJr9rjN^Iz+z|OlXzwVj!*zQk*Cd`YnXm4}_iy
z=o29HV?gb~miDhU76sZ`)E!7m=?kPoya$B#kFbBo(ig22D3Fc@t<Z2F9S1iqHM$B&
z^F1iEmxY#s1s403h?ACK({UP*rtJjMQeFmPpAd1r7Ft?ItJQiS^eFH>yAu{G3Y`y>
ztxz!#`g{2P3}~W4zX!@u=yf3UB=9{7l&w$~BwM3%fzZdmw^syRxI!a=rYf`vXqrL|
zU2KTI1L-(!>y9H5%J)Se9mnTD7bx0yShncgeF%%48H%>CH@3wTItLRF?YpS2MOO)$
zoM~y-33^S?F+p!*8mOf_a*9O<1<lN|w1l9Sfpm&4?r(j&pK4L5pdcoC7dp(BCozT6
zHSuMjS&G&Sq~m=bC|A)2pJ8)j`5^0CBj_DL2}~Vks}N5C<tcPJhI}n=Bv8JhO%d8`
zp{*2Jh0v}Q+Kocn0W?QRc^PP~LJQ8aWwb`n-+|^S-?>9<`Cclh5lBmU0%*SCn}n>;
z@&*jErTQk2u0x}STi-cA*($_iK)UpsN7$OfW~}Q_C!ht2?`)up6q*X8!!8rP5}<|3
z_vhl<77bsAI1fn6n<r>FkPh)F&>|JKHyWGfyHL<#AkFt<Af1lAKyy`ycB5?^eSox9
z<AAi3nLrB^-vS^lWj&D2wO;`(R=#_L_8yRy@)eM-2WO(g=?uOUXEad03Q-EA`JO(<
z#x@k4kk;=4Anp4bAg$>PbSav4C(uMC<w-%`if<0O8O_%Sq~$#!v>bFZTHZ<^EoBqX
z0wwRKKsv`C7vEQbw7ky*wLur9!*&DG`LY*iiIUO_>^i;ufN~XWnb0l;(s{5E2>;oy
z!O~j20;DDPMwh3h^as*XE(5w)h1dcFR)l>JNQd16v{cdF0n+Ih1Yug<I9OWK%Yby)
zgFwqvh^{#n4FS@=Q-oFmRG|2NB)*%4b_bB|LH-1U|Iq4LLH`i+36PfjA0RESJ-XFp
zD#TSlAS3L(K+6?+1W2bXhJw_-|LTGbc;%adzdc}5)QF+;iaZ*zhwrU?@5EnpUf{be
zXweNJi+(QXO+o)iwZ0z;`c%-jg2EVowd4tcas@SGtku4U1bJzemLVuxP_CfGf{F#z
z2)b6#x#?EkR6#|8Dg><+^sXRoET5tBWnqRz%R5?BD(I&eS2f=+1r;HaHLXF==!m5~
zDClIAmgZY5=vhHO?rMEM7Zm7bX&Hk03K}ek_h4(uYX$vH(0)P31*LVjAqEP%5fw;F
z`IDfdf~NMgzEy&_G}j@zon+Ceg18~6eP0rEYA;KhEa*Bxf5^1H`vf%$;-w>6UY4N!
zg1Vk!eQN~$M9}kD*7q$z9|;=Q&-zXmG*8e!1RWA|R8Y9T4Le29N<qI6v=H+Rt^Lh{
zcz1%P?GVJRCrx`!(4^BWEmu&PpgROTCFs%tHbg>Dlb|OB4aS^C$JQk1XM-$lr=Twc
z^~6j@hqzwQF9h8u=xae2VP2v`Bm~t9dQ#Atn4xICrv>d3^p+r=G}nA%hFCO75a%@7
zceS9a1T_oFLN{%+62!CenwExnjz(hzO%udz4(+>WxJ5;Rek|yALH7yzT2KgcBrRpA
zpm~Cp3tBH|tDtRy_6s^HC^FJY9xiBtpgRQpR?zD}omKz0Ur;j;nis~34~6dwp#?G1
z(!LQvILTn7j1)9Rd?y0w^v)F8B0+rLNXx4R(z?WfP%WXs)#7`dpqs>Zo6sHy(qW$z
z^o;oK1=1S4DYRyxeJr%E1+^VzwaNt2lKTl7AihI^wB+%E&KKWVKss!`pd#_TT4?ox
zwutX7Kw9$cLi?5Q-6N<;d><9sZb2`J@0UXRTF`gm%a@IGDfAX}x}fPmIvt!1YcyMY
zxuK}TUM6TYkk-CdXjcpEdZGP7(49b9^4)?S6yLuIZJ(f5#P>r%p8)B2zZP0}jMZ-h
zkoJuUx?Io(K~D+#3`lGBrJ%2Ybb5KlTcbXLh6x%4q+^>Xw5dYN6WV;CEf-o`(3Rp_
zFSI`jdP)#arRvyT7TSA)z6H|h@Xoa;45V9GcOadPlLehBzGn&T93U;_Jn_9yd>4rC
zV)0!qzH0@o7vC*HyG2lgphiKz7xb{8Ck4GCs2ND>cR<h=;`_DGz7v#!HIq(xJ0Kml
zqoAHZI#2rx-|0ddDYSEhHd$y31yu^-D=a#;>w$D^Hwn5GNXN$2o#wj-NSD$5;`^BR
za_y%>JTJ7@fVAW{fppl9#rLq#jtXjrm7$KUkDx3d9d;0qj$@SgP5{zzOcpd(d>0Ds
zVnHj#HzueWNXK!N&^8F|2BG~NNXK@&_}(YJe-PRuLVF5Ghu9-%ACOMRe&PE_&{5$F
zV1=v0h6J?*(qX#*>AdPGwEjXH1f;_b5i~~lCJEnkq47l_Ew4yWjiBoU-6g0=&~t)b
z1kySAj?g|8^qn9V>vNrsc0fAbPD1M~v|&OUC$uR*I&J3z>DU&E?+QVDWTGXn2GSuC
zKsv-m@x4jVHbJ)w-#tRRU(jPfTHX`F_ZLAg0O_>70i-qfSkO^Hfo#i{4y5@y0%`ra
zitowddpeMgcd+m+7g~{^OMtYzN+7Mvl|s8t&^AF20%^&Q2zp$6_W)@rFA42+p}i-x
zgF^ea&^k@9x?~FC9*R!oD4|Ugv_Mb{NNZIks78D@3%UVF>$gp4w+roFq5WQH&kOp8
zpo7Bqm7s5dw5Dw*+H`aP(y{dv+9*L|#doUEE(Ox*C>K;IzI>%b%ez)+n}zlhq1`Qr
zZz1RqZwl>0L7#~4*Frlcv^F_59qoa%lpaDmP0%3m9VN7}Ksq<h7g`iZr>$5}srarH
zv>r&ucD>MU7FvVQo(IzMUKI4I_`WCTkf84brA)G6+X87#dkN|fbh5*_{AA&qE@-Cs
zE*G>CNb6i7v^7HG9+{SRyP(I#_kf_of(A^s@+Jw&6;vYVCP8}zwVPtYRtUOM&_+Rb
z3ThVgji63bt&~23vIT7f(s_TKpc{d7Dt{(?_Xv7O&{M+qwV-3-+h&@T(oN85f<_A(
z2c&a+n$TtnZGq5gg|<m(TZQ&Bq1`9w2|@b=y$Ymbdq-$r1L-_)r(2W)q-#@GAe|e1
z1q~213`mDPThImKI~!=As(%ZCbi7gVy+ml$Lc3bfErRY6^d~`&0BLzo3+)X-Z;S6o
zLOUv`+xa#{rwcj@XrR(`hS25$>9k!WzBS^zPS8d{HwoG%=yo72`5vL&FKDNrKMQ(Z
z&})L41$`*!b3xw<@-DDxYbU4^kk+8D&;|hMv<(v9(c(K!Xj6nXOVA=99d@bk#RSEL
z?<zs{;(MdeekN!;kd}9spx=w{gF<^m&>r#KC+Jo2eM8WD;`<Sh&V&C5?WoW~Gi<J9
z0BKz!KsrP}@jX+}*@DIknkHzrpoM~#0%>`xgm#&rgrGV>n+5$?&}~3k%AG>HSI{2?
zJtpWGL3;)52hyo*2Ga5li|?00J0`T$nKp+y0qL+^fppj`L4$;Eq@eNQI}PXz)yftC
zX(@}vw-iYCG^+)z6|_On79bt(EkbJ$)F|lpf*uz1q@d>ny&~u>K_3V@1f*m8QfS8n
z1uwL|89-Y5u0rc8v@?NpdWVYdIPsk#=mPPbBeZ2eI&7i%#>6)+=t}XuR%q7??N%V2
z_jii#{eqqpv`6?}658uPIuAY)+7Us=fV6(@EQ`7U>D=fow37v$4y1J%1*9cU1JWTD
z3Exsdg+Mw)x$vz4(qXR_+D75~vCwW4+AoFnM?nvZ@1KSCrl3QDJ_FLRg>$W@Jq4X9
z=sZC=KssNh3R)<>%Yd}JN}<Jt?+QVi#rJ1|b_jY<_#P4Ty!gHhq~rKNXrBq+m*N|m
zZBx`<P-h?=wwKVdgf>!WQv_WAq|0cY&=v`;NN90ESBh`F(5?g0@!lo0dxX{`v`2w-
z?(P=!n(+Ng_`Vb5=2`vP0qMHdNoc)=Hb~G=ARWg@LDR(dLZRgeDiGgQKsp@>p=}hj
zP0()z?Gp5&pnnSbMo@=*t9=AW=XhVC^%L4zLOV}T4v^MrfzXx!bymG{fuNZ9t`XXg
z1YIY-+XUSKq$NKnw4FemmE>K5UJ&0`h4zM^55@OCf=-=drJOEkFpw_6Q9wEmW(jSH
zpylFQDzplrT_LoqfI2HpuMu>c_%;gqt@!>y&@<xuHz1t{F9K<;{vp2a3hiG)`y5Dz
z;6VeOqV|IN3OY;B2p}zaywDa1DnlA{I=Tb(RVnHvG%U*u4O4!@w^?Xgh1MjrokH6$
zv}U2D2dumdARX^mp=ArLL}+}8PxIX+v__!~a;>}}K$>rX&=w2rR-tVZ+H*qNE3~6R
zbAndh03e+&gM?Nnv{gd8S!lNkZM|p1ZUEByr64y>f=R)@)+j^rYOp%e3MYQYj^ovX
zz?xM!B06}5CduE81|d_FM7($fv=z=I<pEH3z$7V8!F9L=&puGHk^Ur4GbmeIP(Ej<
z7L*X!_aeQ?P#pn>Ahk(KAHZ6y(vy?{fO|XoDWmDx$xk^Slw4$4GSnP~iufs)fWi;G
zCwYEE*ws(D4HSMXT=NW8ugQZ4KT?7LzCyZ-PWcTkET}3lE+iH_;w514^2$o<K=Qwr
zhyK4YVUZ!=3Dauzd&uyF;1dk+QiF*U+2Z$S!^1ig43ws8?OU)o`wUO2;@OF~`n6<$
z>n+0*Ry^4YTQPv}q2Xzxc*f$dA^4cTHl((SXD3u|&C`aNhhG{@Fp!DAh5%%L-3<u|
z0#6OCR=-mXPdoSo12?u3GI&LKX=xN!58&5c@t|sb&u=I~s_(SJPYam@YwJX<yQa+5
zmI|%midK}>EhxCtp>#zoF7av4Yg+Ko^XIK7zimZ%tQF<2ttfA|qWr5B<#;Pf#8;!V
z=NYXi{#vJb=C$G}Zbezwio%}I{<NICTTvcuMR~pz<^5Kaps)RC$(>tK2DPG0Xhm7t
zg2EE4jH>FR)Yg(KTkz21+E$cXT2bz9McLJg@@gx}`>iNnx1w}p_h5cn!&6&P#<!x(
zX+>GtigINu%1x~(jjbpTx1v1Pit<h?$~Ubj9oVHwx=w~`aA9<L^~$9M%a>O~S6i2Q
z`NjB@6qiLUy{LjO+E|bB6&A*-mzTk((&w&<$CB=Xih{D0NoPwJ-Ys#KMsat6e(gfN
z88TO0P@<@O59CCe-(6T-S+Kk$s@~*Tszz<TGBSl%UudVkAt9$ET7Y;IgQiR`tBh7u
z8B%_%q!^fLOeiZTi6;=cJXSe)#F#N7TafwE2riu{j849+x&UF~I%2#YQm7IAz~uL?
zbe1l!E-ool*N5a*l;bjvr4`X4Ofbq;L@Q@iVXC20R5^G>NqJdx@Gxg7Uua>nCdTv1
z*Ay4pjQ#(*n9OTO>g|__(Urwz(A0My5O4mmgr!BQ2#h!1#F>OEQL2!1`|eU{fqI9_
zx~EspD85v^9aP2lp)5JSs^Y@wIi)cnC{fid-QqbZdRcXORg^qJ%WdIOH?8E9V-T@1
z(0hV?!N*Tz)teBDMSZCvFUcpQWeSRadYQf+#!BG3P7?|XXT?~YI+G?X$17e;^sEY9
zK@DA4hYPEahPEKhEVwi}qhL8+sj@PuQ4Z>y5R?`+J+m$q`o!Y0f{J)fd1<VmBFeX>
zcu|g(f?RHq$t{GyQy3>LpQ%!?Fj`SAMCvdd*SO$bqJpxj3(Kp{FZWdq<y$nRpaid-
z+4!{9Ep@;PW&W7pELU%s*)U8c-j*vaikp|PtcP~aDQ}toGjl6&MN*MODLFc#1qrXO
zp&eGCq>_o88m*cWEsf=|*AnJDRA0O~*V==Eb5@Zz7kz~(QY#|5Qb>LQKC&%93Km|K
z6kIZ-dSWYc7OJA^D1=S9)N6E>$EQrP-jSFWtt>BDeM04-$NANzv1#awL@0?+A6Ejk
zt*$B>Tz*!j{Duxcd+6}dqlS+jl9@ST7|HtY*&{|Mo?#>LQ)pS+83E1@aZ};NxB*Wg
zFW_GhkhB-mXU+@1n5P)j>@^e6zbeo^t^a0|&$lvY&7mo^u+AFM(zgt8MmU}J|3Euy
zC=SQ@emntr73Rsy=WF6!w8+QXp?$yKVnWWR%zs&;iE4gMz7fNGTzI7w9w$x4>#>GU
zO~J`Ga%2m>^RZ-DJEa9l$9pyu^8L8Zd=@*rGmyvpNxY+5#`|Z?1mf5uop&PNn3n0y
zgpBjBCR%3rpqh?%=+NPW_Q(B;i^138$8-!GhLe-YAJ>elzlYDiiXb-@nohH+0}>kY
z<__Ie|Ic~(n`VYLElJ-P*fKjX?s52EnY*!eFD5Vju~c`)yiql3<MhC~cj%~pe%<@K
zVAnleTh;mFzC)kg*w#m?Zoj)ZrS6^a6SsJQF)vlWQ+H(T+V)M~A>gK&8TB0(UA*MU
z`rYf^agH26zV2)1b=2K=>vz|^b8Ow$+!UyO<Kve;ZnxF{n_K_S`SbGY4wY=2oW5yE
zc*ErTkL}r*-?zinSx9*8754`^tdAoZn|{=N%cSvc{p5Q$RYvNo57b?8Z)S(<cYtTh
z%%|!P*UxMW9IK!CK<zi+e~}@-aXYME#eg#(s9$o|$K^xc+)@+VxWKKy;=u0r!u3mT
z-nbxGx651io=WrN1NCojT5@y!-gWQp!Zd#OyKT4h>btwSExh6Ee;iC(Ztlt25qRQ1
zPoQQw)w6dzdjI2(cVJF^&|$+xfejPfE%Tc<bgbJQ+%);Xn5R2jvm1UxU)-`FurZ^4
z$${PPhKIhnaX}#P#ujL?<iM8OoB_zBZ;zt^cerNB@#DwqzFE5_w4vjKj~`$6jiO%L
z36a<Dt$TO;?t>|HPt?{m_uVi%P<JqUL!fTA`|+(?s!l~hk>Zz+A@rg2{DbWQ>Yu24
zDx-<3>Z@O@9<eDWvZ=Cr{qFk72Lhjs*;9E^{aa9CW5$N=&~ig=pl%m3^}v|jYd)<1
z_r}ThZ^-F8bk~;X7mF@ly5vd9-?Zee`aPSf9~gMJKBqh4cp4X69=!Xz<HtA7y?;|q
zuMPQq`;R|*{P?Dsjfl0VKBw21nGbYWe>QTyZqG8hH%)$^J|_Z^Lw6~mn<n3zmzTTg
zf{fV*mqASZ<OdLN)7%G)##L9L^iigPW6%%9%Jf}57|B9iK#`WBY&Tu;z{eT&Pi&YP
z*!@v>L$|tTT$SOgS8kbmV0PZT+=F4rh0t*<w$-n0*^0|Yj&GP6tlzi$!%n+DYFqbC
zu<pYFb?@%l(4l_!?hoM}ANb3L`GNW;Ag}J-VBJUkHq3YHp7B1uyJ#yb-i+~q`kD8B
zcooEMMSeip`XdAPZkZK8mOP#6eE3hOXX@E1R54Sh-rlkxh;nA3v!=1up$xvYbxc<+
z)HGDH@2_C@KfdG9|FMECL%gWhxq*${>*pRA`r^ji0BYIySFpnGtziE_E%~1+*lK1r
z+fVxqsk;w`k>xhGJ6!WQV$a{Q<Ul@h{FZNhIsUTFan!k&HcWMQf83UN{NAqJA9X@b
zLkhFFIk+V~t?r`%bqD)x=zzRO@i4>h+PbB(-=?|uqSDOH%bj=dJjkuDW(_G?cR{aA
z_ru?^%Dl8;@9vLN>YB&by*Ix8wcVel*F9NVx2qPd1_j>XniAAUM)tw@x_47IT;$e$
zl(At#a6`u}^K03Bc6%Q#0>^)oaxIegKTBB+j;*SHRXtd*O>@JW65Z>L2Ud^Uv@o(U
zxMA`K8*>6<k5`>L^sBMQswXv}QJ_ov;CS_zuO{}&uAYYGv}M+@x+mRBj_1zK&pVil
z1k^p1X`A0xw!g>F1u)RD>W9Z3tJ+!r+0b3<pRL+oe^~Y0lvC9NIh!gnpP9%pz<Fk3
zCM^ht)Gayg?A*MA|M{ANBlVM;^N+u}X>v32(?){+cV6A|$MZK$4sV*7UjM|^&(;LD
zj0kTGk9m6a1jICM=&p~`Hnz<k^Lgc9I8UEg`}O0iKgF2v*LCmhLOjU&>USr$a914$
zcg2ew3lR9omIqE%3hg|Nmd&p%OYVAz`(E{L*Bx5*@84{io3Uwf`X$b$>hL9QUT!`L
z{on+pb@xjG`3KKdFr)U$K2CM-O_Q6xn!GE!I(`0pRFRXkmralA22(+MW^xnbLsFr{
z3-w=ZG4ZSIOEc(XU`#}e^>5T4-u+SE4Ra4{nSFfB8&?eI@K|o3!(*e-n9w~2zS;7y
z>Z*^kQ(n^-qzQ`e^4DvxIN(&jh$sdg9{S><fqU6$qSIym4m|uYi`x*3xWVnPJe`0W
z^g=1A;Wlm4(%ZG~kkPSI=SY{X-MaVac~Y<5efpm0Z{4&xISF(O^bdDV3x-b$cMNn2
zWMB+;`#EW8=YfR%#;#5<d`{ZAY16S4?R5?W!)YNnLjgEL?X+KLdgsxYxTV0^o_^Yy
z+5tjv;|VPWZUafi8+Xq@Qv0+tD=AG07H9gY4nwr-5;!e=dS^z}KBOoeSnwI0A!sb7
zX&vcL-%dtJ#Ehp5A}fu45u+q@ppspTlE&Fp^ia&*jE+j-?#bk(rL{{-Ph<EVh&;^5
zdj<kpwUbVUYG)y(y}AWdij<_@$!PJZmSm)O9%9&37G@^nz|*Y3f$`}&x0!C1Ms^C*
za7suD!A0?8`J7Ox--s5z{e4dOp4!$F5}!+)mWI;q6rjujh7EZ}nFF<t<D4!^gjy<b
zhKZE{Aa_t&V6IZ`OrIdo2Pd7JYl~{*(;3S70Fz}_V^pR9F6hY2F*kGs2A@?~vEnQ)
zZdN$abIvM_$12KKR-UDoZf6e1H6D7J&E*MyZXjjFDr_GG&En1p{(2e6o^{R$xPK3%
zV2&M%&BL88?i+z6*w1&foKP9Ao^{_0l*7->@<Ii4?hm|zr;2V?IOQwK{)h2R50ztm
zr*CO--!jCEP_#lX@7=czDMAvjvT@vIL+TzXsIDr<(!La%SnfN4+mYvPR<985cZn^n
ztSZOi&VAQVdx!MC%aj7#p<L*=?-_cZP#JDInE*Mf3syMpfxtMWWZ#fka=QOCk!6Nr
zlZr}kV+(e|-1h_b3}9USQuuVk{U9(+MLi%Ct0*q7z>PV2`^r6NJcc0lmBo<%p^-K^
z<r4<{$T-I$y7H=m61|>w+>Z@CJEU*haSsLFRC-Mc@j@2I{VcFRxu=E7Cf8I&%hX*u
z?&l`hoKS&}`tQJf8B}%wiV166$NeJkjtaauRIs9|cy*N296Z}_zck^Og=*$h6s!R2
zSAipnwJ?PHc|e&^vC?t>6IiVZc2%eb+j{C5qI)C|Ih~P|gkpxKSid%`u@G*oVL2)4
zH-=gjs?pROY_2Tl1+VV6fzy?onoukcSxuq}a?}L5JXB-p$w1!)zCh;?%&HB9Vsm47
zw5IhurosfX)(1j0nw$)BJdlfcf>|5j$1=Sz8ZBhKaNNrjeRB&sUTAa!?v2W4D<VmT
zP|CS3GbEUGGrX{W<G4ZhODr;iS+@pK{=#zhTyB5|v$h37<^mx~3>oV7K&X1C<F;|{
zLS6^6?n2b4kgFUw&E2h{yccpwQIWMXk?jB*vU+7j6psnr443&9%z6N<ma5o08uq3@
zsLXoIiXlWNm(4SnwKEVZF!vU_UECuW--B7ZAY~qQSsb^ko2Qg|8C>&F1<DYzn>$&h
z?sbT?wC+aQe(<TQj@+I`Rx>De-_1SA5Wfh7misQac6+(^q6MKiTt%N#TpBH}Mvd%k
z#NO<(6T$7!Rcu9l+-Fo`Z*@b3Xp`ItLJCk_PjT4?1he+Iw$n1Vs0W|!$toKTVW)Xz
zruxH+#7)n()ZD%vd?s6Qr6#$m(X>{UMGG^1?DlH*;Ir)fTn}xs%1QOY9t%0_O-G5h
z;Umr9DehKK+7f%gEcXv^gkm$z{p`Vh?mL_aWZ~(h=~0*Zu5TX^tWy3dT`8$r<paCc
znw*ky>?j6TyDqwE_O3O&K+6fPaZgi(aHwW}1ulAaf;DcwqNKAq<AP|k3nv(N%M>vq
zRFfaarP0BJTdxR_P|XzdjrqlR2oU^{dygV^57nrBw&3N4s~4J58MbmSb%IwIQYLg-
z6<u*Dw%Vc<tD}WFz?DY7ep)PcNpYDLF0Eec{zXY1fcSA$czK16u-32-3gO<Z)x|5g
zwTKR<3LBr5DDz4uxXy44K^A|2j7w*Bwo^UUQ8?T454_f^GB^Z>_G6|fzxHgS?OEsB
zFT@|PhT)}|W(bo)ex^KlbqITB3NN!y3p8Rb5-(<?_M!yDP$gb>i5C&P7&z=*FAU6;
zWLTvv{C9xb=6(bSZg+X1e+F@&O(iLvg1pebE%CHq=OD*kU0EVQM$gJpnV40{LUn>&
z49yFb*5npct>S|#%sdS>oN|;ByD1@VR(i@T%w&SygDW7@&B{RU6N^paiG^T~pzixo
zTevUl1bYT=RZOTU=IKDNSFlNuP**0bz@r`%UT;G}T`^n4T7f>n*A**kNp(p{QnS9n
z@016s$)pk;Q)ZC2cez=tA|+~@+zFl>9HD4KNXw6xqRj>8D9Q*@Ok2qcUaDxL(N=J!
zetBt`QmUVcd@QPBNffu$1^WlDQH<HB(t3lOJ&_YUHTZi)pM)ZL7nvURilJTlbYz;Y
zKsUnKo+Z$pS>`K8dVrk;683m~wB~09`S?wB`Gxp1SF}I9+N;N>Vec{VXXcy`-ZH(V
zm{>~8t|SxU4}#D!z#MBWyAP=C)PTwS)BdW(FhK}=jta|sO!|SmPz9rs%(<jkcwHu5
zw~H4MyzYkOhP}e_>g6R-xHrSy$##PJ(-Xm9o4<kDnb-AC@@kf2fR9u=-sRt53mR2B
zQsH=4C^1>#Na1qFyK)4^B-GVN!tvHJzuc@yq|EVZshgYCy$ffZ-nz>>)72}&2epoO
zm7X&8iQti><JD<b-w126<E`hU!p+KzB=T3`xuoM=tv;rg)z4{j6J!O`+mwN!EAayF
zg_nW5bVIZ8_WnZ64V^B18RI^Fi2&Vnq|)(TY@={Ef<d6v@m|`YoHHWDmAX26FKcCU
zBl><n?-f1GoRiF)LS9N(&3<#KN<#3Fc2qO$eS^Op11VTG>As^4i!Hb!qZ24?iPM9r
z9WR6<<y5xqaL0dPq-P&dmWMAs1lx4fQG05_5^UR1XJOcBGmvr$GZs<~@u1)%85iQ5
zOvr!dV(`%n9p2$!FCXd%KAG{RipC4cMTx<u3~M-4U@uP$?#XyZ@umBN>&M~2=QBP~
zei<QNSy_!X{(_MZA%zdmf_pQxzTGjMj~32R55jRJqVn5kxO;`l^_`Veu(}kpz2J++
zD>H;_EiT0XS*WgL48D}1>lVs-Ez=*(ScoLICH8{dI>wp)*gQO|Mlad%0#)<SQ5TZ6
zDC26f66Xd>Gt%IxyX7(y8OQL7s2YsRGiIx>7{sAe89$v7tS~f;<LYWk_3@2hbw-8a
z#8^J5xN?PMUY)T)kuy>XSgLD`Q+nr`jNd7L^v<R)jA#5=QP4SKWWe}}89>IjiiFNt
zUHcfk-0+}Ro?MQ~afNZCGsaAgH(Ca-%s5#sD$p70wN7wt##lu`SF9)7POvtkK#|ZF
z>&NE7bw)w-#CrB|l_8)HHVe66ogtwUwo`p4xZV&aQSGuqPBGQ<^5E4O_p3OjaUP@x
zmHLe56={a)Y}qrkSAUXIfOAOWG`4*W`UkY1+3IgLDCz9+!X8UC?6E<GJr<(wxJwv>
zUhRqC#U>T@<_iPMLot9_Bh))BwLKBMehmwOQB%U+b;8D?X-_Xu|0vW?EmhB6)Cj}Y
z)}9{V<XR)_J&4{i?EO_jorFA4vf3-e0Ptr&8ukM4)9GQEX)ZG_;Z2p=i)E*iDv`A}
zOcRA^Q%feLo1$^eiI{GH7509Dza7;wG^vc$o@EmDR)RxE%d*qanvv%r5Rx-wHV2$U
zkuD}Z_*lj`^baZTBfj9{(#G&HlHe}o!#OfO{lk$axZ6-dp<<p}nN?K8Q(3_$Ot3JP
zd10CItIdxSVpd%UJ~R{#{yAfdMEkTvi~bpN>St`kKdiX<8c{g-SJg#^3My8v)=%<-
z&xy2h?ra4ACep$lFAYV#LCj%~@rS*C<8L}Uq@emLQK*ZDGp?N#j)XF+;fP!sjpOhS
z=3$|erz4j*e6GMz5PtS2bc&_~K&i$uCX~g(=6JQLs*+2AP(MuwM~aFoD#6e{q=wLR
zFgT%sY08n|bc0+c)U_7Talzt5Lc@3qX@t8gPH4Ce<3w-;?P_s)5p@bSG=fzC8$*$p
z(rBc1rbo)OQ^%j-bmsS!!l6?s%W8X?_Jn&Cz6|Ar2Iz=9<O@?C_NavG=>?q>EZ1vT
zw#hOOD~n1F@tG|+I`NB5Zo1mx>cp=$x$Oejp>sO%%S~?kKnauXrM3*iuQ|CL0>j|f
ziC=VbGXgi0&kgAq7<DIn;>qn8V6AO47u~iyB+vw&w#4b~(7+KmI3LEG#2prBhbIIa
zr(<e4KiuqtU_j;7zK%P>?Ae4(^C5e3se>G#v`*$bL5`aj$O1!}bq{i13=Zys=n9J~
zF#70K^h-fK5pvLMqP&B+xNIfw7j|DU9)S=KYFX-Qc4?6^n2C8kxN#6Q4u{H2STkn0
ze>aS3kjF0CJHf4rGlNqJHLSSr8kUG9O;CrW-1iI}<2#lV)uq)X1(*V1zs}Hm*<FW2
z!CREf%ut!mz<(Kzewtw9ePXBsoKCVgF(+^yaw5&TBkt|)??6y%A@>foSHp7PRMEXt
zZ8WfFQL`}jF5?bi0}88P$Ni<+c402m@D!K(D>v&5<_gDeOfKEKT|K+ZPzrEJb>{{i
zGx5_Iao4(w(Uf%bwGzGBg>>9??$@VNo)=2Y;Z)YW%5a2338uht>kJ`1ggdq`#Nx_v
z*BdP{ld8lqp;ERl_i97zn9`fYcMV^-hTu-%nO0m_h&7(O!LW43_Z_h(G%v6cilqT|
zcdrT@7A5NfdJ=}ZIuQ+Qec%b~ZBWJHGP84Zwb^wIhbjw-qE+#wCF-7R_ZmZQ!+kDP
zv};W*M{e=Nn4)b^n|zqzr{qz=`oN5Vlpb+9nR8L@{J?SQWt@fXPXf*8mO_>4`)3$4
z$}cTOM%`)}j1#I_UZT25_oo4Fdnru|Yc%OLL+T!?!k5W3?PrEI2$fA`-8MtW4&n0b
z%hZ0^&jZ{qbF=1zxG%c2sJsHRO2_?$N#FuqeHx7OBE1*BJ)oB*3qvakpzKoB@w&Gg
zMHh##zH#pi=mpL)rxTA(IqrhMzmU2#<(TC5^)h=Ptr+#(OwTl5U7#nc4JkJ(pyN8l
z({Z_a7n7;hiwrNMuP}G}dAe$au?4Gcj2B8eSg;-Axcxod#xp`y>I-h}Y2Lz<RcVAO
zV+E)&1B|;D##uG;x&zf3m|Nx?sKtpbbK4iWXL#FG+Z_}t2F-B?nIJ<##Yzz#uQSrl
zG+rZ8MzPWk_C~7KH5%L0+_fCy=~BSH`n0G{!*CNK+iA0#3S1NzgbZs-oZ-&(e#G1>
z(>XiOusSLCl5@Usq8?8+x4ydz3=L}-$6e}WoC&_Hbf=T97YhR$ATCWgdbtyW^Kl9#
z6q`~}Uh23xL9H4HoNR02q~HXlKU;IT<4z8m)tBZWX^P=MYew^S+^MDm%TSxEj(b6{
zR!P8;s1l#>!?P0ZX3sDkcK1-V+7`zmqsVb*8fuSFp*owYsTUe*Pc&B^5!TdMhI$gx
zh5?CR2Xq$&Rw6-Z)}84ta?ix;M(CRPbYQW&fdd|T%Hmuc_npk{a*63cT(vy2J*<1N
zAqREUTxy)CiR?txhLgL@cBE>H$}Mp9>Y6=+8X%XuoMLj53adTr;kYXd0c#+v6mVD>
zlNh(qeNT0l-F0^wb@}xX>;pKR%y$mm#euO%Lz;1>yO()2OcRQ?+B;trFA_K%dAizG
z2VFbX*qQ)QYN_Tf30$KjDc2D9?%?IUY&YI$3KpV}398rswJAtECA0VUyY~dSZN$N&
zpct#G$!v1J32rk32&;Gr(sZw>Noa&+SQWeX8A*{)d70i%aDOZ1&nIO@zu!smbELqL
zS;yUB^y;NE`S-!IR9u<5tNlYzceVXe-eh~YKX{Gu9S|xoL(Kz0E~2nA=X659sJ>m`
zE)8r(veT?P;?@Ow^hSoVFIykfeVG|duQm#Cpjc6%de&<U3F9g1P;t%l%E>%<j*-E5
zq+mENj+UT2Hkf3GwRZJJJ3Yxjh>gL`N?nY!_A$q@zyPR{W}F#rsk<6(wK3wBxn^TT
z*OYRXs}K$idSr@8b>xEEz03^bX!_>!3GRx()f8@=)7(L!Q?L<)2Sd8+JTs)bPTf}z
z4(YxcNw37Z9&;*e0k~%wDpo0#<^U@aI>b;@Kvn(YP(w)NJgstaY!xcOFhdJtMpwxr
z%WLc&i#yzSwbA3kh|qMFW>#AaUKMDgBSUir(~VAE9dvixvqO3y$j}qJQAYDfC^oHN
zHD-T~JKAt`56SmH+%bl&7av67X{h6#6VknNrmkJ*8fQN<zLfGK817g@#eguQSUu1k
zXM_)eaJ^1*&od;92!?5VNUs1!go-VbC5;Xh;B+(hj&;^#hZd>?jzw9SZ<D%(fng||
zH0vJX-sHttT4gFrZuU%9rknbYjT6tJ9QO`yl9J{*olJWy3S3E9+Lh~m<8nyUwdh-!
zzUkiksCk@&Mz4DF@7#f^j)u`^s``J-FrY9@t3B@OHfdYCV_Ul(0Rusu$Cw~<KhJfI
zH%h^NSj7zn&(+NuW08u*GlNP$HD^>kLCEw3C<gUV$8l4Gx)xy8Q;6NM5}VC!O$<Xq
z*vu-NRaSzzWV&gcC=J#}Y;wBo3~6L&RY7vn+1^mk4qb}1sT!3!7}6;9RDU{$jSNE?
z4RP~|E2>lv(8&<TfM}oncQ&+h@OZ5pO(hbXs!}@EY|^=1g50xlv$8{Fy49<p%0B*>
zgr3Yt?q<5PX}bICVY<H=C}}<0Sru4?qD|ATu={xMZa6~;$K4gYL&fWKFN|Xrv^&T(
zq8I3k{-ZnGPiS{v_9spommSC@f%_4*E%6{XBc=2d2;wBJV~SbXV$*Vk%AZb#f}V&a
z>bRX#ba94t4d{}hYe0Ia3VR9I)o{C|=t&u#-<THNJw=x#+AF6zx<~4fqI)D%6+0N7
zlyaV`+@{6$N{J~aTI`GhHrC#TfaR0au1f<~K>0N59^~!|<zfCGQhRdliy^x<sM4d?
zONQX7<i0H3Ruwk3QEgtaot4rZdH1Sm`e+e)=){BQ*FsuNEFkeX%M{MvLuM+fOYe=4
z9=zBP3YOcY!kdPg8LGsjVQGn))$R|OWa@tEA0eH;1Dv4#rf|x@rASZ@?Fe*hk1|U+
zy#k~R!a%q2Bn+wpp)28#lo5Xbj+D(*U*Ap{Y4<7$jJUJu&8pCo3niM9I-<U`#iE@#
z7gVP;QhW3JC7!~$0k3y}mwR&*_4=3<0mc?gv{pM_-@qlhOH%ra6AN*?)Zk^B<pgGs
zvtoJ~?44|Am_?H1l)(C7)Cj9@{kDylWf;({D2fT!&yca~HjMoPddiX+Do`60-l>6&
zN>)GB#a+n9joxVi{lsGcra$`gN!|b>3B5}!rxFi!1_rjOa6@pm0B4W9(+$H2oIjxZ
z3?l=*dqNQg1@z=&Y^eNFML5%hz~LEn=*Amt2$RtG`P}6!<DQ0t4|ESPB4<D?44LX6
ziZ|3S<?1zA4xTc2!whXs2v1du${lZb;De#eumvHsQNH$#6ACLXor4DK*?pP97G9I0
zF&ymhMjAn@T6j9%*@0~;@g<=co=1%`T(J<wXK%D|RfVd{iZ82HCw9CsdKW6IhNq*-
zD<<eoaqk?%dpVchI1Qzj-`=^3tj@_)M60SR%9Of}H#TqwqE!cFG~K8<&hQ_^K@ZGB
zbh~rB^9=bAPIe@G^zo`Bf?0?4sTVI>?FR(2aM&XTw(63qd~{3R1eM*vtRsO?v?f-<
zeLHWWS`Y`bjs`;5$-_HEIFB?7^c+L~4pA+~o)Z=|-Xudirov<23be_Fc03R&EiO~%
zANbsRie7$uQ;c`5iwxmo8+{1F@unJ&b*?&)<xMk5TaW!ZbfZ=3@vk>s9plocQ}}gp
zbqvir-|%k5d_XsG?}9)L8*UbktCZzmhG&Q~49`<;D4_^5O`hy=(eFiZumnYb^J;vx
z+?#Efacx95&dpM@UO-##N|@n2#Ak>40pr8w0b`_$8zbH$x?k}kXnAx$zEIW4uoGnM
zPVL9XsJ*<@;kQCS?_wu)1o?Z%oK&^Z+B@N-p3T0wcWgTLI8#R{Hk21;+o_}ZytWUY
zYNn21q&Vsdcn%+F_STOmQ_tn@L2vayGj%MRcW?b%EOi`5+&(Wdz<GZH9laV)$>CWE
z7LQ?%-B{S;-ecHf(!w5>NuAlxp(~1{p2357k@6T{EOk-`nJtY-Y=qiyOFdJc(+jA_
zx~YS;w;PF#bW+dKj$kA<)JYv;GY9V@rViB(Y%~vdQio|rIz&3D<0DW3i%6b%GzWgv
z?tj?h_EuO;3hk2s`4W7(`>z0xY=w%k73O}TN{{Q_vgn#QYDM;`A$jUhlj9y%wGHb!
zr*GIzad{pxv$%3PdX9>U>KH4xo2n*$nb@+!61Whj!on_}L_!5_28KPJ&BRjx)UuB1
zXrA8cHBU-DfWVIGAYPK(ehxAnL5{&sKVacOG5w4<?DYihsE)!V_l)%s28wLY^Gygl
zL~-$8oaR!`(wKdU6%6wf1JB2u$iVY7U|0h$9Xn67eQ#VULX(hN!PJupehokkiUFv}
zCA@lm1cCJEIUTY&p-~)+hWmXw8t%6GqDda>F$x_=u&~GdT|B14ay{&E2^jV`0Sl|$
zps>gFY8rdJnFTQ?>`qf#ETLk(Wi#DOe=+X^hvS}aCeD2HFcXo7)h=95whk`bMMcgC
z!(Jmu>3jfScjB=<S%U4<H-dw)1!i`!-juB(yNR~nMC$2Hw0{^UmJQr$kK)Lz-c)$Y
zc%+Al*$2398#iWxdW);sOzQECI<x(@w20d&8SV#a``+>$G<;49I|28@pzeCGTvc*E
zN-B_Cy?$&XM>@GF8TRf|`N5Qhz0Q36U?-nTaZari&pa+tJ7_l2g=PcNES?srb9G#T
z^QnVc&SICzY;q#$dNI7j5ZZ(a@iMvNUToZ)P2GW*&CZUFG3-{TO&z^Dt27ayA@eCm
zmEGV$$gbG==`^vps#G03Ugxnf+0~*JHORfi<193k;C|I|eq_@9i4~~j-zo`6OeiTX
zz{K^ZhJr0tOiCU1HnU%uuBY-pGuxSJpT0cChaK!2wwWYFLYH7CR6lt5xuJCl*)LMM
zzcBi9QI3gogUL-yfag}KRr_|OFiy5$_EExa#&K`=a@8JJKcty^c|DiG$^8JSx7@_&
z$u`e9rlPvw-Ghz@$9Yc1pr<B~J5k+(6U$MTz0+8|JDYi4%p2W21pRr;&ilsDiOw>@
zzSBEL_r+cp9;f!s)u*Y$>fxb2UEqz?G#u~28`vE2$JMI2Zudw9Zwi=RIS)I1AfKnn
zJt75FQ`GZHZ@i}Tj9`;QpZ+o;v$e-bkup3S0Sz+~P3e`4*hrnIJ$grCmC@?La+FyK
zrn5Pk+9y(IHe6?xuZ~t>S~y92^u@s*!#Y`0GC|Snd2foQoE%wRzOoubz47Hu)q~e5
zky0gVj$X=n({%FtMfhaJo6fZYw%a0QYLC=AUuWNth(4s}U7*)mBO=9I=6f@A;L#E6
zC75Vt>MgwNE*zh|3pqZ!S(74WPtBX91x|}pMlZ`z&xO5QEo4SS4ez!XXY;TEo_2IO
z72SiEr?<`)MATyp&TOi2>gggaY;h!35HBe&C{zbNy@i^(EK;DJUwMn(R~4c#QeZY1
zyv3TbDpH^dXNgw11odsDs&&iI7K2uirJGS5dWF3>&uC$m<0YtX?-)0%y&tjH(!<37
zc&pmm*XfMelFGlZx06$*h@L(@svkc)>J%7nZtx!aB8`c}I*p+(u@W4o+nvn4gE+kH
zbS3QWeYlT;%JNIfQA{7{B%+S%1G(PEn&3r>)sbEAkamZ=@bsnkFNVebTckh-|Kv60
z&Om}0XHO=G%MH^cgL(<_pMQhYS>bf=2%bzM`pGzJi*o<k#ve0H;Ts);7tzaj?_2E-
z^BJUCzBpcLAO|Aw5LCOndttRERPQ->ZOrQoPRb`#xUHGq;Ax)LCCw~{(xLKdln2hQ
zBICo}Ef5*@4xxa<9yL_`$R7YyQo1`Q2h7>Oxm87@Rn`Q4u4E$?=Z62o+?#+`Rh|38
zd!Kz0b_O6!PM{oSPz(VlhC~xc02%Zofdp{C2w@TdAz@Mk45;ylCD&@TwW8Iw+N;*K
z+QAV;1zOvpQnhMZwAhB)s<l?VwwCYrd*8Lz+2<s^-~I0M{GacCo@bx+u6Mm_t#{4i
z{%!u@ckF3+OJ}3!-^neON-zd(<P{Fj-z9r4ZSg^?Hp=xS|1OHg+QPvLJpUWagDdGD
z!vH+Gs5sHY7$z$t_OG7*ltg(KMCZfLcVY4?OoL=<>pvwc*EVkuE_iUs!D9{oDQT>2
z@ge4hp#L;|1Z_`j9=sgqrv7e5UVxS{c;orF&F(+52+mbvKNrr=()wMoYD)Hy@uo05
z|2bNE;zb@N<9SXS2$eLniFfd+@O)m7_b2+NLu6P8PYduA!O!poV?19M!Gq&S#V~?x
zQK}S<gZXld=f6SC&xh+^EG_*vspksHj#z~_p2H)743iwWkq+Jo?9Qo@X+2?_jFWB2
zne3d3>$QMy!9kZ_=Zo)45Oe~!u^&Y!{m%eSpyp?tuDRR1;Z&erL~|fI{8IXzBNOEs
z*fDZ@-rt$3OGkVD1;W2m<dDb<#rg)U-iX8aKMwH>m-BUhg`5`0$v~Z1DXXrbutij6
zWt)Us<}+AS+f`d?dJUd&c)mt$H?p9%`<$1?+PqU%Ox(b#vR(9zwZ(_8_WWzbvI#yI
z)pb7o{XlG5s@DtWV{lLh?}lR`GvDPL)EIqc)5@`)|Aa4U?u29)Oq+Y+DL4~4V6z8q
za%2J(5XTcfXR(Oh>hpxrCp;CI_oUDDRM2+E=B!AlyCn8yO>7YYxfai*cy4DzlGv9`
z;7BZU$MauyiA71hA{!3hhYu$9pk&M^v>}^*C4y&$C=K44pN*%Ob@30vH&y6<L?l({
z9B)Xv)k`x(0iV7X&N;zOcrBz#=H;~0IHmK8-v!6d39hFrtE~4O)a;nI9F*_>qgz+}
z`{2kcm-4b3&<o^kH!w9WthI`l&>hYSP6I1`Ytb7xH*8cdQK?J0+E<biN<l$1Cgkv4
zzCYm9X^ZDJKNvf;*Vkvxn>VlOZ$a;H-_D@#&Y;f&LDxHj{5zN28*D5+J=josMtRU{
zXOI{6j9t(x9N!Wf*(><Z&9O85n;$&8?!2=4vQbMWj2cyT<MQBbZ_%h=(cyc>owH;@
z*@SruXWX(jC|ERMRPf~HIpKiC^<NvkqAe&m{NeP+gZkK1KNuMnH%}<rzCAX}hPw>6
zg04N-@;F{Gne2xH%7WFe;x&)Seo!2n0+p{RZ)qv3Iy2~cILKQRUKT9aSHJZ9V0CfO
zt@x44#-82W9QJ-M$iJo<N+*_-Os{xt)JZL|A-zsIzbZI2Obi@3?~b!et}d@HoBQDI
za6qu}nzo=@xM*PAHB0UYdX-KOe;-_)0CDex>HS9q8>b~FH1{7BI}c@3giOO5?MDH~
za8+0sk6({+KuvW&_Vg9q!tJrjt~nE1;@1YTCHZ?QUZ{8;vK1JD%Z=n+FrP+uBC->^
z=1gwMxi)@X5LEibMX~APWv_UuDu~TARs``p!zeXjuv^*<+Qw(Xh?N&7W<)}mTo6kZ
z7tNp+dn*`*)t4Q`rPe=msJJ$$Y>CHeqY9(fk{=uNIxCB`O;UX?Elx}?E?OLkt)f?~
z96DNX61LB^*54GDPNr#+)u*E1e6=u>G&)vqw2G!UO|}xyA<Zj<ZVqX#R(_l&^F8J@
zqur)|J%!gsyiEBJu<zB(0eJzQz+1g}7YX_UAOG^hOi)lveJ?o}<SaZODY#Tg8tNwr
zN`80Y|86`~mnLUXRF~!iv@)tivs~z=I8EY(l25bE@M&_?jwa(Jgz*;gAn@Am-CPQR
zvoWrTWg3X{@%Uaf4SEzlJjm}o{2QMSh))I&i3c{{1A>@}NEnSrg{+}r0)JpLLwp`Z
zA@U?%!Q*>%G)znnY&H>jubG%)UfYEQCKS?EEz(ihPhrVNCgu+6ox9E(xT`DtaA-$L
zs3Tur&qbY~ll8{LaC#v6khlU5<eOluQ<BCHl%(;Rl5fCZE<l#KN6=f4jN)}X5*&$l
zgkS$IjCLhyoFv&>UkZac<9qc?(nU(rAgV2bqro|c1V`d!<^KxC>q^q-EqPc?W2}-B
zV3a9IV=5jAgTyr9*Vn?RQ<BELN<IkVyGpW13Q+jaqc@CdCHZC+3kqDDhs?G!Br9rY
zoGoOs2F6O|-U#DnC272%B#r$-CYe*3J;~2NYMvyS;M*mYH8j2{Wby|v4k-7JFg_Nt
zmc}sAyN1TeLMEBqnMy8$akG+4*ylpl9FLTgOKMz0Jsv9c6SZn-Ou&PzyKys#O6A*x
z9|v7e#1r#Yi8&H<q{)8_>3@okB#mB~u2(|it5ta#Z9>-5*ri+>3p?WmJnRK%HYy#`
zd`#%(kmhdX$7%LQr^?n&lbtdBM#FnpWJ`9@`~e=cSQ?KjNh42umF%L~0}mwnz|g?j
z*xSjE%3X&i=9TQCse#oogr6BU&DZdtmDAu<6qSd@pOkCE;=261cydh>Ce85B%;z(}
zP*hqYrqN@*^}7}BJMlnGivChb8pan2K!1#syc~%oLGnaA&@L*`Pgu2<#pnj$VLs9v
zq;yD=b6e&$&8w9kr^%Uew8v!_Rl+OTH5FzO57b=?W22I3UnQ=CDuI*wY7?_sL~Cd)
zQj!LJqUNOo;7Fpsv*2`<IM-R{NLo4iw&7vIXx^f9Nb>`sn?sr(DnCxs(CcY(DjrQF
zN97*EYl_o6PU(>5DxsT0npY@4PIJ5A)8vdhT3H$18NwUAs}yD>9(0#9ID<x-8Ny~I
zX>7xj<E`8BaNx3VI9M7+o0tp-8P6~{69>tlmMF>KHY#azFzr8GEDyjD?HND9!Ev>o
zp04X6{lwE8ufuA3IVL|wzQfXx%fLujb`AEe47RR`xc*6tjy}^aVO~u0xisMK8Pxi;
zzU;b<M~|l%N}IRAd5hmL%$wir^NqNX;d{iE!>hc~_A(fJ|JX7jFK!<|)>^irH}H*7
z%UQc<jmOt^qjtWz<LnK~n;Sj8rDHkfWZ63y;bp%C$hVZN{95cndweU&GM36KGXkl|
z_l+!@a`PAHF+5)%vHZ(dE^J0}`4U?ei|?LTmIeyl@H!$+aGN~7l9K6YUzOo&Dw!^6
zZ{{r+zFe3oBI@$pMa!0C@g=+{!|KoL+j2*nFMW`xT8?uCzWc#<M&gF)@$D4n%I!41
z;lV9^zTLs?M84U<>(P9R<9fQo<YFB!Y&-yiZ(QgO$7+vnY((um*DyyZ9#1uK6eCch
zJYq7(GCa`2ZZ}U9%{>&JSIL14&q?f|h{wCgazTqHrS_IBcje9X9G+L{E;5fyvBfJl
zE_qs|mzX>rWtsbj+_ty3+jz50_oI13Mz70o>)u@1k?XTO|FTzjcnL+Xs&K<~Vw2fx
z<q@~A<<Prg_3DNV9xuIQ^LRGEw(s$%mxNr{<=zC(j(Ac)CXNmGHUaX5m-kJ+5ZuI+
zvpa3QB+{aJ|JY^>uX37n^Zf~v*JnqHfY<Ug-8`7H2YS4sExF8lsx}jOb62yLH@q~9
zczR_I$#7ue@f^$A<<N|8)YziuoqQ=#o;lePH77;UGUmaO7N<J$^06sip2XNACmzF?
z;!`<ZSG48Hd#0wCdG*Q`8!wbai<CRD$Yq{4$jJ<M%1u#nOV*IQCBSmw7Ps9P=k)_u
zaD3U>wmsV?abKESzsZKhjc7Cx3pc7|Q<&S+LU7}ElG#?C6rp*RE!70&>!B!2C+;S5
zf|g1*{<t@PD;~}OIrXtW*Q%|C(p@YCZmuBX2=I+mKkFXp6fH}7d6(Q(rYhpSxh6d@
zvT~+_v{v@$j*j%HmS^+I<<kniL}lG|jIdS3Gx#tb--VNQ-N2(=J@vE~#JMp?jNV1d
z8y2te<UN9n5_e5?m87}BqCE3*B>VPNQ&z8RUNv!phu2n?^QGhLrn^z@Yel;^?5d)t
zU%A1XGHKHI#BktBjWDoMC<4@7tROh8ec#6xHK^VmzjA=;1L_V?+&1a$J%vI=%LerT
z$_^*+pmH$9QtEL>y#NZ04z6#5LPG-ecTgH02rmy$u2+VCjkm&4RiH3R!1ZqYQ?p!;
z0F+97%TYJMqw=;x7p2-9#k!@um%3Q$H;($fqdsudKOJ=jHd54YrK65T<5AuMN3C?!
zm5yq4R2PhW>Z6yV5{^2@QRh4A0!N*X3{bxpIBKJ#u65MSj{3w=pJI?#zbkrJYAwc1
z<!yD;gBbsm_Y+5LL`SH+B)VUve(9)j=--vs<fykD^&mP<b<ID{QpY>$E=RrZr~&9t
z)yJuhn(nAaFhr>9>yA1J4CO6#)UA#xL+7KeGaPk+qyEcL<IwG@+*C&`cGSR=tZS{K
zzUHV|=)TqOO^*7|QPT%l*ZUmxh@(Do)J*jD8cH5IPo*X~YKf!PIBJ8VwmB*oZ2fK<
zYN@k^S?YO59dOiJj;cn3)_5;;)DB0z@2GcAv2t}IE%h@;jXc%zZgkX>j(P&)l*Vx?
zhAE|*9d#MT73HmU)DIjr8v~5GE_Bq-Kn2nt{L)dcfI>A#A92`GJx{Z|vq7nkiH@4=
zT)*U~U5<LlQBOPSMMwSGQ6GTPkUw_RXO1es;z_mY0ZQfiIBJA*J<CyL&b7i(N#}Z#
z<Nb%DZgs9danycC{Q?x467uD3$NSJxpMX-WK6g~X8CK`x9aRcS<;opZ>0H-3YMY~O
zb<}Q9>i0QE?Q^ap&a|$lItp`jlWPkcb%mogJ8By!4f%RU?QzuGj@p3qs~ox<kGtEs
zGCxsXrQ=O?a@RZFjgGg^@m_Sij~(wb#~bO}I7&ci931H|ARyk(D0I|DuH$#S^w<jm
z8NVA~+u4Qt0SvRa!*{B<bY*<$UlfrZ!#KW;ly<XJ6pfyGcP2yGJB$a;>;j)y^c{cS
zF)R$fkm1I|y&Z&pXgJK1z<&rDbyVtEBZCA%hWPV^hLbjaX~<Ayh&|u&_l99{z7hBj
z<G*8Ee=;)pBJ(^{?<n)Rkzwuzeggj;lb>h2QPaR@o$L7HEj<1(TtkL9^O?Wm1^=_}
zR1GvfX{aWrfxHX0G-n3LOH681rV*S3vOO)c0p!jM&JEyjODiq23nY(h(;WN7GU~1&
z@1vvnDd%??oX)?1^|uTedbi&LBdy^KR)Y+1&Va4>|Bi3}nE5}B|IOj||8;ulE?@K$
z8yOd7vK-P^Kdb|i<}O%7c)GKf!LZwUmdQOmOLIkrc=-t!xke>-@3I`tH%6Qv`?;2y
zhINi-!oe#DM1_h5psOj|=vldt_am(n@g`SS;*&f1%NrLrEZC6#B#8SS$Qb)2kj(Fa
zj6UnEF=r+COMegKU+19aNiFR7JrH)|{2oZ<1QC$0I3_?wdtY_w_+L)B|K;~U{($yV
z$*wl~gC5!61NrT6tkKYdW2GuMp9bZ!z6bIJ*db<UKSo;lljcdetnY!$fLjjcYR?)u
zh-i3O-vi-MQ8nZ;ehe?`dmw`#@D64ouV%-a^*xaLG4$kM4sj@3u9NS9JTwlcH`)4S
zeGg<R;{65WGJe!A>w6&VwT~H}AtmXJ_SSUmjptNT2b?s*v)|h&9sOpixo~gQAv$jV
zr2960B5`lkbF^+b+v~pV%diumzUuIf*@y7?kff2VS$4Fpy8TgpPT;vj>z?hqyKkQf
zQJ~6$+!jL=@Re-;G6Y)p!rz>EJK|qJz)M!QZx&xgtyKqFtDd0vnQ+(<|MA``PH4Q=
zs@;354hq%0kD&Im57o3!XFxBcs)_)rzI}I7Q_H^=cHdUV7%w`w{mtf;E&pn4UIys>
zPbPNtn;Nzsy?R({^Fb!=fZ*ptubP_LWP6;!#P6JhP{#dk^O02ZK?&#;1cW%LU#jXr
z>Y^7@GkYg%>#L8>*7&+_=chhJ^fH97Xs4=`YTj4V{ypITBe>Q*CTChc>(Nx4YCb%A
z_YJuwCqLOH(<;B|n91Z?Yx7@?J435FkZfP1L2ZAt`?k#_|IwrQ*wm)ywjXUSf+V$L
znQUJUx4l(QFoz_+n+hebhpX?@%qO<*Z|W`@K2g)&({MM1Nu;PfP%BHU`HEE4amdTO
z)a>K-qQFoFjUTtZuAk?ad2svw?%N)LbgF9ic6^`X#qKw~4O?sTi=*E}LCii>&2JSv
z!VfV-@^kj?RP&3ivtK;&D19~`KJp_7JkI&qk!qGY651TrwQmBKMeus}?d!o#%{&e&
zZxxlpn)dk;=-~Exm^)Vat)~xep8*nTO5wNS10XdT*wN;&eYAvCSeHa<j+V3!6l>9u
z5=fXLJu(h-^lLLacm5y4&yRxIr&09NnE3gMiC>^N`-M?>{jLtyUQp({IY@l50!5!d
z`9(vKmw2aB!Ss7tF#TQ@;l8)?C5ZM!&Np8I7>n8DF;S@eV_keA+BtH56!-pwDDHh<
z3#H%BLg}CAK<EoHLFiA)aY_(QzJJ7uiC*ILv@5IwB31|wG)VXbM8Y3r;p+#J@Vp@w
z|9<EI<jOGk<hKg&9e{HRiT3Zkfl)>(cIUYDW)S}Gq3b`=0K871>lYx3Oz8S!G4$aD
zaqQm$y8Z!7@#W<$oJ0V+{wcWel@kM9e{dkJVeZoi1km;Bngw02%nayyWo1CuD=Qni
z{)3(jKO4GUxgDYFmEQrnzEqTqLf30#iA?DFGevB0PI_k>0QTPy1@P8?Hh{f4L;&nH
z%&~Y^RyUymVy~=@Aoj|SfY`qwQCH$6Oa-y87yHyK5PS8O4PxH~>)i|x`$OWn6A*j#
ze@O(y{!<ZM$T#QHAog6T#Re_O0I~0dsYE9r_9~hUVz1mLi(Kj69R`T~2nlC>2M~Mp
za#b4HGVSRLe==5w@^Wq_h&}!MI}rQx5l?3z_N#>78HjzGxO56)uMvG2Z|ed+#si4`
z`PlRzh`j}^_W)%7bI~Rn$X>a3Ss?p+kl&d=_PZt8EFgQ0FdN98dDkhBy^41NWX}T6
z2C}cg23jVNeYGf+31q*k8>KRV>@~C~kiCYL1!S+xjzIRGqa}3)WUs+y1KGbIiR}c)
zo^8BSAbVb3_<sko=Uui~_&)}+XII$8o=7dQFTn>f|8_Wp@m=`OlV;9T<g+01h1yGs
zf2bO0)lFUjVDMQP!Z;`Sg=6ps82sOX)0H$~@O_L088G-ITv{L>x>*Gxw<!pNPj`jT
zZH_TkcGDKlc5SR$d;>vOUK{}o{#s!Gc+bJ$e?vHcjEchGKPgPYMj06V*M%XlQE3?b
z{}LwPb1e+MN&!7L4TG<&1a#^Q24D39lrCRL=K-jJ!9N}wPO(A55q|~@zKV||OyIwP
z!B>eAWbv6$t~;|+%Vs*P`TT>^D^dm%U{N<_inv7z?=r|hwB8AQ%?Sx5C2WN5hEoyV
z(RQ-TJ`K=F+~=H_AL_&q5W^nl^f%{33QqJK#((Psm@8?&qAc9`5vRhN;UTyyb_yhV
zkoF7DBd2Fj22NMfgu&-Hu9c;CU@J=$248vEF!;(1bFXEH$4Vf06Dyb3Z2^P-eVH3%
z!r-$F5GljK;QvvCP*Z^K$k)aIgWm;HB97`27<^@+u4KXB4--+=k}Mef8RCFyl7_)w
zEG$-$Gz@-=@PNJSVDRq|&gtYh82rbC2k_-g7<`Sq6jjl};QvYl%Tc8>Veq*<j28t_
zB%_h(VVpSj-PzK$mc0#YK1(2<Sr#crIzXJ+9LAr7Mdg_r5qUbp{V&d)im5xD^4YP#
zy(_rtpP7^8-wK^7LM$a_S6T@EYryE~GsilHeYx|-{8M-7?wBC>Z56-F$Fv*R_lq|w
z$(&0E3#Z-A=|ks43QnKEh{E8%347u9;S|gZdm^WMkoH}_?11r$;U>WNe&Je57v}M`
zfgYrNbiAN@`g8EF&8Lu>2MdZ8g42~Wk>KxxMZl7H9{_0ZQ!rf0^w*%lGbx<^+Up2F
zglFy(yP&W?!&_MN2*V>yMELtKgD0q+yAK9Lcn!lN08E;_r|1lc3IMhinJjqDhyw4<
z@%9x>5IMndv)&yde1*8-{b+{>uaQL&;Z<KC*K~piuhN|&!mCrFBO<(%7SR6-FJ<~0
ziylFeyOJg%{3}eqLxle(rWG8~3b}z4EGqgPMM)D8z7dYvL#=RG6hValPw|WK47p|z
z;gyFWEdvq$MUlj?mWc@ej<Abz2}%^KD^jcLsMZ(dVOEC^BDf)RLs5U>pr67J1rz}f
zi14$8g?>t2sRSat%AkWXi12Dhzho|41y>hcDSpr|>3ta>!rv+!^h#+&_{W8XZpk6S
ztAgm1EF!!z&>f`_;gyB{D2fQL%u2y|%s_<iDocf_oDvB7RM1*9Tv#(qzi|_?C|~~4
zQ<*Q5$N8YnXTta_lvf!4DmdNQ_`^6$HH@=ig>e?5_CYVu3!U;w!HG>PjDODwP)!j4
z_hrZZ!gBLT!6`t-z%yz}7;krC%;tPLf!iI1#(A#g>MTq;Th`lrIzW;W_b`5(C^E$P
zYIeSaq6bKwE>agbDVCYUm~V#Yt<H&Mr%82@S)n_e(7TyJqMPuzfJ1!m!99%s75_bb
zvhtlWR(qC77=Olv$g<ODO()z7jPzttuD32ocQHhSC*ZuivkXLdZO{U%21IzeuwzRj
z!Yii(BD{L*1Q9+fW_!(*i12@O(Z1lKwTSR0;(xDr1QDKHWF{iKON2p$x1j+-2XUg_
z$Uox;{0Mw^XNRPS@bNwugV9^=$M%jVehEvT%Pb;%e83Ep3i_%(77;!^P&qz0M1+qI
z(zxS&3?h7du*sS}iU=PcGQTH-D1-p;yBft(q%iRDW8Oe?xY`2+;$z0Zsm}@`!pBcj
zKVBa}gtyjspM?O?0C*Ow0LGd=f(Rc!L#>5<1Q9-dhQ?py^%g|<_)vyrwH;=1s?P#J
zgpUu`hzQHVl!tLD5&PdE!gn!<@UmJmi14M<Gz$g3i$Q_E5m9w9DDdwv+9(Qq7e#?*
zK^F3u87T0%*fQ)&nkev-Vc~R;K!{`f3t;2;Y*FAfM=*$56nIl6rh}k(dZv$5Gqf)D
zk}6Q(uYkRqwG##YDjYs!p}^}lQzt0!>X3~BuNoL=n%9FXhfw3rP~cTi26h1Fyd7*6
z$qW>D73qiquY8Q@St#(zkD$O`Ct)ViDDWyVI12?{xx>9K7{%nec5Ie^BXXjfwG##Y
z3ov9U02FwgRCpEzUUMRi0<ZQ63cRVv7|Rp|e&Ar{3dd|kf#;qNai^$&L4hyqqw!l5
z`0v23(Qk3lI~4fOFw2m6nni&(v$Qk{yfT3LmqvkCEd^aBjRLRC9=R{EE?yhcP9PHn
zUPXF&UARYD=RZnCK@tW2>|?BwExyeog91MY`z};5f&#Arbwq(zei{Ydw0kszGzz@Q
zvE1)a&sKlBgx=fhV(#k#1%4)U>1M1%fiFh?(-8$;i#`Jdo?AMiX&MDyS(zyC$^&Ad
zqNv{CE2BJ$0?*B+PEg=Afer;;t#fr-`7Zyb>>~zcqrj`876qQOme`<6ye@Lf94PP;
zkh*SSAqxBo+#4|{@EW+M1v)_XV~7I(H1lm>T;qzM!0Wa!&_!o7E&{~o;J8*TKomI?
zc;x_r)1ts@8wVt<MS(viLG5}w6nM2qQQ%EG)DNeQkQE_!L82(|JEZNVQQ*}JFn>Fu
zz^l{gxgRi5#qranb&WNsN+oeEg$xvU^-=B>-c2ua{f)@5uB3?qzn{6cLUXpx=;r0#
zNXdF*MLmw7z-wq&w|GE-_lGj^g<cn}7xVmA5nMO15C#65xKNiyfmhYQ-~`*Ez?X~u
z4h7z}Wsy-7c$GkFMt|V}1zr_Mqrh*L5VBF=wJKzzz$-T!1zx$?DDcYdi?pRt;2%YT
zx><VyDDYRF!0a<9@UKc`2Bua71ztnxfC8`VK&$5bm|9U2flcL5;7vy=J2XInFOl|z
zepCm@OJkf?W}v_;1M8kB3j90LT^^_1X=AKito^($=G6<Jz~6v0bTd|>z`wvW2@3oK
zDPAP-TmWXRwbemu$2wyT5fta69#G&9N=RZO3j9mBkE-$B7uX(>rD#y#wIFfeWH0#x
z1)jSm973Zg@F_EZq*36tCRtqQ2Thg8K!MjB)k7zv-**FL9-qd3e%R>MPc!*@L9xV@
z(609Tfp)b3bWOjJ05JINA~ZY#2G9Lqg28t&uN%ZJ@ed*K-HerZ>tk@6+HF4obKPt|
zX#T8>ah}hP*kZ2R!sn6}nCm(OprM)97l655fdIQ1D>2u9iwoH}$FP{|+EHoGSe#=k
zSSIGWa<ehll^elaS4Jl0y7D^3Tvw+&?S)Uz(P1@>xn4DlDMgp+FxRz{Ez11^d!4g#
zRPzkXb(J8zn|{yE1LnGl0prbKu4`YI(6XG6qt?M$nCr?#_v<j%HSm#9%yng<|8<z_
zT3ItN*Ok=~bA7rbuoPvL#$10Nh11R2iMc)!7vvr0y6HHyVcil}tHE49LqdytUG#mf
z*dl*CymnI?G1ocZXf67On=ENx`A>6pfF>q==NGZzQgb7i>zW1>hG`>5W7-02+wyGN
z((%R*H2W|eHJIxf0HLOV(7l-70Sbcg+KAGa>)M59V6JO_fMSpn1Y)k+V#vl^*BCM}
z*R_geV6H1G8*^Q`8JO$J%D`M#Ru<;EGBYvPm6yg`pDZaYO=GTeSEM86x+bAA8*^QI
zjj7t%9B(?C87OIsxjq<0+f8l6TwegIVy?GIybg2yF$_FW%yqFV=6d1tY*fqqmGIk@
zG%?pl3_w6D1#?|hgUw;CD+fIhOVk7Ax)x`sHK0$f)_^GHx=wkbnCq^+a$;dI*Ik3P
zLr>q_QBt{0i|v<tfmqREE#|s1uvl@m>oR{Fl<#Kk#9Z%&fze^E+i?c3rD2;l_DYU2
zEativV2Do~8O(KMVE&EXNHEt`b+iZ_s04Fe)y%?NHxoZCy*F}ns9-~gVy-JU3v=Bh
zQ~Rmk<Y@jn%=MfReUYGE`Wh-Wx0yTv3Fb~WXH+<o!t$&GY%kX%q4X<uyT-jpO4wc=
zP+QnuTj&wkUR&yy$|u%7^i4*2#}l@fcR^0*0NYD1Cq!X;xm^quxOxlY{pGY|1bp`N
zc^N_1=4LzV55nfvgETw;A=F}c`~q&e=f`7l-OvXzE$E&;5C7APd_8iJ?KbXD!0#xL
z;#B~Zk_}JlDWVXVEdsm|kS)OTKM1Ualg7^T`%dGM2u(u10-?T4@T(yDU4|6+P?K{m
z+2lijbm+@5kQGZL7!4O_8V#4nk!aG#kVc_@!5cCKB_7Jm4BI&v_`^8ca46IFFwTiq
zH~W?^VS70zPQ&)v;<m88rb)p249JCXmUS3sr-AQQg43NlG<K`R!StRu1Ys(8>zjd{
z%co&_O$E|b&Tq`H(Fshi%B5j?)gFQA)dtu*t-vA+)5{LTBIdT6@d6B;4<8A1f{fJ)
zU+RthDXl^jsMkb~lycn|#_y0EVA{fX19ymQkEJgk6R4Mq92@OCvqm%{?geu4&v{!0
zP_OM}98j<AWh_vy+6mNqGh#NAZ;g>ay_|RJkiN!5fYMZ;UX#u6*#$yf>|4{Zt#LLV
zJH^nT2-M52D-)>K^pG0<Z7u<6pk5WgDi}Q(fqJ#93$_3MnpttmR!S78SCf<p)T_J<
zpkCGA0rhHOqt|pmy=F*=0`*oPrTB~*(#+*n-)dMniFA#LGvB@pm>sKd3DmnF0T37q
z);Pa$eIu~^2FQ&LG)B)}oBRH7AU7=p+~7djW@z*J3u?VThz-0Ff+wwa7nc0NTM!9g
zHcyg0Nq>k;(%TA8T4m1+{h>0Zw-qH;BevnxsSRNa*vK6Qz}o^_a0CO6wOu%1Rc+Jd
zfU`WA8pPV>B;?alYdrrH2EjK`5}0EV)zm+g;rv`UX<drRJST=5h)kM7V>a=n67(0I
z_hkf{kXfLAIt9N3LBs%XU&L?*WB3I)gA))<EcN^ul$jdP=a5_A@CS<XlUg&^EcX13
zbS0h<8%Zv<@A`6^cMqZ%>J8%!_}rd9hQ;?YEZ%>?CFX6y|G$AMY#cvo;j+c6R*k|p
zpq4i;Y=pUdDLz#1dG6*T(xX>o98_TzjNy{bkP8<ODY|$G*06}&ViykegS?%=y5e&-
z{_&Q*&3BD2+5X6b;iw6VgPzv}P2r+nhp+ud*z5P-`z*Zo!9R>2)jY3k>e_J2Rl%gk
zf@iVO;)kQcd5=#Rm2AE>m~rP1%1$lY|NE`MqE~~&HNgpYhWo?C57v)b99$3^=*J3?
zVDz9JkpE7nHs;6rmxboHsW{P4TogR&NAdBH+wwz3AT^3`$C3aY((I3L1Qd!TCUjGr
zCc}?n_%IN3b>Owd37fhe524m*@|7mQ2hq4mNgCf&atQ*uTmnnuvZVtn*_DLl0z5$6
zp>e;EwLgOKm~v^nCuALsd<2V#XUu}hx2xcf#xp|JvI55toA1@q$Q3e4;~3>8V4Nak
zT_X%?2idfeCA-#vb&ar-G+31(ftcloq1w9v53#Li-hu}z(D*9j_S&Y>6g?n9lQ9D=
z?2*lkn~_q8re;gYE}D#$e430>Jdn_WXq$=%<VOXxAWC-8yaX{o_=(LVnD5k#=69?E
zi67(XLaE$A{w`XWU*e5QF;cPE2*slDdENpLEEWb#)0P0u6Y#{m(YuK8#sX)_FhpiC
zX&WGAY<Md`tj2?EqoMVrp1znV0CKYV0n+*hX}#lZ=L~gJg|<qXMup0V3YAoa0p|hZ
zZ_MDfsksApWoQ0siMN)9DThiMF%rRETz<d9KdT@!0(weDplUFJay(=wVQMN|jd=hp
zh86+X>MwyXOui@7fKkWZ<C9^A4&RJ3K>jE)3#JkAI8{~J;4bkz%`gl$6R(Kb5OKv2
zP(2)YEN6ketjHU0mMKskymXks;7vKph+Hw`+}yGijDvTZEQjzOykHi!v)8xwH5|8i
z(ry`gONXcGmV>itdDWIT2P{wUNqAGhG9rK^yaQm_QIsYg=~})4A>qZ6EEdm$ElUH9
zoQ?CCIMdM{U-RfV(<SZAoJ{k=Po{{VH1S@MWlOSnF(%5eC`~*jkyB_M#5%+lp2zYW
zmxt8i$`fPf%IoJmb>)1HC$2oU;OQ!Ng?O^cNfi!KdFeI^SHhFjsGXBpd)mqMB9^mq
z+{cxK*@NY}1&3K&IGVE~E=%MrfRkf86ZUvUAba{;ecIh`PQ}bZo*Txxf5e4|+4JNo
z#q3UUerET+xbLNVSH~nk$xg=tQo4O4h)g2}IJ?KyuP%jo_6BWv)Md1-hnvZDx71~4
zXLufW>#e%njy0O`w9(`M4?b<ia9d3^<EqH6rg)$sY3JUyCUUS-oQnsO$FfY~GQ!$r
z)xtApTL?V0lDy@V-{!4O)OjLfIUeWrnz8E0?Rk^YoCw<)KWD)vQ&o;zj5e3KH*7M0
zTqHBO2^7s}<W;BmLmad0kKHv#MBAYz;KokY{{905hb!xDJAcZtC$&FUzoYHMb9hCT
z8|f4*OS(2|F};Abvahno2aea2hIz9*+aW1((0`9dWO0zJU+M1@cqp2A4r3_V>N?;I
zDX!4``3slLms#n24d}lG7ebaz!NXCex3>iU386TXMqz^YJ^T+8>NETg5^6fi0M!w$
zM7u>5^K!i{j=B{TDhyot5~0fd$?^D7B?d9LPDP0g7iu%85kh?()X7496Vxd}Jq&83
zP(O37Z-8QL>5Z7NQoxhzmE#|5P?e6F3JU!tc=zHTwHwsI97`Q?)JX_NT@wgQsgaHv
z<EXP8HQiC$9Cfp!x}ewAP<lD)3`Y?vTV3Zms?kyRJL*wK-H$}5k4GJK&{2mR^%qAa
z0b-y&sxkH`wa-xpFbXK|O-KC$y}a_eper#x9CatUFXf$xK253X9QCZDMxoDC*MB%_
z4!R@dEq2uVjw(fuq^>I+b)}<jcT@~QDmT<o%N_M2M;&%l3LP;lDD$s6Dvs_-dH6oH
zp?>SA?&#Rmwcb%h=&Y4D%~20Hs!PJUE_Bo?M?K`Iya873c}E>})Il^8jpGS4C#6nA
zBT{OUqaJe9Iy54!?N>T#Gbj`>(tDSq4m;|E;nsDeqbeLl%pnc04iqvSp)7N*S2=2{
zbG^y&ZULo!Z+FxK&h<G^nvRzorOP75!I*H60Sbj+LdgY{FTBnurch(+h|J;^^N`VB
zM;sQ8IH=Z<Ula*|A$Nwc5=8;vVz@II2FaB17snIe;|yZS`n%28(fvS%llJ*p5@}=>
z=0M<of&Y#{J#2h+5t$kIr}mk@Cyh0P8TfqXzvFM8VdcRLeD?7j<9gl5uv`M4@A`L?
zX*V+Hwjh(he@A^j1(!c`RFIh}boO742^w7(WGpI6S}OWxKkH85qZ8}oS7gGWp_-f&
zQCc~pI&i8waOQR3Ea|}6)PeJ*4xGC?aQJ;1`%`_M?!b{(@r{tmyqh62AJBpPAdda1
z%-=I*E^oYi!Kw{b1i6s|vEqe|mo_h+-*D-r{KBoV$*RN9+#<95MXULhS?jQJfhAWp
zU&?FXYa(`Ti8*@%KB==fZOybnb?fi{XDuu)iSFJy8!phUYFM4dOX1ubcS>OJ_O2DP
zh$!>$`83Bwxiqdy+l)uKGH?COU$k@uzO1$p;dhv}rDbqC&jnMlYH8Jayx!|vO|Y^A
zc1(QnQoigNWn7N!RcF5(>v|MnK39}!<dsCiVXvItIrhqFW5;yBUa3QuH%n?(C)g`!
zn8aRrYn@iTS{MmD(H>V_I{uea?th8B5~6>q%<SZ)3&_S^nKB;x-<*kDsqrV-YM^g6
z_R5XuH*c=?yz$qooHQ=VWnr%rp-b;S8*v-C5{gqU3wxy)v#C+@FgrHGg$pkWdxbmk
z7olkvXUk<_uN*;oPhN%3H)P9og1yqK87n&@2h~izj6RK|{e_74G{|NAn2s#$l^Y;8
zVQq$#gct3h>5Alf&zm~nq!FIQUMXySHFf=4aB1Ds`qQU5E<W>l|JHq<9^L+O(}2{?
z9DGuf<E^LPP+rlR61mCo(Yt}sp$Hu!up_>M(bOkvYTNH6CI)~=p8YY$Mg(#&)k1GO
z;@9kj0fdus4$v?{H8>o>#<_*ps_{uY?_Iy+hve;e0`sV}zGGYWq^iQ!*@s)J-bz&!
z*0jz%)LQj=`>BZb;`yz6ca--?*0%RIO1uDIkt=p2i*`)$tAWgMxOMiyWKFvdS3s7e
zW*=<LO;x?sS{HAf9Hy#XZ=GDYqh&YZs;jR_w!bMDB?*LZd@5Opg!Cjb$ked4>R|QJ
zmyyI&)j@EQ?caysoO#Q<+V=azOHu1Z;od4qmdU0gUxLGXT{FNxZ2l*Zl++2Wzu0l5
z-#UIr@2@jgYEnI*z&s5N3LFbanbzL7?T!B!j$Ui7&He3fUOiwmP*D!;SnH*Zp?dMh
zrX<@3sK;^t*!(9XlkAz$`mO5r5DxQFxykmU0%UR+iAOs2N>xmUs@V?x>S_V8vhy&a
zMC#8>-FA@Fn@uBA$5p4cw8QdJJ4^ig4D41qw#EmyzP@AH)Rt!}+xuw|>}dS#f{QQO
zGh~g&4sUs5LU-Sq7c{M0omkX>SBDplPr!9&C(a9(F60M;6AK#`EXPQYShHYB<K+z^
zzGUgbg&24f#zgvUewL$tY@C{!SPA@>R8LfoeM<<*x3`Mv@M=+dd#etSZ2$b9T2o&D
zs*TiDU;wekrQmVq!Pc9ZqGWPM)ge5GQG3Gr>Qqrp?a|qVEdU#;dJfn%(@>{SKD|>j
z_oaHEVzV=8EkXdT6U$SNOMV?~T9umlVlp+Ze#uVgQQO{vXj6jd(;72)I`55Kv{Nv2
zx^LrmSL&0Za&7w@6>W{p74)HVRbdq9-WG<<UtRlY%1u>0XRAe)Ku-zfMb_BW@$H{n
z{j0rI2k3Qg)jk?K9>K~6sh;^_YW9ItMVP8AVjV}amLZ^I`z!xoHWdQlsCDnM+}b5i
zAr<XU2@@Dd&E1e!H&o=7CYl<z?H0_V(;zzflj>z%YL`4u+5d2|y>6J)r8Lof+jWR<
z8*+Oy%*m6+eY*MO)a-r09-7#)yLT(7nJ)sBDOI&^LPfm$jSHl;y2OqCWZb7$!|~vj
zt4ebH<M+2b(`85R(c@mbs#oiWi1>!yy{_*al<(*rj{E%TkI=-ol#cP5^N{SE7b?db
zO(*k(%A#KWd)G~V@8M+Kk}ITSj(m=inMtgrR{zMYXe*`zdYbuz`qlF15Qt2u2&vhH
ztusLb4@sK&{v#J7jV2@0{guccC&Flg^r*h}9~lMlj{N~co*J)cof^Mr&rTCxRbeU_
zpVpd;Z-2SDFa@-#Fg3Ag|ItG`_wVTtUwvI|%b)w9{%>KgjeZ4X*qpkVz3=vyub!SN
z+5SmW)##(|_1Mug)JwHU*M9ns!7NGTrqBz;iD{LGLa#e|0GTi)nXIdAZ_;)=?r{dQ
zdB1v-it*Tg0ozFWcDQ(ZB|K8_YHK1RO6NyiEnt^Ylgkmy@ijHc)Z`hd@=KEKJrTp+
z$>qjtYVuULSEMekMDI3a^qcSHX(@n@SW|_!O{#7$N6d(2+{Klf+rdYsXg70Y7#wW2
zXved2Qo{=NA^1pcV(rq^P0bC<6Vef_Ni1EFSc4A%HZDAMK?8c01U4NTz1C0C`bvI|
zOkISrp*K3&)TY8zfR_77dAG3p_5o<9)yuqPJ|3^8zP9~8KSS;L0ox_I2V`oO)Fh@9
zs+pm(S9LY}`pGje1YHf`7bcJM_fD>4y3sq&LkBQ7HS;i#$r|9e<Gjk&nXm7to60`*
zC5&6>X;QOaZ+{*sOwD|2NBrDp4h8TwXC6y#=3A+WVX82!u4x}kHPC&<2SXg5+Ha<h
zW9H5QjX@<R+qsF(09Bh9PvyVVp1OHA)baPFx{uh`@{aHCMmFa?+bUcsneN+0vOV@f
zlq`;#Fx5N1CN;J`)vbEjiM8$D`jjP;uxUp7XvZ?zSdUx}SKV)&&(C$v$JeL%TCQOk
z+oYPRidj{Ox^ru0&90b{m{l=xMpa_SERTJBvXV|is*8uLNz_)&N^rSTHcZNM*vJGY
z_+>+?M<$vsT|VDgR<B&yv<f)>WhEmMhzSCT`l(elRf*O7z;fB3Aqzc`9X8~OVT>fJ
z{QIH&TVHSg3-e7%cW;Y~B*-Qr)d~1pU1e&*_LsZgbS~<Isi#FXt+U^1|H>!Ycg}t*
zx#K$KEJ~mSyw=I3$k;8LlV11jgXpQM5LIOux(ZhgPe?h8IABU-H%h}6L~=(9U6V_0
z$7G?teGCGe*IIRWE~{33`yh!E6R=dvZID96{YeUPsoa*&{qEcT4%X4;Lr0qrCzI7X
z;x(!B!yWNwQkYP^RlVd9$kn#L^LHxU8}+KD{Z-Jd{RX%H0wxBbw-C)74EayP3U^lh
zWnF999~K||Ftb>~m-6e|cL@WSd2gjQ9bR@c$#zn+?8N%^YsH~=>ZIECD^;c(Ldn|H
zMG{!evh}s?mx_a{Lw0<sn}G_)26T*MZK+5Vl@oF8aLevEf<fjERW35K{|i%2@@+jt
zvHoN|5_g1CKhvKeq@Z=;CF!B`y&YNoJ$lo)mi`CG(^N}4@~-8OpRNF{!kT-*MSB*p
zzplkRi$!=lD+ne^{ZW`NwFj|O8-0#=T^bY$QLONkinVT~Xlg6nQ#Ek}-tx}B@(#2L
z0}?A%Ce}1BSi-Iecm_IAGWjuk^lrr1@@F)2jLjitXkE8#9Ot3inN|)MyPVWT|J=VP
zHLVo%LQG&j24v#Lh{a3!sq!$nqasYEg7&>yS1^nx*qUd5jPk8%fBSDpEix4o1_omC
zYv#u_)jBVMQ2UdRp+ME)_nsGQ!|K$;shA!u`6jlYYTNHrXWn7(j$DCEXZ}ckTEsB`
zquR`()TZ94I@G@M9r0&V$JJKXwJ(9M);$b%YH6x`>h}F9uj#C0eadfrBegybo$HgW
zAGY^&N{>m^mLuV(pqN`f<a*@DP=uiR)+9xhy7peGN^2KU#?}a<&(=Q|LPaw<WKS<m
zoDKU9Xuji?KVuevjDGDWXT$op|HKf$$>0lBulvc?uhX%<rv3XLNmj^QsA@N=UYFEV
zA_;Cn=F}vY`L*pkAu%5~gmq6bKiapd2j=*W&kzQJ^Qzk~0~dq9?qqudsJZj&YWG&{
zhPc;Wt@2iNlRmVmKDF&<IJY17fvhabq&&8)ABWCm13T+v*jg828i9q5TXn@5^5{>}
zwg1TFY#JHkHEI{?vy|2}EvIK#Y$&Rl_9y=;iN<6jSw4C<3gP(Fq|%g^D({U9=!K-!
z$Q%NeT&YAm_f9I8D0hoh+KbeO!qlcPby4B=H&Z|2grxbr$C*c|FLAoD_d2rp+cD|r
zxM!{&nX0_=p9perswh=cibxqzQWj&#{r>7{lE`j8*ec<ns@Z&Ntt#xmi}d%8RU#gp
z<W+_352BKd-o1ZMdOq-2dDMMJ2X|AyIbHzFG?k+2s0DK{6_|$kRry#n8|Z#^N@h~P
z20ba|!+zYj7n)8Uz5Bg_RPU`wQQo*$oBEcI`|PR@k+iy_v)KwEHNqwW=IGs0${Nm(
zxl4_}ZjT7Gex&%BM~?dt4bS!$M!%7m%s@YcnX_f=Elv6Gr)_6Xs=O534_I-Uj-Xgm
z<5Tmeq8t0oj>$3z&OT7hwJ(;}yFW06zkN5>3{6kmP_S)(Q=hGGAB8SAwBpaZJ}kc>
z+_t~@J){CFC{!C+M4{#!t)Gg)rFCy@`$i3A`_b;()}ih}60`bb`vR~pXxW{ZPn_54
z_F3t;x^Fula;<xRf}Y&_+c)U}OZeZ`w3moXVfl{Qei#k7#6JlfG{4qK=%Eg^P70BW
zTc*e3N4g;ZU55W3!`@U(%{1y}6kIdkfn5rkW`Tpr6l<Y^Yj#cJbaqpmPM~h$0Lj8_
z_ONi9J)<z6|CeBID$eJy!i1oCo|FdJ#O@p{1{o7uk!gTUoOh=&GjZfyfDT|#u`eOz
z5W`c$8f?PKApq$R6P8$pny|!T@i)aXyukM%JtB$;s-c}6ji86$(=X4Z<SFS$VrW?-
z)6vj+YC58R80Lyk^hfuq0S4%tg1J(FqjJ2_y(m~>Awfr*ltCNv$D{+G^)#bI7E<Zy
zMhQTOQtAw&gt49(an1L<vm&mrjx{kD;c+H@V;x@%jnk=}Ao{{r>FGxCvb08Nv9rY$
zV&`bGm{H}5eOeLC*>fX7PmDUGgPN4i_B6B70;*OyPbl}a`(%?uW+JqhVlu#3r$+J=
zuIEO>h-x%#02<MBlOOPF&{-#89~!HF{Ng^o{*;(xKL6y)ht@~QHvNB(&HA})T_O}e
zcL6^vADAm8UT}W{gSFNfe(cwNSM0DlY}SRCEED`<1#Ub6o0T5{<68y>n>7dfo_I?(
z_Xq+3Hmka3VY4bT1DjP@8Q84K%Eo5BAGZ!VVzVl@BQ~q@J7BY3K9qq(u~{{;L?$-t
zViC*2W=)C$csno~n^hem*sL061~#j*I%2abKZ4C#AlX>yuvxDcRkE>J)mt_;>!b4W
z^&Au!zxNmW*zX~Mb%M>R{x6AOvkn*0g?z&<jm^4Aig-x|HfyB_F6S$*D|rh_-ZTF%
zUq!RAS(V#lF{Ip^0>EaSC*iE`fX%92u1aG}r9FM&{|il~6Kq!c`FGf?TM$oY*sOO8
zzcXysXT_ycY*vjZg3U_QC}Okb?qju&$F_?m*|@CAz02aV9z>aD;<El#qRhf&)yT4O
zS($I0;<BoEC%CLE>}*_CexfH6m-QM^>Y%T$)Epa|DJjduWYv(On5-JkAz$9+Rp^$!
zF=ckdWPJoJs54Af4K^E-^;1b`Czz~k+nr*v4q$Z+bC$1Mu{a@rghDm_+kA74IoOL1
z8B+gaOjdS*2355SP*qu!VSE}&J8v@nfU5cxaPmnLRrM#ZWT2{YLkXRxS77?p`H?Hn
zL{+7`y!I3{$Fx-fZpa`-u8rk&p>LqjSya_xVT2J>)p^1J1Va>6wON=ERMnlr5EzCu
zs_OTI2?#ois;W}`qNu9MN<gR1P*qhwz|jG+E{dx9l7u`w8&y@sM-q1D-=M0hL<zF^
zePm1_v$Ly=B>_V0#y>cvqzwKB0d-@hh+8+dfo{ykZVmW@Xm>cNP^}XZDk?M=PTc{)
z=46?D8lVa066eJHP$!0f7_M|q|LL4a!HJ&3_^nQWxsvuP%EJ9e;O0F94?tD@J?J9R
ze%>;2dIo<7C!aJ?RXGA{W$7K*$`VCYRbDo#s&d2JR~h255(uyka#v&G3RKl)GOA~y
zsxlj6QB>7kB7~ZfMpb=USg0$&fNET`#tTjil!dyIg{t~H5oImOLRF2UI~VZXG^%QU
zVX=y&QB@}hFN&&qfp7p{7(rECEj$1iW}>QU<fRc*)g2;Ojw+prs`_K$6IJyHGChp1
zg4%`CkZD?hZilrSOQ0LGEK-hifH<=`j5oug^308hJe}eGP3KO<)SXV<*s;L<dFRf|
z$?|W7-W4I160<8U1poP9^zfNu9m5_1ZdVzpnSbgoErtn#-wN@|d`!E6-5}nmBy%nu
zES%Omr~8}}DL6d@BZ{heGwgZXCIPDIPeB)v_IuiH(V?pT0dBqcwydA`6-pQ8eMV{0
zc-K6Rg-j2>2>;rA@~AmbRk^^)CrwmUzTuI3I;(fs<L{X6%B0mGsxleqQDwXanksW0
zvsN!}7{gg8=&bpqiKaRS$7R`Qs_Nh4cxT~Iy<kt#?<JZ{G*uM^Zj1#83HB8o5xLIM
zR6h_myu|9zR5gSsnyTvCIhv|UcZ#N}PMx5sN-5zr*1Q&`zp-c`lAKSPXsTOb$vr@a
z<9gI$I>2!(?*iHv744uPX=17Nf}{3JD~dEK4q~et8=4xuU}e!<@rzLmd1kRxm4|^W
z150(INMbO{#8TZU?4sQDEYo#GYQ<o7{wkcR2kVP|B<|>*%)q&!=;y*g?}UNLV5t(m
zGd2jllf_b18FWhqOI7U{wD9%?;eddpIzs%QH*#32mBPuuQe7%6bVd$KRTV^6WU*A0
zflermrK&9SLQyPLWmXDWQU;c);<ZlYL_jWv0Za8&iFStRZAy{gZt|BN11FNld0e;6
zsOD&sHS#|doI*DFFwRm9<7`f0oQ0@8R};O^sT(Ocu|b9L`A&dpiU7D<9GCF8>Wvhf
z2)+u>s3{l)ofxyZ8=b&?(s4hvTphlpi)B^nMh8f8q8-K$peq2Xy7M&%c_3kR6N(<-
z{%4WOgPW#@Wu{VQU>@b1Sazzji>#Xwn&yOV&J+^egvSLJ;=3IN(E0J-!zU}PjMbiH
z62@1;O*LZKX|xOsPS1dmo+7RQb`@?8x(<d|s#WM6a(ROaSgN*-0WJkts&wHbF^#3F
zoDNv3>a7zj)vTE9%V@+>y~RcQf{WH-shWuYz2XrpRd$e>SgI}&220h37RKK~W`yxN
z_z2^SKaBqa|Ap+1ES72^)-MiAbrUR6EY)eqCG=GhELG*Cu~aqg2$rhJ8i%FYRTldO
zOSP9+9G2?!hz?f)p+J1hAx3SmRMn5eQdO(NQe_puNMo^7)#|WRHU2b~Dm^<aRg+T=
zOVxyod|}GNIF*R~@32&R8Z1?=a(Wsp)iFY!HpYu}^P8CTEL_!|23K`F+<F>Z)jKE`
z#Z~R8xT-AFyi#=Az*XH1nS9d3RprfkP6!oOwGV6@r7f<i=1v4x)s&BEJ`_*S^^pS%
zt*3pd4Y;bOz+PbO#8o}BH=<j(bTvNmfH&?4!V~BgQ75>n>X41Asv5*|r!q0G2j3n+
zjXT3tRlzi_>VqPgfvc(_9dT8a-w{_;`4L>zA4r&qG_I;jWaFwTcevLRBbvokos66)
zuy*3A{s;_N3;<VErxy-aRdXVZtE%=0uBxfj7}pe6wRSjjh2yv4s&c=ExT;h@5cX#K
zFPQjg?H$`3TZn@|jed)Z-r=f_kno7ah^rG`>>48xrg2qO;|yF?)l$Gf(zvS1?2&s4
zi|^W)b_kicsw&dU>&gAiI)5b;D*#Dc)z6%gExyeogR44qD3h3htEvHY#8p*(8dufy
z0cZwkTvd}}xwY)WTK%ge^xj@i^Li<8Rl6Jmy^NK(s_n3M#8uUz&%jmXwv1?+##L2T
zCa$XTBDku`D39W*a<ixtTvbh=!&O!5T-_4B%iqR6q64m~Dr#|6IfID}y2R@#Z>0iP
z_3uorSct1S>^P*AAYqBP2JUHr4v-xg;;J5Dz733PToGJV-O>eun8j7qss%(Dfior2
zs&as`WpP!tjYn`*ufhbF>*6)58i30+Jg)XAuBvH=GEm1x$eJ)4SM?{-cGI}3>IJxd
zqR6zB0O(bmuv3lq({p)k2e_(@(i+C*Ud=R?#I+DIU{y7&a^Mos$6Wt3<X1jv!m3`w
z%v+%uTW7-da=*>M>WwuMR#ij80>%TZ>M18f4zQ{{Ev)L75L|(SRlOMRHK$=!RW&f8
zu&P(M#=O#tRR!9PPym!sSXGrs!>XzRX;{^VC4_8PRjmoxu&T<<hE-K=Hms_0`yy>=
zSk)CsP=U240IPaB-c56`syn4F0|6-ltE!=NfK^p?pfz)TOs%MhQCL;ekIEJeU{xEW
zd7&HC@$u3aXP6nVs>+c4Jo92mY+<aIWY2Nhn>NOd7i&MSr^U9r(4T}f6c{UERW~zD
z0;}36#ft<gtg7aGTx-WVQ#(Qg#i=P_Rd+~8Vk4~Tb$D-5<Gs%mEP}F~{{3dN3TH+3
zy=cIya@&L>XcSiU2~oK)H^EBzK%mvg;yylTg2}*C)$Gi|R8?jMrmEJqewxGI3+78i
z3GHUTA80o_I15wthaxmQf~m@N6fsqMViLhmwg6N0R;0YZSc$26m^s1C2jHoi%?Hhx
zl`+os*#TQTRa@#@)&fseyMDB=WW(w;2>Vk1BZjTE&tg~P+}a<dwGe~T>KyGSy&OO~
z#n$B5(%Q#tYszsgOV5Ftb8a|=5f>7_>O8)JRoe(?>9skUO$s463Ev@H;>Fe(W{;c&
z-0!uc&U(Y{iO;y;5+sm!HyBQ@9K80lrV+4AD}l4Q(Qq-fnT0EpHH`pkywdRcDDT`A
zsQ6y&D#JY{r@={X%GoK363LVAf{FL5P3nMznPzS_Omu$ok-RO&UXC~#kU?9Gy)tKo
z0IywR>^Mi0w6_@hjGP6RO>Ce(+YBd}vu^d$rpB2KYcBIJ+gKv)d=_$U<z-6^_gcf9
zW4KdRHlahi&IE9w;R4pG8R1@^bC;y)647jVqinUuZV=&M5Du9dq_<agD(7Jc2ZM0H
zw7PMz?m5KTjO=ZOxe{gfABKm6rWJKK#Eso-7&v1hLp%8|8|J-fW`(@Y6}!c_+=uvA
zIr&?2ekjr79IA2ss^tw!G01&I$|)FxW2iOAY6Am$TMmalIfh!p8fDnG8}<_rCS0ar
zf7P&`!zT=DuK-~7*K*htf<Z5WF$-^1c(FSS=Kwx?cwXZ=GXj1+hdn?r=%C>$9)}mZ
zGv_iiP5EMA6L_^v4GU0OyK<fo^>IG6v7)(Y33i+0ZMWE6CU6{6t&!u(Zy1FR`#I)q
zjk+dQn|n-R|BU$R^!l|H%)LgD50R5o8<#EyP)h9ECJ#Rbx?&mu`I~5?1rY?~i38AP
z(+J2qrLYLdb}Yz5Kvr%x0<v-=2*}FFL_k(vrwGXEl&ABh({pqJoJK%yl3I$%k3&G#
z=}?g_c+SdE%`*^?RU#7sS;YXJ=Ma!}){@YkcS4R@2WKH5D;J0B4gpyM9~nhJRu*PT
z4gpy^z6=CpWpzYA-Y5wyMOmd0kZVvl1=dak<ee<772tTWFUQRouVdgX#%d6dFP6~a
zUQbg~7x{NGEVU5<c^TS=_WS>E%NmP-Y`SYXGxcI$#OBI46G1>$0ThNAZjZ)vys{&q
zXGcPv8Tx@{AN$S5MOcR$=YF|ceRTXmz}CX8&s92iiw8Q<$^bvsK?5Zq2Ym!Twk41a
zeyrMMf*)(`$^buBRyO#tax=h>m6ZX0tgI~XV`XN7A1iNsZZ#9yJ6I<PEtO5{Sf7A<
zn6W_^6m)!+wttMtoXXts94(IxbWESBQ-R~nQ~;l-!otIgE%ph%T149KX}Yr|{te(2
zsEruN`(afK<Yy&*hk?x9lPCtV*cAggk8haAmioVf-+a=8V-s?(AB;*Pv-{FqJB0=w
z?zx27EX%dkX65pQ!a3V;unEz)4s$IXv(CxYF$-63mM?VNa>Ffhpvo1-H)hj|SFBv!
zIIWpW_=$#loK~GlxmtD1ys0vmJuGUHm-hs7XPN(HXq-=)5YFcfK|Uyiv+5d!aJJez
z2xkpB)GFL3SF3Oo!dX{WQ3z+(;c$Gj5YDd0vD4hXxpP!Y?Q;6%J}XvqITpfM8Q2#w
z*g0P8GXG*IUtsNoa6Sz~kAra5)`8`;g>Y7eg>cqt7=dtBMg+oHRY#N7NwGjUtD0F5
z&Ss6N)$xrSotb7sI4d^`!r3HKQ~etmBC+=L0)?u|8BvY|r6HV|yg(+1xhKw}i_kb?
z<4O)6HN`ef2RLVLgM`va+8twuaYZ<1-fOXN&b9(X;GAs@uyD>M(-h8`*T*`-Inzr9
zoHNg>paM6I!uV@l_)q0~_`~5}w*<|O`mtd2@OfJ)&F*#~8YH|FgR2|yyiKDgiMZ4u
zK6qa!y|<`my$rG&w@Bgl5|QHVA(fId7wRdZ5V%$Zp6x_{7Y`utZ8&M{e|17GfJlTU
zA^RZImkI8I&ZXb+NP&-pajhrk3<!`8eL0}Bl8FSP;l7YY!(F*ZlG67dj6$Q}j(Z3w
z@laNTIIY1fCXBN^hq7%D#<{>NumEI)bLLt+4d<+7i(U}b+lx&zYe0VPYm)@dvJT_y
z|HAk_a0<CGY<Fk{r|h`c8^QDuw*Pz6to;y$8DZZt{dQdUR(@lwouE0ZE@?DpwHM_Q
z<s){;3~Rm9u`jY%&g@B4s@+Io>ZVKZBZ02T(@4%5Dx!}fIh&}FNbXeO8_be;CM%5h
z<({<dxD+0ZNY30>(Mac+9VjzzxIpe2alM#<<7~SchvRI!8jItscH%fcjd;y!U*jW=
zGZ*?gF<E0GKpt~|X|j7j@HrYnJuRvmaGcq0>_ka}B91fruS^_g(@kplx48tQahz2k
z)Isj6W(%uO$AGVy4KCTajlwu<iZWrGm6rkIteNj%oVCY|!Z@2@0SmO{Sc75_dw2XY
zBvfIXxxLf(N?2DQRjv_nH6O+~iSNtcxsVn&f;pdujz_p$;R&~k+PR1mdjX_45d<>2
zR0K{G!Z=6y6EUfBlal7k8*x$1zs~o^j5Ns4*RfmapFo@Tuj5SMq>Y@s_}4N22#$O`
zwMnd)xS<J%DSj($12~`YZ{T!hU}Bl)?;sO*(|ISDcPRD3g1pM^`8B@Ws`4)eIND%r
zDfqQMV;sWChd;|_ltVbD@@M;;Qw`?PJuq0{+w<#u9^MZYfN9UK_Zj0*VoT4JFhP#-
z{CPqTJHYTR@Hr71+MsE;(C4}IQ29WSf0242R<-9}EPLxiH)_UkUFrGrg*Ut_^c=cz
z^2*hhH$a0ced!wq4&`=|=cgo)fkX9_z~7<4tdKJU|0azAdG;kEhP?T@GFR}J!oO22
z%&QR=nw!f(S@|LT{x-zjUlKB#>F`cQ+09y6hl{c+koPZXPSX25{KIc}F|Ot_Q(uxy
z<(oPq#s5o^5tqY$YDG;=#oYPlo;Rt+^I!JqBd3^!fvO`v{~iBxSVyhL->u}7OvWE$
z82thM{8xP*?B5S^jI9N)Njmm|h5nU=f7$}Mf?+nN{9fYzFkG)d$^I7R+lcmbD%zWc
zKM>qAcq`2B!|Wy8_Zi&C@{i#@)@7j1l$|U8SlPI0^UmVNm4BS<TeZanUi<{cJ9dSZ
zomhzcF;1#dU)H4iU@iF*;=TaHSPT~c8}bLRTE7GafK&D%2eyDb0oU9Q!#r~oa^d%2
zmV+_jGZ3*huQZN^QVT|DR}fzz(HF#%AWEKtry_EOf%6s!&nrWTq5ViZL&>3VSvCo{
z5p3Zfc)p5Q&d7sL|0TBn(*guE0sO^y#%}cdSC}K!;3igh{y|A3^X*s6w>4lxakkw9
z5XYMz-ko5rE`j2+z|4(<m=9t+hzaXJ#M<H$ZV)ppy$$AEIGp`mVO&`HILzn3DBTa@
zbGp1LE^|tM5A%40UV0CRnIO)&4Dsy5GX!y!{uA8G!S%`$_$%#(n!|i8A4^+5*zTp@
zlR@kuF&4z1L6kg&IJ%HC37k`NLCgeE2ZFx}+a~5~ZJK|%ZhiV^Np&iL#~M6KA^rxm
zIFs2jmf3=0I!kKPIOZLae3n$E@v<q}7Mi*=LF-cCzl&%7T689pB&tgg%~m{jBdXfb
zCaTJesH!renw%Nc6cd$J+o@V@i@fn{b~_R7E<C?R*jFIz32b*rfj7}6pS5Q8isdV@
z(}Z5@F33KMr$-mhd&KH;k=5k@^3A_UR-bKgZ_)zvzWVtyd`Zpo7sdPo@Y;x|8sL58
z7}HxUiqZe=V4bpZ(V{ijqlGA|8gGb>K?k;2Y_Gyro<t0zC7NY1>6Ai<toQuOV!WGk
z5^PzjPg>rHeM0{Ve-)zrBOanFZ$;E+t^!vUn{D1W32`+8+zRLNB?x6KBHlnPZtEDR
zTzJy`Y5y)i0mb;*^0RpQpXPaINqf4R?Fl(~<|=jyqdor{bVGGe21@rHWuQhxJN|o>
zTR3)UC2G{SsKLpoN8=LE$^SMLJ{Q)ptZw%)->!!ZgDaO$8D)lyU%F<AQS!Hb0%E-j
z&~w7XdqhUb-#R6$RxI@V-x?Li$#D2PMwXLrB0I#$&W3H=G3+khW)o|oRr<Jh*vIjz
zW91g8^AS=ycB6h%;Zq9kXDAzWi_QOxoR7(oB>oqZNIcN7Yd!yS&NND3@yc(*-<VbB
zFNa=3WMDoY?9sL0`a|V>_;T8%r45sD@vE?pF<tO*X*oY(Kwed}Dx*8(+6`^h_Y-hF
z56>5Pnvo}yrQpW;CQ~|itXkjH$ZVSE`$>4=JJe?sdfv;<>qP5y3M$t`-{j_0{X)eg
zv3F_nat9sucX{VVwKDS*xg_X6q9f~W1iuo&Z^yIg46EHEHj2qoMvq9&pjM5RVt7<$
zEpNle7*0%nD7kPH*2;&G5sMJY7@cxFD|3aJT`{|0P1+*^wpWsbDB~O^W&D&*H#$*O
zuQ>YetEQ{qgOM~KxKqx=t6vQAeF+i`V2YIT`=SaIor0Zjan>#?oMPrv@5_8D)>bH*
ze<0#dBEZp-&JQJ>M`@RY{#6n>9943(sQQtpDm{YB*!gCUdp>7^o?jG`Fg=9P2mW})
zZ;w^BNV*^@yHT%iLPs2P!H?-!r>-$AsfQeN1#O2niJrZrYdSzZM9<zaHkzI|ww$UN
z-A8vp@x2D87kg9|cqNXMR<Fb~V2Wy%Kqyz^nGWCeXPIoA;xv<NoFeh1vvG=1FcfXh
z71wXWziKm0v^fHM`975YXqmU1FI{ENA~uZ-o#fJ{f0Zi3>y5eaI0SNe7)hl}uX4)B
zT=y!g3_IyfVrhoBsB*Pfcd2zv!=lC}By_Vd_k*dExh?Xx&2L~Y;f=@_@o49Mt#s~v
zdmu1$?$?RNXTg@GvAaU*e^s?Eg2uz}OoQxXtMyl{)|tsQS5p0Z)N2X6O~G>wyl%B#
z@9EsDUU>B%R-Z}uYRB^!e12hlK5TtXJ^-yDYDPuLobO3K@E+M{nHzjxPE1$9UVaGD
z%+6;;WII?{X+9rcu35gaA$?2MKOFP9NdFKj@FmCZ!cQL7L{eh!S~aGus>Bw#{|7x|
zM>EuQ$R8ydd`4$7cM1IVn5-V#3bp?HN$StvsHddjJxN7wFW99O{yD~ohQdBZkL>-w
z$dP?5Ioj*JALHy}jWBS)<@q0o26vLdF6u*3;0anc&RDswakWmN|0>PqBVl{~N3rgR
zrwAK080mN&GK_N{r7!;yaGB;!zZmMruIW+?o9`F)fniw{X_j|A=8Q4#5`^<_K7%9p
zXT{J9I$yCI2crL<zIC$}?;jQ~p=S)7m=a^B@j&439CPWIVC$x^DM$sS!QZbcg_(fa
z6zm8}M+HsSG&Z+QD5;+rJEd3f#8u&)JKyYkS=+7&qo$XI11FS?8h>`#;&)#Q2e$q6
z?kj>{dtvF$vQtORUArsDYg)W^RM33Q<68$b-u-Udkx{|eSLcih&lz>nw%~<$SR6cd
z<)UrD=iF`I8RQq21<j>F*V14O|7Wc~sjPY4_|a=x&l$HgoHzdL2j{LS3Gx@+6}AQI
z9{6rJASl>3VOKDGXE5ghn0bq01AF~_I=;CB^W3sg;q-81uwhZqKYTS<_(0ILc*g$6
z8-pKgP6R*4Ec&POf-61>E-nrBZi)@{7f)Eczkg5|7B8Mq)>yW<e^3yXmX<Y7TvWC$
zx&6d*f`0}d?JQY%_Vn10J}u7;NrlI^?fPl(#g$?4oU*bR@7}dGENdLl_}#M?J`oI!
zmHRuN9#L^m*lTfc{HwvTYet<~cK7sE6~R04!@-?b?u0o9X6b{mF}=dq!fyrZOK*7S
z)Ws9R^MZzJg8ofGLsM{C>_Ok(IdT1hZ)}?|s-<kgsPOU1UpB{v^$zlpWor{be(8fu
z<}o*d(ev?^bIZ298}<sf{XRGbCD?TM?D1uz_J;$StAn`@1cN_n39o7@Tl=M5i<eJZ
za!>eBu(7lyyev54h5Lq#ShOtY9rg@X%_*y{TN}I{TNK>4skCJswAuJTupvC$zbxz(
z6hE+YIebkF^1^AshSIW$!N%g##{^%C?F`=CRC@E9W5-MmHavg=$)EF;r&m@kZViuJ
zb>4|f*Q}i|J;-m`Kezt6n`SKj#*}sQ%7P1DeJB`M%8Va4Cs=yt-HVs32^Kd6eT#z=
z!ktaaP|PJ~oi=^@^ragcZV3`iJ1goJj}F!&+Pu;y=T2`3*1Za<=JH_e1Ls^GCI{5d
z-S!Lq1^N4Sq6XZ3{?mWk+I;T(<|~6WEb?ICoW=D)ziIc+oDv)hiLQ&L2Serr7v5Pm
zeepS?HiXkBjA~x|t92o=c**xe)aUJO%T5lP7cZGGJ(h#^hql|{t4t%=X3Xy%m|0(C
z+K}-zrt0FN5+nOC%x5~v&n_;CeQi(03l)1So-d5Y%Zm%Edc{hOpDk#nU+w5;PI1xv
zXf)mM5`C;j13?(i3nV{-NT7kA7x6!_C4OzNu(;?_$}&2*O{E}yTp!QEla-z&#YO9j
z6PuxB$0&bolwh31!x#8(hQ*cVK$teHc_yxYbi|L##Q`v_``j#dF8MH2IQQwseK0-a
z$0c4y`1ur=RAAF&%ZO{aTOe=ancR|dZTz|*R*B?PrZe5ch$ufUz}7|NCBJ4t_*_XT
zBPlQTW)z5Dqf^rO<q~TS$}20b#l?w>qGeSu1HrvsoS2c3chl3#AOg>YiIouUFl2{$
zC4zVqLBL2BC#Dw{%}s|#t)>>7UtF{-5<w*jCt>vjjVN50l`TQz9+PocAjywQhuIOC
zik9GV1jn!|3NG1G0rPpA$6Nz^*UDCQ%|Un<NOA0`D41Vd)R@1A(o+h`C1lUzO#Dk$
zeqz@gQzr9@i#A8{sk}H|)y<n+Ftxa-Hk~)NUC0DEk}v0Kxo$#+P*2;KrWDjiG6CPj
zwmNefdvQbu=v-f1w92U6&8sMwDO%fl!I|c@5qVpWDvFC1M&hd|NNVIvv90Tz@9~uc
zsTWha=A38hjdkawt~2*J@WUUcZnweAs#h_T{&^X3PmZLuqM$azHZ`3otY26S%8&E0
z{762Ubj{8PcWH4EJ~ekPzna7!#4$hV_+_~&;WvjgCmR`>>?5<kEQcd3gp;H(QOH^=
z8Ts@Y9K1f_T0>)!kacOnIxyrn4*zH4@jb_CfOV0uk~FA;@73U6ehlLRJUQMKIb#Oz
zQl{szhyETOrjF(hln!YwN3xj;npX(j6sKwE^$?LC!*~i0Qb%JcM35vJD%mDd{G;T{
zc%T;z<9s1V`K6t!BhI!`c&|a|4Lpd426uoX-%R@hSRbk@jUnP%N8@ZElVHm4FZll#
zo=E0wfrQ*mK`zj2!GjzLY3>oaIi$(GT;>!_LyLJl#t`NdO>PuZMkCYB<8MM9T3Z&s
z1$2i5wOUL%<8yQu=91Wr2iZsCS>dnSyo+&}kNep$ZZYmT-Z~%UNr|80F;*+}EwG5i
zjmT*n!Go{8xg4c0^7&b}-x>EvmL`yt0VX*#2PqxW)DQbLhcvls9ZfR*5j`ET(pWB}
ztEb$@COhy}9rj7g6wBJfP(XiWMk3~|5=jcgytN{@7<8n;a0GuzoSWh_Ur{=w`9?r*
z%^}S<g>H(|G_;sMLOD@}=8uJLiqqt-Ir&y4#`88FB#Fjr2nJd(q&!H2%!dbh%F<20
zidREJgG_&FZzw!Z#KX*|c`hCVPh&eC`92|uoAB`4f;1nq4kQj(3)Nu!49V(|@p;4F
zB6_M2c&qmbu^2v3&<yfxN?L!B;{O~za>O-B!{|T5W=R2fC#o|IYJ=X0x_qi+I!IUc
zOeY1YDJ3;bd}`4Acz{5qa=l<DVt4%a!DB|#-`8NWh$8Jb0qaO%C2440v^h=B0Ix!w
zY1|}aJ;R`6B*hHp5<HBi6{bqoQSvdvrpeO@BsGMg0l4)246d)?fh&#Q3Ynzwu97yP
z6y#xw?^RnCCy=A@uqDwvP3e#(PghtSY4Ug@+S)FGozM>C(OjT(Nb@S8n?ssBtBCsJ
zgtN`?Xx^-JNb^pin?ssBhlu*)MD%XMqj`_gA<ZX+ZVqYgR(_o3Glox-=M>TKIAMLs
z@MylGbVzeyE@hiTnmnM$_V+eq*d$>zz&YCZz<OU?YiOwF^ygXI!TTp3mNd<-;=6t%
zj4~x{vCuV7SalRqS6ASDz~V=^poI0n3H23ts4LAiN{2KL3f&yiJf!?M%|94EO`e8C
z(|INAJMiS-JIT3&%55~e!1|7emh7VW13XCoZWupP(n@lcJ^&8`r8!9Hkmf3(n?ssc
zC_hefA$mT^c$kesH^phLF?^alT!|{W6aK!82YEq5y|vA<YFq%`Qarhmj)Okw6?o8A
z7~`b~4I~Zv#Ft!?xp_|vbX~xD$ZW-fj?K#@VZwK_2Ogyiz$3|oIY{Y{CP5&W9GVXc
z-4v(ESF_2d`Jv&{<dF>dR`+oTV+kIsJLzvh4hr87<4;Qd#rOo*dQ2LRqBVUj6VZD5
zdQZu;uX^k2661>l;7ZU};fZ#4ux`S`%1d*nI45cRT-a+%8U7v#-_^^P;q<CX(zqM0
zm<wFU=s!2Kjh_%38}LMG^*iv=uD)rUD6Tcub40mua2c<DY1n9N&~Jc8UkIA9<{+aZ
zvHS!qsvUT1Ulf9()RMAVDCsu*xDn>m;1$rn#uHIwFRc6UV4mUcBJp!^PtrJu2lYhE
zUnw1@$soXY<<6t10a6#xbYKorI;1&MX!OZ2d0Z833S3N98y?MCr9+z62;CggY*Buk
z=DmhblV@1b@VMZ7#_(u9uXITBu+YsR&3Ba_r#S+PPS#<XB|<mFY4RW`TDRLF8-j<S
zXgZ9flD51U^C1bfWEVrt6W=AfXcmcR@?;njm1F>y;$h9Csd1&hi~JcvpbUz1xs72J
z>{kd6{UyvbN{2LmC3JI0^9|+4Y4Xc~EI*q661q90$>XkQzA@~lgjceQ=1X``-5A72
zhE4NRp-1nc$si&%@~g1kqbwRP3t7tm{-LBz#$B*d0&TXG=95CNDW&M2@kB=YZyV>h
zw`QN0n-*|Qm1}(;50gSOP&%af6QP?!n!A-Br}>8A(>!GOG<m2NEp89I&Ej6Ni{>>#
zkKRS|yLixf(RfVABn=HAJxS{a9*-z(XGppU4}4PmbtT_~k&Cz^ogud%28cRnO)v*3
z9nxGObaO~^rSju6S1B##CZU@{nmmz<mNdg&AiR=YG?(E)G16c#AUD9c3Qypz*)0Tv
zh?F#ONO*|}EE<;!Sxe9K6`5M_y4j_|as|fClC5~C5zQ8*Lz;gTx;dozk@Dj-bFdM?
zf}zPHy=ZD4g8QQ)Te6GCZ@<O^4a7S{Bg!!5j*>}AGSEo+{$W^bo3_$^#rW2ueBEbA
zAK*cuF$7}NfTY2|td#Z5!@-~7$@kXav*T;MfqDNNXx*MQZjla|yFxwiFrhS$Q#zzM
zROsfACQk~ZnZezn(S}EJtkNOP$wD`WG<i%I^~YVLYQv*ht8_^7he9`pG=HT0IL+OL
zPm>@h43Fk(hEMZ#!>9Rs!>7r^#_ag-6JE(KnhYQ1K|_Nm*+uhr%C;GIIjrBtgBe2{
z^Emx&0HX~L%Z}z9co5XrVce~xmE`u;U-3{8ntxL|q}ij0{N|7*51J`MlgE?ME}{?Y
z-1>@Co`Hsi!F0E{og?mUdugz7kJCMuo+%LXR*Shsgx&NegjM5jyYL;*8h?6Vr+ZiN
zlB8io=d`Cq-44e0!26|&(qKrD#=*>BV9Yj#LOn>+-2VSGcP`FV)K?te5Spn}Dr&U8
z>V!9lhM?413)KV&5*~(#6s;I<$V~)Eat(=!qJvC3tq!#~#SRpFp;V_Gm8q|3#fno~
zpHp>I)MBgFCy3UL72BcKe!su-JKwv@@&|O8&He26{9gOG%ii5{&SJ(2@?%p#4R0D2
zTg=Ljn*yHY8+aBL3ufg<m!Vsq40ltw#8<S@=gu>VW!=^2o3>vI9n9!W7L9aD2%ewx
z0!wMp^^4A0Db>8H=th+iQ(jRcPs&)*zDRUFN>y@y9Qxm6<>+lg@0ye$?I}aAn0-y=
znL;m=Xvunk(BosDD(;3smy47sctg<hA*IRRfW8GOJ-QOmZ6KwZmjFEiQey7$J$E60
zv*RuVChklg>#;^M7(WV)TanZgZ=h$AnkdA~o&_l<#WKtj85_V06ye9hRGk@t`6XRQ
zCFW#ciOXI62qH~(rWC&4n`s%n1ebq@>sVh7@8*6kC0K4d{^ao@$n6wDQ-|R4%(dX1
z!%SN)q+UDD99k~3T<fC#UPJ{X^Z{@^`eiaP+ddNWDY;~gqJQ|@Ai%dTVVb3^(bGTO
zkh7Gl#mr9a`yVc|@p+qJwU|~eE%^AET7)lQPngI^Z)1N03#|yTWs;|0WyU30nQoa`
zix`u@j71E0>qoXCru<-LB8F`;D-k0Ekc8+ye5Buo&MZXfWrk&VrXU7A!J|B+%3(MR
zm}zPld^5EzVf0fBh-YjKLpc(Ld3a1m!UP*3!jd6Wo;reY1u-&>*%mCKlhHKMEt?Sr
z=2OL>n;1FVFccW$RM&vb4U3@!fx-!jo{koS$gl#v1)ibMj4+UZcZ)KR$3xo~_hk`b
zj9&;rU(9ra^<!e0xPHt!9ru?ayb7tWBa>tJ3NisgTo>l{iQB9(wJ8}IYiqz@AP*v9
z{*bV>m`cJn%e7i12F}F25~71<jx8^TcpYYV^4-Q9F=1~o;Klcbg{d$BiYv*4<9t_`
zk=Zcfu3;RA$GcnsjvL>~F-+L^2IITqPGWWj+jHlqwl5<h)7zc_o?7P4;l$^1cA~=>
zFHZcg)TeQPTFiXvGzs$r%qL>@iMMC(LRG(|>iQ69yob84&KqgNFb~JfTW&t_p4Oi*
z`|UB;e~dd0yph0LGYP)TK5fDBJ5l4^0iSk*N8&qPhq)QEPjhim%3lQhQNf=BKJoJE
z9?X6fw*$<}vfpCfirFW9>C-2V)OVm{hm~7XXUsy3B4OB!o5TMBrFe+D7*CtN$dkDz
zDPilXoIdS(VLy#`TUrH|?Y|7|bbJBn137zHXHuHqhbBYD8#NsMyXaV2=v<Z*Vo=HA
z`NiI4i+j4uhi=IZv{E?C<Emv3t3pQyJe}cP7`>=7C%Mw}-k$zagBg=jJb>eP&n}gU
zNbC^2&XUW6-x>0EnNMbj*6oDX`t&JNPOTY(R}PGgZyc~)v;ZHtl)!sipT%EXIe`9x
zzo!J+i@!XCtCOJ>xJebL3H0qi^FTbftCLM2Yh{P5bV;yspNpFCo#8{+>f{3uZyHr4
z1MpQiEoh9xFm1Us24a|YyR>^j*7B30U81r0`q+AW3uJY_13EqQQIxhs8m~>P+@T;F
zO9Q@C*2h-STwF8MhgPlvH3ZrKniA+0(9}SmiRPo(X+gUXWPKFz)wJ;~2Tc#w$3SL%
z3S=XA6=Z$vmbDsRT`PAK=!{Tz6v#$e3z`wM$)Kh{vp_QgeHUbP7lN#hOF*-N^=gof
z>gUq7N!t#xz5fr8wQ@906V~s^Ak$6*HHP*=(oj%Ua=x^+pxMFtmTK$-*;txz`(sY9
zE(M(#=n9baaXqLxXd6It1N{m#Ind)Et8p4mQnQ0L38!P*ALoKvpj9QSK-S)Rkge~X
zApTaVPM(qWSCAd|T{w2FkC${D@NTEAC8UIB#j0>r+cw}nGh!KBtiZYne`^A*$8l=3
z2*;n%Y8-V&>qOf{Jg&_8wrH1VkEjxzTDeK0nW9Iq-^}{7h_{MO`?u&|{6}Eg*G0#P
zW{A!a6-DP@Us~Ows8_T~be(8}i1#9`?icv)!{`$11*5BQ{b+QJ=zeTk(;gMA!bOE?
z3vl^j^s=ZPmr16r5bYG*kBbnq9`ZG(p`trQdqiKtwTaajBbq2`5j}*9Ei3oBXe2IO
zOe=|Q6ul>^KibPRi|!CTAbLr3EUrzg<pz8hEfYN?>Kp3TyG28Wxi(&O#BkR}i)M+w
zC%Q;<spu)ucF|j+B_q7$<)UjuH;7&k)sFNUyF?>Kx%So=r-5UgCW+caFN@w4O+U_S
z+#z~G^s?xqabE72<DD)LEfsAMEkD7_tq0)?iSxmYqFX^Y@Sxo%`V9!X3EE@Q-UM0Q
zcR<Gm>!-5rmGukJz*=wRAdvMjOw<6f_8LV^vYsa@fNU%mNh?XaT-tTgel6`mX^%?#
zBgp!FO0+}PcctwTeI)B%(ShTAjSdqXD;f^6K1Pe`WSu3gSu{`9g&<qsPH9V3t|Yor
z*0rLWWxY*whphLB9u{pEy(juuR8i+^IY@L6$ky#pQH`vlKz3}5mo`z_WND3}Gez@2
z*75>TLDnUr>t($`v|iSGK(_rJ7X3%%_&dn@7znas@+gqi7$ce{S^%;d=ZP)=S=}E=
zTP<26>n}jo^5e2TEqYev{wDfVRC%KJ@nw*0)4?EX?+95(i5fsQ(ne8}tgRrcyI5K`
z$XdQa+D4GIa*OD8S?>Z_E1ydnaFS~Wg5ow6)q||PX`&gjwt%d?9?^1He<)fl>(8WZ
zkhWRcFG03Ok4Sr7^oHm|(I+6QF>s=f{s54Ts#@BS(nd(by`#9kXM=1l&k-$@wF6}B
zt&w%DXr0R4s&b#m`k832$_@O6w|A&$nCJwM?S)CAdXTN<d}*B^8}mh?639k+qqJK^
zn?cs{9?@Qq)u=kztzQ9|cDS^orHzu-1hNs#5w*yAljt^(wRg9)w?S6-ebH`NkN>8R
zWdg|RPLfs+vaQi5>s(nc23gDfqUEyQDSA-!jOclg_4b;yH$m3kJEC1G_o>QNp5kL3
z4YC^JMB`;`lhz?xBI`zJw}@_+^&yar??q{^N_$({PLOS(&!i2<4-y;IXwf*(;R&x4
z+CbLw#iA9mUM+34wCkm9ly<l15z%v^*F}3o15fo4Fnx)QV4|oCW3w?I0jkDa6>goG
zc80WBDz`$~N@-iAZIkxCwB6Def@po50<u1MkHR#DU6|G<jd7%=t(CS;+E!`Xr0tgW
zv9vJ*ypQ8S*4_$fE2YsT*2eOpw0}zbm$aHnFE;{Y?KMlACvB~?b<$px_KGw{@L0b{
zv>)3$UD{M>bmX*h?b23C`@Xc-q`e{SGW=e(k@7e35X@EhmnT}RTy40Uheb^P{Q{Xf
zDtLzuA&dJ=*T!XR?$9FAg@CqTE-Ra{v=WPDWgC<lY|*mv0u=6nvhpz%jN6pj@IVI=
zCMuN`yrFwmSoS})?S;NVTtHJO<CgMgZ5v*u6({V1{g$B_s~je5LX_d2$xnl0`xqq3
z@R?e3uE!&z!mV9du^L_GiUi+&wvL+xC^H1j)p0R1ofxZe?^IUQ;y}o^GdW5Jgfeu5
z&zG4Ur9q+0POMkH%)%())&cse!C!98?8G1nP6uMf_Q^K_{qm>|4rQ3BCOg$G>gfu(
znIL}^b7jTB*#dFt2dG&Wj|3YDqYW;|C=WnclTjXra!W?}GZcEW;v=pR&lfe=>}91A
z9nkZ#tl))<NewndSs4$79&u%58kB7rWg!%LYn99NL7}r!S-BQU4OYCYY=W{fqudK+
z$U*5cPe7^5C_A7uXOs`2&{?3|@*p1UaT<`c;`Z}Wyxhqr6vuQ-woF&CYZ1~1`DA74
zGG%C+l2e$-$0w`Rl~b<FDL=_6H|LZsIpy~`<<*?>_neZXzRxzoLvqUSoH8+|oRL!&
z<dm+QvNEUqG^cFNDGcfG$;SMLoI)pkpRCLWIR%c_ng%3?VX3yg*w)|KT4-zQEnebF
zi@Q5|oR=={E;@JgGI3a}f_y!WrT(^VSeB)h`|wr~Ef<i_tFyeAUBcm*w5IcZ#cW9N
z!6!|Io@T0c5#B&rtgQ>RT#UJ=LL!dnz=4KCO14;jLejb@lP&1~WYzuAR@SMeb-yw_
zYTUx-UEyhUT8O?hX~`UE(n`vUCM~C3Xwtg-&+MZ`=b5yc_MFM-<~HMU)@R05t`i&a
zXJlzTc*~>(xyq!)=qHnw%t<D#<UC~DIJK>%i0*M@mzCK;XenGOjgL-ebR*$ZpQP3f
zyk|yBEk&f5LRyDnFWw*#ABuW|^`*trE<<)8U!K}_R$uR&sr@A>vytDsyRSpbw9nvM
zfV>KlviJ7Q3+ZDd;hh3qg?T;pu-{caaBS@D=`vpiS3{5K4nszFzLP*b;F)Sqc&h4k
zxXL&_+Erpscv*oxI`u+$H)(Ks@Z~8N@@qdO<o8!amZ)!UKeLoNl3kjpQtT_chAsWw
op*Nf?;#VUKQcG|{im&T%yS-2~+e+qvtO~Z-K0deD+mj6XADzsA)c^nh

literal 0
HcmV?d00001

diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/notes.txt b/client/src/thirdparty/sqlite-3.4.2/examples/notes.txt
new file mode 100644
index 0000000..ff7914e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/notes.txt
@@ -0,0 +1,14 @@
+This directory contains three examples how to use SQLite with DJGPP.
+
+I found these examples on the net and do not claim copyright on them.
+
+Compile these with the three batch files included c1-c3.bat.
+
+You can also copy libsqlite3.a into djgpp\lib and sqlite3.h into djgpp\inc.
+
+Links to tutorials:
+http://zetcode.com/db/sqlite/
+http://souptonuts.sourceforge.net/readme_sqlite_tutorial.html
+http://www.yolinux.com/TUTORIALS/SQLite.html
+
+20th Feb. 2013 Georg
diff --git a/client/src/thirdparty/sqlite-3.4.2/examples/sqlite3.h b/client/src/thirdparty/sqlite-3.4.2/examples/sqlite3.h
new file mode 100644
index 0000000..31e466e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/examples/sqlite3.h
@@ -0,0 +1,4804 @@
+/*
+** 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.
+**
+*************************************************************************
+** This header file defines the interface that the SQLite library
+** presents to client programs.  If a C-function, structure, datatype,
+** or constant definition does not appear in this file, then it is
+** not a published API of SQLite, is subject to change without
+** notice, and should not be referenced by programs that use SQLite.
+**
+** Some of the definitions that are in this file are marked as
+** "experimental".  Experimental interfaces are normally new
+** features recently added to SQLite.  We do not anticipate changes 
+** to experimental interfaces but reserve to make minor changes if
+** experience from use "in the wild" suggest such changes are prudent.
+**
+** The official C-language API documentation for SQLite is derived
+** from comments in this file.  This file is the authoritative source
+** on how SQLite interfaces are suppose to operate.
+**
+** The name of this file under configuration management is "sqlite.h.in".
+** The makefile makes some minor changes to this file (such as inserting
+** the version number) and changes its name to "sqlite3.h" as
+** part of the build process.
+**
+** @(#) $Id: sqlite.h.in,v 1.284 2008/02/06 14:11:35 drh Exp $
+*/
+#ifndef _SQLITE3_H_
+#define _SQLITE3_H_
+#include <stdarg.h>     /* Needed for the definition of va_list */
+
+/*
+** Make sure we can call this stuff from C++.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+** Add the ability to override 'extern'
+*/
+#ifndef SQLITE_EXTERN
+# define SQLITE_EXTERN extern
+#endif
+
+/*
+** Make sure these symbols where not defined by some previous header
+** file.
+*/
+#ifdef SQLITE_VERSION
+# undef SQLITE_VERSION
+#endif
+#ifdef SQLITE_VERSION_NUMBER
+# undef SQLITE_VERSION_NUMBER
+#endif
+
+/*
+** CAPI3REF: Compile-Time Library Version Numbers {F10010}
+**
+** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in
+** the sqlite3.h file specify the version of SQLite with which
+** that header file is associated.
+**
+** The "version" of SQLite is a strong of the form "X.Y.Z".
+** The phrase "alpha" or "beta" might be appended after the Z.
+** The X value is major version number always 3 in SQLite3.
+** The X value only changes when  backwards compatibility is
+** broken and we intend to never break
+** backwards compatibility.  The Y value is the minor version
+** number and only changes when
+** there are major feature enhancements that are forwards compatible
+** but not backwards compatible.  The Z value is release number
+** and is incremented with
+** each release but resets back to 0 when Y is incremented.
+**
+** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()].
+**
+** INVARIANTS:
+**
+** {F10011} The SQLITE_VERSION #define in the sqlite3.h header file
+**          evaluates to a string literal that is the SQLite version
+**          with which the header file is associated.
+**
+** {F10014} The SQLITE_VERSION_NUMBER #define resolves to an integer
+**          with the value  (X*1000000 + Y*1000 + Z) where X, Y, and
+**          Z are the major version, minor version, and release number.
+*/
+#define SQLITE_VERSION         "3.5.6"
+#define SQLITE_VERSION_NUMBER 3005006
+
+/*
+** CAPI3REF: Run-Time Library Version Numbers {F10020}
+** KEYWORDS: sqlite3_version
+**
+** These features provide the same information as the [SQLITE_VERSION]
+** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated
+** with the library instead of the header file.  Cautious programmers might
+** include a check in their application to verify that 
+** sqlite3_libversion_number() always returns the value 
+** [SQLITE_VERSION_NUMBER].
+**
+** The sqlite3_libversion() function returns the same information as is
+** in the sqlite3_version[] string constant.  The function is provided
+** for use in DLLs since DLL users usually do not have direct access to string
+** constants within the DLL.
+**
+** INVARIANTS:
+**
+** {F10021} The [sqlite3_libversion_number()] interface returns an integer
+**          equal to [SQLITE_VERSION_NUMBER]. 
+**
+** {F10022} The [sqlite3_version] string constant contains the text of the
+**          [SQLITE_VERSION] string. 
+**
+** {F10023} The [sqlite3_libversion()] function returns
+**          a pointer to the [sqlite3_version] string constant.
+*/
+SQLITE_EXTERN const char sqlite3_version[];
+const char *sqlite3_libversion(void);
+int sqlite3_libversion_number(void);
+
+/*
+** CAPI3REF: Test To See If The Library Is Threadsafe {F10100}
+**
+** SQLite can be compiled with or without mutexes.  When
+** the SQLITE_THREADSAFE C preprocessor macro is true, mutexes
+** are enabled and SQLite is threadsafe.  When that macro os false,
+** the mutexes are omitted.  Without the mutexes, it is not safe
+** to use SQLite from more than one thread.
+**
+** There is a measurable performance penalty for enabling mutexes.
+** So if speed is of utmost importance, it makes sense to disable
+** the mutexes.  But for maximum safety, mutexes should be enabled.
+** The default behavior is for mutexes to be enabled.
+**
+** This interface can be used by a program to make sure that the
+** version of SQLite that it is linking against was compiled with
+** the desired setting of the SQLITE_THREADSAFE macro.
+**
+** INVARIANTS:
+**
+** {F10101} The [sqlite3_threadsafe()] function returns nonzero if
+**          SQLite was compiled with its mutexes enabled or zero
+**          if SQLite was compiled with mutexes disabled.
+*/
+int sqlite3_threadsafe(void);
+
+/*
+** CAPI3REF: Database Connection Handle {F12000}
+** KEYWORDS: {database connection}
+**
+** Each open SQLite database is represented by pointer to an instance of the
+** opaque structure named "sqlite3".  It is useful to think of an sqlite3
+** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and
+** [sqlite3_open_v2()] interfaces are its constructors
+** and [sqlite3_close()] is its destructor.  There are many other interfaces
+** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and
+** [sqlite3_busy_timeout()] to name but three) that are methods on this
+** object.
+*/
+typedef struct sqlite3 sqlite3;
+
+
+/*
+** CAPI3REF: 64-Bit Integer Types {F10200}
+** KEYWORDS: sqlite_int64 sqlite_uint64
+**
+** Because there is no cross-platform way to specify 64-bit integer types
+** SQLite includes typedefs for 64-bit signed and unsigned integers.
+**
+** The sqlite3_int64 and sqlite3_uint64 are the preferred type
+** definitions.  The sqlite_int64 and sqlite_uint64 types are
+** supported for backwards compatibility only.
+**
+** INVARIANTS:
+**
+** {F10201} The [sqlite_int64] and [sqlite3_int64] types specify a
+**          64-bit signed integer.
+**
+** {F10202} The [sqlite_uint64] and [sqlite3_uint64] types specify
+**          a 64-bit unsigned integer.
+*/
+#ifdef SQLITE_INT64_TYPE
+  typedef SQLITE_INT64_TYPE sqlite_int64;
+  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+  typedef __int64 sqlite_int64;
+  typedef unsigned __int64 sqlite_uint64;
+#else
+  typedef long long int sqlite_int64;
+  typedef unsigned long long int sqlite_uint64;
+#endif
+typedef sqlite_int64 sqlite3_int64;
+typedef sqlite_uint64 sqlite3_uint64;
+
+/*
+** If compiling for a processor that lacks floating point support,
+** substitute integer for floating-point
+*/
+#ifdef SQLITE_OMIT_FLOATING_POINT
+# define double sqlite3_int64
+#endif
+
+/*
+** CAPI3REF: Closing A Database Connection {F12010}
+**
+** This routine is the destructor for the [sqlite3] object.  
+**
+** Applications should [sqlite3_finalize | finalize] all
+** [prepared statements] and
+** [sqlite3_blob_close | close] all [sqlite3_blob | BLOBs] 
+** associated with the [sqlite3] object prior
+** to attempting to close the [sqlite3] object.
+**
+** <todo>What happens to pending transactions?  Are they
+** rolled back, or abandoned?</todo>
+**
+** INVARIANTS:
+**
+** {F12011} The [sqlite3_close()] interface destroys an [sqlite3] object
+**          allocated by a prior call to [sqlite3_open()],
+**          [sqlite3_open16()], or [sqlite3_open_v2()].
+**
+** {F12012} The [sqlite3_close()] function releases all memory used by the
+**          connection and closes all open files.
+**
+** {F12013} If the database connection contains
+**          [prepared statements] that have not been
+**          finalized by [sqlite3_finalize()], then [sqlite3_close()]
+**          returns [SQLITE_BUSY] and leaves the connection open.
+**
+** {F12014} Giving sqlite3_close() a NULL pointer is a harmless no-op.
+**
+** LIMITATIONS:
+**
+** {U12015} The parameter to [sqlite3_close()] must be an [sqlite3] object
+**          pointer previously obtained from [sqlite3_open()] or the 
+**          equivalent, or NULL.
+**
+** {U12016} The parameter to [sqlite3_close()] must not have been previously
+**          closed.
+*/
+int sqlite3_close(sqlite3 *);
+
+/*
+** The type for a callback function.
+** This is legacy and deprecated.  It is included for historical
+** compatibility and is not documented.
+*/
+typedef int (*sqlite3_callback)(void*,int,char**, char**);
+
+/*
+** CAPI3REF: One-Step Query Execution Interface {F12100}
+**
+** The sqlite3_exec() interface is a convenient way of running
+** one or more SQL statements without a lot of C code.  The
+** SQL statements are passed in as the second parameter to
+** sqlite3_exec().  The statements are evaluated one by one
+** until either an error or an interrupt is encountered or
+** until they are all done.  The 3rd parameter is an optional
+** callback that is invoked once for each row of any query results
+** produced by the SQL statements.  The 5th parameter tells where
+** to write any error messages.
+**
+** The sqlite3_exec() interface is implemented in terms of
+** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
+** The sqlite3_exec() routine does nothing that cannot be done
+** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
+** The sqlite3_exec() is just a convenient wrapper.
+**
+** INVARIANTS:
+** 
+** {F12101} The [sqlite3_exec()] interface evaluates zero or more UTF-8
+**          encoded, semicolon-separated, SQL statements in the
+**          zero-terminated string of its 2nd parameter within the
+**          context of the [sqlite3] object given in the 1st parameter.
+**
+** {F12104} The return value of [sqlite3_exec()] is SQLITE_OK if all
+**          SQL statements run successfully.
+**
+** {F12105} The return value of [sqlite3_exec()] is an appropriate 
+**          non-zero error code if any SQL statement fails.
+**
+** {F12107} If one or more of the SQL statements handed to [sqlite3_exec()]
+**          return results and the 3rd parameter is not NULL, then
+**          the callback function specified by the 3rd parameter is
+**          invoked once for each row of result.
+**
+** {F12110} If the callback returns a non-zero value then [sqlite3_exec()]
+**          will aborted the SQL statement it is currently evaluating,
+**          skip all subsequent SQL statements, and return [SQLITE_ABORT].
+**          <todo>What happens to *errmsg here?  Does the result code for
+**          sqlite3_errcode() get set?</todo>
+**
+** {F12113} The [sqlite3_exec()] routine will pass its 4th parameter through
+**          as the 1st parameter of the callback.
+**
+** {F12116} The [sqlite3_exec()] routine sets the 2nd parameter of its
+**          callback to be the number of columns in the current row of
+**          result.
+**
+** {F12119} The [sqlite3_exec()] routine sets the 3rd parameter of its 
+**          callback to be an array of pointers to strings holding the
+**          values for each column in the current result set row as
+**          obtained from [sqlite3_column_text()].
+**
+** {F12122} The [sqlite3_exec()] routine sets the 4th parameter of its
+**          callback to be an array of pointers to strings holding the
+**          names of result columns as obtained from [sqlite3_column_name()].
+**
+** {F12125} If the 3rd parameter to [sqlite3_exec()] is NULL then
+**          [sqlite3_exec()] never invokes a callback.  All query
+**          results are silently discarded.
+**
+** {F12128} If an error occurs while parsing or evaluating any of the SQL
+**          statements handed to [sqlite3_exec()] then [sqlite3_exec()] will
+**          return an [error code] other than [SQLITE_OK].
+**
+** {F12131} If an error occurs while parsing or evaluating any of the SQL
+**          handed to [sqlite3_exec()] and if the 5th parameter (errmsg)
+**          to [sqlite3_exec()] is not NULL, then an error message is
+**          allocated using the equivalent of [sqlite3_mprintf()] and
+**          *errmsg is made to point to that message.
+**
+** {F12134} The [sqlite3_exec()] routine does not change the value of
+**          *errmsg if errmsg is NULL or if there are no errors.
+**
+** {F12137} The [sqlite3_exec()] function sets the error code and message
+**          accessible via [sqlite3_errcode()] and [sqlite3_errmsg()].
+**
+** LIMITATIONS:
+**
+** {U12141} The first parameter to [sqlite3_exec()] must be an valid and open
+**          [database connection].
+**
+** {U12142} The database connection must not be closed while
+**          [sqlite3_exec()] is running.
+** 
+** {U12143} The calling function is should use [sqlite3_free()] to free
+**          the memory that *errmsg is left pointing at once the error
+**          message is no longer needed.
+**
+** {U12145} The SQL statement text in the 2nd parameter to [sqlite3_exec()]
+**          must remain unchanged while [sqlite3_exec()] is running.
+*/
+int sqlite3_exec(
+  sqlite3*,                                  /* An open database */
+  const char *sql,                           /* SQL to be evaluted */
+  int (*callback)(void*,int,char**,char**),  /* Callback function */
+  void *,                                    /* 1st argument to callback */
+  char **errmsg                              /* Error msg written here */
+);
+
+/*
+** CAPI3REF: Result Codes {F10210}
+** KEYWORDS: SQLITE_OK {error code} {error codes}
+**
+** Many SQLite functions return an integer result code from the set shown
+** here in order to indicates success or failure.
+**
+** See also: [SQLITE_IOERR_READ | extended result codes]
+*/
+#define SQLITE_OK           0   /* Successful result */
+/* beginning-of-error-codes */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */
+#define SQLITE_EMPTY       16   /* Database is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
+#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_FORMAT      24   /* Auxiliary database format error */
+#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
+#define SQLITE_NOTADB      26   /* File opened that is not a database file */
+#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
+/* end-of-error-codes */
+
+/*
+** CAPI3REF: Extended Result Codes {F10220}
+** KEYWORDS: {extended error code} {extended error codes}
+** KEYWORDS: {extended result codes}
+**
+** In its default configuration, SQLite API routines return one of 26 integer
+** [SQLITE_OK | result codes].  However, experience has shown that
+** many of these result codes are too course-grained.  They do not provide as
+** much information about problems as programmers might like.  In an effort to
+** address this, newer versions of SQLite (version 3.3.8 and later) include
+** support for additional result codes that provide more detailed information
+** about errors. The extended result codes are enabled or disabled
+** for each database connection using the [sqlite3_extended_result_codes()]
+** API.
+** 
+** Some of the available extended result codes are listed here.
+** One may expect the number of extended result codes will be expand
+** over time.  Software that uses extended result codes should expect
+** to see new result codes in future releases of SQLite.
+**
+** The SQLITE_OK result code will never be extended.  It will always
+** be exactly zero.
+** 
+** INVARIANTS:
+**
+** {F10223} The symbolic name for an extended result code always contains
+**          a related primary result code as a prefix.
+**
+** {F10224} Primary result code names contain a single "_" character.
+**
+** {F10225} Extended result code names contain two or more "_" characters.
+**
+** {F10226} The numeric value of an extended result code contains the
+**          numeric value of its corresponding primary result code it
+**          its least significant 8 bits.
+*/
+#define SQLITE_IOERR_READ          (SQLITE_IOERR | (1<<8))
+#define SQLITE_IOERR_SHORT_READ    (SQLITE_IOERR | (2<<8))
+#define SQLITE_IOERR_WRITE         (SQLITE_IOERR | (3<<8))
+#define SQLITE_IOERR_FSYNC         (SQLITE_IOERR | (4<<8))
+#define SQLITE_IOERR_DIR_FSYNC     (SQLITE_IOERR | (5<<8))
+#define SQLITE_IOERR_TRUNCATE      (SQLITE_IOERR | (6<<8))
+#define SQLITE_IOERR_FSTAT         (SQLITE_IOERR | (7<<8))
+#define SQLITE_IOERR_UNLOCK        (SQLITE_IOERR | (8<<8))
+#define SQLITE_IOERR_RDLOCK        (SQLITE_IOERR | (9<<8))
+#define SQLITE_IOERR_DELETE        (SQLITE_IOERR | (10<<8))
+#define SQLITE_IOERR_BLOCKED       (SQLITE_IOERR | (11<<8))
+#define SQLITE_IOERR_NOMEM         (SQLITE_IOERR | (12<<8))
+
+/*
+** CAPI3REF: Flags For File Open Operations {F10230}
+**
+** These bit values are intended for use in then
+** 3rd parameter to the [sqlite3_open_v2()] interface and
+** in the 4th parameter to the xOpen method of the
+** [sqlite3_vfs] object.
+*/
+#define SQLITE_OPEN_READONLY         0x00000001
+#define SQLITE_OPEN_READWRITE        0x00000002
+#define SQLITE_OPEN_CREATE           0x00000004
+#define SQLITE_OPEN_DELETEONCLOSE    0x00000008
+#define SQLITE_OPEN_EXCLUSIVE        0x00000010
+#define SQLITE_OPEN_MAIN_DB          0x00000100
+#define SQLITE_OPEN_TEMP_DB          0x00000200
+#define SQLITE_OPEN_TRANSIENT_DB     0x00000400
+#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800
+#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000
+#define SQLITE_OPEN_SUBJOURNAL       0x00002000
+#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000
+
+/*
+** CAPI3REF: Device Characteristics {F10240}
+**
+** The xDeviceCapabilities method of the [sqlite3_io_methods]
+** object returns an integer which is a vector of the these
+** bit values expressing I/O characteristics of the mass storage
+** device that holds the file that the [sqlite3_io_methods]
+** refers to.
+**
+** The SQLITE_IOCAP_ATOMIC property means that all writes of
+** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
+** mean that writes of blocks that are nnn bytes in size and
+** are aligned to an address which is an integer multiple of
+** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
+** that when data is appended to a file, the data is appended
+** first then the size of the file is extended, never the other
+** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
+** information is written to disk in the same order as calls
+** to xWrite().
+*/
+#define SQLITE_IOCAP_ATOMIC          0x00000001
+#define SQLITE_IOCAP_ATOMIC512       0x00000002
+#define SQLITE_IOCAP_ATOMIC1K        0x00000004
+#define SQLITE_IOCAP_ATOMIC2K        0x00000008
+#define SQLITE_IOCAP_ATOMIC4K        0x00000010
+#define SQLITE_IOCAP_ATOMIC8K        0x00000020
+#define SQLITE_IOCAP_ATOMIC16K       0x00000040
+#define SQLITE_IOCAP_ATOMIC32K       0x00000080
+#define SQLITE_IOCAP_ATOMIC64K       0x00000100
+#define SQLITE_IOCAP_SAFE_APPEND     0x00000200
+#define SQLITE_IOCAP_SEQUENTIAL      0x00000400
+
+/*
+** CAPI3REF: File Locking Levels {F10250}
+**
+** SQLite uses one of these integer values as the second
+** argument to calls it makes to the xLock() and xUnlock() methods
+** of an [sqlite3_io_methods] object.
+*/
+#define SQLITE_LOCK_NONE          0
+#define SQLITE_LOCK_SHARED        1
+#define SQLITE_LOCK_RESERVED      2
+#define SQLITE_LOCK_PENDING       3
+#define SQLITE_LOCK_EXCLUSIVE     4
+
+/*
+** CAPI3REF: Synchronization Type Flags {F10260}
+**
+** When SQLite invokes the xSync() method of an
+** [sqlite3_io_methods] object it uses a combination of the
+** these integer values as the second argument.
+**
+** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
+** sync operation only needs to flush data to mass storage.  Inode
+** information need not be flushed. The SQLITE_SYNC_NORMAL means 
+** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means 
+** to use Mac OS-X style fullsync instead of fsync().
+*/
+#define SQLITE_SYNC_NORMAL        0x00002
+#define SQLITE_SYNC_FULL          0x00003
+#define SQLITE_SYNC_DATAONLY      0x00010
+
+
+/*
+** CAPI3REF: OS Interface Open File Handle {F11110}
+**
+** An [sqlite3_file] object represents an open file in the OS
+** interface layer.  Individual OS interface implementations will
+** want to subclass this object by appending additional fields
+** for their own use.  The pMethods entry is a pointer to an
+** [sqlite3_io_methods] object that defines methods for performing
+** I/O operations on the open file.
+*/
+typedef struct sqlite3_file sqlite3_file;
+struct sqlite3_file {
+  const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
+};
+
+/*
+** CAPI3REF: OS Interface File Virtual Methods Object {F11120}
+**
+** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to
+** an instance of the this object.  This object defines the
+** methods used to perform various operations against the open file.
+**
+** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
+** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
+*  The second choice is an
+** OS-X style fullsync.  The SQLITE_SYNC_DATA flag may be ORed in to
+** indicate that only the data of the file and not its inode needs to be
+** synced.
+** 
+** The integer values to xLock() and xUnlock() are one of
+** <ul>
+** <li> [SQLITE_LOCK_NONE],
+** <li> [SQLITE_LOCK_SHARED],
+** <li> [SQLITE_LOCK_RESERVED],
+** <li> [SQLITE_LOCK_PENDING], or
+** <li> [SQLITE_LOCK_EXCLUSIVE].
+** </ul>
+** xLock() increases the lock. xUnlock() decreases the lock.  
+** The xCheckReservedLock() method looks
+** to see if any database connection, either in this
+** process or in some other process, is holding an RESERVED,
+** PENDING, or EXCLUSIVE lock on the file.  It returns true
+** if such a lock exists and false if not.
+** 
+** The xFileControl() method is a generic interface that allows custom
+** VFS implementations to directly control an open file using the
+** [sqlite3_file_control()] interface.  The second "op" argument
+** is an integer opcode.   The third
+** argument is a generic pointer which is intended to be a pointer
+** to a structure that may contain arguments or space in which to
+** write return values.  Potential uses for xFileControl() might be
+** functions to enable blocking locks with timeouts, to change the
+** locking strategy (for example to use dot-file locks), to inquire
+** about the status of a lock, or to break stale locks.  The SQLite
+** core reserves opcodes less than 100 for its own use. 
+** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
+** Applications that define a custom xFileControl method should use opcodes 
+** greater than 100 to avoid conflicts.
+**
+** The xSectorSize() method returns the sector size of the
+** device that underlies the file.  The sector size is the
+** minimum write that can be performed without disturbing
+** other bytes in the file.  The xDeviceCharacteristics()
+** method returns a bit vector describing behaviors of the
+** underlying device:
+**
+** <ul>
+** <li> [SQLITE_IOCAP_ATOMIC]
+** <li> [SQLITE_IOCAP_ATOMIC512]
+** <li> [SQLITE_IOCAP_ATOMIC1K]
+** <li> [SQLITE_IOCAP_ATOMIC2K]
+** <li> [SQLITE_IOCAP_ATOMIC4K]
+** <li> [SQLITE_IOCAP_ATOMIC8K]
+** <li> [SQLITE_IOCAP_ATOMIC16K]
+** <li> [SQLITE_IOCAP_ATOMIC32K]
+** <li> [SQLITE_IOCAP_ATOMIC64K]
+** <li> [SQLITE_IOCAP_SAFE_APPEND]
+** <li> [SQLITE_IOCAP_SEQUENTIAL]
+** </ul>
+**
+** The SQLITE_IOCAP_ATOMIC property means that all writes of
+** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
+** mean that writes of blocks that are nnn bytes in size and
+** are aligned to an address which is an integer multiple of
+** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
+** that when data is appended to a file, the data is appended
+** first then the size of the file is extended, never the other
+** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
+** information is written to disk in the same order as calls
+** to xWrite().
+*/
+typedef struct sqlite3_io_methods sqlite3_io_methods;
+struct sqlite3_io_methods {
+  int iVersion;
+  int (*xClose)(sqlite3_file*);
+  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
+  int (*xSync)(sqlite3_file*, int flags);
+  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
+  int (*xLock)(sqlite3_file*, int);
+  int (*xUnlock)(sqlite3_file*, int);
+  int (*xCheckReservedLock)(sqlite3_file*);
+  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
+  int (*xSectorSize)(sqlite3_file*);
+  int (*xDeviceCharacteristics)(sqlite3_file*);
+  /* Additional methods may be added in future releases */
+};
+
+/*
+** CAPI3REF: Standard File Control Opcodes {F11310}
+**
+** These integer constants are opcodes for the xFileControl method
+** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()]
+** interface.
+**
+** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
+** opcode cases the xFileControl method to write the current state of
+** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
+** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
+** into an integer that the pArg argument points to. This capability
+** is used during testing and only needs to be supported when SQLITE_TEST
+** is defined.
+*/
+#define SQLITE_FCNTL_LOCKSTATE        1
+
+/*
+** CAPI3REF: Mutex Handle {F17110}
+**
+** The mutex module within SQLite defines [sqlite3_mutex] to be an
+** abstract type for a mutex object.  The SQLite core never looks
+** at the internal representation of an [sqlite3_mutex].  It only
+** deals with pointers to the [sqlite3_mutex] object.
+**
+** Mutexes are created using [sqlite3_mutex_alloc()].
+*/
+typedef struct sqlite3_mutex sqlite3_mutex;
+
+/*
+** CAPI3REF: OS Interface Object {F11140}
+**
+** An instance of this object defines the interface between the
+** SQLite core and the underlying operating system.  The "vfs"
+** in the name of the object stands for "virtual file system".
+**
+** The iVersion field is initially 1 but may be larger for future
+** versions of SQLite.  Additional fields may be appended to this
+** object when the iVersion value is increased.
+**
+** The szOsFile field is the size of the subclassed [sqlite3_file]
+** structure used by this VFS.  mxPathname is the maximum length of
+** a pathname in this VFS.
+**
+** Registered vfs modules are kept on a linked list formed by
+** the pNext pointer.  The [sqlite3_vfs_register()]
+** and [sqlite3_vfs_unregister()] interfaces manage this list
+** in a thread-safe way.  The [sqlite3_vfs_find()] interface
+** searches the list.
+**
+** The pNext field is the only fields in the sqlite3_vfs 
+** structure that SQLite will ever modify.  SQLite will only access
+** or modify this field while holding a particular static mutex.
+** The application should never modify anything within the sqlite3_vfs
+** object once the object has been registered.
+**
+** The zName field holds the name of the VFS module.  The name must
+** be unique across all VFS modules.
+**
+** {F11141} SQLite will guarantee that the zFilename string passed to
+** xOpen() is a full pathname as generated by xFullPathname() and
+** that the string will be valid and unchanged until xClose() is
+** called.  {END} So the [sqlite3_file] can store a pointer to the
+** filename if it needs to remember the filename for some reason.
+**
+** {F11142} The flags argument to xOpen() includes all bits set in
+** the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
+** or [sqlite3_open16()] is used, then flags includes at least
+** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END}
+** If xOpen() opens a file read-only then it sets *pOutFlags to
+** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be
+** set.
+** 
+** {F11143} SQLite will also add one of the following flags to the xOpen()
+** call, depending on the object being opened:
+** 
+** <ul>
+** <li>  [SQLITE_OPEN_MAIN_DB]
+** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
+** <li>  [SQLITE_OPEN_TEMP_DB]
+** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
+** <li>  [SQLITE_OPEN_TRANSIENT_DB]
+** <li>  [SQLITE_OPEN_SUBJOURNAL]
+** <li>  [SQLITE_OPEN_MASTER_JOURNAL]
+** </ul> {END}
+**
+** The file I/O implementation can use the object type flags to
+** changes the way it deals with files.  For example, an application
+** that does not care about crash recovery or rollback, might make
+** the open of a journal file a no-op.  Writes to this journal are
+** also a no-op.  Any attempt to read the journal return SQLITE_IOERR.
+** Or the implementation might recognize the a database file will
+** be doing page-aligned sector reads and writes in a random order
+** and set up its I/O subsystem accordingly.
+** 
+** SQLite might also add one of the following flags to the xOpen
+** method:
+** 
+** <ul>
+** <li> [SQLITE_OPEN_DELETEONCLOSE]
+** <li> [SQLITE_OPEN_EXCLUSIVE]
+** </ul>
+** 
+** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
+** deleted when it is closed.  {F11146} The [SQLITE_OPEN_DELETEONCLOSE]
+** will be set for TEMP  databases, journals and for subjournals. 
+** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
+** for exclusive access.  This flag is set for all files except
+** for the main database file. {END}
+** 
+** {F11148} At least szOsFile bytes of memory is allocated by SQLite 
+** to hold the  [sqlite3_file] structure passed as the third 
+** argument to xOpen.  {END}  The xOpen method does not have to
+** allocate the structure; it should just fill it in.
+** 
+** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] 
+** to test for the existance of a file,
+** or [SQLITE_ACCESS_READWRITE] to test to see
+** if a file is readable and writable, or [SQLITE_ACCESS_READ]
+** to test to see if a file is at least readable.  {END} The file can be a 
+** directory.
+** 
+** {F11150} SQLite will always allocate at least mxPathname+1 byte for
+** the output buffers for xGetTempname and xFullPathname. {F11151} The exact
+** size of the output buffer is also passed as a parameter to both 
+** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN
+** should be returned. As this is handled as a fatal error by SQLite,
+** vfs implementations should endeavor to prevent this by setting 
+** mxPathname to a sufficiently large value.
+** 
+** The xRandomness(), xSleep(), and xCurrentTime() interfaces
+** are not strictly a part of the filesystem, but they are
+** included in the VFS structure for completeness.
+** The xRandomness() function attempts to return nBytes bytes
+** of good-quality randomness into zOut.  The return value is
+** the actual number of bytes of randomness obtained.  The
+** xSleep() method cause the calling thread to sleep for at
+** least the number of microseconds given.  The xCurrentTime()
+** method returns a Julian Day Number for the current date and
+** time.
+*/
+typedef struct sqlite3_vfs sqlite3_vfs;
+struct sqlite3_vfs {
+  int iVersion;            /* Structure version number */
+  int szOsFile;            /* Size of subclassed sqlite3_file */
+  int mxPathname;          /* Maximum file pathname length */
+  sqlite3_vfs *pNext;      /* Next registered VFS */
+  const char *zName;       /* Name of this virtual file system */
+  void *pAppData;          /* Pointer to application-specific data */
+  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
+               int flags, int *pOutFlags);
+  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
+  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags);
+  int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut);
+  int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
+  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
+  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
+  void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
+  void (*xDlClose)(sqlite3_vfs*, void*);
+  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
+  int (*xSleep)(sqlite3_vfs*, int microseconds);
+  int (*xCurrentTime)(sqlite3_vfs*, double*);
+  /* New fields may be appended in figure versions.  The iVersion
+  ** value will increment whenever this happens. */
+};
+
+/*
+** CAPI3REF: Flags for the xAccess VFS method {F11190}
+**
+** {F11191} These integer constants can be used as the third parameter to
+** the xAccess method of an [sqlite3_vfs] object. {END}  They determine
+** the kind of what kind of permissions the xAccess method is
+** looking for.  {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method
+** simply checks to see if the file exists. {F11193} With
+** SQLITE_ACCESS_READWRITE, the xAccess method checks to see
+** if the file is both readable and writable.  {F11194} With
+** SQLITE_ACCESS_READ the xAccess method
+** checks to see if the file is readable.
+*/
+#define SQLITE_ACCESS_EXISTS    0
+#define SQLITE_ACCESS_READWRITE 1
+#define SQLITE_ACCESS_READ      2
+
+/*
+** CAPI3REF: Enable Or Disable Extended Result Codes {F12200}
+**
+** The sqlite3_extended_result_codes() routine enables or disables the
+** [SQLITE_IOERR_READ | extended result codes] feature of SQLite.
+** The extended result codes are disabled by default for historical
+** compatibility.
+**
+** INVARIANTS:
+**
+** {F12201} Each new [database connection] has the 
+**          [extended result codes] feature
+**          disabled by default.
+**
+** {F12202} The [sqlite3_extended_result_codes(D,F)] interface will enable
+**          [extended result codes] for the 
+**          [database connection] D if the F parameter
+**          is true, or disable them if F is false.
+*/
+int sqlite3_extended_result_codes(sqlite3*, int onoff);
+
+/*
+** CAPI3REF: Last Insert Rowid {F12220}
+**
+** Each entry in an SQLite table has a unique 64-bit signed
+** integer key called the "rowid". The rowid is always available
+** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
+** names are not also used by explicitly declared columns. If
+** the table has a column of type INTEGER PRIMARY KEY then that column
+** is another an alias for the rowid.
+**
+** This routine returns the rowid of the most recent
+** successful INSERT into the database from the database connection
+** shown in the first argument.  If no successful inserts
+** have ever occurred on this database connection, zero is returned.
+**
+** If an INSERT occurs within a trigger, then the rowid of the
+** inserted row is returned by this routine as long as the trigger
+** is running.  But once the trigger terminates, the value returned
+** by this routine reverts to the last value inserted before the
+** trigger fired.
+**
+** An INSERT that fails due to a constraint violation is not a
+** successful insert and does not change the value returned by this
+** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
+** and INSERT OR ABORT make no changes to the return value of this
+** routine when their insertion fails.  When INSERT OR REPLACE 
+** encounters a constraint violation, it does not fail.  The
+** INSERT continues to completion after deleting rows that caused
+** the constraint problem so INSERT OR REPLACE will always change
+** the return value of this interface. 
+**
+** For the purposes of this routine, an insert is considered to
+** be successful even if it is subsequently rolled back.
+**
+** INVARIANTS:
+**
+** {F12221} The [sqlite3_last_insert_rowid()] function returns the
+**          rowid of the most recent successful insert done
+**          on the same database connection and within the same
+**          trigger context, or zero if there have
+**          been no qualifying inserts on that connection.
+**
+** {F12223} The [sqlite3_last_insert_rowid()] function returns
+**          same value when called from the same trigger context
+**          immediately before and after a ROLLBACK.
+**
+** LIMITATIONS:
+**
+** {U12232} If separate thread does a new insert on the same
+**          database connection while the [sqlite3_last_insert_rowid()]
+**          function is running and thus changes the last insert rowid,
+**          then the value returned by [sqlite3_last_insert_rowid()] is
+**          unpredictable and might not equal either the old or the new
+**          last insert rowid.
+*/
+sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
+
+/*
+** CAPI3REF: Count The Number Of Rows Modified {F12240}
+**
+** This function returns the number of database rows that were changed
+** or inserted or deleted by the most recently completed SQL statement
+** on the connection specified by the first parameter.  Only
+** changes that are directly specified by the INSERT, UPDATE, or
+** DELETE statement are counted.  Auxiliary changes caused by
+** triggers are not counted. Use the [sqlite3_total_changes()] function
+** to find the total number of changes including changes caused by triggers.
+**
+** A "row changes" is a change to a single row of a single table
+** caused by an INSERT, DELETE, or UPDATE statement.  Rows that
+** are changed as side effects of REPLACE constraint resolution,
+** rollback, ABORT processing, DROP TABLE, or by any other
+** mechanisms do not count as direct row changes.
+**
+** A "trigger context" is a scope of execution that begins and
+** ends with the script of a trigger.  Most SQL statements are
+** evaluated outside of any trigger.  This is the "top level"
+** trigger context.  If a trigger fires from the top level, a
+** new trigger context is entered for the duration of that one
+** trigger.  Subtriggers create subcontexts for their duration.
+**
+** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
+** not create a new trigger context.
+**
+** This function returns the number of direct row changes in the
+** most recent INSERT, UPDATE, or DELETE statement within the same
+** trigger context.
+**
+** So when called from the top level, this function returns the
+** number of changes in the most recent INSERT, UPDATE, or DELETE
+** that also occurred at the top level.
+** Within the body of a trigger, the sqlite3_changes() interface
+** can be called to find the number of
+** changes in the most recently completed INSERT, UPDATE, or DELETE
+** statement within the body of the same trigger.
+** However, the number returned does not include in changes
+** caused by subtriggers since they have their own context.
+**
+** SQLite implements the command "DELETE FROM table" without
+** a WHERE clause by dropping and recreating the table.  (This is much
+** faster than going through and deleting individual elements from the
+** table.)  Because of this optimization, the deletions in
+** "DELETE FROM table" are not row changes and will not be counted
+** by the sqlite3_changes() or [sqlite3_total_changes()] functions.
+** To get an accurate count of the number of rows deleted, use
+** "DELETE FROM table WHERE 1" instead.
+**
+** INVARIANTS:
+**
+** {F12241} The [sqlite3_changes()] function returns the number of
+**          row changes caused by the most recent INSERT, UPDATE,
+**          or DELETE statement on the same database connection and
+**          within the same trigger context, or zero if there have
+**          not been any qualifying row changes.
+**
+** LIMITATIONS:
+**
+** {U12252} If a separate thread makes changes on the same database connection
+**          while [sqlite3_changes()] is running then the value returned
+**          is unpredictable and unmeaningful.
+*/
+int sqlite3_changes(sqlite3*);
+
+/*
+** CAPI3REF: Total Number Of Rows Modified {F12260}
+***
+** This function returns the number of row changes caused
+** by INSERT, UPDATE or DELETE statements since the database handle
+** was opened.  The count includes all changes from all trigger
+** contexts.  But the count does not include changes used to
+** implement REPLACE constraints, do rollbacks or ABORT processing,
+** or DROP table processing.
+** The changes
+** are counted as soon as the statement that makes them is completed 
+** (when the statement handle is passed to [sqlite3_reset()] or 
+** [sqlite3_finalize()]).
+**
+** SQLite implements the command "DELETE FROM table" without
+** a WHERE clause by dropping and recreating the table.  (This is much
+** faster than going
+** through and deleting individual elements form the table.)  Because of
+** this optimization, the change count for "DELETE FROM table" will be
+** zero regardless of the number of elements that were originally in the
+** table. To get an accurate count of the number of rows deleted, use
+** "DELETE FROM table WHERE 1" instead.
+**
+** See also the [sqlite3_changes()] interface.
+**
+** INVARIANTS:
+** 
+** {F12261} The [sqlite3_total_changes()] returns the total number
+**          of row changes caused by INSERT, UPDATE, and/or DELETE
+**          statements on the same [database connection], in any
+**          trigger context, since the database connection was
+**          created.
+**
+** LIMITATIONS:
+**
+** {U12264} If a separate thread makes changes on the same database connection
+**          while [sqlite3_total_changes()] is running then the value 
+**          returned is unpredictable and unmeaningful.
+*/
+int sqlite3_total_changes(sqlite3*);
+
+/*
+** CAPI3REF: Interrupt A Long-Running Query {F12270}
+**
+** This function causes any pending database operation to abort and
+** return at its earliest opportunity. This routine is typically
+** called in response to a user action such as pressing "Cancel"
+** or Ctrl-C where the user wants a long query operation to halt
+** immediately.
+**
+** It is safe to call this routine from a thread different from the
+** thread that is currently running the database operation.  But it
+** is not safe to call this routine with a database connection that
+** is closed or might close before sqlite3_interrupt() returns.
+**
+** If an SQL is very nearly finished at the time when sqlite3_interrupt()
+** is called, then it might not have an opportunity to be interrupted.
+** It might continue to completion.
+** An SQL operation that is interrupted will return
+** [SQLITE_INTERRUPT].  If the interrupted SQL operation is an
+** INSERT, UPDATE, or DELETE that is inside an explicit transaction, 
+** then the entire transaction will be rolled back automatically.
+** A call to sqlite3_interrupt() has no effect on SQL statements
+** that are started after sqlite3_interrupt() returns.
+**
+** INVARIANTS:
+**
+** {F12271} The [sqlite3_interrupt()] interface will force all running
+**          SQL statements associated with the same database connection
+**          to halt after processing at most one additional row of
+**          data.
+**
+** {F12272} Any SQL statement that is interrupted by [sqlite3_interrupt()]
+**          will return [SQLITE_INTERRUPT].
+**
+** LIMITATIONS:
+**
+** {U12279} If the database connection closes while [sqlite3_interrupt()]
+**          is running then bad things will likely happen.
+*/
+void sqlite3_interrupt(sqlite3*);
+
+/*
+** CAPI3REF: Determine If An SQL Statement Is Complete {F10510}
+**
+** These routines are useful for command-line input to determine if the
+** currently entered text seems to form complete a SQL statement or
+** if additional input is needed before sending the text into
+** SQLite for parsing.  These routines return true if the input string
+** appears to be a complete SQL statement.  A statement is judged to be
+** complete if it ends with a semicolon token and is not a fragment of a
+** CREATE TRIGGER statement.  Semicolons that are embedded within
+** string literals or quoted identifier names or comments are not
+** independent tokens (they are part of the token in which they are
+** embedded) and thus do not count as a statement terminator.
+**
+** These routines do not parse the SQL and
+** so will not detect syntactically incorrect SQL.
+**
+** INVARIANTS:
+**
+** {F10511} The sqlite3_complete() and sqlite3_complete16() functions
+**          return true (non-zero) if and only if the last
+**          non-whitespace token in their input is a semicolon that
+**          is not in between the BEGIN and END of a CREATE TRIGGER
+**          statement.
+**
+** LIMITATIONS:
+**
+** {U10512} The input to sqlite3_complete() must be a zero-terminated
+**          UTF-8 string.
+**
+** {U10513} The input to sqlite3_complete16() must be a zero-terminated
+**          UTF-16 string in native byte order.
+*/
+int sqlite3_complete(const char *sql);
+int sqlite3_complete16(const void *sql);
+
+/*
+** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310}
+**
+** This routine identifies a callback function that might be
+** invoked whenever an attempt is made to open a database table 
+** that another thread or process has locked.
+** If the busy callback is NULL, then [SQLITE_BUSY]
+** or [SQLITE_IOERR_BLOCKED]
+** is returned immediately upon encountering the lock.
+** If the busy callback is not NULL, then the
+** callback will be invoked with two arguments.  The
+** first argument to the handler is a copy of the void* pointer which
+** is the third argument to this routine.  The second argument to
+** the handler is the number of times that the busy handler has
+** been invoked for this locking event.   If the
+** busy callback returns 0, then no additional attempts are made to
+** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
+** If the callback returns non-zero, then another attempt
+** is made to open the database for reading and the cycle repeats.
+**
+** The presence of a busy handler does not guarantee that
+** it will be invoked when there is lock contention.
+** If SQLite determines that invoking the busy handler could result in
+** a deadlock, it will go ahead and return [SQLITE_BUSY] or
+** [SQLITE_IOERR_BLOCKED] instead of invoking the
+** busy handler.
+** Consider a scenario where one process is holding a read lock that
+** it is trying to promote to a reserved lock and
+** a second process is holding a reserved lock that it is trying
+** to promote to an exclusive lock.  The first process cannot proceed
+** because it is blocked by the second and the second process cannot
+** proceed because it is blocked by the first.  If both processes
+** invoke the busy handlers, neither will make any progress.  Therefore,
+** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
+** will induce the first process to release its read lock and allow
+** the second process to proceed.
+**
+** The default busy callback is NULL.
+**
+** The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
+** when SQLite is in the middle of a large transaction where all the
+** changes will not fit into the in-memory cache.  SQLite will
+** already hold a RESERVED lock on the database file, but it needs
+** to promote this lock to EXCLUSIVE so that it can spill cache
+** pages into the database file without harm to concurrent
+** readers.  If it is unable to promote the lock, then the in-memory
+** cache will be left in an inconsistent state and so the error
+** code is promoted from the relatively benign [SQLITE_BUSY] to
+** the more severe [SQLITE_IOERR_BLOCKED].  This error code promotion
+** forces an automatic rollback of the changes.  See the
+** <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError">
+** CorruptionFollowingBusyError</a> wiki page for a discussion of why
+** this is important.
+**	
+** There can only be a single busy handler defined for each database
+** connection.  Setting a new busy handler clears any previous one. 
+** Note that calling [sqlite3_busy_timeout()] will also set or clear
+** the busy handler.
+**
+** INVARIANTS:
+**
+** {F12311} The [sqlite3_busy_handler()] function replaces the busy handler
+**          callback in the database connection identified by the 1st
+**          parameter with a new busy handler identified by the 2nd and 3rd
+**          parameters.
+**
+** {F12312} The default busy handler for new database connections is NULL.
+**
+** {F12314} When two or more database connection share a common cache,
+**          the busy handler for the database connection currently using
+**          the cache is invoked when the cache encounters a lock.
+**
+** {F12316} If a busy handler callback returns zero, then the SQLite
+**          interface that provoked the locking event will return
+**          [SQLITE_BUSY].
+**
+** {F12318} SQLite will invokes the busy handler with two argument which
+**          are a copy of the pointer supplied by the 3rd parameter to
+**          [sqlite3_busy_handler()] and a count of the number of prior
+**          invocations of the busy handler for the same locking event.
+**
+** LIMITATIONS:
+**
+** {U12319} A busy handler should not call close the database connection
+**          or prepared statement that invoked the busy handler.
+*/
+int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
+
+/*
+** CAPI3REF: Set A Busy Timeout {F12340}
+**
+** This routine sets a [sqlite3_busy_handler | busy handler]
+** that sleeps for a while when a
+** table is locked.  The handler will sleep multiple times until 
+** at least "ms" milliseconds of sleeping have been done. {F12343} After
+** "ms" milliseconds of sleeping, the handler returns 0 which
+** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
+**
+** Calling this routine with an argument less than or equal to zero
+** turns off all busy handlers.
+**
+** There can only be a single busy handler for a particular database
+** connection.  If another busy handler was defined  
+** (using [sqlite3_busy_handler()]) prior to calling
+** this routine, that other busy handler is cleared.
+**
+** INVARIANTS:
+**
+** {F12341} The [sqlite3_busy_timeout()] function overrides any prior
+**          [sqlite3_busy_timeout()] or [sqlite3_busy_handler()] setting
+**          on the same database connection.
+**
+** {F12343} If the 2nd parameter to [sqlite3_busy_timeout()] is less than
+**          or equal to zero, then the busy handler is cleared so that
+**          all subsequent locking events immediately return [SQLITE_BUSY].
+**
+** {F12344} If the 2nd parameter to [sqlite3_busy_timeout()] is a positive
+**          number N, then a busy handler is set that repeatedly calls
+**          the xSleep() method in the VFS interface until either the
+**          lock clears or until the cumulative sleep time reported back
+**          by xSleep() exceeds N milliseconds.
+*/
+int sqlite3_busy_timeout(sqlite3*, int ms);
+
+/*
+** CAPI3REF: Convenience Routines For Running Queries {F12370}
+**
+** Definition: A <b>result table</b> is memory data structure created by the
+** [sqlite3_get_table()] interface.  A result table records the
+** complete query results from one or more queries.
+**
+** The table conceptually has a number of rows and columns.  But
+** these numbers are not part of the result table itself.  These
+** numbers are obtained separately.  Let N be the number of rows
+** and M be the number of columns.
+**
+** A result table is an array of pointers to zero-terminated
+** UTF-8 strings.  There are (N+1)*M elements in the array.  
+** The first M pointers point to zero-terminated strings that 
+** contain the names of the columns.
+** The remaining entries all point to query results.  NULL
+** values are give a NULL pointer.  All other values are in
+** their UTF-8 zero-terminated string representation as returned by
+** [sqlite3_column_text()].
+**
+** A result table might consists of one or more memory allocations.
+** It is not safe to pass a result table directly to [sqlite3_free()].
+** A result table should be deallocated using [sqlite3_free_table()].
+**
+** As an example of the result table format, suppose a query result
+** is as follows:
+**
+** <blockquote><pre>
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+** </pre></blockquote>
+**
+** There are two column (M==2) and three rows (N==3).  Thus the
+** result table has 8 entries.  Suppose the result table is stored
+** in an array names azResult.  Then azResult holds this content:
+**
+** <blockquote><pre>
+**        azResult&#91;0] = "Name";
+**        azResult&#91;1] = "Age";
+**        azResult&#91;2] = "Alice";
+**        azResult&#91;3] = "43";
+**        azResult&#91;4] = "Bob";
+**        azResult&#91;5] = "28";
+**        azResult&#91;6] = "Cindy";
+**        azResult&#91;7] = "21";
+** </pre></blockquote>
+**
+** The sqlite3_get_table() function evaluates one or more
+** semicolon-separated SQL statements in the zero-terminated UTF-8
+** string of its 2nd parameter.  It returns a result table to the
+** pointer given in its 3rd parameter.
+**
+** After the calling function has finished using the result, it should 
+** pass the pointer to the result table to sqlite3_free_table() in order to 
+** release the memory that was malloc-ed.  Because of the way the 
+** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
+** function must not try to call [sqlite3_free()] directly.  Only 
+** [sqlite3_free_table()] is able to release the memory properly and safely.
+**
+** The sqlite3_get_table() interface is implemented as a wrapper around
+** [sqlite3_exec()].  The sqlite3_get_table() routine does not have access
+** to any internal data structures of SQLite.  It uses only the public
+** interface defined here.  As a consequence, errors that occur in the
+** wrapper layer outside of the internal [sqlite3_exec()] call are not
+** reflected in subsequent calls to [sqlite3_errcode()] or
+** [sqlite3_errmsg()].
+**
+** INVARIANTS:
+**
+** {F12371} If a [sqlite3_get_table()] fails a memory allocation, then
+**          it frees the result table under construction, aborts the
+**          query in process, skips any subsequent queries, sets the
+**          *resultp output pointer to NULL and returns [SQLITE_NOMEM].
+**
+** {F12373} If the ncolumn parameter to [sqlite3_get_table()] is not NULL
+**          then [sqlite3_get_table()] write the number of columns in the
+**          result set of the query into *ncolumn if the query is
+**          successful (if the function returns SQLITE_OK).
+**
+** {F12374} If the nrow parameter to [sqlite3_get_table()] is not NULL
+**          then [sqlite3_get_table()] write the number of rows in the
+**          result set of the query into *nrow if the query is
+**          successful (if the function returns SQLITE_OK).
+**
+** {F12376} The [sqlite3_get_table()] function sets its *ncolumn value
+**          to the number of columns in the result set of the query in the
+**          sql parameter, or to zero if the query in sql has an empty
+**          result set.
+*/
+int sqlite3_get_table(
+  sqlite3*,             /* An open database */
+  const char *sql,      /* SQL to be evaluated */
+  char ***pResult,      /* Results of the query */
+  int *nrow,            /* Number of result rows written here */
+  int *ncolumn,         /* Number of result columns written here */
+  char **errmsg         /* Error msg written here */
+);
+void sqlite3_free_table(char **result);
+
+/*
+** CAPI3REF: Formatted String Printing Functions {F17400}
+**
+** These routines are workalikes of the "printf()" family of functions
+** from the standard C library.
+**
+** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
+** results into memory obtained from [sqlite3_malloc()].
+** The strings returned by these two routines should be
+** released by [sqlite3_free()].   Both routines return a
+** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
+** memory to hold the resulting string.
+**
+** In sqlite3_snprintf() routine is similar to "snprintf()" from
+** the standard C library.  The result is written into the
+** buffer supplied as the second parameter whose size is given by
+** the first parameter. Note that the order of the
+** first two parameters is reversed from snprintf().  This is an
+** historical accident that cannot be fixed without breaking
+** backwards compatibility.  Note also that sqlite3_snprintf()
+** returns a pointer to its buffer instead of the number of
+** characters actually written into the buffer.  We admit that
+** the number of characters written would be a more useful return
+** value but we cannot change the implementation of sqlite3_snprintf()
+** now without breaking compatibility.
+**
+** As long as the buffer size is greater than zero, sqlite3_snprintf()
+** guarantees that the buffer is always zero-terminated.  The first
+** parameter "n" is the total size of the buffer, including space for
+** the zero terminator.  So the longest string that can be completely
+** written will be n-1 characters.
+**
+** These routines all implement some additional formatting
+** options that are useful for constructing SQL statements.
+** All of the usual printf formatting options apply.  In addition, there
+** is are "%q", "%Q", and "%z" options.
+**
+** The %q option works like %s in that it substitutes a null-terminated
+** string from the argument list.  But %q also doubles every '\'' character.
+** %q is designed for use inside a string literal.  By doubling each '\''
+** character it escapes that character and allows it to be inserted into
+** the string.
+**
+** For example, so some string variable contains text as follows:
+**
+** <blockquote><pre>
+**  char *zText = "It's a happy day!";
+** </pre></blockquote>
+**
+** One can use this text in an SQL statement as follows:
+**
+** <blockquote><pre>
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+** </pre></blockquote>
+**
+** Because the %q format string is used, the '\'' character in zText
+** is escaped and the SQL generated is as follows:
+**
+** <blockquote><pre>
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+** </pre></blockquote>
+**
+** This is correct.  Had we used %s instead of %q, the generated SQL
+** would have looked like this:
+**
+** <blockquote><pre>
+**  INSERT INTO table1 VALUES('It's a happy day!');
+** </pre></blockquote>
+**
+** This second example is an SQL syntax error.  As a general rule you
+** should always use %q instead of %s when inserting text into a string 
+** literal.
+**
+** The %Q option works like %q except it also adds single quotes around
+** the outside of the total string.  Or if the parameter in the argument
+** list is a NULL pointer, %Q substitutes the text "NULL" (without single
+** quotes) in place of the %Q option. {END}  So, for example, one could say:
+**
+** <blockquote><pre>
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+** </pre></blockquote>
+**
+** The code above will render a correct SQL statement in the zSQL
+** variable even if the zText variable is a NULL pointer.
+**
+** The "%z" formatting option works exactly like "%s" with the
+** addition that after the string has been read and copied into
+** the result, [sqlite3_free()] is called on the input string. {END}
+**
+** INVARIANTS:
+**
+** {F17403}  The [sqlite3_mprintf()] and [sqlite3_vmprintf()] interfaces
+**           return either pointers to zero-terminated UTF-8 strings held in
+**           memory obtained from [sqlite3_malloc()] or NULL pointers if
+**           a call to [sqlite3_malloc()] fails.
+**
+** {F17406}  The [sqlite3_snprintf()] interface writes a zero-terminated
+**           UTF-8 string into the buffer pointed to by the second parameter
+**           provided that the first parameter is greater than zero.
+**
+** {F17407}  The [sqlite3_snprintf()] interface does not writes slots of
+**           its output buffer (the second parameter) outside the range
+**           of 0 through N-1 (where N is the first parameter)
+**           regardless of the length of the string
+**           requested by the format specification.
+**   
+*/
+char *sqlite3_mprintf(const char*,...);
+char *sqlite3_vmprintf(const char*, va_list);
+char *sqlite3_snprintf(int,char*,const char*, ...);
+
+/*
+** CAPI3REF: Memory Allocation Subsystem {F17300}
+**
+** The SQLite core  uses these three routines for all of its own
+** internal memory allocation needs. "Core" in the previous sentence
+** does not include operating-system specific VFS implementation.  The
+** windows VFS uses native malloc and free for some operations.
+**
+** The sqlite3_malloc() routine returns a pointer to a block
+** of memory at least N bytes in length, where N is the parameter.
+** If sqlite3_malloc() is unable to obtain sufficient free
+** memory, it returns a NULL pointer.  If the parameter N to
+** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
+** a NULL pointer.
+**
+** Calling sqlite3_free() with a pointer previously returned
+** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
+** that it might be reused.  The sqlite3_free() routine is
+** a no-op if is called with a NULL pointer.  Passing a NULL pointer
+** to sqlite3_free() is harmless.  After being freed, memory
+** should neither be read nor written.  Even reading previously freed
+** memory might result in a segmentation fault or other severe error.
+** Memory corruption, a segmentation fault, or other severe error
+** might result if sqlite3_free() is called with a non-NULL pointer that
+** was not obtained from sqlite3_malloc() or sqlite3_free().
+**
+** The sqlite3_realloc() interface attempts to resize a
+** prior memory allocation to be at least N bytes, where N is the
+** second parameter.  The memory allocation to be resized is the first
+** parameter.  If the first parameter to sqlite3_realloc()
+** is a NULL pointer then its behavior is identical to calling
+** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
+** If the second parameter to sqlite3_realloc() is zero or
+** negative then the behavior is exactly the same as calling
+** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
+** Sqlite3_realloc() returns a pointer to a memory allocation
+** of at least N bytes in size or NULL if sufficient memory is unavailable.
+** If M is the size of the prior allocation, then min(N,M) bytes
+** of the prior allocation are copied into the beginning of buffer returned
+** by sqlite3_realloc() and the prior allocation is freed.
+** If sqlite3_realloc() returns NULL, then the prior allocation
+** is not freed.
+**
+** The memory returned by sqlite3_malloc() and sqlite3_realloc()
+** is always aligned to at least an 8 byte boundary. {END}
+**
+** The default implementation
+** of the memory allocation subsystem uses the malloc(), realloc()
+** and free() provided by the standard C library. {F17382} However, if 
+** SQLite is compiled with the following C preprocessor macro
+**
+** <blockquote> SQLITE_MEMORY_SIZE=<i>NNN</i> </blockquote>
+**
+** where <i>NNN</i> is an integer, then SQLite create a static
+** array of at least <i>NNN</i> bytes in size and use that array
+** for all of its dynamic memory allocation needs. {END}  Additional
+** memory allocator options may be added in future releases.
+**
+** In SQLite version 3.5.0 and 3.5.1, it was possible to define
+** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
+** implementation of these routines to be omitted.  That capability
+** is no longer provided.  Only built-in memory allocators can be
+** used.
+**
+** The windows OS interface layer calls
+** the system malloc() and free() directly when converting
+** filenames between the UTF-8 encoding used by SQLite
+** and whatever filename encoding is used by the particular windows
+** installation.  Memory allocation errors are detected, but
+** they are reported back as [SQLITE_CANTOPEN] or
+** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
+**
+** INVARIANTS:
+**
+** {F17303}  The [sqlite3_malloc(N)] interface returns either a pointer to 
+**           newly checked-out block of at least N bytes of memory
+**           that is 8-byte aligned, 
+**           or it returns NULL if it is unable to fulfill the request.
+**
+** {F17304}  The [sqlite3_malloc(N)] interface returns a NULL pointer if
+**           N is less than or equal to zero.
+**
+** {F17305}  The [sqlite3_free(P)] interface releases memory previously
+**           returned from [sqlite3_malloc()] or [sqlite3_realloc()],
+**           making it available for reuse.
+**
+** {F17306}  A call to [sqlite3_free(NULL)] is a harmless no-op.
+**
+** {F17310}  A call to [sqlite3_realloc(0,N)] is equivalent to a call
+**           to [sqlite3_malloc(N)].
+**
+** {F17312}  A call to [sqlite3_realloc(P,0)] is equivalent to a call
+**           to [sqlite3_free(P)].
+**
+** {F17315}  The SQLite core uses [sqlite3_malloc()], [sqlite3_realloc()],
+**           and [sqlite3_free()] for all of its memory allocation and
+**           deallocation needs.
+**
+** {F17318}  The [sqlite3_realloc(P,N)] interface returns either a pointer
+**           to a block of checked-out memory of at least N bytes in size
+**           that is 8-byte aligned, or a NULL pointer.
+**
+** {F17321}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
+**           copies the first K bytes of content from P into the newly allocated
+**           where K is the lessor of N and the size of the buffer P.
+**
+** {F17322}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
+**           releases the buffer P.
+**
+** {F17323}  When [sqlite3_realloc(P,N)] returns NULL, the buffer P is
+**           not modified or released.
+**
+** LIMITATIONS:
+**
+** {U17350}  The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
+**           must be either NULL or else a pointer obtained from a prior
+**           invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that has
+**           not been released.
+**
+** {U17351}  The application must not read or write any part of 
+**           a block of memory after it has been released using
+**           [sqlite3_free()] or [sqlite3_realloc()].
+**
+*/
+void *sqlite3_malloc(int);
+void *sqlite3_realloc(void*, int);
+void sqlite3_free(void*);
+
+/*
+** CAPI3REF: Memory Allocator Statistics {F17370}
+**
+** SQLite provides these two interfaces for reporting on the status
+** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
+** the memory allocation subsystem included within the SQLite.
+**
+** INVARIANTS:
+**
+** {F17371} The [sqlite3_memory_used()] routine returns the
+**          number of bytes of memory currently outstanding 
+**          (malloced but not freed).
+**
+** {F17373} The [sqlite3_memory_highwater()] routine returns the maximum
+**          value of [sqlite3_memory_used()] 
+**          since the highwater mark was last reset.
+**
+** {F17374} The values returned by [sqlite3_memory_used()] and
+**          [sqlite3_memory_highwater()] include any overhead
+**          added by SQLite in its implementation of [sqlite3_malloc()],
+**          but not overhead added by the any underlying system library
+**          routines that [sqlite3_malloc()] may call.
+** 
+** {F17375} The memory highwater mark is reset to the current value of
+**          [sqlite3_memory_used()] if and only if the parameter to
+**          [sqlite3_memory_highwater()] is true.  The value returned
+**          by [sqlite3_memory_highwater(1)] is the highwater mark
+**          prior to the reset.
+*/
+sqlite3_int64 sqlite3_memory_used(void);
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
+
+/*
+** CAPI3REF: Compile-Time Authorization Callbacks {F12500}
+**
+** This routine registers a authorizer callback with a particular
+** database connection, supplied in the first argument.
+** The authorizer callback is invoked as SQL statements are being compiled
+** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
+** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  At various
+** points during the compilation process, as logic is being created
+** to perform various actions, the authorizer callback is invoked to
+** see if those actions are allowed.  The authorizer callback should
+** return SQLITE_OK to allow the action, [SQLITE_IGNORE] to disallow the
+** specific action but allow the SQL statement to continue to be
+** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
+** rejected with an error.   If the authorizer callback returns
+** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
+** then [sqlite3_prepare_v2()] or equivalent call that triggered
+** the authorizer will fail with an error message.
+**
+** When the callback returns [SQLITE_OK], that means the operation
+** requested is ok.  When the callback returns [SQLITE_DENY], the
+** [sqlite3_prepare_v2()] or equivalent call that triggered the
+** authorizer will fail with an error message explaining that
+** access is denied.  If the authorizer code is [SQLITE_READ]
+** and the callback returns [SQLITE_IGNORE] then the prepared
+** statement is constructed to insert a NULL value in place of
+** the table column that would have
+** been read if [SQLITE_OK] had been returned.  The [SQLITE_IGNORE]
+** return can be used to deny an untrusted user access to individual
+** columns of a table.
+**
+** The first parameter to the authorizer callback is a copy of
+** the third parameter to the sqlite3_set_authorizer() interface.
+** The second parameter to the callback is an integer 
+** [SQLITE_COPY | action code] that specifies the particular action
+** to be authorized. The third through sixth
+** parameters to the callback are zero-terminated strings that contain 
+** additional details about the action to be authorized.
+**
+** An authorizer is used when preparing SQL statements from an untrusted
+** source, to ensure that the SQL statements do not try to access data
+** that they are not allowed to see, or that they do not try to
+** execute malicious statements that damage the database.  For
+** example, an application may allow a user to enter arbitrary
+** SQL queries for evaluation by a database.  But the application does
+** not want the user to be able to make arbitrary changes to the
+** database.  An authorizer could then be put in place while the
+** user-entered SQL is being prepared that disallows everything
+** except SELECT statements.  
+**
+** Only a single authorizer can be in place on a database connection
+** at a time.  Each call to sqlite3_set_authorizer overrides the
+** previous call.  Disable the authorizer by installing a NULL callback.
+** The authorizer is disabled by default.
+**
+** Note that the authorizer callback is invoked only during 
+** [sqlite3_prepare()] or its variants.  Authorization is not
+** performed during statement evaluation in [sqlite3_step()].
+**
+** INVARIANTS:
+**
+** {F12501} The [sqlite3_set_authorizer(D,...)] interface registers a
+**          authorizer callback with database connection D.
+**
+** {F12502} The authorizer callback is invoked as SQL statements are
+**          being compiled
+**
+** {F12503} If the authorizer callback returns any value other than
+**          [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] then
+**          the [sqlite3_prepare_v2()] or equivalent call that caused
+**          the authorizer callback to run shall fail with an
+**          [SQLITE_ERROR] error code and an appropriate error message.
+**
+** {F12504} When the authorizer callback returns [SQLITE_OK], the operation
+**          described is coded normally.
+**
+** {F12505} When the authorizer callback returns [SQLITE_DENY], the
+**          [sqlite3_prepare_v2()] or equivalent call that caused the
+**          authorizer callback to run shall fail
+**          with an [SQLITE_ERROR] error code and an error message
+**          explaining that access is denied.
+**
+** {F12506} If the authorizer code (the 2nd parameter to the authorizer
+**          callback) is [SQLITE_READ] and the authorizer callback returns
+**          [SQLITE_IGNORE] then the prepared statement is constructed to
+**          insert a NULL value in place of the table column that would have
+**          been read if [SQLITE_OK] had been returned.
+**
+** {F12507} If the authorizer code (the 2nd parameter to the authorizer
+**          callback) is anything other than [SQLITE_READ], then
+**          a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. 
+**
+** {F12510} The first parameter to the authorizer callback is a copy of
+**          the third parameter to the [sqlite3_set_authorizer()] interface.
+**
+** {F12511} The second parameter to the callback is an integer 
+**          [SQLITE_COPY | action code] that specifies the particular action
+**          to be authorized.
+**
+** {F12512} The third through sixth parameters to the callback are
+**          zero-terminated strings that contain 
+**          additional details about the action to be authorized.
+**
+** {F12520} Each call to [sqlite3_set_authorizer()] overrides the
+**          any previously installed authorizer.
+**
+** {F12521} A NULL authorizer means that no authorization
+**          callback is invoked.
+**
+** {F12522} The default authorizer is NULL.
+*/
+int sqlite3_set_authorizer(
+  sqlite3*,
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
+  void *pUserData
+);
+
+/*
+** CAPI3REF: Authorizer Return Codes {F12590}
+**
+** The [sqlite3_set_authorizer | authorizer callback function] must
+** return either [SQLITE_OK] or one of these two constants in order
+** to signal SQLite whether or not the action is permitted.  See the
+** [sqlite3_set_authorizer | authorizer documentation] for additional
+** information.
+*/
+#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
+#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
+
+/*
+** CAPI3REF: Authorizer Action Codes {F12550}
+**
+** The [sqlite3_set_authorizer()] interface registers a callback function
+** that is invoked to authorizer certain SQL statement actions.  The
+** second parameter to the callback is an integer code that specifies
+** what action is being authorized.  These are the integer action codes that
+** the authorizer callback may be passed.
+**
+** These action code values signify what kind of operation is to be 
+** authorized.  The 3rd and 4th parameters to the authorization
+** callback function will be parameters or NULL depending on which of these
+** codes is used as the second parameter.  The 5th parameter to the
+** authorizer callback is the name of the database ("main", "temp", 
+** etc.) if applicable.  The 6th parameter to the authorizer callback
+** is the name of the inner-most trigger or view that is responsible for
+** the access attempt or NULL if this access attempt is directly from 
+** top-level SQL code.
+**
+** INVARIANTS:
+**
+** {F12551} The second parameter to an 
+**          [sqlite3_set_authorizer | authorizer callback is always an integer
+**          [SQLITE_COPY | authorizer code] that specifies what action
+**          is being authorized.
+**
+** {F12552} The 3rd and 4th parameters to the 
+**          [sqlite3_set_authorizer | authorization callback function]
+**          will be parameters or NULL depending on which 
+**          [SQLITE_COPY | authorizer code] is used as the second parameter.
+**
+** {F12553} The 5th parameter to the
+**          [sqlite3_set_authorizer | authorizer callback] is the name
+**          of the database (example: "main", "temp", etc.) if applicable.
+**
+** {F12554} The 6th parameter to the
+**          [sqlite3_set_authorizer | authorizer callback] is the name
+**          of the inner-most trigger or view that is responsible for
+**          the access attempt or NULL if this access attempt is directly from 
+**          top-level SQL code.
+*/
+/******************************************* 3rd ************ 4th ***********/
+#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
+#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
+#define SQLITE_DELETE                9   /* Table Name      NULL            */
+#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
+#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
+#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
+#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
+#define SQLITE_INSERT               18   /* Table Name      NULL            */
+#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
+#define SQLITE_READ                 20   /* Table Name      Column Name     */
+#define SQLITE_SELECT               21   /* NULL            NULL            */
+#define SQLITE_TRANSACTION          22   /* NULL            NULL            */
+#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
+#define SQLITE_ATTACH               24   /* Filename        NULL            */
+#define SQLITE_DETACH               25   /* Database Name   NULL            */
+#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
+#define SQLITE_REINDEX              27   /* Index Name      NULL            */
+#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
+#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
+#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
+#define SQLITE_FUNCTION             31   /* Function Name   NULL            */
+#define SQLITE_COPY                  0   /* No longer used */
+
+/*
+** CAPI3REF: Tracing And Profiling Functions {F12280}
+**
+** These routines register callback functions that can be used for
+** tracing and profiling the execution of SQL statements.
+**
+** The callback function registered by sqlite3_trace() is invoked at
+** various times when an SQL statement is being run by [sqlite3_step()].
+** The callback returns a UTF-8 rendering of the SQL statement text
+** as the statement first begins executing.  Additional callbacks occur
+** as each triggersubprogram is entered.  The callbacks for triggers
+** contain a UTF-8 SQL comment that identifies the trigger.
+** 
+** The callback function registered by sqlite3_profile() is invoked
+** as each SQL statement finishes.  The profile callback contains
+** the original statement text and an estimate of wall-clock time
+** of how long that statement took to run.
+**
+** The sqlite3_profile() API is currently considered experimental and
+** is subject to change or removal in a future release.
+**
+** The trigger reporting feature of the trace callback is considered
+** experimental and is subject to change or removal in future releases.
+** Future versions of SQLite might also add new trace callback 
+** invocations.
+**
+** INVARIANTS:
+**
+** {F12281} The callback function registered by [sqlite3_trace()] is
+**          whenever an SQL statement first begins to execute and
+**          whenever a trigger subprogram first begins to run.
+**
+** {F12282} Each call to [sqlite3_trace()] overrides the previously
+**          registered trace callback.
+**
+** {F12283} A NULL trace callback disables tracing.
+**
+** {F12284} The first argument to the trace callback is a copy of
+**          the pointer which was the 3rd argument to [sqlite3_trace()].
+**
+** {F12285} The second argument to the trace callback is a
+**          zero-terminated UTF8 string containing the original text
+**          of the SQL statement as it was passed into [sqlite3_prepare_v2()]
+**          or the equivalent, or an SQL comment indicating the beginning
+**          of a trigger subprogram.
+**
+** {F12287} The callback function registered by [sqlite3_profile()] is invoked
+**          as each SQL statement finishes.
+**
+** {F12288} The first parameter to the profile callback is a copy of
+**          the 3rd parameter to [sqlite3_profile()].
+**
+** {F12289} The second parameter to the profile callback is a
+**          zero-terminated UTF-8 string that contains the complete text of
+**          the SQL statement as it was processed by [sqlite3_prepare_v2()]
+**          or the equivalent.
+**
+** {F12290} The third parameter to the profile  callback is an estimate
+**          of the number of nanoseconds of wall-clock time required to
+**          run the SQL statement from start to finish.
+*/
+void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
+void *sqlite3_profile(sqlite3*,
+   void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
+
+/*
+** CAPI3REF: Query Progress Callbacks {F12910}
+**
+** This routine configures a callback function - the
+** progress callback - that is invoked periodically during long
+** running calls to [sqlite3_exec()], [sqlite3_step()] and
+** [sqlite3_get_table()].   An example use for this 
+** interface is to keep a GUI updated during a large query.
+**
+** If the progress callback returns non-zero, the opertion is
+** interrupted.  This feature can be used to implement a
+** "Cancel" button on a GUI dialog box.
+**
+** INVARIANTS:
+**
+** {F12911} The callback function registered by [sqlite3_progress_handler()]
+**          is invoked periodically during long running calls to
+**          [sqlite3_step()].
+**
+** {F12912} The progress callback is invoked once for every N virtual
+**          machine opcodes, where N is the second argument to 
+**          the [sqlite3_progress_handler()] call that registered
+**          the callback.  <todo>What if N is less than 1?</todo>
+**
+** {F12913} The progress callback itself is identified by the third
+**          argument to [sqlite3_progress_handler()].
+**
+** {F12914} The fourth argument [sqlite3_progress_handler()] is a
+***         void pointer passed to the progress callback
+**          function each time it is invoked.
+**
+** {F12915} If a call to [sqlite3_step()] results in fewer than
+**          N opcodes being executed,
+**          then the progress callback is never invoked. {END}
+** 
+** {F12916} Every call to [sqlite3_progress_handler()]
+**          overwrites any previously registere progress handler.
+**
+** {F12917} If the progress handler callback is NULL then no progress
+**          handler is invoked.
+**
+** {F12918} If the progress callback returns a result other than 0, then
+**          the behavior is a if [sqlite3_interrupt()] had been called.
+*/
+void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
+
+/*
+** CAPI3REF: Opening A New Database Connection {F12700}
+**
+** These routines open an SQLite database file whose name
+** is given by the filename argument.
+** The filename argument is interpreted as UTF-8
+** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16
+** in the native byte order for [sqlite3_open16()].
+** An [sqlite3*] handle is usually returned in *ppDb, even
+** if an error occurs.  The only exception is if SQLite is unable
+** to allocate memory to hold the [sqlite3] object, a NULL will
+** be written into *ppDb instead of a pointer to the [sqlite3] object.
+** If the database is opened (and/or created)
+** successfully, then [SQLITE_OK] is returned.  Otherwise an
+** error code is returned.  The
+** [sqlite3_errmsg()] or [sqlite3_errmsg16()]  routines can be used to obtain
+** an English language description of the error.
+**
+** The default encoding for the database will be UTF-8 if
+** [sqlite3_open()] or [sqlite3_open_v2()] is called and
+** UTF-16 in the native byte order if [sqlite3_open16()] is used.
+**
+** Whether or not an error occurs when it is opened, resources
+** associated with the [sqlite3*] handle should be released by passing it
+** to [sqlite3_close()] when it is no longer required.
+**
+** The [sqlite3_open_v2()] interface works like [sqlite3_open()] 
+** except that it acccepts two additional parameters for additional control
+** over the new database connection.  The flags parameter can be
+** one of:
+**
+** <ol>
+** <li>  [SQLITE_OPEN_READONLY]
+** <li>  [SQLITE_OPEN_READWRITE]
+** <li>  [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+** </ol>
+**
+** The first value opens the database read-only. 
+** If the database does not previously exist, an error is returned.
+** The second option opens
+** the database for reading and writing if possible, or reading only if
+** if the file is write protected.  In either case the database
+** must already exist or an error is returned.  The third option
+** opens the database for reading and writing and creates it if it does
+** not already exist.
+** The third options is behavior that is always used for [sqlite3_open()]
+** and [sqlite3_open16()].
+**
+** If the filename is ":memory:", then an private
+** in-memory database is created for the connection.  This in-memory
+** database will vanish when the database connection is closed.  Future
+** version of SQLite might make use of additional special filenames
+** that begin with the ":" character.  It is recommended that 
+** when a database filename really does begin with
+** ":" that you prefix the filename with a pathname like "./" to
+** avoid ambiguity.
+**
+** If the filename is an empty string, then a private temporary
+** on-disk database will be created.  This private database will be
+** automatically deleted as soon as the database connection is closed.
+**
+** The fourth parameter to sqlite3_open_v2() is the name of the
+** [sqlite3_vfs] object that defines the operating system 
+** interface that the new database connection should use.  If the
+** fourth parameter is a NULL pointer then the default [sqlite3_vfs]
+** object is used.
+**
+** <b>Note to windows users:</b>  The encoding used for the filename argument
+** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever
+** codepage is currently defined.  Filenames containing international
+** characters must be converted to UTF-8 prior to passing them into
+** [sqlite3_open()] or [sqlite3_open_v2()].
+**
+** INVARIANTS:
+**
+** {F12701} The [sqlite3_open()], [sqlite3_open16()], and
+**          [sqlite3_open_v2()] interfaces create a new
+**          [database connection] associated with
+**          the database file given in their first parameter.
+**
+** {F12702} The filename argument is interpreted as UTF-8
+**          for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16
+**          in the native byte order for [sqlite3_open16()].
+**
+** {F12703} A successful invocation of [sqlite3_open()], [sqlite3_open16()], 
+**          or [sqlite3_open_v2()] writes a pointer to a new
+**          [database connection] into *ppDb.
+**
+** {F12704} The [sqlite3_open()], [sqlite3_open16()], and
+**          [sqlite3_open_v2()] interfaces return [SQLITE_OK] upon success,
+**          or an appropriate [error code] on failure.
+**
+** {F12706} The default text encoding for a new database created using
+**          [sqlite3_open()] or [sqlite3_open_v2()] will be UTF-8.
+**
+** {F12707} The default text encoding for a new database created using
+**          [sqlite3_open16()] will be UTF-16.
+**
+** {F12709} The [sqlite3_open(F,D)] interface is equivalent to
+**          [sqlite3_open_v2(F,D,G,0)] where the G parameter is
+**          [SQLITE_OPEN_READWRITE]|[SQLITE_OPEN_CREATE].
+**
+** {F12711} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_READONLY] then the database is opened
+**          for reading only.
+**
+** {F12712} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_READWRITE] then the database is opened
+**          reading and writing if possible, or for reading only if the
+**          file is write protected by the operating system.
+**
+** {F12713} If the G parameter to [sqlite3_open(v2(F,D,G,V)] omits the
+**          bit value [SQLITE_OPEN_CREATE] and the database does not
+**          previously exist, an error is returned.
+**
+** {F12714} If the G parameter to [sqlite3_open(v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_CREATE] and the database does not
+**          previously exist, then an attempt is made to create and
+**          initialize the database.
+**
+** {F12717} If the filename argument to [sqlite3_open()], [sqlite3_open16()],
+**          or [sqlite3_open_v2()] is ":memory:", then an private,
+**          ephemeral, in-memory database is created for the connection.
+**          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
+**          in sqlite3_open_v2()?</todo>
+**
+** {F12719} If the filename is an empty string, then a private, ephermeral
+**          on-disk database will be created.
+**          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
+**          in sqlite3_open_v2()?</todo>
+**
+** {F12721} The [database connection] created by 
+**          [sqlite3_open_v2(F,D,G,V)] will use the
+**          [sqlite3_vfs] object identified by the V parameter, or
+**          the default [sqlite3_vfs] object is V is a NULL pointer.
+*/
+int sqlite3_open(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+int sqlite3_open16(
+  const void *filename,   /* Database filename (UTF-16) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+int sqlite3_open_v2(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb,         /* OUT: SQLite db handle */
+  int flags,              /* Flags */
+  const char *zVfs        /* Name of VFS module to use */
+);
+
+/*
+** CAPI3REF: Error Codes And Messages {F12800}
+**
+** The sqlite3_errcode() interface returns the numeric
+** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code]
+** for the most recent failed sqlite3_* API call associated
+** with [sqlite3] handle 'db'. If a prior API call failed but the
+** most recent API call succeeded, the return value from sqlite3_errcode()
+** is undefined.
+**
+** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
+** text that describes the error, as either UTF8 or UTF16 respectively.
+** Memory to hold the error message string is managed internally.
+** The application does not need to worry with freeing the result.
+** However, the error string might be overwritten or deallocated b
+** subsequent calls to other SQLite interface functions.
+**
+** INVARIANTS:
+**
+** {F12801} The [sqlite3_errcode(D)] interface returns the numeric
+**          [SQLITE_OK | result code] or
+**          [SQLITE_IOERR_READ | extended result code]
+**          for the most recent failed interface call associated
+**          with [sqlite3] handle D.
+**
+** {U12802} If a prior API call failed but the most recent API call
+**          succeeded, the return value from [sqlite3_errcode()],
+**          [sqlite3_errmsg()], and [sqlite3_errmsg16()] are undefined.
+**
+** {F12803} The [sqlite3_errmsg(D)] and [sqlite3_errmsg16(D)]
+**          interfaces return English-language text that describes
+**          the error in the mostly recently failed interface call,
+**          encoded as either UTF8 or UTF16 respectively.
+**
+** {U12804} The strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]
+**          are only valid until the next SQLite interface call.
+**
+** {F12807} Calls to [sqlite3_errcode()], [sqlite3_errmsg()], and
+**          [sqlite3_errmsg16()] themselves do not affect the
+**          results of future invocations of these routines.
+**
+** {F12808} Calls to API routines that do not return an error code
+**          (example: [sqlite3_data_count()]) do not
+**          change the error code or message returned by
+**          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].
+**
+** {F12809} Interfaces that are not associated with a specific
+**          [database connection] (examples:
+**          [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()]
+**          do not change the values returned by
+**          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].
+*/
+int sqlite3_errcode(sqlite3 *db);
+const char *sqlite3_errmsg(sqlite3*);
+const void *sqlite3_errmsg16(sqlite3*);
+
+/*
+** CAPI3REF: SQL Statement Object {F13000}
+** KEYWORDS: {prepared statement} {prepared statements}
+**
+** An instance of this object represent single SQL statements.  This
+** object is variously known as a "prepared statement" or a 
+** "compiled SQL statement" or simply as a "statement".
+** 
+** The life of a statement object goes something like this:
+**
+** <ol>
+** <li> Create the object using [sqlite3_prepare_v2()] or a related
+**      function.
+** <li> Bind values to host parameters using
+**      [sqlite3_bind_blob | sqlite3_bind_* interfaces].
+** <li> Run the SQL by calling [sqlite3_step()] one or more times.
+** <li> Reset the statement using [sqlite3_reset()] then go back
+**      to step 2.  Do this zero or more times.
+** <li> Destroy the object using [sqlite3_finalize()].
+** </ol>
+**
+** Refer to documentation on individual methods above for additional
+** information.
+*/
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+/*
+** CAPI3REF: Compiling An SQL Statement {F13010}
+**
+** To execute an SQL query, it must first be compiled into a byte-code
+** program using one of these routines. 
+**
+** The first argument "db" is an [database connection] 
+** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()]
+** or [sqlite3_open16()]. 
+** The second argument "zSql" is the statement to be compiled, encoded
+** as either UTF-8 or UTF-16.  The sqlite3_prepare() and sqlite3_prepare_v2()
+** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2()
+** use UTF-16. {END}
+**
+** If the nByte argument is less
+** than zero, then zSql is read up to the first zero terminator.
+** If nByte is non-negative, then it is the maximum number of 
+** bytes read from zSql.  When nByte is non-negative, the
+** zSql string ends at either the first '\000' or '\u0000' character or 
+** until the nByte-th byte, whichever comes first. {END}
+**
+** *pzTail is made to point to the first byte past the end of the
+** first SQL statement in zSql.  These routines only compiles the first
+** statement in zSql, so *pzTail is left pointing to what remains
+** uncompiled.
+**
+** *ppStmt is left pointing to a compiled [prepared statement] that can be
+** executed using [sqlite3_step()].  Or if there is an error, *ppStmt may be
+** set to NULL.  If the input text contains no SQL (if the input
+** is and empty string or a comment) then *ppStmt is set to NULL.
+** {U13018} The calling procedure is responsible for deleting the
+** compiled SQL statement
+** using [sqlite3_finalize()] after it has finished with it.
+**
+** On success, [SQLITE_OK] is returned.  Otherwise an 
+** [error code] is returned.
+**
+** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
+** recommended for all new programs. The two older interfaces are retained
+** for backwards compatibility, but their use is discouraged.
+** In the "v2" interfaces, the prepared statement
+** that is returned (the [sqlite3_stmt] object) contains a copy of the 
+** original SQL text. {END} This causes the [sqlite3_step()] interface to
+** behave a differently in two ways:
+**
+** <ol>
+** <li>
+** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
+** always used to do, [sqlite3_step()] will automatically recompile the SQL
+** statement and try to run it again.  If the schema has changed in
+** a way that makes the statement no longer valid, [sqlite3_step()] will still
+** return [SQLITE_SCHEMA].  But unlike the legacy behavior, 
+** [SQLITE_SCHEMA] is now a fatal error.  Calling
+** [sqlite3_prepare_v2()] again will not make the
+** error go away.  Note: use [sqlite3_errmsg()] to find the text
+** of the parsing error that results in an [SQLITE_SCHEMA] return. {END}
+** </li>
+**
+** <li>
+** When an error occurs, 
+** [sqlite3_step()] will return one of the detailed 
+** [error codes] or [extended error codes]. 
+** The legacy behavior was that [sqlite3_step()] would only return a generic
+** [SQLITE_ERROR] result code and you would have to make a second call to
+** [sqlite3_reset()] in order to find the underlying cause of the problem.
+** With the "v2" prepare interfaces, the underlying reason for the error is
+** returned immediately.
+** </li>
+** </ol>
+**
+** INVARIANTS:
+**
+** {F13011} The [sqlite3_prepare(db,zSql,...)] and
+**          [sqlite3_prepare_v2(db,zSql,...)] interfaces interpret the
+**          text in their zSql parameter as UTF-8.
+**
+** {F13012} The [sqlite3_prepare16(db,zSql,...)] and
+**          [sqlite3_prepare16_v2(db,zSql,...)] interfaces interpret the
+**          text in their zSql parameter as UTF-16 in the native byte order.
+**
+** {F13013} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)]
+**          and its variants is less than zero, then SQL text is
+**          read from zSql is read up to the first zero terminator.
+**
+** {F13014} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)]
+**          and its variants is non-negative, then nBytes bytes
+**          SQL text is read from zSql.
+**
+** {F13015} In [sqlite3_prepare_v2(db,zSql,N,P,pzTail)] and its variants
+**          if the zSql input text contains more than one SQL statement
+**          and pzTail is not NULL, then *pzTail is made to point to the
+**          first byte past the end of the first SQL statement in zSql.
+**          <todo>What does *pzTail point to if there is one statement?</todo>
+**
+** {F13016} A successful call to [sqlite3_prepare_v2(db,zSql,N,ppStmt,...)]
+**          or one of its variants writes into *ppStmt a pointer to a new
+**          [prepared statement] or a pointer to NULL
+**          if zSql contains nothing other than whitespace or comments. 
+**
+** {F13019} The [sqlite3_prepare_v2()] interface and its variants return
+**          [SQLITE_OK] or an appropriate [error code] upon failure.
+*/
+int sqlite3_prepare(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare_v2(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16_v2(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+
+/*
+** CAPIREF: Retrieving Statement SQL {F13100}
+**
+** This intereface can be used to retrieve a saved copy of the original
+** SQL text used to create a [prepared statement].
+**
+** INVARIANTS:
+**
+** {F13101} If the [prepared statement] passed as 
+**          the an argument to [sqlite3_sql()] was compiled
+**          compiled using either [sqlite3_prepare_v2()] or
+**          [sqlite3_prepare16_v2()],
+**          then [sqlite3_sql()] function returns a pointer to a
+**          zero-terminated string containing a UTF-8 rendering
+**          of the original SQL statement.
+**
+** {F13102} If the [prepared statement] passed as 
+**          the an argument to [sqlite3_sql()] was compiled
+**          compiled using either [sqlite3_prepare()] or
+**          [sqlite3_prepare16()],
+**          then [sqlite3_sql()] function returns a NULL pointer.
+**
+** {F13103} The string returned by [sqlite3_sql(S)] is valid until the
+**          [prepared statement] S is deleted using [sqlite3_finalize(S)].
+*/
+const char *sqlite3_sql(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF:  Dynamically Typed Value Object  {F15000}
+**
+** SQLite uses the sqlite3_value object to represent all values
+** that are or can be stored in a database table.
+** SQLite uses dynamic typing for the values it stores.  
+** Values stored in sqlite3_value objects can be
+** be integers, floating point values, strings, BLOBs, or NULL.
+*/
+typedef struct Mem sqlite3_value;
+
+/*
+** CAPI3REF:  SQL Function Context Object {F16001}
+**
+** The context in which an SQL function executes is stored in an
+** sqlite3_context object.  A pointer to an sqlite3_context
+** object is always first parameter to application-defined SQL functions.
+*/
+typedef struct sqlite3_context sqlite3_context;
+
+/*
+** CAPI3REF:  Binding Values To Prepared Statements {F13500}
+**
+** In the SQL strings input to [sqlite3_prepare_v2()] and its
+** variants, literals may be replace by a parameter in one
+** of these forms:
+**
+** <ul>
+** <li>  ?
+** <li>  ?NNN
+** <li>  :VVV
+** <li>  @VVV
+** <li>  $VVV
+** </ul>
+**
+** In the parameter forms shown above NNN is an integer literal,
+** VVV alpha-numeric parameter name.
+** The values of these parameters (also called "host parameter names"
+** or "SQL parameters")
+** can be set using the sqlite3_bind_*() routines defined here.
+**
+** The first argument to the sqlite3_bind_*() routines always
+** is a pointer to the [sqlite3_stmt] object returned from
+** [sqlite3_prepare_v2()] or its variants. The second
+** argument is the index of the parameter to be set. The
+** first parameter has an index of 1.  When the same named
+** parameter is used more than once, second and subsequent
+** occurrences have the same index as the first occurrence. 
+** The index for named parameters can be looked up using the
+** [sqlite3_bind_parameter_name()] API if desired.  The index
+** for "?NNN" parameters is the value of NNN.
+** The NNN value must be between 1 and the compile-time
+** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999).
+**
+** The third argument is the value to bind to the parameter.
+**
+** In those
+** routines that have a fourth argument, its value is the number of bytes
+** in the parameter.  To be clear: the value is the number of <u>bytes</u>
+** in the value, not the number of characters.   The number
+** of bytes does not include the zero-terminator at the end of strings.
+** If the fourth parameter is negative, the length of the string is
+** number of bytes up to the first zero terminator.
+**
+** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
+** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
+** string after SQLite has finished with it. If the fifth argument is
+** the special value [SQLITE_STATIC], then SQLite assumes that the
+** information is in static, unmanaged space and does not need to be freed.
+** If the fifth argument has the value [SQLITE_TRANSIENT], then
+** SQLite makes its own private copy of the data immediately, before
+** the sqlite3_bind_*() routine returns.
+**
+** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
+** is filled with zeros.  A zeroblob uses a fixed amount of memory
+** (just an integer to hold it size) while it is being processed.
+** Zeroblobs are intended to serve as place-holders for BLOBs whose
+** content is later written using 
+** [sqlite3_blob_open | increment BLOB I/O] routines. A negative
+** value for the zeroblob results in a zero-length BLOB.
+**
+** The sqlite3_bind_*() routines must be called after
+** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and
+** before [sqlite3_step()].
+** Bindings are not cleared by the [sqlite3_reset()] routine.
+** Unbound parameters are interpreted as NULL.
+**
+** These routines return [SQLITE_OK] on success or an error code if
+** anything goes wrong.  [SQLITE_RANGE] is returned if the parameter
+** index is out of range.  [SQLITE_NOMEM] is returned if malloc fails.
+** [SQLITE_MISUSE] might be returned if these routines are called on a
+** virtual machine that is the wrong state or which has already been finalized.
+** Detection of misuse is unreliable.  Applications should not depend
+** on SQLITE_MISUSE returns.  SQLITE_MISUSE is intended to indicate a
+** a logic error in the application.  Future versions of SQLite might
+** panic rather than return SQLITE_MISUSE.
+**
+** See also: [sqlite3_bind_parameter_count()],
+** [sqlite3_bind_parameter_name()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13506} The [sqlite3_prepare | SQL statement compiler] recognizes
+**          tokens of the forms "?", "?NNN", "$VVV", ":VVV", and "@VVV"
+**          as SQL parameters, where NNN is any sequence of one or more
+**          digits and where VVV is any sequence of one or more 
+**          alphanumeric characters or "::" optionally followed by
+**          a string containing no spaces and contained within parentheses.
+**
+** {F13509} The initial value of an SQL parameter is NULL.
+**
+** {F13512} The index of an "?" SQL parameter is one larger than the
+**          largest index of SQL parameter to the left, or 1 if
+**          the "?" is the leftmost SQL parameter.
+**
+** {F13515} The index of an "?NNN" SQL parameter is the integer NNN.
+**
+** {F13518} The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is
+**          the same as the index of leftmost occurances of the same
+**          parameter, or one more than the largest index over all
+**          parameters to the left if this is the first occurrance
+**          of this parameter, or 1 if this is the leftmost parameter.
+**
+** {F13521} The [sqlite3_prepare | SQL statement compiler] fail with
+**          an [SQLITE_RANGE] error if the index of an SQL parameter
+**          is less than 1 or greater than SQLITE_MAX_VARIABLE_NUMBER.
+**
+** {F13524} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,V,...)]
+**          associate the value V with all SQL parameters having an
+**          index of N in the [prepared statement] S.
+**
+** {F13527} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,...)]
+**          override prior calls with the same values of S and N.
+**
+** {F13530} Bindings established by [sqlite3_bind_text | sqlite3_bind(S,...)]
+**          persist across calls to [sqlite3_reset(S)].
+**
+** {F13533} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds the first L
+**          bytes of the blob or string pointed to by V, when L
+**          is non-negative.
+**
+** {F13536} In calls to [sqlite3_bind_text(S,N,V,L,D)] or
+**          [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds characters
+**          from V through the first zero character when L is negative.
+**
+** {F13539} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is the special
+**          constant [SQLITE_STATIC], SQLite assumes that the value V
+**          is held in static unmanaged space that will not change
+**          during the lifetime of the binding.
+**
+** {F13542} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is the special
+**          constant [SQLITE_TRANSIENT], the routine makes a 
+**          private copy of V value before it returns.
+**
+** {F13545} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is a pointer to
+**          a function, SQLite invokes that function to destroy the
+**          V value after it has finished using the V value.
+**
+** {F13548} In calls to [sqlite3_bind_zeroblob(S,N,V,L)] the value bound
+**          is a blob of L bytes, or a zero-length blob if L is negative.
+*/
+int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+int sqlite3_bind_double(sqlite3_stmt*, int, double);
+int sqlite3_bind_int(sqlite3_stmt*, int, int);
+int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
+int sqlite3_bind_null(sqlite3_stmt*, int);
+int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
+int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
+int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
+
+/*
+** CAPI3REF: Number Of SQL Parameters {F13600}
+**
+** This routine can be used to find the number of SQL parameters
+** in a prepared statement.  SQL parameters are tokens of the
+** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
+** place-holders for values that are [sqlite3_bind_blob | bound]
+** to the parameters at a later time.
+**
+** This routine actually returns the index of the largest parameter.
+** For all forms except ?NNN, this will correspond to the number of
+** unique parameters.  If parameters of the ?NNN are used, there may
+** be gaps in the list.
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_name()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13601} The [sqlite3_bind_parameter_count(S)] interface returns
+**          the largest index of all SQL parameters in the
+**          [prepared statement] S, or 0 if S
+**          contains no SQL parameters.
+*/
+int sqlite3_bind_parameter_count(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Name Of A Host Parameter {F13620}
+**
+** This routine returns a pointer to the name of the n-th
+** SQL parameter in a [prepared statement].
+** SQL parameters of the form ":AAA" or "@AAA" or "$AAA" have a name
+** which is the string ":AAA" or "@AAA" or "$VVV". 
+** In other words, the initial ":" or "$" or "@"
+** is included as part of the name.
+** Parameters of the form "?" or "?NNN" have no name.
+**
+** The first host parameter has an index of 1, not 0.
+**
+** If the value n is out of range or if the n-th parameter is
+** nameless, then NULL is returned.  The returned string is
+** always in the UTF-8 encoding even if the named parameter was
+** originally specified as UTF-16 in [sqlite3_prepare16()] or
+** [sqlite3_prepare16_v2()].
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_count()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13621} The [sqlite3_bind_parameter_name(S,N)] interface returns
+**          a UTF-8 rendering of the name of the SQL parameter in
+**          [prepared statement] S having index N, or
+**          NULL if there is no SQL parameter with index N or if the
+**          parameter with index N is an anonymous parameter "?" or
+**          a numbered parameter "?NNN".
+*/
+const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
+
+/*
+** CAPI3REF: Index Of A Parameter With A Given Name {F13640}
+**
+** Return the index of an SQL parameter given its name.  The
+** index value returned is suitable for use as the second
+** parameter to [sqlite3_bind_blob|sqlite3_bind()].  A zero
+** is returned if no matching parameter is found.  The parameter
+** name must be given in UTF-8 even if the original statement
+** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_count()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13641} The [sqlite3_bind_parameter_index(S,N)] interface returns
+**          the index of SQL parameter in [prepared statement]
+**          S whose name matches the UTF-8 string N, or 0 if there is
+**          no match.
+*/
+int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
+
+/*
+** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660}
+**
+** Contrary to the intuition of many, [sqlite3_reset()] does not
+** reset the [sqlite3_bind_blob | bindings] on a 
+** [prepared statement].  Use this routine to
+** reset all host parameters to NULL.
+**
+** INVARIANTS:
+**
+** {F13661} The [sqlite3_clear_bindings(S)] interface resets all
+**          SQL parameter bindings in [prepared statement] S
+**          back to NULL.
+*/
+int sqlite3_clear_bindings(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Number Of Columns In A Result Set {F13710}
+**
+** Return the number of columns in the result set returned by the 
+** [prepared statement]. This routine returns 0
+** if pStmt is an SQL statement that does not return data (for 
+** example an UPDATE).
+**
+** INVARIANTS:
+**
+** {F13711} The [sqlite3_column_count(S)] interface returns the number of
+**          columns in the result set generated by the
+**          [prepared statement] S, or 0 if S does not generate
+**          a result set.
+*/
+int sqlite3_column_count(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Column Names In A Result Set {F13720}
+**
+** These routines return the name assigned to a particular column
+** in the result set of a SELECT statement.  The sqlite3_column_name()
+** interface returns a pointer to a zero-terminated UTF8 string
+** and sqlite3_column_name16() returns a pointer to a zero-terminated
+** UTF16 string.  The first parameter is the
+** [prepared statement] that implements the SELECT statement.
+** The second parameter is the column number.  The left-most column is
+** number 0.
+**
+** The returned string pointer is valid until either the 
+** [prepared statement] is destroyed by [sqlite3_finalize()]
+** or until the next call sqlite3_column_name() or sqlite3_column_name16()
+** on the same column.
+**
+** If sqlite3_malloc() fails during the processing of either routine
+** (for example during a conversion from UTF-8 to UTF-16) then a
+** NULL pointer is returned.
+**
+** The name of a result column is the value of the "AS" clause for
+** that column, if there is an AS clause.  If there is no AS clause
+** then the name of the column is unspecified and may change from
+** one release of SQLite to the next.
+**
+** INVARIANTS:
+**
+** {F13721} A successful invocation of the [sqlite3_column_name(S,N)]
+**          interface returns the name
+**          of the Nth column (where 0 is the left-most column) for the
+**          result set of [prepared statement] S as a
+**          zero-terminated UTF-8 string.
+**
+** {F13723} A successful invocation of the [sqlite3_column_name16(S,N)]
+**          interface returns the name
+**          of the Nth column (where 0 is the left-most column) for the
+**          result set of [prepared statement] S as a
+**          zero-terminated UTF-16 string in the native byte order.
+**
+** {F13724} The [sqlite3_column_name()] and [sqlite3_column_name16()]
+**          interfaces return a NULL pointer if they are unable to
+**          allocate memory memory to hold there normal return strings.
+**
+** {F13725} If the N parameter to [sqlite3_column_name(S,N)] or
+**          [sqlite3_column_name16(S,N)] is out of range, then the
+**          interfaces returns a NULL pointer.
+** 
+** {F13726} The strings returned by [sqlite3_column_name(S,N)] and
+**          [sqlite3_column_name16(S,N)] are valid until the next
+**          call to either routine with the same S and N parameters
+**          or until [sqlite3_finalize(S)] is called.
+**
+** {F13727} When a result column of a [SELECT] statement contains
+**          an AS clause, the name of that column is the indentifier
+**          to the right of the AS keyword.
+*/
+const char *sqlite3_column_name(sqlite3_stmt*, int N);
+const void *sqlite3_column_name16(sqlite3_stmt*, int N);
+
+/*
+** CAPI3REF: Source Of Data In A Query Result {F13740}
+**
+** These routines provide a means to determine what column of what
+** table in which database a result of a SELECT statement comes from.
+** The name of the database or table or column can be returned as
+** either a UTF8 or UTF16 string.  The _database_ routines return
+** the database name, the _table_ routines return the table name, and
+** the origin_ routines return the column name.
+** The returned string is valid until
+** the [prepared statement] is destroyed using
+** [sqlite3_finalize()] or until the same information is requested
+** again in a different encoding.
+**
+** The names returned are the original un-aliased names of the
+** database, table, and column.
+**
+** The first argument to the following calls is a [prepared statement].
+** These functions return information about the Nth column returned by 
+** the statement, where N is the second function argument.
+**
+** If the Nth column returned by the statement is an expression
+** or subquery and is not a column value, then all of these functions
+** return NULL.  These routine might also return NULL if a memory
+** allocation error occurs.  Otherwise, they return the 
+** name of the attached database, table and column that query result
+** column was extracted from.
+**
+** As with all other SQLite APIs, those postfixed with "16" return
+** UTF-16 encoded strings, the other functions return UTF-8. {END}
+**
+** These APIs are only available if the library was compiled with the 
+** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined.
+**
+** {U13751}
+** If two or more threads call one or more of these routines against the same
+** prepared statement and column at the same time then the results are
+** undefined.
+**
+** INVARIANTS:
+**
+** {F13741} The [sqlite3_column_database_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the database from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13742} The [sqlite3_column_database_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the database from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13743} The [sqlite3_column_table_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the table from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13744} The [sqlite3_column_table_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the table from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13745} The [sqlite3_column_origin_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the table column from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13746} The [sqlite3_column_origin_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the table column from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13748} The return values from
+**          [sqlite3_column_database_name|column metadata interfaces]
+**          are valid
+**          for the lifetime of the [prepared statement]
+**          or until the encoding is changed by another metadata
+**          interface call for the same prepared statement and column.
+**
+** LIMITATIONS:
+**
+** {U13751} If two or more threads call one or more
+**          [sqlite3_column_database_name|column metadata interfaces]
+**          the same [prepared statement] and result column
+**          at the same time then the results are undefined.
+*/
+const char *sqlite3_column_database_name(sqlite3_stmt*,int);
+const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_table_name(sqlite3_stmt*,int);
+const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
+const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
+
+/*
+** CAPI3REF: Declared Datatype Of A Query Result {F13760}
+**
+** The first parameter is a [prepared statement]. 
+** If this statement is a SELECT statement and the Nth column of the 
+** returned result set of that SELECT is a table column (not an
+** expression or subquery) then the declared type of the table
+** column is returned.  If the Nth column of the result set is an
+** expression or subquery, then a NULL pointer is returned.
+** The returned string is always UTF-8 encoded.  {END} 
+** For example, in the database schema:
+**
+** CREATE TABLE t1(c1 VARIANT);
+**
+** And the following statement compiled:
+**
+** SELECT c1 + 1, c1 FROM t1;
+**
+** Then this routine would return the string "VARIANT" for the second
+** result column (i==1), and a NULL pointer for the first result column
+** (i==0).
+**
+** SQLite uses dynamic run-time typing.  So just because a column
+** is declared to contain a particular type does not mean that the
+** data stored in that column is of the declared type.  SQLite is
+** strongly typed, but the typing is dynamic not static.  Type
+** is associated with individual values, not with the containers
+** used to hold those values.
+**
+** INVARIANTS:
+**
+** {F13761}  A successful call to [sqlite3_column_decltype(S,N)]
+**           returns a zero-terminated UTF-8 string containing the
+**           the declared datatype of the table column that appears
+**           as the Nth column (numbered from 0) of the result set to the
+**           [prepared statement] S.
+**
+** {F13762}  A successful call to [sqlite3_column_decltype16(S,N)]
+**           returns a zero-terminated UTF-16 native byte order string
+**           containing the declared datatype of the table column that appears
+**           as the Nth column (numbered from 0) of the result set to the
+**           [prepared statement] S.
+**
+** {F13763}  If N is less than 0 or N is greater than or equal to
+**           the number of columns in [prepared statement] S
+**           or if the Nth column of S is an expression or subquery rather
+**           than a table column or if a memory allocation failure
+**           occurs during encoding conversions, then
+**           calls to [sqlite3_column_decltype(S,N)] or
+**           [sqlite3_column_decltype16(S,N)] return NULL.
+*/
+const char *sqlite3_column_decltype(sqlite3_stmt*,int);
+const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+
+/* 
+** CAPI3REF:  Evaluate An SQL Statement {F13200}
+**
+** After an [prepared statement] has been prepared with a call
+** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of
+** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()],
+** then this function must be called one or more times to evaluate the 
+** statement.
+**
+** The details of the behavior of this sqlite3_step() interface depend
+** on whether the statement was prepared using the newer "v2" interface
+** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
+** interface [sqlite3_prepare()] and [sqlite3_prepare16()].  The use of the
+** new "v2" interface is recommended for new applications but the legacy
+** interface will continue to be supported.
+**
+** In the lagacy interface, the return value will be either [SQLITE_BUSY], 
+** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
+** With the "v2" interface, any of the other [SQLITE_OK | result code]
+** or [SQLITE_IOERR_READ | extended result code] might be returned as
+** well.
+**
+** [SQLITE_BUSY] means that the database engine was unable to acquire the
+** database locks it needs to do its job.  If the statement is a COMMIT
+** or occurs outside of an explicit transaction, then you can retry the
+** statement.  If the statement is not a COMMIT and occurs within a
+** explicit transaction then you should rollback the transaction before
+** continuing.
+**
+** [SQLITE_DONE] means that the statement has finished executing
+** successfully.  sqlite3_step() should not be called again on this virtual
+** machine without first calling [sqlite3_reset()] to reset the virtual
+** machine back to its initial state.
+**
+** If the SQL statement being executed returns any data, then 
+** [SQLITE_ROW] is returned each time a new row of data is ready
+** for processing by the caller. The values may be accessed using
+** the [sqlite3_column_int | column access functions].
+** sqlite3_step() is called again to retrieve the next row of data.
+** 
+** [SQLITE_ERROR] means that a run-time error (such as a constraint
+** violation) has occurred.  sqlite3_step() should not be called again on
+** the VM. More information may be found by calling [sqlite3_errmsg()].
+** With the legacy interface, a more specific error code (example:
+** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
+** can be obtained by calling [sqlite3_reset()] on the
+** [prepared statement].  In the "v2" interface,
+** the more specific error code is returned directly by sqlite3_step().
+**
+** [SQLITE_MISUSE] means that the this routine was called inappropriately.
+** Perhaps it was called on a [prepared statement] that has
+** already been [sqlite3_finalize | finalized] or on one that had 
+** previously returned [SQLITE_ERROR] or [SQLITE_DONE].  Or it could
+** be the case that the same database connection is being used by two or
+** more threads at the same moment in time.
+**
+** <b>Goofy Interface Alert:</b>
+** In the legacy interface, 
+** the sqlite3_step() API always returns a generic error code,
+** [SQLITE_ERROR], following any error other than [SQLITE_BUSY]
+** and [SQLITE_MISUSE].  You must call [sqlite3_reset()] or
+** [sqlite3_finalize()] in order to find one of the specific
+** [error codes] that better describes the error.
+** We admit that this is a goofy design.  The problem has been fixed
+** with the "v2" interface.  If you prepare all of your SQL statements
+** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
+** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the 
+** more specific [error codes] are returned directly
+** by sqlite3_step().  The use of the "v2" interface is recommended.
+**
+** INVARIANTS:
+**
+** {F13202}  If [prepared statement] S is ready to be
+**           run, then [sqlite3_step(S)] advances that prepared statement
+**           until to completion or until it is ready to return another
+**           row of the result set or an interrupt or run-time error occurs.
+**
+** {F15304}  When a call to [sqlite3_step(S)] causes the 
+**           [prepared statement] S to run to completion,
+**           the function returns [SQLITE_DONE].
+**
+** {F15306}  When a call to [sqlite3_step(S)] stops because it is ready
+**           to return another row of the result set, it returns
+**           [SQLITE_ROW].
+**
+** {F15308}  If a call to [sqlite3_step(S)] encounters an
+**           [sqlite3_interrupt|interrupt] or a run-time error,
+**           it returns an appropraite error code that is not one of
+**           [SQLITE_OK], [SQLITE_ROW], or [SQLITE_DONE].
+**
+** {F15310}  If an [sqlite3_interrupt|interrupt] or run-time error
+**           occurs during a call to [sqlite3_step(S)]
+**           for a [prepared statement] S created using
+**           legacy interfaces [sqlite3_prepare()] or
+**           [sqlite3_prepare16()] then the function returns either
+**           [SQLITE_ERROR], [SQLITE_BUSY], or [SQLITE_MISUSE].
+*/
+int sqlite3_step(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Number of columns in a result set {F13770}
+**
+** Return the number of values in the current row of the result set.
+**
+** INVARIANTS:
+**
+** {F13771}  After a call to [sqlite3_step(S)] that returns
+**           [SQLITE_ROW], the [sqlite3_data_count(S)] routine
+**           will return the same value as the
+**           [sqlite3_column_count(S)] function.
+**
+** {F13772}  After [sqlite3_step(S)] has returned any value other than
+**           [SQLITE_ROW] or before [sqlite3_step(S)] has been 
+**           called on the [prepared statement] for
+**           the first time since it was [sqlite3_prepare|prepared]
+**           or [sqlite3_reset|reset], the [sqlite3_data_count(S)]
+**           routine returns zero.
+*/
+int sqlite3_data_count(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Fundamental Datatypes {F10265}
+** KEYWORDS: SQLITE_TEXT
+**
+** {F10266}Every value in SQLite has one of five fundamental datatypes:
+**
+** <ul>
+** <li> 64-bit signed integer
+** <li> 64-bit IEEE floating point number
+** <li> string
+** <li> BLOB
+** <li> NULL
+** </ul> {END}
+**
+** These constants are codes for each of those types.
+**
+** Note that the SQLITE_TEXT constant was also used in SQLite version 2
+** for a completely different meaning.  Software that links against both
+** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not
+** SQLITE_TEXT.
+*/
+#define SQLITE_INTEGER  1
+#define SQLITE_FLOAT    2
+#define SQLITE_BLOB     4
+#define SQLITE_NULL     5
+#ifdef SQLITE_TEXT
+# undef SQLITE_TEXT
+#else
+# define SQLITE_TEXT     3
+#endif
+#define SQLITE3_TEXT     3
+
+/*
+** CAPI3REF: Results Values From A Query {F13800}
+**
+** These routines form the "result set query" interface.
+**
+** These routines return information about
+** a single column of the current result row of a query.  In every
+** case the first argument is a pointer to the 
+** [prepared statement] that is being
+** evaluated (the [sqlite3_stmt*] that was returned from 
+** [sqlite3_prepare_v2()] or one of its variants) and
+** the second argument is the index of the column for which information 
+** should be returned.  The left-most column of the result set
+** has an index of 0.
+**
+** If the SQL statement is not currently point to a valid row, or if the
+** the column index is out of range, the result is undefined. 
+** These routines may only be called when the most recent call to
+** [sqlite3_step()] has returned [SQLITE_ROW] and neither
+** [sqlite3_reset()] nor [sqlite3_finalize()] has been call subsequently.
+** If any of these routines are called after [sqlite3_reset()] or
+** [sqlite3_finalize()] or after [sqlite3_step()] has returned
+** something other than [SQLITE_ROW], the results are undefined.
+** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
+** are called from a different thread while any of these routines
+** are pending, then the results are undefined.  
+**
+** The sqlite3_column_type() routine returns 
+** [SQLITE_INTEGER | datatype code] for the initial data type
+** of the result column.  The returned value is one of [SQLITE_INTEGER],
+** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].  The value
+** returned by sqlite3_column_type() is only meaningful if no type
+** conversions have occurred as described below.  After a type conversion,
+** the value returned by sqlite3_column_type() is undefined.  Future
+** versions of SQLite may change the behavior of sqlite3_column_type()
+** following a type conversion.
+**
+** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() 
+** routine returns the number of bytes in that BLOB or string.
+** If the result is a UTF-16 string, then sqlite3_column_bytes() converts
+** the string to UTF-8 and then returns the number of bytes.
+** If the result is a numeric value then sqlite3_column_bytes() uses
+** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
+** the number of bytes in that string.
+** The value returned does not include the zero terminator at the end
+** of the string.  For clarity: the value returned is the number of
+** bytes in the string, not the number of characters.
+**
+** Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
+** even empty strings, are always zero terminated.  The return
+** value from sqlite3_column_blob() for a zero-length blob is an arbitrary
+** pointer, possibly even a NULL pointer.
+**
+** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
+** but leaves the result in UTF-16 in native byte order instead of UTF-8.  
+** The zero terminator is not included in this count.
+**
+** These routines attempt to convert the value where appropriate.  For
+** example, if the internal representation is FLOAT and a text result
+** is requested, [sqlite3_snprintf()] is used internally to do the conversion
+** automatically.  The following table details the conversions that
+** are applied:
+**
+** <blockquote>
+** <table border="1">
+** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
+**
+** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
+** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
+** <tr><td>  NULL    <td>   TEXT    <td> Result is NULL pointer
+** <tr><td>  NULL    <td>   BLOB    <td> Result is NULL pointer
+** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
+** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
+** <tr><td> INTEGER  <td>   BLOB    <td> Same as for INTEGER->TEXT
+** <tr><td>  FLOAT   <td> INTEGER   <td> Convert from float to integer
+** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
+** <tr><td>  FLOAT   <td>   BLOB    <td> Same as FLOAT->TEXT
+** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
+** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
+** <tr><td>  TEXT    <td>   BLOB    <td> No change
+** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
+** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
+** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
+** </table>
+** </blockquote>
+**
+** The table above makes reference to standard C library functions atoi()
+** and atof().  SQLite does not really use these functions.  It has its
+** on equavalent internal routines.  The atoi() and atof() names are
+** used in the table for brevity and because they are familiar to most
+** C programmers.
+**
+** Note that when type conversions occur, pointers returned by prior
+** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
+** sqlite3_column_text16() may be invalidated. 
+** Type conversions and pointer invalidations might occur
+** in the following cases:
+**
+** <ul>
+** <li><p>  The initial content is a BLOB and sqlite3_column_text() 
+**          or sqlite3_column_text16() is called.  A zero-terminator might
+**          need to be added to the string.</p></li>
+**
+** <li><p>  The initial content is UTF-8 text and sqlite3_column_bytes16() or
+**          sqlite3_column_text16() is called.  The content must be converted
+**          to UTF-16.</p></li>
+**
+** <li><p>  The initial content is UTF-16 text and sqlite3_column_bytes() or
+**          sqlite3_column_text() is called.  The content must be converted
+**          to UTF-8.</p></li>
+** </ul>
+**
+** Conversions between UTF-16be and UTF-16le are always done in place and do
+** not invalidate a prior pointer, though of course the content of the buffer
+** that the prior pointer points to will have been modified.  Other kinds
+** of conversion are done in place when it is possible, but sometime it is
+** not possible and in those cases prior pointers are invalidated.  
+**
+** The safest and easiest to remember policy is to invoke these routines
+** in one of the following ways:
+**
+**  <ul>
+**  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
+**  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
+**  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
+**  </ul>
+**
+** In other words, you should call sqlite3_column_text(), sqlite3_column_blob(),
+** or sqlite3_column_text16() first to force the result into the desired
+** format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to
+** find the size of the result.  Do not mix call to sqlite3_column_text() or
+** sqlite3_column_blob() with calls to sqlite3_column_bytes16().  And do not
+** mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes().
+**
+** The pointers returned are valid until a type conversion occurs as
+** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
+** [sqlite3_finalize()] is called.  The memory space used to hold strings
+** and blobs is freed automatically.  Do <b>not</b> pass the pointers returned
+** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into 
+** [sqlite3_free()].
+**
+** If a memory allocation error occurs during the evaluation of any
+** of these routines, a default value is returned.  The default value
+** is either the integer 0, the floating point number 0.0, or a NULL
+** pointer.  Subsequent calls to [sqlite3_errcode()] will return
+** [SQLITE_NOMEM].
+**
+** INVARIANTS:
+**
+** {F13803} The [sqlite3_column_blob(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a blob and then returns a
+**          pointer to the converted value.
+**
+** {F13806} The [sqlite3_column_bytes(S,N)] interface returns the
+**          number of bytes in the blob or string (exclusive of the
+**          zero terminator on the string) that was returned by the
+**          most recent call to [sqlite3_column_blob(S,N)] or
+**          [sqlite3_column_text(S,N)].
+**
+** {F13809} The [sqlite3_column_bytes16(S,N)] interface returns the
+**          number of bytes in the string (exclusive of the
+**          zero terminator on the string) that was returned by the
+**          most recent call to [sqlite3_column_text16(S,N)].
+**
+** {F13812} The [sqlite3_column_double(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a floating point value and
+**          returns a copy of that value.
+**
+** {F13815} The [sqlite3_column_int(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a 32-bit signed integer and
+**          returns a copy of that integer.
+**
+** {F13818} The [sqlite3_column_int64(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a 64-bit signed integer and
+**          returns a copy of that integer.
+**
+** {F13821} The [sqlite3_column_text(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a zero-terminated UTF-8 
+**          string and returns a pointer to that string.
+**
+** {F13824} The [sqlite3_column_text16(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a zero-terminated 2-byte
+**          aligned UTF-16 native byte order
+**          string and returns a pointer to that string.
+**
+** {F13827} The [sqlite3_column_type(S,N)] interface returns
+**          one of [SQLITE_NULL], [SQLITE_INTEGER], [SQLITE_FLOAT],
+**          [SQLITE_TEXT], or [SQLITE_BLOB] as appropriate for
+**          the Nth column in the current row of the result set for
+**          [prepared statement] S.
+**
+** {F13830} The [sqlite3_column_value(S,N)] interface returns a
+**          pointer to the [sqlite3_value] object that for the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S.
+*/
+const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
+double sqlite3_column_double(sqlite3_stmt*, int iCol);
+int sqlite3_column_int(sqlite3_stmt*, int iCol);
+sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
+const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
+const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
+int sqlite3_column_type(sqlite3_stmt*, int iCol);
+sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
+
+/*
+** CAPI3REF: Destroy A Prepared Statement Object {F13300}
+**
+** The sqlite3_finalize() function is called to delete a 
+** [prepared statement]. If the statement was
+** executed successfully, or not executed at all, then SQLITE_OK is returned.
+** If execution of the statement failed then an 
+** [error code] or [extended error code]
+** is returned. 
+**
+** This routine can be called at any point during the execution of the
+** [prepared statement].  If the virtual machine has not 
+** completed execution when this routine is called, that is like
+** encountering an error or an interrupt.  (See [sqlite3_interrupt()].) 
+** Incomplete updates may be rolled back and transactions cancelled,  
+** depending on the circumstances, and the 
+** [error code] returned will be [SQLITE_ABORT].
+**
+** INVARIANTS:
+**
+** {F11302} The [sqlite3_finalize(S)] interface destroys the
+**          [prepared statement] S and releases all
+**          memory and file resources held by that object.
+**
+** {F11304} If the most recent call to [sqlite3_step(S)] for the
+**          [prepared statement] S returned an error,
+**          then [sqlite3_finalize(S)] returns that same error.
+*/
+int sqlite3_finalize(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Reset A Prepared Statement Object {F13330}
+**
+** The sqlite3_reset() function is called to reset a 
+** [prepared statement] object.
+** back to its initial state, ready to be re-executed.
+** Any SQL statement variables that had values bound to them using
+** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
+** Use [sqlite3_clear_bindings()] to reset the bindings.
+**
+** {F11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S
+**          back to the beginning of its program.
+**
+** {F11334} If the most recent call to [sqlite3_step(S)] for 
+**          [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
+**          or if [sqlite3_step(S)] has never before been called on S,
+**          then [sqlite3_reset(S)] returns [SQLITE_OK].
+**
+** {F11336} If the most recent call to [sqlite3_step(S)] for
+**          [prepared statement] S indicated an error, then
+**          [sqlite3_reset(S)] returns an appropriate [error code].
+**
+** {F11338} The [sqlite3_reset(S)] interface does not change the values
+**          of any [sqlite3_bind_blob|bindings] on [prepared statement] S.
+*/
+int sqlite3_reset(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Create Or Redefine SQL Functions {F16100}
+** KEYWORDS: {function creation routines} 
+**
+** These two functions (collectively known as
+** "function creation routines") are used to add SQL functions or aggregates
+** or to redefine the behavior of existing SQL functions or aggregates.  The
+** difference only between the two is that the second parameter, the
+** name of the (scalar) function or aggregate, is encoded in UTF-8 for
+** sqlite3_create_function() and UTF-16 for sqlite3_create_function16().
+**
+** The first argument is the [database connection] that holds the
+** SQL function or aggregate is to be added or redefined. If a single
+** program uses more than one database handle internally, then SQL
+** functions or aggregates must be added individually to each database
+** handle with which they will be used.
+**
+** The second parameter is the name of the SQL function to be created
+** or redefined.
+** The length of the name is limited to 255 bytes, exclusive of the 
+** zero-terminator.  Note that the name length limit is in bytes, not
+** characters.  Any attempt to create a function with a longer name
+** will result in an SQLITE_ERROR error.
+**
+** The third parameter is the number of arguments that the SQL function or
+** aggregate takes. If this parameter is negative, then the SQL function or
+** aggregate may take any number of arguments.
+**
+** The fourth parameter, eTextRep, specifies what 
+** [SQLITE_UTF8 | text encoding] this SQL function prefers for
+** its parameters.  Any SQL function implementation should be able to work
+** work with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
+** more efficient with one encoding than another.  It is allowed to
+** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
+** times with the same function but with different values of eTextRep.
+** When multiple implementations of the same function are available, SQLite
+** will pick the one that involves the least amount of data conversion.
+** If there is only a single implementation which does not care what
+** text encoding is used, then the fourth argument should be
+** [SQLITE_ANY].
+**
+** The fifth parameter is an arbitrary pointer.  The implementation
+** of the function can gain access to this pointer using
+** [sqlite3_user_data()].
+**
+** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are
+** pointers to C-language functions that implement the SQL
+** function or aggregate. A scalar SQL function requires an implementation of
+** the xFunc callback only, NULL pointers should be passed as the xStep
+** and xFinal parameters. An aggregate SQL function requires an implementation
+** of xStep and xFinal and NULL should be passed for xFunc. To delete an
+** existing SQL function or aggregate, pass NULL for all three function
+** callback.
+**
+** It is permitted to register multiple implementations of the same
+** functions with the same name but with either differing numbers of
+** arguments or differing perferred text encodings.  SQLite will use
+** the implementation most closely matches the way in which the
+** SQL function is used.
+**
+** INVARIANTS:
+**
+** {F16103} The [sqlite3_create_function16()] interface behaves exactly
+**          like [sqlite3_create_function()] in every way except that it
+**          interprets the zFunctionName argument as
+**          zero-terminated UTF-16 native byte order instead of as a
+**          zero-terminated UTF-8.
+**
+** {F16106} 
+*/
+int sqlite3_create_function(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+int sqlite3_create_function16(
+  sqlite3 *db,
+  const void *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+
+/*
+** CAPI3REF: Text Encodings {F10267}
+**
+** These constant define integer codes that represent the various
+** text encodings supported by SQLite.
+*/
+#define SQLITE_UTF8           1
+#define SQLITE_UTF16LE        2
+#define SQLITE_UTF16BE        3
+#define SQLITE_UTF16          4    /* Use native byte order */
+#define SQLITE_ANY            5    /* sqlite3_create_function only */
+#define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
+
+/*
+** CAPI3REF: Obsolete Functions
+**
+** These functions are all now obsolete.  In order to maintain
+** backwards compatibility with older code, we continue to support
+** these functions.  However, new development projects should avoid
+** the use of these functions.  To help encourage people to avoid
+** using these functions, we are not going to tell you want they do.
+*/
+int sqlite3_aggregate_count(sqlite3_context*);
+int sqlite3_expired(sqlite3_stmt*);
+int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
+int sqlite3_global_recover(void);
+void sqlite3_thread_cleanup(void);
+int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
+
+/*
+** CAPI3REF: Obtaining SQL Function Parameter Values {F15100}
+**
+** The C-language implementation of SQL functions and aggregates uses
+** this set of interface routines to access the parameter values on
+** the function or aggregate.
+**
+** The xFunc (for scalar functions) or xStep (for aggregates) parameters
+** to [sqlite3_create_function()] and [sqlite3_create_function16()]
+** define callbacks that implement the SQL functions and aggregates.
+** The 4th parameter to these callbacks is an array of pointers to
+** [sqlite3_value] objects.  There is one [sqlite3_value] object for
+** each parameter to the SQL function.  These routines are used to
+** extract values from the [sqlite3_value] objects.
+**
+** These routines work just like the corresponding 
+** [sqlite3_column_blob | sqlite3_column_* routines] except that 
+** these routines take a single [sqlite3_value*] pointer instead
+** of an [sqlite3_stmt*] pointer and an integer column number.
+**
+** The sqlite3_value_text16() interface extracts a UTF16 string
+** in the native byte-order of the host machine.  The
+** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
+** extract UTF16 strings as big-endian and little-endian respectively.
+**
+** The sqlite3_value_numeric_type() interface attempts to apply
+** numeric affinity to the value.  This means that an attempt is
+** made to convert the value to an integer or floating point.  If
+** such a conversion is possible without loss of information (in other
+** words if the value is a string that looks like a number)
+** then the conversion is done.  Otherwise no conversion occurs.  The 
+** [SQLITE_INTEGER | datatype] after conversion is returned.
+**
+** Please pay particular attention to the fact that the pointer that
+** is returned from [sqlite3_value_blob()], [sqlite3_value_text()], or
+** [sqlite3_value_text16()] can be invalidated by a subsequent call to
+** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
+** or [sqlite3_value_text16()].  
+**
+** These routines must be called from the same thread as
+** the SQL function that supplied the sqlite3_value* parameters.
+** Or, if the sqlite3_value* argument comes from the [sqlite3_column_value()]
+** interface, then these routines should be called from the same thread
+** that ran [sqlite3_column_value()].
+**
+*/
+const void *sqlite3_value_blob(sqlite3_value*);
+int sqlite3_value_bytes(sqlite3_value*);
+int sqlite3_value_bytes16(sqlite3_value*);
+double sqlite3_value_double(sqlite3_value*);
+int sqlite3_value_int(sqlite3_value*);
+sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
+const unsigned char *sqlite3_value_text(sqlite3_value*);
+const void *sqlite3_value_text16(sqlite3_value*);
+const void *sqlite3_value_text16le(sqlite3_value*);
+const void *sqlite3_value_text16be(sqlite3_value*);
+int sqlite3_value_type(sqlite3_value*);
+int sqlite3_value_numeric_type(sqlite3_value*);
+
+/*
+** CAPI3REF: Obtain Aggregate Function Context {F16210}
+**
+** The implementation of aggregate SQL functions use this routine to allocate
+** a structure for storing their state.  
+** {F16211} The first time the sqlite3_aggregate_context() routine is
+** is called for a particular aggregate, SQLite allocates nBytes of memory
+** zeros that memory, and returns a pointer to it.
+** {F16212} On second and subsequent calls to sqlite3_aggregate_context()
+** for the same aggregate function index, the same buffer is returned. {END}
+** The implementation
+** of the aggregate can use the returned buffer to accumulate data.
+**
+** {F16213} SQLite automatically frees the allocated buffer when the aggregate
+** query concludes. {END}
+**
+** The first parameter should be a copy of the 
+** [sqlite3_context | SQL function context] that is the first
+** parameter to the callback routine that implements the aggregate
+** function.
+**
+** This routine must be called from the same thread in which
+** the aggregate SQL function is running.
+*/
+void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
+
+/*
+** CAPI3REF: User Data For Functions {F16240}
+**
+** {F16241} The sqlite3_user_data() interface returns a copy of
+** the pointer that was the pUserData parameter (the 5th parameter)
+** of the the [sqlite3_create_function()]
+** and [sqlite3_create_function16()] routines that originally
+** registered the application defined function. {END}
+**
+** {U16243} This routine must be called from the same thread in which
+** the application-defined function is running.
+*/
+void *sqlite3_user_data(sqlite3_context*);
+
+/*
+** CAPI3REF: Function Auxiliary Data {F16270}
+**
+** The following two functions may be used by scalar SQL functions to
+** associate meta-data with argument values. If the same value is passed to
+** multiple invocations of the same SQL function during query execution, under
+** some circumstances the associated meta-data may be preserved. This may
+** be used, for example, to add a regular-expression matching scalar
+** function. The compiled version of the regular expression is stored as
+** meta-data associated with the SQL value passed as the regular expression
+** pattern.  The compiled regular expression can be reused on multiple
+** invocations of the same function so that the original pattern string
+** does not need to be recompiled on each invocation.
+**
+** {F16271}
+** The sqlite3_get_auxdata() interface returns a pointer to the meta-data
+** associated by the sqlite3_set_auxdata() function with the Nth argument
+** value to the application-defined function.
+** {F16272} If no meta-data has been ever been set for the Nth
+** argument of the function, or if the cooresponding function parameter
+** has changed since the meta-data was set, then sqlite3_get_auxdata()
+** returns a NULL pointer.
+**
+** {F16275} The sqlite3_set_auxdata() interface saves the meta-data
+** pointed to by its 3rd parameter as the meta-data for the N-th
+** argument of the application-defined function. {END} Subsequent
+** calls to sqlite3_get_auxdata() might return this data, if it has
+** not been destroyed. 
+** {F16277} If it is not NULL, SQLite will invoke the destructor 
+** function given by the 4th parameter to sqlite3_set_auxdata() on
+** the meta-data when the corresponding function parameter changes
+** or when the SQL statement completes, whichever comes first. {END}
+**
+** In practice, meta-data is preserved between function calls for
+** expressions that are constant at compile time. This includes literal
+** values and SQL variables.
+**
+** These routines must be called from the same thread in which
+** the SQL function is running.
+*/
+void *sqlite3_get_auxdata(sqlite3_context*, int N);
+void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
+
+
+/*
+** CAPI3REF: Constants Defining Special Destructor Behavior {F10280}
+**
+** These are special value for the destructor that is passed in as the
+** final argument to routines like [sqlite3_result_blob()].  If the destructor
+** argument is SQLITE_STATIC, it means that the content pointer is constant
+** and will never change.  It does not need to be destroyed.  The 
+** SQLITE_TRANSIENT value means that the content will likely change in
+** the near future and that SQLite should make its own private copy of
+** the content before returning.
+**
+** The typedef is necessary to work around problems in certain
+** C++ compilers.  See ticket #2191.
+*/
+typedef void (*sqlite3_destructor_type)(void*);
+#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
+#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
+
+/*
+** CAPI3REF: Setting The Result Of An SQL Function {F16400}
+**
+** These routines are used by the xFunc or xFinal callbacks that
+** implement SQL functions and aggregates.  See
+** [sqlite3_create_function()] and [sqlite3_create_function16()]
+** for additional information.
+**
+** These functions work very much like the 
+** [sqlite3_bind_blob | sqlite3_bind_*] family of functions used
+** to bind values to host parameters in prepared statements.
+** Refer to the
+** [sqlite3_bind_blob | sqlite3_bind_* documentation] for
+** additional information.
+**
+** {F16402} The sqlite3_result_blob() interface sets the result from
+** an application defined function to be the BLOB whose content is pointed
+** to by the second parameter and which is N bytes long where N is the
+** third parameter. 
+** {F16403} The sqlite3_result_zeroblob() inerfaces set the result of
+** the application defined function to be a BLOB containing all zero
+** bytes and N bytes in size, where N is the value of the 2nd parameter.
+**
+** {F16407} The sqlite3_result_double() interface sets the result from
+** an application defined function to be a floating point value specified
+** by its 2nd argument.
+**
+** {F16409} The sqlite3_result_error() and sqlite3_result_error16() functions
+** cause the implemented SQL function to throw an exception.
+** {F16411} SQLite uses the string pointed to by the
+** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
+** as the text of an error message. {F16412} SQLite interprets the error
+** message string from sqlite3_result_error() as UTF8.  {F16413} SQLite
+** interprets the string from sqlite3_result_error16() as UTF16 in native
+** byte order.  {F16414} If the third parameter to sqlite3_result_error()
+** or sqlite3_result_error16() is negative then SQLite takes as the error
+** message all text up through the first zero character.
+** {F16415} If the third parameter to sqlite3_result_error() or
+** sqlite3_result_error16() is non-negative then SQLite takes that many
+** bytes (not characters) from the 2nd parameter as the error message.
+** {F16417} The sqlite3_result_error() and sqlite3_result_error16()
+** routines make a copy private copy of the error message text before
+** they return.  {END} Hence, the calling function can deallocate or
+** modify the text after they return without harm.
+** The sqlite3_result_error_code() function changes the error code
+** returned by SQLite as a result of an error in a function.  By default,
+** the error code is SQLITE_ERROR. 
+**
+** {F16421} The sqlite3_result_toobig() interface causes SQLite
+** to throw an error indicating that a string or BLOB is to long
+** to represent.  {F16422} The sqlite3_result_nomem() interface
+** causes SQLite to throw an exception indicating that the a
+** memory allocation failed.
+**
+** {F16431} The sqlite3_result_int() interface sets the return value
+** of the application-defined function to be the 32-bit signed integer
+** value given in the 2nd argument.
+** {F16432} The sqlite3_result_int64() interface sets the return value
+** of the application-defined function to be the 64-bit signed integer
+** value given in the 2nd argument.
+**
+** {F16437} The sqlite3_result_null() interface sets the return value
+** of the application-defined function to be NULL.
+**
+** {F16441} The sqlite3_result_text(), sqlite3_result_text16(), 
+** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
+** set the return value of the application-defined function to be
+** a text string which is represented as UTF-8, UTF-16 native byte order,
+** UTF-16 little endian, or UTF-16 big endian, respectively.
+** {F16442} SQLite takes the text result from the application from
+** the 2nd parameter of the sqlite3_result_text* interfaces.
+** {F16444} If the 3rd parameter to the sqlite3_result_text* interfaces
+** is negative, then SQLite takes result text from the 2nd parameter 
+** through the first zero character.
+** {F16447} If the 3rd parameter to the sqlite3_result_text* interfaces
+** is non-negative, then as many bytes (not characters) of the text
+** pointed to by the 2nd parameter are taken as the application-defined
+** function result.
+** {F16451} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
+** function as the destructor on the text or blob result when it has
+** finished using that result.
+** {F16453} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is the special constant SQLITE_STATIC, then
+** SQLite assumes that the text or blob result is constant space and
+** does not copy the space or call a destructor when it has
+** finished using that result.
+** {F16454} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
+** then SQLite makes a copy of the result into space obtained from
+** from [sqlite3_malloc()] before it returns.
+**
+** {F16461} The sqlite3_result_value() interface sets the result of
+** the application-defined function to be a copy the [sqlite3_value]
+** object specified by the 2nd parameter.  {F16463} The
+** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
+** so that [sqlite3_value] specified in the parameter may change or
+** be deallocated after sqlite3_result_value() returns without harm.
+**
+** {U16491} These routines are called from within the different thread 
+** than the one containing the application-defined function that recieved
+** the [sqlite3_context] pointer, the results are undefined.
+*/
+void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
+void sqlite3_result_double(sqlite3_context*, double);
+void sqlite3_result_error(sqlite3_context*, const char*, int);
+void sqlite3_result_error16(sqlite3_context*, const void*, int);
+void sqlite3_result_error_toobig(sqlite3_context*);
+void sqlite3_result_error_nomem(sqlite3_context*);
+void sqlite3_result_error_code(sqlite3_context*, int);
+void sqlite3_result_int(sqlite3_context*, int);
+void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
+void sqlite3_result_null(sqlite3_context*);
+void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
+void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
+void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
+void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
+void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
+void sqlite3_result_zeroblob(sqlite3_context*, int n);
+
+/*
+** CAPI3REF: Define New Collating Sequences {F16600}
+**
+** {F16601}
+** These functions are used to add new collation sequences to the
+** [sqlite3*] handle specified as the first argument. 
+**
+** {F16602}
+** The name of the new collation sequence is specified as a UTF-8 string
+** for sqlite3_create_collation() and sqlite3_create_collation_v2()
+** and a UTF-16 string for sqlite3_create_collation16(). {F16603} In all cases
+** the name is passed as the second function argument.
+**
+** {F16604}
+** The third argument may be one of the constants [SQLITE_UTF8],
+** [SQLITE_UTF16LE] or [SQLITE_UTF16BE], indicating that the user-supplied
+** routine expects to be passed pointers to strings encoded using UTF-8,
+** UTF-16 little-endian or UTF-16 big-endian respectively. {F16605} The
+** third argument might also be [SQLITE_UTF16_ALIGNED] to indicate that
+** the routine expects pointers to 16-bit word aligned strings
+** of UTF16 in the native byte order of the host computer.
+**
+** {F16607}
+** A pointer to the user supplied routine must be passed as the fifth
+** argument. {F16609} If it is NULL, this is the same as deleting the collation
+** sequence (so that SQLite cannot call it anymore).
+** {F16611} Each time the application
+** supplied function is invoked, it is passed a copy of the void* passed as
+** the fourth argument to sqlite3_create_collation() or
+** sqlite3_create_collation16() as its first parameter.
+**
+** {F16612}
+** The remaining arguments to the application-supplied routine are two strings,
+** each represented by a (length, data) pair and encoded in the encoding
+** that was passed as the third argument when the collation sequence was
+** registered. {END} The application defined collation routine should
+** return negative, zero or positive if
+** the first string is less than, equal to, or greater than the second
+** string. i.e. (STRING1 - STRING2).
+**
+** {F16615}
+** The sqlite3_create_collation_v2() works like sqlite3_create_collation()
+** excapt that it takes an extra argument which is a destructor for
+** the collation.  {F16617} The destructor is called when the collation is
+** destroyed and is passed a copy of the fourth parameter void* pointer
+** of the sqlite3_create_collation_v2().
+** {F16618}  Collations are destroyed when
+** they are overridden by later calls to the collation creation functions
+** or when the [sqlite3*] database handle is closed using [sqlite3_close()].
+*/
+int sqlite3_create_collation(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+int sqlite3_create_collation_v2(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*),
+  void(*xDestroy)(void*)
+);
+int sqlite3_create_collation16(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+
+/*
+** CAPI3REF: Collation Needed Callbacks {F16700}
+**
+** {F16701}
+** To avoid having to register all collation sequences before a database
+** can be used, a single callback function may be registered with the
+** database handle to be called whenever an undefined collation sequence is
+** required.
+**
+** {F16702}
+** If the function is registered using the sqlite3_collation_needed() API,
+** then it is passed the names of undefined collation sequences as strings
+** encoded in UTF-8. {F16703} If sqlite3_collation_needed16() is used, the names
+** are passed as UTF-16 in machine native byte order. {F16704} A call to either
+** function replaces any existing callback.
+**
+** {F16705} When the callback is invoked, the first argument passed is a copy
+** of the second argument to sqlite3_collation_needed() or
+** sqlite3_collation_needed16(). {F16706} The second argument is the database
+** handle.  {F16707} The third argument is one of [SQLITE_UTF8],
+** [SQLITE_UTF16BE], or [SQLITE_UTF16LE], indicating the most
+** desirable form of the collation sequence function required.
+** {F16708} The fourth parameter is the name of the
+** required collation sequence. {END}
+**
+** The callback function should register the desired collation using
+** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
+** [sqlite3_create_collation_v2()].
+*/
+int sqlite3_collation_needed(
+  sqlite3*, 
+  void*, 
+  void(*)(void*,sqlite3*,int eTextRep,const char*)
+);
+int sqlite3_collation_needed16(
+  sqlite3*, 
+  void*,
+  void(*)(void*,sqlite3*,int eTextRep,const void*)
+);
+
+/*
+** Specify the key for an encrypted database.  This routine should be
+** called right after sqlite3_open().
+**
+** The code to implement this API is not available in the public release
+** of SQLite.
+*/
+int sqlite3_key(
+  sqlite3 *db,                   /* Database to be rekeyed */
+  const void *pKey, int nKey     /* The key */
+);
+
+/*
+** Change the key on an open database.  If the current database is not
+** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
+** database is decrypted.
+**
+** The code to implement this API is not available in the public release
+** of SQLite.
+*/
+int sqlite3_rekey(
+  sqlite3 *db,                   /* Database to be rekeyed */
+  const void *pKey, int nKey     /* The new key */
+);
+
+/*
+** CAPI3REF:  Suspend Execution For A Short Time {F10530}
+**
+** {F10531} The sqlite3_sleep() function
+** causes the current thread to suspend execution
+** for at least a number of milliseconds specified in its parameter.
+**
+** {F10532} If the operating system does not support sleep requests with 
+** millisecond time resolution, then the time will be rounded up to 
+** the nearest second. {F10533} The number of milliseconds of sleep actually 
+** requested from the operating system is returned.
+**
+** {F10534} SQLite implements this interface by calling the xSleep()
+** method of the default [sqlite3_vfs] object. {END}
+*/
+int sqlite3_sleep(int);
+
+/*
+** CAPI3REF:  Name Of The Folder Holding Temporary Files {F10310}
+**
+** If this global variable is made to point to a string which is
+** the name of a folder (a.ka. directory), then all temporary files
+** created by SQLite will be placed in that directory.  If this variable
+** is NULL pointer, then SQLite does a search for an appropriate temporary
+** file directory.
+**
+** It is not safe to modify this variable once a database connection
+** has been opened.  It is intended that this variable be set once
+** as part of process initialization and before any SQLite interface
+** routines have been call and remain unchanged thereafter.
+*/
+SQLITE_EXTERN char *sqlite3_temp_directory;
+
+/*
+** CAPI3REF:  Test To See If The Database Is In Auto-Commit Mode {F12930}
+**
+** The sqlite3_get_autocommit() interfaces returns non-zero or
+** zero if the given database connection is or is not in autocommit mode,
+** respectively.   Autocommit mode is on
+** by default.  Autocommit mode is disabled by a [BEGIN] statement.
+** Autocommit mode is reenabled by a [COMMIT] or [ROLLBACK].
+**
+** If certain kinds of errors occur on a statement within a multi-statement
+** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], 
+** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
+** transaction might be rolled back automatically.  The only way to
+** find out if SQLite automatically rolled back the transaction after
+** an error is to use this function.
+**
+** INVARIANTS:
+**
+** {F12931} The [sqlite3_get_autocommit()] interface returns non-zero or
+**          zero if the given database connection is or is not in autocommit
+**          mode, respectively.
+**
+** {F12932} Autocommit mode is on by default.
+**
+** {F12933} Autocommit mode is disabled by a successful [BEGIN] statement.
+**
+** {F12934} Autocommit mode is enabled by a successful [COMMIT] or [ROLLBACK]
+**          statement.
+** 
+**
+** LIMITATIONS:
+***
+** {U12936} If another thread changes the autocommit status of the database
+**          connection while this routine is running, then the return value
+**          is undefined.
+*/
+int sqlite3_get_autocommit(sqlite3*);
+
+/*
+** CAPI3REF:  Find The Database Handle Of A Prepared Statement {F13120}
+**
+** {F13121} The sqlite3_db_handle interface
+** returns the [sqlite3*] database handle to which a
+** [prepared statement] belongs.
+** {F13122} the database handle returned by sqlite3_db_handle
+** is the same database handle that was
+** the first argument to the [sqlite3_prepare_v2()] or its variants
+** that was used to create the statement in the first place.
+*/
+sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
+
+
+/*
+** CAPI3REF: Commit And Rollback Notification Callbacks {F12950}
+**
+** {F12951} The sqlite3_commit_hook() interface registers a callback
+** function to be invoked whenever a transaction is committed.
+** {F12952} Any callback set by a previous call to sqlite3_commit_hook()
+** for the same database connection is overridden.
+** {F12953} The sqlite3_rollback_hook() interface registers a callback
+** function to be invoked whenever a transaction is committed.
+** {F12954} Any callback set by a previous call to sqlite3_commit_hook()
+** for the same database connection is overridden.
+** {F12956} The pArg argument is passed through
+** to the callback.  {F12957} If the callback on a commit hook function 
+** returns non-zero, then the commit is converted into a rollback.
+**
+** {F12958} If another function was previously registered, its
+** pArg value is returned.  Otherwise NULL is returned.
+**
+** {F12959} Registering a NULL function disables the callback.
+**
+** {F12961} For the purposes of this API, a transaction is said to have been 
+** rolled back if an explicit "ROLLBACK" statement is executed, or
+** an error or constraint causes an implicit rollback to occur.
+** {F12962} The rollback callback is not invoked if a transaction is
+** automatically rolled back because the database connection is closed.
+** {F12964} The rollback callback is not invoked if a transaction is
+** rolled back because a commit callback returned non-zero.
+** <todo> Check on this </todo> {END}
+**
+** These are experimental interfaces and are subject to change.
+*/
+void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
+void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
+
+/*
+** CAPI3REF: Data Change Notification Callbacks {F12970}
+**
+** {F12971} The sqlite3_update_hook() interface
+** registers a callback function with the database connection identified by the 
+** first argument to be invoked whenever a row is updated, inserted or deleted.
+** {F12972} Any callback set by a previous call to this function for the same 
+** database connection is overridden.
+**
+** {F12974} The second argument is a pointer to the function to invoke when a 
+** row is updated, inserted or deleted. 
+** {F12976} The first argument to the callback is
+** a copy of the third argument to sqlite3_update_hook().
+** {F12977} The second callback 
+** argument is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
+** depending on the operation that caused the callback to be invoked.
+** {F12978} The third and 
+** fourth arguments to the callback contain pointers to the database and 
+** table name containing the affected row.
+** {F12979} The final callback parameter is 
+** the rowid of the row.
+** {F12981} In the case of an update, this is the rowid after 
+** the update takes place.
+**
+** {F12983} The update hook is not invoked when internal system tables are
+** modified (i.e. sqlite_master and sqlite_sequence).
+**
+** {F12984} If another function was previously registered, its pArg value
+** is returned.  {F12985} Otherwise NULL is returned.
+*/
+void *sqlite3_update_hook(
+  sqlite3*, 
+  void(*)(void *,int ,char const *,char const *,sqlite3_int64),
+  void*
+);
+
+/*
+** CAPI3REF:  Enable Or Disable Shared Pager Cache {F10330}
+**
+** {F10331}
+** This routine enables or disables the sharing of the database cache
+** and schema data structures between connections to the same database.
+** {F10332}
+** Sharing is enabled if the argument is true and disabled if the argument
+** is false.
+**
+** {F10333} Cache sharing is enabled and disabled
+** for an entire process. {END} This is a change as of SQLite version 3.5.0.
+** In prior versions of SQLite, sharing was
+** enabled or disabled for each thread separately.
+**
+** {F10334}
+** The cache sharing mode set by this interface effects all subsequent
+** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
+** {F10335} Existing database connections continue use the sharing mode
+** that was in effect at the time they were opened. {END}
+**
+** Virtual tables cannot be used with a shared cache.  {F10336} When shared
+** cache is enabled, the [sqlite3_create_module()] API used to register
+** virtual tables will always return an error. {END}
+**
+** {F10337} This routine returns [SQLITE_OK] if shared cache was
+** enabled or disabled successfully.  {F10338} An [error code]
+** is returned otherwise. {END}
+**
+** {F10339} Shared cache is disabled by default. {END} But this might change in
+** future releases of SQLite.  Applications that care about shared
+** cache setting should set it explicitly.
+*/
+int sqlite3_enable_shared_cache(int);
+
+/*
+** CAPI3REF:  Attempt To Free Heap Memory {F17340}
+**
+** {F17341} The sqlite3_release_memory() interface attempts to
+** free N bytes of heap memory by deallocating non-essential memory
+** allocations held by the database labrary. {END}  Memory used
+** to cache database pages to improve performance is an example of
+** non-essential memory.  {F16342} sqlite3_release_memory() returns
+** the number of bytes actually freed, which might be more or less
+** than the amount requested.
+*/
+int sqlite3_release_memory(int);
+
+/*
+** CAPI3REF:  Impose A Limit On Heap Size {F17350}
+**
+** {F16351} The sqlite3_soft_heap_limit() interface
+** places a "soft" limit on the amount of heap memory that may be allocated
+** by SQLite. {F16352} If an internal allocation is requested 
+** that would exceed the soft heap limit, [sqlite3_release_memory()] is
+** invoked one or more times to free up some space before the allocation
+** is made. {END}
+**
+** {F16353} The limit is called "soft", because if
+** [sqlite3_release_memory()] cannot
+** free sufficient memory to prevent the limit from being exceeded,
+** the memory is allocated anyway and the current operation proceeds.
+**
+** {F16354}
+** A negative or zero value for N means that there is no soft heap limit and
+** [sqlite3_release_memory()] will only be called when memory is exhausted.
+** {F16355} The default value for the soft heap limit is zero.
+**
+** SQLite makes a best effort to honor the soft heap limit.  
+** {F16356} But if the soft heap limit cannot honored, execution will
+** continue without error or notification. {END}  This is why the limit is 
+** called a "soft" limit.  It is advisory only.
+**
+** Prior to SQLite version 3.5.0, this routine only constrained the memory
+** allocated by a single thread - the same thread in which this routine
+** runs.  Beginning with SQLite version 3.5.0, the soft heap limit is
+** applied to all threads. {F16357} The value specified for the soft heap limit
+** is an upper bound on the total memory allocation for all threads. {END}  In
+** version 3.5.0 there is no mechanism for limiting the heap usage for
+** individual threads.
+*/
+void sqlite3_soft_heap_limit(int);
+
+/*
+** CAPI3REF:  Extract Metadata About A Column Of A Table {F12850}
+**
+** This routine
+** returns meta-data about a specific column of a specific database
+** table accessible using the connection handle passed as the first function 
+** argument.
+**
+** The column is identified by the second, third and fourth parameters to 
+** this function. The second parameter is either the name of the database
+** (i.e. "main", "temp" or an attached database) containing the specified
+** table or NULL. If it is NULL, then all attached databases are searched
+** for the table using the same algorithm as the database engine uses to 
+** resolve unqualified table references.
+**
+** The third and fourth parameters to this function are the table and column 
+** name of the desired column, respectively. Neither of these parameters 
+** may be NULL.
+**
+** Meta information is returned by writing to the memory locations passed as
+** the 5th and subsequent parameters to this function. Any of these 
+** arguments may be NULL, in which case the corresponding element of meta 
+** information is ommitted.
+**
+** <pre>
+** Parameter     Output Type      Description
+** -----------------------------------
+**
+**   5th         const char*      Data type
+**   6th         const char*      Name of the default collation sequence 
+**   7th         int              True if the column has a NOT NULL constraint
+**   8th         int              True if the column is part of the PRIMARY KEY
+**   9th         int              True if the column is AUTOINCREMENT
+** </pre>
+**
+**
+** The memory pointed to by the character pointers returned for the 
+** declaration type and collation sequence is valid only until the next 
+** call to any sqlite API function.
+**
+** If the specified table is actually a view, then an error is returned.
+**
+** If the specified column is "rowid", "oid" or "_rowid_" and an 
+** INTEGER PRIMARY KEY column has been explicitly declared, then the output 
+** parameters are set for the explicitly declared column. If there is no
+** explicitly declared IPK column, then the output parameters are set as 
+** follows:
+**
+** <pre>
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+** </pre>
+**
+** This function may load one or more schemas from database files. If an
+** error occurs during this process, or if the requested table or column
+** cannot be found, an SQLITE error code is returned and an error message
+** left in the database handle (to be retrieved using sqlite3_errmsg()).
+**
+** This API is only available if the library was compiled with the
+** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined.
+*/
+int sqlite3_table_column_metadata(
+  sqlite3 *db,                /* Connection handle */
+  const char *zDbName,        /* Database name or NULL */
+  const char *zTableName,     /* Table name */
+  const char *zColumnName,    /* Column name */
+  char const **pzDataType,    /* OUTPUT: Declared data type */
+  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
+  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
+  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
+  int *pAutoinc               /* OUTPUT: True if column is auto-increment */
+);
+
+/*
+** CAPI3REF: Load An Extension {F12600}
+**
+** {F12601} The sqlite3_load_extension() interface
+** attempts to load an SQLite extension library contained in the file
+** zFile. {F12602} The entry point is zProc. {F12603} zProc may be 0
+** in which case the name of the entry point defaults
+** to "sqlite3_extension_init".
+**
+** {F12604} The sqlite3_load_extension() interface shall
+** return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
+**
+** {F12605}
+** If an error occurs and pzErrMsg is not 0, then the
+** sqlite3_load_extension() interface shall attempt to fill *pzErrMsg with 
+** error message text stored in memory obtained from [sqlite3_malloc()].
+** {END}  The calling function should free this memory
+** by calling [sqlite3_free()].
+**
+** {F12606}
+** Extension loading must be enabled using [sqlite3_enable_load_extension()]
+** prior to calling this API or an error will be returned.
+*/
+int sqlite3_load_extension(
+  sqlite3 *db,          /* Load the extension into this database connection */
+  const char *zFile,    /* Name of the shared library containing extension */
+  const char *zProc,    /* Entry point.  Derived from zFile if 0 */
+  char **pzErrMsg       /* Put error message here if not 0 */
+);
+
+/*
+** CAPI3REF:  Enable Or Disable Extension Loading {F12620}
+**
+** So as not to open security holes in older applications that are
+** unprepared to deal with extension loading, and as a means of disabling
+** extension loading while evaluating user-entered SQL, the following
+** API is provided to turn the [sqlite3_load_extension()] mechanism on and
+** off.  {F12622} It is off by default. {END} See ticket #1863.
+**
+** {F12621} Call the sqlite3_enable_load_extension() routine
+** with onoff==1 to turn extension loading on
+** and call it with onoff==0 to turn it back off again. {END}
+*/
+int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
+
+/*
+** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640}
+**
+** {F12641} This function
+** registers an extension entry point that is automatically invoked
+** whenever a new database connection is opened using
+** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. {END}
+**
+** This API can be invoked at program startup in order to register
+** one or more statically linked extensions that will be available
+** to all new database connections.
+**
+** {F12642} Duplicate extensions are detected so calling this routine multiple
+** times with the same extension is harmless.
+**
+** {F12643} This routine stores a pointer to the extension in an array
+** that is obtained from sqlite_malloc(). {END} If you run a memory leak
+** checker on your program and it reports a leak because of this
+** array, then invoke [sqlite3_reset_auto_extension()] prior
+** to shutdown to free the memory.
+**
+** {F12644} Automatic extensions apply across all threads. {END}
+**
+** This interface is experimental and is subject to change or
+** removal in future releases of SQLite.
+*/
+int sqlite3_auto_extension(void *xEntryPoint);
+
+
+/*
+** CAPI3REF: Reset Automatic Extension Loading {F12660}
+**
+** {F12661} This function disables all previously registered
+** automatic extensions. {END}  This
+** routine undoes the effect of all prior [sqlite3_auto_extension()]
+** calls.
+**
+** {F12662} This call disabled automatic extensions in all threads. {END}
+**
+** This interface is experimental and is subject to change or
+** removal in future releases of SQLite.
+*/
+void sqlite3_reset_auto_extension(void);
+
+
+/*
+****** EXPERIMENTAL - subject to change without notice **************
+**
+** The interface to the virtual-table mechanism is currently considered
+** to be experimental.  The interface might change in incompatible ways.
+** If this is a problem for you, do not use the interface at this time.
+**
+** When the virtual-table mechanism stablizes, we will declare the
+** interface fixed, support it indefinitely, and remove this comment.
+*/
+
+/*
+** Structures used by the virtual table interface
+*/
+typedef struct sqlite3_vtab sqlite3_vtab;
+typedef struct sqlite3_index_info sqlite3_index_info;
+typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
+typedef struct sqlite3_module sqlite3_module;
+
+/*
+** A module is a class of virtual tables.  Each module is defined
+** by an instance of the following structure.  This structure consists
+** mostly of methods for the module.
+*/
+struct sqlite3_module {
+  int iVersion;
+  int (*xCreate)(sqlite3*, void *pAux,
+               int argc, const char *const*argv,
+               sqlite3_vtab **ppVTab, char**);
+  int (*xConnect)(sqlite3*, void *pAux,
+               int argc, const char *const*argv,
+               sqlite3_vtab **ppVTab, char**);
+  int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
+  int (*xDisconnect)(sqlite3_vtab *pVTab);
+  int (*xDestroy)(sqlite3_vtab *pVTab);
+  int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
+  int (*xClose)(sqlite3_vtab_cursor*);
+  int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
+                int argc, sqlite3_value **argv);
+  int (*xNext)(sqlite3_vtab_cursor*);
+  int (*xEof)(sqlite3_vtab_cursor*);
+  int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
+  int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
+  int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
+  int (*xBegin)(sqlite3_vtab *pVTab);
+  int (*xSync)(sqlite3_vtab *pVTab);
+  int (*xCommit)(sqlite3_vtab *pVTab);
+  int (*xRollback)(sqlite3_vtab *pVTab);
+  int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
+                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+                       void **ppArg);
+
+  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
+};
+
+/*
+** The sqlite3_index_info structure and its substructures is used to
+** pass information into and receive the reply from the xBestIndex
+** method of an sqlite3_module.  The fields under **Inputs** are the
+** inputs to xBestIndex and are read-only.  xBestIndex inserts its
+** results into the **Outputs** fields.
+**
+** The aConstraint[] array records WHERE clause constraints of the
+** form:
+**
+**         column OP expr
+**
+** Where OP is =, &lt;, &lt;=, &gt;, or &gt;=.  
+** The particular operator is stored
+** in aConstraint[].op.  The index of the column is stored in 
+** aConstraint[].iColumn.  aConstraint[].usable is TRUE if the
+** expr on the right-hand side can be evaluated (and thus the constraint
+** is usable) and false if it cannot.
+**
+** The optimizer automatically inverts terms of the form "expr OP column"
+** and makes other simplifications to the WHERE clause in an attempt to
+** get as many WHERE clause terms into the form shown above as possible.
+** The aConstraint[] array only reports WHERE clause terms in the correct
+** form that refer to the particular virtual table being queried.
+**
+** Information about the ORDER BY clause is stored in aOrderBy[].
+** Each term of aOrderBy records a column of the ORDER BY clause.
+**
+** The xBestIndex method must fill aConstraintUsage[] with information
+** about what parameters to pass to xFilter.  If argvIndex>0 then
+** the right-hand side of the corresponding aConstraint[] is evaluated
+** and becomes the argvIndex-th entry in argv.  If aConstraintUsage[].omit
+** is true, then the constraint is assumed to be fully handled by the
+** virtual table and is not checked again by SQLite.
+**
+** The idxNum and idxPtr values are recorded and passed into xFilter.
+** sqlite3_free() is used to free idxPtr if needToFreeIdxPtr is true.
+**
+** The orderByConsumed means that output from xFilter will occur in
+** the correct order to satisfy the ORDER BY clause so that no separate
+** sorting step is required.
+**
+** The estimatedCost value is an estimate of the cost of doing the
+** particular lookup.  A full scan of a table with N entries should have
+** a cost of N.  A binary search of a table of N entries should have a
+** cost of approximately log(N).
+*/
+struct sqlite3_index_info {
+  /* Inputs */
+  int nConstraint;           /* Number of entries in aConstraint */
+  struct sqlite3_index_constraint {
+     int iColumn;              /* Column on left-hand side of constraint */
+     unsigned char op;         /* Constraint operator */
+     unsigned char usable;     /* True if this constraint is usable */
+     int iTermOffset;          /* Used internally - xBestIndex should ignore */
+  } *aConstraint;            /* Table of WHERE clause constraints */
+  int nOrderBy;              /* Number of terms in the ORDER BY clause */
+  struct sqlite3_index_orderby {
+     int iColumn;              /* Column number */
+     unsigned char desc;       /* True for DESC.  False for ASC. */
+  } *aOrderBy;               /* The ORDER BY clause */
+
+  /* Outputs */
+  struct sqlite3_index_constraint_usage {
+    int argvIndex;           /* if >0, constraint is part of argv to xFilter */
+    unsigned char omit;      /* Do not code a test for this constraint */
+  } *aConstraintUsage;
+  int idxNum;                /* Number used to identify the index */
+  char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
+  int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
+  int orderByConsumed;       /* True if output is already ordered */
+  double estimatedCost;      /* Estimated cost of using this index */
+};
+#define SQLITE_INDEX_CONSTRAINT_EQ    2
+#define SQLITE_INDEX_CONSTRAINT_GT    4
+#define SQLITE_INDEX_CONSTRAINT_LE    8
+#define SQLITE_INDEX_CONSTRAINT_LT    16
+#define SQLITE_INDEX_CONSTRAINT_GE    32
+#define SQLITE_INDEX_CONSTRAINT_MATCH 64
+
+/*
+** This routine is used to register a new module name with an SQLite
+** connection.  Module names must be registered before creating new
+** virtual tables on the module, or before using preexisting virtual
+** tables of the module.
+*/
+int sqlite3_create_module(
+  sqlite3 *db,               /* SQLite connection to register module with */
+  const char *zName,         /* Name of the module */
+  const sqlite3_module *,    /* Methods for the module */
+  void *                     /* Client data for xCreate/xConnect */
+);
+
+/*
+** This routine is identical to the sqlite3_create_module() method above,
+** except that it allows a destructor function to be specified. It is
+** even more experimental than the rest of the virtual tables API.
+*/
+int sqlite3_create_module_v2(
+  sqlite3 *db,               /* SQLite connection to register module with */
+  const char *zName,         /* Name of the module */
+  const sqlite3_module *,    /* Methods for the module */
+  void *,                    /* Client data for xCreate/xConnect */
+  void(*xDestroy)(void*)     /* Module destructor function */
+);
+
+/*
+** Every module implementation uses a subclass of the following structure
+** to describe a particular instance of the module.  Each subclass will
+** be tailored to the specific needs of the module implementation.   The
+** purpose of this superclass is to define certain fields that are common
+** to all module implementations.
+**
+** Virtual tables methods can set an error message by assigning a
+** string obtained from sqlite3_mprintf() to zErrMsg.  The method should
+** take care that any prior string is freed by a call to sqlite3_free()
+** prior to assigning a new string to zErrMsg.  After the error message
+** is delivered up to the client application, the string will be automatically
+** freed by sqlite3_free() and the zErrMsg field will be zeroed.  Note
+** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field
+** since virtual tables are commonly implemented in loadable extensions which
+** do not have access to sqlite3MPrintf() or sqlite3Free().
+*/
+struct sqlite3_vtab {
+  const sqlite3_module *pModule;  /* The module for this virtual table */
+  int nRef;                       /* Used internally */
+  char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
+  /* Virtual table implementations will typically add additional fields */
+};
+
+/* Every module implementation uses a subclass of the following structure
+** to describe cursors that point into the virtual table and are used
+** to loop through the virtual table.  Cursors are created using the
+** xOpen method of the module.  Each module implementation will define
+** the content of a cursor structure to suit its own needs.
+**
+** This superclass exists in order to define fields of the cursor that
+** are common to all implementations.
+*/
+struct sqlite3_vtab_cursor {
+  sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
+  /* Virtual table implementations will typically add additional fields */
+};
+
+/*
+** The xCreate and xConnect methods of a module use the following API
+** to declare the format (the names and datatypes of the columns) of
+** the virtual tables they implement.
+*/
+int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable);
+
+/*
+** Virtual tables can provide alternative implementations of functions
+** using the xFindFunction method.  But global versions of those functions
+** must exist in order to be overloaded.
+**
+** This API makes sure a global version of a function with a particular
+** name and number of parameters exists.  If no such function exists
+** before this API is called, a new function is created.  The implementation
+** of the new function always causes an exception to be thrown.  So
+** the new function is not good for anything by itself.  Its only
+** purpose is to be a place-holder function that can be overloaded
+** by virtual tables.
+**
+** This API should be considered part of the virtual table interface,
+** which is experimental and subject to change.
+*/
+int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
+
+/*
+** The interface to the virtual-table mechanism defined above (back up
+** to a comment remarkably similar to this one) is currently considered
+** to be experimental.  The interface might change in incompatible ways.
+** If this is a problem for you, do not use the interface at this time.
+**
+** When the virtual-table mechanism stabilizes, we will declare the
+** interface fixed, support it indefinitely, and remove this comment.
+**
+****** EXPERIMENTAL - subject to change without notice **************
+*/
+
+/*
+** CAPI3REF: A Handle To An Open BLOB {F17800}
+**
+** An instance of the following opaque structure is used to 
+** represent an blob-handle.  A blob-handle is created by
+** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()].
+** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
+** can be used to read or write small subsections of the blob.
+** The [sqlite3_blob_bytes()] interface returns the size of the
+** blob in bytes.
+*/
+typedef struct sqlite3_blob sqlite3_blob;
+
+/*
+** CAPI3REF: Open A BLOB For Incremental I/O {F17810}
+**
+** {F17811} This interfaces opens a handle to the blob located
+** in row iRow,, column zColumn, table zTable in database zDb;
+** in other words,  the same blob that would be selected by:
+**
+** <pre>
+**     SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;
+** </pre> {END}
+**
+** {F17812} If the flags parameter is non-zero, the blob is opened for 
+** read and write access. If it is zero, the blob is opened for read 
+** access. {END}
+**
+** {F17813} On success, [SQLITE_OK] is returned and the new 
+** [sqlite3_blob | blob handle] is written to *ppBlob. 
+** {F17814} Otherwise an error code is returned and 
+** any value written to *ppBlob should not be used by the caller.
+** {F17815} This function sets the database-handle error code and message
+** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()].
+** <todo>We should go through and mark all interfaces that behave this
+** way with a similar statement</todo>
+*/
+int sqlite3_blob_open(
+  sqlite3*,
+  const char *zDb,
+  const char *zTable,
+  const char *zColumn,
+  sqlite3_int64 iRow,
+  int flags,
+  sqlite3_blob **ppBlob
+);
+
+/*
+** CAPI3REF:  Close A BLOB Handle {F17830}
+**
+** Close an open [sqlite3_blob | blob handle].
+**
+** {F17831} Closing a BLOB shall cause the current transaction to commit
+** if there are no other BLOBs, no pending prepared statements, and the
+** database connection is in autocommit mode.
+** {F17832} If any writes were made to the BLOB, they might be held in cache
+** until the close operation if they will fit. {END}
+** Closing the BLOB often forces the changes
+** out to disk and so if any I/O errors occur, they will likely occur
+** at the time when the BLOB is closed.  {F17833} Any errors that occur during
+** closing are reported as a non-zero return value.
+**
+** {F17839} The BLOB is closed unconditionally.  Even if this routine returns
+** an error code, the BLOB is still closed.
+*/
+int sqlite3_blob_close(sqlite3_blob *);
+
+/*
+** CAPI3REF:  Return The Size Of An Open BLOB {F17805}
+**
+** {F16806} Return the size in bytes of the blob accessible via the open 
+** [sqlite3_blob | blob-handle] passed as an argument.
+*/
+int sqlite3_blob_bytes(sqlite3_blob *);
+
+/*
+** CAPI3REF:  Read Data From A BLOB Incrementally {F17850}
+**
+** This function is used to read data from an open 
+** [sqlite3_blob | blob-handle] into a caller supplied buffer.
+** {F17851} n bytes of data are copied into buffer
+** z from the open blob, starting at offset iOffset.
+**
+** {F17852} If offset iOffset is less than n bytes from the end of the blob, 
+** [SQLITE_ERROR] is returned and no data is read.  {F17853} If n is
+** less than zero [SQLITE_ERROR] is returned and no data is read.
+**
+** {F17854} On success, SQLITE_OK is returned. Otherwise, an 
+** [error code] or an [extended error code] is returned.
+*/
+int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset);
+
+/*
+** CAPI3REF:  Write Data Into A BLOB Incrementally {F17870}
+**
+** This function is used to write data into an open 
+** [sqlite3_blob | blob-handle] from a user supplied buffer.
+** {F17871} n bytes of data are copied from the buffer
+** pointed to by z into the open blob, starting at offset iOffset.
+**
+** {F17872} If the [sqlite3_blob | blob-handle] passed as the first argument
+** was not opened for writing (the flags parameter to [sqlite3_blob_open()]
+*** was zero), this function returns [SQLITE_READONLY].
+**
+** {F17873} This function may only modify the contents of the blob; it is
+** not possible to increase the size of a blob using this API.
+** {F17874} If offset iOffset is less than n bytes from the end of the blob, 
+** [SQLITE_ERROR] is returned and no data is written.  {F17875} If n is
+** less than zero [SQLITE_ERROR] is returned and no data is written.
+**
+** {F17876} On success, SQLITE_OK is returned. Otherwise, an 
+** [error code] or an [extended error code] is returned.
+*/
+int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
+
+/*
+** CAPI3REF:  Virtual File System Objects {F11200}
+**
+** A virtual filesystem (VFS) is an [sqlite3_vfs] object
+** that SQLite uses to interact
+** with the underlying operating system.  Most builds come with a
+** single default VFS that is appropriate for the host computer.
+** New VFSes can be registered and existing VFSes can be unregistered.
+** The following interfaces are provided.
+**
+** {F11201} The sqlite3_vfs_find() interface returns a pointer to 
+** a VFS given its name.  {F11202} Names are case sensitive.
+** {F11203} Names are zero-terminated UTF-8 strings.
+** {F11204} If there is no match, a NULL
+** pointer is returned. {F11205} If zVfsName is NULL then the default 
+** VFS is returned. {END}
+**
+** {F11210} New VFSes are registered with sqlite3_vfs_register().
+** {F11211} Each new VFS becomes the default VFS if the makeDflt flag is set.
+** {F11212} The same VFS can be registered multiple times without injury.
+** {F11213} To make an existing VFS into the default VFS, register it again
+** with the makeDflt flag set. {U11214} If two different VFSes with the
+** same name are registered, the behavior is undefined.  {U11215} If a
+** VFS is registered with a name that is NULL or an empty string,
+** then the behavior is undefined.
+** 
+** {F11220} Unregister a VFS with the sqlite3_vfs_unregister() interface.
+** {F11221} If the default VFS is unregistered, another VFS is chosen as
+** the default.  The choice for the new VFS is arbitrary.
+*/
+sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
+int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
+int sqlite3_vfs_unregister(sqlite3_vfs*);
+
+/*
+** CAPI3REF: Mutexes {F17000}
+**
+** The SQLite core uses these routines for thread
+** synchronization.  Though they are intended for internal
+** use by SQLite, code that links against SQLite is
+** permitted to use any of these routines.
+**
+** The SQLite source code contains multiple implementations 
+** of these mutex routines.  An appropriate implementation
+** is selected automatically at compile-time.  The following
+** implementations are available in the SQLite core:
+**
+** <ul>
+** <li>   SQLITE_MUTEX_OS2
+** <li>   SQLITE_MUTEX_PTHREAD
+** <li>   SQLITE_MUTEX_W32
+** <li>   SQLITE_MUTEX_NOOP
+** </ul>
+**
+** The SQLITE_MUTEX_NOOP implementation is a set of routines 
+** that does no real locking and is appropriate for use in 
+** a single-threaded application.  The SQLITE_MUTEX_OS2,
+** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations
+** are appropriate for use on os/2, unix, and windows.
+** 
+** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
+** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
+** implementation is included with the library.  The
+** mutex interface routines defined here become external
+** references in the SQLite library for which implementations
+** must be provided by the application.  This facility allows an
+** application that links against SQLite to provide its own mutex
+** implementation without having to modify the SQLite core.
+**
+** {F17011} The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it. {F17012} If it returns NULL
+** that means that a mutex could not be allocated. {F17013} SQLite
+** will unwind its stack and return an error. {F17014} The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST
+** <li>  SQLITE_MUTEX_RECURSIVE
+** <li>  SQLITE_MUTEX_STATIC_MASTER
+** <li>  SQLITE_MUTEX_STATIC_MEM
+** <li>  SQLITE_MUTEX_STATIC_MEM2
+** <li>  SQLITE_MUTEX_STATIC_PRNG
+** <li>  SQLITE_MUTEX_STATIC_LRU
+** </ul> {END}
+**
+** {F17015} The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END}
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  {F17016} But SQLite will only request a recursive mutex in
+** cases where it really needs one.  {END} If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** {F17017} The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex. {END}  Four static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** {F17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  {F17034} But for the static 
+** mutex types, the same mutex is returned on every call that has
+** the same type number. {END}
+**
+** {F17019} The sqlite3_mutex_free() routine deallocates a previously
+** allocated dynamic mutex. {F17020} SQLite is careful to deallocate every
+** dynamic mutex that it allocates. {U17021} The dynamic mutexes must not be in 
+** use when they are deallocated. {U17022} Attempting to deallocate a static
+** mutex results in undefined behavior. {F17023} SQLite never deallocates
+** a static mutex. {END}
+**
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex. {F17024} If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY. {F17025}  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  {F17026} Mutexes created using
+** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
+** {F17027} In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  {U17028} If the same thread tries to enter any other
+** kind of mutex more than once, the behavior is undefined.
+** {F17029} SQLite will never exhibit
+** such behavior in its own use of mutexes. {END}
+**
+** Some systems (ex: windows95) do not the operation implemented by
+** sqlite3_mutex_try().  On those systems, sqlite3_mutex_try() will
+** always return SQLITE_BUSY.  {F17030} The SQLite core only ever uses
+** sqlite3_mutex_try() as an optimization so this is acceptable behavior. {END}
+**
+** {F17031} The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  {U17032} The behavior
+** is undefined if the mutex is not currently entered by the
+** calling thread or is not currently allocated.  {F17033} SQLite will
+** never do either. {END}
+**
+** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int);
+void sqlite3_mutex_free(sqlite3_mutex*);
+void sqlite3_mutex_enter(sqlite3_mutex*);
+int sqlite3_mutex_try(sqlite3_mutex*);
+void sqlite3_mutex_leave(sqlite3_mutex*);
+
+/*
+** CAPI3REF: Mutex Verifcation Routines {F17080}
+**
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
+** are intended for use inside assert() statements. {F17081} The SQLite core
+** never uses these routines except inside an assert() and applications
+** are advised to follow the lead of the core.  {F17082} The core only
+** provides implementations for these routines when it is compiled
+** with the SQLITE_DEBUG flag.  {U17087} External mutex implementations
+** are only required to provide these routines if SQLITE_DEBUG is
+** defined and if NDEBUG is not defined.
+**
+** {F17083} These routines should return true if the mutex in their argument
+** is held or not held, respectively, by the calling thread. {END}
+**
+** {X17084} The implementation is not required to provided versions of these
+** routines that actually work.
+** If the implementation does not provide working
+** versions of these routines, it should at least provide stubs
+** that always return true so that one does not get spurious
+** assertion failures. {END}
+**
+** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then
+** the routine should return 1.  {END} This seems counter-intuitive since
+** clearly the mutex cannot be held if it does not exist.  But the
+** the reason the mutex does not exist is because the build is not
+** using mutexes.  And we do not want the assert() containing the
+** call to sqlite3_mutex_held() to fail, so a non-zero return is
+** the appropriate thing to do.  {F17086} The sqlite3_mutex_notheld() 
+** interface should also return 1 when given a NULL pointer.
+*/
+int sqlite3_mutex_held(sqlite3_mutex*);
+int sqlite3_mutex_notheld(sqlite3_mutex*);
+
+/*
+** CAPI3REF: Mutex Types {F17001}
+**
+** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument
+** which is one of these integer constants. {END}
+*/
+#define SQLITE_MUTEX_FAST             0
+#define SQLITE_MUTEX_RECURSIVE        1
+#define SQLITE_MUTEX_STATIC_MASTER    2
+#define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
+#define SQLITE_MUTEX_STATIC_MEM2      4  /* sqlite3_release_memory() */
+#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
+#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
+
+/*
+** CAPI3REF: Low-Level Control Of Database Files {F11300}
+**
+** {F11301} The [sqlite3_file_control()] interface makes a direct call to the
+** xFileControl method for the [sqlite3_io_methods] object associated
+** with a particular database identified by the second argument. {F11302} The
+** name of the database is the name assigned to the database by the
+** <a href="lang_attach.html">ATTACH</a> SQL command that opened the
+** database. {F11303} To control the main database file, use the name "main"
+** or a NULL pointer. {F11304} The third and fourth parameters to this routine
+** are passed directly through to the second and third parameters of
+** the xFileControl method.  {F11305} The return value of the xFileControl
+** method becomes the return value of this routine.
+**
+** {F11306} If the second parameter (zDbName) does not match the name of any
+** open database file, then SQLITE_ERROR is returned. {F11307} This error
+** code is not remembered and will not be recalled by [sqlite3_errcode()]
+** or [sqlite3_errmsg()]. {U11308} The underlying xFileControl method might
+** also return SQLITE_ERROR.  {U11309} There is no way to distinguish between
+** an incorrect zDbName and an SQLITE_ERROR return from the underlying
+** xFileControl method. {END}
+**
+** See also: [SQLITE_FCNTL_LOCKSTATE]
+*/
+int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
+
+/*
+** CAPI3REF: Testing Interface {F11400}
+**
+** The sqlite3_test_control() interface is used to read out internal
+** state of SQLite and to inject faults into SQLite for testing
+** purposes.  The first parameter a operation code that determines
+** the number, meaning, and operation of all subsequent parameters.
+**
+** This interface is not for use by applications.  It exists solely
+** for verifying the correct operation of the SQLite library.  Depending
+** on how the SQLite library is compiled, this interface might not exist.
+**
+** The details of the operation codes, their meanings, the parameters
+** they take, and what they do are all subject to change without notice.
+** Unlike most of the SQLite API, this function is not guaranteed to
+** operate consistently from one release to the next.
+*/
+int sqlite3_test_control(int op, ...);
+
+/*
+** CAPI3REF: Testing Interface Operation Codes {F11410}
+**
+** These constants are the valid operation code parameters used
+** as the first argument to [sqlite3_test_control()].
+**
+** These parameters and their meansing are subject to change
+** without notice.  These values are for testing purposes only.
+** Applications should not use any of these parameters or the
+** [sqlite3_test_control()] interface.
+*/
+#define SQLITE_TESTCTRL_FAULT_CONFIG             1
+#define SQLITE_TESTCTRL_FAULT_FAILURES           2
+#define SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES    3
+#define SQLITE_TESTCTRL_FAULT_PENDING            4
+
+
+
+
+
+/*
+** Undo the hack that converts floating point types to integer for
+** builds on processors without floating point support.
+*/
+#ifdef SQLITE_OMIT_FLOATING_POINT
+# undef double
+#endif
+
+#ifdef __cplusplus
+}  /* End of the 'extern "C"' block */
+#endif
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/README.txt b/client/src/thirdparty/sqlite-3.4.2/ext/README.txt
new file mode 100644
index 0000000..009495f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/README.txt
@@ -0,0 +1,2 @@
+Version loadable extensions to SQLite are found in subfolders
+of this folder.
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Entries b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Entries
new file mode 100644
index 0000000..511e1a0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Entries
@@ -0,0 +1,15 @@
+/README.txt/1.1/Tue Aug 22 14:45:37 2006//
+/fts1.h/1.2/Wed Sep 13 18:40:26 2006//
+/fts1_hash.c/1.1/Thu Aug 31 15:07:15 2006//
+/fts1_hash.h/1.1/Thu Aug 31 15:07:15 2006//
+/fts1_porter.c/1.6/Fri Nov 30 01:28:10 2007//
+/fts1_tokenizer.h/1.4/Sun Oct  1 18:41:20 2006//
+/fts1_tokenizer1.c/1.8/Fri Nov 30 01:28:10 2007//
+/fts1.c/1.55/Thu Dec 13 21:45:43 2007//
+/ft_hash.c/1.1/Wed Aug 23 23:58:50 2006//
+/ft_hash.h/1.1/Wed Aug 23 23:58:50 2006//
+/fulltext.c/1.3/Mon Aug 28 23:46:02 2006//
+/fulltext.h/1.1/Wed Aug 23 23:58:50 2006//
+/simple_tokenizer.c/1.3/Wed Aug 30 21:40:30 2006//
+/tokenizer.h/1.1/Wed Aug 23 23:58:50 2006//
+D
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Repository b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Repository
new file mode 100644
index 0000000..18923d9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Repository
@@ -0,0 +1 @@
+sqlite/ext/fts1
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Root b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Root
new file mode 100644
index 0000000..a3ae5d0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/CVS/Root
@@ -0,0 +1 @@
+:pserver:drh@sqlite.org:/sqlite
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/README.txt b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/README.txt
new file mode 100644
index 0000000..292b7da
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/README.txt
@@ -0,0 +1,2 @@
+This folder contains source code to the first full-text search
+extension for SQLite.
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.c
new file mode 100644
index 0000000..8b3a706
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.c
@@ -0,0 +1,404 @@
+/*
+** 2001 September 22
+**
+** 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 is the implementation of generic hash-tables used in SQLite.
+** We've modified it slightly to serve as a standalone hash table
+** implementation for the full-text indexing module.
+*/
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ft_hash.h"
+
+void *malloc_and_zero(int n){
+  void *p = malloc(n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+
+/* Turn bulk memory into a hash table object by initializing the
+** fields of the Hash structure.
+**
+** "pNew" is a pointer to the hash table that is to be initialized.
+** keyClass is one of the constants HASH_INT, HASH_POINTER,
+** HASH_BINARY, or HASH_STRING.  The value of keyClass 
+** determines what kind of key the hash table will use.  "copyKey" is
+** true if the hash table should make its own private copy of keys and
+** false if it should just use the supplied pointer.  CopyKey only makes
+** sense for HASH_STRING and HASH_BINARY and is ignored
+** for other key classes.
+*/
+void HashInit(Hash *pNew, int keyClass, int copyKey){
+  assert( pNew!=0 );
+  assert( keyClass>=HASH_STRING && keyClass<=HASH_BINARY );
+  pNew->keyClass = keyClass;
+#if 0
+  if( keyClass==HASH_POINTER || keyClass==HASH_INT ) copyKey = 0;
+#endif
+  pNew->copyKey = copyKey;
+  pNew->first = 0;
+  pNew->count = 0;
+  pNew->htsize = 0;
+  pNew->ht = 0;
+  pNew->xMalloc = malloc_and_zero;
+  pNew->xFree = free;
+}
+
+/* Remove all entries from a hash table.  Reclaim all memory.
+** Call this routine to delete a hash table or to reset a hash table
+** to the empty state.
+*/
+void HashClear(Hash *pH){
+  HashElem *elem;         /* For looping over all elements of the table */
+
+  assert( pH!=0 );
+  elem = pH->first;
+  pH->first = 0;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = 0;
+  pH->htsize = 0;
+  while( elem ){
+    HashElem *next_elem = elem->next;
+    if( pH->copyKey && elem->pKey ){
+      pH->xFree(elem->pKey);
+    }
+    pH->xFree(elem);
+    elem = next_elem;
+  }
+  pH->count = 0;
+}
+
+#if 0 /* NOT USED */
+/*
+** Hash and comparison functions when the mode is HASH_INT
+*/
+static int intHash(const void *pKey, int nKey){
+  return nKey ^ (nKey<<8) ^ (nKey>>8);
+}
+static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  return n2 - n1;
+}
+#endif
+
+#if 0 /* NOT USED */
+/*
+** Hash and comparison functions when the mode is HASH_POINTER
+*/
+static int ptrHash(const void *pKey, int nKey){
+  uptr x = Addr(pKey);
+  return x ^ (x<<8) ^ (x>>8);
+}
+static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( pKey1==pKey2 ) return 0;
+  if( pKey1<pKey2 ) return -1;
+  return 1;
+}
+#endif
+
+/*
+** Hash and comparison functions when the mode is HASH_STRING
+*/
+static int strHash(const void *pKey, int nKey){
+  const char *z = (const char *)pKey;
+  int h = 0;
+  if( nKey<=0 ) nKey = (int) strlen(z);
+  while( nKey > 0  ){
+    h = (h<<3) ^ h ^ *z++;
+    nKey--;
+  }
+  return h & 0x7fffffff;
+}
+static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return strncmp((const char*)pKey1,(const char*)pKey2,n1);
+}
+
+/*
+** Hash and comparison functions when the mode is HASH_BINARY
+*/
+static int binHash(const void *pKey, int nKey){
+  int h = 0;
+  const char *z = (const char *)pKey;
+  while( nKey-- > 0 ){
+    h = (h<<3) ^ h ^ *(z++);
+  }
+  return h & 0x7fffffff;
+}
+static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return memcmp(pKey1,pKey2,n1);
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** The C syntax in this function definition may be unfamilar to some 
+** programmers, so we provide the following additional explanation:
+**
+** The name of the function is "hashFunction".  The function takes a
+** single parameter "keyClass".  The return value of hashFunction()
+** is a pointer to another function.  Specifically, the return value
+** of hashFunction() is a pointer to a function that takes two parameters
+** with types "const void*" and "int" and returns an "int".
+*/
+static int (*hashFunction(int keyClass))(const void*,int){
+#if 0  /* HASH_INT and HASH_POINTER are never used */
+  switch( keyClass ){
+    case HASH_INT:     return &intHash;
+    case HASH_POINTER: return &ptrHash;
+    case HASH_STRING:  return &strHash;
+    case HASH_BINARY:  return &binHash;;
+    default: break;
+  }
+  return 0;
+#else
+  if( keyClass==HASH_STRING ){
+    return &strHash;
+  }else{
+    assert( keyClass==HASH_BINARY );
+    return &binHash;
+  }
+#endif
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** For help in interpreted the obscure C code in the function definition,
+** see the header comment on the previous function.
+*/
+static int (*compareFunction(int keyClass))(const void*,int,const void*,int){
+#if 0 /* HASH_INT and HASH_POINTER are never used */
+  switch( keyClass ){
+    case HASH_INT:     return &intCompare;
+    case HASH_POINTER: return &ptrCompare;
+    case HASH_STRING:  return &strCompare;
+    case HASH_BINARY:  return &binCompare;
+    default: break;
+  }
+  return 0;
+#else
+  if( keyClass==HASH_STRING ){
+    return &strCompare;
+  }else{
+    assert( keyClass==HASH_BINARY );
+    return &binCompare;
+  }
+#endif
+}
+
+/* Link an element into the hash table
+*/
+static void insertElement(
+  Hash *pH,              /* The complete hash table */
+  struct _ht *pEntry,    /* The entry into which pNew is inserted */
+  HashElem *pNew         /* The element to be inserted */
+){
+  HashElem *pHead;       /* First element already in pEntry */
+  pHead = pEntry->chain;
+  if( pHead ){
+    pNew->next = pHead;
+    pNew->prev = pHead->prev;
+    if( pHead->prev ){ pHead->prev->next = pNew; }
+    else             { pH->first = pNew; }
+    pHead->prev = pNew;
+  }else{
+    pNew->next = pH->first;
+    if( pH->first ){ pH->first->prev = pNew; }
+    pNew->prev = 0;
+    pH->first = pNew;
+  }
+  pEntry->count++;
+  pEntry->chain = pNew;
+}
+
+
+/* Resize the hash table so that it cantains "new_size" buckets.
+** "new_size" must be a power of 2.  The hash table might fail 
+** to resize if sqliteMalloc() fails.
+*/
+static void rehash(Hash *pH, int new_size){
+  struct _ht *new_ht;            /* The new hash table */
+  HashElem *elem, *next_elem;    /* For looping over existing elements */
+  int (*xHash)(const void*,int); /* The hash function */
+
+  assert( (new_size & (new_size-1))==0 );
+  new_ht = (struct _ht *)pH->xMalloc( new_size*sizeof(struct _ht) );
+  if( new_ht==0 ) return;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = new_ht;
+  pH->htsize = new_size;
+  xHash = hashFunction(pH->keyClass);
+  for(elem=pH->first, pH->first=0; elem; elem = next_elem){
+    int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
+    next_elem = elem->next;
+    insertElement(pH, &new_ht[h], elem);
+  }
+}
+
+/* This function (for internal use only) locates an element in an
+** hash table that matches the given key.  The hash for this key has
+** already been computed and is passed as the 4th parameter.
+*/
+static HashElem *findElementGivenHash(
+  const Hash *pH,     /* The pH to be searched */
+  const void *pKey,   /* The key we are searching for */
+  int nKey,
+  int h               /* The hash for this key. */
+){
+  HashElem *elem;                /* Used to loop thru the element list */
+  int count;                     /* Number of elements left to test */
+  int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
+
+  if( pH->ht ){
+    struct _ht *pEntry = &pH->ht[h];
+    elem = pEntry->chain;
+    count = pEntry->count;
+    xCompare = compareFunction(pH->keyClass);
+    while( count-- && elem ){
+      if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
+        return elem;
+      }
+      elem = elem->next;
+    }
+  }
+  return 0;
+}
+
+/* Remove a single entry from the hash table given a pointer to that
+** element and a hash on the element's key.
+*/
+static void removeElementGivenHash(
+  Hash *pH,         /* The pH containing "elem" */
+  HashElem* elem,   /* The element to be removed from the pH */
+  int h             /* Hash value for the element */
+){
+  struct _ht *pEntry;
+  if( elem->prev ){
+    elem->prev->next = elem->next; 
+  }else{
+    pH->first = elem->next;
+  }
+  if( elem->next ){
+    elem->next->prev = elem->prev;
+  }
+  pEntry = &pH->ht[h];
+  if( pEntry->chain==elem ){
+    pEntry->chain = elem->next;
+  }
+  pEntry->count--;
+  if( pEntry->count<=0 ){
+    pEntry->chain = 0;
+  }
+  if( pH->copyKey && elem->pKey ){
+    pH->xFree(elem->pKey);
+  }
+  pH->xFree( elem );
+  pH->count--;
+  if( pH->count<=0 ){
+    assert( pH->first==0 );
+    assert( pH->count==0 );
+    HashClear(pH);
+  }
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *HashFind(const Hash *pH, const void *pKey, int nKey){
+  int h;             /* A hash on key */
+  HashElem *elem;    /* The element that matches key */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  if( pH==0 || pH->ht==0 ) return 0;
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  h = (*xHash)(pKey,nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem ? elem->data : 0;
+}
+
+/* Insert an element into the hash table pH.  The key is pKey,nKey
+** and the data is "data".
+**
+** If no element exists with a matching key, then a new
+** element is created.  A copy of the key is made if the copyKey
+** flag is set.  NULL is returned.
+**
+** If another element already exists with the same key, then the
+** new data replaces the old data and the old data is returned.
+** The key is not copied in this instance.  If a malloc fails, then
+** the new data is returned and the hash table is unchanged.
+**
+** If the "data" parameter to this function is NULL, then the
+** element corresponding to "key" is removed from the hash table.
+*/
+void *HashInsert(Hash *pH, const void *pKey, int nKey, void *data){
+  int hraw;             /* Raw hash value of the key */
+  int h;                /* the hash of the key modulo hash table size */
+  HashElem *elem;       /* Used to loop thru the element list */
+  HashElem *new_elem;   /* New element added to the pH */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  assert( pH!=0 );
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  hraw = (*xHash)(pKey, nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  elem = findElementGivenHash(pH,pKey,nKey,h);
+  if( elem ){
+    void *old_data = elem->data;
+    if( data==0 ){
+      removeElementGivenHash(pH,elem,h);
+    }else{
+      elem->data = data;
+    }
+    return old_data;
+  }
+  if( data==0 ) return 0;
+  new_elem = (HashElem*)pH->xMalloc( sizeof(HashElem) );
+  if( new_elem==0 ) return data;
+  if( pH->copyKey && pKey!=0 ){
+    new_elem->pKey = pH->xMalloc( nKey );
+    if( new_elem->pKey==0 ){
+      pH->xFree(new_elem);
+      return data;
+    }
+    memcpy((void*)new_elem->pKey, pKey, nKey);
+  }else{
+    new_elem->pKey = (void*)pKey;
+  }
+  new_elem->nKey = nKey;
+  pH->count++;
+  if( pH->htsize==0 ){
+    rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      pH->xFree(new_elem);
+      return data;
+    }
+  }
+  if( pH->count > pH->htsize ){
+    rehash(pH,pH->htsize*2);
+  }
+  assert( pH->htsize>0 );
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  insertElement(pH, &pH->ht[h], new_elem);
+  new_elem->data = data;
+  return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.h
new file mode 100644
index 0000000..93b6dcf
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/ft_hash.h
@@ -0,0 +1,111 @@
+/*
+** 2001 September 22
+**
+** 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 is the header file for the generic hash-table implemenation
+** used in SQLite.  We've modified it slightly to serve as a standalone
+** hash table implementation for the full-text indexing module.
+**
+*/
+#ifndef _HASH_H_
+#define _HASH_H_
+
+/* Forward declarations of structures. */
+typedef struct Hash Hash;
+typedef struct HashElem HashElem;
+
+/* A complete hash table is an instance of the following structure.
+** The internals of this structure are intended to be opaque -- client
+** code should not attempt to access or modify the fields of this structure
+** directly.  Change this structure only by using the routines below.
+** However, many of the "procedures" and "functions" for modifying and
+** accessing this structure are really macros, so we can't really make
+** this structure opaque.
+*/
+struct Hash {
+  char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
+  char copyKey;           /* True if copy of key made on insert */
+  int count;              /* Number of entries in this table */
+  HashElem *first;        /* The first element of the array */
+  void *(*xMalloc)(int);  /* malloc() function to use */
+  void (*xFree)(void *);  /* free() function to use */
+  int htsize;             /* Number of buckets in the hash table */
+  struct _ht {            /* the hash table */
+    int count;               /* Number of entries with this hash */
+    HashElem *chain;         /* Pointer to first entry with this hash */
+  } *ht;
+};
+
+/* Each element in the hash table is an instance of the following 
+** structure.  All elements are stored on a single doubly-linked list.
+**
+** Again, this structure is intended to be opaque, but it can't really
+** be opaque because it is used by macros.
+*/
+struct HashElem {
+  HashElem *next, *prev;   /* Next and previous elements in the table */
+  void *data;              /* Data associated with this element */
+  void *pKey; int nKey;    /* Key associated with this element */
+};
+
+/*
+** There are 4 different modes of operation for a hash table:
+**
+**   HASH_INT         nKey is used as the key and pKey is ignored.
+**
+**   HASH_POINTER     pKey is used as the key and nKey is ignored.
+**
+**   HASH_STRING      pKey points to a string that is nKey bytes long
+**                           (including the null-terminator, if any).  Case
+**                           is respected in comparisons.
+**
+**   HASH_BINARY      pKey points to binary data nKey bytes long. 
+**                           memcmp() is used to compare keys.
+**
+** A copy of the key is made for HASH_STRING and HASH_BINARY
+** if the copyKey parameter to HashInit is 1.  
+*/
+/* #define HASH_INT       1 // NOT USED */
+/* #define HASH_POINTER   2 // NOT USED */
+#define HASH_STRING    3
+#define HASH_BINARY    4
+
+/*
+** Access routines.  To delete, insert a NULL pointer.
+*/
+void HashInit(Hash*, int keytype, int copyKey);
+void *HashInsert(Hash*, const void *pKey, int nKey, void *pData);
+void *HashFind(const Hash*, const void *pKey, int nKey);
+void HashClear(Hash*);
+
+/*
+** Macros for looping over all elements of a hash table.  The idiom is
+** like this:
+**
+**   Hash h;
+**   HashElem *p;
+**   ...
+**   for(p=HashFirst(&h); p; p=HashNext(p)){
+**     SomeStructure *pData = HashData(p);
+**     // do something with pData
+**   }
+*/
+#define HashFirst(H)  ((H)->first)
+#define HashNext(E)   ((E)->next)
+#define HashData(E)   ((E)->data)
+#define HashKey(E)    ((E)->pKey)
+#define HashKeysize(E) ((E)->nKey)
+
+/*
+** Number of entries in a hash table
+*/
+#define HashCount(H)  ((H)->count)
+
+#endif /* _HASH_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.c
new file mode 100644
index 0000000..f2650e2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.c
@@ -0,0 +1,3345 @@
+/* fts1 has a design flaw which can lead to database corruption (see
+** below).  It is recommended not to use it any longer, instead use
+** fts3 (or higher).  If you believe that your use of fts1 is safe,
+** add -DSQLITE_ENABLE_BROKEN_FTS1=1 to your CFLAGS.
+*/
+#if (!defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)) \
+        && !defined(SQLITE_ENABLE_BROKEN_FTS1)
+#error fts1 has a design flaw and has been deprecated.
+#endif
+/* The flaw is that fts1 uses the content table's unaliased rowid as
+** the unique docid.  fts1 embeds the rowid in the index it builds,
+** and expects the rowid to not change.  The SQLite VACUUM operation
+** will renumber such rowids, thereby breaking fts1.  If you are using
+** fts1 in a system which has disabled VACUUM, then you can continue
+** to use it safely.  Note that PRAGMA auto_vacuum does NOT disable
+** VACUUM, though systems using auto_vacuum are unlikely to invoke
+** VACUUM.
+**
+** fts1 should be safe even across VACUUM if you only insert documents
+** and never delete.
+*/
+
+/* The author disclaims copyright to this source code.
+ *
+ * This is an SQLite module implementing full-text search.
+ */
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS1 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS1 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS1 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)
+
+#if defined(SQLITE_ENABLE_FTS1) && !defined(SQLITE_CORE)
+# define SQLITE_CORE 1
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts1.h"
+#include "fts1_hash.h"
+#include "fts1_tokenizer.h"
+#include "sqlite3.h"
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+
+#if 0
+# define TRACE(A)  printf A; fflush(stdout)
+#else
+# define TRACE(A)
+#endif
+
+/* utility functions */
+
+typedef struct StringBuffer {
+  int len;      /* length, not including null terminator */
+  int alloced;  /* Space allocated for s[] */ 
+  char *s;      /* Content of the string */
+} StringBuffer;
+
+static void initStringBuffer(StringBuffer *sb){
+  sb->len = 0;
+  sb->alloced = 100;
+  sb->s = malloc(100);
+  sb->s[0] = '\0';
+}
+
+static void nappend(StringBuffer *sb, const char *zFrom, int nFrom){
+  if( sb->len + nFrom >= sb->alloced ){
+    sb->alloced = sb->len + nFrom + 100;
+    sb->s = realloc(sb->s, sb->alloced+1);
+    if( sb->s==0 ){
+      initStringBuffer(sb);
+      return;
+    }
+  }
+  memcpy(sb->s + sb->len, zFrom, nFrom);
+  sb->len += nFrom;
+  sb->s[sb->len] = 0;
+}
+static void append(StringBuffer *sb, const char *zFrom){
+  nappend(sb, zFrom, strlen(zFrom));
+}
+
+/* We encode variable-length integers in little-endian order using seven bits
+ * per byte as follows:
+**
+** KEY:
+**         A = 0xxxxxxx    7 bits of data and one flag bit
+**         B = 1xxxxxxx    7 bits of data and one flag bit
+**
+**  7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** and so on.
+*/
+
+/* We may need up to VARINT_MAX bytes to store an encoded 64-bit integer. */
+#define VARINT_MAX 10
+
+/* Write a 64-bit variable-length integer to memory starting at p[0].
+ * The length of data written will be between 1 and VARINT_MAX bytes.
+ * The number of bytes written is returned. */
+static int putVarint(char *p, sqlite_int64 v){
+  unsigned char *q = (unsigned char *) p;
+  sqlite_uint64 vu = v;
+  do{
+    *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
+    vu >>= 7;
+  }while( vu!=0 );
+  q[-1] &= 0x7f;  /* turn off high bit in final byte */
+  assert( q - (unsigned char *)p <= VARINT_MAX );
+  return (int) (q - (unsigned char *)p);
+}
+
+/* Read a 64-bit variable-length integer from memory starting at p[0].
+ * Return the number of bytes read, or 0 on error.
+ * The value is stored in *v. */
+static int getVarint(const char *p, sqlite_int64 *v){
+  const unsigned char *q = (const unsigned char *) p;
+  sqlite_uint64 x = 0, y = 1;
+  while( (*q & 0x80) == 0x80 ){
+    x += y * (*q++ & 0x7f);
+    y <<= 7;
+    if( q - (unsigned char *)p >= VARINT_MAX ){  /* bad data */
+      assert( 0 );
+      return 0;
+    }
+  }
+  x += y * (*q++);
+  *v = (sqlite_int64) x;
+  return (int) (q - (unsigned char *)p);
+}
+
+static int getVarint32(const char *p, int *pi){
+ sqlite_int64 i;
+ int ret = getVarint(p, &i);
+ *pi = (int) i;
+ assert( *pi==i );
+ return ret;
+}
+
+/*** Document lists ***
+ *
+ * A document list holds a sorted list of varint-encoded document IDs.
+ *
+ * A doclist with type DL_POSITIONS_OFFSETS is stored like this:
+ *
+ * array {
+ *   varint docid;
+ *   array {
+ *     varint position;     (delta from previous position plus POS_BASE)
+ *     varint startOffset;  (delta from previous startOffset)
+ *     varint endOffset;    (delta from startOffset)
+ *   }
+ * }
+ *
+ * Here, array { X } means zero or more occurrences of X, adjacent in memory.
+ *
+ * A position list may hold positions for text in multiple columns.  A position
+ * POS_COLUMN is followed by a varint containing the index of the column for
+ * following positions in the list.  Any positions appearing before any
+ * occurrences of POS_COLUMN are for column 0.
+ *
+ * A doclist with type DL_POSITIONS is like the above, but holds only docids
+ * and positions without offset information.
+ *
+ * A doclist with type DL_DOCIDS is like the above, but holds only docids
+ * without positions or offset information.
+ *
+ * On disk, every document list has positions and offsets, so we don't bother
+ * to serialize a doclist's type.
+ * 
+ * We don't yet delta-encode document IDs; doing so will probably be a
+ * modest win.
+ *
+ * NOTE(shess) I've thought of a slightly (1%) better offset encoding.
+ * After the first offset, estimate the next offset by using the
+ * current token position and the previous token position and offset,
+ * offset to handle some variance.  So the estimate would be
+ * (iPosition*w->iStartOffset/w->iPosition-64), which is delta-encoded
+ * as normal.  Offsets more than 64 chars from the estimate are
+ * encoded as the delta to the previous start offset + 128.  An
+ * additional tiny increment can be gained by using the end offset of
+ * the previous token to make the estimate a tiny bit more precise.
+*/
+
+/* It is not safe to call isspace(), tolower(), or isalnum() on
+** hi-bit-set characters.  This is the same solution used in the
+** tokenizer.
+*/
+/* TODO(shess) The snippet-generation code should be using the
+** tokenizer-generated tokens rather than doing its own local
+** tokenization.
+*/
+/* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
+static int safe_isspace(char c){
+  return (c&0x80)==0 ? isspace(c) : 0;
+}
+static int safe_tolower(char c){
+  return (c&0x80)==0 ? tolower(c) : c;
+}
+static int safe_isalnum(char c){
+  return (c&0x80)==0 ? isalnum(c) : 0;
+}
+
+typedef enum DocListType {
+  DL_DOCIDS,              /* docids only */
+  DL_POSITIONS,           /* docids + positions */
+  DL_POSITIONS_OFFSETS    /* docids + positions + offsets */
+} DocListType;
+
+/*
+** By default, only positions and not offsets are stored in the doclists.
+** To change this so that offsets are stored too, compile with
+**
+**          -DDL_DEFAULT=DL_POSITIONS_OFFSETS
+**
+*/
+#ifndef DL_DEFAULT
+# define DL_DEFAULT DL_POSITIONS
+#endif
+
+typedef struct DocList {
+  char *pData;
+  int nData;
+  DocListType iType;
+  int iLastColumn;    /* the last column written */
+  int iLastPos;       /* the last position written */
+  int iLastOffset;    /* the last start offset written */
+} DocList;
+
+enum {
+  POS_END = 0,        /* end of this position list */
+  POS_COLUMN,         /* followed by new column number */
+  POS_BASE
+};
+
+/* Initialize a new DocList to hold the given data. */
+static void docListInit(DocList *d, DocListType iType,
+                        const char *pData, int nData){
+  d->nData = nData;
+  if( nData>0 ){
+    d->pData = malloc(nData);
+    memcpy(d->pData, pData, nData);
+  } else {
+    d->pData = NULL;
+  }
+  d->iType = iType;
+  d->iLastColumn = 0;
+  d->iLastPos = d->iLastOffset = 0;
+}
+
+/* Create a new dynamically-allocated DocList. */
+static DocList *docListNew(DocListType iType){
+  DocList *d = (DocList *) malloc(sizeof(DocList));
+  docListInit(d, iType, 0, 0);
+  return d;
+}
+
+static void docListDestroy(DocList *d){
+  free(d->pData);
+#ifndef NDEBUG
+  memset(d, 0x55, sizeof(*d));
+#endif
+}
+
+static void docListDelete(DocList *d){
+  docListDestroy(d);
+  free(d);
+}
+
+static char *docListEnd(DocList *d){
+  return d->pData + d->nData;
+}
+
+/* Append a varint to a DocList's data. */
+static void appendVarint(DocList *d, sqlite_int64 i){
+  char c[VARINT_MAX];
+  int n = putVarint(c, i);
+  d->pData = realloc(d->pData, d->nData + n);
+  memcpy(d->pData + d->nData, c, n);
+  d->nData += n;
+}
+
+static void docListAddDocid(DocList *d, sqlite_int64 iDocid){
+  appendVarint(d, iDocid);
+  if( d->iType>=DL_POSITIONS ){
+    appendVarint(d, POS_END);  /* initially empty position list */
+    d->iLastColumn = 0;
+    d->iLastPos = d->iLastOffset = 0;
+  }
+}
+
+/* helper function for docListAddPos and docListAddPosOffset */
+static void addPos(DocList *d, int iColumn, int iPos){
+  assert( d->nData>0 );
+  --d->nData;  /* remove previous terminator */
+  if( iColumn!=d->iLastColumn ){
+    assert( iColumn>d->iLastColumn );
+    appendVarint(d, POS_COLUMN);
+    appendVarint(d, iColumn);
+    d->iLastColumn = iColumn;
+    d->iLastPos = d->iLastOffset = 0;
+  }
+  assert( iPos>=d->iLastPos );
+  appendVarint(d, iPos-d->iLastPos+POS_BASE);
+  d->iLastPos = iPos;
+}
+
+/* Add a position to the last position list in a doclist. */
+static void docListAddPos(DocList *d, int iColumn, int iPos){
+  assert( d->iType==DL_POSITIONS );
+  addPos(d, iColumn, iPos);
+  appendVarint(d, POS_END);  /* add new terminator */
+}
+
+/*
+** Add a position and starting and ending offsets to a doclist.
+**
+** If the doclist is setup to handle only positions, then insert
+** the position only and ignore the offsets.
+*/
+static void docListAddPosOffset(
+  DocList *d,             /* Doclist under construction */
+  int iColumn,            /* Column the inserted term is part of */
+  int iPos,               /* Position of the inserted term */
+  int iStartOffset,       /* Starting offset of inserted term */
+  int iEndOffset          /* Ending offset of inserted term */
+){
+  assert( d->iType>=DL_POSITIONS );
+  addPos(d, iColumn, iPos);
+  if( d->iType==DL_POSITIONS_OFFSETS ){
+    assert( iStartOffset>=d->iLastOffset );
+    appendVarint(d, iStartOffset-d->iLastOffset);
+    d->iLastOffset = iStartOffset;
+    assert( iEndOffset>=iStartOffset );
+    appendVarint(d, iEndOffset-iStartOffset);
+  }
+  appendVarint(d, POS_END);  /* add new terminator */
+}
+
+/*
+** A DocListReader object is a cursor into a doclist.  Initialize
+** the cursor to the beginning of the doclist by calling readerInit().
+** Then use routines
+**
+**      peekDocid()
+**      readDocid()
+**      readPosition()
+**      skipPositionList()
+**      and so forth...
+**
+** to read information out of the doclist.  When we reach the end
+** of the doclist, atEnd() returns TRUE.
+*/
+typedef struct DocListReader {
+  DocList *pDoclist;  /* The document list we are stepping through */
+  char *p;            /* Pointer to next unread byte in the doclist */
+  int iLastColumn;
+  int iLastPos;  /* the last position read, or -1 when not in a position list */
+} DocListReader;
+
+/*
+** Initialize the DocListReader r to point to the beginning of pDoclist.
+*/
+static void readerInit(DocListReader *r, DocList *pDoclist){
+  r->pDoclist = pDoclist;
+  if( pDoclist!=NULL ){
+    r->p = pDoclist->pData;
+  }
+  r->iLastColumn = -1;
+  r->iLastPos = -1;
+}
+
+/*
+** Return TRUE if we have reached then end of pReader and there is
+** nothing else left to read.
+*/
+static int atEnd(DocListReader *pReader){
+  return pReader->pDoclist==0 || (pReader->p >= docListEnd(pReader->pDoclist));
+}
+
+/* Peek at the next docid without advancing the read pointer. 
+*/
+static sqlite_int64 peekDocid(DocListReader *pReader){
+  sqlite_int64 ret;
+  assert( !atEnd(pReader) );
+  assert( pReader->iLastPos==-1 );
+  getVarint(pReader->p, &ret);
+  return ret;
+}
+
+/* Read the next docid.   See also nextDocid().
+*/
+static sqlite_int64 readDocid(DocListReader *pReader){
+  sqlite_int64 ret;
+  assert( !atEnd(pReader) );
+  assert( pReader->iLastPos==-1 );
+  pReader->p += getVarint(pReader->p, &ret);
+  if( pReader->pDoclist->iType>=DL_POSITIONS ){
+    pReader->iLastColumn = 0;
+    pReader->iLastPos = 0;
+  }
+  return ret;
+}
+
+/* Read the next position and column index from a position list.
+ * Returns the position, or -1 at the end of the list. */
+static int readPosition(DocListReader *pReader, int *iColumn){
+  int i;
+  int iType = pReader->pDoclist->iType;
+
+  if( pReader->iLastPos==-1 ){
+    return -1;
+  }
+  assert( !atEnd(pReader) );
+
+  if( iType<DL_POSITIONS ){
+    return -1;
+  }
+  pReader->p += getVarint32(pReader->p, &i);
+  if( i==POS_END ){
+    pReader->iLastColumn = pReader->iLastPos = -1;
+    *iColumn = -1;
+    return -1;
+  }
+  if( i==POS_COLUMN ){
+    pReader->p += getVarint32(pReader->p, &pReader->iLastColumn);
+    pReader->iLastPos = 0;
+    pReader->p += getVarint32(pReader->p, &i);
+    assert( i>=POS_BASE );
+  }
+  pReader->iLastPos += ((int) i)-POS_BASE;
+  if( iType>=DL_POSITIONS_OFFSETS ){
+    /* Skip over offsets, ignoring them for now. */
+    int iStart, iEnd;
+    pReader->p += getVarint32(pReader->p, &iStart);
+    pReader->p += getVarint32(pReader->p, &iEnd);
+  }
+  *iColumn = pReader->iLastColumn;
+  return pReader->iLastPos;
+}
+
+/* Skip past the end of a position list. */
+static void skipPositionList(DocListReader *pReader){
+  DocList *p = pReader->pDoclist;
+  if( p && p->iType>=DL_POSITIONS ){
+    int iColumn;
+    while( readPosition(pReader, &iColumn)!=-1 ){}
+  }
+}
+
+/* Skip over a docid, including its position list if the doclist has
+ * positions. */
+static void skipDocument(DocListReader *pReader){
+  readDocid(pReader);
+  skipPositionList(pReader);
+}
+
+/* Skip past all docids which are less than [iDocid].  Returns 1 if a docid
+ * matching [iDocid] was found.  */
+static int skipToDocid(DocListReader *pReader, sqlite_int64 iDocid){
+  sqlite_int64 d = 0;
+  while( !atEnd(pReader) && (d=peekDocid(pReader))<iDocid ){
+    skipDocument(pReader);
+  }
+  return !atEnd(pReader) && d==iDocid;
+}
+
+/* Return the first document in a document list.
+*/
+static sqlite_int64 firstDocid(DocList *d){
+  DocListReader r;
+  readerInit(&r, d);
+  return readDocid(&r);
+}
+
+#ifdef SQLITE_DEBUG
+/*
+** This routine is used for debugging purpose only.
+**
+** Write the content of a doclist to standard output.
+*/
+static void printDoclist(DocList *p){
+  DocListReader r;
+  const char *zSep = "";
+
+  readerInit(&r, p);
+  while( !atEnd(&r) ){
+    sqlite_int64 docid = readDocid(&r);
+    if( docid==0 ){
+      skipPositionList(&r);
+      continue;
+    }
+    printf("%s%lld", zSep, docid);
+    zSep =  ",";
+    if( p->iType>=DL_POSITIONS ){
+      int iPos, iCol;
+      const char *zDiv = "";
+      printf("(");
+      while( (iPos = readPosition(&r, &iCol))>=0 ){
+        printf("%s%d:%d", zDiv, iCol, iPos);
+        zDiv = ":";
+      }
+      printf(")");
+    }
+  }
+  printf("\n");
+  fflush(stdout);
+}
+#endif /* SQLITE_DEBUG */
+
+/* Trim the given doclist to contain only positions in column
+ * [iRestrictColumn]. */
+static void docListRestrictColumn(DocList *in, int iRestrictColumn){
+  DocListReader r;
+  DocList out;
+
+  assert( in->iType>=DL_POSITIONS );
+  readerInit(&r, in);
+  docListInit(&out, DL_POSITIONS, NULL, 0);
+
+  while( !atEnd(&r) ){
+    sqlite_int64 iDocid = readDocid(&r);
+    int iPos, iColumn;
+
+    docListAddDocid(&out, iDocid);
+    while( (iPos = readPosition(&r, &iColumn)) != -1 ){
+      if( iColumn==iRestrictColumn ){
+        docListAddPos(&out, iColumn, iPos);
+      }
+    }
+  }
+
+  docListDestroy(in);
+  *in = out;
+}
+
+/* Trim the given doclist by discarding any docids without any remaining
+ * positions. */
+static void docListDiscardEmpty(DocList *in) {
+  DocListReader r;
+  DocList out;
+
+  /* TODO: It would be nice to implement this operation in place; that
+   * could save a significant amount of memory in queries with long doclists. */
+  assert( in->iType>=DL_POSITIONS );
+  readerInit(&r, in);
+  docListInit(&out, DL_POSITIONS, NULL, 0);
+
+  while( !atEnd(&r) ){
+    sqlite_int64 iDocid = readDocid(&r);
+    int match = 0;
+    int iPos, iColumn;
+    while( (iPos = readPosition(&r, &iColumn)) != -1 ){
+      if( !match ){
+        docListAddDocid(&out, iDocid);
+        match = 1;
+      }
+      docListAddPos(&out, iColumn, iPos);
+    }
+  }
+
+  docListDestroy(in);
+  *in = out;
+}
+
+/* Helper function for docListUpdate() and docListAccumulate().
+** Splices a doclist element into the doclist represented by r,
+** leaving r pointing after the newly spliced element.
+*/
+static void docListSpliceElement(DocListReader *r, sqlite_int64 iDocid,
+                                 const char *pSource, int nSource){
+  DocList *d = r->pDoclist;
+  char *pTarget;
+  int nTarget, found;
+
+  found = skipToDocid(r, iDocid);
+
+  /* Describe slice in d to place pSource/nSource. */
+  pTarget = r->p;
+  if( found ){
+    skipDocument(r);
+    nTarget = r->p-pTarget;
+  }else{
+    nTarget = 0;
+  }
+
+  /* The sense of the following is that there are three possibilities.
+  ** If nTarget==nSource, we should not move any memory nor realloc.
+  ** If nTarget>nSource, trim target and realloc.
+  ** If nTarget<nSource, realloc then expand target.
+  */
+  if( nTarget>nSource ){
+    memmove(pTarget+nSource, pTarget+nTarget, docListEnd(d)-(pTarget+nTarget));
+  }
+  if( nTarget!=nSource ){
+    int iDoclist = pTarget-d->pData;
+    d->pData = realloc(d->pData, d->nData+nSource-nTarget);
+    pTarget = d->pData+iDoclist;
+  }
+  if( nTarget<nSource ){
+    memmove(pTarget+nSource, pTarget+nTarget, docListEnd(d)-(pTarget+nTarget));
+  }
+
+  memcpy(pTarget, pSource, nSource);
+  d->nData += nSource-nTarget;
+  r->p = pTarget+nSource;
+}
+
+/* Insert/update pUpdate into the doclist. */
+static void docListUpdate(DocList *d, DocList *pUpdate){
+  DocListReader reader;
+
+  assert( d!=NULL && pUpdate!=NULL );
+  assert( d->iType==pUpdate->iType);
+
+  readerInit(&reader, d);
+  docListSpliceElement(&reader, firstDocid(pUpdate),
+                       pUpdate->pData, pUpdate->nData);
+}
+
+/* Propagate elements from pUpdate to pAcc, overwriting elements with
+** matching docids.
+*/
+static void docListAccumulate(DocList *pAcc, DocList *pUpdate){
+  DocListReader accReader, updateReader;
+
+  /* Handle edge cases where one doclist is empty. */
+  assert( pAcc!=NULL );
+  if( pUpdate==NULL || pUpdate->nData==0 ) return;
+  if( pAcc->nData==0 ){
+    pAcc->pData = malloc(pUpdate->nData);
+    memcpy(pAcc->pData, pUpdate->pData, pUpdate->nData);
+    pAcc->nData = pUpdate->nData;
+    return;
+  }
+
+  readerInit(&accReader, pAcc);
+  readerInit(&updateReader, pUpdate);
+
+  while( !atEnd(&updateReader) ){
+    char *pSource = updateReader.p;
+    sqlite_int64 iDocid = readDocid(&updateReader);
+    skipPositionList(&updateReader);
+    docListSpliceElement(&accReader, iDocid, pSource, updateReader.p-pSource);
+  }
+}
+
+/*
+** Read the next docid off of pIn.  Return 0 if we reach the end.
+*
+* TODO: This assumes that docids are never 0, but they may actually be 0 since
+* users can choose docids when inserting into a full-text table.  Fix this.
+*/
+static sqlite_int64 nextDocid(DocListReader *pIn){
+  skipPositionList(pIn);
+  return atEnd(pIn) ? 0 : readDocid(pIn);
+}
+
+/*
+** pLeft and pRight are two DocListReaders that are pointing to
+** positions lists of the same document: iDocid. 
+**
+** If there are no instances in pLeft or pRight where the position
+** of pLeft is one less than the position of pRight, then this
+** routine adds nothing to pOut.
+**
+** If there are one or more instances where positions from pLeft
+** are exactly one less than positions from pRight, then add a new
+** document record to pOut.  If pOut wants to hold positions, then
+** include the positions from pRight that are one more than a
+** position in pLeft.  In other words:  pRight.iPos==pLeft.iPos+1.
+**
+** pLeft and pRight are left pointing at the next document record.
+*/
+static void mergePosList(
+  DocListReader *pLeft,    /* Left position list */
+  DocListReader *pRight,   /* Right position list */
+  sqlite_int64 iDocid,     /* The docid from pLeft and pRight */
+  DocList *pOut            /* Write the merged document record here */
+){
+  int iLeftCol, iLeftPos = readPosition(pLeft, &iLeftCol);
+  int iRightCol, iRightPos = readPosition(pRight, &iRightCol);
+  int match = 0;
+
+  /* Loop until we've reached the end of both position lists. */
+  while( iLeftPos!=-1 && iRightPos!=-1 ){
+    if( iLeftCol==iRightCol && iLeftPos+1==iRightPos ){
+      if( !match ){
+        docListAddDocid(pOut, iDocid);
+        match = 1;
+      }
+      if( pOut->iType>=DL_POSITIONS ){
+        docListAddPos(pOut, iRightCol, iRightPos);
+      }
+      iLeftPos = readPosition(pLeft, &iLeftCol);
+      iRightPos = readPosition(pRight, &iRightCol);
+    }else if( iRightCol<iLeftCol ||
+              (iRightCol==iLeftCol && iRightPos<iLeftPos+1) ){
+      iRightPos = readPosition(pRight, &iRightCol);
+    }else{
+      iLeftPos = readPosition(pLeft, &iLeftCol);
+    }
+  }
+  if( iLeftPos>=0 ) skipPositionList(pLeft);
+  if( iRightPos>=0 ) skipPositionList(pRight);
+}
+
+/* We have two doclists:  pLeft and pRight.
+** Write the phrase intersection of these two doclists into pOut.
+**
+** A phrase intersection means that two documents only match
+** if pLeft.iPos+1==pRight.iPos.
+**
+** The output pOut may or may not contain positions.  If pOut
+** does contain positions, they are the positions of pRight.
+*/
+static void docListPhraseMerge(
+  DocList *pLeft,    /* Doclist resulting from the words on the left */
+  DocList *pRight,   /* Doclist for the next word to the right */
+  DocList *pOut      /* Write the combined doclist here */
+){
+  DocListReader left, right;
+  sqlite_int64 docidLeft, docidRight;
+
+  readerInit(&left, pLeft);
+  readerInit(&right, pRight);
+  docidLeft = nextDocid(&left);
+  docidRight = nextDocid(&right);
+
+  while( docidLeft>0 && docidRight>0 ){
+    if( docidLeft<docidRight ){
+      docidLeft = nextDocid(&left);
+    }else if( docidRight<docidLeft ){
+      docidRight = nextDocid(&right);
+    }else{
+      mergePosList(&left, &right, docidLeft, pOut);
+      docidLeft = nextDocid(&left);
+      docidRight = nextDocid(&right);
+    }
+  }
+}
+
+/* We have two doclists:  pLeft and pRight.
+** Write the intersection of these two doclists into pOut.
+** Only docids are matched.  Position information is ignored.
+**
+** The output pOut never holds positions.
+*/
+static void docListAndMerge(
+  DocList *pLeft,    /* Doclist resulting from the words on the left */
+  DocList *pRight,   /* Doclist for the next word to the right */
+  DocList *pOut      /* Write the combined doclist here */
+){
+  DocListReader left, right;
+  sqlite_int64 docidLeft, docidRight;
+
+  assert( pOut->iType<DL_POSITIONS );
+
+  readerInit(&left, pLeft);
+  readerInit(&right, pRight);
+  docidLeft = nextDocid(&left);
+  docidRight = nextDocid(&right);
+
+  while( docidLeft>0 && docidRight>0 ){
+    if( docidLeft<docidRight ){
+      docidLeft = nextDocid(&left);
+    }else if( docidRight<docidLeft ){
+      docidRight = nextDocid(&right);
+    }else{
+      docListAddDocid(pOut, docidLeft);
+      docidLeft = nextDocid(&left);
+      docidRight = nextDocid(&right);
+    }
+  }
+}
+
+/* We have two doclists:  pLeft and pRight.
+** Write the union of these two doclists into pOut.
+** Only docids are matched.  Position information is ignored.
+**
+** The output pOut never holds positions.
+*/
+static void docListOrMerge(
+  DocList *pLeft,    /* Doclist resulting from the words on the left */
+  DocList *pRight,   /* Doclist for the next word to the right */
+  DocList *pOut      /* Write the combined doclist here */
+){
+  DocListReader left, right;
+  sqlite_int64 docidLeft, docidRight, priorLeft;
+
+  readerInit(&left, pLeft);
+  readerInit(&right, pRight);
+  docidLeft = nextDocid(&left);
+  docidRight = nextDocid(&right);
+
+  while( docidLeft>0 && docidRight>0 ){
+    if( docidLeft<=docidRight ){
+      docListAddDocid(pOut, docidLeft);
+    }else{
+      docListAddDocid(pOut, docidRight);
+    }
+    priorLeft = docidLeft;
+    if( docidLeft<=docidRight ){
+      docidLeft = nextDocid(&left);
+    }
+    if( docidRight>0 && docidRight<=priorLeft ){
+      docidRight = nextDocid(&right);
+    }
+  }
+  while( docidLeft>0 ){
+    docListAddDocid(pOut, docidLeft);
+    docidLeft = nextDocid(&left);
+  }
+  while( docidRight>0 ){
+    docListAddDocid(pOut, docidRight);
+    docidRight = nextDocid(&right);
+  }
+}
+
+/* We have two doclists:  pLeft and pRight.
+** Write into pOut all documents that occur in pLeft but not
+** in pRight.
+**
+** Only docids are matched.  Position information is ignored.
+**
+** The output pOut never holds positions.
+*/
+static void docListExceptMerge(
+  DocList *pLeft,    /* Doclist resulting from the words on the left */
+  DocList *pRight,   /* Doclist for the next word to the right */
+  DocList *pOut      /* Write the combined doclist here */
+){
+  DocListReader left, right;
+  sqlite_int64 docidLeft, docidRight, priorLeft;
+
+  readerInit(&left, pLeft);
+  readerInit(&right, pRight);
+  docidLeft = nextDocid(&left);
+  docidRight = nextDocid(&right);
+
+  while( docidLeft>0 && docidRight>0 ){
+    priorLeft = docidLeft;
+    if( docidLeft<docidRight ){
+      docListAddDocid(pOut, docidLeft);
+    }
+    if( docidLeft<=docidRight ){
+      docidLeft = nextDocid(&left);
+    }
+    if( docidRight>0 && docidRight<=priorLeft ){
+      docidRight = nextDocid(&right);
+    }
+  }
+  while( docidLeft>0 ){
+    docListAddDocid(pOut, docidLeft);
+    docidLeft = nextDocid(&left);
+  }
+}
+
+static char *string_dup_n(const char *s, int n){
+  char *str = malloc(n + 1);
+  memcpy(str, s, n);
+  str[n] = '\0';
+  return str;
+}
+
+/* Duplicate a string; the caller must free() the returned string.
+ * (We don't use strdup() since it is not part of the standard C library and
+ * may not be available everywhere.) */
+static char *string_dup(const char *s){
+  return string_dup_n(s, strlen(s));
+}
+
+/* Format a string, replacing each occurrence of the % character with
+ * zDb.zName.  This may be more convenient than sqlite_mprintf()
+ * when one string is used repeatedly in a format string.
+ * The caller must free() the returned string. */
+static char *string_format(const char *zFormat,
+                           const char *zDb, const char *zName){
+  const char *p;
+  size_t len = 0;
+  size_t nDb = strlen(zDb);
+  size_t nName = strlen(zName);
+  size_t nFullTableName = nDb+1+nName;
+  char *result;
+  char *r;
+
+  /* first compute length needed */
+  for(p = zFormat ; *p ; ++p){
+    len += (*p=='%' ? nFullTableName : 1);
+  }
+  len += 1;  /* for null terminator */
+
+  r = result = malloc(len);
+  for(p = zFormat; *p; ++p){
+    if( *p=='%' ){
+      memcpy(r, zDb, nDb);
+      r += nDb;
+      *r++ = '.';
+      memcpy(r, zName, nName);
+      r += nName;
+    } else {
+      *r++ = *p;
+    }
+  }
+  *r++ = '\0';
+  assert( r == result + len );
+  return result;
+}
+
+static int sql_exec(sqlite3 *db, const char *zDb, const char *zName,
+                    const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  TRACE(("FTS1 sql: %s\n", zCommand));
+  rc = sqlite3_exec(db, zCommand, NULL, 0, NULL);
+  free(zCommand);
+  return rc;
+}
+
+static int sql_prepare(sqlite3 *db, const char *zDb, const char *zName,
+                       sqlite3_stmt **ppStmt, const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  TRACE(("FTS1 prepare: %s\n", zCommand));
+  rc = sqlite3_prepare(db, zCommand, -1, ppStmt, NULL);
+  free(zCommand);
+  return rc;
+}
+
+/* end utility functions */
+
+/* Forward reference */
+typedef struct fulltext_vtab fulltext_vtab;
+
+/* A single term in a query is represented by an instances of
+** the following structure.
+*/
+typedef struct QueryTerm {
+  short int nPhrase; /* How many following terms are part of the same phrase */
+  short int iPhrase; /* This is the i-th term of a phrase. */
+  short int iColumn; /* Column of the index that must match this term */
+  signed char isOr;  /* this term is preceded by "OR" */
+  signed char isNot; /* this term is preceded by "-" */
+  char *pTerm;       /* text of the term.  '\000' terminated.  malloced */
+  int nTerm;         /* Number of bytes in pTerm[] */
+} QueryTerm;
+
+
+/* A query string is parsed into a Query structure.
+ *
+ * We could, in theory, allow query strings to be complicated
+ * nested expressions with precedence determined by parentheses.
+ * But none of the major search engines do this.  (Perhaps the
+ * feeling is that an parenthesized expression is two complex of
+ * an idea for the average user to grasp.)  Taking our lead from
+ * the major search engines, we will allow queries to be a list
+ * of terms (with an implied AND operator) or phrases in double-quotes,
+ * with a single optional "-" before each non-phrase term to designate
+ * negation and an optional OR connector.
+ *
+ * OR binds more tightly than the implied AND, which is what the
+ * major search engines seem to do.  So, for example:
+ * 
+ *    [one two OR three]     ==>    one AND (two OR three)
+ *    [one OR two three]     ==>    (one OR two) AND three
+ *
+ * A "-" before a term matches all entries that lack that term.
+ * The "-" must occur immediately before the term with in intervening
+ * space.  This is how the search engines do it.
+ *
+ * A NOT term cannot be the right-hand operand of an OR.  If this
+ * occurs in the query string, the NOT is ignored:
+ *
+ *    [one OR -two]          ==>    one OR two
+ *
+ */
+typedef struct Query {
+  fulltext_vtab *pFts;  /* The full text index */
+  int nTerms;           /* Number of terms in the query */
+  QueryTerm *pTerms;    /* Array of terms.  Space obtained from malloc() */
+  int nextIsOr;         /* Set the isOr flag on the next inserted term */
+  int nextColumn;       /* Next word parsed must be in this column */
+  int dfltColumn;       /* The default column */
+} Query;
+
+
+/*
+** An instance of the following structure keeps track of generated
+** matching-word offset information and snippets.
+*/
+typedef struct Snippet {
+  int nMatch;     /* Total number of matches */
+  int nAlloc;     /* Space allocated for aMatch[] */
+  struct snippetMatch { /* One entry for each matching term */
+    char snStatus;       /* Status flag for use while constructing snippets */
+    short int iCol;      /* The column that contains the match */
+    short int iTerm;     /* The index in Query.pTerms[] of the matching term */
+    short int nByte;     /* Number of bytes in the term */
+    int iStart;          /* The offset to the first character of the term */
+  } *aMatch;      /* Points to space obtained from malloc */
+  char *zOffset;  /* Text rendering of aMatch[] */
+  int nOffset;    /* strlen(zOffset) */
+  char *zSnippet; /* Snippet text */
+  int nSnippet;   /* strlen(zSnippet) */
+} Snippet;
+
+
+typedef enum QueryType {
+  QUERY_GENERIC,   /* table scan */
+  QUERY_ROWID,     /* lookup by rowid */
+  QUERY_FULLTEXT   /* QUERY_FULLTEXT + [i] is a full-text search for column i*/
+} QueryType;
+
+/* TODO(shess) CHUNK_MAX controls how much data we allow in segment 0
+** before we start aggregating into larger segments.  Lower CHUNK_MAX
+** means that for a given input we have more individual segments per
+** term, which means more rows in the table and a bigger index (due to
+** both more rows and bigger rowids).  But it also reduces the average
+** cost of adding new elements to the segment 0 doclist, and it seems
+** to reduce the number of pages read and written during inserts.  256
+** was chosen by measuring insertion times for a certain input (first
+** 10k documents of Enron corpus), though including query performance
+** in the decision may argue for a larger value.
+*/
+#define CHUNK_MAX 256
+
+typedef enum fulltext_statement {
+  CONTENT_INSERT_STMT,
+  CONTENT_SELECT_STMT,
+  CONTENT_UPDATE_STMT,
+  CONTENT_DELETE_STMT,
+
+  TERM_SELECT_STMT,
+  TERM_SELECT_ALL_STMT,
+  TERM_INSERT_STMT,
+  TERM_UPDATE_STMT,
+  TERM_DELETE_STMT,
+
+  MAX_STMT                     /* Always at end! */
+} fulltext_statement;
+
+/* These must exactly match the enum above. */
+/* TODO(adam): Is there some risk that a statement (in particular,
+** pTermSelectStmt) will be used in two cursors at once, e.g.  if a
+** query joins a virtual table to itself?  If so perhaps we should
+** move some of these to the cursor object.
+*/
+static const char *const fulltext_zStatement[MAX_STMT] = {
+  /* CONTENT_INSERT */ NULL,  /* generated in contentInsertStatement() */
+  /* CONTENT_SELECT */ "select * from %_content where rowid = ?",
+  /* CONTENT_UPDATE */ NULL,  /* generated in contentUpdateStatement() */
+  /* CONTENT_DELETE */ "delete from %_content where rowid = ?",
+
+  /* TERM_SELECT */
+  "select rowid, doclist from %_term where term = ? and segment = ?",
+  /* TERM_SELECT_ALL */
+  "select doclist from %_term where term = ? order by segment",
+  /* TERM_INSERT */
+  "insert into %_term (rowid, term, segment, doclist) values (?, ?, ?, ?)",
+  /* TERM_UPDATE */ "update %_term set doclist = ? where rowid = ?",
+  /* TERM_DELETE */ "delete from %_term where rowid = ?",
+};
+
+/*
+** A connection to a fulltext index is an instance of the following
+** structure.  The xCreate and xConnect methods create an instance
+** of this structure and xDestroy and xDisconnect free that instance.
+** All other methods receive a pointer to the structure as one of their
+** arguments.
+*/
+struct fulltext_vtab {
+  sqlite3_vtab base;               /* Base class used by SQLite core */
+  sqlite3 *db;                     /* The database connection */
+  const char *zDb;                 /* logical database name */
+  const char *zName;               /* virtual table name */
+  int nColumn;                     /* number of columns in virtual table */
+  char **azColumn;                 /* column names.  malloced */
+  char **azContentColumn;          /* column names in content table; malloced */
+  sqlite3_tokenizer *pTokenizer;   /* tokenizer for inserts and queries */
+
+  /* Precompiled statements which we keep as long as the table is
+  ** open.
+  */
+  sqlite3_stmt *pFulltextStatements[MAX_STMT];
+};
+
+/*
+** When the core wants to do a query, it create a cursor using a
+** call to xOpen.  This structure is an instance of a cursor.  It
+** is destroyed by xClose.
+*/
+typedef struct fulltext_cursor {
+  sqlite3_vtab_cursor base;        /* Base class used by SQLite core */
+  QueryType iCursorType;           /* Copy of sqlite3_index_info.idxNum */
+  sqlite3_stmt *pStmt;             /* Prepared statement in use by the cursor */
+  int eof;                         /* True if at End Of Results */
+  Query q;                         /* Parsed query string */
+  Snippet snippet;                 /* Cached snippet for the current row */
+  int iColumn;                     /* Column being searched */
+  DocListReader result;  /* used when iCursorType == QUERY_FULLTEXT */ 
+} fulltext_cursor;
+
+static struct fulltext_vtab *cursor_vtab(fulltext_cursor *c){
+  return (fulltext_vtab *) c->base.pVtab;
+}
+
+static const sqlite3_module fulltextModule;   /* forward declaration */
+
+/* Append a list of strings separated by commas to a StringBuffer. */
+static void appendList(StringBuffer *sb, int nString, char **azString){
+  int i;
+  for(i=0; i<nString; ++i){
+    if( i>0 ) append(sb, ", ");
+    append(sb, azString[i]);
+  }
+}
+
+/* Return a dynamically generated statement of the form
+ *   insert into %_content (rowid, ...) values (?, ...)
+ */
+static const char *contentInsertStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "insert into %_content (rowid, ");
+  appendList(&sb, v->nColumn, v->azContentColumn);
+  append(&sb, ") values (?");
+  for(i=0; i<v->nColumn; ++i)
+    append(&sb, ", ?");
+  append(&sb, ")");
+  return sb.s;
+}
+
+/* Return a dynamically generated statement of the form
+ *   update %_content set [col_0] = ?, [col_1] = ?, ...
+ *                    where rowid = ?
+ */
+static const char *contentUpdateStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "update %_content set ");
+  for(i=0; i<v->nColumn; ++i) {
+    if( i>0 ){
+      append(&sb, ", ");
+    }
+    append(&sb, v->azContentColumn[i]);
+    append(&sb, " = ?");
+  }
+  append(&sb, " where rowid = ?");
+  return sb.s;
+}
+
+/* Puts a freshly-prepared statement determined by iStmt in *ppStmt.
+** If the indicated statement has never been prepared, it is prepared
+** and cached, otherwise the cached version is reset.
+*/
+static int sql_get_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                             sqlite3_stmt **ppStmt){
+  assert( iStmt<MAX_STMT );
+  if( v->pFulltextStatements[iStmt]==NULL ){
+    const char *zStmt;
+    int rc;
+    switch( iStmt ){
+      case CONTENT_INSERT_STMT:
+        zStmt = contentInsertStatement(v); break;
+      case CONTENT_UPDATE_STMT:
+        zStmt = contentUpdateStatement(v); break;
+      default:
+        zStmt = fulltext_zStatement[iStmt];
+    }
+    rc = sql_prepare(v->db, v->zDb, v->zName, &v->pFulltextStatements[iStmt],
+                         zStmt);
+    if( zStmt != fulltext_zStatement[iStmt]) free((void *) zStmt);
+    if( rc!=SQLITE_OK ) return rc;
+  } else {
+    int rc = sqlite3_reset(v->pFulltextStatements[iStmt]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pFulltextStatements[iStmt];
+  return SQLITE_OK;
+}
+
+/* Step the indicated statement, handling errors SQLITE_BUSY (by
+** retrying) and SQLITE_SCHEMA (by re-preparing and transferring
+** bindings to the new statement).
+** TODO(adam): We should extend this function so that it can work with
+** statements declared locally, not only globally cached statements.
+*/
+static int sql_step_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                              sqlite3_stmt **ppStmt){
+  int rc;
+  sqlite3_stmt *s = *ppStmt;
+  assert( iStmt<MAX_STMT );
+  assert( s==v->pFulltextStatements[iStmt] );
+
+  while( (rc=sqlite3_step(s))!=SQLITE_DONE && rc!=SQLITE_ROW ){
+    if( rc==SQLITE_BUSY ) continue;
+    if( rc!=SQLITE_ERROR ) return rc;
+
+    /* If an SQLITE_SCHEMA error has occured, then finalizing this
+     * statement is going to delete the fulltext_vtab structure. If
+     * the statement just executed is in the pFulltextStatements[]
+     * array, it will be finalized twice. So remove it before
+     * calling sqlite3_finalize().
+     */
+    v->pFulltextStatements[iStmt] = NULL;
+    rc = sqlite3_finalize(s);
+    break;
+  }
+  return rc;
+
+ err:
+  sqlite3_finalize(s);
+  return rc;
+}
+
+/* Like sql_step_statement(), but convert SQLITE_DONE to SQLITE_OK.
+** Useful for statements like UPDATE, where we expect no results.
+*/
+static int sql_single_step_statement(fulltext_vtab *v,
+                                     fulltext_statement iStmt,
+                                     sqlite3_stmt **ppStmt){
+  int rc = sql_step_statement(v, iStmt, ppStmt);
+  return (rc==SQLITE_DONE) ? SQLITE_OK : rc;
+}
+
+/* insert into %_content (rowid, ...) values ([rowid], [pValues]) */
+static int content_insert(fulltext_vtab *v, sqlite3_value *rowid,
+                          sqlite3_value **pValues){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_value(s, 1, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 2+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  return sql_single_step_statement(v, CONTENT_INSERT_STMT, &s);
+}
+
+/* update %_content set col0 = pValues[0], col1 = pValues[1], ...
+ *                  where rowid = [iRowid] */
+static int content_update(fulltext_vtab *v, sqlite3_value **pValues,
+                          sqlite_int64 iRowid){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_UPDATE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 1+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  rc = sqlite3_bind_int64(s, 1+v->nColumn, iRowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, CONTENT_UPDATE_STMT, &s);
+}
+
+static void freeStringArray(int nString, const char **pString){
+  int i;
+
+  for (i=0 ; i < nString ; ++i) {
+    if( pString[i]!=NULL ) free((void *) pString[i]);
+  }
+  free((void *) pString);
+}
+
+/* select * from %_content where rowid = [iRow]
+ * The caller must delete the returned array and all strings in it.
+ * null fields will be NULL in the returned array.
+ *
+ * TODO: Perhaps we should return pointer/length strings here for consistency
+ * with other code which uses pointer/length. */
+static int content_select(fulltext_vtab *v, sqlite_int64 iRow,
+                          const char ***pValues){
+  sqlite3_stmt *s;
+  const char **values;
+  int i;
+  int rc;
+
+  *pValues = NULL;
+
+  rc = sql_get_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sql_step_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_ROW ) return rc;
+
+  values = (const char **) malloc(v->nColumn * sizeof(const char *));
+  for(i=0; i<v->nColumn; ++i){
+    if( sqlite3_column_type(s, i)==SQLITE_NULL ){
+      values[i] = NULL;
+    }else{
+      values[i] = string_dup((char*)sqlite3_column_text(s, i));
+    }
+  }
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ){
+    *pValues = values;
+    return SQLITE_OK;
+  }
+
+  freeStringArray(v->nColumn, values);
+  return rc;
+}
+
+/* delete from %_content where rowid = [iRow ] */
+static int content_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, CONTENT_DELETE_STMT, &s);
+}
+
+/* select rowid, doclist from %_term
+ *  where term = [pTerm] and segment = [iSegment]
+ * If found, returns SQLITE_ROW; the caller must free the
+ * returned doclist.  If no rows found, returns SQLITE_DONE. */
+static int term_select(fulltext_vtab *v, const char *pTerm, int nTerm,
+                       int iSegment,
+                       sqlite_int64 *rowid, DocList *out){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 1, pTerm, nTerm, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 2, iSegment);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sql_step_statement(v, TERM_SELECT_STMT, &s);
+  if( rc!=SQLITE_ROW ) return rc;
+
+  *rowid = sqlite3_column_int64(s, 0);
+  docListInit(out, DL_DEFAULT,
+              sqlite3_column_blob(s, 1), sqlite3_column_bytes(s, 1));
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  return rc==SQLITE_DONE ? SQLITE_ROW : rc;
+}
+
+/* Load the segment doclists for term pTerm and merge them in
+** appropriate order into out.  Returns SQLITE_OK if successful.  If
+** there are no segments for pTerm, successfully returns an empty
+** doclist in out.
+**
+** Each document consists of 1 or more "columns".  The number of
+** columns is v->nColumn.  If iColumn==v->nColumn, then return
+** position information about all columns.  If iColumn<v->nColumn,
+** then only return position information about the iColumn-th column
+** (where the first column is 0).
+*/
+static int term_select_all(
+  fulltext_vtab *v,     /* The fulltext index we are querying against */
+  int iColumn,          /* If <nColumn, only look at the iColumn-th column */
+  const char *pTerm,    /* The term whose posting lists we want */
+  int nTerm,            /* Number of bytes in pTerm */
+  DocList *out          /* Write the resulting doclist here */
+){
+  DocList doclist;
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_SELECT_ALL_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 1, pTerm, nTerm, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  docListInit(&doclist, DL_DEFAULT, 0, 0);
+
+  /* TODO(shess) Handle schema and busy errors. */
+  while( (rc=sql_step_statement(v, TERM_SELECT_ALL_STMT, &s))==SQLITE_ROW ){
+    DocList old;
+
+    /* TODO(shess) If we processed doclists from oldest to newest, we
+    ** could skip the malloc() involved with the following call.  For
+    ** now, I'd rather keep this logic similar to index_insert_term().
+    ** We could additionally drop elements when we see deletes, but
+    ** that would require a distinct version of docListAccumulate().
+    */
+    docListInit(&old, DL_DEFAULT,
+                sqlite3_column_blob(s, 0), sqlite3_column_bytes(s, 0));
+
+    if( iColumn<v->nColumn ){   /* querying a single column */
+      docListRestrictColumn(&old, iColumn);
+    }
+
+    /* doclist contains the newer data, so write it over old.  Then
+    ** steal accumulated result for doclist.
+    */
+    docListAccumulate(&old, &doclist);
+    docListDestroy(&doclist);
+    doclist = old;
+  }
+  if( rc!=SQLITE_DONE ){
+    docListDestroy(&doclist);
+    return rc;
+  }
+
+  docListDiscardEmpty(&doclist);
+  *out = doclist;
+  return SQLITE_OK;
+}
+
+/* insert into %_term (rowid, term, segment, doclist)
+               values ([piRowid], [pTerm], [iSegment], [doclist])
+** Lets sqlite select rowid if piRowid is NULL, else uses *piRowid.
+**
+** NOTE(shess) piRowid is IN, with values of "space of int64" plus
+** null, it is not used to pass data back to the caller.
+*/
+static int term_insert(fulltext_vtab *v, sqlite_int64 *piRowid,
+                       const char *pTerm, int nTerm,
+                       int iSegment, DocList *doclist){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  if( piRowid==NULL ){
+    rc = sqlite3_bind_null(s, 1);
+  }else{
+    rc = sqlite3_bind_int64(s, 1, *piRowid);
+  }
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 2, pTerm, nTerm, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 3, iSegment);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 4, doclist->pData, doclist->nData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_INSERT_STMT, &s);
+}
+
+/* update %_term set doclist = [doclist] where rowid = [rowid] */
+static int term_update(fulltext_vtab *v, sqlite_int64 rowid,
+                       DocList *doclist){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_UPDATE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 1, doclist->pData, doclist->nData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_UPDATE_STMT, &s);
+}
+
+static int term_delete(fulltext_vtab *v, sqlite_int64 rowid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_DELETE_STMT, &s);
+}
+
+/*
+** Free the memory used to contain a fulltext_vtab structure.
+*/
+static void fulltext_vtab_destroy(fulltext_vtab *v){
+  int iStmt, i;
+
+  TRACE(("FTS1 Destroy %p\n", v));
+  for( iStmt=0; iStmt<MAX_STMT; iStmt++ ){
+    if( v->pFulltextStatements[iStmt]!=NULL ){
+      sqlite3_finalize(v->pFulltextStatements[iStmt]);
+      v->pFulltextStatements[iStmt] = NULL;
+    }
+  }
+
+  if( v->pTokenizer!=NULL ){
+    v->pTokenizer->pModule->xDestroy(v->pTokenizer);
+    v->pTokenizer = NULL;
+  }
+  
+  free(v->azColumn);
+  for(i = 0; i < v->nColumn; ++i) {
+    sqlite3_free(v->azContentColumn[i]);
+  }
+  free(v->azContentColumn);
+  free(v);
+}
+
+/*
+** Token types for parsing the arguments to xConnect or xCreate.
+*/
+#define TOKEN_EOF         0    /* End of file */
+#define TOKEN_SPACE       1    /* Any kind of whitespace */
+#define TOKEN_ID          2    /* An identifier */
+#define TOKEN_STRING      3    /* A string literal */
+#define TOKEN_PUNCT       4    /* A single punctuation character */
+
+/*
+** If X is a character that can be used in an identifier then
+** IdChar(X) will be true.  Otherwise it is false.
+**
+** For ASCII, any character with the high-order bit set is
+** allowed in an identifier.  For 7-bit characters, 
+** sqlite3IsIdChar[X] must be 1.
+**
+** Ticket #1066.  the SQL standard does not allow '$' in the
+** middle of identfiers.  But many SQL implementations do. 
+** SQLite will allow '$' in identifiers for compatibility.
+** But the feature is undocumented.
+*/
+static const char isIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && isIdChar[c-0x20]))
+
+
+/*
+** Return the length of the token that begins at z[0]. 
+** Store the token type in *tokenType before returning.
+*/
+static int getToken(const char *z, int *tokenType){
+  int i, c;
+  switch( *z ){
+    case 0: {
+      *tokenType = TOKEN_EOF;
+      return 0;
+    }
+    case ' ': case '\t': case '\n': case '\f': case '\r': {
+      for(i=1; safe_isspace(z[i]); i++){}
+      *tokenType = TOKEN_SPACE;
+      return i;
+    }
+    case '`':
+    case '\'':
+    case '"': {
+      int delim = z[0];
+      for(i=1; (c=z[i])!=0; i++){
+        if( c==delim ){
+          if( z[i+1]==delim ){
+            i++;
+          }else{
+            break;
+          }
+        }
+      }
+      *tokenType = TOKEN_STRING;
+      return i + (c!=0);
+    }
+    case '[': {
+      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+    default: {
+      if( !IdChar(*z) ){
+        break;
+      }
+      for(i=1; IdChar(z[i]); i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+  }
+  *tokenType = TOKEN_PUNCT;
+  return 1;
+}
+
+/*
+** A token extracted from a string is an instance of the following
+** structure.
+*/
+typedef struct Token {
+  const char *z;       /* Pointer to token text.  Not '\000' terminated */
+  short int n;         /* Length of the token text in bytes. */
+} Token;
+
+/*
+** Given a input string (which is really one of the argv[] parameters
+** passed into xConnect or xCreate) split the string up into tokens.
+** Return an array of pointers to '\000' terminated strings, one string
+** for each non-whitespace token.
+**
+** The returned array is terminated by a single NULL pointer.
+**
+** Space to hold the returned array is obtained from a single
+** malloc and should be freed by passing the return value to free().
+** The individual strings within the token list are all a part of
+** the single memory allocation and will all be freed at once.
+*/
+static char **tokenizeString(const char *z, int *pnToken){
+  int nToken = 0;
+  Token *aToken = malloc( strlen(z) * sizeof(aToken[0]) );
+  int n = 1;
+  int e, i;
+  int totalSize = 0;
+  char **azToken;
+  char *zCopy;
+  while( n>0 ){
+    n = getToken(z, &e);
+    if( e!=TOKEN_SPACE ){
+      aToken[nToken].z = z;
+      aToken[nToken].n = n;
+      nToken++;
+      totalSize += n+1;
+    }
+    z += n;
+  }
+  azToken = (char**)malloc( nToken*sizeof(char*) + totalSize );
+  zCopy = (char*)&azToken[nToken];
+  nToken--;
+  for(i=0; i<nToken; i++){
+    azToken[i] = zCopy;
+    n = aToken[i].n;
+    memcpy(zCopy, aToken[i].z, n);
+    zCopy[n] = 0;
+    zCopy += n+1;
+  }
+  azToken[nToken] = 0;
+  free(aToken);
+  *pnToken = nToken;
+  return azToken;
+}
+
+/*
+** 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.
+**
+** Examples:
+**
+**     "abc"   becomes   abc
+**     'xyz'   becomes   xyz
+**     [pqr]   becomes   pqr
+**     `mno`   becomes   mno
+*/
+static void dequoteString(char *z){
+  int quote;
+  int i, j;
+  if( z==0 ) return;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return;
+  }
+  for(i=1, j=0; z[i]; i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        z[j++] = 0;
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+}
+
+/*
+** The input azIn is a NULL-terminated list of tokens.  Remove the first
+** token and all punctuation tokens.  Remove the quotes from
+** around string literal tokens.
+**
+** Example:
+**
+**     input:      tokenize chinese ( 'simplifed' , 'mixed' )
+**     output:     chinese simplifed mixed
+**
+** Another example:
+**
+**     input:      delimiters ( '[' , ']' , '...' )
+**     output:     [ ] ...
+*/
+static void tokenListToIdList(char **azIn){
+  int i, j;
+  if( azIn ){
+    for(i=0, j=-1; azIn[i]; i++){
+      if( safe_isalnum(azIn[i][0]) || azIn[i][1] ){
+        dequoteString(azIn[i]);
+        if( j>=0 ){
+          azIn[j] = azIn[i];
+        }
+        j++;
+      }
+    }
+    azIn[j] = 0;
+  }
+}
+
+
+/*
+** Find the first alphanumeric token in the string zIn.  Null-terminate
+** this token.  Remove any quotation marks.  And return a pointer to
+** the result.
+*/
+static char *firstToken(char *zIn, char **pzTail){
+  int n, ttype;
+  while(1){
+    n = getToken(zIn, &ttype);
+    if( ttype==TOKEN_SPACE ){
+      zIn += n;
+    }else if( ttype==TOKEN_EOF ){
+      *pzTail = zIn;
+      return 0;
+    }else{
+      zIn[n] = 0;
+      *pzTail = &zIn[1];
+      dequoteString(zIn);
+      return zIn;
+    }
+  }
+  /*NOTREACHED*/
+}
+
+/* Return true if...
+**
+**   *  s begins with the string t, ignoring case
+**   *  s is longer than t
+**   *  The first character of s beyond t is not a alphanumeric
+** 
+** Ignore leading space in *s.
+**
+** To put it another way, return true if the first token of
+** s[] is t[].
+*/
+static int startsWith(const char *s, const char *t){
+  while( safe_isspace(*s) ){ s++; }
+  while( *t ){
+    if( safe_tolower(*s++)!=safe_tolower(*t++) ) return 0;
+  }
+  return *s!='_' && !safe_isalnum(*s);
+}
+
+/*
+** An instance of this structure defines the "spec" of a
+** full text index.  This structure is populated by parseSpec
+** and use by fulltextConnect and fulltextCreate.
+*/
+typedef struct TableSpec {
+  const char *zDb;         /* Logical database name */
+  const char *zName;       /* Name of the full-text index */
+  int nColumn;             /* Number of columns to be indexed */
+  char **azColumn;         /* Original names of columns to be indexed */
+  char **azContentColumn;  /* Column names for %_content */
+  char **azTokenizer;      /* Name of tokenizer and its arguments */
+} TableSpec;
+
+/*
+** Reclaim all of the memory used by a TableSpec
+*/
+static void clearTableSpec(TableSpec *p) {
+  free(p->azColumn);
+  free(p->azContentColumn);
+  free(p->azTokenizer);
+}
+
+/* Parse a CREATE VIRTUAL TABLE statement, which looks like this:
+ *
+ * CREATE VIRTUAL TABLE email
+ *        USING fts1(subject, body, tokenize mytokenizer(myarg))
+ *
+ * We return parsed information in a TableSpec structure.
+ * 
+ */
+static int parseSpec(TableSpec *pSpec, int argc, const char *const*argv,
+                     char**pzErr){
+  int i, n;
+  char *z, *zDummy;
+  char **azArg;
+  const char *zTokenizer = 0;    /* argv[] entry describing the tokenizer */
+
+  assert( argc>=3 );
+  /* Current interface:
+  ** argv[0] - module name
+  ** argv[1] - database name
+  ** argv[2] - table name
+  ** argv[3..] - columns, optionally followed by tokenizer specification
+  **             and snippet delimiters specification.
+  */
+
+  /* Make a copy of the complete argv[][] array in a single allocation.
+  ** The argv[][] array is read-only and transient.  We can write to the
+  ** copy in order to modify things and the copy is persistent.
+  */
+  memset(pSpec, 0, sizeof(*pSpec));
+  for(i=n=0; i<argc; i++){
+    n += strlen(argv[i]) + 1;
+  }
+  azArg = malloc( sizeof(char*)*argc + n );
+  if( azArg==0 ){
+    return SQLITE_NOMEM;
+  }
+  z = (char*)&azArg[argc];
+  for(i=0; i<argc; i++){
+    azArg[i] = z;
+    strcpy(z, argv[i]);
+    z += strlen(z)+1;
+  }
+
+  /* Identify the column names and the tokenizer and delimiter arguments
+  ** in the argv[][] array.
+  */
+  pSpec->zDb = azArg[1];
+  pSpec->zName = azArg[2];
+  pSpec->nColumn = 0;
+  pSpec->azColumn = azArg;
+  zTokenizer = "tokenize simple";
+  for(i=3; i<argc; ++i){
+    if( startsWith(azArg[i],"tokenize") ){
+      zTokenizer = azArg[i];
+    }else{
+      z = azArg[pSpec->nColumn] = firstToken(azArg[i], &zDummy);
+      pSpec->nColumn++;
+    }
+  }
+  if( pSpec->nColumn==0 ){
+    azArg[0] = "content";
+    pSpec->nColumn = 1;
+  }
+
+  /*
+  ** Construct the list of content column names.
+  **
+  ** Each content column name will be of the form cNNAAAA
+  ** where NN is the column number and AAAA is the sanitized
+  ** column name.  "sanitized" means that special characters are
+  ** converted to "_".  The cNN prefix guarantees that all column
+  ** names are unique.
+  **
+  ** The AAAA suffix is not strictly necessary.  It is included
+  ** for the convenience of people who might examine the generated
+  ** %_content table and wonder what the columns are used for.
+  */
+  pSpec->azContentColumn = malloc( pSpec->nColumn * sizeof(char *) );
+  if( pSpec->azContentColumn==0 ){
+    clearTableSpec(pSpec);
+    return SQLITE_NOMEM;
+  }
+  for(i=0; i<pSpec->nColumn; i++){
+    char *p;
+    pSpec->azContentColumn[i] = sqlite3_mprintf("c%d%s", i, azArg[i]);
+    for (p = pSpec->azContentColumn[i]; *p ; ++p) {
+      if( !safe_isalnum(*p) ) *p = '_';
+    }
+  }
+
+  /*
+  ** Parse the tokenizer specification string.
+  */
+  pSpec->azTokenizer = tokenizeString(zTokenizer, &n);
+  tokenListToIdList(pSpec->azTokenizer);
+
+  return SQLITE_OK;
+}
+
+/*
+** Generate a CREATE TABLE statement that describes the schema of
+** the virtual table.  Return a pointer to this schema string.
+**
+** Space is obtained from sqlite3_mprintf() and should be freed
+** using sqlite3_free().
+*/
+static char *fulltextSchema(
+  int nColumn,                  /* Number of columns */
+  const char *const* azColumn,  /* List of columns */
+  const char *zTableName        /* Name of the table */
+){
+  int i;
+  char *zSchema, *zNext;
+  const char *zSep = "(";
+  zSchema = sqlite3_mprintf("CREATE TABLE x");
+  for(i=0; i<nColumn; i++){
+    zNext = sqlite3_mprintf("%s%s%Q", zSchema, zSep, azColumn[i]);
+    sqlite3_free(zSchema);
+    zSchema = zNext;
+    zSep = ",";
+  }
+  zNext = sqlite3_mprintf("%s,%Q)", zSchema, zTableName);
+  sqlite3_free(zSchema);
+  return zNext;
+}
+
+/*
+** Build a new sqlite3_vtab structure that will describe the
+** fulltext index defined by spec.
+*/
+static int constructVtab(
+  sqlite3 *db,              /* The SQLite database connection */
+  TableSpec *spec,          /* Parsed spec information from parseSpec() */
+  sqlite3_vtab **ppVTab,    /* Write the resulting vtab structure here */
+  char **pzErr              /* Write any error message here */
+){
+  int rc;
+  int n;
+  fulltext_vtab *v = 0;
+  const sqlite3_tokenizer_module *m = NULL;
+  char *schema;
+
+  v = (fulltext_vtab *) malloc(sizeof(fulltext_vtab));
+  if( v==0 ) return SQLITE_NOMEM;
+  memset(v, 0, sizeof(*v));
+  /* sqlite will initialize v->base */
+  v->db = db;
+  v->zDb = spec->zDb;       /* Freed when azColumn is freed */
+  v->zName = spec->zName;   /* Freed when azColumn is freed */
+  v->nColumn = spec->nColumn;
+  v->azContentColumn = spec->azContentColumn;
+  spec->azContentColumn = 0;
+  v->azColumn = spec->azColumn;
+  spec->azColumn = 0;
+
+  if( spec->azTokenizer==0 ){
+    return SQLITE_NOMEM;
+  }
+  /* TODO(shess) For now, add new tokenizers as else if clauses. */
+  if( spec->azTokenizer[0]==0 || startsWith(spec->azTokenizer[0], "simple") ){
+    sqlite3Fts1SimpleTokenizerModule(&m);
+  }else if( startsWith(spec->azTokenizer[0], "porter") ){
+    sqlite3Fts1PorterTokenizerModule(&m);
+  }else{
+    *pzErr = sqlite3_mprintf("unknown tokenizer: %s", spec->azTokenizer[0]);
+    rc = SQLITE_ERROR;
+    goto err;
+  }
+  for(n=0; spec->azTokenizer[n]; n++){}
+  if( n ){
+    rc = m->xCreate(n-1, (const char*const*)&spec->azTokenizer[1],
+                    &v->pTokenizer);
+  }else{
+    rc = m->xCreate(0, 0, &v->pTokenizer);
+  }
+  if( rc!=SQLITE_OK ) goto err;
+  v->pTokenizer->pModule = m;
+
+  /* TODO: verify the existence of backing tables foo_content, foo_term */
+
+  schema = fulltextSchema(v->nColumn, (const char*const*)v->azColumn,
+                          spec->zName);
+  rc = sqlite3_declare_vtab(db, schema);
+  sqlite3_free(schema);
+  if( rc!=SQLITE_OK ) goto err;
+
+  memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
+
+  *ppVTab = &v->base;
+  TRACE(("FTS1 Connect %p\n", v));
+
+  return rc;
+
+err:
+  fulltext_vtab_destroy(v);
+  return rc;
+}
+
+static int fulltextConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVTab,
+  char **pzErr
+){
+  TableSpec spec;
+  int rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = constructVtab(db, &spec, ppVTab, pzErr);
+  clearTableSpec(&spec);
+  return rc;
+}
+
+  /* The %_content table holds the text of each document, with
+  ** the rowid used as the docid.
+  **
+  ** The %_term table maps each term to a document list blob
+  ** containing elements sorted by ascending docid, each element
+  ** encoded as:
+  **
+  **   docid varint-encoded
+  **   token elements:
+  **     position+1 varint-encoded as delta from previous position
+  **     start offset varint-encoded as delta from previous start offset
+  **     end offset varint-encoded as delta from start offset
+  **
+  ** The sentinel position of 0 indicates the end of the token list.
+  **
+  ** Additionally, doclist blobs are chunked into multiple segments,
+  ** using segment to order the segments.  New elements are added to
+  ** the segment at segment 0, until it exceeds CHUNK_MAX.  Then
+  ** segment 0 is deleted, and the doclist is inserted at segment 1.
+  ** If there is already a doclist at segment 1, the segment 0 doclist
+  ** is merged with it, the segment 1 doclist is deleted, and the
+  ** merged doclist is inserted at segment 2, repeating those
+  ** operations until an insert succeeds.
+  **
+  ** Since this structure doesn't allow us to update elements in place
+  ** in case of deletion or update, these are simply written to
+  ** segment 0 (with an empty token list in case of deletion), with
+  ** docListAccumulate() taking care to retain lower-segment
+  ** information in preference to higher-segment information.
+  */
+  /* TODO(shess) Provide a VACUUM type operation which both removes
+  ** deleted elements which are no longer necessary, and duplicated
+  ** elements.  I suspect this will probably not be necessary in
+  ** practice, though.
+  */
+static int fulltextCreate(sqlite3 *db, void *pAux,
+                          int argc, const char * const *argv,
+                          sqlite3_vtab **ppVTab, char **pzErr){
+  int rc;
+  TableSpec spec;
+  StringBuffer schema;
+  TRACE(("FTS1 Create\n"));
+
+  rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  initStringBuffer(&schema);
+  append(&schema, "CREATE TABLE %_content(");
+  appendList(&schema, spec.nColumn, spec.azContentColumn);
+  append(&schema, ")");
+  rc = sql_exec(db, spec.zDb, spec.zName, schema.s);
+  free(schema.s);
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = sql_exec(db, spec.zDb, spec.zName,
+    "create table %_term(term text, segment integer, doclist blob, "
+                        "primary key(term, segment));");
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = constructVtab(db, &spec, ppVTab, pzErr);
+
+out:
+  clearTableSpec(&spec);
+  return rc;
+}
+
+/* Decide how to handle an SQL query. */
+static int fulltextBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
+  int i;
+  TRACE(("FTS1 BestIndex\n"));
+
+  for(i=0; i<pInfo->nConstraint; ++i){
+    const struct sqlite3_index_constraint *pConstraint;
+    pConstraint = &pInfo->aConstraint[i];
+    if( pConstraint->usable ) {
+      if( pConstraint->iColumn==-1 &&
+          pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
+        pInfo->idxNum = QUERY_ROWID;      /* lookup by rowid */
+        TRACE(("FTS1 QUERY_ROWID\n"));
+      } else if( pConstraint->iColumn>=0 &&
+                 pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
+        /* full-text search */
+        pInfo->idxNum = QUERY_FULLTEXT + pConstraint->iColumn;
+        TRACE(("FTS1 QUERY_FULLTEXT %d\n", pConstraint->iColumn));
+      } else continue;
+
+      pInfo->aConstraintUsage[i].argvIndex = 1;
+      pInfo->aConstraintUsage[i].omit = 1;
+
+      /* An arbitrary value for now.
+       * TODO: Perhaps rowid matches should be considered cheaper than
+       * full-text searches. */
+      pInfo->estimatedCost = 1.0;   
+
+      return SQLITE_OK;
+    }
+  }
+  pInfo->idxNum = QUERY_GENERIC;
+  return SQLITE_OK;
+}
+
+static int fulltextDisconnect(sqlite3_vtab *pVTab){
+  TRACE(("FTS1 Disconnect %p\n", pVTab));
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextDestroy(sqlite3_vtab *pVTab){
+  fulltext_vtab *v = (fulltext_vtab *)pVTab;
+  int rc;
+
+  TRACE(("FTS1 Destroy %p\n", pVTab));
+  rc = sql_exec(v->db, v->zDb, v->zName,
+                "drop table if exists %_content;"
+                "drop table if exists %_term;"
+                );
+  if( rc!=SQLITE_OK ) return rc;
+
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  fulltext_cursor *c;
+
+  c = (fulltext_cursor *) calloc(sizeof(fulltext_cursor), 1);
+  /* sqlite will initialize c->base */
+  *ppCursor = &c->base;
+  TRACE(("FTS1 Open %p: %p\n", pVTab, c));
+
+  return SQLITE_OK;
+}
+
+
+/* Free all of the dynamically allocated memory held by *q
+*/
+static void queryClear(Query *q){
+  int i;
+  for(i = 0; i < q->nTerms; ++i){
+    free(q->pTerms[i].pTerm);
+  }
+  free(q->pTerms);
+  memset(q, 0, sizeof(*q));
+}
+
+/* Free all of the dynamically allocated memory held by the
+** Snippet
+*/
+static void snippetClear(Snippet *p){
+  free(p->aMatch);
+  free(p->zOffset);
+  free(p->zSnippet);
+  memset(p, 0, sizeof(*p));
+}
+/*
+** Append a single entry to the p->aMatch[] log.
+*/
+static void snippetAppendMatch(
+  Snippet *p,               /* Append the entry to this snippet */
+  int iCol, int iTerm,      /* The column and query term */
+  int iStart, int nByte     /* Offset and size of the match */
+){
+  int i;
+  struct snippetMatch *pMatch;
+  if( p->nMatch+1>=p->nAlloc ){
+    p->nAlloc = p->nAlloc*2 + 10;
+    p->aMatch = realloc(p->aMatch, p->nAlloc*sizeof(p->aMatch[0]) );
+    if( p->aMatch==0 ){
+      p->nMatch = 0;
+      p->nAlloc = 0;
+      return;
+    }
+  }
+  i = p->nMatch++;
+  pMatch = &p->aMatch[i];
+  pMatch->iCol = iCol;
+  pMatch->iTerm = iTerm;
+  pMatch->iStart = iStart;
+  pMatch->nByte = nByte;
+}
+
+/*
+** Sizing information for the circular buffer used in snippetOffsetsOfColumn()
+*/
+#define FTS1_ROTOR_SZ   (32)
+#define FTS1_ROTOR_MASK (FTS1_ROTOR_SZ-1)
+
+/*
+** Add entries to pSnippet->aMatch[] for every match that occurs against
+** document zDoc[0..nDoc-1] which is stored in column iColumn.
+*/
+static void snippetOffsetsOfColumn(
+  Query *pQuery,
+  Snippet *pSnippet,
+  int iColumn,
+  const char *zDoc,
+  int nDoc
+){
+  const sqlite3_tokenizer_module *pTModule;  /* The tokenizer module */
+  sqlite3_tokenizer *pTokenizer;             /* The specific tokenizer */
+  sqlite3_tokenizer_cursor *pTCursor;        /* Tokenizer cursor */
+  fulltext_vtab *pVtab;                /* The full text index */
+  int nColumn;                         /* Number of columns in the index */
+  const QueryTerm *aTerm;              /* Query string terms */
+  int nTerm;                           /* Number of query string terms */  
+  int i, j;                            /* Loop counters */
+  int rc;                              /* Return code */
+  unsigned int match, prevMatch;       /* Phrase search bitmasks */
+  const char *zToken;                  /* Next token from the tokenizer */
+  int nToken;                          /* Size of zToken */
+  int iBegin, iEnd, iPos;              /* Offsets of beginning and end */
+
+  /* The following variables keep a circular buffer of the last
+  ** few tokens */
+  unsigned int iRotor = 0;             /* Index of current token */
+  int iRotorBegin[FTS1_ROTOR_SZ];      /* Beginning offset of token */
+  int iRotorLen[FTS1_ROTOR_SZ];        /* Length of token */
+
+  pVtab = pQuery->pFts;
+  nColumn = pVtab->nColumn;
+  pTokenizer = pVtab->pTokenizer;
+  pTModule = pTokenizer->pModule;
+  rc = pTModule->xOpen(pTokenizer, zDoc, nDoc, &pTCursor);
+  if( rc ) return;
+  pTCursor->pTokenizer = pTokenizer;
+  aTerm = pQuery->pTerms;
+  nTerm = pQuery->nTerms;
+  if( nTerm>=FTS1_ROTOR_SZ ){
+    nTerm = FTS1_ROTOR_SZ - 1;
+  }
+  prevMatch = 0;
+  while(1){
+    rc = pTModule->xNext(pTCursor, &zToken, &nToken, &iBegin, &iEnd, &iPos);
+    if( rc ) break;
+    iRotorBegin[iRotor&FTS1_ROTOR_MASK] = iBegin;
+    iRotorLen[iRotor&FTS1_ROTOR_MASK] = iEnd-iBegin;
+    match = 0;
+    for(i=0; i<nTerm; i++){
+      int iCol;
+      iCol = aTerm[i].iColumn;
+      if( iCol>=0 && iCol<nColumn && iCol!=iColumn ) continue;
+      if( aTerm[i].nTerm!=nToken ) continue;
+      if( memcmp(aTerm[i].pTerm, zToken, nToken) ) continue;
+      if( aTerm[i].iPhrase>1 && (prevMatch & (1<<i))==0 ) continue;
+      match |= 1<<i;
+      if( i==nTerm-1 || aTerm[i+1].iPhrase==1 ){
+        for(j=aTerm[i].iPhrase-1; j>=0; j--){
+          int k = (iRotor-j) & FTS1_ROTOR_MASK;
+          snippetAppendMatch(pSnippet, iColumn, i-j,
+                iRotorBegin[k], iRotorLen[k]);
+        }
+      }
+    }
+    prevMatch = match<<1;
+    iRotor++;
+  }
+  pTModule->xClose(pTCursor);  
+}
+
+
+/*
+** Compute all offsets for the current row of the query.  
+** If the offsets have already been computed, this routine is a no-op.
+*/
+static void snippetAllOffsets(fulltext_cursor *p){
+  int nColumn;
+  int iColumn, i;
+  int iFirst, iLast;
+  fulltext_vtab *pFts;
+
+  if( p->snippet.nMatch ) return;
+  if( p->q.nTerms==0 ) return;
+  pFts = p->q.pFts;
+  nColumn = pFts->nColumn;
+  iColumn = p->iCursorType - QUERY_FULLTEXT;
+  if( iColumn<0 || iColumn>=nColumn ){
+    iFirst = 0;
+    iLast = nColumn-1;
+  }else{
+    iFirst = iColumn;
+    iLast = iColumn;
+  }
+  for(i=iFirst; i<=iLast; i++){
+    const char *zDoc;
+    int nDoc;
+    zDoc = (const char*)sqlite3_column_text(p->pStmt, i+1);
+    nDoc = sqlite3_column_bytes(p->pStmt, i+1);
+    snippetOffsetsOfColumn(&p->q, &p->snippet, i, zDoc, nDoc);
+  }
+}
+
+/*
+** Convert the information in the aMatch[] array of the snippet
+** into the string zOffset[0..nOffset-1].
+*/
+static void snippetOffsetText(Snippet *p){
+  int i;
+  int cnt = 0;
+  StringBuffer sb;
+  char zBuf[200];
+  if( p->zOffset ) return;
+  initStringBuffer(&sb);
+  for(i=0; i<p->nMatch; i++){
+    struct snippetMatch *pMatch = &p->aMatch[i];
+    zBuf[0] = ' ';
+    sprintf(&zBuf[cnt>0], "%d %d %d %d", pMatch->iCol,
+        pMatch->iTerm, pMatch->iStart, pMatch->nByte);
+    append(&sb, zBuf);
+    cnt++;
+  }
+  p->zOffset = sb.s;
+  p->nOffset = sb.len;
+}
+
+/*
+** zDoc[0..nDoc-1] is phrase of text.  aMatch[0..nMatch-1] are a set
+** of matching words some of which might be in zDoc.  zDoc is column
+** number iCol.
+**
+** iBreak is suggested spot in zDoc where we could begin or end an
+** excerpt.  Return a value similar to iBreak but possibly adjusted
+** to be a little left or right so that the break point is better.
+*/
+static int wordBoundary(
+  int iBreak,                   /* The suggested break point */
+  const char *zDoc,             /* Document text */
+  int nDoc,                     /* Number of bytes in zDoc[] */
+  struct snippetMatch *aMatch,  /* Matching words */
+  int nMatch,                   /* Number of entries in aMatch[] */
+  int iCol                      /* The column number for zDoc[] */
+){
+  int i;
+  if( iBreak<=10 ){
+    return 0;
+  }
+  if( iBreak>=nDoc-10 ){
+    return nDoc;
+  }
+  for(i=0; i<nMatch && aMatch[i].iCol<iCol; i++){}
+  while( i<nMatch && aMatch[i].iStart+aMatch[i].nByte<iBreak ){ i++; }
+  if( i<nMatch ){
+    if( aMatch[i].iStart<iBreak+10 ){
+      return aMatch[i].iStart;
+    }
+    if( i>0 && aMatch[i-1].iStart+aMatch[i-1].nByte>=iBreak ){
+      return aMatch[i-1].iStart;
+    }
+  }
+  for(i=1; i<=10; i++){
+    if( safe_isspace(zDoc[iBreak-i]) ){
+      return iBreak - i + 1;
+    }
+    if( safe_isspace(zDoc[iBreak+i]) ){
+      return iBreak + i + 1;
+    }
+  }
+  return iBreak;
+}
+
+/*
+** If the StringBuffer does not end in white space, add a single
+** space character to the end.
+*/
+static void appendWhiteSpace(StringBuffer *p){
+  if( p->len==0 ) return;
+  if( safe_isspace(p->s[p->len-1]) ) return;
+  append(p, " ");
+}
+
+/*
+** Remove white space from teh end of the StringBuffer
+*/
+static void trimWhiteSpace(StringBuffer *p){
+  while( p->len>0 && safe_isspace(p->s[p->len-1]) ){
+    p->len--;
+  }
+}
+
+
+
+/*
+** Allowed values for Snippet.aMatch[].snStatus
+*/
+#define SNIPPET_IGNORE  0   /* It is ok to omit this match from the snippet */
+#define SNIPPET_DESIRED 1   /* We want to include this match in the snippet */
+
+/*
+** Generate the text of a snippet.
+*/
+static void snippetText(
+  fulltext_cursor *pCursor,   /* The cursor we need the snippet for */
+  const char *zStartMark,     /* Markup to appear before each match */
+  const char *zEndMark,       /* Markup to appear after each match */
+  const char *zEllipsis       /* Ellipsis mark */
+){
+  int i, j;
+  struct snippetMatch *aMatch;
+  int nMatch;
+  int nDesired;
+  StringBuffer sb;
+  int tailCol;
+  int tailOffset;
+  int iCol;
+  int nDoc;
+  const char *zDoc;
+  int iStart, iEnd;
+  int tailEllipsis = 0;
+  int iMatch;
+  
+
+  free(pCursor->snippet.zSnippet);
+  pCursor->snippet.zSnippet = 0;
+  aMatch = pCursor->snippet.aMatch;
+  nMatch = pCursor->snippet.nMatch;
+  initStringBuffer(&sb);
+
+  for(i=0; i<nMatch; i++){
+    aMatch[i].snStatus = SNIPPET_IGNORE;
+  }
+  nDesired = 0;
+  for(i=0; i<pCursor->q.nTerms; i++){
+    for(j=0; j<nMatch; j++){
+      if( aMatch[j].iTerm==i ){
+        aMatch[j].snStatus = SNIPPET_DESIRED;
+        nDesired++;
+        break;
+      }
+    }
+  }
+
+  iMatch = 0;
+  tailCol = -1;
+  tailOffset = 0;
+  for(i=0; i<nMatch && nDesired>0; i++){
+    if( aMatch[i].snStatus!=SNIPPET_DESIRED ) continue;
+    nDesired--;
+    iCol = aMatch[i].iCol;
+    zDoc = (const char*)sqlite3_column_text(pCursor->pStmt, iCol+1);
+    nDoc = sqlite3_column_bytes(pCursor->pStmt, iCol+1);
+    iStart = aMatch[i].iStart - 40;
+    iStart = wordBoundary(iStart, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iStart<=10 ){
+      iStart = 0;
+    }
+    if( iCol==tailCol && iStart<=tailOffset+20 ){
+      iStart = tailOffset;
+    }
+    if( (iCol!=tailCol && tailCol>=0) || iStart!=tailOffset ){
+      trimWhiteSpace(&sb);
+      appendWhiteSpace(&sb);
+      append(&sb, zEllipsis);
+      appendWhiteSpace(&sb);
+    }
+    iEnd = aMatch[i].iStart + aMatch[i].nByte + 40;
+    iEnd = wordBoundary(iEnd, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iEnd>=nDoc-10 ){
+      iEnd = nDoc;
+      tailEllipsis = 0;
+    }else{
+      tailEllipsis = 1;
+    }
+    while( iMatch<nMatch && aMatch[iMatch].iCol<iCol ){ iMatch++; }
+    while( iStart<iEnd ){
+      while( iMatch<nMatch && aMatch[iMatch].iStart<iStart
+             && aMatch[iMatch].iCol<=iCol ){
+        iMatch++;
+      }
+      if( iMatch<nMatch && aMatch[iMatch].iStart<iEnd
+             && aMatch[iMatch].iCol==iCol ){
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].iStart - iStart);
+        iStart = aMatch[iMatch].iStart;
+        append(&sb, zStartMark);
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].nByte);
+        append(&sb, zEndMark);
+        iStart += aMatch[iMatch].nByte;
+        for(j=iMatch+1; j<nMatch; j++){
+          if( aMatch[j].iTerm==aMatch[iMatch].iTerm
+              && aMatch[j].snStatus==SNIPPET_DESIRED ){
+            nDesired--;
+            aMatch[j].snStatus = SNIPPET_IGNORE;
+          }
+        }
+      }else{
+        nappend(&sb, &zDoc[iStart], iEnd - iStart);
+        iStart = iEnd;
+      }
+    }
+    tailCol = iCol;
+    tailOffset = iEnd;
+  }
+  trimWhiteSpace(&sb);
+  if( tailEllipsis ){
+    appendWhiteSpace(&sb);
+    append(&sb, zEllipsis);
+  }
+  pCursor->snippet.zSnippet = sb.s;
+  pCursor->snippet.nSnippet = sb.len;  
+}
+
+
+/*
+** Close the cursor.  For additional information see the documentation
+** on the xClose method of the virtual table interface.
+*/
+static int fulltextClose(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  TRACE(("FTS1 Close %p\n", c));
+  sqlite3_finalize(c->pStmt);
+  queryClear(&c->q);
+  snippetClear(&c->snippet);
+  if( c->result.pDoclist!=NULL ){
+    docListDelete(c->result.pDoclist);
+  }
+  free(c);
+  return SQLITE_OK;
+}
+
+static int fulltextNext(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  sqlite_int64 iDocid;
+  int rc;
+
+  TRACE(("FTS1 Next %p\n", pCursor));
+  snippetClear(&c->snippet);
+  if( c->iCursorType < QUERY_FULLTEXT ){
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    switch( rc ){
+      case SQLITE_ROW:
+        c->eof = 0;
+        return SQLITE_OK;
+      case SQLITE_DONE:
+        c->eof = 1;
+        return SQLITE_OK;
+      default:
+        c->eof = 1;
+        return rc;
+    }
+  } else {  /* full-text query */
+    rc = sqlite3_reset(c->pStmt);
+    if( rc!=SQLITE_OK ) return rc;
+
+    iDocid = nextDocid(&c->result);
+    if( iDocid==0 ){
+      c->eof = 1;
+      return SQLITE_OK;
+    }
+    rc = sqlite3_bind_int64(c->pStmt, 1, iDocid);
+    if( rc!=SQLITE_OK ) return rc;
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    if( rc==SQLITE_ROW ){   /* the case we expect */
+      c->eof = 0;
+      return SQLITE_OK;
+    }
+    /* an error occurred; abort */
+    return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+  }
+}
+
+
+/* Return a DocList corresponding to the query term *pTerm.  If *pTerm
+** is the first term of a phrase query, go ahead and evaluate the phrase
+** query and return the doclist for the entire phrase query.
+**
+** The result is stored in pTerm->doclist.
+*/
+static int docListOfTerm(
+  fulltext_vtab *v,     /* The full text index */
+  int iColumn,          /* column to restrict to.  No restrition if >=nColumn */
+  QueryTerm *pQTerm,    /* Term we are looking for, or 1st term of a phrase */
+  DocList **ppResult    /* Write the result here */
+){
+  DocList *pLeft, *pRight, *pNew;
+  int i, rc;
+
+  pLeft = docListNew(DL_POSITIONS);
+  rc = term_select_all(v, iColumn, pQTerm->pTerm, pQTerm->nTerm, pLeft);
+  if( rc ){
+    docListDelete(pLeft);
+    return rc;
+  }
+  for(i=1; i<=pQTerm->nPhrase; i++){
+    pRight = docListNew(DL_POSITIONS);
+    rc = term_select_all(v, iColumn, pQTerm[i].pTerm, pQTerm[i].nTerm, pRight);
+    if( rc ){
+      docListDelete(pLeft);
+      return rc;
+    }
+    pNew = docListNew(i<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS);
+    docListPhraseMerge(pLeft, pRight, pNew);
+    docListDelete(pLeft);
+    docListDelete(pRight);
+    pLeft = pNew;
+  }
+  *ppResult = pLeft;
+  return SQLITE_OK;
+}
+
+/* Add a new term pTerm[0..nTerm-1] to the query *q.
+*/
+static void queryAdd(Query *q, const char *pTerm, int nTerm){
+  QueryTerm *t;
+  ++q->nTerms;
+  q->pTerms = realloc(q->pTerms, q->nTerms * sizeof(q->pTerms[0]));
+  if( q->pTerms==0 ){
+    q->nTerms = 0;
+    return;
+  }
+  t = &q->pTerms[q->nTerms - 1];
+  memset(t, 0, sizeof(*t));
+  t->pTerm = malloc(nTerm+1);
+  memcpy(t->pTerm, pTerm, nTerm);
+  t->pTerm[nTerm] = 0;
+  t->nTerm = nTerm;
+  t->isOr = q->nextIsOr;
+  q->nextIsOr = 0;
+  t->iColumn = q->nextColumn;
+  q->nextColumn = q->dfltColumn;
+}
+
+/*
+** Check to see if the string zToken[0...nToken-1] matches any
+** column name in the virtual table.   If it does,
+** return the zero-indexed column number.  If not, return -1.
+*/
+static int checkColumnSpecifier(
+  fulltext_vtab *pVtab,    /* The virtual table */
+  const char *zToken,      /* Text of the token */
+  int nToken               /* Number of characters in the token */
+){
+  int i;
+  for(i=0; i<pVtab->nColumn; i++){
+    if( memcmp(pVtab->azColumn[i], zToken, nToken)==0
+        && pVtab->azColumn[i][nToken]==0 ){
+      return i;
+    }
+  }
+  return -1;
+}
+
+/*
+** Parse the text at pSegment[0..nSegment-1].  Add additional terms
+** to the query being assemblied in pQuery.
+**
+** inPhrase is true if pSegment[0..nSegement-1] is contained within
+** double-quotes.  If inPhrase is true, then the first term
+** is marked with the number of terms in the phrase less one and
+** OR and "-" syntax is ignored.  If inPhrase is false, then every
+** term found is marked with nPhrase=0 and OR and "-" syntax is significant.
+*/
+static int tokenizeSegment(
+  sqlite3_tokenizer *pTokenizer,          /* The tokenizer to use */
+  const char *pSegment, int nSegment,     /* Query expression being parsed */
+  int inPhrase,                           /* True if within "..." */
+  Query *pQuery                           /* Append results here */
+){
+  const sqlite3_tokenizer_module *pModule = pTokenizer->pModule;
+  sqlite3_tokenizer_cursor *pCursor;
+  int firstIndex = pQuery->nTerms;
+  int iCol;
+  int nTerm = 1;
+  
+  int rc = pModule->xOpen(pTokenizer, pSegment, nSegment, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+  pCursor->pTokenizer = pTokenizer;
+
+  while( 1 ){
+    const char *pToken;
+    int nToken, iBegin, iEnd, iPos;
+
+    rc = pModule->xNext(pCursor,
+                        &pToken, &nToken,
+                        &iBegin, &iEnd, &iPos);
+    if( rc!=SQLITE_OK ) break;
+    if( !inPhrase &&
+        pSegment[iEnd]==':' &&
+         (iCol = checkColumnSpecifier(pQuery->pFts, pToken, nToken))>=0 ){
+      pQuery->nextColumn = iCol;
+      continue;
+    }
+    if( !inPhrase && pQuery->nTerms>0 && nToken==2
+         && pSegment[iBegin]=='O' && pSegment[iBegin+1]=='R' ){
+      pQuery->nextIsOr = 1;
+      continue;
+    }
+    queryAdd(pQuery, pToken, nToken);
+    if( !inPhrase && iBegin>0 && pSegment[iBegin-1]=='-' ){
+      pQuery->pTerms[pQuery->nTerms-1].isNot = 1;
+    }
+    pQuery->pTerms[pQuery->nTerms-1].iPhrase = nTerm;
+    if( inPhrase ){
+      nTerm++;
+    }
+  }
+
+  if( inPhrase && pQuery->nTerms>firstIndex ){
+    pQuery->pTerms[firstIndex].nPhrase = pQuery->nTerms - firstIndex - 1;
+  }
+
+  return pModule->xClose(pCursor);
+}
+
+/* Parse a query string, yielding a Query object pQuery.
+**
+** The calling function will need to queryClear() to clean up
+** the dynamically allocated memory held by pQuery.
+*/
+static int parseQuery(
+  fulltext_vtab *v,        /* The fulltext index */
+  const char *zInput,      /* Input text of the query string */
+  int nInput,              /* Size of the input text */
+  int dfltColumn,          /* Default column of the index to match against */
+  Query *pQuery            /* Write the parse results here. */
+){
+  int iInput, inPhrase = 0;
+
+  if( zInput==0 ) nInput = 0;
+  if( nInput<0 ) nInput = strlen(zInput);
+  pQuery->nTerms = 0;
+  pQuery->pTerms = NULL;
+  pQuery->nextIsOr = 0;
+  pQuery->nextColumn = dfltColumn;
+  pQuery->dfltColumn = dfltColumn;
+  pQuery->pFts = v;
+
+  for(iInput=0; iInput<nInput; ++iInput){
+    int i;
+    for(i=iInput; i<nInput && zInput[i]!='"'; ++i){}
+    if( i>iInput ){
+      tokenizeSegment(v->pTokenizer, zInput+iInput, i-iInput, inPhrase,
+                       pQuery);
+    }
+    iInput = i;
+    if( i<nInput ){
+      assert( zInput[i]=='"' );
+      inPhrase = !inPhrase;
+    }
+  }
+
+  if( inPhrase ){
+    /* unmatched quote */
+    queryClear(pQuery);
+    return SQLITE_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/* Perform a full-text query using the search expression in
+** zInput[0..nInput-1].  Return a list of matching documents
+** in pResult.
+**
+** Queries must match column iColumn.  Or if iColumn>=nColumn
+** they are allowed to match against any column.
+*/
+static int fulltextQuery(
+  fulltext_vtab *v,      /* The full text index */
+  int iColumn,           /* Match against this column by default */
+  const char *zInput,    /* The query string */
+  int nInput,            /* Number of bytes in zInput[] */
+  DocList **pResult,     /* Write the result doclist here */
+  Query *pQuery          /* Put parsed query string here */
+){
+  int i, iNext, rc;
+  DocList *pLeft = NULL;
+  DocList *pRight, *pNew, *pOr;
+  int nNot = 0;
+  QueryTerm *aTerm;
+
+  rc = parseQuery(v, zInput, nInput, iColumn, pQuery);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Merge AND terms. */
+  aTerm = pQuery->pTerms;
+  for(i = 0; i<pQuery->nTerms; i=iNext){
+    if( aTerm[i].isNot ){
+      /* Handle all NOT terms in a separate pass */
+      nNot++;
+      iNext = i + aTerm[i].nPhrase+1;
+      continue;
+    }
+    iNext = i + aTerm[i].nPhrase + 1;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &pRight);
+    if( rc ){
+      queryClear(pQuery);
+      return rc;
+    }
+    while( iNext<pQuery->nTerms && aTerm[iNext].isOr ){
+      rc = docListOfTerm(v, aTerm[iNext].iColumn, &aTerm[iNext], &pOr);
+      iNext += aTerm[iNext].nPhrase + 1;
+      if( rc ){
+        queryClear(pQuery);
+        return rc;
+      }
+      pNew = docListNew(DL_DOCIDS);
+      docListOrMerge(pRight, pOr, pNew);
+      docListDelete(pRight);
+      docListDelete(pOr);
+      pRight = pNew;
+    }
+    if( pLeft==0 ){
+      pLeft = pRight;
+    }else{
+      pNew = docListNew(DL_DOCIDS);
+      docListAndMerge(pLeft, pRight, pNew);
+      docListDelete(pRight);
+      docListDelete(pLeft);
+      pLeft = pNew;
+    }
+  }
+
+  if( nNot && pLeft==0 ){
+    /* We do not yet know how to handle a query of only NOT terms */
+    return SQLITE_ERROR;
+  }
+
+  /* Do the EXCEPT terms */
+  for(i=0; i<pQuery->nTerms;  i += aTerm[i].nPhrase + 1){
+    if( !aTerm[i].isNot ) continue;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &pRight);
+    if( rc ){
+      queryClear(pQuery);
+      docListDelete(pLeft);
+      return rc;
+    }
+    pNew = docListNew(DL_DOCIDS);
+    docListExceptMerge(pLeft, pRight, pNew);
+    docListDelete(pRight);
+    docListDelete(pLeft);
+    pLeft = pNew;
+  }
+
+  *pResult = pLeft;
+  return rc;
+}
+
+/*
+** This is the xFilter interface for the virtual table.  See
+** the virtual table xFilter method documentation for additional
+** information.
+**
+** If idxNum==QUERY_GENERIC then do a full table scan against
+** the %_content table.
+**
+** If idxNum==QUERY_ROWID then do a rowid lookup for a single entry
+** in the %_content table.
+**
+** If idxNum>=QUERY_FULLTEXT then use the full text index.  The
+** column on the left-hand side of the MATCH operator is column
+** number idxNum-QUERY_FULLTEXT, 0 indexed.  argv[0] is the right-hand
+** side of the MATCH operator.
+*/
+/* TODO(shess) Upgrade the cursor initialization and destruction to
+** account for fulltextFilter() being called multiple times on the
+** same cursor.  The current solution is very fragile.  Apply fix to
+** fts2 as appropriate.
+*/
+static int fulltextFilter(
+  sqlite3_vtab_cursor *pCursor,     /* The cursor used for this query */
+  int idxNum, const char *idxStr,   /* Which indexing scheme to use */
+  int argc, sqlite3_value **argv    /* Arguments for the indexing scheme */
+){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+  int rc;
+  char *zSql;
+
+  TRACE(("FTS1 Filter %p\n",pCursor));
+
+  zSql = sqlite3_mprintf("select rowid, * from %%_content %s",
+                          idxNum==QUERY_GENERIC ? "" : "where rowid=?");
+  sqlite3_finalize(c->pStmt);
+  rc = sql_prepare(v->db, v->zDb, v->zName, &c->pStmt, zSql);
+  sqlite3_free(zSql);
+  if( rc!=SQLITE_OK ) return rc;
+
+  c->iCursorType = idxNum;
+  switch( idxNum ){
+    case QUERY_GENERIC:
+      break;
+
+    case QUERY_ROWID:
+      rc = sqlite3_bind_int64(c->pStmt, 1, sqlite3_value_int64(argv[0]));
+      if( rc!=SQLITE_OK ) return rc;
+      break;
+
+    default:   /* full-text search */
+    {
+      const char *zQuery = (const char *)sqlite3_value_text(argv[0]);
+      DocList *pResult;
+      assert( idxNum<=QUERY_FULLTEXT+v->nColumn);
+      assert( argc==1 );
+      queryClear(&c->q);
+      rc = fulltextQuery(v, idxNum-QUERY_FULLTEXT, zQuery, -1, &pResult, &c->q);
+      if( rc!=SQLITE_OK ) return rc;
+      if( c->result.pDoclist!=NULL ) docListDelete(c->result.pDoclist);
+      readerInit(&c->result, pResult);
+      break;
+    }
+  }
+
+  return fulltextNext(pCursor);
+}
+
+/* This is the xEof method of the virtual table.  The SQLite core
+** calls this routine to find out if it has reached the end of
+** a query's results set.
+*/
+static int fulltextEof(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  return c->eof;
+}
+
+/* This is the xColumn method of the virtual table.  The SQLite
+** core calls this method during a query when it needs the value
+** of a column from the virtual table.  This method needs to use
+** one of the sqlite3_result_*() routines to store the requested
+** value back in the pContext.
+*/
+static int fulltextColumn(sqlite3_vtab_cursor *pCursor,
+                          sqlite3_context *pContext, int idxCol){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+
+  if( idxCol<v->nColumn ){
+    sqlite3_value *pVal = sqlite3_column_value(c->pStmt, idxCol+1);
+    sqlite3_result_value(pContext, pVal);
+  }else if( idxCol==v->nColumn ){
+    /* The extra column whose name is the same as the table.
+    ** Return a blob which is a pointer to the cursor
+    */
+    sqlite3_result_blob(pContext, &c, sizeof(c), SQLITE_TRANSIENT);
+  }
+  return SQLITE_OK;
+}
+
+/* This is the xRowid method.  The SQLite core calls this routine to
+** retrive the rowid for the current row of the result set.  The
+** rowid should be written to *pRowid.
+*/
+static int fulltextRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+
+  *pRowid = sqlite3_column_int64(c->pStmt, 0);
+  return SQLITE_OK;
+}
+
+/* Add all terms in [zText] to the given hash table.  If [iColumn] > 0,
+ * we also store positions and offsets in the hash table using the given
+ * column number. */
+static int buildTerms(fulltext_vtab *v, fts1Hash *terms, sqlite_int64 iDocid,
+                      const char *zText, int iColumn){
+  sqlite3_tokenizer *pTokenizer = v->pTokenizer;
+  sqlite3_tokenizer_cursor *pCursor;
+  const char *pToken;
+  int nTokenBytes;
+  int iStartOffset, iEndOffset, iPosition;
+  int rc;
+
+  rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+
+  pCursor->pTokenizer = pTokenizer;
+  while( SQLITE_OK==pTokenizer->pModule->xNext(pCursor,
+                                               &pToken, &nTokenBytes,
+                                               &iStartOffset, &iEndOffset,
+                                               &iPosition) ){
+    DocList *p;
+
+    /* Positions can't be negative; we use -1 as a terminator internally. */
+    if( iPosition<0 ){
+      pTokenizer->pModule->xClose(pCursor);
+      return SQLITE_ERROR;
+    }
+
+    p = fts1HashFind(terms, pToken, nTokenBytes);
+    if( p==NULL ){
+      p = docListNew(DL_DEFAULT);
+      docListAddDocid(p, iDocid);
+      fts1HashInsert(terms, pToken, nTokenBytes, p);
+    }
+    if( iColumn>=0 ){
+      docListAddPosOffset(p, iColumn, iPosition, iStartOffset, iEndOffset);
+    }
+  }
+
+  /* TODO(shess) Check return?  Should this be able to cause errors at
+  ** this point?  Actually, same question about sqlite3_finalize(),
+  ** though one could argue that failure there means that the data is
+  ** not durable.  *ponder*
+  */
+  pTokenizer->pModule->xClose(pCursor);
+  return rc;
+}
+
+/* Update the %_terms table to map the term [pTerm] to the given rowid. */
+static int index_insert_term(fulltext_vtab *v, const char *pTerm, int nTerm,
+                             DocList *d){
+  sqlite_int64 iIndexRow;
+  DocList doclist;
+  int iSegment = 0, rc;
+
+  rc = term_select(v, pTerm, nTerm, iSegment, &iIndexRow, &doclist);
+  if( rc==SQLITE_DONE ){
+    docListInit(&doclist, DL_DEFAULT, 0, 0);
+    docListUpdate(&doclist, d);
+    /* TODO(shess) Consider length(doclist)>CHUNK_MAX? */
+    rc = term_insert(v, NULL, pTerm, nTerm, iSegment, &doclist);
+    goto err;
+  }
+  if( rc!=SQLITE_ROW ) return SQLITE_ERROR;
+
+  docListUpdate(&doclist, d);
+  if( doclist.nData<=CHUNK_MAX ){
+    rc = term_update(v, iIndexRow, &doclist);
+    goto err;
+  }
+
+  /* Doclist doesn't fit, delete what's there, and accumulate
+  ** forward.
+  */
+  rc = term_delete(v, iIndexRow);
+  if( rc!=SQLITE_OK ) goto err;
+
+  /* Try to insert the doclist into a higher segment bucket.  On
+  ** failure, accumulate existing doclist with the doclist from that
+  ** bucket, and put results in the next bucket.
+  */
+  iSegment++;
+  while( (rc=term_insert(v, &iIndexRow, pTerm, nTerm, iSegment,
+                         &doclist))!=SQLITE_OK ){
+    sqlite_int64 iSegmentRow;
+    DocList old;
+    int rc2;
+
+    /* Retain old error in case the term_insert() error was really an
+    ** error rather than a bounced insert.
+    */
+    rc2 = term_select(v, pTerm, nTerm, iSegment, &iSegmentRow, &old);
+    if( rc2!=SQLITE_ROW ) goto err;
+
+    rc = term_delete(v, iSegmentRow);
+    if( rc!=SQLITE_OK ) goto err;
+
+    /* Reusing lowest-number deleted row keeps the index smaller. */
+    if( iSegmentRow<iIndexRow ) iIndexRow = iSegmentRow;
+
+    /* doclist contains the newer data, so accumulate it over old.
+    ** Then steal accumulated data for doclist.
+    */
+    docListAccumulate(&old, &doclist);
+    docListDestroy(&doclist);
+    doclist = old;
+
+    iSegment++;
+  }
+
+ err:
+  docListDestroy(&doclist);
+  return rc;
+}
+
+/* Add doclists for all terms in [pValues] to the hash table [terms]. */
+static int insertTerms(fulltext_vtab *v, fts1Hash *terms, sqlite_int64 iRowid,
+                sqlite3_value **pValues){
+  int i;
+  for(i = 0; i < v->nColumn ; ++i){
+    char *zText = (char*)sqlite3_value_text(pValues[i]);
+    int rc = buildTerms(v, terms, iRowid, zText, i);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Add empty doclists for all terms in the given row's content to the hash
+ * table [pTerms]. */
+static int deleteTerms(fulltext_vtab *v, fts1Hash *pTerms, sqlite_int64 iRowid){
+  const char **pValues;
+  int i;
+
+  int rc = content_select(v, iRowid, &pValues);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i = 0 ; i < v->nColumn; ++i) {
+    rc = buildTerms(v, pTerms, iRowid, pValues[i], -1);
+    if( rc!=SQLITE_OK ) break;
+  }
+
+  freeStringArray(v->nColumn, pValues);
+  return SQLITE_OK;
+}
+
+/* Insert a row into the %_content table; set *piRowid to be the ID of the
+ * new row.  Fill [pTerms] with new doclists for the %_term table. */
+static int index_insert(fulltext_vtab *v, sqlite3_value *pRequestRowid,
+                        sqlite3_value **pValues,
+                        sqlite_int64 *piRowid, fts1Hash *pTerms){
+  int rc;
+
+  rc = content_insert(v, pRequestRowid, pValues);  /* execute an SQL INSERT */
+  if( rc!=SQLITE_OK ) return rc;
+  *piRowid = sqlite3_last_insert_rowid(v->db);
+  return insertTerms(v, pTerms, *piRowid, pValues);
+}
+
+/* Delete a row from the %_content table; fill [pTerms] with empty doclists
+ * to be written to the %_term table. */
+static int index_delete(fulltext_vtab *v, sqlite_int64 iRow, fts1Hash *pTerms){
+  int rc = deleteTerms(v, pTerms, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+  return content_delete(v, iRow);  /* execute an SQL DELETE */
+}
+
+/* Update a row in the %_content table; fill [pTerms] with new doclists for the
+ * %_term table. */
+static int index_update(fulltext_vtab *v, sqlite_int64 iRow,
+                        sqlite3_value **pValues, fts1Hash *pTerms){
+  /* Generate an empty doclist for each term that previously appeared in this
+   * row. */
+  int rc = deleteTerms(v, pTerms, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = content_update(v, pValues, iRow);  /* execute an SQL UPDATE */
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Now add positions for terms which appear in the updated row. */
+  return insertTerms(v, pTerms, iRow, pValues);
+}
+
+/* This function implements the xUpdate callback; it is the top-level entry
+ * point for inserting, deleting or updating a row in a full-text table. */
+static int fulltextUpdate(sqlite3_vtab *pVtab, int nArg, sqlite3_value **ppArg,
+                   sqlite_int64 *pRowid){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  fts1Hash terms;   /* maps term string -> PosList */
+  int rc;
+  fts1HashElem *e;
+
+  TRACE(("FTS1 Update %p\n", pVtab));
+  
+  fts1HashInit(&terms, FTS1_HASH_STRING, 1);
+
+  if( nArg<2 ){
+    rc = index_delete(v, sqlite3_value_int64(ppArg[0]), &terms);
+  } else if( sqlite3_value_type(ppArg[0]) != SQLITE_NULL ){
+    /* An update:
+     * ppArg[0] = old rowid
+     * ppArg[1] = new rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     */
+    sqlite_int64 rowid = sqlite3_value_int64(ppArg[0]);
+    if( sqlite3_value_type(ppArg[1]) != SQLITE_INTEGER ||
+      sqlite3_value_int64(ppArg[1]) != rowid ){
+      rc = SQLITE_ERROR;  /* we don't allow changing the rowid */
+    } else {
+      assert( nArg==2+v->nColumn+1);
+      rc = index_update(v, rowid, &ppArg[2], &terms);
+    }
+  } else {
+    /* An insert:
+     * ppArg[1] = requested rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     */
+    assert( nArg==2+v->nColumn+1);
+    rc = index_insert(v, ppArg[1], &ppArg[2], pRowid, &terms);
+  }
+
+  if( rc==SQLITE_OK ){
+    /* Write updated doclists to disk. */
+    for(e=fts1HashFirst(&terms); e; e=fts1HashNext(e)){
+      DocList *p = fts1HashData(e);
+      rc = index_insert_term(v, fts1HashKey(e), fts1HashKeysize(e), p);
+      if( rc!=SQLITE_OK ) break;
+    }
+  }
+
+  /* clean up */
+  for(e=fts1HashFirst(&terms); e; e=fts1HashNext(e)){
+    DocList *p = fts1HashData(e);
+    docListDelete(p);
+  }
+  fts1HashClear(&terms);
+
+  return rc;
+}
+
+/*
+** Implementation of the snippet() function for FTS1
+*/
+static void snippetFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to html_snippet",-1);
+  }else{
+    const char *zStart = "<b>";
+    const char *zEnd = "</b>";
+    const char *zEllipsis = "<b>...</b>";
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    if( argc>=2 ){
+      zStart = (const char*)sqlite3_value_text(argv[1]);
+      if( argc>=3 ){
+        zEnd = (const char*)sqlite3_value_text(argv[2]);
+        if( argc>=4 ){
+          zEllipsis = (const char*)sqlite3_value_text(argv[3]);
+        }
+      }
+    }
+    snippetAllOffsets(pCursor);
+    snippetText(pCursor, zStart, zEnd, zEllipsis);
+    sqlite3_result_text(pContext, pCursor->snippet.zSnippet,
+                        pCursor->snippet.nSnippet, SQLITE_STATIC);
+  }
+}
+
+/*
+** Implementation of the offsets() function for FTS1
+*/
+static void snippetOffsetsFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to offsets",-1);
+  }else{
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    snippetAllOffsets(pCursor);
+    snippetOffsetText(&pCursor->snippet);
+    sqlite3_result_text(pContext,
+                        pCursor->snippet.zOffset, pCursor->snippet.nOffset,
+                        SQLITE_STATIC);
+  }
+}
+
+/*
+** This routine implements the xFindFunction method for the FTS1
+** virtual table.
+*/
+static int fulltextFindFunction(
+  sqlite3_vtab *pVtab,
+  int nArg,
+  const char *zName,
+  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+  void **ppArg
+){
+  if( strcmp(zName,"snippet")==0 ){
+    *pxFunc = snippetFunc;
+    return 1;
+  }else if( strcmp(zName,"offsets")==0 ){
+    *pxFunc = snippetOffsetsFunc;
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Rename an fts1 table.
+*/
+static int fulltextRename(
+  sqlite3_vtab *pVtab,
+  const char *zName
+){
+  fulltext_vtab *p = (fulltext_vtab *)pVtab;
+  int rc = SQLITE_NOMEM;
+  char *zSql = sqlite3_mprintf(
+    "ALTER TABLE %Q.'%q_content'  RENAME TO '%q_content';"
+    "ALTER TABLE %Q.'%q_term' RENAME TO '%q_term';"
+    , p->zDb, p->zName, zName
+    , p->zDb, p->zName, zName
+  );
+  if( zSql ){
+    rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+  }
+  return rc;
+}
+
+static const sqlite3_module fulltextModule = {
+  /* iVersion      */ 0,
+  /* xCreate       */ fulltextCreate,
+  /* xConnect      */ fulltextConnect,
+  /* xBestIndex    */ fulltextBestIndex,
+  /* xDisconnect   */ fulltextDisconnect,
+  /* xDestroy      */ fulltextDestroy,
+  /* xOpen         */ fulltextOpen,
+  /* xClose        */ fulltextClose,
+  /* xFilter       */ fulltextFilter,
+  /* xNext         */ fulltextNext,
+  /* xEof          */ fulltextEof,
+  /* xColumn       */ fulltextColumn,
+  /* xRowid        */ fulltextRowid,
+  /* xUpdate       */ fulltextUpdate,
+  /* xBegin        */ 0, 
+  /* xSync         */ 0,
+  /* xCommit       */ 0,
+  /* xRollback     */ 0,
+  /* xFindFunction */ fulltextFindFunction,
+  /* xRename       */ fulltextRename,
+};
+
+int sqlite3Fts1Init(sqlite3 *db){
+  sqlite3_overload_function(db, "snippet", -1);
+  sqlite3_overload_function(db, "offsets", -1);
+  return sqlite3_create_module(db, "fts1", &fulltextModule, 0);
+}
+
+#if !SQLITE_CORE
+int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg,
+                           const sqlite3_api_routines *pApi){
+  SQLITE_EXTENSION_INIT2(pApi)
+  return sqlite3Fts1Init(db);
+}
+#endif
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.h
new file mode 100644
index 0000000..d55e689
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1.h
@@ -0,0 +1,11 @@
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+int sqlite3Fts1Init(sqlite3 *db);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.c
new file mode 100644
index 0000000..463a52b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.c
@@ -0,0 +1,369 @@
+/*
+** 2001 September 22
+**
+** 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 is the implementation of generic hash-tables used in SQLite.
+** We've modified it slightly to serve as a standalone hash table
+** implementation for the full-text indexing module.
+*/
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS1 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS1 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS1 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)
+
+
+#include "fts1_hash.h"
+
+static void *malloc_and_zero(int n){
+  void *p = malloc(n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+
+/* Turn bulk memory into a hash table object by initializing the
+** fields of the Hash structure.
+**
+** "pNew" is a pointer to the hash table that is to be initialized.
+** keyClass is one of the constants 
+** FTS1_HASH_BINARY or FTS1_HASH_STRING.  The value of keyClass 
+** determines what kind of key the hash table will use.  "copyKey" is
+** true if the hash table should make its own private copy of keys and
+** false if it should just use the supplied pointer.
+*/
+void sqlite3Fts1HashInit(fts1Hash *pNew, int keyClass, int copyKey){
+  assert( pNew!=0 );
+  assert( keyClass>=FTS1_HASH_STRING && keyClass<=FTS1_HASH_BINARY );
+  pNew->keyClass = keyClass;
+  pNew->copyKey = copyKey;
+  pNew->first = 0;
+  pNew->count = 0;
+  pNew->htsize = 0;
+  pNew->ht = 0;
+  pNew->xMalloc = malloc_and_zero;
+  pNew->xFree = free;
+}
+
+/* Remove all entries from a hash table.  Reclaim all memory.
+** Call this routine to delete a hash table or to reset a hash table
+** to the empty state.
+*/
+void sqlite3Fts1HashClear(fts1Hash *pH){
+  fts1HashElem *elem;         /* For looping over all elements of the table */
+
+  assert( pH!=0 );
+  elem = pH->first;
+  pH->first = 0;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = 0;
+  pH->htsize = 0;
+  while( elem ){
+    fts1HashElem *next_elem = elem->next;
+    if( pH->copyKey && elem->pKey ){
+      pH->xFree(elem->pKey);
+    }
+    pH->xFree(elem);
+    elem = next_elem;
+  }
+  pH->count = 0;
+}
+
+/*
+** Hash and comparison functions when the mode is FTS1_HASH_STRING
+*/
+static int strHash(const void *pKey, int nKey){
+  const char *z = (const char *)pKey;
+  int h = 0;
+  if( nKey<=0 ) nKey = (int) strlen(z);
+  while( nKey > 0  ){
+    h = (h<<3) ^ h ^ *z++;
+    nKey--;
+  }
+  return h & 0x7fffffff;
+}
+static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return strncmp((const char*)pKey1,(const char*)pKey2,n1);
+}
+
+/*
+** Hash and comparison functions when the mode is FTS1_HASH_BINARY
+*/
+static int binHash(const void *pKey, int nKey){
+  int h = 0;
+  const char *z = (const char *)pKey;
+  while( nKey-- > 0 ){
+    h = (h<<3) ^ h ^ *(z++);
+  }
+  return h & 0x7fffffff;
+}
+static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return memcmp(pKey1,pKey2,n1);
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** The C syntax in this function definition may be unfamilar to some 
+** programmers, so we provide the following additional explanation:
+**
+** The name of the function is "hashFunction".  The function takes a
+** single parameter "keyClass".  The return value of hashFunction()
+** is a pointer to another function.  Specifically, the return value
+** of hashFunction() is a pointer to a function that takes two parameters
+** with types "const void*" and "int" and returns an "int".
+*/
+static int (*hashFunction(int keyClass))(const void*,int){
+  if( keyClass==FTS1_HASH_STRING ){
+    return &strHash;
+  }else{
+    assert( keyClass==FTS1_HASH_BINARY );
+    return &binHash;
+  }
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** For help in interpreted the obscure C code in the function definition,
+** see the header comment on the previous function.
+*/
+static int (*compareFunction(int keyClass))(const void*,int,const void*,int){
+  if( keyClass==FTS1_HASH_STRING ){
+    return &strCompare;
+  }else{
+    assert( keyClass==FTS1_HASH_BINARY );
+    return &binCompare;
+  }
+}
+
+/* Link an element into the hash table
+*/
+static void insertElement(
+  fts1Hash *pH,            /* The complete hash table */
+  struct _fts1ht *pEntry,  /* The entry into which pNew is inserted */
+  fts1HashElem *pNew       /* The element to be inserted */
+){
+  fts1HashElem *pHead;     /* First element already in pEntry */
+  pHead = pEntry->chain;
+  if( pHead ){
+    pNew->next = pHead;
+    pNew->prev = pHead->prev;
+    if( pHead->prev ){ pHead->prev->next = pNew; }
+    else             { pH->first = pNew; }
+    pHead->prev = pNew;
+  }else{
+    pNew->next = pH->first;
+    if( pH->first ){ pH->first->prev = pNew; }
+    pNew->prev = 0;
+    pH->first = pNew;
+  }
+  pEntry->count++;
+  pEntry->chain = pNew;
+}
+
+
+/* Resize the hash table so that it cantains "new_size" buckets.
+** "new_size" must be a power of 2.  The hash table might fail 
+** to resize if sqliteMalloc() fails.
+*/
+static void rehash(fts1Hash *pH, int new_size){
+  struct _fts1ht *new_ht;          /* The new hash table */
+  fts1HashElem *elem, *next_elem;  /* For looping over existing elements */
+  int (*xHash)(const void*,int);   /* The hash function */
+
+  assert( (new_size & (new_size-1))==0 );
+  new_ht = (struct _fts1ht *)pH->xMalloc( new_size*sizeof(struct _fts1ht) );
+  if( new_ht==0 ) return;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = new_ht;
+  pH->htsize = new_size;
+  xHash = hashFunction(pH->keyClass);
+  for(elem=pH->first, pH->first=0; elem; elem = next_elem){
+    int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
+    next_elem = elem->next;
+    insertElement(pH, &new_ht[h], elem);
+  }
+}
+
+/* This function (for internal use only) locates an element in an
+** hash table that matches the given key.  The hash for this key has
+** already been computed and is passed as the 4th parameter.
+*/
+static fts1HashElem *findElementGivenHash(
+  const fts1Hash *pH, /* The pH to be searched */
+  const void *pKey,   /* The key we are searching for */
+  int nKey,
+  int h               /* The hash for this key. */
+){
+  fts1HashElem *elem;            /* Used to loop thru the element list */
+  int count;                     /* Number of elements left to test */
+  int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
+
+  if( pH->ht ){
+    struct _fts1ht *pEntry = &pH->ht[h];
+    elem = pEntry->chain;
+    count = pEntry->count;
+    xCompare = compareFunction(pH->keyClass);
+    while( count-- && elem ){
+      if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
+        return elem;
+      }
+      elem = elem->next;
+    }
+  }
+  return 0;
+}
+
+/* Remove a single entry from the hash table given a pointer to that
+** element and a hash on the element's key.
+*/
+static void removeElementGivenHash(
+  fts1Hash *pH,         /* The pH containing "elem" */
+  fts1HashElem* elem,   /* The element to be removed from the pH */
+  int h                 /* Hash value for the element */
+){
+  struct _fts1ht *pEntry;
+  if( elem->prev ){
+    elem->prev->next = elem->next; 
+  }else{
+    pH->first = elem->next;
+  }
+  if( elem->next ){
+    elem->next->prev = elem->prev;
+  }
+  pEntry = &pH->ht[h];
+  if( pEntry->chain==elem ){
+    pEntry->chain = elem->next;
+  }
+  pEntry->count--;
+  if( pEntry->count<=0 ){
+    pEntry->chain = 0;
+  }
+  if( pH->copyKey && elem->pKey ){
+    pH->xFree(elem->pKey);
+  }
+  pH->xFree( elem );
+  pH->count--;
+  if( pH->count<=0 ){
+    assert( pH->first==0 );
+    assert( pH->count==0 );
+    fts1HashClear(pH);
+  }
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *sqlite3Fts1HashFind(const fts1Hash *pH, const void *pKey, int nKey){
+  int h;                 /* A hash on key */
+  fts1HashElem *elem;    /* The element that matches key */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  if( pH==0 || pH->ht==0 ) return 0;
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  h = (*xHash)(pKey,nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem ? elem->data : 0;
+}
+
+/* Insert an element into the hash table pH.  The key is pKey,nKey
+** and the data is "data".
+**
+** If no element exists with a matching key, then a new
+** element is created.  A copy of the key is made if the copyKey
+** flag is set.  NULL is returned.
+**
+** If another element already exists with the same key, then the
+** new data replaces the old data and the old data is returned.
+** The key is not copied in this instance.  If a malloc fails, then
+** the new data is returned and the hash table is unchanged.
+**
+** If the "data" parameter to this function is NULL, then the
+** element corresponding to "key" is removed from the hash table.
+*/
+void *sqlite3Fts1HashInsert(
+  fts1Hash *pH,        /* The hash table to insert into */
+  const void *pKey,    /* The key */
+  int nKey,            /* Number of bytes in the key */
+  void *data           /* The data */
+){
+  int hraw;                 /* Raw hash value of the key */
+  int h;                    /* the hash of the key modulo hash table size */
+  fts1HashElem *elem;       /* Used to loop thru the element list */
+  fts1HashElem *new_elem;   /* New element added to the pH */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  assert( pH!=0 );
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  hraw = (*xHash)(pKey, nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  elem = findElementGivenHash(pH,pKey,nKey,h);
+  if( elem ){
+    void *old_data = elem->data;
+    if( data==0 ){
+      removeElementGivenHash(pH,elem,h);
+    }else{
+      elem->data = data;
+    }
+    return old_data;
+  }
+  if( data==0 ) return 0;
+  new_elem = (fts1HashElem*)pH->xMalloc( sizeof(fts1HashElem) );
+  if( new_elem==0 ) return data;
+  if( pH->copyKey && pKey!=0 ){
+    new_elem->pKey = pH->xMalloc( nKey );
+    if( new_elem->pKey==0 ){
+      pH->xFree(new_elem);
+      return data;
+    }
+    memcpy((void*)new_elem->pKey, pKey, nKey);
+  }else{
+    new_elem->pKey = (void*)pKey;
+  }
+  new_elem->nKey = nKey;
+  pH->count++;
+  if( pH->htsize==0 ){
+    rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      pH->xFree(new_elem);
+      return data;
+    }
+  }
+  if( pH->count > pH->htsize ){
+    rehash(pH,pH->htsize*2);
+  }
+  assert( pH->htsize>0 );
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  insertElement(pH, &pH->ht[h], new_elem);
+  new_elem->data = data;
+  return 0;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.h
new file mode 100644
index 0000000..c31c430
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_hash.h
@@ -0,0 +1,112 @@
+/*
+** 2001 September 22
+**
+** 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 is the header file for the generic hash-table implemenation
+** used in SQLite.  We've modified it slightly to serve as a standalone
+** hash table implementation for the full-text indexing module.
+**
+*/
+#ifndef _FTS1_HASH_H_
+#define _FTS1_HASH_H_
+
+/* Forward declarations of structures. */
+typedef struct fts1Hash fts1Hash;
+typedef struct fts1HashElem fts1HashElem;
+
+/* A complete hash table is an instance of the following structure.
+** The internals of this structure are intended to be opaque -- client
+** code should not attempt to access or modify the fields of this structure
+** directly.  Change this structure only by using the routines below.
+** However, many of the "procedures" and "functions" for modifying and
+** accessing this structure are really macros, so we can't really make
+** this structure opaque.
+*/
+struct fts1Hash {
+  char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
+  char copyKey;           /* True if copy of key made on insert */
+  int count;              /* Number of entries in this table */
+  fts1HashElem *first;    /* The first element of the array */
+  void *(*xMalloc)(int);  /* malloc() function to use */
+  void (*xFree)(void *);  /* free() function to use */
+  int htsize;             /* Number of buckets in the hash table */
+  struct _fts1ht {        /* the hash table */
+    int count;               /* Number of entries with this hash */
+    fts1HashElem *chain;     /* Pointer to first entry with this hash */
+  } *ht;
+};
+
+/* Each element in the hash table is an instance of the following 
+** structure.  All elements are stored on a single doubly-linked list.
+**
+** Again, this structure is intended to be opaque, but it can't really
+** be opaque because it is used by macros.
+*/
+struct fts1HashElem {
+  fts1HashElem *next, *prev; /* Next and previous elements in the table */
+  void *data;                /* Data associated with this element */
+  void *pKey; int nKey;      /* Key associated with this element */
+};
+
+/*
+** There are 2 different modes of operation for a hash table:
+**
+**   FTS1_HASH_STRING        pKey points to a string that is nKey bytes long
+**                           (including the null-terminator, if any).  Case
+**                           is respected in comparisons.
+**
+**   FTS1_HASH_BINARY        pKey points to binary data nKey bytes long. 
+**                           memcmp() is used to compare keys.
+**
+** A copy of the key is made if the copyKey parameter to fts1HashInit is 1.  
+*/
+#define FTS1_HASH_STRING    1
+#define FTS1_HASH_BINARY    2
+
+/*
+** Access routines.  To delete, insert a NULL pointer.
+*/
+void sqlite3Fts1HashInit(fts1Hash*, int keytype, int copyKey);
+void *sqlite3Fts1HashInsert(fts1Hash*, const void *pKey, int nKey, void *pData);
+void *sqlite3Fts1HashFind(const fts1Hash*, const void *pKey, int nKey);
+void sqlite3Fts1HashClear(fts1Hash*);
+
+/*
+** Shorthand for the functions above
+*/
+#define fts1HashInit   sqlite3Fts1HashInit
+#define fts1HashInsert sqlite3Fts1HashInsert
+#define fts1HashFind   sqlite3Fts1HashFind
+#define fts1HashClear  sqlite3Fts1HashClear
+
+/*
+** Macros for looping over all elements of a hash table.  The idiom is
+** like this:
+**
+**   fts1Hash h;
+**   fts1HashElem *p;
+**   ...
+**   for(p=fts1HashFirst(&h); p; p=fts1HashNext(p)){
+**     SomeStructure *pData = fts1HashData(p);
+**     // do something with pData
+**   }
+*/
+#define fts1HashFirst(H)  ((H)->first)
+#define fts1HashNext(E)   ((E)->next)
+#define fts1HashData(E)   ((E)->data)
+#define fts1HashKey(E)    ((E)->pKey)
+#define fts1HashKeysize(E) ((E)->nKey)
+
+/*
+** Number of entries in a hash table
+*/
+#define fts1HashCount(H)  ((H)->count)
+
+#endif /* _FTS1_HASH_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_porter.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_porter.c
new file mode 100644
index 0000000..1d26236
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_porter.c
@@ -0,0 +1,643 @@
+/*
+** 2006 September 30
+**
+** 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.
+**
+*************************************************************************
+** Implementation of the full-text-search tokenizer that implements
+** a Porter stemmer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS1 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS1 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS1 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts1_tokenizer.h"
+
+/*
+** Class derived from sqlite3_tokenizer
+*/
+typedef struct porter_tokenizer {
+  sqlite3_tokenizer base;      /* Base class */
+} porter_tokenizer;
+
+/*
+** Class derived from sqlit3_tokenizer_cursor
+*/
+typedef struct porter_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *zInput;          /* input we are tokenizing */
+  int nInput;                  /* size of the input */
+  int iOffset;                 /* current position in zInput */
+  int iToken;                  /* index of next token to be returned */
+  char *zToken;                /* storage for current token */
+  int nAllocated;              /* space allocated to zToken buffer */
+} porter_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module porterTokenizerModule;
+
+
+/*
+** Create a new tokenizer instance.
+*/
+static int porterCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  porter_tokenizer *t;
+  t = (porter_tokenizer *) calloc(sizeof(*t), 1);
+  if( t==NULL ) return SQLITE_NOMEM;
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int porterDestroy(sqlite3_tokenizer *pTokenizer){
+  free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is zInput[0..nInput-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int porterOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *zInput, int nInput,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  porter_tokenizer_cursor *c;
+
+  c = (porter_tokenizer_cursor *) malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->zInput = zInput;
+  if( zInput==0 ){
+    c->nInput = 0;
+  }else if( nInput<0 ){
+    c->nInput = (int)strlen(zInput);
+  }else{
+    c->nInput = nInput;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->zToken = NULL;               /* no space allocated, yet. */
+  c->nAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** porterOpen() above.
+*/
+static int porterClose(sqlite3_tokenizer_cursor *pCursor){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  free(c->zToken);
+  free(c);
+  return SQLITE_OK;
+}
+/*
+** Vowel or consonant
+*/
+static const char cType[] = {
+   0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,
+   1, 1, 1, 2, 1
+};
+
+/*
+** isConsonant() and isVowel() determine if their first character in
+** the string they point to is a consonant or a vowel, according
+** to Porter ruls.  
+**
+** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'.
+** 'Y' is a consonant unless it follows another consonant,
+** in which case it is a vowel.
+**
+** In these routine, the letters are in reverse order.  So the 'y' rule
+** is that 'y' is a consonant unless it is followed by another
+** consonent.
+*/
+static int isVowel(const char*);
+static int isConsonant(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return j;
+  return z[1]==0 || isVowel(z + 1);
+}
+static int isVowel(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return 1-j;
+  return isConsonant(z + 1);
+}
+
+/*
+** Let any sequence of one or more vowels be represented by V and let
+** C be sequence of one or more consonants.  Then every word can be
+** represented as:
+**
+**           [C] (VC){m} [V]
+**
+** In prose:  A word is an optional consonant followed by zero or
+** vowel-consonant pairs followed by an optional vowel.  "m" is the
+** number of vowel consonant pairs.  This routine computes the value
+** of m for the first i bytes of a word.
+**
+** Return true if the m-value for z is 1 or more.  In other words,
+** return true if z contains at least one vowel that is followed
+** by a consonant.
+**
+** In this routine z[] is in reverse order.  So we are really looking
+** for an instance of of a consonant followed by a vowel.
+*/
+static int m_gt_0(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/* Like mgt0 above except we are looking for a value of m which is
+** exactly 1
+*/
+static int m_eq_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 1;
+  while( isConsonant(z) ){ z++; }
+  return *z==0;
+}
+
+/* Like mgt0 above except we are looking for a value of m>1 instead
+** or m>0
+*/
+static int m_gt_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if there is a vowel anywhere within z[0..n-1]
+*/
+static int hasVowel(const char *z){
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if the word ends in a double consonant.
+**
+** The text is reversed here. So we are really looking at
+** the first two characters of z[].
+*/
+static int doubleConsonant(const char *z){
+  return isConsonant(z) && z[0]==z[1] && isConsonant(z+1);
+}
+
+/*
+** Return TRUE if the word ends with three letters which
+** are consonant-vowel-consonent and where the final consonant
+** is not 'w', 'x', or 'y'.
+**
+** The word is reversed here.  So we are really checking the
+** first three letters and the first one cannot be in [wxy].
+*/
+static int star_oh(const char *z){
+  return
+    z[0]!=0 && isConsonant(z) &&
+    z[0]!='w' && z[0]!='x' && z[0]!='y' &&
+    z[1]!=0 && isVowel(z+1) &&
+    z[2]!=0 && isConsonant(z+2);
+}
+
+/*
+** If the word ends with zFrom and xCond() is true for the stem
+** of the word that preceeds the zFrom ending, then change the 
+** ending to zTo.
+**
+** The input word *pz and zFrom are both in reverse order.  zTo
+** is in normal order. 
+**
+** Return TRUE if zFrom matches.  Return FALSE if zFrom does not
+** match.  Not that TRUE is returned even if xCond() fails and
+** no substitution occurs.
+*/
+static int stem(
+  char **pz,             /* The word being stemmed (Reversed) */
+  const char *zFrom,     /* If the ending matches this... (Reversed) */
+  const char *zTo,       /* ... change the ending to this (not reversed) */
+  int (*xCond)(const char*)   /* Condition that must be true */
+){
+  char *z = *pz;
+  while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
+  if( *zFrom!=0 ) return 0;
+  if( xCond && !xCond(z) ) return 1;
+  while( *zTo ){
+    *(--z) = *(zTo++);
+  }
+  *pz = z;
+  return 1;
+}
+
+/*
+** This is the fallback stemmer used when the porter stemmer is
+** inappropriate.  The input word is copied into the output with
+** US-ASCII case folding.  If the input word is too long (more
+** than 20 bytes if it contains no digits or more than 6 bytes if
+** it contains digits) then word is truncated to 20 or 6 bytes
+** by taking 10 or 3 bytes from the beginning and end.
+*/
+static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, mx, j;
+  int hasDigit = 0;
+  for(i=0; i<nIn; i++){
+    int c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zOut[i] = c - 'A' + 'a';
+    }else{
+      if( c>='0' && c<='9' ) hasDigit = 1;
+      zOut[i] = c;
+    }
+  }
+  mx = hasDigit ? 3 : 10;
+  if( nIn>mx*2 ){
+    for(j=mx, i=nIn-mx; i<nIn; i++, j++){
+      zOut[j] = zOut[i];
+    }
+    i = j;
+  }
+  zOut[i] = 0;
+  *pnOut = i;
+}
+
+
+/*
+** Stem the input word zIn[0..nIn-1].  Store the output in zOut.
+** zOut is at least big enough to hold nIn bytes.  Write the actual
+** size of the output word (exclusive of the '\0' terminator) into *pnOut.
+**
+** Any upper-case characters in the US-ASCII character set ([A-Z])
+** are converted to lower case.  Upper-case UTF characters are
+** unchanged.
+**
+** Words that are longer than about 20 bytes are stemmed by retaining
+** a few bytes from the beginning and the end of the word.  If the
+** word contains digits, 3 bytes are taken from the beginning and
+** 3 bytes from the end.  For long words without digits, 10 bytes
+** are taken from each end.  US-ASCII case folding still applies.
+** 
+** If the input word contains not digits but does characters not 
+** in [a-zA-Z] then no stemming is attempted and this routine just 
+** copies the input into the input into the output with US-ASCII
+** case folding.
+**
+** Stemming never increases the length of the word.  So there is
+** no chance of overflowing the zOut buffer.
+*/
+static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, j, c;
+  char zReverse[28];
+  char *z, *z2;
+  if( nIn<3 || nIn>=sizeof(zReverse)-7 ){
+    /* The word is too big or too small for the porter stemmer.
+    ** Fallback to the copy stemmer */
+    copy_stemmer(zIn, nIn, zOut, pnOut);
+    return;
+  }
+  for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
+    c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zReverse[j] = c + 'a' - 'A';
+    }else if( c>='a' && c<='z' ){
+      zReverse[j] = c;
+    }else{
+      /* The use of a character not in [a-zA-Z] means that we fallback
+      ** to the copy stemmer */
+      copy_stemmer(zIn, nIn, zOut, pnOut);
+      return;
+    }
+  }
+  memset(&zReverse[sizeof(zReverse)-5], 0, 5);
+  z = &zReverse[j+1];
+
+
+  /* Step 1a */
+  if( z[0]=='s' ){
+    if(
+     !stem(&z, "sess", "ss", 0) &&
+     !stem(&z, "sei", "i", 0)  &&
+     !stem(&z, "ss", "ss", 0)
+    ){
+      z++;
+    }
+  }
+
+  /* Step 1b */  
+  z2 = z;
+  if( stem(&z, "dee", "ee", m_gt_0) ){
+    /* Do nothing.  The work was all in the test */
+  }else if( 
+     (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
+      && z!=z2
+  ){
+     if( stem(&z, "ta", "ate", 0) ||
+         stem(&z, "lb", "ble", 0) ||
+         stem(&z, "zi", "ize", 0) ){
+       /* Do nothing.  The work was all in the test */
+     }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
+       z++;
+     }else if( m_eq_1(z) && star_oh(z) ){
+       *(--z) = 'e';
+     }
+  }
+
+  /* Step 1c */
+  if( z[0]=='y' && hasVowel(z+1) ){
+    z[0] = 'i';
+  }
+
+  /* Step 2 */
+  switch( z[1] ){
+   case 'a':
+     stem(&z, "lanoita", "ate", m_gt_0) ||
+     stem(&z, "lanoit", "tion", m_gt_0);
+     break;
+   case 'c':
+     stem(&z, "icne", "ence", m_gt_0) ||
+     stem(&z, "icna", "ance", m_gt_0);
+     break;
+   case 'e':
+     stem(&z, "rezi", "ize", m_gt_0);
+     break;
+   case 'g':
+     stem(&z, "igol", "log", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "ilb", "ble", m_gt_0) ||
+     stem(&z, "illa", "al", m_gt_0) ||
+     stem(&z, "iltne", "ent", m_gt_0) ||
+     stem(&z, "ile", "e", m_gt_0) ||
+     stem(&z, "ilsuo", "ous", m_gt_0);
+     break;
+   case 'o':
+     stem(&z, "noitazi", "ize", m_gt_0) ||
+     stem(&z, "noita", "ate", m_gt_0) ||
+     stem(&z, "rota", "ate", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "msila", "al", m_gt_0) ||
+     stem(&z, "ssenevi", "ive", m_gt_0) ||
+     stem(&z, "ssenluf", "ful", m_gt_0) ||
+     stem(&z, "ssensuo", "ous", m_gt_0);
+     break;
+   case 't':
+     stem(&z, "itila", "al", m_gt_0) ||
+     stem(&z, "itivi", "ive", m_gt_0) ||
+     stem(&z, "itilib", "ble", m_gt_0);
+     break;
+  }
+
+  /* Step 3 */
+  switch( z[0] ){
+   case 'e':
+     stem(&z, "etaci", "ic", m_gt_0) ||
+     stem(&z, "evita", "", m_gt_0)   ||
+     stem(&z, "ezila", "al", m_gt_0);
+     break;
+   case 'i':
+     stem(&z, "itici", "ic", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "laci", "ic", m_gt_0) ||
+     stem(&z, "luf", "", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "ssen", "", m_gt_0);
+     break;
+  }
+
+  /* Step 4 */
+  switch( z[1] ){
+   case 'a':
+     if( z[0]=='l' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'c':
+     if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e')  && m_gt_1(z+4)  ){
+       z += 4;
+     }
+     break;
+   case 'e':
+     if( z[0]=='r' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'i':
+     if( z[0]=='c' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'l':
+     if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
+       z += 4;
+     }
+     break;
+   case 'n':
+     if( z[0]=='t' ){
+       if( z[2]=='a' ){
+         if( m_gt_1(z+3) ){
+           z += 3;
+         }
+       }else if( z[2]=='e' ){
+         stem(&z, "tneme", "", m_gt_1) ||
+         stem(&z, "tnem", "", m_gt_1) ||
+         stem(&z, "tne", "", m_gt_1);
+       }
+     }
+     break;
+   case 'o':
+     if( z[0]=='u' ){
+       if( m_gt_1(z+2) ){
+         z += 2;
+       }
+     }else if( z[3]=='s' || z[3]=='t' ){
+       stem(&z, "noi", "", m_gt_1);
+     }
+     break;
+   case 's':
+     if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 't':
+     stem(&z, "eta", "", m_gt_1) ||
+     stem(&z, "iti", "", m_gt_1);
+     break;
+   case 'u':
+     if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 'v':
+   case 'z':
+     if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+  }
+
+  /* Step 5a */
+  if( z[0]=='e' ){
+    if( m_gt_1(z+1) ){
+      z++;
+    }else if( m_eq_1(z+1) && !star_oh(z+1) ){
+      z++;
+    }
+  }
+
+  /* Step 5b */
+  if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
+    z++;
+  }
+
+  /* z[] is now the stemmed word in reverse order.  Flip it back
+  ** around into forward order and return.
+  */
+  *pnOut = i = strlen(z);
+  zOut[i] = 0;
+  while( *z ){
+    zOut[--i] = *(z++);
+  }
+}
+
+/*
+** Characters that can be part of a token.  We assume any character
+** whose value is greater than 0x80 (any UTF character) can be
+** part of a token.  In other words, delimiters all must have
+** values of 0x7f or lower.
+*/
+static const char isIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define idChar(C)  (((ch=C)&0x80)!=0 || (ch>0x2f && isIdChar[ch-0x30]))
+#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !isIdChar[ch-0x30]))
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to porterOpen().
+*/
+static int porterNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by porterOpen */
+  const char **pzToken,               /* OUT: *pzToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  const char *z = c->zInput;
+
+  while( c->iOffset<c->nInput ){
+    int iStartOffset, ch;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int n = c->iOffset-iStartOffset;
+      if( n>c->nAllocated ){
+        c->nAllocated = n+20;
+        c->zToken = realloc(c->zToken, c->nAllocated);
+        if( c->zToken==NULL ) return SQLITE_NOMEM;
+      }
+      porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
+      *pzToken = c->zToken;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the porter-stemmer tokenizer
+*/
+static const sqlite3_tokenizer_module porterTokenizerModule = {
+  0,
+  porterCreate,
+  porterDestroy,
+  porterOpen,
+  porterClose,
+  porterNext,
+};
+
+/*
+** Allocate a new porter tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts1PorterTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &porterTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer.h
new file mode 100644
index 0000000..a48cb74
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer.h
@@ -0,0 +1,90 @@
+/*
+** 2006 July 10
+**
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Defines the interface to tokenizers used by fulltext-search.  There
+** are three basic components:
+**
+** sqlite3_tokenizer_module is a singleton defining the tokenizer
+** interface functions.  This is essentially the class structure for
+** tokenizers.
+**
+** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
+** including customization information defined at creation time.
+**
+** sqlite3_tokenizer_cursor is generated by a tokenizer to generate
+** tokens from a particular input.
+*/
+#ifndef _FTS1_TOKENIZER_H_
+#define _FTS1_TOKENIZER_H_
+
+/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
+** If tokenizers are to be allowed to call sqlite3_*() functions, then
+** we will need a way to register the API consistently.
+*/
+#include "sqlite3.h"
+
+/*
+** Structures used by the tokenizer interface.
+*/
+typedef struct sqlite3_tokenizer sqlite3_tokenizer;
+typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
+typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module;
+
+struct sqlite3_tokenizer_module {
+  int iVersion;                  /* currently 0 */
+
+  /*
+  ** Create and destroy a tokenizer.  argc/argv are passed down from
+  ** the fulltext virtual table creation to allow customization.
+  */
+  int (*xCreate)(int argc, const char *const*argv,
+                 sqlite3_tokenizer **ppTokenizer);
+  int (*xDestroy)(sqlite3_tokenizer *pTokenizer);
+
+  /*
+  ** Tokenize a particular input.  Call xOpen() to prepare to
+  ** tokenize, xNext() repeatedly until it returns SQLITE_DONE, then
+  ** xClose() to free any internal state.  The pInput passed to
+  ** xOpen() must exist until the cursor is closed.  The ppToken
+  ** result from xNext() is only valid until the next call to xNext()
+  ** or until xClose() is called.
+  */
+  /* TODO(shess) current implementation requires pInput to be
+  ** nul-terminated.  This should either be fixed, or pInput/nBytes
+  ** should be converted to zInput.
+  */
+  int (*xOpen)(sqlite3_tokenizer *pTokenizer,
+               const char *pInput, int nBytes,
+               sqlite3_tokenizer_cursor **ppCursor);
+  int (*xClose)(sqlite3_tokenizer_cursor *pCursor);
+  int (*xNext)(sqlite3_tokenizer_cursor *pCursor,
+               const char **ppToken, int *pnBytes,
+               int *piStartOffset, int *piEndOffset, int *piPosition);
+};
+
+struct sqlite3_tokenizer {
+  const sqlite3_tokenizer_module *pModule;  /* The module for this tokenizer */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+struct sqlite3_tokenizer_cursor {
+  sqlite3_tokenizer *pTokenizer;       /* Tokenizer for this cursor. */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+/*
+** Get the module for a tokenizer which generates tokens based on a
+** set of non-token characters.  The default is to break tokens at any
+** non-alnum character, though the set of delimiters can also be
+** specified by the first argv argument to xCreate().
+*/
+/* TODO(shess) This doesn't belong here.  Need some sort of
+** registration process.
+*/
+void sqlite3Fts1SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+void sqlite3Fts1PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+
+#endif /* _FTS1_TOKENIZER_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer1.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer1.c
new file mode 100644
index 0000000..f58fba8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fts1_tokenizer1.c
@@ -0,0 +1,221 @@
+/*
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Implementation of the "simple" full-text-search tokenizer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS1 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS1 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS1 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts1_tokenizer.h"
+
+typedef struct simple_tokenizer {
+  sqlite3_tokenizer base;
+  char delim[128];             /* flag ASCII delimiters */
+} simple_tokenizer;
+
+typedef struct simple_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *pInput;          /* input we are tokenizing */
+  int nBytes;                  /* size of the input */
+  int iOffset;                 /* current position in pInput */
+  int iToken;                  /* index of next token to be returned */
+  char *pToken;                /* storage for current token */
+  int nTokenAllocated;         /* space allocated to zToken buffer */
+} simple_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module simpleTokenizerModule;
+
+static int isDelim(simple_tokenizer *t, unsigned char c){
+  return c<0x80 && t->delim[c];
+}
+
+/*
+** Create a new tokenizer instance.
+*/
+static int simpleCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  simple_tokenizer *t;
+
+  t = (simple_tokenizer *) calloc(sizeof(*t), 1);
+  if( t==NULL ) return SQLITE_NOMEM;
+
+  /* TODO(shess) Delimiters need to remain the same from run to run,
+  ** else we need to reindex.  One solution would be a meta-table to
+  ** track such information in the database, then we'd only want this
+  ** information on the initial create.
+  */
+  if( argc>1 ){
+    int i, n = strlen(argv[1]);
+    for(i=0; i<n; i++){
+      unsigned char ch = argv[1][i];
+      /* We explicitly don't support UTF-8 delimiters for now. */
+      if( ch>=0x80 ){
+        free(t);
+        return SQLITE_ERROR;
+      }
+      t->delim[ch] = 1;
+    }
+  } else {
+    /* Mark non-alphanumeric ASCII characters as delimiters */
+    int i;
+    for(i=1; i<0x80; i++){
+      t->delim[i] = !isalnum(i);
+    }
+  }
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
+  free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is pInput[0..nBytes-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int simpleOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *pInput, int nBytes,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  simple_tokenizer_cursor *c;
+
+  c = (simple_tokenizer_cursor *) malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->pInput = pInput;
+  if( pInput==0 ){
+    c->nBytes = 0;
+  }else if( nBytes<0 ){
+    c->nBytes = (int)strlen(pInput);
+  }else{
+    c->nBytes = nBytes;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->pToken = NULL;               /* no space allocated, yet. */
+  c->nTokenAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** simpleOpen() above.
+*/
+static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  free(c->pToken);
+  free(c);
+  return SQLITE_OK;
+}
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to simpleOpen().
+*/
+static int simpleNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
+  const char **ppToken,               /* OUT: *ppToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
+  unsigned char *p = (unsigned char *)c->pInput;
+
+  while( c->iOffset<c->nBytes ){
+    int iStartOffset;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nBytes && isDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nBytes && !isDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int i, n = c->iOffset-iStartOffset;
+      if( n>c->nTokenAllocated ){
+        c->nTokenAllocated = n+20;
+        c->pToken = realloc(c->pToken, c->nTokenAllocated);
+        if( c->pToken==NULL ) return SQLITE_NOMEM;
+      }
+      for(i=0; i<n; i++){
+        /* TODO(shess) This needs expansion to handle UTF-8
+        ** case-insensitivity.
+        */
+        unsigned char ch = p[iStartOffset+i];
+        c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
+      }
+      *ppToken = c->pToken;
+      *pnBytes = n;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the simple tokenizer
+*/
+static const sqlite3_tokenizer_module simpleTokenizerModule = {
+  0,
+  simpleCreate,
+  simpleDestroy,
+  simpleOpen,
+  simpleClose,
+  simpleNext,
+};
+
+/*
+** Allocate a new simple tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts1SimpleTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &simpleTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS1) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.c
new file mode 100644
index 0000000..e6034ba
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.c
@@ -0,0 +1,1496 @@
+/* The author disclaims copyright to this source code.
+ *
+ * This is an SQLite module implementing full-text search.
+ */
+
+#include <assert.h>
+#if !defined(__APPLE__)
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fulltext.h"
+#include "ft_hash.h"
+#include "tokenizer.h"
+#include "sqlite3.h"
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+/* utility functions */
+
+/* We encode variable-length integers in little-endian order using seven bits
+ * per byte as follows:
+**
+** KEY:
+**         A = 0xxxxxxx    7 bits of data and one flag bit
+**         B = 1xxxxxxx    7 bits of data and one flag bit
+**
+**  7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** and so on.
+*/
+
+/* We may need up to VARINT_MAX bytes to store an encoded 64-bit integer. */
+#define VARINT_MAX 10
+
+/* Write a 64-bit variable-length integer to memory starting at p[0].
+ * The length of data written will be between 1 and VARINT_MAX bytes.
+ * The number of bytes written is returned. */
+static int putVarint(char *p, sqlite_int64 v){
+  unsigned char *q = (unsigned char *) p;
+  sqlite_uint64 vu = v;
+  do{
+    *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
+    vu >>= 7;
+  }while( vu!=0 );
+  q[-1] &= 0x7f;  /* turn off high bit in final byte */
+  assert( q - (unsigned char *)p <= VARINT_MAX );
+  return (int) (q - (unsigned char *)p);
+}
+
+/* Read a 64-bit variable-length integer from memory starting at p[0].
+ * Return the number of bytes read, or 0 on error.
+ * The value is stored in *v. */
+static int getVarint(const char *p, sqlite_int64 *v){
+  const unsigned char *q = (const unsigned char *) p;
+  sqlite_uint64 x = 0, y = 1;
+  while( (*q & 0x80) == 0x80 ){
+    x += y * (*q++ & 0x7f);
+    y <<= 7;
+    if( q - (unsigned char *)p >= VARINT_MAX ){  /* bad data */
+      assert( 0 );
+      return 0;
+    }
+  }
+  x += y * (*q++);
+  *v = (sqlite_int64) x;
+  return (int) (q - (unsigned char *)p);
+}
+
+static int getVarint32(const char *p, int *pi){
+ sqlite_int64 i;
+ int ret = getVarint(p, &i);
+ *pi = (int) i;
+ assert( *pi==i );
+ return ret;
+}
+
+/*** Document lists ***
+ *
+ * A document list holds a sorted list of varint-encoded document IDs.
+ *
+ * A doclist with type DL_POSITIONS_OFFSETS is stored like this:
+ *
+ * array {
+ *   varint docid;
+ *   array {
+ *     varint position;     (delta from previous position plus 1, or 0 for end)
+ *     varint startOffset;  (delta from previous startOffset)
+ *     varint endOffset;    (delta from startOffset)
+ *   }
+ * }
+ *
+ * Here, array { X } means zero or more occurrences of X, adjacent in memory.
+ *
+ * A doclist with type DL_POSITIONS is like the above, but holds only docids
+ * and positions without offset information.
+ *
+ * A doclist with type DL_DOCIDS is like the above, but holds only docids
+ * without positions or offset information.
+ *
+ * On disk, every document list has positions and offsets, so we don't bother
+ * to serialize a doclist's type.
+ * 
+ * We don't yet delta-encode document IDs; doing so will probably be a
+ * modest win.
+ *
+ * NOTE(shess) I've thought of a slightly (1%) better offset encoding.
+ * After the first offset, estimate the next offset by using the
+ * current token position and the previous token position and offset,
+ * offset to handle some variance.  So the estimate would be
+ * (iPosition*w->iStartOffset/w->iPosition-64), which is delta-encoded
+ * as normal.  Offsets more than 64 chars from the estimate are
+ * encoded as the delta to the previous start offset + 128.  An
+ * additional tiny increment can be gained by using the end offset of
+ * the previous token to make the estimate a tiny bit more precise.
+*/
+
+typedef enum DocListType {
+  DL_DOCIDS,              /* docids only */
+  DL_POSITIONS,           /* docids + positions */
+  DL_POSITIONS_OFFSETS    /* docids + positions + offsets */
+} DocListType;
+
+typedef struct DocList {
+  char *pData;
+  int nData;
+  DocListType iType;
+  int iLastPos;       /* the last position written */
+  int iLastOffset;    /* the last start offset written */
+} DocList;
+
+/* Initialize a new DocList to hold the given data. */
+static void docListInit(DocList *d, DocListType iType,
+                        const char *pData, int nData){
+  d->nData = nData;
+  if( nData>0 ){
+    d->pData = malloc(nData);
+    memcpy(d->pData, pData, nData);
+  } else {
+    d->pData = NULL;
+  }
+  d->iType = iType;
+  d->iLastPos = 0;
+  d->iLastOffset = 0;
+}
+
+/* Create a new dynamically-allocated DocList. */
+static DocList *docListNew(DocListType iType){
+  DocList *d = (DocList *) malloc(sizeof(DocList));
+  docListInit(d, iType, 0, 0);
+  return d;
+}
+
+static void docListDestroy(DocList *d){
+  free(d->pData);
+#ifndef NDEBUG
+  memset(d, 0x55, sizeof(*d));
+#endif
+}
+
+static void docListDelete(DocList *d){
+  docListDestroy(d);
+  free(d);
+}
+
+static char *docListEnd(DocList *d){
+  return d->pData + d->nData;
+}
+
+/* Append a varint to a DocList's data. */
+static void appendVarint(DocList *d, sqlite_int64 i){
+  char c[VARINT_MAX];
+  int n = putVarint(c, i);
+  d->pData = realloc(d->pData, d->nData + n);
+  memcpy(d->pData + d->nData, c, n);
+  d->nData += n;
+}
+
+static void docListAddDocid(DocList *d, sqlite_int64 iDocid){
+  appendVarint(d, iDocid);
+  d->iLastPos = 0;
+}
+
+/* Add a position to the last position list in a doclist. */
+static void docListAddPos(DocList *d, int iPos){
+  assert( d->iType>=DL_POSITIONS );
+  appendVarint(d, iPos-d->iLastPos+1);
+  d->iLastPos = iPos;
+}
+
+static void docListAddPosOffset(DocList *d, int iPos,
+                                int iStartOffset, int iEndOffset){
+  assert( d->iType==DL_POSITIONS_OFFSETS );
+  docListAddPos(d, iPos);
+  appendVarint(d, iStartOffset-d->iLastOffset);
+  d->iLastOffset = iStartOffset;
+  appendVarint(d, iEndOffset-iStartOffset);
+}
+
+/* Terminate the last position list in the given doclist. */
+static void docListAddEndPos(DocList *d){
+  appendVarint(d, 0);
+}
+
+typedef struct DocListReader {
+  DocList *pDoclist;
+  char *p;
+  int iLastPos;    /* the last position read */
+} DocListReader;
+
+static void readerInit(DocListReader *r, DocList *pDoclist){
+  r->pDoclist = pDoclist;
+  if( pDoclist!=NULL ){
+    r->p = pDoclist->pData;
+  }
+  r->iLastPos = 0;
+}
+
+static int readerAtEnd(DocListReader *pReader){
+  return pReader->p >= docListEnd(pReader->pDoclist);
+}
+
+/* Peek at the next docid without advancing the read pointer. */
+static sqlite_int64 peekDocid(DocListReader *pReader){
+  sqlite_int64 ret;
+  assert( !readerAtEnd(pReader) );
+  getVarint(pReader->p, &ret);
+  return ret;
+}
+
+/* Read the next docid. */
+static sqlite_int64 readDocid(DocListReader *pReader){
+  sqlite_int64 ret;
+  assert( !readerAtEnd(pReader) );
+  pReader->p += getVarint(pReader->p, &ret);
+  pReader->iLastPos = 0;
+  return ret;
+}
+
+/* Read the next position from a position list.
+ * Returns the position, or -1 at the end of the list. */
+static int readPosition(DocListReader *pReader){
+  int i;
+  int iType = pReader->pDoclist->iType;
+  assert( iType>=DL_POSITIONS );
+  assert( !readerAtEnd(pReader) );
+
+  pReader->p += getVarint32(pReader->p, &i);
+  if( i==0 ){
+    pReader->iLastPos = -1;
+    return -1;
+  }
+  pReader->iLastPos += ((int) i)-1;
+  if( iType>=DL_POSITIONS_OFFSETS ){
+    /* Skip over offsets, ignoring them for now. */
+    int iStart, iEnd;
+    pReader->p += getVarint32(pReader->p, &iStart);
+    pReader->p += getVarint32(pReader->p, &iEnd);
+  }
+  return pReader->iLastPos;
+}
+
+/* Skip past the end of a position list. */
+static void skipPositionList(DocListReader *pReader){
+  while( readPosition(pReader)!=-1 )
+    ;
+}
+
+/* Skip over a docid, including its position list if the doclist has
+ * positions. */
+static void skipDocument(DocListReader *pReader){
+  readDocid(pReader);
+  if( pReader->pDoclist->iType >= DL_POSITIONS ){
+    skipPositionList(pReader);
+  }
+}
+
+static sqlite_int64 firstDocid(DocList *d){
+  DocListReader r;
+  readerInit(&r, d);
+  return readDocid(&r);
+}
+
+/* Doclist multi-tool.  Pass pUpdate==NULL to delete the indicated docid;
+ * otherwise pUpdate, which must contain only the single docid [iDocid], is
+ * inserted (if not present) or updated (if already present). */
+static int docListUpdate(DocList *d, sqlite_int64 iDocid, DocList *pUpdate){
+  int modified = 0;
+  DocListReader reader;
+  char *p;
+
+  if( pUpdate!=NULL ){
+    assert( d->iType==pUpdate->iType);
+    assert( iDocid==firstDocid(pUpdate) );
+  }
+
+  readerInit(&reader, d);
+  while( !readerAtEnd(&reader) && peekDocid(&reader)<iDocid ){
+    skipDocument(&reader);
+  }
+
+  p = reader.p;
+  /* Delete if there is a matching element. */
+  if( !readerAtEnd(&reader) && iDocid==peekDocid(&reader) ){
+    skipDocument(&reader);
+    memmove(p, reader.p, docListEnd(d) - reader.p);
+    d->nData -= (reader.p - p);
+    modified = 1;
+  }
+
+  /* Insert if indicated. */
+  if( pUpdate!=NULL ){
+    int iDoclist = p-d->pData;
+    docListAddEndPos(pUpdate);
+
+    d->pData = realloc(d->pData, d->nData+pUpdate->nData);
+    p = d->pData + iDoclist;
+
+    memmove(p+pUpdate->nData, p, docListEnd(d) - p);
+    memcpy(p, pUpdate->pData, pUpdate->nData);
+    d->nData += pUpdate->nData;
+    modified = 1;
+  }
+
+  return modified;
+}
+
+/* Split the second half of doclist d into a separate doclist d2.  Returns 1
+ * if successful, or 0 if d contains a single document and hence can't be
+ * split. */
+static int docListSplit(DocList *d, DocList *d2){
+  const char *pSplitPoint = d->pData + d->nData / 2;
+  DocListReader reader;
+
+  readerInit(&reader, d);
+  while( reader.p<pSplitPoint ){
+    skipDocument(&reader);
+  }
+  if( readerAtEnd(&reader) ) return 0;
+  docListInit(d2, d->iType, reader.p, docListEnd(d) - reader.p);
+  d->nData = reader.p - d->pData;
+  d->pData = realloc(d->pData, d->nData);
+  return 1;
+}
+
+/* A DocListMerge computes the AND of an in-memory DocList [in] and a chunked
+ * on-disk doclist, resulting in another in-memory DocList [out].  [in]
+ * and [out] may or may not store position information according to the
+ * caller's wishes.  The on-disk doclist always comes with positions.
+ *
+ * The caller must read each chunk of the on-disk doclist in succession and
+ * pass it to mergeBlock().
+ *
+ * If [in] has positions, then the merge output contains only documents with
+ * matching positions in the two input doclists.  If [in] does not have
+ * positions, then the merge output contains all documents common to the two
+ * input doclists.
+ *
+ * If [in] is NULL, then the on-disk doclist is copied to [out] directly.
+ *
+ * A merge is performed using an integer [iOffset] provided by the caller.
+ * [iOffset] is subtracted from each position in the on-disk doclist for the
+ * purpose of position comparison; this is helpful in implementing phrase
+ * searches.
+ *
+ * A DocListMerge is not yet able to propagate offsets through query
+ * processing; we should add that capability soon.
+*/
+typedef struct DocListMerge {
+  DocListReader in;
+  DocList *pOut;
+  int iOffset;
+} DocListMerge;
+
+static void mergeInit(DocListMerge *m,
+                      DocList *pIn, int iOffset, DocList *pOut){
+  readerInit(&m->in, pIn);
+  m->pOut = pOut;
+  m->iOffset = iOffset;
+
+  /* can't handle offsets yet */
+  assert( pIn==NULL || pIn->iType <= DL_POSITIONS );
+  assert( pOut->iType <= DL_POSITIONS );
+}
+
+/* A helper function for mergeBlock(), below.  Merge the position lists
+ * pointed to by m->in and pBlockReader.
+ * If the merge matches, write [iDocid] to m->pOut; if m->pOut
+ * has positions then write all matching positions as well. */
+static void mergePosList(DocListMerge *m, sqlite_int64 iDocid,
+                  DocListReader *pBlockReader){
+  int block_pos = readPosition(pBlockReader);
+  int in_pos = readPosition(&m->in);
+  int match = 0;
+  while( block_pos!=-1 || in_pos!=-1 ){
+    if( block_pos-m->iOffset==in_pos ){
+      if( !match ){
+        docListAddDocid(m->pOut, iDocid);
+        match = 1;
+      }
+      if( m->pOut->iType >= DL_POSITIONS ){
+        docListAddPos(m->pOut, in_pos);
+      }
+      block_pos = readPosition(pBlockReader);
+      in_pos = readPosition(&m->in);
+    } else if( in_pos==-1 || (block_pos!=-1 && block_pos-m->iOffset<in_pos) ){
+      block_pos = readPosition(pBlockReader);
+    } else {
+      in_pos = readPosition(&m->in);
+    }
+  }
+  if( m->pOut->iType >= DL_POSITIONS && match ){
+    docListAddEndPos(m->pOut);
+  }
+}
+
+/* Merge one block of an on-disk doclist into a DocListMerge. */
+static void mergeBlock(DocListMerge *m, DocList *pBlock){
+  DocListReader blockReader;
+  assert( pBlock->iType >= DL_POSITIONS );
+  readerInit(&blockReader, pBlock);
+  while( !readerAtEnd(&blockReader) ){
+    sqlite_int64 iDocid = readDocid(&blockReader);
+    if( m->in.pDoclist!=NULL ){
+      while( 1 ){
+        if( readerAtEnd(&m->in) ) return;  /* nothing more to merge */
+        if( peekDocid(&m->in)>=iDocid ) break;
+        skipDocument(&m->in);
+      }
+      if( peekDocid(&m->in)>iDocid ){  /* [pIn] has no match with iDocid */
+        skipPositionList(&blockReader);  /* skip this docid in the block */
+        continue;
+      }
+      readDocid(&m->in);
+    }
+    /* We have a document match. */
+    if( m->in.pDoclist==NULL || m->in.pDoclist->iType < DL_POSITIONS ){
+      /* We don't need to do a poslist merge. */
+      docListAddDocid(m->pOut, iDocid);
+      if( m->pOut->iType >= DL_POSITIONS ){
+        /* Copy all positions to the output doclist. */
+        while( 1 ){
+          int pos = readPosition(&blockReader);
+          if( pos==-1 ) break;
+          docListAddPos(m->pOut, pos);
+        }
+        docListAddEndPos(m->pOut);
+      } else skipPositionList(&blockReader);
+      continue;
+    }
+    mergePosList(m, iDocid, &blockReader);
+  }
+}
+
+static char *string_dup_n(const char *s, int n){
+  char *str = malloc(n + 1);
+  memcpy(str, s, n);
+  str[n] = '\0';
+  return str;
+}
+
+/* Duplicate a string; the caller must free() the returned string.
+ * (We don't use strdup() since it's not part of the standard C library and
+ * may not be available everywhere.) */
+static char *string_dup(const char *s){
+  return string_dup_n(s, strlen(s));
+}
+
+/* Format a string, replacing each occurrence of the % character with
+ * zName.  This may be more convenient than sqlite_mprintf()
+ * when one string is used repeatedly in a format string.
+ * The caller must free() the returned string. */
+static char *string_format(const char *zFormat, const char *zName){
+  const char *p;
+  size_t len = 0;
+  size_t nName = strlen(zName);
+  char *result;
+  char *r;
+
+  /* first compute length needed */
+  for(p = zFormat ; *p ; ++p){
+    len += (*p=='%' ? nName : 1);
+  }
+  len += 1;  /* for null terminator */
+
+  r = result = malloc(len);
+  for(p = zFormat; *p; ++p){
+    if( *p=='%' ){
+      memcpy(r, zName, nName);
+      r += nName;
+    } else {
+      *r++ = *p;
+    }
+  }
+  *r++ = '\0';
+  assert( r == result + len );
+  return result;
+}
+
+static int sql_exec(sqlite3 *db, const char *zName, const char *zFormat){
+  char *zCommand = string_format(zFormat, zName);
+  int rc = sqlite3_exec(db, zCommand, NULL, 0, NULL);
+  free(zCommand);
+  return rc;
+}
+
+static int sql_prepare(sqlite3 *db, const char *zName, sqlite3_stmt **ppStmt,
+                const char *zFormat){
+  char *zCommand = string_format(zFormat, zName);
+  int rc = sqlite3_prepare(db, zCommand, -1, ppStmt, NULL);
+  free(zCommand);
+  return rc;
+}
+
+/* end utility functions */
+
+#define QUERY_GENERIC 0
+#define QUERY_FULLTEXT 1
+
+#define CHUNK_MAX 1024
+
+typedef enum fulltext_statement {
+  CONTENT_INSERT_STMT,
+  CONTENT_SELECT_STMT,
+  CONTENT_DELETE_STMT,
+
+  TERM_SELECT_STMT,
+  TERM_CHUNK_SELECT_STMT,
+  TERM_INSERT_STMT,
+  TERM_UPDATE_STMT,
+  TERM_DELETE_STMT,
+
+  MAX_STMT                     /* Always at end! */
+} fulltext_statement;
+
+/* These must exactly match the enum above. */
+/* TODO(adam): Is there some risk that a statement (in particular,
+** pTermSelectStmt) will be used in two cursors at once, e.g.  if a
+** query joins a virtual table to itself?  If so perhaps we should
+** move some of these to the cursor object.
+*/
+static const char *fulltext_zStatement[MAX_STMT] = {
+  /* CONTENT_INSERT */ "insert into %_content (rowid, content) values (?, ?)",
+  /* CONTENT_SELECT */ "select content from %_content where rowid = ?",
+  /* CONTENT_DELETE */ "delete from %_content where rowid = ?",
+
+  /* TERM_SELECT */
+  "select rowid, doclist from %_term where term = ? and first = ?",
+  /* TERM_CHUNK_SELECT */
+  "select max(first) from %_term where term = ? and first <= ?",
+  /* TERM_INSERT */
+  "insert into %_term (term, first, doclist) values (?, ?, ?)",
+  /* TERM_UPDATE */ "update %_term set doclist = ? where rowid = ?",
+  /* TERM_DELETE */ "delete from %_term where rowid = ?",
+};
+
+typedef struct fulltext_vtab {
+  sqlite3_vtab base;
+  sqlite3 *db;
+  const char *zName;               /* virtual table name */
+  sqlite3_tokenizer *pTokenizer;   /* tokenizer for inserts and queries */
+
+  /* Precompiled statements which we keep as long as the table is
+  ** open.
+  */
+  sqlite3_stmt *pFulltextStatements[MAX_STMT];
+} fulltext_vtab;
+
+typedef struct fulltext_cursor {
+  sqlite3_vtab_cursor base;
+  int iCursorType;  /* QUERY_GENERIC or QUERY_FULLTEXT */
+
+  sqlite3_stmt *pStmt;
+
+  int eof;
+
+  /* The following is used only when iCursorType == QUERY_FULLTEXT. */
+  DocListReader result;
+} fulltext_cursor;
+
+static struct fulltext_vtab *cursor_vtab(fulltext_cursor *c){
+  return (fulltext_vtab *) c->base.pVtab;
+}
+
+static sqlite3_module fulltextModule;   /* forward declaration */
+
+/* Puts a freshly-prepared statement determined by iStmt in *ppStmt.
+** If the indicated statement has never been prepared, it is prepared
+** and cached, otherwise the cached version is reset.
+*/
+static int sql_get_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                             sqlite3_stmt **ppStmt){
+  assert( iStmt<MAX_STMT );
+  if( v->pFulltextStatements[iStmt]==NULL ){
+    int rc = sql_prepare(v->db, v->zName, &v->pFulltextStatements[iStmt],
+                         fulltext_zStatement[iStmt]);
+    if( rc!=SQLITE_OK ) return rc;
+  } else {
+    int rc = sqlite3_reset(v->pFulltextStatements[iStmt]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pFulltextStatements[iStmt];
+  return SQLITE_OK;
+}
+
+/* Step the indicated statement, handling errors SQLITE_BUSY (by
+** retrying) and SQLITE_SCHEMA (by re-preparing and transferring
+** bindings to the new statement).
+** TODO(adam): We should extend this function so that it can work with
+** statements declared locally, not only globally cached statements.
+*/
+static int sql_step_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                              sqlite3_stmt **ppStmt){
+  int rc;
+  sqlite3_stmt *s = *ppStmt;
+  assert( iStmt<MAX_STMT );
+  assert( s==v->pFulltextStatements[iStmt] );
+
+  while( (rc=sqlite3_step(s))!=SQLITE_DONE && rc!=SQLITE_ROW ){
+    sqlite3_stmt *pNewStmt;
+
+    if( rc==SQLITE_BUSY ) continue;
+    if( rc!=SQLITE_ERROR ) return rc;
+
+    rc = sqlite3_reset(s);
+    if( rc!=SQLITE_SCHEMA ) return SQLITE_ERROR;
+
+    v->pFulltextStatements[iStmt] = NULL;   /* Still in s */
+    rc = sql_get_statement(v, iStmt, &pNewStmt);
+    if( rc!=SQLITE_OK ) goto err;
+    *ppStmt = pNewStmt;
+
+    rc = sqlite3_transfer_bindings(s, pNewStmt);
+    if( rc!=SQLITE_OK ) goto err;
+
+    rc = sqlite3_finalize(s);
+    if( rc!=SQLITE_OK ) return rc;
+    s = pNewStmt;
+  }
+  return rc;
+
+ err:
+  sqlite3_finalize(s);
+  return rc;
+}
+
+/* Like sql_step_statement(), but convert SQLITE_DONE to SQLITE_OK.
+** Useful for statements like UPDATE, where we expect no results.
+*/
+static int sql_single_step_statement(fulltext_vtab *v,
+                                     fulltext_statement iStmt,
+                                     sqlite3_stmt **ppStmt){
+  int rc = sql_step_statement(v, iStmt, ppStmt);
+  return (rc==SQLITE_DONE) ? SQLITE_OK : rc;
+}
+
+/* insert into %_content (rowid, content) values ([rowid], [zContent]) */
+static int content_insert(fulltext_vtab *v, sqlite3_value *rowid,
+                          const char *zContent, int nContent){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_value(s, 1, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 2, zContent, nContent, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, CONTENT_INSERT_STMT, &s);
+}
+
+/* select content from %_content where rowid = [iRow]
+ * The caller must delete the returned string. */
+static int content_select(fulltext_vtab *v, sqlite_int64 iRow,
+                          char **pzContent){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sql_step_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_ROW ) return rc;
+
+  *pzContent = string_dup((const char *)sqlite3_column_text(s, 0));
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ) return SQLITE_OK;
+
+  free(*pzContent);
+  return rc;
+}
+
+/* delete from %_content where rowid = [iRow ] */
+static int content_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, CONTENT_DELETE_STMT, &s);
+}
+
+/* select rowid, doclist from %_term where term = [zTerm] and first = [iFirst]
+ * If found, returns SQLITE_OK; the caller must free the returned doclist.
+ * If no rows found, returns SQLITE_ERROR. */
+static int term_select(fulltext_vtab *v, const char *zTerm, int nTerm,
+                       sqlite_int64 iFirst,
+                       sqlite_int64 *rowid,
+                       DocList *out){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 1, zTerm, nTerm, SQLITE_TRANSIENT);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, iFirst);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sql_step_statement(v, TERM_SELECT_STMT, &s);
+  if( rc!=SQLITE_ROW ) return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+
+  *rowid = sqlite3_column_int64(s, 0);
+  docListInit(out, DL_POSITIONS_OFFSETS,
+              sqlite3_column_blob(s, 1), sqlite3_column_bytes(s, 1));
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  return rc==SQLITE_DONE ? SQLITE_OK : rc;
+}
+
+/* select max(first) from %_term where term = [zTerm] and first <= [iFirst]
+ * If found, returns SQLITE_ROW and result in *piResult; if the query returns
+ * NULL (meaning no row found) returns SQLITE_DONE.
+ */
+static int term_chunk_select(fulltext_vtab *v, const char *zTerm, int nTerm,
+                           sqlite_int64 iFirst, sqlite_int64 *piResult){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_CHUNK_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 1, zTerm, nTerm, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, iFirst);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sql_step_statement(v, TERM_CHUNK_SELECT_STMT, &s);
+  if( rc!=SQLITE_ROW ) return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+
+  switch( sqlite3_column_type(s, 0) ){
+    case SQLITE_NULL:
+      rc = SQLITE_DONE;
+      break;
+    case SQLITE_INTEGER:
+     *piResult = sqlite3_column_int64(s, 0);
+     break;
+    default:
+      return SQLITE_ERROR;
+  }
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  if( sqlite3_step(s) != SQLITE_DONE ) return SQLITE_ERROR;
+  return rc;
+}
+
+/* insert into %_term (term, first, doclist)
+               values ([zTerm], [iFirst], [doclist]) */
+static int term_insert(fulltext_vtab *v, const char *zTerm, int nTerm,
+                       sqlite_int64 iFirst, DocList *doclist){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(s, 1, zTerm, nTerm, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, iFirst);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 3, doclist->pData, doclist->nData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_INSERT_STMT, &s);
+}
+
+/* update %_term set doclist = [doclist] where rowid = [rowid] */
+static int term_update(fulltext_vtab *v, sqlite_int64 rowid,
+                       DocList *doclist){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_UPDATE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 1, doclist->pData, doclist->nData,
+                         SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_UPDATE_STMT, &s);
+}
+
+static int term_delete(fulltext_vtab *v, sqlite_int64 rowid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, TERM_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step_statement(v, TERM_DELETE_STMT, &s);
+}
+
+static void fulltext_vtab_destroy(fulltext_vtab *v){
+  int iStmt;
+
+  for( iStmt=0; iStmt<MAX_STMT; iStmt++ ){
+    if( v->pFulltextStatements[iStmt]!=NULL ){
+      sqlite3_finalize(v->pFulltextStatements[iStmt]);
+      v->pFulltextStatements[iStmt] = NULL;
+    }
+  }
+
+  if( v->pTokenizer!=NULL ){
+    v->pTokenizer->pModule->xDestroy(v->pTokenizer);
+    v->pTokenizer = NULL;
+  }
+
+  free((void *) v->zName);
+  free(v);
+}
+
+/* Current interface:
+** argv[0] - module name
+** argv[1] - database name
+** argv[2] - table name
+** argv[3] - tokenizer name (optional, a sensible default is provided)
+** argv[4..] - passed to tokenizer (optional based on tokenizer)
+**/
+static int fulltextConnect(sqlite3 *db, void *pAux, int argc, char **argv,
+                           sqlite3_vtab **ppVTab){
+  int rc;
+  fulltext_vtab *v;
+  sqlite3_tokenizer_module *m = NULL;
+
+  assert( argc>=3 );
+  v = (fulltext_vtab *) malloc(sizeof(fulltext_vtab));
+  /* sqlite will initialize v->base */
+  v->db = db;
+  v->zName = string_dup(argv[2]);
+  v->pTokenizer = NULL;
+
+  if( argc==3 ){
+    get_simple_tokenizer_module(&m);
+  } else {
+    /* TODO(shess) For now, add new tokenizers as else if clauses. */
+    if( !strcmp(argv[3], "simple") ){
+      get_simple_tokenizer_module(&m);
+    } else {
+      assert( "unrecognized tokenizer"==NULL );
+    }
+  }
+
+  /* TODO(shess) Since tokenization impacts the index, the parameters
+  ** to the tokenizer need to be identical when a persistent virtual
+  ** table is re-created.  One solution would be a meta-table to track
+  ** such information in the database.  Then we could verify that the
+  ** information is identical on subsequent creates.
+  */
+  /* TODO(shess) Why isn't argv already (const char **)? */
+  rc = m->xCreate(argc-3, (const char **) (argv+3), &v->pTokenizer);
+  if( rc!=SQLITE_OK ) return rc;
+  v->pTokenizer->pModule = m;
+
+  /* TODO: verify the existence of backing tables foo_content, foo_term */
+
+  rc = sqlite3_declare_vtab(db, "create table x(content text)");
+  if( rc!=SQLITE_OK ) return rc;
+
+  memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
+
+  *ppVTab = &v->base;
+  return SQLITE_OK;
+}
+
+static int fulltextCreate(sqlite3 *db, void *pAux, int argc, char **argv,
+                          sqlite3_vtab **ppVTab){
+  int rc;
+  assert( argc>=3 );
+
+  /* The %_content table holds the text of each full-text item, with
+  ** the rowid used as the docid.
+  **
+  ** The %_term table maps each term to a document list blob
+  ** containing elements sorted by ascending docid, each element
+  ** encoded as:
+  **
+  **   docid varint-encoded
+  **   token count varint-encoded
+  **   "count" token elements (poslist):
+  **     position varint-encoded as delta from previous position
+  **     start offset varint-encoded as delta from previous start offset
+  **     end offset varint-encoded as delta from start offset
+  **
+  ** Additionally, doclist blobs can be chunked into multiple rows,
+  ** using "first" to order the blobs.  "first" is simply the first
+  ** docid in the blob.
+  */
+  /*
+  ** NOTE(shess) That last sentence is incorrect in the face of
+  ** deletion, which can leave a doclist that doesn't contain the
+  ** first from that row.  I _believe_ this does not matter to the
+  ** operation of the system, but it might be reasonable to update
+  ** appropriately in case this assumption becomes more important.
+  */
+  rc = sql_exec(db, argv[2],
+    "create table %_content(content text);"
+    "create table %_term(term text, first integer, doclist blob);"
+    "create index %_index on %_term(term, first)");
+  if( rc!=SQLITE_OK ) return rc;
+
+  return fulltextConnect(db, pAux, argc, argv, ppVTab);
+}
+
+/* Decide how to handle an SQL query.
+ * At the moment, MATCH queries can include implicit boolean ANDs; we
+ * haven't implemented phrase searches or OR yet. */
+static int fulltextBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
+  int i;
+
+  for(i=0; i<pInfo->nConstraint; ++i){
+    const struct sqlite3_index_constraint *pConstraint;
+    pConstraint = &pInfo->aConstraint[i];
+    if( pConstraint->iColumn==0 &&
+        pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH &&
+        pConstraint->usable ){   /* a full-text search */
+      pInfo->aConstraintUsage[i].argvIndex = 1;
+      pInfo->aConstraintUsage[i].omit = 1;
+      pInfo->idxNum = QUERY_FULLTEXT;
+      pInfo->estimatedCost = 1.0;   /* an arbitrary value for now */
+      return SQLITE_OK;
+    }
+  }
+  pInfo->idxNum = QUERY_GENERIC;
+  return SQLITE_OK;
+}
+
+static int fulltextDisconnect(sqlite3_vtab *pVTab){
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextDestroy(sqlite3_vtab *pVTab){
+  fulltext_vtab *v = (fulltext_vtab *)pVTab;
+
+  int rc = sql_exec(v->db, v->zName,
+                    "drop table %_content; drop table %_term");
+  if( rc!=SQLITE_OK ) return rc;
+
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  fulltext_cursor *c;
+
+  c = (fulltext_cursor *) calloc(sizeof(fulltext_cursor), 1);
+  /* sqlite will initialize c->base */
+  *ppCursor = &c->base;
+
+  return SQLITE_OK;
+}
+
+static int fulltextClose(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  sqlite3_finalize(c->pStmt);
+  if( c->result.pDoclist!=NULL ){
+    docListDelete(c->result.pDoclist);
+  }
+  free(c);
+  return SQLITE_OK;
+}
+
+static int fulltextNext(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  sqlite_int64 iDocid;
+  int rc;
+
+  switch( c->iCursorType ){
+    case QUERY_GENERIC:
+      /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+      rc = sqlite3_step(c->pStmt);
+      switch( rc ){
+        case SQLITE_ROW:
+          c->eof = 0;
+          return SQLITE_OK;
+        case SQLITE_DONE:
+          c->eof = 1;
+          return SQLITE_OK;
+        default:
+          c->eof = 1;
+          return rc;
+      }
+    case QUERY_FULLTEXT:
+      rc = sqlite3_reset(c->pStmt);
+      if( rc!=SQLITE_OK ) return rc;
+
+      if( readerAtEnd(&c->result)){
+        c->eof = 1;
+        return SQLITE_OK;
+      }
+      iDocid = readDocid(&c->result);
+      rc = sqlite3_bind_int64(c->pStmt, 1, iDocid);
+      if( rc!=SQLITE_OK ) return rc;
+      /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+      rc = sqlite3_step(c->pStmt);
+      if( rc==SQLITE_ROW ){   /* the case we expect */
+        c->eof = 0;
+        return SQLITE_OK;
+      }
+      /* an error occurred; abort */
+      return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+    default:
+      assert( 0 );
+      return SQLITE_ERROR;  /* not reached */
+  }
+}
+
+static int term_select_doclist(fulltext_vtab *v, const char *pTerm, int nTerm,
+                               sqlite3_stmt **ppStmt){
+  int rc;
+  if( *ppStmt ){
+    rc = sqlite3_reset(*ppStmt);
+  } else {
+    rc = sql_prepare(v->db, v->zName, ppStmt,
+      "select doclist from %_term where term = ? order by first");
+  }
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_text(*ppStmt, 1, pTerm, nTerm, SQLITE_TRANSIENT);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sqlite3_step(*ppStmt);   /* TODO(adamd): handle schema error */
+}
+
+/* Read the posting list for [zTerm]; AND it with the doclist [in] to
+ * produce the doclist [out], using the given offset [iOffset] for phrase
+ * matching.
+ * (*pSelect) is used to hold an SQLite statement used inside this function;
+ * the caller should initialize *pSelect to NULL before the first call.
+ */
+static int query_merge(fulltext_vtab *v, sqlite3_stmt **pSelect,
+                       const char *zTerm,
+                       DocList *pIn, int iOffset, DocList *out){
+  int rc;
+  DocListMerge merge;
+
+  if( pIn!=NULL && !pIn->nData ){
+    /* If [pIn] is already empty, there's no point in reading the
+     * posting list to AND it in; return immediately. */
+      return SQLITE_OK;
+  }
+
+  rc = term_select_doclist(v, zTerm, -1, pSelect);
+  if( rc!=SQLITE_ROW && rc!=SQLITE_DONE ) return rc;
+
+  mergeInit(&merge, pIn, iOffset, out);
+  while( rc==SQLITE_ROW ){
+    DocList block;
+    docListInit(&block, DL_POSITIONS_OFFSETS,
+                sqlite3_column_blob(*pSelect, 0),
+                sqlite3_column_bytes(*pSelect, 0));
+    mergeBlock(&merge, &block);
+    docListDestroy(&block);
+
+    rc = sqlite3_step(*pSelect);
+    if( rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
+      return rc;
+    }
+  }
+  
+  return SQLITE_OK;
+}
+
+typedef struct QueryTerm {
+  int is_phrase;    /* true if this term begins a new phrase */
+  const char *zTerm;
+} QueryTerm;
+
+/* A parsed query.
+ *
+ * As an example, parsing the query ["four score" years "new nation"] will
+ * yield a Query with 5 terms:
+ *   "four",   is_phrase = 1
+ *   "score",  is_phrase = 0
+ *   "years",  is_phrase = 1
+ *   "new",    is_phrase = 1
+ *   "nation", is_phrase = 0
+ */
+typedef struct Query {
+  int nTerms;
+  QueryTerm *pTerm;
+} Query;
+
+static void query_add(Query *q, int is_phrase, const char *zTerm){
+  QueryTerm *t;
+  ++q->nTerms;
+  q->pTerm = realloc(q->pTerm, q->nTerms * sizeof(q->pTerm[0]));
+  t = &q->pTerm[q->nTerms - 1];
+  t->is_phrase = is_phrase;
+  t->zTerm = zTerm;
+}
+    
+static void query_free(Query *q){
+  int i;
+  for(i = 0; i < q->nTerms; ++i){
+    free((void *) q->pTerm[i].zTerm);
+  }
+  free(q->pTerm);
+}
+
+static int tokenize_segment(sqlite3_tokenizer *pTokenizer,
+                            const char *zQuery, int in_phrase,
+                            Query *pQuery){
+  sqlite3_tokenizer_module *pModule = pTokenizer->pModule;
+  sqlite3_tokenizer_cursor *pCursor;
+  int is_first = 1;
+  
+  int rc = pModule->xOpen(pTokenizer, zQuery, -1, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+  pCursor->pTokenizer = pTokenizer;
+
+  while( 1 ){
+    const char *zToken;
+    int nToken, iStartOffset, iEndOffset, dummy_pos;
+
+    rc = pModule->xNext(pCursor,
+                        &zToken, &nToken,
+                        &iStartOffset, &iEndOffset,
+                        &dummy_pos);
+    if( rc!=SQLITE_OK ) break;
+    query_add(pQuery, !in_phrase || is_first, string_dup_n(zToken, nToken));
+    is_first = 0;
+  }
+
+  return pModule->xClose(pCursor);
+}
+
+/* Parse a query string, yielding a Query object. */
+static int parse_query(fulltext_vtab *v, const char *zQuery, Query *pQuery){
+  char *zQuery1 = string_dup(zQuery);
+  int in_phrase = 0;
+  char *s = zQuery1;
+  pQuery->nTerms = 0;
+  pQuery->pTerm = NULL;
+
+  while( *s ){
+    char *t = s;
+    while( *t ){
+      if( *t=='"' ){
+        *t++ = '\0';
+        break;
+      }
+      ++t;
+    }
+    if( *s ){
+      tokenize_segment(v->pTokenizer, s, in_phrase, pQuery);
+    }
+    s = t;
+    in_phrase = !in_phrase;
+  }
+  
+  free(zQuery1);
+  return SQLITE_OK;
+}
+
+/* Perform a full-text query; return a list of documents in [pResult]. */
+static int fulltext_query(fulltext_vtab *v, const char *zQuery,
+                          DocList **pResult){
+  Query q;
+  int phrase_start = -1;
+  int i;
+  sqlite3_stmt *pSelect = NULL;
+  DocList *d = NULL;
+
+  int rc = parse_query(v, zQuery, &q);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Merge terms. */
+  for(i = 0 ; i < q.nTerms ; ++i){
+    /* In each merge step, we need to generate positions whenever we're
+     * processing a phrase which hasn't ended yet. */
+    int need_positions = i<q.nTerms-1 && !q.pTerm[i+1].is_phrase;
+    DocList *next = docListNew(need_positions ? DL_POSITIONS : DL_DOCIDS);
+    if( q.pTerm[i].is_phrase ){
+      phrase_start = i;
+    }
+    rc = query_merge(v, &pSelect, q.pTerm[i].zTerm, d, i - phrase_start, next);
+    if( rc!=SQLITE_OK ) break;
+    if( d!=NULL ){
+      docListDelete(d);
+    }
+    d = next;
+  }
+
+  sqlite3_finalize(pSelect);
+  query_free(&q);
+  *pResult = d;
+  return rc;
+}
+
+static int fulltextFilter(sqlite3_vtab_cursor *pCursor,
+                          int idxNum, const char *idxStr,
+                          int argc, sqlite3_value **argv){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+  int rc;
+  const char *zStatement;
+
+  c->iCursorType = idxNum;
+  switch( idxNum ){
+    case QUERY_GENERIC:
+      zStatement = "select rowid, content from %_content";
+      break;
+
+    case QUERY_FULLTEXT:   /* full-text search */
+    {
+      const char *zQuery = (const char *)sqlite3_value_text(argv[0]);
+      DocList *pResult;
+      assert( argc==1 );
+      rc = fulltext_query(v, zQuery, &pResult);
+      if( rc!=SQLITE_OK ) return rc;
+      readerInit(&c->result, pResult);
+      zStatement = "select rowid, content from %_content where rowid = ?";
+      break;
+    }
+
+    default:
+      assert( 0 );
+  }
+
+  rc = sql_prepare(v->db, v->zName, &c->pStmt, zStatement);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return fulltextNext(pCursor);
+}
+
+static int fulltextEof(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  return c->eof;
+}
+
+static int fulltextColumn(sqlite3_vtab_cursor *pCursor,
+                          sqlite3_context *pContext, int idxCol){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  const char *s;
+
+  assert( idxCol==0 );
+  s = (const char *) sqlite3_column_text(c->pStmt, 1);
+  sqlite3_result_text(pContext, s, -1, SQLITE_TRANSIENT);
+
+  return SQLITE_OK;
+}
+
+static int fulltextRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+
+  *pRowid = sqlite3_column_int64(c->pStmt, 0);
+  return SQLITE_OK;
+}
+
+/* Build a hash table containing all terms in zText. */
+static int build_terms(Hash *terms, sqlite3_tokenizer *pTokenizer,
+                       const char *zText, sqlite_int64 iDocid){
+  sqlite3_tokenizer_cursor *pCursor;
+  const char *pToken;
+  int nTokenBytes;
+  int iStartOffset, iEndOffset, iPosition;
+
+  int rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+
+  pCursor->pTokenizer = pTokenizer;
+  HashInit(terms, HASH_STRING, 1);
+  while( SQLITE_OK==pTokenizer->pModule->xNext(pCursor,
+                                               &pToken, &nTokenBytes,
+                                               &iStartOffset, &iEndOffset,
+                                               &iPosition) ){
+    DocList *p;
+
+    /* Positions can't be negative; we use -1 as a terminator internally. */
+    if( iPosition<0 ) {
+      rc = SQLITE_ERROR;  
+      goto err;
+    }
+
+    p = HashFind(terms, pToken, nTokenBytes);
+    if( p==NULL ){
+      p = docListNew(DL_POSITIONS_OFFSETS);
+      docListAddDocid(p, iDocid);
+      HashInsert(terms, pToken, nTokenBytes, p);
+    }
+    docListAddPosOffset(p, iPosition, iStartOffset, iEndOffset);
+  }
+
+err:
+  /* TODO(shess) Check return?  Should this be able to cause errors at
+  ** this point?  Actually, same question about sqlite3_finalize(),
+  ** though one could argue that failure there means that the data is
+  ** not durable.  *ponder*
+  */
+  pTokenizer->pModule->xClose(pCursor);
+  return rc;
+}
+/* Update the %_terms table to map the term [zTerm] to the given rowid. */
+static int index_insert_term(fulltext_vtab *v, const char *zTerm, int nTerm,
+                             sqlite_int64 iDocid, DocList *p){
+  sqlite_int64 iFirst;
+  sqlite_int64 iIndexRow;
+  DocList doclist;
+
+  int rc = term_chunk_select(v, zTerm, nTerm, iDocid, &iFirst);
+  if( rc==SQLITE_DONE ){
+    docListInit(&doclist, DL_POSITIONS_OFFSETS, 0, 0);
+    if( docListUpdate(&doclist, iDocid, p) ){
+      rc = term_insert(v, zTerm, nTerm, iDocid, &doclist);
+      docListDestroy(&doclist);
+      return rc;
+    }
+    return SQLITE_OK;
+  }
+  if( rc!=SQLITE_ROW ) return SQLITE_ERROR;
+
+  /* This word is in the index; add this document ID to its blob. */
+
+  rc = term_select(v, zTerm, nTerm, iFirst, &iIndexRow, &doclist);
+  if( rc!=SQLITE_OK ) return rc;
+
+  if( docListUpdate(&doclist, iDocid, p) ){
+    /* If the blob is too big, split it in half. */
+    if( doclist.nData>CHUNK_MAX ){
+      DocList half;
+      if( docListSplit(&doclist, &half) ){
+        rc = term_insert(v, zTerm, nTerm, firstDocid(&half), &half);
+        docListDestroy(&half);
+        if( rc!=SQLITE_OK ) goto err;
+      }
+    }
+    rc = term_update(v, iIndexRow, &doclist);
+  }
+
+err:
+  docListDestroy(&doclist);
+  return rc;
+}
+
+/* Insert a row into the full-text index; set *piRowid to be the ID of the
+ * new row. */
+static int index_insert(fulltext_vtab *v,
+                        sqlite3_value *pRequestRowid, const char *zText,
+                        sqlite_int64 *piRowid){
+  Hash terms;  /* maps term string -> PosList */
+  HashElem *e;
+
+  int rc = content_insert(v, pRequestRowid, zText, -1);
+  if( rc!=SQLITE_OK ) return rc;
+  *piRowid = sqlite3_last_insert_rowid(v->db);
+
+  if( !zText ) return SQLITE_OK;   /* nothing to index */
+
+  rc = build_terms(&terms, v->pTokenizer, zText, *piRowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(e=HashFirst(&terms); e; e=HashNext(e)){
+    DocList *p = HashData(e);
+    rc = index_insert_term(v, HashKey(e), HashKeysize(e), *piRowid, p);
+    if( rc!=SQLITE_OK ) break;
+  }
+
+  for(e=HashFirst(&terms); e; e=HashNext(e)){
+    DocList *p = HashData(e);
+    docListDelete(p);
+  }
+  HashClear(&terms);
+  return rc;
+}
+
+static int index_delete_term(fulltext_vtab *v, const char *zTerm, int nTerm,
+                             sqlite_int64 iDocid){
+  sqlite_int64 iFirst;
+  sqlite_int64 iIndexRow;
+  DocList doclist;
+
+  int rc = term_chunk_select(v, zTerm, nTerm, iDocid, &iFirst);
+  if( rc!=SQLITE_ROW ) return SQLITE_ERROR;
+
+  rc = term_select(v, zTerm, nTerm, iFirst, &iIndexRow, &doclist);
+  if( rc!=SQLITE_OK ) return rc;
+
+  if( docListUpdate(&doclist, iDocid, NULL) ){
+    if( doclist.nData>0 ){
+      rc = term_update(v, iIndexRow, &doclist);
+    } else {  /* empty posting list */
+      rc = term_delete(v, iIndexRow);
+    }
+  }
+  docListDestroy(&doclist);
+  return rc;
+}
+
+/* Delete a row from the full-text index. */
+static int index_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  char *zText;
+  Hash terms;
+  HashElem *e;
+
+  int rc = content_select(v, iRow, &zText);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = build_terms(&terms, v->pTokenizer, zText, iRow);
+  free(zText);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(e=HashFirst(&terms); e; e=HashNext(e)){
+    rc = index_delete_term(v, HashKey(e), HashKeysize(e), iRow);
+    if( rc!=SQLITE_OK ) break;
+  }
+  for(e=HashFirst(&terms); e; e=HashNext(e)){
+    DocList *p = HashData(e);
+    docListDelete(p);
+  }
+  HashClear(&terms);
+
+  return content_delete(v, iRow);
+}
+
+static int fulltextUpdate(sqlite3_vtab *pVtab, int nArg, sqlite3_value **ppArg,
+                   sqlite_int64 *pRowid){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+
+  if( nArg<2 ){
+    return index_delete(v, sqlite3_value_int64(ppArg[0]));
+  }
+
+  if( sqlite3_value_type(ppArg[0]) != SQLITE_NULL ){
+    return SQLITE_ERROR;   /* an update; not yet supported */
+  }
+
+  assert( nArg==3 );    /* ppArg[1] = rowid, ppArg[2] = content */
+  return index_insert(v, ppArg[1],
+                      (const char *)sqlite3_value_text(ppArg[2]), pRowid);
+}
+
+static sqlite3_module fulltextModule = {
+  0,
+  fulltextCreate,
+  fulltextConnect,
+  fulltextBestIndex,
+  fulltextDisconnect,
+  fulltextDestroy,
+  fulltextOpen,
+  fulltextClose,
+  fulltextFilter,
+  fulltextNext,
+  fulltextEof,
+  fulltextColumn,
+  fulltextRowid,
+  fulltextUpdate
+};
+
+int fulltext_init(sqlite3 *db){
+ return sqlite3_create_module(db, "fulltext", &fulltextModule, 0);
+}
+
+#if !SQLITE_CORE
+int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg,
+                           const sqlite3_api_routines *pApi){
+ SQLITE_EXTENSION_INIT2(pApi)
+ return fulltext_init(db);
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.h
new file mode 100644
index 0000000..477dcab
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/fulltext.h
@@ -0,0 +1,11 @@
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+int fulltext_init(sqlite3 *db);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/simple_tokenizer.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/simple_tokenizer.c
new file mode 100644
index 0000000..d00a770
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/simple_tokenizer.c
@@ -0,0 +1,174 @@
+/*
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Implementation of the "simple" full-text-search tokenizer.
+*/
+
+#include <assert.h>
+#if !defined(__APPLE__)
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "tokenizer.h"
+
+/* Duplicate a string; the caller must free() the returned string.
+ * (We don't use strdup() since it's not part of the standard C library and
+ * may not be available everywhere.) */
+/* TODO(shess) Copied from fulltext.c, consider util.c for such
+** things. */
+static char *string_dup(const char *s){
+  char *str = malloc(strlen(s) + 1);
+  strcpy(str, s);
+  return str;
+}
+
+typedef struct simple_tokenizer {
+  sqlite3_tokenizer base;
+  const char *zDelim;          /* token delimiters */
+} simple_tokenizer;
+
+typedef struct simple_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *pInput;          /* input we are tokenizing */
+  int nBytes;                  /* size of the input */
+  const char *pCurrent;        /* current position in pInput */
+  int iToken;                  /* index of next token to be returned */
+  char *zToken;                /* storage for current token */
+  int nTokenBytes;             /* actual size of current token */
+  int nTokenAllocated;         /* space allocated to zToken buffer */
+} simple_tokenizer_cursor;
+
+static sqlite3_tokenizer_module simpleTokenizerModule;/* forward declaration */
+
+static int simpleCreate(
+  int argc, const char **argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  simple_tokenizer *t;
+
+  t = (simple_tokenizer *) malloc(sizeof(simple_tokenizer));
+  /* TODO(shess) Delimiters need to remain the same from run to run,
+  ** else we need to reindex.  One solution would be a meta-table to
+  ** track such information in the database, then we'd only want this
+  ** information on the initial create.
+  */
+  if( argc>1 ){
+    t->zDelim = string_dup(argv[1]);
+  } else {
+    /* Build a string excluding alphanumeric ASCII characters */
+    char zDelim[0x80];               /* nul-terminated, so nul not a member */
+    int i, j;
+    for(i=1, j=0; i<0x80; i++){
+      if( !isalnum(i) ){
+        zDelim[j++] = i;
+      }
+    }
+    zDelim[j++] = '\0';
+    assert( j<=sizeof(zDelim) );
+    t->zDelim = string_dup(zDelim);
+  }
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
+  simple_tokenizer *t = (simple_tokenizer *) pTokenizer;
+
+  free((void *) t->zDelim);
+  free(t);
+
+  return SQLITE_OK;
+}
+
+static int simpleOpen(
+  sqlite3_tokenizer *pTokenizer,
+  const char *pInput, int nBytes,
+  sqlite3_tokenizer_cursor **ppCursor
+){
+  simple_tokenizer_cursor *c;
+
+  c = (simple_tokenizer_cursor *) malloc(sizeof(simple_tokenizer_cursor));
+  c->pInput = pInput;
+  c->nBytes = nBytes<0 ? (int) strlen(pInput) : nBytes;
+  c->pCurrent = c->pInput;        /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->zToken = NULL;               /* no space allocated, yet. */
+  c->nTokenBytes = 0;
+  c->nTokenAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+
+  if( NULL!=c->zToken ){
+    free(c->zToken);
+  }
+  free(c);
+
+  return SQLITE_OK;
+}
+
+static int simpleNext(
+  sqlite3_tokenizer_cursor *pCursor,
+  const char **ppToken, int *pnBytes,
+  int *piStartOffset, int *piEndOffset, int *piPosition
+){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
+  int ii;
+
+  while( c->pCurrent-c->pInput<c->nBytes ){
+    int n = (int) strcspn(c->pCurrent, t->zDelim);
+    if( n>0 ){
+      if( n+1>c->nTokenAllocated ){
+        c->zToken = realloc(c->zToken, n+1);
+      }
+      for(ii=0; ii<n; ii++){
+        /* TODO(shess) This needs expansion to handle UTF-8
+        ** case-insensitivity.
+        */
+        char ch = c->pCurrent[ii];
+        c->zToken[ii] = (unsigned char)ch<0x80 ? tolower(ch) : ch;
+      }
+      c->zToken[n] = '\0';
+      *ppToken = c->zToken;
+      *pnBytes = n;
+      *piStartOffset = (int) (c->pCurrent-c->pInput);
+      *piEndOffset = *piStartOffset+n;
+      *piPosition = c->iToken++;
+      c->pCurrent += n + 1;
+
+      return SQLITE_OK;
+    }
+    c->pCurrent += n + 1;
+    /* TODO(shess) could strspn() to skip delimiters en masse.  Needs
+    ** to happen in two places, though, which is annoying.
+    */
+  }
+  return SQLITE_DONE;
+}
+
+static sqlite3_tokenizer_module simpleTokenizerModule = {
+  0,
+  simpleCreate,
+  simpleDestroy,
+  simpleOpen,
+  simpleClose,
+  simpleNext,
+};
+
+void get_simple_tokenizer_module(
+  sqlite3_tokenizer_module **ppModule
+){
+  *ppModule = &simpleTokenizerModule;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts1/tokenizer.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/tokenizer.h
new file mode 100644
index 0000000..1d7bd1f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts1/tokenizer.h
@@ -0,0 +1,89 @@
+/*
+** 2006 July 10
+**
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Defines the interface to tokenizers used by fulltext-search.  There
+** are three basic components:
+**
+** sqlite3_tokenizer_module is a singleton defining the tokenizer
+** interface functions.  This is essentially the class structure for
+** tokenizers.
+**
+** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
+** including customization information defined at creation time.
+**
+** sqlite3_tokenizer_cursor is generated by a tokenizer to generate
+** tokens from a particular input.
+*/
+#ifndef _TOKENIZER_H_
+#define _TOKENIZER_H_
+
+/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
+** If tokenizers are to be allowed to call sqlite3_*() functions, then
+** we will need a way to register the API consistently.
+*/
+#include "sqlite3.h"
+
+/*
+** Structures used by the tokenizer interface.
+*/
+typedef struct sqlite3_tokenizer sqlite3_tokenizer;
+typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
+typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module;
+
+struct sqlite3_tokenizer_module {
+  int iVersion;                  /* currently 0 */
+
+  /*
+  ** Create and destroy a tokenizer.  argc/argv are passed down from
+  ** the fulltext virtual table creation to allow customization.
+  */
+  int (*xCreate)(int argc, const char **argv,
+                 sqlite3_tokenizer **ppTokenizer);
+  int (*xDestroy)(sqlite3_tokenizer *pTokenizer);
+
+  /*
+  ** Tokenize a particular input.  Call xOpen() to prepare to
+  ** tokenize, xNext() repeatedly until it returns SQLITE_DONE, then
+  ** xClose() to free any internal state.  The pInput passed to
+  ** xOpen() must exist until the cursor is closed.  The ppToken
+  ** result from xNext() is only valid until the next call to xNext()
+  ** or until xClose() is called.
+  */
+  /* TODO(shess) current implementation requires pInput to be
+  ** nul-terminated.  This should either be fixed, or pInput/nBytes
+  ** should be converted to zInput.
+  */
+  int (*xOpen)(sqlite3_tokenizer *pTokenizer,
+               const char *pInput, int nBytes,
+               sqlite3_tokenizer_cursor **ppCursor);
+  int (*xClose)(sqlite3_tokenizer_cursor *pCursor);
+  int (*xNext)(sqlite3_tokenizer_cursor *pCursor,
+               const char **ppToken, int *pnBytes,
+               int *piStartOffset, int *piEndOffset, int *piPosition);
+};
+
+struct sqlite3_tokenizer {
+  sqlite3_tokenizer_module *pModule;  /* The module for this tokenizer */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+struct sqlite3_tokenizer_cursor {
+  sqlite3_tokenizer *pTokenizer;       /* Tokenizer for this cursor. */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+/*
+** Get the module for a tokenizer which generates tokens based on a
+** set of non-token characters.  The default is to break tokens at any
+** non-alnum character, though the set of delimiters can also be
+** specified by the first argv argument to xCreate().
+*/
+/* TODO(shess) This doesn't belong here.  Need some sort of
+** registration process.
+*/
+void get_simple_tokenizer_module(sqlite3_tokenizer_module **ppModule);
+
+#endif /* _TOKENIZER_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Entries b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Entries
new file mode 100644
index 0000000..05243d8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Entries
@@ -0,0 +1,13 @@
+/README.txt/1.1/Tue Oct 10 17:37:14 2006//
+/fts2.h/1.3/Fri Nov 30 01:28:10 2007//
+/fts2_hash.c/1.2/Fri Nov 30 01:28:10 2007//
+/fts2_hash.h/1.1/Tue Oct 10 17:37:14 2006//
+/fts2_icu.c/1.1/Fri Jun 22 15:21:16 2007//
+/fts2_porter.c/1.7/Fri Nov 30 01:28:10 2007//
+/fts2_tokenizer.c/1.6/Tue Jun 26 10:55:02 2007//
+/fts2_tokenizer.h/1.3/Fri Nov 30 01:28:10 2007//
+/fts2_tokenizer1.c/1.5/Fri Nov 30 01:28:10 2007//
+/mkfts2amal.tcl/1.3/Fri Nov 30 01:28:10 2007//
+/README.tokenizers/1.3/Thu Dec 13 21:44:03 2007//
+/fts2.c/1.48/Thu Dec 13 21:45:31 2007//
+D
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Repository b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Repository
new file mode 100644
index 0000000..f52cff4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Repository
@@ -0,0 +1 @@
+sqlite/ext/fts2
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Root b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Root
new file mode 100644
index 0000000..a3ae5d0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/CVS/Root
@@ -0,0 +1 @@
+:pserver:drh@sqlite.org:/sqlite
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.tokenizers b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.tokenizers
new file mode 100644
index 0000000..98d2021
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.tokenizers
@@ -0,0 +1,133 @@
+
+1. FTS2 Tokenizers
+
+  When creating a new full-text table, FTS2 allows the user to select
+  the text tokenizer implementation to be used when indexing text
+  by specifying a "tokenizer" clause as part of the CREATE VIRTUAL TABLE
+  statement:
+
+    CREATE VIRTUAL TABLE <table-name> USING fts2(
+      <columns ...> [, tokenizer <tokenizer-name> [<tokenizer-args>]]
+    );
+
+  The built-in tokenizers (valid values to pass as <tokenizer name>) are
+  "simple" and "porter".
+
+  <tokenizer-args> should consist of zero or more white-space separated
+  arguments to pass to the selected tokenizer implementation. The 
+  interpretation of the arguments, if any, depends on the individual 
+  tokenizer.
+
+2. Custom Tokenizers
+
+  FTS2 allows users to provide custom tokenizer implementations. The 
+  interface used to create a new tokenizer is defined and described in 
+  the fts2_tokenizer.h source file.
+
+  Registering a new FTS2 tokenizer is similar to registering a new 
+  virtual table module with SQLite. The user passes a pointer to a
+  structure containing pointers to various callback functions that
+  make up the implementation of the new tokenizer type. For tokenizers,
+  the structure (defined in fts2_tokenizer.h) is called
+  "sqlite3_tokenizer_module".
+
+  FTS2 does not expose a C-function that users call to register new
+  tokenizer types with a database handle. Instead, the pointer must
+  be encoded as an SQL blob value and passed to FTS2 through the SQL
+  engine by evaluating a special scalar function, "fts2_tokenizer()".
+  The fts2_tokenizer() function may be called with one or two arguments,
+  as follows:
+
+    SELECT fts2_tokenizer(<tokenizer-name>);
+    SELECT fts2_tokenizer(<tokenizer-name>, <sqlite3_tokenizer_module ptr>);
+  
+  Where <tokenizer-name> is a string identifying the tokenizer and
+  <sqlite3_tokenizer_module ptr> is a pointer to an sqlite3_tokenizer_module
+  structure encoded as an SQL blob. If the second argument is present,
+  it is registered as tokenizer <tokenizer-name> and a copy of it
+  returned. If only one argument is passed, a pointer to the tokenizer
+  implementation currently registered as <tokenizer-name> is returned,
+  encoded as a blob. Or, if no such tokenizer exists, an SQL exception
+  (error) is raised.
+
+  SECURITY: If the fts2 extension is used in an environment where potentially
+    malicious users may execute arbitrary SQL (i.e. gears), they should be
+    prevented from invoking the fts2_tokenizer() function, possibly using the
+    authorisation callback.
+
+  See "Sample code" below for an example of calling the fts2_tokenizer()
+  function from C code.
+
+3. ICU Library Tokenizers
+
+  If this extension is compiled with the SQLITE_ENABLE_ICU pre-processor 
+  symbol defined, then there exists a built-in tokenizer named "icu" 
+  implemented using the ICU library. The first argument passed to the
+  xCreate() method (see fts2_tokenizer.h) of this tokenizer may be
+  an ICU locale identifier. For example "tr_TR" for Turkish as used
+  in Turkey, or "en_AU" for English as used in Australia. For example:
+
+    "CREATE VIRTUAL TABLE thai_text USING fts2(text, tokenizer icu th_TH)"
+
+  The ICU tokenizer implementation is very simple. It splits the input
+  text according to the ICU rules for finding word boundaries and discards
+  any tokens that consist entirely of white-space. This may be suitable
+  for some applications in some locales, but not all. If more complex
+  processing is required, for example to implement stemming or 
+  discard punctuation, this can be done by creating a tokenizer 
+  implementation that uses the ICU tokenizer as part of its implementation.
+
+  When using the ICU tokenizer this way, it is safe to overwrite the
+  contents of the strings returned by the xNext() method (see
+  fts2_tokenizer.h).
+
+4. Sample code.
+
+  The following two code samples illustrate the way C code should invoke
+  the fts2_tokenizer() scalar function:
+
+      int registerTokenizer(
+        sqlite3 *db, 
+        char *zName, 
+        const sqlite3_tokenizer_module *p
+      ){
+        int rc;
+        sqlite3_stmt *pStmt;
+        const char zSql[] = "SELECT fts2_tokenizer(?, ?)";
+      
+        rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+      
+        sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+        sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
+        sqlite3_step(pStmt);
+      
+        return sqlite3_finalize(pStmt);
+      }
+      
+      int queryTokenizer(
+        sqlite3 *db, 
+        char *zName,  
+        const sqlite3_tokenizer_module **pp
+      ){
+        int rc;
+        sqlite3_stmt *pStmt;
+        const char zSql[] = "SELECT fts2_tokenizer(?)";
+      
+        *pp = 0;
+        rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+      
+        sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+        if( SQLITE_ROW==sqlite3_step(pStmt) ){
+          if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+            memcpy(pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+          }
+        }
+      
+        return sqlite3_finalize(pStmt);
+      }
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.txt b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.txt
new file mode 100644
index 0000000..517a2a0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/README.txt
@@ -0,0 +1,4 @@
+This folder contains source code to the second full-text search
+extension for SQLite.  While the API is the same, this version uses a
+substantially different storage schema from fts1, so tables will need
+to be rebuilt.
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.c
new file mode 100644
index 0000000..1c0c02e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.c
@@ -0,0 +1,5937 @@
+/* fts2 has a design flaw which can lead to database corruption (see
+** below).  It is recommended not to use it any longer, instead use
+** fts3 (or higher).  If you believe that your use of fts2 is safe,
+** add -DSQLITE_ENABLE_BROKEN_FTS2=1 to your CFLAGS.
+*/
+#if (!defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)) \
+        && !defined(SQLITE_ENABLE_BROKEN_FTS2)
+#error fts2 has a design flaw and has been deprecated.
+#endif
+/* The flaw is that fts2 uses the content table's unaliased rowid as
+** the unique docid.  fts2 embeds the rowid in the index it builds,
+** and expects the rowid to not change.  The SQLite VACUUM operation
+** will renumber such rowids, thereby breaking fts2.  If you are using
+** fts2 in a system which has disabled VACUUM, then you can continue
+** to use it safely.  Note that PRAGMA auto_vacuum does NOT disable
+** VACUUM, though systems using auto_vacuum are unlikely to invoke
+** VACUUM.
+**
+** Unlike fts1, which is safe across VACUUM if you never delete
+** documents, fts2 has a second exposure to this flaw, in the segments
+** table.  So fts2 should be considered unsafe across VACUUM in all
+** cases.
+*/
+
+/*
+** 2006 Oct 10
+**
+** 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 is an SQLite module implementing full-text search.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS2 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS2 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
+*/
+
+/* TODO(shess) Consider exporting this comment to an HTML file or the
+** wiki.
+*/
+/* The full-text index is stored in a series of b+tree (-like)
+** structures called segments which map terms to doclists.  The
+** structures are like b+trees in layout, but are constructed from the
+** bottom up in optimal fashion and are not updatable.  Since trees
+** are built from the bottom up, things will be described from the
+** bottom up.
+**
+**
+**** Varints ****
+** The basic unit of encoding is a variable-length integer called a
+** varint.  We encode variable-length integers in little-endian order
+** using seven bits * per byte as follows:
+**
+** KEY:
+**         A = 0xxxxxxx    7 bits of data and one flag bit
+**         B = 1xxxxxxx    7 bits of data and one flag bit
+**
+**  7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** and so on.
+**
+** This is identical to how sqlite encodes varints (see util.c).
+**
+**
+**** Document lists ****
+** A doclist (document list) holds a docid-sorted list of hits for a
+** given term.  Doclists hold docids, and can optionally associate
+** token positions and offsets with docids.
+**
+** A DL_POSITIONS_OFFSETS doclist is stored like this:
+**
+** array {
+**   varint docid;
+**   array {                (position list for column 0)
+**     varint position;     (delta from previous position plus POS_BASE)
+**     varint startOffset;  (delta from previous startOffset)
+**     varint endOffset;    (delta from startOffset)
+**   }
+**   array {
+**     varint POS_COLUMN;   (marks start of position list for new column)
+**     varint column;       (index of new column)
+**     array {
+**       varint position;   (delta from previous position plus POS_BASE)
+**       varint startOffset;(delta from previous startOffset)
+**       varint endOffset;  (delta from startOffset)
+**     }
+**   }
+**   varint POS_END;        (marks end of positions for this document.
+** }
+**
+** Here, array { X } means zero or more occurrences of X, adjacent in
+** memory.  A "position" is an index of a token in the token stream
+** generated by the tokenizer, while an "offset" is a byte offset,
+** both based at 0.  Note that POS_END and POS_COLUMN occur in the
+** same logical place as the position element, and act as sentinals
+** ending a position list array.
+**
+** A DL_POSITIONS doclist omits the startOffset and endOffset
+** information.  A DL_DOCIDS doclist omits both the position and
+** offset information, becoming an array of varint-encoded docids.
+**
+** On-disk data is stored as type DL_DEFAULT, so we don't serialize
+** the type.  Due to how deletion is implemented in the segmentation
+** system, on-disk doclists MUST store at least positions.
+**
+**
+**** Segment leaf nodes ****
+** Segment leaf nodes store terms and doclists, ordered by term.  Leaf
+** nodes are written using LeafWriter, and read using LeafReader (to
+** iterate through a single leaf node's data) and LeavesReader (to
+** iterate through a segment's entire leaf layer).  Leaf nodes have
+** the format:
+**
+** varint iHeight;             (height from leaf level, always 0)
+** varint nTerm;               (length of first term)
+** char pTerm[nTerm];          (content of first term)
+** varint nDoclist;            (length of term's associated doclist)
+** char pDoclist[nDoclist];    (content of doclist)
+** array {
+**                             (further terms are delta-encoded)
+**   varint nPrefix;           (length of prefix shared with previous term)
+**   varint nSuffix;           (length of unshared suffix)
+**   char pTermSuffix[nSuffix];(unshared suffix of next term)
+**   varint nDoclist;          (length of term's associated doclist)
+**   char pDoclist[nDoclist];  (content of doclist)
+** }
+**
+** Here, array { X } means zero or more occurrences of X, adjacent in
+** memory.
+**
+** Leaf nodes are broken into blocks which are stored contiguously in
+** the %_segments table in sorted order.  This means that when the end
+** of a node is reached, the next term is in the node with the next
+** greater node id.
+**
+** New data is spilled to a new leaf node when the current node
+** exceeds LEAF_MAX bytes (default 2048).  New data which itself is
+** larger than STANDALONE_MIN (default 1024) is placed in a standalone
+** node (a leaf node with a single term and doclist).  The goal of
+** these settings is to pack together groups of small doclists while
+** making it efficient to directly access large doclists.  The
+** assumption is that large doclists represent terms which are more
+** likely to be query targets.
+**
+** TODO(shess) It may be useful for blocking decisions to be more
+** dynamic.  For instance, it may make more sense to have a 2.5k leaf
+** node rather than splitting into 2k and .5k nodes.  My intuition is
+** that this might extend through 2x or 4x the pagesize.
+**
+**
+**** Segment interior nodes ****
+** Segment interior nodes store blockids for subtree nodes and terms
+** to describe what data is stored by the each subtree.  Interior
+** nodes are written using InteriorWriter, and read using
+** InteriorReader.  InteriorWriters are created as needed when
+** SegmentWriter creates new leaf nodes, or when an interior node
+** itself grows too big and must be split.  The format of interior
+** nodes:
+**
+** varint iHeight;           (height from leaf level, always >0)
+** varint iBlockid;          (block id of node's leftmost subtree)
+** optional {
+**   varint nTerm;           (length of first term)
+**   char pTerm[nTerm];      (content of first term)
+**   array {
+**                                (further terms are delta-encoded)
+**     varint nPrefix;            (length of shared prefix with previous term)
+**     varint nSuffix;            (length of unshared suffix)
+**     char pTermSuffix[nSuffix]; (unshared suffix of next term)
+**   }
+** }
+**
+** Here, optional { X } means an optional element, while array { X }
+** means zero or more occurrences of X, adjacent in memory.
+**
+** An interior node encodes n terms separating n+1 subtrees.  The
+** subtree blocks are contiguous, so only the first subtree's blockid
+** is encoded.  The subtree at iBlockid will contain all terms less
+** than the first term encoded (or all terms if no term is encoded).
+** Otherwise, for terms greater than or equal to pTerm[i] but less
+** than pTerm[i+1], the subtree for that term will be rooted at
+** iBlockid+i.  Interior nodes only store enough term data to
+** distinguish adjacent children (if the rightmost term of the left
+** child is "something", and the leftmost term of the right child is
+** "wicked", only "w" is stored).
+**
+** New data is spilled to a new interior node at the same height when
+** the current node exceeds INTERIOR_MAX bytes (default 2048).
+** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing
+** interior nodes and making the tree too skinny.  The interior nodes
+** at a given height are naturally tracked by interior nodes at
+** height+1, and so on.
+**
+**
+**** Segment directory ****
+** The segment directory in table %_segdir stores meta-information for
+** merging and deleting segments, and also the root node of the
+** segment's tree.
+**
+** The root node is the top node of the segment's tree after encoding
+** the entire segment, restricted to ROOT_MAX bytes (default 1024).
+** This could be either a leaf node or an interior node.  If the top
+** node requires more than ROOT_MAX bytes, it is flushed to %_segments
+** and a new root interior node is generated (which should always fit
+** within ROOT_MAX because it only needs space for 2 varints, the
+** height and the blockid of the previous root).
+**
+** The meta-information in the segment directory is:
+**   level               - segment level (see below)
+**   idx                 - index within level
+**                       - (level,idx uniquely identify a segment)
+**   start_block         - first leaf node
+**   leaves_end_block    - last leaf node
+**   end_block           - last block (including interior nodes)
+**   root                - contents of root node
+**
+** If the root node is a leaf node, then start_block,
+** leaves_end_block, and end_block are all 0.
+**
+**
+**** Segment merging ****
+** To amortize update costs, segments are groups into levels and
+** merged in matches.  Each increase in level represents exponentially
+** more documents.
+**
+** New documents (actually, document updates) are tokenized and
+** written individually (using LeafWriter) to a level 0 segment, with
+** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
+** level 0 segments are merged into a single level 1 segment.  Level 1
+** is populated like level 0, and eventually MERGE_COUNT level 1
+** segments are merged to a single level 2 segment (representing
+** MERGE_COUNT^2 updates), and so on.
+**
+** A segment merge traverses all segments at a given level in
+** parallel, performing a straightforward sorted merge.  Since segment
+** leaf nodes are written in to the %_segments table in order, this
+** merge traverses the underlying sqlite disk structures efficiently.
+** After the merge, all segment blocks from the merged level are
+** deleted.
+**
+** MERGE_COUNT controls how often we merge segments.  16 seems to be
+** somewhat of a sweet spot for insertion performance.  32 and 64 show
+** very similar performance numbers to 16 on insertion, though they're
+** a tiny bit slower (perhaps due to more overhead in merge-time
+** sorting).  8 is about 20% slower than 16, 4 about 50% slower than
+** 16, 2 about 66% slower than 16.
+**
+** At query time, high MERGE_COUNT increases the number of segments
+** which need to be scanned and merged.  For instance, with 100k docs
+** inserted:
+**
+**    MERGE_COUNT   segments
+**       16           25
+**        8           12
+**        4           10
+**        2            6
+**
+** This appears to have only a moderate impact on queries for very
+** frequent terms (which are somewhat dominated by segment merge
+** costs), and infrequent and non-existent terms still seem to be fast
+** even with many segments.
+**
+** TODO(shess) That said, it would be nice to have a better query-side
+** argument for MERGE_COUNT of 16.  Also, it is possible/likely that
+** optimizations to things like doclist merging will swing the sweet
+** spot around.
+**
+**
+**
+**** Handling of deletions and updates ****
+** Since we're using a segmented structure, with no docid-oriented
+** index into the term index, we clearly cannot simply update the term
+** index when a document is deleted or updated.  For deletions, we
+** write an empty doclist (varint(docid) varint(POS_END)), for updates
+** we simply write the new doclist.  Segment merges overwrite older
+** data for a particular docid with newer data, so deletes or updates
+** will eventually overtake the earlier data and knock it out.  The
+** query logic likewise merges doclists so that newer data knocks out
+** older data.
+**
+** TODO(shess) Provide a VACUUM type operation to clear out all
+** deletions and duplications.  This would basically be a forced merge
+** into a single segment.
+*/
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+
+#if defined(SQLITE_ENABLE_FTS2) && !defined(SQLITE_CORE)
+# define SQLITE_CORE 1
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts2.h"
+#include "fts2_hash.h"
+#include "fts2_tokenizer.h"
+#include "sqlite3.h"
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+
+/* TODO(shess) MAN, this thing needs some refactoring.  At minimum, it
+** would be nice to order the file better, perhaps something along the
+** lines of:
+**
+**  - utility functions
+**  - table setup functions
+**  - table update functions
+**  - table query functions
+**
+** Put the query functions last because they're likely to reference
+** typedefs or functions from the table update section.
+*/
+
+#if 0
+# define TRACE(A)  printf A; fflush(stdout)
+#else
+# define TRACE(A)
+#endif
+
+/* It is not safe to call isspace(), tolower(), or isalnum() on
+** hi-bit-set characters.  This is the same solution used in the
+** tokenizer.
+*/
+/* TODO(shess) The snippet-generation code should be using the
+** tokenizer-generated tokens rather than doing its own local
+** tokenization.
+*/
+/* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
+static int safe_isspace(char c){
+  return (c&0x80)==0 ? isspace(c) : 0;
+}
+static int safe_tolower(char c){
+  return (c&0x80)==0 ? tolower(c) : c;
+}
+static int safe_isalnum(char c){
+  return (c&0x80)==0 ? isalnum(c) : 0;
+}
+
+typedef enum DocListType {
+  DL_DOCIDS,              /* docids only */
+  DL_POSITIONS,           /* docids + positions */
+  DL_POSITIONS_OFFSETS    /* docids + positions + offsets */
+} DocListType;
+
+/*
+** By default, only positions and not offsets are stored in the doclists.
+** To change this so that offsets are stored too, compile with
+**
+**          -DDL_DEFAULT=DL_POSITIONS_OFFSETS
+**
+** If DL_DEFAULT is set to DL_DOCIDS, your table can only be inserted
+** into (no deletes or updates).
+*/
+#ifndef DL_DEFAULT
+# define DL_DEFAULT DL_POSITIONS
+#endif
+
+enum {
+  POS_END = 0,        /* end of this position list */
+  POS_COLUMN,         /* followed by new column number */
+  POS_BASE
+};
+
+/* MERGE_COUNT controls how often we merge segments (see comment at
+** top of file).
+*/
+#define MERGE_COUNT 16
+
+/* utility functions */
+
+/* CLEAR() and SCRAMBLE() abstract memset() on a pointer to a single
+** record to prevent errors of the form:
+**
+** my_function(SomeType *b){
+**   memset(b, '\0', sizeof(b));  // sizeof(b)!=sizeof(*b)
+** }
+*/
+/* TODO(shess) Obvious candidates for a header file. */
+#define CLEAR(b) memset(b, '\0', sizeof(*(b)))
+
+#ifndef NDEBUG
+#  define SCRAMBLE(b) memset(b, 0x55, sizeof(*(b)))
+#else
+#  define SCRAMBLE(b)
+#endif
+
+/* We may need up to VARINT_MAX bytes to store an encoded 64-bit integer. */
+#define VARINT_MAX 10
+
+/* Write a 64-bit variable-length integer to memory starting at p[0].
+ * The length of data written will be between 1 and VARINT_MAX bytes.
+ * The number of bytes written is returned. */
+static int putVarint(char *p, sqlite_int64 v){
+  unsigned char *q = (unsigned char *) p;
+  sqlite_uint64 vu = v;
+  do{
+    *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
+    vu >>= 7;
+  }while( vu!=0 );
+  q[-1] &= 0x7f;  /* turn off high bit in final byte */
+  assert( q - (unsigned char *)p <= VARINT_MAX );
+  return (int) (q - (unsigned char *)p);
+}
+
+/* Read a 64-bit variable-length integer from memory starting at p[0].
+ * Return the number of bytes read, or 0 on error.
+ * The value is stored in *v. */
+static int getVarint(const char *p, sqlite_int64 *v){
+  const unsigned char *q = (const unsigned char *) p;
+  sqlite_uint64 x = 0, y = 1;
+  while( (*q & 0x80) == 0x80 ){
+    x += y * (*q++ & 0x7f);
+    y <<= 7;
+    if( q - (unsigned char *)p >= VARINT_MAX ){  /* bad data */
+      assert( 0 );
+      return 0;
+    }
+  }
+  x += y * (*q++);
+  *v = (sqlite_int64) x;
+  return (int) (q - (unsigned char *)p);
+}
+
+static int getVarint32(const char *p, int *pi){
+ sqlite_int64 i;
+ int ret = getVarint(p, &i);
+ *pi = (int) i;
+ assert( *pi==i );
+ return ret;
+}
+
+/*******************************************************************/
+/* DataBuffer is used to collect data into a buffer in piecemeal
+** fashion.  It implements the usual distinction between amount of
+** data currently stored (nData) and buffer capacity (nCapacity).
+**
+** dataBufferInit - create a buffer with given initial capacity.
+** dataBufferReset - forget buffer's data, retaining capacity.
+** dataBufferDestroy - free buffer's data.
+** dataBufferExpand - expand capacity without adding data.
+** dataBufferAppend - append data.
+** dataBufferAppend2 - append two pieces of data at once.
+** dataBufferReplace - replace buffer's data.
+*/
+typedef struct DataBuffer {
+  char *pData;          /* Pointer to malloc'ed buffer. */
+  int nCapacity;        /* Size of pData buffer. */
+  int nData;            /* End of data loaded into pData. */
+} DataBuffer;
+
+static void dataBufferInit(DataBuffer *pBuffer, int nCapacity){
+  assert( nCapacity>=0 );
+  pBuffer->nData = 0;
+  pBuffer->nCapacity = nCapacity;
+  pBuffer->pData = nCapacity==0 ? NULL : malloc(nCapacity);
+}
+static void dataBufferReset(DataBuffer *pBuffer){
+  pBuffer->nData = 0;
+}
+static void dataBufferDestroy(DataBuffer *pBuffer){
+  if( pBuffer->pData!=NULL ) free(pBuffer->pData);
+  SCRAMBLE(pBuffer);
+}
+static void dataBufferExpand(DataBuffer *pBuffer, int nAddCapacity){
+  assert( nAddCapacity>0 );
+  /* TODO(shess) Consider expanding more aggressively.  Note that the
+  ** underlying malloc implementation may take care of such things for
+  ** us already.
+  */
+  if( pBuffer->nData+nAddCapacity>pBuffer->nCapacity ){
+    pBuffer->nCapacity = pBuffer->nData+nAddCapacity;
+    pBuffer->pData = realloc(pBuffer->pData, pBuffer->nCapacity);
+  }
+}
+static void dataBufferAppend(DataBuffer *pBuffer,
+                             const char *pSource, int nSource){
+  assert( nSource>0 && pSource!=NULL );
+  dataBufferExpand(pBuffer, nSource);
+  memcpy(pBuffer->pData+pBuffer->nData, pSource, nSource);
+  pBuffer->nData += nSource;
+}
+static void dataBufferAppend2(DataBuffer *pBuffer,
+                              const char *pSource1, int nSource1,
+                              const char *pSource2, int nSource2){
+  assert( nSource1>0 && pSource1!=NULL );
+  assert( nSource2>0 && pSource2!=NULL );
+  dataBufferExpand(pBuffer, nSource1+nSource2);
+  memcpy(pBuffer->pData+pBuffer->nData, pSource1, nSource1);
+  memcpy(pBuffer->pData+pBuffer->nData+nSource1, pSource2, nSource2);
+  pBuffer->nData += nSource1+nSource2;
+}
+static void dataBufferReplace(DataBuffer *pBuffer,
+                              const char *pSource, int nSource){
+  dataBufferReset(pBuffer);
+  dataBufferAppend(pBuffer, pSource, nSource);
+}
+
+/* StringBuffer is a null-terminated version of DataBuffer. */
+typedef struct StringBuffer {
+  DataBuffer b;            /* Includes null terminator. */
+} StringBuffer;
+
+static void initStringBuffer(StringBuffer *sb){
+  dataBufferInit(&sb->b, 100);
+  dataBufferReplace(&sb->b, "", 1);
+}
+static int stringBufferLength(StringBuffer *sb){
+  return sb->b.nData-1;
+}
+static char *stringBufferData(StringBuffer *sb){
+  return sb->b.pData;
+}
+static void stringBufferDestroy(StringBuffer *sb){
+  dataBufferDestroy(&sb->b);
+}
+
+static void nappend(StringBuffer *sb, const char *zFrom, int nFrom){
+  assert( sb->b.nData>0 );
+  if( nFrom>0 ){
+    sb->b.nData--;
+    dataBufferAppend2(&sb->b, zFrom, nFrom, "", 1);
+  }
+}
+static void append(StringBuffer *sb, const char *zFrom){
+  nappend(sb, zFrom, strlen(zFrom));
+}
+
+/* Append a list of strings separated by commas. */
+static void appendList(StringBuffer *sb, int nString, char **azString){
+  int i;
+  for(i=0; i<nString; ++i){
+    if( i>0 ) append(sb, ", ");
+    append(sb, azString[i]);
+  }
+}
+
+static int endsInWhiteSpace(StringBuffer *p){
+  return stringBufferLength(p)>0 &&
+    safe_isspace(stringBufferData(p)[stringBufferLength(p)-1]);
+}
+
+/* If the StringBuffer ends in something other than white space, add a
+** single space character to the end.
+*/
+static void appendWhiteSpace(StringBuffer *p){
+  if( stringBufferLength(p)==0 ) return;
+  if( !endsInWhiteSpace(p) ) append(p, " ");
+}
+
+/* Remove white space from the end of the StringBuffer */
+static void trimWhiteSpace(StringBuffer *p){
+  while( endsInWhiteSpace(p) ){
+    p->b.pData[--p->b.nData-1] = '\0';
+  }
+}
+
+/*******************************************************************/
+/* DLReader is used to read document elements from a doclist.  The
+** current docid is cached, so dlrDocid() is fast.  DLReader does not
+** own the doclist buffer.
+**
+** dlrAtEnd - true if there's no more data to read.
+** dlrDocid - docid of current document.
+** dlrDocData - doclist data for current document (including docid).
+** dlrDocDataBytes - length of same.
+** dlrAllDataBytes - length of all remaining data.
+** dlrPosData - position data for current document.
+** dlrPosDataLen - length of pos data for current document (incl POS_END).
+** dlrStep - step to current document.
+** dlrInit - initial for doclist of given type against given data.
+** dlrDestroy - clean up.
+**
+** Expected usage is something like:
+**
+**   DLReader reader;
+**   dlrInit(&reader, pData, nData);
+**   while( !dlrAtEnd(&reader) ){
+**     // calls to dlrDocid() and kin.
+**     dlrStep(&reader);
+**   }
+**   dlrDestroy(&reader);
+*/
+typedef struct DLReader {
+  DocListType iType;
+  const char *pData;
+  int nData;
+
+  sqlite_int64 iDocid;
+  int nElement;
+} DLReader;
+
+static int dlrAtEnd(DLReader *pReader){
+  assert( pReader->nData>=0 );
+  return pReader->nData==0;
+}
+static sqlite_int64 dlrDocid(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->iDocid;
+}
+static const char *dlrDocData(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->pData;
+}
+static int dlrDocDataBytes(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nElement;
+}
+static int dlrAllDataBytes(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nData;
+}
+/* TODO(shess) Consider adding a field to track iDocid varint length
+** to make these two functions faster.  This might matter (a tiny bit)
+** for queries.
+*/
+static const char *dlrPosData(DLReader *pReader){
+  sqlite_int64 iDummy;
+  int n = getVarint(pReader->pData, &iDummy);
+  assert( !dlrAtEnd(pReader) );
+  return pReader->pData+n;
+}
+static int dlrPosDataLen(DLReader *pReader){
+  sqlite_int64 iDummy;
+  int n = getVarint(pReader->pData, &iDummy);
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nElement-n;
+}
+static void dlrStep(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+
+  /* Skip past current doclist element. */
+  assert( pReader->nElement<=pReader->nData );
+  pReader->pData += pReader->nElement;
+  pReader->nData -= pReader->nElement;
+
+  /* If there is more data, read the next doclist element. */
+  if( pReader->nData!=0 ){
+    sqlite_int64 iDocidDelta;
+    int iDummy, n = getVarint(pReader->pData, &iDocidDelta);
+    pReader->iDocid += iDocidDelta;
+    if( pReader->iType>=DL_POSITIONS ){
+      assert( n<pReader->nData );
+      while( 1 ){
+        n += getVarint32(pReader->pData+n, &iDummy);
+        assert( n<=pReader->nData );
+        if( iDummy==POS_END ) break;
+        if( iDummy==POS_COLUMN ){
+          n += getVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
+        }else if( pReader->iType==DL_POSITIONS_OFFSETS ){
+          n += getVarint32(pReader->pData+n, &iDummy);
+          n += getVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
+        }
+      }
+    }
+    pReader->nElement = n;
+    assert( pReader->nElement<=pReader->nData );
+  }
+}
+static void dlrInit(DLReader *pReader, DocListType iType,
+                    const char *pData, int nData){
+  assert( pData!=NULL && nData!=0 );
+  pReader->iType = iType;
+  pReader->pData = pData;
+  pReader->nData = nData;
+  pReader->nElement = 0;
+  pReader->iDocid = 0;
+
+  /* Load the first element's data.  There must be a first element. */
+  dlrStep(pReader);
+}
+static void dlrDestroy(DLReader *pReader){
+  SCRAMBLE(pReader);
+}
+
+#ifndef NDEBUG
+/* Verify that the doclist can be validly decoded.  Also returns the
+** last docid found because it is convenient in other assertions for
+** DLWriter.
+*/
+static void docListValidate(DocListType iType, const char *pData, int nData,
+                            sqlite_int64 *pLastDocid){
+  sqlite_int64 iPrevDocid = 0;
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+  while( nData!=0 ){
+    sqlite_int64 iDocidDelta;
+    int n = getVarint(pData, &iDocidDelta);
+    iPrevDocid += iDocidDelta;
+    if( iType>DL_DOCIDS ){
+      int iDummy;
+      while( 1 ){
+        n += getVarint32(pData+n, &iDummy);
+        if( iDummy==POS_END ) break;
+        if( iDummy==POS_COLUMN ){
+          n += getVarint32(pData+n, &iDummy);
+        }else if( iType>DL_POSITIONS ){
+          n += getVarint32(pData+n, &iDummy);
+          n += getVarint32(pData+n, &iDummy);
+        }
+        assert( n<=nData );
+      }
+    }
+    assert( n<=nData );
+    pData += n;
+    nData -= n;
+  }
+  if( pLastDocid ) *pLastDocid = iPrevDocid;
+}
+#define ASSERT_VALID_DOCLIST(i, p, n, o) docListValidate(i, p, n, o)
+#else
+#define ASSERT_VALID_DOCLIST(i, p, n, o) assert( 1 )
+#endif
+
+/*******************************************************************/
+/* DLWriter is used to write doclist data to a DataBuffer.  DLWriter
+** always appends to the buffer and does not own it.
+**
+** dlwInit - initialize to write a given type doclistto a buffer.
+** dlwDestroy - clear the writer's memory.  Does not free buffer.
+** dlwAppend - append raw doclist data to buffer.
+** dlwCopy - copy next doclist from reader to writer.
+** dlwAdd - construct doclist element and append to buffer.
+**    Only apply dlwAdd() to DL_DOCIDS doclists (else use PLWriter).
+*/
+typedef struct DLWriter {
+  DocListType iType;
+  DataBuffer *b;
+  sqlite_int64 iPrevDocid;
+#ifndef NDEBUG
+  int has_iPrevDocid;
+#endif
+} DLWriter;
+
+static void dlwInit(DLWriter *pWriter, DocListType iType, DataBuffer *b){
+  pWriter->b = b;
+  pWriter->iType = iType;
+  pWriter->iPrevDocid = 0;
+#ifndef NDEBUG
+  pWriter->has_iPrevDocid = 0;
+#endif
+}
+static void dlwDestroy(DLWriter *pWriter){
+  SCRAMBLE(pWriter);
+}
+/* iFirstDocid is the first docid in the doclist in pData.  It is
+** needed because pData may point within a larger doclist, in which
+** case the first item would be delta-encoded.
+**
+** iLastDocid is the final docid in the doclist in pData.  It is
+** needed to create the new iPrevDocid for future delta-encoding.  The
+** code could decode the passed doclist to recreate iLastDocid, but
+** the only current user (docListMerge) already has decoded this
+** information.
+*/
+/* TODO(shess) This has become just a helper for docListMerge.
+** Consider a refactor to make this cleaner.
+*/
+static void dlwAppend(DLWriter *pWriter,
+                      const char *pData, int nData,
+                      sqlite_int64 iFirstDocid, sqlite_int64 iLastDocid){
+  sqlite_int64 iDocid = 0;
+  char c[VARINT_MAX];
+  int nFirstOld, nFirstNew;     /* Old and new varint len of first docid. */
+#ifndef NDEBUG
+  sqlite_int64 iLastDocidDelta;
+#endif
+
+  /* Recode the initial docid as delta from iPrevDocid. */
+  nFirstOld = getVarint(pData, &iDocid);
+  assert( nFirstOld<nData || (nFirstOld==nData && pWriter->iType==DL_DOCIDS) );
+  nFirstNew = putVarint(c, iFirstDocid-pWriter->iPrevDocid);
+
+  /* Verify that the incoming doclist is valid AND that it ends with
+  ** the expected docid.  This is essential because we'll trust this
+  ** docid in future delta-encoding.
+  */
+  ASSERT_VALID_DOCLIST(pWriter->iType, pData, nData, &iLastDocidDelta);
+  assert( iLastDocid==iFirstDocid-iDocid+iLastDocidDelta );
+
+  /* Append recoded initial docid and everything else.  Rest of docids
+  ** should have been delta-encoded from previous initial docid.
+  */
+  if( nFirstOld<nData ){
+    dataBufferAppend2(pWriter->b, c, nFirstNew,
+                      pData+nFirstOld, nData-nFirstOld);
+  }else{
+    dataBufferAppend(pWriter->b, c, nFirstNew);
+  }
+  pWriter->iPrevDocid = iLastDocid;
+}
+static void dlwCopy(DLWriter *pWriter, DLReader *pReader){
+  dlwAppend(pWriter, dlrDocData(pReader), dlrDocDataBytes(pReader),
+            dlrDocid(pReader), dlrDocid(pReader));
+}
+static void dlwAdd(DLWriter *pWriter, sqlite_int64 iDocid){
+  char c[VARINT_MAX];
+  int n = putVarint(c, iDocid-pWriter->iPrevDocid);
+
+  /* Docids must ascend. */
+  assert( !pWriter->has_iPrevDocid || iDocid>pWriter->iPrevDocid );
+  assert( pWriter->iType==DL_DOCIDS );
+
+  dataBufferAppend(pWriter->b, c, n);
+  pWriter->iPrevDocid = iDocid;
+#ifndef NDEBUG
+  pWriter->has_iPrevDocid = 1;
+#endif
+}
+
+/*******************************************************************/
+/* PLReader is used to read data from a document's position list.  As
+** the caller steps through the list, data is cached so that varints
+** only need to be decoded once.
+**
+** plrInit, plrDestroy - create/destroy a reader.
+** plrColumn, plrPosition, plrStartOffset, plrEndOffset - accessors
+** plrAtEnd - at end of stream, only call plrDestroy once true.
+** plrStep - step to the next element.
+*/
+typedef struct PLReader {
+  /* These refer to the next position's data.  nData will reach 0 when
+  ** reading the last position, so plrStep() signals EOF by setting
+  ** pData to NULL.
+  */
+  const char *pData;
+  int nData;
+
+  DocListType iType;
+  int iColumn;         /* the last column read */
+  int iPosition;       /* the last position read */
+  int iStartOffset;    /* the last start offset read */
+  int iEndOffset;      /* the last end offset read */
+} PLReader;
+
+static int plrAtEnd(PLReader *pReader){
+  return pReader->pData==NULL;
+}
+static int plrColumn(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iColumn;
+}
+static int plrPosition(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iPosition;
+}
+static int plrStartOffset(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iStartOffset;
+}
+static int plrEndOffset(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iEndOffset;
+}
+static void plrStep(PLReader *pReader){
+  int i, n;
+
+  assert( !plrAtEnd(pReader) );
+
+  if( pReader->nData==0 ){
+    pReader->pData = NULL;
+    return;
+  }
+
+  n = getVarint32(pReader->pData, &i);
+  if( i==POS_COLUMN ){
+    n += getVarint32(pReader->pData+n, &pReader->iColumn);
+    pReader->iPosition = 0;
+    pReader->iStartOffset = 0;
+    n += getVarint32(pReader->pData+n, &i);
+  }
+  /* Should never see adjacent column changes. */
+  assert( i!=POS_COLUMN );
+
+  if( i==POS_END ){
+    pReader->nData = 0;
+    pReader->pData = NULL;
+    return;
+  }
+
+  pReader->iPosition += i-POS_BASE;
+  if( pReader->iType==DL_POSITIONS_OFFSETS ){
+    n += getVarint32(pReader->pData+n, &i);
+    pReader->iStartOffset += i;
+    n += getVarint32(pReader->pData+n, &i);
+    pReader->iEndOffset = pReader->iStartOffset+i;
+  }
+  assert( n<=pReader->nData );
+  pReader->pData += n;
+  pReader->nData -= n;
+}
+
+static void plrInit(PLReader *pReader, DLReader *pDLReader){
+  pReader->pData = dlrPosData(pDLReader);
+  pReader->nData = dlrPosDataLen(pDLReader);
+  pReader->iType = pDLReader->iType;
+  pReader->iColumn = 0;
+  pReader->iPosition = 0;
+  pReader->iStartOffset = 0;
+  pReader->iEndOffset = 0;
+  plrStep(pReader);
+}
+static void plrDestroy(PLReader *pReader){
+  SCRAMBLE(pReader);
+}
+
+/*******************************************************************/
+/* PLWriter is used in constructing a document's position list.  As a
+** convenience, if iType is DL_DOCIDS, PLWriter becomes a no-op.
+** PLWriter writes to the associated DLWriter's buffer.
+**
+** plwInit - init for writing a document's poslist.
+** plwDestroy - clear a writer.
+** plwAdd - append position and offset information.
+** plwCopy - copy next position's data from reader to writer.
+** plwTerminate - add any necessary doclist terminator.
+**
+** Calling plwAdd() after plwTerminate() may result in a corrupt
+** doclist.
+*/
+/* TODO(shess) Until we've written the second item, we can cache the
+** first item's information.  Then we'd have three states:
+**
+** - initialized with docid, no positions.
+** - docid and one position.
+** - docid and multiple positions.
+**
+** Only the last state needs to actually write to dlw->b, which would
+** be an improvement in the DLCollector case.
+*/
+typedef struct PLWriter {
+  DLWriter *dlw;
+
+  int iColumn;    /* the last column written */
+  int iPos;       /* the last position written */
+  int iOffset;    /* the last start offset written */
+} PLWriter;
+
+/* TODO(shess) In the case where the parent is reading these values
+** from a PLReader, we could optimize to a copy if that PLReader has
+** the same type as pWriter.
+*/
+static void plwAdd(PLWriter *pWriter, int iColumn, int iPos,
+                   int iStartOffset, int iEndOffset){
+  /* Worst-case space for POS_COLUMN, iColumn, iPosDelta,
+  ** iStartOffsetDelta, and iEndOffsetDelta.
+  */
+  char c[5*VARINT_MAX];
+  int n = 0;
+
+  /* Ban plwAdd() after plwTerminate(). */
+  assert( pWriter->iPos!=-1 );
+
+  if( pWriter->dlw->iType==DL_DOCIDS ) return;
+
+  if( iColumn!=pWriter->iColumn ){
+    n += putVarint(c+n, POS_COLUMN);
+    n += putVarint(c+n, iColumn);
+    pWriter->iColumn = iColumn;
+    pWriter->iPos = 0;
+    pWriter->iOffset = 0;
+  }
+  assert( iPos>=pWriter->iPos );
+  n += putVarint(c+n, POS_BASE+(iPos-pWriter->iPos));
+  pWriter->iPos = iPos;
+  if( pWriter->dlw->iType==DL_POSITIONS_OFFSETS ){
+    assert( iStartOffset>=pWriter->iOffset );
+    n += putVarint(c+n, iStartOffset-pWriter->iOffset);
+    pWriter->iOffset = iStartOffset;
+    assert( iEndOffset>=iStartOffset );
+    n += putVarint(c+n, iEndOffset-iStartOffset);
+  }
+  dataBufferAppend(pWriter->dlw->b, c, n);
+}
+static void plwCopy(PLWriter *pWriter, PLReader *pReader){
+  plwAdd(pWriter, plrColumn(pReader), plrPosition(pReader),
+         plrStartOffset(pReader), plrEndOffset(pReader));
+}
+static void plwInit(PLWriter *pWriter, DLWriter *dlw, sqlite_int64 iDocid){
+  char c[VARINT_MAX];
+  int n;
+
+  pWriter->dlw = dlw;
+
+  /* Docids must ascend. */
+  assert( !pWriter->dlw->has_iPrevDocid || iDocid>pWriter->dlw->iPrevDocid );
+  n = putVarint(c, iDocid-pWriter->dlw->iPrevDocid);
+  dataBufferAppend(pWriter->dlw->b, c, n);
+  pWriter->dlw->iPrevDocid = iDocid;
+#ifndef NDEBUG
+  pWriter->dlw->has_iPrevDocid = 1;
+#endif
+
+  pWriter->iColumn = 0;
+  pWriter->iPos = 0;
+  pWriter->iOffset = 0;
+}
+/* TODO(shess) Should plwDestroy() also terminate the doclist?  But
+** then plwDestroy() would no longer be just a destructor, it would
+** also be doing work, which isn't consistent with the overall idiom.
+** Another option would be for plwAdd() to always append any necessary
+** terminator, so that the output is always correct.  But that would
+** add incremental work to the common case with the only benefit being
+** API elegance.  Punt for now.
+*/
+static void plwTerminate(PLWriter *pWriter){
+  if( pWriter->dlw->iType>DL_DOCIDS ){
+    char c[VARINT_MAX];
+    int n = putVarint(c, POS_END);
+    dataBufferAppend(pWriter->dlw->b, c, n);
+  }
+#ifndef NDEBUG
+  /* Mark as terminated for assert in plwAdd(). */
+  pWriter->iPos = -1;
+#endif
+}
+static void plwDestroy(PLWriter *pWriter){
+  SCRAMBLE(pWriter);
+}
+
+/*******************************************************************/
+/* DLCollector wraps PLWriter and DLWriter to provide a
+** dynamically-allocated doclist area to use during tokenization.
+**
+** dlcNew - malloc up and initialize a collector.
+** dlcDelete - destroy a collector and all contained items.
+** dlcAddPos - append position and offset information.
+** dlcAddDoclist - add the collected doclist to the given buffer.
+** dlcNext - terminate the current document and open another.
+*/
+typedef struct DLCollector {
+  DataBuffer b;
+  DLWriter dlw;
+  PLWriter plw;
+} DLCollector;
+
+/* TODO(shess) This could also be done by calling plwTerminate() and
+** dataBufferAppend().  I tried that, expecting nominal performance
+** differences, but it seemed to pretty reliably be worth 1% to code
+** it this way.  I suspect it is the incremental malloc overhead (some
+** percentage of the plwTerminate() calls will cause a realloc), so
+** this might be worth revisiting if the DataBuffer implementation
+** changes.
+*/
+static void dlcAddDoclist(DLCollector *pCollector, DataBuffer *b){
+  if( pCollector->dlw.iType>DL_DOCIDS ){
+    char c[VARINT_MAX];
+    int n = putVarint(c, POS_END);
+    dataBufferAppend2(b, pCollector->b.pData, pCollector->b.nData, c, n);
+  }else{
+    dataBufferAppend(b, pCollector->b.pData, pCollector->b.nData);
+  }
+}
+static void dlcNext(DLCollector *pCollector, sqlite_int64 iDocid){
+  plwTerminate(&pCollector->plw);
+  plwDestroy(&pCollector->plw);
+  plwInit(&pCollector->plw, &pCollector->dlw, iDocid);
+}
+static void dlcAddPos(DLCollector *pCollector, int iColumn, int iPos,
+                      int iStartOffset, int iEndOffset){
+  plwAdd(&pCollector->plw, iColumn, iPos, iStartOffset, iEndOffset);
+}
+
+static DLCollector *dlcNew(sqlite_int64 iDocid, DocListType iType){
+  DLCollector *pCollector = malloc(sizeof(DLCollector));
+  dataBufferInit(&pCollector->b, 0);
+  dlwInit(&pCollector->dlw, iType, &pCollector->b);
+  plwInit(&pCollector->plw, &pCollector->dlw, iDocid);
+  return pCollector;
+}
+static void dlcDelete(DLCollector *pCollector){
+  plwDestroy(&pCollector->plw);
+  dlwDestroy(&pCollector->dlw);
+  dataBufferDestroy(&pCollector->b);
+  SCRAMBLE(pCollector);
+  free(pCollector);
+}
+
+
+/* Copy the doclist data of iType in pData/nData into *out, trimming
+** unnecessary data as we go.  Only columns matching iColumn are
+** copied, all columns copied if iColumn is -1.  Elements with no
+** matching columns are dropped.  The output is an iOutType doclist.
+*/
+/* NOTE(shess) This code is only valid after all doclists are merged.
+** If this is run before merges, then doclist items which represent
+** deletion will be trimmed, and will thus not effect a deletion
+** during the merge.
+*/
+static void docListTrim(DocListType iType, const char *pData, int nData,
+                        int iColumn, DocListType iOutType, DataBuffer *out){
+  DLReader dlReader;
+  DLWriter dlWriter;
+
+  assert( iOutType<=iType );
+
+  dlrInit(&dlReader, iType, pData, nData);
+  dlwInit(&dlWriter, iOutType, out);
+
+  while( !dlrAtEnd(&dlReader) ){
+    PLReader plReader;
+    PLWriter plWriter;
+    int match = 0;
+
+    plrInit(&plReader, &dlReader);
+
+    while( !plrAtEnd(&plReader) ){
+      if( iColumn==-1 || plrColumn(&plReader)==iColumn ){
+        if( !match ){
+          plwInit(&plWriter, &dlWriter, dlrDocid(&dlReader));
+          match = 1;
+        }
+        plwAdd(&plWriter, plrColumn(&plReader), plrPosition(&plReader),
+               plrStartOffset(&plReader), plrEndOffset(&plReader));
+      }
+      plrStep(&plReader);
+    }
+    if( match ){
+      plwTerminate(&plWriter);
+      plwDestroy(&plWriter);
+    }
+
+    plrDestroy(&plReader);
+    dlrStep(&dlReader);
+  }
+  dlwDestroy(&dlWriter);
+  dlrDestroy(&dlReader);
+}
+
+/* Used by docListMerge() to keep doclists in the ascending order by
+** docid, then ascending order by age (so the newest comes first).
+*/
+typedef struct OrderedDLReader {
+  DLReader *pReader;
+
+  /* TODO(shess) If we assume that docListMerge pReaders is ordered by
+  ** age (which we do), then we could use pReader comparisons to break
+  ** ties.
+  */
+  int idx;
+} OrderedDLReader;
+
+/* Order eof to end, then by docid asc, idx desc. */
+static int orderedDLReaderCmp(OrderedDLReader *r1, OrderedDLReader *r2){
+  if( dlrAtEnd(r1->pReader) ){
+    if( dlrAtEnd(r2->pReader) ) return 0;  /* Both atEnd(). */
+    return 1;                              /* Only r1 atEnd(). */
+  }
+  if( dlrAtEnd(r2->pReader) ) return -1;   /* Only r2 atEnd(). */
+
+  if( dlrDocid(r1->pReader)<dlrDocid(r2->pReader) ) return -1;
+  if( dlrDocid(r1->pReader)>dlrDocid(r2->pReader) ) return 1;
+
+  /* Descending on idx. */
+  return r2->idx-r1->idx;
+}
+
+/* Bubble p[0] to appropriate place in p[1..n-1].  Assumes that
+** p[1..n-1] is already sorted.
+*/
+/* TODO(shess) Is this frequent enough to warrant a binary search?
+** Before implementing that, instrument the code to check.  In most
+** current usage, I expect that p[0] will be less than p[1] a very
+** high proportion of the time.
+*/
+static void orderedDLReaderReorder(OrderedDLReader *p, int n){
+  while( n>1 && orderedDLReaderCmp(p, p+1)>0 ){
+    OrderedDLReader tmp = p[0];
+    p[0] = p[1];
+    p[1] = tmp;
+    n--;
+    p++;
+  }
+}
+
+/* Given an array of doclist readers, merge their doclist elements
+** into out in sorted order (by docid), dropping elements from older
+** readers when there is a duplicate docid.  pReaders is assumed to be
+** ordered by age, oldest first.
+*/
+/* TODO(shess) nReaders must be <= MERGE_COUNT.  This should probably
+** be fixed.
+*/
+static void docListMerge(DataBuffer *out,
+                         DLReader *pReaders, int nReaders){
+  OrderedDLReader readers[MERGE_COUNT];
+  DLWriter writer;
+  int i, n;
+  const char *pStart = 0;
+  int nStart = 0;
+  sqlite_int64 iFirstDocid = 0, iLastDocid = 0;
+
+  assert( nReaders>0 );
+  if( nReaders==1 ){
+    dataBufferAppend(out, dlrDocData(pReaders), dlrAllDataBytes(pReaders));
+    return;
+  }
+
+  assert( nReaders<=MERGE_COUNT );
+  n = 0;
+  for(i=0; i<nReaders; i++){
+    assert( pReaders[i].iType==pReaders[0].iType );
+    readers[i].pReader = pReaders+i;
+    readers[i].idx = i;
+    n += dlrAllDataBytes(&pReaders[i]);
+  }
+  /* Conservatively size output to sum of inputs.  Output should end
+  ** up strictly smaller than input.
+  */
+  dataBufferExpand(out, n);
+
+  /* Get the readers into sorted order. */
+  while( i-->0 ){
+    orderedDLReaderReorder(readers+i, nReaders-i);
+  }
+
+  dlwInit(&writer, pReaders[0].iType, out);
+  while( !dlrAtEnd(readers[0].pReader) ){
+    sqlite_int64 iDocid = dlrDocid(readers[0].pReader);
+
+    /* If this is a continuation of the current buffer to copy, extend
+    ** that buffer.  memcpy() seems to be more efficient if it has a
+    ** lots of data to copy.
+    */
+    if( dlrDocData(readers[0].pReader)==pStart+nStart ){
+      nStart += dlrDocDataBytes(readers[0].pReader);
+    }else{
+      if( pStart!=0 ){
+        dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
+      }
+      pStart = dlrDocData(readers[0].pReader);
+      nStart = dlrDocDataBytes(readers[0].pReader);
+      iFirstDocid = iDocid;
+    }
+    iLastDocid = iDocid;
+    dlrStep(readers[0].pReader);
+
+    /* Drop all of the older elements with the same docid. */
+    for(i=1; i<nReaders &&
+             !dlrAtEnd(readers[i].pReader) &&
+             dlrDocid(readers[i].pReader)==iDocid; i++){
+      dlrStep(readers[i].pReader);
+    }
+
+    /* Get the readers back into order. */
+    while( i-->0 ){
+      orderedDLReaderReorder(readers+i, nReaders-i);
+    }
+  }
+
+  /* Copy over any remaining elements. */
+  if( nStart>0 ) dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
+  dlwDestroy(&writer);
+}
+
+/* Helper function for posListUnion().  Compares the current position
+** between left and right, returning as standard C idiom of <0 if
+** left<right, >0 if left>right, and 0 if left==right.  "End" always
+** compares greater.
+*/
+static int posListCmp(PLReader *pLeft, PLReader *pRight){
+  assert( pLeft->iType==pRight->iType );
+  if( pLeft->iType==DL_DOCIDS ) return 0;
+
+  if( plrAtEnd(pLeft) ) return plrAtEnd(pRight) ? 0 : 1;
+  if( plrAtEnd(pRight) ) return -1;
+
+  if( plrColumn(pLeft)<plrColumn(pRight) ) return -1;
+  if( plrColumn(pLeft)>plrColumn(pRight) ) return 1;
+
+  if( plrPosition(pLeft)<plrPosition(pRight) ) return -1;
+  if( plrPosition(pLeft)>plrPosition(pRight) ) return 1;
+  if( pLeft->iType==DL_POSITIONS ) return 0;
+
+  if( plrStartOffset(pLeft)<plrStartOffset(pRight) ) return -1;
+  if( plrStartOffset(pLeft)>plrStartOffset(pRight) ) return 1;
+
+  if( plrEndOffset(pLeft)<plrEndOffset(pRight) ) return -1;
+  if( plrEndOffset(pLeft)>plrEndOffset(pRight) ) return 1;
+
+  return 0;
+}
+
+/* Write the union of position lists in pLeft and pRight to pOut.
+** "Union" in this case meaning "All unique position tuples".  Should
+** work with any doclist type, though both inputs and the output
+** should be the same type.
+*/
+static void posListUnion(DLReader *pLeft, DLReader *pRight, DLWriter *pOut){
+  PLReader left, right;
+  PLWriter writer;
+
+  assert( dlrDocid(pLeft)==dlrDocid(pRight) );
+  assert( pLeft->iType==pRight->iType );
+  assert( pLeft->iType==pOut->iType );
+
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
+  plwInit(&writer, pOut, dlrDocid(pLeft));
+
+  while( !plrAtEnd(&left) || !plrAtEnd(&right) ){
+    int c = posListCmp(&left, &right);
+    if( c<0 ){
+      plwCopy(&writer, &left);
+      plrStep(&left);
+    }else if( c>0 ){
+      plwCopy(&writer, &right);
+      plrStep(&right);
+    }else{
+      plwCopy(&writer, &left);
+      plrStep(&left);
+      plrStep(&right);
+    }
+  }
+
+  plwTerminate(&writer);
+  plwDestroy(&writer);
+  plrDestroy(&left);
+  plrDestroy(&right);
+}
+
+/* Write the union of doclists in pLeft and pRight to pOut.  For
+** docids in common between the inputs, the union of the position
+** lists is written.  Inputs and outputs are always type DL_DEFAULT.
+*/
+static void docListUnion(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ){
+    if( nRight!=0) dataBufferAppend(pOut, pRight, nRight);
+    return;
+  }
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DEFAULT, pLeft, nLeft);
+  dlrInit(&right, DL_DEFAULT, pRight, nRight);
+  dlwInit(&writer, DL_DEFAULT, pOut);
+
+  while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
+    if( dlrAtEnd(&right) ){
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
+    }else if( dlrAtEnd(&left) ){
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
+    }else if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
+    }else if( dlrDocid(&left)>dlrDocid(&right) ){
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
+    }else{
+      posListUnion(&left, &right, &writer);
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* pLeft and pRight are DLReaders positioned to the same docid.
+**
+** If there are no instances in pLeft or pRight where the position
+** of pLeft is one less than the position of pRight, then this
+** routine adds nothing to pOut.
+**
+** If there are one or more instances where positions from pLeft
+** are exactly one less than positions from pRight, then add a new
+** document record to pOut.  If pOut wants to hold positions, then
+** include the positions from pRight that are one more than a
+** position in pLeft.  In other words:  pRight.iPos==pLeft.iPos+1.
+*/
+static void posListPhraseMerge(DLReader *pLeft, DLReader *pRight,
+                               DLWriter *pOut){
+  PLReader left, right;
+  PLWriter writer;
+  int match = 0;
+
+  assert( dlrDocid(pLeft)==dlrDocid(pRight) );
+  assert( pOut->iType!=DL_POSITIONS_OFFSETS );
+
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
+
+  while( !plrAtEnd(&left) && !plrAtEnd(&right) ){
+    if( plrColumn(&left)<plrColumn(&right) ){
+      plrStep(&left);
+    }else if( plrColumn(&left)>plrColumn(&right) ){
+      plrStep(&right);
+    }else if( plrPosition(&left)+1<plrPosition(&right) ){
+      plrStep(&left);
+    }else if( plrPosition(&left)+1>plrPosition(&right) ){
+      plrStep(&right);
+    }else{
+      if( !match ){
+        plwInit(&writer, pOut, dlrDocid(pLeft));
+        match = 1;
+      }
+      plwAdd(&writer, plrColumn(&right), plrPosition(&right), 0, 0);
+      plrStep(&left);
+      plrStep(&right);
+    }
+  }
+
+  if( match ){
+    plwTerminate(&writer);
+    plwDestroy(&writer);
+  }
+
+  plrDestroy(&left);
+  plrDestroy(&right);
+}
+
+/* We have two doclists with positions:  pLeft and pRight.
+** Write the phrase intersection of these two doclists into pOut.
+**
+** A phrase intersection means that two documents only match
+** if pLeft.iPos+1==pRight.iPos.
+**
+** iType controls the type of data written to pOut.  If iType is
+** DL_POSITIONS, the positions are those from pRight.
+*/
+static void docListPhraseMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DocListType iType,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 || nRight==0 ) return;
+
+  assert( iType!=DL_POSITIONS_OFFSETS );
+
+  dlrInit(&left, DL_POSITIONS, pLeft, nLeft);
+  dlrInit(&right, DL_POSITIONS, pRight, nRight);
+  dlwInit(&writer, iType, pOut);
+
+  while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
+    if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }else{
+      posListPhraseMerge(&left, &right, &writer);
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write the intersection of these two doclists into pOut as a
+** DL_DOCIDS doclist.
+*/
+static void docListAndMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 || nRight==0 ) return;
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
+    if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }else{
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write the union of these two doclists into pOut as a
+** DL_DOCIDS doclist.
+*/
+static void docListOrMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ){
+    if( nRight!=0 ) dataBufferAppend(pOut, pRight, nRight);
+    return;
+  }
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
+    if( dlrAtEnd(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+    }else if( dlrAtEnd(&left) ){
+      dlwAdd(&writer, dlrDocid(&right));
+      dlrStep(&right);
+    }else if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlwAdd(&writer, dlrDocid(&right));
+      dlrStep(&right);
+    }else{
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write into pOut as DL_DOCIDS doclist containing all documents that
+** occur in pLeft but not in pRight.
+*/
+static void docListExceptMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ) return;
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) ){
+    while( !dlrAtEnd(&right) && dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }
+    if( dlrAtEnd(&right) || dlrDocid(&left)<dlrDocid(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+    }
+    dlrStep(&left);
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+static char *string_dup_n(const char *s, int n){
+  char *str = malloc(n + 1);
+  memcpy(str, s, n);
+  str[n] = '\0';
+  return str;
+}
+
+/* Duplicate a string; the caller must free() the returned string.
+ * (We don't use strdup() since it is not part of the standard C library and
+ * may not be available everywhere.) */
+static char *string_dup(const char *s){
+  return string_dup_n(s, strlen(s));
+}
+
+/* Format a string, replacing each occurrence of the % character with
+ * zDb.zName.  This may be more convenient than sqlite_mprintf()
+ * when one string is used repeatedly in a format string.
+ * The caller must free() the returned string. */
+static char *string_format(const char *zFormat,
+                           const char *zDb, const char *zName){
+  const char *p;
+  size_t len = 0;
+  size_t nDb = strlen(zDb);
+  size_t nName = strlen(zName);
+  size_t nFullTableName = nDb+1+nName;
+  char *result;
+  char *r;
+
+  /* first compute length needed */
+  for(p = zFormat ; *p ; ++p){
+    len += (*p=='%' ? nFullTableName : 1);
+  }
+  len += 1;  /* for null terminator */
+
+  r = result = malloc(len);
+  for(p = zFormat; *p; ++p){
+    if( *p=='%' ){
+      memcpy(r, zDb, nDb);
+      r += nDb;
+      *r++ = '.';
+      memcpy(r, zName, nName);
+      r += nName;
+    } else {
+      *r++ = *p;
+    }
+  }
+  *r++ = '\0';
+  assert( r == result + len );
+  return result;
+}
+
+static int sql_exec(sqlite3 *db, const char *zDb, const char *zName,
+                    const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  TRACE(("FTS2 sql: %s\n", zCommand));
+  rc = sqlite3_exec(db, zCommand, NULL, 0, NULL);
+  free(zCommand);
+  return rc;
+}
+
+static int sql_prepare(sqlite3 *db, const char *zDb, const char *zName,
+                       sqlite3_stmt **ppStmt, const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  TRACE(("FTS2 prepare: %s\n", zCommand));
+  rc = sqlite3_prepare_v2(db, zCommand, -1, ppStmt, NULL);
+  free(zCommand);
+  return rc;
+}
+
+/* end utility functions */
+
+/* Forward reference */
+typedef struct fulltext_vtab fulltext_vtab;
+
+/* A single term in a query is represented by an instances of
+** the following structure.
+*/
+typedef struct QueryTerm {
+  short int nPhrase; /* How many following terms are part of the same phrase */
+  short int iPhrase; /* This is the i-th term of a phrase. */
+  short int iColumn; /* Column of the index that must match this term */
+  signed char isOr;  /* this term is preceded by "OR" */
+  signed char isNot; /* this term is preceded by "-" */
+  signed char isPrefix; /* this term is followed by "*" */
+  char *pTerm;       /* text of the term.  '\000' terminated.  malloced */
+  int nTerm;         /* Number of bytes in pTerm[] */
+} QueryTerm;
+
+
+/* A query string is parsed into a Query structure.
+ *
+ * We could, in theory, allow query strings to be complicated
+ * nested expressions with precedence determined by parentheses.
+ * But none of the major search engines do this.  (Perhaps the
+ * feeling is that an parenthesized expression is two complex of
+ * an idea for the average user to grasp.)  Taking our lead from
+ * the major search engines, we will allow queries to be a list
+ * of terms (with an implied AND operator) or phrases in double-quotes,
+ * with a single optional "-" before each non-phrase term to designate
+ * negation and an optional OR connector.
+ *
+ * OR binds more tightly than the implied AND, which is what the
+ * major search engines seem to do.  So, for example:
+ * 
+ *    [one two OR three]     ==>    one AND (two OR three)
+ *    [one OR two three]     ==>    (one OR two) AND three
+ *
+ * A "-" before a term matches all entries that lack that term.
+ * The "-" must occur immediately before the term with in intervening
+ * space.  This is how the search engines do it.
+ *
+ * A NOT term cannot be the right-hand operand of an OR.  If this
+ * occurs in the query string, the NOT is ignored:
+ *
+ *    [one OR -two]          ==>    one OR two
+ *
+ */
+typedef struct Query {
+  fulltext_vtab *pFts;  /* The full text index */
+  int nTerms;           /* Number of terms in the query */
+  QueryTerm *pTerms;    /* Array of terms.  Space obtained from malloc() */
+  int nextIsOr;         /* Set the isOr flag on the next inserted term */
+  int nextColumn;       /* Next word parsed must be in this column */
+  int dfltColumn;       /* The default column */
+} Query;
+
+
+/*
+** An instance of the following structure keeps track of generated
+** matching-word offset information and snippets.
+*/
+typedef struct Snippet {
+  int nMatch;     /* Total number of matches */
+  int nAlloc;     /* Space allocated for aMatch[] */
+  struct snippetMatch { /* One entry for each matching term */
+    char snStatus;       /* Status flag for use while constructing snippets */
+    short int iCol;      /* The column that contains the match */
+    short int iTerm;     /* The index in Query.pTerms[] of the matching term */
+    short int nByte;     /* Number of bytes in the term */
+    int iStart;          /* The offset to the first character of the term */
+  } *aMatch;      /* Points to space obtained from malloc */
+  char *zOffset;  /* Text rendering of aMatch[] */
+  int nOffset;    /* strlen(zOffset) */
+  char *zSnippet; /* Snippet text */
+  int nSnippet;   /* strlen(zSnippet) */
+} Snippet;
+
+
+typedef enum QueryType {
+  QUERY_GENERIC,   /* table scan */
+  QUERY_ROWID,     /* lookup by rowid */
+  QUERY_FULLTEXT   /* QUERY_FULLTEXT + [i] is a full-text search for column i*/
+} QueryType;
+
+typedef enum fulltext_statement {
+  CONTENT_INSERT_STMT,
+  CONTENT_SELECT_STMT,
+  CONTENT_UPDATE_STMT,
+  CONTENT_DELETE_STMT,
+
+  BLOCK_INSERT_STMT,
+  BLOCK_SELECT_STMT,
+  BLOCK_DELETE_STMT,
+
+  SEGDIR_MAX_INDEX_STMT,
+  SEGDIR_SET_STMT,
+  SEGDIR_SELECT_STMT,
+  SEGDIR_SPAN_STMT,
+  SEGDIR_DELETE_STMT,
+  SEGDIR_SELECT_ALL_STMT,
+
+  MAX_STMT                     /* Always at end! */
+} fulltext_statement;
+
+/* These must exactly match the enum above. */
+/* TODO(shess): Is there some risk that a statement will be used in two
+** cursors at once, e.g.  if a query joins a virtual table to itself?
+** If so perhaps we should move some of these to the cursor object.
+*/
+static const char *const fulltext_zStatement[MAX_STMT] = {
+  /* CONTENT_INSERT */ NULL,  /* generated in contentInsertStatement() */
+  /* CONTENT_SELECT */ "select * from %_content where rowid = ?",
+  /* CONTENT_UPDATE */ NULL,  /* generated in contentUpdateStatement() */
+  /* CONTENT_DELETE */ "delete from %_content where rowid = ?",
+
+  /* BLOCK_INSERT */ "insert into %_segments values (?)",
+  /* BLOCK_SELECT */ "select block from %_segments where rowid = ?",
+  /* BLOCK_DELETE */ "delete from %_segments where rowid between ? and ?",
+
+  /* SEGDIR_MAX_INDEX */ "select max(idx) from %_segdir where level = ?",
+  /* SEGDIR_SET */ "insert into %_segdir values (?, ?, ?, ?, ?, ?)",
+  /* SEGDIR_SELECT */
+  "select start_block, leaves_end_block, root from %_segdir "
+  " where level = ? order by idx",
+  /* SEGDIR_SPAN */
+  "select min(start_block), max(end_block) from %_segdir "
+  " where level = ? and start_block <> 0",
+  /* SEGDIR_DELETE */ "delete from %_segdir where level = ?",
+  /* SEGDIR_SELECT_ALL */
+  "select root, leaves_end_block from %_segdir order by level desc, idx",
+};
+
+/*
+** A connection to a fulltext index is an instance of the following
+** structure.  The xCreate and xConnect methods create an instance
+** of this structure and xDestroy and xDisconnect free that instance.
+** All other methods receive a pointer to the structure as one of their
+** arguments.
+*/
+struct fulltext_vtab {
+  sqlite3_vtab base;               /* Base class used by SQLite core */
+  sqlite3 *db;                     /* The database connection */
+  const char *zDb;                 /* logical database name */
+  const char *zName;               /* virtual table name */
+  int nColumn;                     /* number of columns in virtual table */
+  char **azColumn;                 /* column names.  malloced */
+  char **azContentColumn;          /* column names in content table; malloced */
+  sqlite3_tokenizer *pTokenizer;   /* tokenizer for inserts and queries */
+
+  /* Precompiled statements which we keep as long as the table is
+  ** open.
+  */
+  sqlite3_stmt *pFulltextStatements[MAX_STMT];
+
+  /* Precompiled statements used for segment merges.  We run a
+  ** separate select across the leaf level of each tree being merged.
+  */
+  sqlite3_stmt *pLeafSelectStmts[MERGE_COUNT];
+  /* The statement used to prepare pLeafSelectStmts. */
+#define LEAF_SELECT \
+  "select block from %_segments where rowid between ? and ? order by rowid"
+
+  /* These buffer pending index updates during transactions.
+  ** nPendingData estimates the memory size of the pending data.  It
+  ** doesn't include the hash-bucket overhead, nor any malloc
+  ** overhead.  When nPendingData exceeds kPendingThreshold, the
+  ** buffer is flushed even before the transaction closes.
+  ** pendingTerms stores the data, and is only valid when nPendingData
+  ** is >=0 (nPendingData<0 means pendingTerms has not been
+  ** initialized).  iPrevDocid is the last docid written, used to make
+  ** certain we're inserting in sorted order.
+  */
+  int nPendingData;
+#define kPendingThreshold (1*1024*1024)
+  sqlite_int64 iPrevDocid;
+  fts2Hash pendingTerms;
+};
+
+/*
+** When the core wants to do a query, it create a cursor using a
+** call to xOpen.  This structure is an instance of a cursor.  It
+** is destroyed by xClose.
+*/
+typedef struct fulltext_cursor {
+  sqlite3_vtab_cursor base;        /* Base class used by SQLite core */
+  QueryType iCursorType;           /* Copy of sqlite3_index_info.idxNum */
+  sqlite3_stmt *pStmt;             /* Prepared statement in use by the cursor */
+  int eof;                         /* True if at End Of Results */
+  Query q;                         /* Parsed query string */
+  Snippet snippet;                 /* Cached snippet for the current row */
+  int iColumn;                     /* Column being searched */
+  DataBuffer result;               /* Doclist results from fulltextQuery */
+  DLReader reader;                 /* Result reader if result not empty */
+} fulltext_cursor;
+
+static struct fulltext_vtab *cursor_vtab(fulltext_cursor *c){
+  return (fulltext_vtab *) c->base.pVtab;
+}
+
+static const sqlite3_module fts2Module;   /* forward declaration */
+
+/* Return a dynamically generated statement of the form
+ *   insert into %_content (rowid, ...) values (?, ...)
+ */
+static const char *contentInsertStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "insert into %_content (rowid, ");
+  appendList(&sb, v->nColumn, v->azContentColumn);
+  append(&sb, ") values (?");
+  for(i=0; i<v->nColumn; ++i)
+    append(&sb, ", ?");
+  append(&sb, ")");
+  return stringBufferData(&sb);
+}
+
+/* Return a dynamically generated statement of the form
+ *   update %_content set [col_0] = ?, [col_1] = ?, ...
+ *                    where rowid = ?
+ */
+static const char *contentUpdateStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "update %_content set ");
+  for(i=0; i<v->nColumn; ++i) {
+    if( i>0 ){
+      append(&sb, ", ");
+    }
+    append(&sb, v->azContentColumn[i]);
+    append(&sb, " = ?");
+  }
+  append(&sb, " where rowid = ?");
+  return stringBufferData(&sb);
+}
+
+/* Puts a freshly-prepared statement determined by iStmt in *ppStmt.
+** If the indicated statement has never been prepared, it is prepared
+** and cached, otherwise the cached version is reset.
+*/
+static int sql_get_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                             sqlite3_stmt **ppStmt){
+  assert( iStmt<MAX_STMT );
+  if( v->pFulltextStatements[iStmt]==NULL ){
+    const char *zStmt;
+    int rc;
+    switch( iStmt ){
+      case CONTENT_INSERT_STMT:
+        zStmt = contentInsertStatement(v); break;
+      case CONTENT_UPDATE_STMT:
+        zStmt = contentUpdateStatement(v); break;
+      default:
+        zStmt = fulltext_zStatement[iStmt];
+    }
+    rc = sql_prepare(v->db, v->zDb, v->zName, &v->pFulltextStatements[iStmt],
+                         zStmt);
+    if( zStmt != fulltext_zStatement[iStmt]) free((void *) zStmt);
+    if( rc!=SQLITE_OK ) return rc;
+  } else {
+    int rc = sqlite3_reset(v->pFulltextStatements[iStmt]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pFulltextStatements[iStmt];
+  return SQLITE_OK;
+}
+
+/* Like sqlite3_step(), but convert SQLITE_DONE to SQLITE_OK and
+** SQLITE_ROW to SQLITE_ERROR.  Useful for statements like UPDATE,
+** where we expect no results.
+*/
+static int sql_single_step(sqlite3_stmt *s){
+  int rc = sqlite3_step(s);
+  return (rc==SQLITE_DONE) ? SQLITE_OK : rc;
+}
+
+/* Like sql_get_statement(), but for special replicated LEAF_SELECT
+** statements.
+*/
+/* TODO(shess) Write version for generic statements and then share
+** that between the cached-statement functions.
+*/
+static int sql_get_leaf_statement(fulltext_vtab *v, int idx,
+                                  sqlite3_stmt **ppStmt){
+  assert( idx>=0 && idx<MERGE_COUNT );
+  if( v->pLeafSelectStmts[idx]==NULL ){
+    int rc = sql_prepare(v->db, v->zDb, v->zName, &v->pLeafSelectStmts[idx],
+                         LEAF_SELECT);
+    if( rc!=SQLITE_OK ) return rc;
+  }else{
+    int rc = sqlite3_reset(v->pLeafSelectStmts[idx]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pLeafSelectStmts[idx];
+  return SQLITE_OK;
+}
+
+/* insert into %_content (rowid, ...) values ([rowid], [pValues]) */
+static int content_insert(fulltext_vtab *v, sqlite3_value *rowid,
+                          sqlite3_value **pValues){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_value(s, 1, rowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 2+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  return sql_single_step(s);
+}
+
+/* update %_content set col0 = pValues[0], col1 = pValues[1], ...
+ *                  where rowid = [iRowid] */
+static int content_update(fulltext_vtab *v, sqlite3_value **pValues,
+                          sqlite_int64 iRowid){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_UPDATE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 1+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  rc = sqlite3_bind_int64(s, 1+v->nColumn, iRowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+static void freeStringArray(int nString, const char **pString){
+  int i;
+
+  for (i=0 ; i < nString ; ++i) {
+    if( pString[i]!=NULL ) free((void *) pString[i]);
+  }
+  free((void *) pString);
+}
+
+/* select * from %_content where rowid = [iRow]
+ * The caller must delete the returned array and all strings in it.
+ * null fields will be NULL in the returned array.
+ *
+ * TODO: Perhaps we should return pointer/length strings here for consistency
+ * with other code which uses pointer/length. */
+static int content_select(fulltext_vtab *v, sqlite_int64 iRow,
+                          const char ***pValues){
+  sqlite3_stmt *s;
+  const char **values;
+  int i;
+  int rc;
+
+  *pValues = NULL;
+
+  rc = sql_get_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc!=SQLITE_ROW ) return rc;
+
+  values = (const char **) malloc(v->nColumn * sizeof(const char *));
+  for(i=0; i<v->nColumn; ++i){
+    if( sqlite3_column_type(s, i)==SQLITE_NULL ){
+      values[i] = NULL;
+    }else{
+      values[i] = string_dup((char*)sqlite3_column_text(s, i));
+    }
+  }
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ){
+    *pValues = values;
+    return SQLITE_OK;
+  }
+
+  freeStringArray(v->nColumn, values);
+  return rc;
+}
+
+/* delete from %_content where rowid = [iRow ] */
+static int content_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* insert into %_segments values ([pData])
+**   returns assigned rowid in *piBlockid
+*/
+static int block_insert(fulltext_vtab *v, const char *pData, int nData,
+                        sqlite_int64 *piBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, BLOCK_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 1, pData, nData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+
+  *piBlockid = sqlite3_last_insert_rowid(v->db);
+  return SQLITE_OK;
+}
+
+/* delete from %_segments
+**   where rowid between [iStartBlockid] and [iEndBlockid]
+**
+** Deletes the range of blocks, inclusive, used to delete the blocks
+** which form a segment.
+*/
+static int block_delete(fulltext_vtab *v,
+                        sqlite_int64 iStartBlockid, sqlite_int64 iEndBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, BLOCK_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iStartBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* Returns SQLITE_ROW with *pidx set to the maximum segment idx found
+** at iLevel.  Returns SQLITE_DONE if there are no segments at
+** iLevel.  Otherwise returns an error.
+*/
+static int segdir_max_index(fulltext_vtab *v, int iLevel, int *pidx){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_MAX_INDEX_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  /* Should always get at least one row due to how max() works. */
+  if( rc==SQLITE_DONE ) return SQLITE_DONE;
+  if( rc!=SQLITE_ROW ) return rc;
+
+  /* NULL means that there were no inputs to max(). */
+  if( SQLITE_NULL==sqlite3_column_type(s, 0) ){
+    rc = sqlite3_step(s);
+    if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+    return rc;
+  }
+
+  *pidx = sqlite3_column_int(s, 0);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+  return SQLITE_ROW;
+}
+
+/* insert into %_segdir values (
+**   [iLevel], [idx],
+**   [iStartBlockid], [iLeavesEndBlockid], [iEndBlockid],
+**   [pRootData]
+** )
+*/
+static int segdir_set(fulltext_vtab *v, int iLevel, int idx,
+                      sqlite_int64 iStartBlockid,
+                      sqlite_int64 iLeavesEndBlockid,
+                      sqlite_int64 iEndBlockid,
+                      const char *pRootData, int nRootData){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SET_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 2, idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 3, iStartBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 4, iLeavesEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 5, iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 6, pRootData, nRootData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* Queries %_segdir for the block span of the segments in level
+** iLevel.  Returns SQLITE_DONE if there are no blocks for iLevel,
+** SQLITE_ROW if there are blocks, else an error.
+*/
+static int segdir_span(fulltext_vtab *v, int iLevel,
+                       sqlite_int64 *piStartBlockid,
+                       sqlite_int64 *piEndBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SPAN_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ) return SQLITE_DONE;  /* Should never happen */
+  if( rc!=SQLITE_ROW ) return rc;
+
+  /* This happens if all segments at this level are entirely inline. */
+  if( SQLITE_NULL==sqlite3_column_type(s, 0) ){
+    /* We expect only one row.  We must execute another sqlite3_step()
+     * to complete the iteration; otherwise the table will remain locked. */
+    int rc2 = sqlite3_step(s);
+    if( rc2==SQLITE_ROW ) return SQLITE_ERROR;
+    return rc2;
+  }
+
+  *piStartBlockid = sqlite3_column_int64(s, 0);
+  *piEndBlockid = sqlite3_column_int64(s, 1);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+  return SQLITE_ROW;
+}
+
+/* Delete the segment blocks and segment directory records for all
+** segments at iLevel.
+*/
+static int segdir_delete(fulltext_vtab *v, int iLevel){
+  sqlite3_stmt *s;
+  sqlite_int64 iStartBlockid, iEndBlockid;
+  int rc = segdir_span(v, iLevel, &iStartBlockid, &iEndBlockid);
+  if( rc!=SQLITE_ROW && rc!=SQLITE_DONE ) return rc;
+
+  if( rc==SQLITE_ROW ){
+    rc = block_delete(v, iStartBlockid, iEndBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  /* Delete the segment directory itself. */
+  rc = sql_get_statement(v, SEGDIR_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* TODO(shess) clearPendingTerms() is far down the file because
+** writeZeroSegment() is far down the file because LeafWriter is far
+** down the file.  Consider refactoring the code to move the non-vtab
+** code above the vtab code so that we don't need this forward
+** reference.
+*/
+static int clearPendingTerms(fulltext_vtab *v);
+
+/*
+** Free the memory used to contain a fulltext_vtab structure.
+*/
+static void fulltext_vtab_destroy(fulltext_vtab *v){
+  int iStmt, i;
+
+  TRACE(("FTS2 Destroy %p\n", v));
+  for( iStmt=0; iStmt<MAX_STMT; iStmt++ ){
+    if( v->pFulltextStatements[iStmt]!=NULL ){
+      sqlite3_finalize(v->pFulltextStatements[iStmt]);
+      v->pFulltextStatements[iStmt] = NULL;
+    }
+  }
+
+  for( i=0; i<MERGE_COUNT; i++ ){
+    if( v->pLeafSelectStmts[i]!=NULL ){
+      sqlite3_finalize(v->pLeafSelectStmts[i]);
+      v->pLeafSelectStmts[i] = NULL;
+    }
+  }
+
+  if( v->pTokenizer!=NULL ){
+    v->pTokenizer->pModule->xDestroy(v->pTokenizer);
+    v->pTokenizer = NULL;
+  }
+
+  clearPendingTerms(v);
+
+  free(v->azColumn);
+  for(i = 0; i < v->nColumn; ++i) {
+    sqlite3_free(v->azContentColumn[i]);
+  }
+  free(v->azContentColumn);
+  free(v);
+}
+
+/*
+** Token types for parsing the arguments to xConnect or xCreate.
+*/
+#define TOKEN_EOF         0    /* End of file */
+#define TOKEN_SPACE       1    /* Any kind of whitespace */
+#define TOKEN_ID          2    /* An identifier */
+#define TOKEN_STRING      3    /* A string literal */
+#define TOKEN_PUNCT       4    /* A single punctuation character */
+
+/*
+** If X is a character that can be used in an identifier then
+** IdChar(X) will be true.  Otherwise it is false.
+**
+** For ASCII, any character with the high-order bit set is
+** allowed in an identifier.  For 7-bit characters, 
+** sqlite3IsIdChar[X] must be 1.
+**
+** Ticket #1066.  the SQL standard does not allow '$' in the
+** middle of identfiers.  But many SQL implementations do. 
+** SQLite will allow '$' in identifiers for compatibility.
+** But the feature is undocumented.
+*/
+static const char isIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && isIdChar[c-0x20]))
+
+
+/*
+** Return the length of the token that begins at z[0]. 
+** Store the token type in *tokenType before returning.
+*/
+static int getToken(const char *z, int *tokenType){
+  int i, c;
+  switch( *z ){
+    case 0: {
+      *tokenType = TOKEN_EOF;
+      return 0;
+    }
+    case ' ': case '\t': case '\n': case '\f': case '\r': {
+      for(i=1; safe_isspace(z[i]); i++){}
+      *tokenType = TOKEN_SPACE;
+      return i;
+    }
+    case '`':
+    case '\'':
+    case '"': {
+      int delim = z[0];
+      for(i=1; (c=z[i])!=0; i++){
+        if( c==delim ){
+          if( z[i+1]==delim ){
+            i++;
+          }else{
+            break;
+          }
+        }
+      }
+      *tokenType = TOKEN_STRING;
+      return i + (c!=0);
+    }
+    case '[': {
+      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+    default: {
+      if( !IdChar(*z) ){
+        break;
+      }
+      for(i=1; IdChar(z[i]); i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+  }
+  *tokenType = TOKEN_PUNCT;
+  return 1;
+}
+
+/*
+** A token extracted from a string is an instance of the following
+** structure.
+*/
+typedef struct Token {
+  const char *z;       /* Pointer to token text.  Not '\000' terminated */
+  short int n;         /* Length of the token text in bytes. */
+} Token;
+
+/*
+** Given a input string (which is really one of the argv[] parameters
+** passed into xConnect or xCreate) split the string up into tokens.
+** Return an array of pointers to '\000' terminated strings, one string
+** for each non-whitespace token.
+**
+** The returned array is terminated by a single NULL pointer.
+**
+** Space to hold the returned array is obtained from a single
+** malloc and should be freed by passing the return value to free().
+** The individual strings within the token list are all a part of
+** the single memory allocation and will all be freed at once.
+*/
+static char **tokenizeString(const char *z, int *pnToken){
+  int nToken = 0;
+  Token *aToken = malloc( strlen(z) * sizeof(aToken[0]) );
+  int n = 1;
+  int e, i;
+  int totalSize = 0;
+  char **azToken;
+  char *zCopy;
+  while( n>0 ){
+    n = getToken(z, &e);
+    if( e!=TOKEN_SPACE ){
+      aToken[nToken].z = z;
+      aToken[nToken].n = n;
+      nToken++;
+      totalSize += n+1;
+    }
+    z += n;
+  }
+  azToken = (char**)malloc( nToken*sizeof(char*) + totalSize );
+  zCopy = (char*)&azToken[nToken];
+  nToken--;
+  for(i=0; i<nToken; i++){
+    azToken[i] = zCopy;
+    n = aToken[i].n;
+    memcpy(zCopy, aToken[i].z, n);
+    zCopy[n] = 0;
+    zCopy += n+1;
+  }
+  azToken[nToken] = 0;
+  free(aToken);
+  *pnToken = nToken;
+  return azToken;
+}
+
+/*
+** 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.
+**
+** Examples:
+**
+**     "abc"   becomes   abc
+**     'xyz'   becomes   xyz
+**     [pqr]   becomes   pqr
+**     `mno`   becomes   mno
+*/
+static void dequoteString(char *z){
+  int quote;
+  int i, j;
+  if( z==0 ) return;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return;
+  }
+  for(i=1, j=0; z[i]; i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        z[j++] = 0;
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+}
+
+/*
+** The input azIn is a NULL-terminated list of tokens.  Remove the first
+** token and all punctuation tokens.  Remove the quotes from
+** around string literal tokens.
+**
+** Example:
+**
+**     input:      tokenize chinese ( 'simplifed' , 'mixed' )
+**     output:     chinese simplifed mixed
+**
+** Another example:
+**
+**     input:      delimiters ( '[' , ']' , '...' )
+**     output:     [ ] ...
+*/
+static void tokenListToIdList(char **azIn){
+  int i, j;
+  if( azIn ){
+    for(i=0, j=-1; azIn[i]; i++){
+      if( safe_isalnum(azIn[i][0]) || azIn[i][1] ){
+        dequoteString(azIn[i]);
+        if( j>=0 ){
+          azIn[j] = azIn[i];
+        }
+        j++;
+      }
+    }
+    azIn[j] = 0;
+  }
+}
+
+
+/*
+** Find the first alphanumeric token in the string zIn.  Null-terminate
+** this token.  Remove any quotation marks.  And return a pointer to
+** the result.
+*/
+static char *firstToken(char *zIn, char **pzTail){
+  int n, ttype;
+  while(1){
+    n = getToken(zIn, &ttype);
+    if( ttype==TOKEN_SPACE ){
+      zIn += n;
+    }else if( ttype==TOKEN_EOF ){
+      *pzTail = zIn;
+      return 0;
+    }else{
+      zIn[n] = 0;
+      *pzTail = &zIn[1];
+      dequoteString(zIn);
+      return zIn;
+    }
+  }
+  /*NOTREACHED*/
+}
+
+/* Return true if...
+**
+**   *  s begins with the string t, ignoring case
+**   *  s is longer than t
+**   *  The first character of s beyond t is not a alphanumeric
+** 
+** Ignore leading space in *s.
+**
+** To put it another way, return true if the first token of
+** s[] is t[].
+*/
+static int startsWith(const char *s, const char *t){
+  while( safe_isspace(*s) ){ s++; }
+  while( *t ){
+    if( safe_tolower(*s++)!=safe_tolower(*t++) ) return 0;
+  }
+  return *s!='_' && !safe_isalnum(*s);
+}
+
+/*
+** An instance of this structure defines the "spec" of a
+** full text index.  This structure is populated by parseSpec
+** and use by fulltextConnect and fulltextCreate.
+*/
+typedef struct TableSpec {
+  const char *zDb;         /* Logical database name */
+  const char *zName;       /* Name of the full-text index */
+  int nColumn;             /* Number of columns to be indexed */
+  char **azColumn;         /* Original names of columns to be indexed */
+  char **azContentColumn;  /* Column names for %_content */
+  char **azTokenizer;      /* Name of tokenizer and its arguments */
+} TableSpec;
+
+/*
+** Reclaim all of the memory used by a TableSpec
+*/
+static void clearTableSpec(TableSpec *p) {
+  free(p->azColumn);
+  free(p->azContentColumn);
+  free(p->azTokenizer);
+}
+
+/* Parse a CREATE VIRTUAL TABLE statement, which looks like this:
+ *
+ * CREATE VIRTUAL TABLE email
+ *        USING fts2(subject, body, tokenize mytokenizer(myarg))
+ *
+ * We return parsed information in a TableSpec structure.
+ * 
+ */
+static int parseSpec(TableSpec *pSpec, int argc, const char *const*argv,
+                     char**pzErr){
+  int i, n;
+  char *z, *zDummy;
+  char **azArg;
+  const char *zTokenizer = 0;    /* argv[] entry describing the tokenizer */
+
+  assert( argc>=3 );
+  /* Current interface:
+  ** argv[0] - module name
+  ** argv[1] - database name
+  ** argv[2] - table name
+  ** argv[3..] - columns, optionally followed by tokenizer specification
+  **             and snippet delimiters specification.
+  */
+
+  /* Make a copy of the complete argv[][] array in a single allocation.
+  ** The argv[][] array is read-only and transient.  We can write to the
+  ** copy in order to modify things and the copy is persistent.
+  */
+  CLEAR(pSpec);
+  for(i=n=0; i<argc; i++){
+    n += strlen(argv[i]) + 1;
+  }
+  azArg = malloc( sizeof(char*)*argc + n );
+  if( azArg==0 ){
+    return SQLITE_NOMEM;
+  }
+  z = (char*)&azArg[argc];
+  for(i=0; i<argc; i++){
+    azArg[i] = z;
+    strcpy(z, argv[i]);
+    z += strlen(z)+1;
+  }
+
+  /* Identify the column names and the tokenizer and delimiter arguments
+  ** in the argv[][] array.
+  */
+  pSpec->zDb = azArg[1];
+  pSpec->zName = azArg[2];
+  pSpec->nColumn = 0;
+  pSpec->azColumn = azArg;
+  zTokenizer = "tokenize simple";
+  for(i=3; i<argc; ++i){
+    if( startsWith(azArg[i],"tokenize") ){
+      zTokenizer = azArg[i];
+    }else{
+      z = azArg[pSpec->nColumn] = firstToken(azArg[i], &zDummy);
+      pSpec->nColumn++;
+    }
+  }
+  if( pSpec->nColumn==0 ){
+    azArg[0] = "content";
+    pSpec->nColumn = 1;
+  }
+
+  /*
+  ** Construct the list of content column names.
+  **
+  ** Each content column name will be of the form cNNAAAA
+  ** where NN is the column number and AAAA is the sanitized
+  ** column name.  "sanitized" means that special characters are
+  ** converted to "_".  The cNN prefix guarantees that all column
+  ** names are unique.
+  **
+  ** The AAAA suffix is not strictly necessary.  It is included
+  ** for the convenience of people who might examine the generated
+  ** %_content table and wonder what the columns are used for.
+  */
+  pSpec->azContentColumn = malloc( pSpec->nColumn * sizeof(char *) );
+  if( pSpec->azContentColumn==0 ){
+    clearTableSpec(pSpec);
+    return SQLITE_NOMEM;
+  }
+  for(i=0; i<pSpec->nColumn; i++){
+    char *p;
+    pSpec->azContentColumn[i] = sqlite3_mprintf("c%d%s", i, azArg[i]);
+    for (p = pSpec->azContentColumn[i]; *p ; ++p) {
+      if( !safe_isalnum(*p) ) *p = '_';
+    }
+  }
+
+  /*
+  ** Parse the tokenizer specification string.
+  */
+  pSpec->azTokenizer = tokenizeString(zTokenizer, &n);
+  tokenListToIdList(pSpec->azTokenizer);
+
+  return SQLITE_OK;
+}
+
+/*
+** Generate a CREATE TABLE statement that describes the schema of
+** the virtual table.  Return a pointer to this schema string.
+**
+** Space is obtained from sqlite3_mprintf() and should be freed
+** using sqlite3_free().
+*/
+static char *fulltextSchema(
+  int nColumn,                  /* Number of columns */
+  const char *const* azColumn,  /* List of columns */
+  const char *zTableName        /* Name of the table */
+){
+  int i;
+  char *zSchema, *zNext;
+  const char *zSep = "(";
+  zSchema = sqlite3_mprintf("CREATE TABLE x");
+  for(i=0; i<nColumn; i++){
+    zNext = sqlite3_mprintf("%s%s%Q", zSchema, zSep, azColumn[i]);
+    sqlite3_free(zSchema);
+    zSchema = zNext;
+    zSep = ",";
+  }
+  zNext = sqlite3_mprintf("%s,%Q)", zSchema, zTableName);
+  sqlite3_free(zSchema);
+  return zNext;
+}
+
+/*
+** Build a new sqlite3_vtab structure that will describe the
+** fulltext index defined by spec.
+*/
+static int constructVtab(
+  sqlite3 *db,              /* The SQLite database connection */
+  fts2Hash *pHash,          /* Hash table containing tokenizers */
+  TableSpec *spec,          /* Parsed spec information from parseSpec() */
+  sqlite3_vtab **ppVTab,    /* Write the resulting vtab structure here */
+  char **pzErr              /* Write any error message here */
+){
+  int rc;
+  int n;
+  fulltext_vtab *v = 0;
+  const sqlite3_tokenizer_module *m = NULL;
+  char *schema;
+
+  char const *zTok;         /* Name of tokenizer to use for this fts table */
+  int nTok;                 /* Length of zTok, including nul terminator */
+
+  v = (fulltext_vtab *) malloc(sizeof(fulltext_vtab));
+  if( v==0 ) return SQLITE_NOMEM;
+  CLEAR(v);
+  /* sqlite will initialize v->base */
+  v->db = db;
+  v->zDb = spec->zDb;       /* Freed when azColumn is freed */
+  v->zName = spec->zName;   /* Freed when azColumn is freed */
+  v->nColumn = spec->nColumn;
+  v->azContentColumn = spec->azContentColumn;
+  spec->azContentColumn = 0;
+  v->azColumn = spec->azColumn;
+  spec->azColumn = 0;
+
+  if( spec->azTokenizer==0 ){
+    return SQLITE_NOMEM;
+  }
+
+  zTok = spec->azTokenizer[0]; 
+  if( !zTok ){
+    zTok = "simple";
+  }
+  nTok = strlen(zTok)+1;
+
+  m = (sqlite3_tokenizer_module *)sqlite3Fts2HashFind(pHash, zTok, nTok);
+  if( !m ){
+    *pzErr = sqlite3_mprintf("unknown tokenizer: %s", spec->azTokenizer[0]);
+    rc = SQLITE_ERROR;
+    goto err;
+  }
+
+  for(n=0; spec->azTokenizer[n]; n++){}
+  if( n ){
+    rc = m->xCreate(n-1, (const char*const*)&spec->azTokenizer[1],
+                    &v->pTokenizer);
+  }else{
+    rc = m->xCreate(0, 0, &v->pTokenizer);
+  }
+  if( rc!=SQLITE_OK ) goto err;
+  v->pTokenizer->pModule = m;
+
+  /* TODO: verify the existence of backing tables foo_content, foo_term */
+
+  schema = fulltextSchema(v->nColumn, (const char*const*)v->azColumn,
+                          spec->zName);
+  rc = sqlite3_declare_vtab(db, schema);
+  sqlite3_free(schema);
+  if( rc!=SQLITE_OK ) goto err;
+
+  memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
+
+  /* Indicate that the buffer is not live. */
+  v->nPendingData = -1;
+
+  *ppVTab = &v->base;
+  TRACE(("FTS2 Connect %p\n", v));
+
+  return rc;
+
+err:
+  fulltext_vtab_destroy(v);
+  return rc;
+}
+
+static int fulltextConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVTab,
+  char **pzErr
+){
+  TableSpec spec;
+  int rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = constructVtab(db, (fts2Hash *)pAux, &spec, ppVTab, pzErr);
+  clearTableSpec(&spec);
+  return rc;
+}
+
+/* The %_content table holds the text of each document, with
+** the rowid used as the docid.
+*/
+/* TODO(shess) This comment needs elaboration to match the updated
+** code.  Work it into the top-of-file comment at that time.
+*/
+static int fulltextCreate(sqlite3 *db, void *pAux,
+                          int argc, const char * const *argv,
+                          sqlite3_vtab **ppVTab, char **pzErr){
+  int rc;
+  TableSpec spec;
+  StringBuffer schema;
+  TRACE(("FTS2 Create\n"));
+
+  rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  initStringBuffer(&schema);
+  append(&schema, "CREATE TABLE %_content(");
+  appendList(&schema, spec.nColumn, spec.azContentColumn);
+  append(&schema, ")");
+  rc = sql_exec(db, spec.zDb, spec.zName, stringBufferData(&schema));
+  stringBufferDestroy(&schema);
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = sql_exec(db, spec.zDb, spec.zName,
+                "create table %_segments(block blob);");
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = sql_exec(db, spec.zDb, spec.zName,
+                "create table %_segdir("
+                "  level integer,"
+                "  idx integer,"
+                "  start_block integer,"
+                "  leaves_end_block integer,"
+                "  end_block integer,"
+                "  root blob,"
+                "  primary key(level, idx)"
+                ");");
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = constructVtab(db, (fts2Hash *)pAux, &spec, ppVTab, pzErr);
+
+out:
+  clearTableSpec(&spec);
+  return rc;
+}
+
+/* Decide how to handle an SQL query. */
+static int fulltextBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
+  int i;
+  TRACE(("FTS2 BestIndex\n"));
+
+  for(i=0; i<pInfo->nConstraint; ++i){
+    const struct sqlite3_index_constraint *pConstraint;
+    pConstraint = &pInfo->aConstraint[i];
+    if( pConstraint->usable ) {
+      if( pConstraint->iColumn==-1 &&
+          pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
+        pInfo->idxNum = QUERY_ROWID;      /* lookup by rowid */
+        TRACE(("FTS2 QUERY_ROWID\n"));
+      } else if( pConstraint->iColumn>=0 &&
+                 pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
+        /* full-text search */
+        pInfo->idxNum = QUERY_FULLTEXT + pConstraint->iColumn;
+        TRACE(("FTS2 QUERY_FULLTEXT %d\n", pConstraint->iColumn));
+      } else continue;
+
+      pInfo->aConstraintUsage[i].argvIndex = 1;
+      pInfo->aConstraintUsage[i].omit = 1;
+
+      /* An arbitrary value for now.
+       * TODO: Perhaps rowid matches should be considered cheaper than
+       * full-text searches. */
+      pInfo->estimatedCost = 1.0;   
+
+      return SQLITE_OK;
+    }
+  }
+  pInfo->idxNum = QUERY_GENERIC;
+  return SQLITE_OK;
+}
+
+static int fulltextDisconnect(sqlite3_vtab *pVTab){
+  TRACE(("FTS2 Disconnect %p\n", pVTab));
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextDestroy(sqlite3_vtab *pVTab){
+  fulltext_vtab *v = (fulltext_vtab *)pVTab;
+  int rc;
+
+  TRACE(("FTS2 Destroy %p\n", pVTab));
+  rc = sql_exec(v->db, v->zDb, v->zName,
+                "drop table if exists %_content;"
+                "drop table if exists %_segments;"
+                "drop table if exists %_segdir;"
+                );
+  if( rc!=SQLITE_OK ) return rc;
+
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  fulltext_cursor *c;
+
+  c = (fulltext_cursor *) calloc(sizeof(fulltext_cursor), 1);
+  /* sqlite will initialize c->base */
+  *ppCursor = &c->base;
+  TRACE(("FTS2 Open %p: %p\n", pVTab, c));
+
+  return SQLITE_OK;
+}
+
+
+/* Free all of the dynamically allocated memory held by *q
+*/
+static void queryClear(Query *q){
+  int i;
+  for(i = 0; i < q->nTerms; ++i){
+    free(q->pTerms[i].pTerm);
+  }
+  free(q->pTerms);
+  CLEAR(q);
+}
+
+/* Free all of the dynamically allocated memory held by the
+** Snippet
+*/
+static void snippetClear(Snippet *p){
+  free(p->aMatch);
+  free(p->zOffset);
+  free(p->zSnippet);
+  CLEAR(p);
+}
+/*
+** Append a single entry to the p->aMatch[] log.
+*/
+static void snippetAppendMatch(
+  Snippet *p,               /* Append the entry to this snippet */
+  int iCol, int iTerm,      /* The column and query term */
+  int iStart, int nByte     /* Offset and size of the match */
+){
+  int i;
+  struct snippetMatch *pMatch;
+  if( p->nMatch+1>=p->nAlloc ){
+    p->nAlloc = p->nAlloc*2 + 10;
+    p->aMatch = realloc(p->aMatch, p->nAlloc*sizeof(p->aMatch[0]) );
+    if( p->aMatch==0 ){
+      p->nMatch = 0;
+      p->nAlloc = 0;
+      return;
+    }
+  }
+  i = p->nMatch++;
+  pMatch = &p->aMatch[i];
+  pMatch->iCol = iCol;
+  pMatch->iTerm = iTerm;
+  pMatch->iStart = iStart;
+  pMatch->nByte = nByte;
+}
+
+/*
+** Sizing information for the circular buffer used in snippetOffsetsOfColumn()
+*/
+#define FTS2_ROTOR_SZ   (32)
+#define FTS2_ROTOR_MASK (FTS2_ROTOR_SZ-1)
+
+/*
+** Add entries to pSnippet->aMatch[] for every match that occurs against
+** document zDoc[0..nDoc-1] which is stored in column iColumn.
+*/
+static void snippetOffsetsOfColumn(
+  Query *pQuery,
+  Snippet *pSnippet,
+  int iColumn,
+  const char *zDoc,
+  int nDoc
+){
+  const sqlite3_tokenizer_module *pTModule;  /* The tokenizer module */
+  sqlite3_tokenizer *pTokenizer;             /* The specific tokenizer */
+  sqlite3_tokenizer_cursor *pTCursor;        /* Tokenizer cursor */
+  fulltext_vtab *pVtab;                /* The full text index */
+  int nColumn;                         /* Number of columns in the index */
+  const QueryTerm *aTerm;              /* Query string terms */
+  int nTerm;                           /* Number of query string terms */  
+  int i, j;                            /* Loop counters */
+  int rc;                              /* Return code */
+  unsigned int match, prevMatch;       /* Phrase search bitmasks */
+  const char *zToken;                  /* Next token from the tokenizer */
+  int nToken;                          /* Size of zToken */
+  int iBegin, iEnd, iPos;              /* Offsets of beginning and end */
+
+  /* The following variables keep a circular buffer of the last
+  ** few tokens */
+  unsigned int iRotor = 0;             /* Index of current token */
+  int iRotorBegin[FTS2_ROTOR_SZ];      /* Beginning offset of token */
+  int iRotorLen[FTS2_ROTOR_SZ];        /* Length of token */
+
+  pVtab = pQuery->pFts;
+  nColumn = pVtab->nColumn;
+  pTokenizer = pVtab->pTokenizer;
+  pTModule = pTokenizer->pModule;
+  rc = pTModule->xOpen(pTokenizer, zDoc, nDoc, &pTCursor);
+  if( rc ) return;
+  pTCursor->pTokenizer = pTokenizer;
+  aTerm = pQuery->pTerms;
+  nTerm = pQuery->nTerms;
+  if( nTerm>=FTS2_ROTOR_SZ ){
+    nTerm = FTS2_ROTOR_SZ - 1;
+  }
+  prevMatch = 0;
+  while(1){
+    rc = pTModule->xNext(pTCursor, &zToken, &nToken, &iBegin, &iEnd, &iPos);
+    if( rc ) break;
+    iRotorBegin[iRotor&FTS2_ROTOR_MASK] = iBegin;
+    iRotorLen[iRotor&FTS2_ROTOR_MASK] = iEnd-iBegin;
+    match = 0;
+    for(i=0; i<nTerm; i++){
+      int iCol;
+      iCol = aTerm[i].iColumn;
+      if( iCol>=0 && iCol<nColumn && iCol!=iColumn ) continue;
+      if( aTerm[i].nTerm>nToken ) continue;
+      if( !aTerm[i].isPrefix && aTerm[i].nTerm<nToken ) continue;
+      assert( aTerm[i].nTerm<=nToken );
+      if( memcmp(aTerm[i].pTerm, zToken, aTerm[i].nTerm) ) continue;
+      if( aTerm[i].iPhrase>1 && (prevMatch & (1<<i))==0 ) continue;
+      match |= 1<<i;
+      if( i==nTerm-1 || aTerm[i+1].iPhrase==1 ){
+        for(j=aTerm[i].iPhrase-1; j>=0; j--){
+          int k = (iRotor-j) & FTS2_ROTOR_MASK;
+          snippetAppendMatch(pSnippet, iColumn, i-j,
+                iRotorBegin[k], iRotorLen[k]);
+        }
+      }
+    }
+    prevMatch = match<<1;
+    iRotor++;
+  }
+  pTModule->xClose(pTCursor);  
+}
+
+
+/*
+** Compute all offsets for the current row of the query.  
+** If the offsets have already been computed, this routine is a no-op.
+*/
+static void snippetAllOffsets(fulltext_cursor *p){
+  int nColumn;
+  int iColumn, i;
+  int iFirst, iLast;
+  fulltext_vtab *pFts;
+
+  if( p->snippet.nMatch ) return;
+  if( p->q.nTerms==0 ) return;
+  pFts = p->q.pFts;
+  nColumn = pFts->nColumn;
+  iColumn = (p->iCursorType - QUERY_FULLTEXT);
+  if( iColumn<0 || iColumn>=nColumn ){
+    iFirst = 0;
+    iLast = nColumn-1;
+  }else{
+    iFirst = iColumn;
+    iLast = iColumn;
+  }
+  for(i=iFirst; i<=iLast; i++){
+    const char *zDoc;
+    int nDoc;
+    zDoc = (const char*)sqlite3_column_text(p->pStmt, i+1);
+    nDoc = sqlite3_column_bytes(p->pStmt, i+1);
+    snippetOffsetsOfColumn(&p->q, &p->snippet, i, zDoc, nDoc);
+  }
+}
+
+/*
+** Convert the information in the aMatch[] array of the snippet
+** into the string zOffset[0..nOffset-1].
+*/
+static void snippetOffsetText(Snippet *p){
+  int i;
+  int cnt = 0;
+  StringBuffer sb;
+  char zBuf[200];
+  if( p->zOffset ) return;
+  initStringBuffer(&sb);
+  for(i=0; i<p->nMatch; i++){
+    struct snippetMatch *pMatch = &p->aMatch[i];
+    zBuf[0] = ' ';
+    sprintf(&zBuf[cnt>0], "%d %d %d %d", pMatch->iCol,
+        pMatch->iTerm, pMatch->iStart, pMatch->nByte);
+    append(&sb, zBuf);
+    cnt++;
+  }
+  p->zOffset = stringBufferData(&sb);
+  p->nOffset = stringBufferLength(&sb);
+}
+
+/*
+** zDoc[0..nDoc-1] is phrase of text.  aMatch[0..nMatch-1] are a set
+** of matching words some of which might be in zDoc.  zDoc is column
+** number iCol.
+**
+** iBreak is suggested spot in zDoc where we could begin or end an
+** excerpt.  Return a value similar to iBreak but possibly adjusted
+** to be a little left or right so that the break point is better.
+*/
+static int wordBoundary(
+  int iBreak,                   /* The suggested break point */
+  const char *zDoc,             /* Document text */
+  int nDoc,                     /* Number of bytes in zDoc[] */
+  struct snippetMatch *aMatch,  /* Matching words */
+  int nMatch,                   /* Number of entries in aMatch[] */
+  int iCol                      /* The column number for zDoc[] */
+){
+  int i;
+  if( iBreak<=10 ){
+    return 0;
+  }
+  if( iBreak>=nDoc-10 ){
+    return nDoc;
+  }
+  for(i=0; i<nMatch && aMatch[i].iCol<iCol; i++){}
+  while( i<nMatch && aMatch[i].iStart+aMatch[i].nByte<iBreak ){ i++; }
+  if( i<nMatch ){
+    if( aMatch[i].iStart<iBreak+10 ){
+      return aMatch[i].iStart;
+    }
+    if( i>0 && aMatch[i-1].iStart+aMatch[i-1].nByte>=iBreak ){
+      return aMatch[i-1].iStart;
+    }
+  }
+  for(i=1; i<=10; i++){
+    if( safe_isspace(zDoc[iBreak-i]) ){
+      return iBreak - i + 1;
+    }
+    if( safe_isspace(zDoc[iBreak+i]) ){
+      return iBreak + i + 1;
+    }
+  }
+  return iBreak;
+}
+
+
+
+/*
+** Allowed values for Snippet.aMatch[].snStatus
+*/
+#define SNIPPET_IGNORE  0   /* It is ok to omit this match from the snippet */
+#define SNIPPET_DESIRED 1   /* We want to include this match in the snippet */
+
+/*
+** Generate the text of a snippet.
+*/
+static void snippetText(
+  fulltext_cursor *pCursor,   /* The cursor we need the snippet for */
+  const char *zStartMark,     /* Markup to appear before each match */
+  const char *zEndMark,       /* Markup to appear after each match */
+  const char *zEllipsis       /* Ellipsis mark */
+){
+  int i, j;
+  struct snippetMatch *aMatch;
+  int nMatch;
+  int nDesired;
+  StringBuffer sb;
+  int tailCol;
+  int tailOffset;
+  int iCol;
+  int nDoc;
+  const char *zDoc;
+  int iStart, iEnd;
+  int tailEllipsis = 0;
+  int iMatch;
+  
+
+  free(pCursor->snippet.zSnippet);
+  pCursor->snippet.zSnippet = 0;
+  aMatch = pCursor->snippet.aMatch;
+  nMatch = pCursor->snippet.nMatch;
+  initStringBuffer(&sb);
+
+  for(i=0; i<nMatch; i++){
+    aMatch[i].snStatus = SNIPPET_IGNORE;
+  }
+  nDesired = 0;
+  for(i=0; i<pCursor->q.nTerms; i++){
+    for(j=0; j<nMatch; j++){
+      if( aMatch[j].iTerm==i ){
+        aMatch[j].snStatus = SNIPPET_DESIRED;
+        nDesired++;
+        break;
+      }
+    }
+  }
+
+  iMatch = 0;
+  tailCol = -1;
+  tailOffset = 0;
+  for(i=0; i<nMatch && nDesired>0; i++){
+    if( aMatch[i].snStatus!=SNIPPET_DESIRED ) continue;
+    nDesired--;
+    iCol = aMatch[i].iCol;
+    zDoc = (const char*)sqlite3_column_text(pCursor->pStmt, iCol+1);
+    nDoc = sqlite3_column_bytes(pCursor->pStmt, iCol+1);
+    iStart = aMatch[i].iStart - 40;
+    iStart = wordBoundary(iStart, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iStart<=10 ){
+      iStart = 0;
+    }
+    if( iCol==tailCol && iStart<=tailOffset+20 ){
+      iStart = tailOffset;
+    }
+    if( (iCol!=tailCol && tailCol>=0) || iStart!=tailOffset ){
+      trimWhiteSpace(&sb);
+      appendWhiteSpace(&sb);
+      append(&sb, zEllipsis);
+      appendWhiteSpace(&sb);
+    }
+    iEnd = aMatch[i].iStart + aMatch[i].nByte + 40;
+    iEnd = wordBoundary(iEnd, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iEnd>=nDoc-10 ){
+      iEnd = nDoc;
+      tailEllipsis = 0;
+    }else{
+      tailEllipsis = 1;
+    }
+    while( iMatch<nMatch && aMatch[iMatch].iCol<iCol ){ iMatch++; }
+    while( iStart<iEnd ){
+      while( iMatch<nMatch && aMatch[iMatch].iStart<iStart
+             && aMatch[iMatch].iCol<=iCol ){
+        iMatch++;
+      }
+      if( iMatch<nMatch && aMatch[iMatch].iStart<iEnd
+             && aMatch[iMatch].iCol==iCol ){
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].iStart - iStart);
+        iStart = aMatch[iMatch].iStart;
+        append(&sb, zStartMark);
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].nByte);
+        append(&sb, zEndMark);
+        iStart += aMatch[iMatch].nByte;
+        for(j=iMatch+1; j<nMatch; j++){
+          if( aMatch[j].iTerm==aMatch[iMatch].iTerm
+              && aMatch[j].snStatus==SNIPPET_DESIRED ){
+            nDesired--;
+            aMatch[j].snStatus = SNIPPET_IGNORE;
+          }
+        }
+      }else{
+        nappend(&sb, &zDoc[iStart], iEnd - iStart);
+        iStart = iEnd;
+      }
+    }
+    tailCol = iCol;
+    tailOffset = iEnd;
+  }
+  trimWhiteSpace(&sb);
+  if( tailEllipsis ){
+    appendWhiteSpace(&sb);
+    append(&sb, zEllipsis);
+  }
+  pCursor->snippet.zSnippet = stringBufferData(&sb);
+  pCursor->snippet.nSnippet = stringBufferLength(&sb);
+}
+
+
+/*
+** Close the cursor.  For additional information see the documentation
+** on the xClose method of the virtual table interface.
+*/
+static int fulltextClose(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  TRACE(("FTS2 Close %p\n", c));
+  sqlite3_finalize(c->pStmt);
+  queryClear(&c->q);
+  snippetClear(&c->snippet);
+  if( c->result.nData!=0 ) dlrDestroy(&c->reader);
+  dataBufferDestroy(&c->result);
+  free(c);
+  return SQLITE_OK;
+}
+
+static int fulltextNext(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  int rc;
+
+  TRACE(("FTS2 Next %p\n", pCursor));
+  snippetClear(&c->snippet);
+  if( c->iCursorType < QUERY_FULLTEXT ){
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    switch( rc ){
+      case SQLITE_ROW:
+        c->eof = 0;
+        return SQLITE_OK;
+      case SQLITE_DONE:
+        c->eof = 1;
+        return SQLITE_OK;
+      default:
+        c->eof = 1;
+        return rc;
+    }
+  } else {  /* full-text query */
+    rc = sqlite3_reset(c->pStmt);
+    if( rc!=SQLITE_OK ) return rc;
+
+    if( c->result.nData==0 || dlrAtEnd(&c->reader) ){
+      c->eof = 1;
+      return SQLITE_OK;
+    }
+    rc = sqlite3_bind_int64(c->pStmt, 1, dlrDocid(&c->reader));
+    dlrStep(&c->reader);
+    if( rc!=SQLITE_OK ) return rc;
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    if( rc==SQLITE_ROW ){   /* the case we expect */
+      c->eof = 0;
+      return SQLITE_OK;
+    }
+    /* an error occurred; abort */
+    return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+  }
+}
+
+
+/* TODO(shess) If we pushed LeafReader to the top of the file, or to
+** another file, term_select() could be pushed above
+** docListOfTerm().
+*/
+static int termSelect(fulltext_vtab *v, int iColumn,
+                      const char *pTerm, int nTerm, int isPrefix,
+                      DocListType iType, DataBuffer *out);
+
+/* Return a DocList corresponding to the query term *pTerm.  If *pTerm
+** is the first term of a phrase query, go ahead and evaluate the phrase
+** query and return the doclist for the entire phrase query.
+**
+** The resulting DL_DOCIDS doclist is stored in pResult, which is
+** overwritten.
+*/
+static int docListOfTerm(
+  fulltext_vtab *v,   /* The full text index */
+  int iColumn,        /* column to restrict to.  No restriction if >=nColumn */
+  QueryTerm *pQTerm,  /* Term we are looking for, or 1st term of a phrase */
+  DataBuffer *pResult /* Write the result here */
+){
+  DataBuffer left, right, new;
+  int i, rc;
+
+  /* No phrase search if no position info. */
+  assert( pQTerm->nPhrase==0 || DL_DEFAULT!=DL_DOCIDS );
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&left, 0);
+  rc = termSelect(v, iColumn, pQTerm->pTerm, pQTerm->nTerm, pQTerm->isPrefix,
+                  0<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS, &left);
+  if( rc ) return rc;
+  for(i=1; i<=pQTerm->nPhrase && left.nData>0; i++){
+    dataBufferInit(&right, 0);
+    rc = termSelect(v, iColumn, pQTerm[i].pTerm, pQTerm[i].nTerm,
+                    pQTerm[i].isPrefix, DL_POSITIONS, &right);
+    if( rc ){
+      dataBufferDestroy(&left);
+      return rc;
+    }
+    dataBufferInit(&new, 0);
+    docListPhraseMerge(left.pData, left.nData, right.pData, right.nData,
+                       i<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS, &new);
+    dataBufferDestroy(&left);
+    dataBufferDestroy(&right);
+    left = new;
+  }
+  *pResult = left;
+  return SQLITE_OK;
+}
+
+/* Add a new term pTerm[0..nTerm-1] to the query *q.
+*/
+static void queryAdd(Query *q, const char *pTerm, int nTerm){
+  QueryTerm *t;
+  ++q->nTerms;
+  q->pTerms = realloc(q->pTerms, q->nTerms * sizeof(q->pTerms[0]));
+  if( q->pTerms==0 ){
+    q->nTerms = 0;
+    return;
+  }
+  t = &q->pTerms[q->nTerms - 1];
+  CLEAR(t);
+  t->pTerm = malloc(nTerm+1);
+  memcpy(t->pTerm, pTerm, nTerm);
+  t->pTerm[nTerm] = 0;
+  t->nTerm = nTerm;
+  t->isOr = q->nextIsOr;
+  t->isPrefix = 0;
+  q->nextIsOr = 0;
+  t->iColumn = q->nextColumn;
+  q->nextColumn = q->dfltColumn;
+}
+
+/*
+** Check to see if the string zToken[0...nToken-1] matches any
+** column name in the virtual table.   If it does,
+** return the zero-indexed column number.  If not, return -1.
+*/
+static int checkColumnSpecifier(
+  fulltext_vtab *pVtab,    /* The virtual table */
+  const char *zToken,      /* Text of the token */
+  int nToken               /* Number of characters in the token */
+){
+  int i;
+  for(i=0; i<pVtab->nColumn; i++){
+    if( memcmp(pVtab->azColumn[i], zToken, nToken)==0
+        && pVtab->azColumn[i][nToken]==0 ){
+      return i;
+    }
+  }
+  return -1;
+}
+
+/*
+** Parse the text at pSegment[0..nSegment-1].  Add additional terms
+** to the query being assemblied in pQuery.
+**
+** inPhrase is true if pSegment[0..nSegement-1] is contained within
+** double-quotes.  If inPhrase is true, then the first term
+** is marked with the number of terms in the phrase less one and
+** OR and "-" syntax is ignored.  If inPhrase is false, then every
+** term found is marked with nPhrase=0 and OR and "-" syntax is significant.
+*/
+static int tokenizeSegment(
+  sqlite3_tokenizer *pTokenizer,          /* The tokenizer to use */
+  const char *pSegment, int nSegment,     /* Query expression being parsed */
+  int inPhrase,                           /* True if within "..." */
+  Query *pQuery                           /* Append results here */
+){
+  const sqlite3_tokenizer_module *pModule = pTokenizer->pModule;
+  sqlite3_tokenizer_cursor *pCursor;
+  int firstIndex = pQuery->nTerms;
+  int iCol;
+  int nTerm = 1;
+  
+  int rc = pModule->xOpen(pTokenizer, pSegment, nSegment, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+  pCursor->pTokenizer = pTokenizer;
+
+  while( 1 ){
+    const char *pToken;
+    int nToken, iBegin, iEnd, iPos;
+
+    rc = pModule->xNext(pCursor,
+                        &pToken, &nToken,
+                        &iBegin, &iEnd, &iPos);
+    if( rc!=SQLITE_OK ) break;
+    if( !inPhrase &&
+        pSegment[iEnd]==':' &&
+         (iCol = checkColumnSpecifier(pQuery->pFts, pToken, nToken))>=0 ){
+      pQuery->nextColumn = iCol;
+      continue;
+    }
+    if( !inPhrase && pQuery->nTerms>0 && nToken==2
+         && pSegment[iBegin]=='O' && pSegment[iBegin+1]=='R' ){
+      pQuery->nextIsOr = 1;
+      continue;
+    }
+    queryAdd(pQuery, pToken, nToken);
+    if( !inPhrase && iBegin>0 && pSegment[iBegin-1]=='-' ){
+      pQuery->pTerms[pQuery->nTerms-1].isNot = 1;
+    }
+    if( iEnd<nSegment && pSegment[iEnd]=='*' ){
+      pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
+    }
+    pQuery->pTerms[pQuery->nTerms-1].iPhrase = nTerm;
+    if( inPhrase ){
+      nTerm++;
+    }
+  }
+
+  if( inPhrase && pQuery->nTerms>firstIndex ){
+    pQuery->pTerms[firstIndex].nPhrase = pQuery->nTerms - firstIndex - 1;
+  }
+
+  return pModule->xClose(pCursor);
+}
+
+/* Parse a query string, yielding a Query object pQuery.
+**
+** The calling function will need to queryClear() to clean up
+** the dynamically allocated memory held by pQuery.
+*/
+static int parseQuery(
+  fulltext_vtab *v,        /* The fulltext index */
+  const char *zInput,      /* Input text of the query string */
+  int nInput,              /* Size of the input text */
+  int dfltColumn,          /* Default column of the index to match against */
+  Query *pQuery            /* Write the parse results here. */
+){
+  int iInput, inPhrase = 0;
+
+  if( zInput==0 ) nInput = 0;
+  if( nInput<0 ) nInput = strlen(zInput);
+  pQuery->nTerms = 0;
+  pQuery->pTerms = NULL;
+  pQuery->nextIsOr = 0;
+  pQuery->nextColumn = dfltColumn;
+  pQuery->dfltColumn = dfltColumn;
+  pQuery->pFts = v;
+
+  for(iInput=0; iInput<nInput; ++iInput){
+    int i;
+    for(i=iInput; i<nInput && zInput[i]!='"'; ++i){}
+    if( i>iInput ){
+      tokenizeSegment(v->pTokenizer, zInput+iInput, i-iInput, inPhrase,
+                       pQuery);
+    }
+    iInput = i;
+    if( i<nInput ){
+      assert( zInput[i]=='"' );
+      inPhrase = !inPhrase;
+    }
+  }
+
+  if( inPhrase ){
+    /* unmatched quote */
+    queryClear(pQuery);
+    return SQLITE_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/* TODO(shess) Refactor the code to remove this forward decl. */
+static int flushPendingTerms(fulltext_vtab *v);
+
+/* Perform a full-text query using the search expression in
+** zInput[0..nInput-1].  Return a list of matching documents
+** in pResult.
+**
+** Queries must match column iColumn.  Or if iColumn>=nColumn
+** they are allowed to match against any column.
+*/
+static int fulltextQuery(
+  fulltext_vtab *v,      /* The full text index */
+  int iColumn,           /* Match against this column by default */
+  const char *zInput,    /* The query string */
+  int nInput,            /* Number of bytes in zInput[] */
+  DataBuffer *pResult,   /* Write the result doclist here */
+  Query *pQuery          /* Put parsed query string here */
+){
+  int i, iNext, rc;
+  DataBuffer left, right, or, new;
+  int nNot = 0;
+  QueryTerm *aTerm;
+
+  /* TODO(shess) Instead of flushing pendingTerms, we could query for
+  ** the relevant term and merge the doclist into what we receive from
+  ** the database.  Wait and see if this is a common issue, first.
+  **
+  ** A good reason not to flush is to not generate update-related
+  ** error codes from here.
+  */
+
+  /* Flush any buffered updates before executing the query. */
+  rc = flushPendingTerms(v);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* TODO(shess) I think that the queryClear() calls below are not
+  ** necessary, because fulltextClose() already clears the query.
+  */
+  rc = parseQuery(v, zInput, nInput, iColumn, pQuery);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Empty or NULL queries return no results. */
+  if( pQuery->nTerms==0 ){
+    dataBufferInit(pResult, 0);
+    return SQLITE_OK;
+  }
+
+  /* Merge AND terms. */
+  /* TODO(shess) I think we can early-exit if( i>nNot && left.nData==0 ). */
+  aTerm = pQuery->pTerms;
+  for(i = 0; i<pQuery->nTerms; i=iNext){
+    if( aTerm[i].isNot ){
+      /* Handle all NOT terms in a separate pass */
+      nNot++;
+      iNext = i + aTerm[i].nPhrase+1;
+      continue;
+    }
+    iNext = i + aTerm[i].nPhrase + 1;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &right);
+    if( rc ){
+      if( i!=nNot ) dataBufferDestroy(&left);
+      queryClear(pQuery);
+      return rc;
+    }
+    while( iNext<pQuery->nTerms && aTerm[iNext].isOr ){
+      rc = docListOfTerm(v, aTerm[iNext].iColumn, &aTerm[iNext], &or);
+      iNext += aTerm[iNext].nPhrase + 1;
+      if( rc ){
+        if( i!=nNot ) dataBufferDestroy(&left);
+        dataBufferDestroy(&right);
+        queryClear(pQuery);
+        return rc;
+      }
+      dataBufferInit(&new, 0);
+      docListOrMerge(right.pData, right.nData, or.pData, or.nData, &new);
+      dataBufferDestroy(&right);
+      dataBufferDestroy(&or);
+      right = new;
+    }
+    if( i==nNot ){           /* first term processed. */
+      left = right;
+    }else{
+      dataBufferInit(&new, 0);
+      docListAndMerge(left.pData, left.nData, right.pData, right.nData, &new);
+      dataBufferDestroy(&right);
+      dataBufferDestroy(&left);
+      left = new;
+    }
+  }
+
+  if( nNot==pQuery->nTerms ){
+    /* We do not yet know how to handle a query of only NOT terms */
+    return SQLITE_ERROR;
+  }
+
+  /* Do the EXCEPT terms */
+  for(i=0; i<pQuery->nTerms;  i += aTerm[i].nPhrase + 1){
+    if( !aTerm[i].isNot ) continue;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &right);
+    if( rc ){
+      queryClear(pQuery);
+      dataBufferDestroy(&left);
+      return rc;
+    }
+    dataBufferInit(&new, 0);
+    docListExceptMerge(left.pData, left.nData, right.pData, right.nData, &new);
+    dataBufferDestroy(&right);
+    dataBufferDestroy(&left);
+    left = new;
+  }
+
+  *pResult = left;
+  return rc;
+}
+
+/*
+** This is the xFilter interface for the virtual table.  See
+** the virtual table xFilter method documentation for additional
+** information.
+**
+** If idxNum==QUERY_GENERIC then do a full table scan against
+** the %_content table.
+**
+** If idxNum==QUERY_ROWID then do a rowid lookup for a single entry
+** in the %_content table.
+**
+** If idxNum>=QUERY_FULLTEXT then use the full text index.  The
+** column on the left-hand side of the MATCH operator is column
+** number idxNum-QUERY_FULLTEXT, 0 indexed.  argv[0] is the right-hand
+** side of the MATCH operator.
+*/
+/* TODO(shess) Upgrade the cursor initialization and destruction to
+** account for fulltextFilter() being called multiple times on the
+** same cursor.  The current solution is very fragile.  Apply fix to
+** fts2 as appropriate.
+*/
+static int fulltextFilter(
+  sqlite3_vtab_cursor *pCursor,     /* The cursor used for this query */
+  int idxNum, const char *idxStr,   /* Which indexing scheme to use */
+  int argc, sqlite3_value **argv    /* Arguments for the indexing scheme */
+){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+  int rc;
+  char *zSql;
+
+  TRACE(("FTS2 Filter %p\n",pCursor));
+
+  zSql = sqlite3_mprintf("select rowid, * from %%_content %s",
+                          idxNum==QUERY_GENERIC ? "" : "where rowid=?");
+  sqlite3_finalize(c->pStmt);
+  rc = sql_prepare(v->db, v->zDb, v->zName, &c->pStmt, zSql);
+  sqlite3_free(zSql);
+  if( rc!=SQLITE_OK ) return rc;
+
+  c->iCursorType = idxNum;
+  switch( idxNum ){
+    case QUERY_GENERIC:
+      break;
+
+    case QUERY_ROWID:
+      rc = sqlite3_bind_int64(c->pStmt, 1, sqlite3_value_int64(argv[0]));
+      if( rc!=SQLITE_OK ) return rc;
+      break;
+
+    default:   /* full-text search */
+    {
+      const char *zQuery = (const char *)sqlite3_value_text(argv[0]);
+      assert( idxNum<=QUERY_FULLTEXT+v->nColumn);
+      assert( argc==1 );
+      queryClear(&c->q);
+      if( c->result.nData!=0 ){
+        /* This case happens if the same cursor is used repeatedly. */
+        dlrDestroy(&c->reader);
+        dataBufferReset(&c->result);
+      }else{
+        dataBufferInit(&c->result, 0);
+      }
+      rc = fulltextQuery(v, idxNum-QUERY_FULLTEXT, zQuery, -1, &c->result, &c->q);
+      if( rc!=SQLITE_OK ) return rc;
+      if( c->result.nData!=0 ){
+        dlrInit(&c->reader, DL_DOCIDS, c->result.pData, c->result.nData);
+      }
+      break;
+    }
+  }
+
+  return fulltextNext(pCursor);
+}
+
+/* This is the xEof method of the virtual table.  The SQLite core
+** calls this routine to find out if it has reached the end of
+** a query's results set.
+*/
+static int fulltextEof(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  return c->eof;
+}
+
+/* This is the xColumn method of the virtual table.  The SQLite
+** core calls this method during a query when it needs the value
+** of a column from the virtual table.  This method needs to use
+** one of the sqlite3_result_*() routines to store the requested
+** value back in the pContext.
+*/
+static int fulltextColumn(sqlite3_vtab_cursor *pCursor,
+                          sqlite3_context *pContext, int idxCol){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+
+  if( idxCol<v->nColumn ){
+    sqlite3_value *pVal = sqlite3_column_value(c->pStmt, idxCol+1);
+    sqlite3_result_value(pContext, pVal);
+  }else if( idxCol==v->nColumn ){
+    /* The extra column whose name is the same as the table.
+    ** Return a blob which is a pointer to the cursor
+    */
+    sqlite3_result_blob(pContext, &c, sizeof(c), SQLITE_TRANSIENT);
+  }
+  return SQLITE_OK;
+}
+
+/* This is the xRowid method.  The SQLite core calls this routine to
+** retrive the rowid for the current row of the result set.  The
+** rowid should be written to *pRowid.
+*/
+static int fulltextRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+
+  *pRowid = sqlite3_column_int64(c->pStmt, 0);
+  return SQLITE_OK;
+}
+
+/* Add all terms in [zText] to pendingTerms table.  If [iColumn] > 0,
+** we also store positions and offsets in the hash table using that
+** column number.
+*/
+static int buildTerms(fulltext_vtab *v, sqlite_int64 iDocid,
+                      const char *zText, int iColumn){
+  sqlite3_tokenizer *pTokenizer = v->pTokenizer;
+  sqlite3_tokenizer_cursor *pCursor;
+  const char *pToken;
+  int nTokenBytes;
+  int iStartOffset, iEndOffset, iPosition;
+  int rc;
+
+  rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+
+  pCursor->pTokenizer = pTokenizer;
+  while( SQLITE_OK==pTokenizer->pModule->xNext(pCursor,
+                                               &pToken, &nTokenBytes,
+                                               &iStartOffset, &iEndOffset,
+                                               &iPosition) ){
+    DLCollector *p;
+    int nData;                   /* Size of doclist before our update. */
+
+    /* Positions can't be negative; we use -1 as a terminator internally. */
+    if( iPosition<0 ){
+      pTokenizer->pModule->xClose(pCursor);
+      return SQLITE_ERROR;
+    }
+
+    p = fts2HashFind(&v->pendingTerms, pToken, nTokenBytes);
+    if( p==NULL ){
+      nData = 0;
+      p = dlcNew(iDocid, DL_DEFAULT);
+      fts2HashInsert(&v->pendingTerms, pToken, nTokenBytes, p);
+
+      /* Overhead for our hash table entry, the key, and the value. */
+      v->nPendingData += sizeof(struct fts2HashElem)+sizeof(*p)+nTokenBytes;
+    }else{
+      nData = p->b.nData;
+      if( p->dlw.iPrevDocid!=iDocid ) dlcNext(p, iDocid);
+    }
+    if( iColumn>=0 ){
+      dlcAddPos(p, iColumn, iPosition, iStartOffset, iEndOffset);
+    }
+
+    /* Accumulate data added by dlcNew or dlcNext, and dlcAddPos. */
+    v->nPendingData += p->b.nData-nData;
+  }
+
+  /* TODO(shess) Check return?  Should this be able to cause errors at
+  ** this point?  Actually, same question about sqlite3_finalize(),
+  ** though one could argue that failure there means that the data is
+  ** not durable.  *ponder*
+  */
+  pTokenizer->pModule->xClose(pCursor);
+  return rc;
+}
+
+/* Add doclists for all terms in [pValues] to pendingTerms table. */
+static int insertTerms(fulltext_vtab *v, sqlite_int64 iRowid,
+                       sqlite3_value **pValues){
+  int i;
+  for(i = 0; i < v->nColumn ; ++i){
+    char *zText = (char*)sqlite3_value_text(pValues[i]);
+    int rc = buildTerms(v, iRowid, zText, i);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Add empty doclists for all terms in the given row's content to
+** pendingTerms.
+*/
+static int deleteTerms(fulltext_vtab *v, sqlite_int64 iRowid){
+  const char **pValues;
+  int i, rc;
+
+  /* TODO(shess) Should we allow such tables at all? */
+  if( DL_DEFAULT==DL_DOCIDS ) return SQLITE_ERROR;
+
+  rc = content_select(v, iRowid, &pValues);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i = 0 ; i < v->nColumn; ++i) {
+    rc = buildTerms(v, iRowid, pValues[i], -1);
+    if( rc!=SQLITE_OK ) break;
+  }
+
+  freeStringArray(v->nColumn, pValues);
+  return SQLITE_OK;
+}
+
+/* TODO(shess) Refactor the code to remove this forward decl. */
+static int initPendingTerms(fulltext_vtab *v, sqlite_int64 iDocid);
+
+/* Insert a row into the %_content table; set *piRowid to be the ID of the
+** new row.  Add doclists for terms to pendingTerms.
+*/
+static int index_insert(fulltext_vtab *v, sqlite3_value *pRequestRowid,
+                        sqlite3_value **pValues, sqlite_int64 *piRowid){
+  int rc;
+
+  rc = content_insert(v, pRequestRowid, pValues);  /* execute an SQL INSERT */
+  if( rc!=SQLITE_OK ) return rc;
+
+  *piRowid = sqlite3_last_insert_rowid(v->db);
+  rc = initPendingTerms(v, *piRowid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return insertTerms(v, *piRowid, pValues);
+}
+
+/* Delete a row from the %_content table; add empty doclists for terms
+** to pendingTerms.
+*/
+static int index_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  int rc = initPendingTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = deleteTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return content_delete(v, iRow);  /* execute an SQL DELETE */
+}
+
+/* Update a row in the %_content table; add delete doclists to
+** pendingTerms for old terms not in the new data, add insert doclists
+** to pendingTerms for terms in the new data.
+*/
+static int index_update(fulltext_vtab *v, sqlite_int64 iRow,
+                        sqlite3_value **pValues){
+  int rc = initPendingTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Generate an empty doclist for each term that previously appeared in this
+   * row. */
+  rc = deleteTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = content_update(v, pValues, iRow);  /* execute an SQL UPDATE */
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Now add positions for terms which appear in the updated row. */
+  return insertTerms(v, iRow, pValues);
+}
+
+/*******************************************************************/
+/* InteriorWriter is used to collect terms and block references into
+** interior nodes in %_segments.  See commentary at top of file for
+** format.
+*/
+
+/* How large interior nodes can grow. */
+#define INTERIOR_MAX 2048
+
+/* Minimum number of terms per interior node (except the root). This
+** prevents large terms from making the tree too skinny - must be >0
+** so that the tree always makes progress.  Note that the min tree
+** fanout will be INTERIOR_MIN_TERMS+1.
+*/
+#define INTERIOR_MIN_TERMS 7
+#if INTERIOR_MIN_TERMS<1
+# error INTERIOR_MIN_TERMS must be greater than 0.
+#endif
+
+/* ROOT_MAX controls how much data is stored inline in the segment
+** directory.
+*/
+/* TODO(shess) Push ROOT_MAX down to whoever is writing things.  It's
+** only here so that interiorWriterRootInfo() and leafWriterRootInfo()
+** can both see it, but if the caller passed it in, we wouldn't even
+** need a define.
+*/
+#define ROOT_MAX 1024
+#if ROOT_MAX<VARINT_MAX*2
+# error ROOT_MAX must have enough space for a header.
+#endif
+
+/* InteriorBlock stores a linked-list of interior blocks while a lower
+** layer is being constructed.
+*/
+typedef struct InteriorBlock {
+  DataBuffer term;           /* Leftmost term in block's subtree. */
+  DataBuffer data;           /* Accumulated data for the block. */
+  struct InteriorBlock *next;
+} InteriorBlock;
+
+static InteriorBlock *interiorBlockNew(int iHeight, sqlite_int64 iChildBlock,
+                                       const char *pTerm, int nTerm){
+  InteriorBlock *block = calloc(1, sizeof(InteriorBlock));
+  char c[VARINT_MAX+VARINT_MAX];
+  int n;
+
+  dataBufferInit(&block->term, 0);
+  dataBufferReplace(&block->term, pTerm, nTerm);
+
+  n = putVarint(c, iHeight);
+  n += putVarint(c+n, iChildBlock);
+  dataBufferInit(&block->data, INTERIOR_MAX);
+  dataBufferReplace(&block->data, c, n);
+
+  return block;
+}
+
+#ifndef NDEBUG
+/* Verify that the data is readable as an interior node. */
+static void interiorBlockValidate(InteriorBlock *pBlock){
+  const char *pData = pBlock->data.pData;
+  int nData = pBlock->data.nData;
+  int n, iDummy;
+  sqlite_int64 iBlockid;
+
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+
+  /* Must lead with height of node as a varint(n), n>0 */
+  n = getVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n<nData );
+  pData += n;
+  nData -= n;
+
+  /* Must contain iBlockid. */
+  n = getVarint(pData, &iBlockid);
+  assert( n>0 );
+  assert( n<=nData );
+  pData += n;
+  nData -= n;
+
+  /* Zero or more terms of positive length */
+  if( nData!=0 ){
+    /* First term is not delta-encoded. */
+    n = getVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0);
+    assert( n+iDummy<=nData );
+    pData += n+iDummy;
+    nData -= n+iDummy;
+
+    /* Following terms delta-encoded. */
+    while( nData!=0 ){
+      /* Length of shared prefix. */
+      n = getVarint32(pData, &iDummy);
+      assert( n>0 );
+      assert( iDummy>=0 );
+      assert( n<nData );
+      pData += n;
+      nData -= n;
+
+      /* Length and data of distinct suffix. */
+      n = getVarint32(pData, &iDummy);
+      assert( n>0 );
+      assert( iDummy>0 );
+      assert( n+iDummy>0);
+      assert( n+iDummy<=nData );
+      pData += n+iDummy;
+      nData -= n+iDummy;
+    }
+  }
+}
+#define ASSERT_VALID_INTERIOR_BLOCK(x) interiorBlockValidate(x)
+#else
+#define ASSERT_VALID_INTERIOR_BLOCK(x) assert( 1 )
+#endif
+
+typedef struct InteriorWriter {
+  int iHeight;                   /* from 0 at leaves. */
+  InteriorBlock *first, *last;
+  struct InteriorWriter *parentWriter;
+
+  DataBuffer term;               /* Last term written to block "last". */
+  sqlite_int64 iOpeningChildBlock; /* First child block in block "last". */
+#ifndef NDEBUG
+  sqlite_int64 iLastChildBlock;  /* for consistency checks. */
+#endif
+} InteriorWriter;
+
+/* Initialize an interior node where pTerm[nTerm] marks the leftmost
+** term in the tree.  iChildBlock is the leftmost child block at the
+** next level down the tree.
+*/
+static void interiorWriterInit(int iHeight, const char *pTerm, int nTerm,
+                               sqlite_int64 iChildBlock,
+                               InteriorWriter *pWriter){
+  InteriorBlock *block;
+  assert( iHeight>0 );
+  CLEAR(pWriter);
+
+  pWriter->iHeight = iHeight;
+  pWriter->iOpeningChildBlock = iChildBlock;
+#ifndef NDEBUG
+  pWriter->iLastChildBlock = iChildBlock;
+#endif
+  block = interiorBlockNew(iHeight, iChildBlock, pTerm, nTerm);
+  pWriter->last = pWriter->first = block;
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+  dataBufferInit(&pWriter->term, 0);
+}
+
+/* Append the child node rooted at iChildBlock to the interior node,
+** with pTerm[nTerm] as the leftmost term in iChildBlock's subtree.
+*/
+static void interiorWriterAppend(InteriorWriter *pWriter,
+                                 const char *pTerm, int nTerm,
+                                 sqlite_int64 iChildBlock){
+  char c[VARINT_MAX+VARINT_MAX];
+  int n, nPrefix = 0;
+
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+
+  /* The first term written into an interior node is actually
+  ** associated with the second child added (the first child was added
+  ** in interiorWriterInit, or in the if clause at the bottom of this
+  ** function).  That term gets encoded straight up, with nPrefix left
+  ** at 0.
+  */
+  if( pWriter->term.nData==0 ){
+    n = putVarint(c, nTerm);
+  }else{
+    while( nPrefix<pWriter->term.nData &&
+           pTerm[nPrefix]==pWriter->term.pData[nPrefix] ){
+      nPrefix++;
+    }
+
+    n = putVarint(c, nPrefix);
+    n += putVarint(c+n, nTerm-nPrefix);
+  }
+
+#ifndef NDEBUG
+  pWriter->iLastChildBlock++;
+#endif
+  assert( pWriter->iLastChildBlock==iChildBlock );
+
+  /* Overflow to a new block if the new term makes the current block
+  ** too big, and the current block already has enough terms.
+  */
+  if( pWriter->last->data.nData+n+nTerm-nPrefix>INTERIOR_MAX &&
+      iChildBlock-pWriter->iOpeningChildBlock>INTERIOR_MIN_TERMS ){
+    pWriter->last->next = interiorBlockNew(pWriter->iHeight, iChildBlock,
+                                           pTerm, nTerm);
+    pWriter->last = pWriter->last->next;
+    pWriter->iOpeningChildBlock = iChildBlock;
+    dataBufferReset(&pWriter->term);
+  }else{
+    dataBufferAppend2(&pWriter->last->data, c, n,
+                      pTerm+nPrefix, nTerm-nPrefix);
+    dataBufferReplace(&pWriter->term, pTerm, nTerm);
+  }
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+}
+
+/* Free the space used by pWriter, including the linked-list of
+** InteriorBlocks, and parentWriter, if present.
+*/
+static int interiorWriterDestroy(InteriorWriter *pWriter){
+  InteriorBlock *block = pWriter->first;
+
+  while( block!=NULL ){
+    InteriorBlock *b = block;
+    block = block->next;
+    dataBufferDestroy(&b->term);
+    dataBufferDestroy(&b->data);
+    free(b);
+  }
+  if( pWriter->parentWriter!=NULL ){
+    interiorWriterDestroy(pWriter->parentWriter);
+    free(pWriter->parentWriter);
+  }
+  dataBufferDestroy(&pWriter->term);
+  SCRAMBLE(pWriter);
+  return SQLITE_OK;
+}
+
+/* If pWriter can fit entirely in ROOT_MAX, return it as the root info
+** directly, leaving *piEndBlockid unchanged.  Otherwise, flush
+** pWriter to %_segments, building a new layer of interior nodes, and
+** recursively ask for their root into.
+*/
+static int interiorWriterRootInfo(fulltext_vtab *v, InteriorWriter *pWriter,
+                                  char **ppRootInfo, int *pnRootInfo,
+                                  sqlite_int64 *piEndBlockid){
+  InteriorBlock *block = pWriter->first;
+  sqlite_int64 iBlockid = 0;
+  int rc;
+
+  /* If we can fit the segment inline */
+  if( block==pWriter->last && block->data.nData<ROOT_MAX ){
+    *ppRootInfo = block->data.pData;
+    *pnRootInfo = block->data.nData;
+    return SQLITE_OK;
+  }
+
+  /* Flush the first block to %_segments, and create a new level of
+  ** interior node.
+  */
+  ASSERT_VALID_INTERIOR_BLOCK(block);
+  rc = block_insert(v, block->data.pData, block->data.nData, &iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+  *piEndBlockid = iBlockid;
+
+  pWriter->parentWriter = malloc(sizeof(*pWriter->parentWriter));
+  interiorWriterInit(pWriter->iHeight+1,
+                     block->term.pData, block->term.nData,
+                     iBlockid, pWriter->parentWriter);
+
+  /* Flush additional blocks and append to the higher interior
+  ** node.
+  */
+  for(block=block->next; block!=NULL; block=block->next){
+    ASSERT_VALID_INTERIOR_BLOCK(block);
+    rc = block_insert(v, block->data.pData, block->data.nData, &iBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+    *piEndBlockid = iBlockid;
+
+    interiorWriterAppend(pWriter->parentWriter,
+                         block->term.pData, block->term.nData, iBlockid);
+  }
+
+  /* Parent node gets the chance to be the root. */
+  return interiorWriterRootInfo(v, pWriter->parentWriter,
+                                ppRootInfo, pnRootInfo, piEndBlockid);
+}
+
+/****************************************************************/
+/* InteriorReader is used to read off the data from an interior node
+** (see comment at top of file for the format).
+*/
+typedef struct InteriorReader {
+  const char *pData;
+  int nData;
+
+  DataBuffer term;          /* previous term, for decoding term delta. */
+
+  sqlite_int64 iBlockid;
+} InteriorReader;
+
+static void interiorReaderDestroy(InteriorReader *pReader){
+  dataBufferDestroy(&pReader->term);
+  SCRAMBLE(pReader);
+}
+
+/* TODO(shess) The assertions are great, but what if we're in NDEBUG
+** and the blob is empty or otherwise contains suspect data?
+*/
+static void interiorReaderInit(const char *pData, int nData,
+                               InteriorReader *pReader){
+  int n, nTerm;
+
+  /* Require at least the leading flag byte */
+  assert( nData>0 );
+  assert( pData[0]!='\0' );
+
+  CLEAR(pReader);
+
+  /* Decode the base blockid, and set the cursor to the first term. */
+  n = getVarint(pData+1, &pReader->iBlockid);
+  assert( 1+n<=nData );
+  pReader->pData = pData+1+n;
+  pReader->nData = nData-(1+n);
+
+  /* A single-child interior node (such as when a leaf node was too
+  ** large for the segment directory) won't have any terms.
+  ** Otherwise, decode the first term.
+  */
+  if( pReader->nData==0 ){
+    dataBufferInit(&pReader->term, 0);
+  }else{
+    n = getVarint32(pReader->pData, &nTerm);
+    dataBufferInit(&pReader->term, nTerm);
+    dataBufferReplace(&pReader->term, pReader->pData+n, nTerm);
+    assert( n+nTerm<=pReader->nData );
+    pReader->pData += n+nTerm;
+    pReader->nData -= n+nTerm;
+  }
+}
+
+static int interiorReaderAtEnd(InteriorReader *pReader){
+  return pReader->term.nData==0;
+}
+
+static sqlite_int64 interiorReaderCurrentBlockid(InteriorReader *pReader){
+  return pReader->iBlockid;
+}
+
+static int interiorReaderTermBytes(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+  return pReader->term.nData;
+}
+static const char *interiorReaderTerm(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+  return pReader->term.pData;
+}
+
+/* Step forward to the next term in the node. */
+static void interiorReaderStep(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+
+  /* If the last term has been read, signal eof, else construct the
+  ** next term.
+  */
+  if( pReader->nData==0 ){
+    dataBufferReset(&pReader->term);
+  }else{
+    int n, nPrefix, nSuffix;
+
+    n = getVarint32(pReader->pData, &nPrefix);
+    n += getVarint32(pReader->pData+n, &nSuffix);
+
+    /* Truncate the current term and append suffix data. */
+    pReader->term.nData = nPrefix;
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
+
+    assert( n+nSuffix<=pReader->nData );
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
+  }
+  pReader->iBlockid++;
+}
+
+/* Compare the current term to pTerm[nTerm], returning strcmp-style
+** results.  If isPrefix, equality means equal through nTerm bytes.
+*/
+static int interiorReaderTermCmp(InteriorReader *pReader,
+                                 const char *pTerm, int nTerm, int isPrefix){
+  const char *pReaderTerm = interiorReaderTerm(pReader);
+  int nReaderTerm = interiorReaderTermBytes(pReader);
+  int c, n = nReaderTerm<nTerm ? nReaderTerm : nTerm;
+
+  if( n==0 ){
+    if( nReaderTerm>0 ) return -1;
+    if( nTerm>0 ) return 1;
+    return 0;
+  }
+
+  c = memcmp(pReaderTerm, pTerm, n);
+  if( c!=0 ) return c;
+  if( isPrefix && n==nTerm ) return 0;
+  return nReaderTerm - nTerm;
+}
+
+/****************************************************************/
+/* LeafWriter is used to collect terms and associated doclist data
+** into leaf blocks in %_segments (see top of file for format info).
+** Expected usage is:
+**
+** LeafWriter writer;
+** leafWriterInit(0, 0, &writer);
+** while( sorted_terms_left_to_process ){
+**   // data is doclist data for that term.
+**   rc = leafWriterStep(v, &writer, pTerm, nTerm, pData, nData);
+**   if( rc!=SQLITE_OK ) goto err;
+** }
+** rc = leafWriterFinalize(v, &writer);
+**err:
+** leafWriterDestroy(&writer);
+** return rc;
+**
+** leafWriterStep() may write a collected leaf out to %_segments.
+** leafWriterFinalize() finishes writing any buffered data and stores
+** a root node in %_segdir.  leafWriterDestroy() frees all buffers and
+** InteriorWriters allocated as part of writing this segment.
+**
+** TODO(shess) Document leafWriterStepMerge().
+*/
+
+/* Put terms with data this big in their own block. */
+#define STANDALONE_MIN 1024
+
+/* Keep leaf blocks below this size. */
+#define LEAF_MAX 2048
+
+typedef struct LeafWriter {
+  int iLevel;
+  int idx;
+  sqlite_int64 iStartBlockid;     /* needed to create the root info */
+  sqlite_int64 iEndBlockid;       /* when we're done writing. */
+
+  DataBuffer term;                /* previous encoded term */
+  DataBuffer data;                /* encoding buffer */
+
+  /* bytes of first term in the current node which distinguishes that
+  ** term from the last term of the previous node.
+  */
+  int nTermDistinct;
+
+  InteriorWriter parentWriter;    /* if we overflow */
+  int has_parent;
+} LeafWriter;
+
+static void leafWriterInit(int iLevel, int idx, LeafWriter *pWriter){
+  CLEAR(pWriter);
+  pWriter->iLevel = iLevel;
+  pWriter->idx = idx;
+
+  dataBufferInit(&pWriter->term, 32);
+
+  /* Start out with a reasonably sized block, though it can grow. */
+  dataBufferInit(&pWriter->data, LEAF_MAX);
+}
+
+#ifndef NDEBUG
+/* Verify that the data is readable as a leaf node. */
+static void leafNodeValidate(const char *pData, int nData){
+  int n, iDummy;
+
+  if( nData==0 ) return;
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+
+  /* Must lead with a varint(0) */
+  n = getVarint32(pData, &iDummy);
+  assert( iDummy==0 );
+  assert( n>0 );
+  assert( n<nData );
+  pData += n;
+  nData -= n;
+
+  /* Leading term length and data must fit in buffer. */
+  n = getVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n+iDummy>0 );
+  assert( n+iDummy<nData );
+  pData += n+iDummy;
+  nData -= n+iDummy;
+
+  /* Leading term's doclist length and data must fit. */
+  n = getVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n+iDummy>0 );
+  assert( n+iDummy<=nData );
+  ASSERT_VALID_DOCLIST(DL_DEFAULT, pData+n, iDummy, NULL);
+  pData += n+iDummy;
+  nData -= n+iDummy;
+
+  /* Verify that trailing terms and doclists also are readable. */
+  while( nData!=0 ){
+    n = getVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>=0 );
+    assert( n<nData );
+    pData += n;
+    nData -= n;
+    n = getVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0 );
+    assert( n+iDummy<nData );
+    pData += n+iDummy;
+    nData -= n+iDummy;
+
+    n = getVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0 );
+    assert( n+iDummy<=nData );
+    ASSERT_VALID_DOCLIST(DL_DEFAULT, pData+n, iDummy, NULL);
+    pData += n+iDummy;
+    nData -= n+iDummy;
+  }
+}
+#define ASSERT_VALID_LEAF_NODE(p, n) leafNodeValidate(p, n)
+#else
+#define ASSERT_VALID_LEAF_NODE(p, n) assert( 1 )
+#endif
+
+/* Flush the current leaf node to %_segments, and adding the resulting
+** blockid and the starting term to the interior node which will
+** contain it.
+*/
+static int leafWriterInternalFlush(fulltext_vtab *v, LeafWriter *pWriter,
+                                   int iData, int nData){
+  sqlite_int64 iBlockid = 0;
+  const char *pStartingTerm;
+  int nStartingTerm, rc, n;
+
+  /* Must have the leading varint(0) flag, plus at least some
+  ** valid-looking data.
+  */
+  assert( nData>2 );
+  assert( iData>=0 );
+  assert( iData+nData<=pWriter->data.nData );
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData+iData, nData);
+
+  rc = block_insert(v, pWriter->data.pData+iData, nData, &iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+  assert( iBlockid!=0 );
+
+  /* Reconstruct the first term in the leaf for purposes of building
+  ** the interior node.
+  */
+  n = getVarint32(pWriter->data.pData+iData+1, &nStartingTerm);
+  pStartingTerm = pWriter->data.pData+iData+1+n;
+  assert( pWriter->data.nData>iData+1+n+nStartingTerm );
+  assert( pWriter->nTermDistinct>0 );
+  assert( pWriter->nTermDistinct<=nStartingTerm );
+  nStartingTerm = pWriter->nTermDistinct;
+
+  if( pWriter->has_parent ){
+    interiorWriterAppend(&pWriter->parentWriter,
+                         pStartingTerm, nStartingTerm, iBlockid);
+  }else{
+    interiorWriterInit(1, pStartingTerm, nStartingTerm, iBlockid,
+                       &pWriter->parentWriter);
+    pWriter->has_parent = 1;
+  }
+
+  /* Track the span of this segment's leaf nodes. */
+  if( pWriter->iEndBlockid==0 ){
+    pWriter->iEndBlockid = pWriter->iStartBlockid = iBlockid;
+  }else{
+    pWriter->iEndBlockid++;
+    assert( iBlockid==pWriter->iEndBlockid );
+  }
+
+  return SQLITE_OK;
+}
+static int leafWriterFlush(fulltext_vtab *v, LeafWriter *pWriter){
+  int rc = leafWriterInternalFlush(v, pWriter, 0, pWriter->data.nData);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Re-initialize the output buffer. */
+  dataBufferReset(&pWriter->data);
+
+  return SQLITE_OK;
+}
+
+/* Fetch the root info for the segment.  If the entire leaf fits
+** within ROOT_MAX, then it will be returned directly, otherwise it
+** will be flushed and the root info will be returned from the
+** interior node.  *piEndBlockid is set to the blockid of the last
+** interior or leaf node written to disk (0 if none are written at
+** all).
+*/
+static int leafWriterRootInfo(fulltext_vtab *v, LeafWriter *pWriter,
+                              char **ppRootInfo, int *pnRootInfo,
+                              sqlite_int64 *piEndBlockid){
+  /* we can fit the segment entirely inline */
+  if( !pWriter->has_parent && pWriter->data.nData<ROOT_MAX ){
+    *ppRootInfo = pWriter->data.pData;
+    *pnRootInfo = pWriter->data.nData;
+    *piEndBlockid = 0;
+    return SQLITE_OK;
+  }
+
+  /* Flush remaining leaf data. */
+  if( pWriter->data.nData>0 ){
+    int rc = leafWriterFlush(v, pWriter);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  /* We must have flushed a leaf at some point. */
+  assert( pWriter->has_parent );
+
+  /* Tenatively set the end leaf blockid as the end blockid.  If the
+  ** interior node can be returned inline, this will be the final
+  ** blockid, otherwise it will be overwritten by
+  ** interiorWriterRootInfo().
+  */
+  *piEndBlockid = pWriter->iEndBlockid;
+
+  return interiorWriterRootInfo(v, &pWriter->parentWriter,
+                                ppRootInfo, pnRootInfo, piEndBlockid);
+}
+
+/* Collect the rootInfo data and store it into the segment directory.
+** This has the effect of flushing the segment's leaf data to
+** %_segments, and also flushing any interior nodes to %_segments.
+*/
+static int leafWriterFinalize(fulltext_vtab *v, LeafWriter *pWriter){
+  sqlite_int64 iEndBlockid;
+  char *pRootInfo;
+  int rc, nRootInfo;
+
+  rc = leafWriterRootInfo(v, pWriter, &pRootInfo, &nRootInfo, &iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Don't bother storing an entirely empty segment. */
+  if( iEndBlockid==0 && nRootInfo==0 ) return SQLITE_OK;
+
+  return segdir_set(v, pWriter->iLevel, pWriter->idx,
+                    pWriter->iStartBlockid, pWriter->iEndBlockid,
+                    iEndBlockid, pRootInfo, nRootInfo);
+}
+
+static void leafWriterDestroy(LeafWriter *pWriter){
+  if( pWriter->has_parent ) interiorWriterDestroy(&pWriter->parentWriter);
+  dataBufferDestroy(&pWriter->term);
+  dataBufferDestroy(&pWriter->data);
+}
+
+/* Encode a term into the leafWriter, delta-encoding as appropriate.
+** Returns the length of the new term which distinguishes it from the
+** previous term, which can be used to set nTermDistinct when a node
+** boundary is crossed.
+*/
+static int leafWriterEncodeTerm(LeafWriter *pWriter,
+                                const char *pTerm, int nTerm){
+  char c[VARINT_MAX+VARINT_MAX];
+  int n, nPrefix = 0;
+
+  assert( nTerm>0 );
+  while( nPrefix<pWriter->term.nData &&
+         pTerm[nPrefix]==pWriter->term.pData[nPrefix] ){
+    nPrefix++;
+    /* Failing this implies that the terms weren't in order. */
+    assert( nPrefix<nTerm );
+  }
+
+  if( pWriter->data.nData==0 ){
+    /* Encode the node header and leading term as:
+    **  varint(0)
+    **  varint(nTerm)
+    **  char pTerm[nTerm]
+    */
+    n = putVarint(c, '\0');
+    n += putVarint(c+n, nTerm);
+    dataBufferAppend2(&pWriter->data, c, n, pTerm, nTerm);
+  }else{
+    /* Delta-encode the term as:
+    **  varint(nPrefix)
+    **  varint(nSuffix)
+    **  char pTermSuffix[nSuffix]
+    */
+    n = putVarint(c, nPrefix);
+    n += putVarint(c+n, nTerm-nPrefix);
+    dataBufferAppend2(&pWriter->data, c, n, pTerm+nPrefix, nTerm-nPrefix);
+  }
+  dataBufferReplace(&pWriter->term, pTerm, nTerm);
+
+  return nPrefix+1;
+}
+
+/* Used to avoid a memmove when a large amount of doclist data is in
+** the buffer.  This constructs a node and term header before
+** iDoclistData and flushes the resulting complete node using
+** leafWriterInternalFlush().
+*/
+static int leafWriterInlineFlush(fulltext_vtab *v, LeafWriter *pWriter,
+                                 const char *pTerm, int nTerm,
+                                 int iDoclistData){
+  char c[VARINT_MAX+VARINT_MAX];
+  int iData, n = putVarint(c, 0);
+  n += putVarint(c+n, nTerm);
+
+  /* There should always be room for the header.  Even if pTerm shared
+  ** a substantial prefix with the previous term, the entire prefix
+  ** could be constructed from earlier data in the doclist, so there
+  ** should be room.
+  */
+  assert( iDoclistData>=n+nTerm );
+
+  iData = iDoclistData-(n+nTerm);
+  memcpy(pWriter->data.pData+iData, c, n);
+  memcpy(pWriter->data.pData+iData+n, pTerm, nTerm);
+
+  return leafWriterInternalFlush(v, pWriter, iData, pWriter->data.nData-iData);
+}
+
+/* Push pTerm[nTerm] along with the doclist data to the leaf layer of
+** %_segments.
+*/
+static int leafWriterStepMerge(fulltext_vtab *v, LeafWriter *pWriter,
+                               const char *pTerm, int nTerm,
+                               DLReader *pReaders, int nReaders){
+  char c[VARINT_MAX+VARINT_MAX];
+  int iTermData = pWriter->data.nData, iDoclistData;
+  int i, nData, n, nActualData, nActual, rc, nTermDistinct;
+
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData, pWriter->data.nData);
+  nTermDistinct = leafWriterEncodeTerm(pWriter, pTerm, nTerm);
+
+  /* Remember nTermDistinct if opening a new node. */
+  if( iTermData==0 ) pWriter->nTermDistinct = nTermDistinct;
+
+  iDoclistData = pWriter->data.nData;
+
+  /* Estimate the length of the merged doclist so we can leave space
+  ** to encode it.
+  */
+  for(i=0, nData=0; i<nReaders; i++){
+    nData += dlrAllDataBytes(&pReaders[i]);
+  }
+  n = putVarint(c, nData);
+  dataBufferAppend(&pWriter->data, c, n);
+
+  docListMerge(&pWriter->data, pReaders, nReaders);
+  ASSERT_VALID_DOCLIST(DL_DEFAULT,
+                       pWriter->data.pData+iDoclistData+n,
+                       pWriter->data.nData-iDoclistData-n, NULL);
+
+  /* The actual amount of doclist data at this point could be smaller
+  ** than the length we encoded.  Additionally, the space required to
+  ** encode this length could be smaller.  For small doclists, this is
+  ** not a big deal, we can just use memmove() to adjust things.
+  */
+  nActualData = pWriter->data.nData-(iDoclistData+n);
+  nActual = putVarint(c, nActualData);
+  assert( nActualData<=nData );
+  assert( nActual<=n );
+
+  /* If the new doclist is big enough for force a standalone leaf
+  ** node, we can immediately flush it inline without doing the
+  ** memmove().
+  */
+  /* TODO(shess) This test matches leafWriterStep(), which does this
+  ** test before it knows the cost to varint-encode the term and
+  ** doclist lengths.  At some point, change to
+  ** pWriter->data.nData-iTermData>STANDALONE_MIN.
+  */
+  if( nTerm+nActualData>STANDALONE_MIN ){
+    /* Push leaf node from before this term. */
+    if( iTermData>0 ){
+      rc = leafWriterInternalFlush(v, pWriter, 0, iTermData);
+      if( rc!=SQLITE_OK ) return rc;
+
+      pWriter->nTermDistinct = nTermDistinct;
+    }
+
+    /* Fix the encoded doclist length. */
+    iDoclistData += n - nActual;
+    memcpy(pWriter->data.pData+iDoclistData, c, nActual);
+
+    /* Push the standalone leaf node. */
+    rc = leafWriterInlineFlush(v, pWriter, pTerm, nTerm, iDoclistData);
+    if( rc!=SQLITE_OK ) return rc;
+
+    /* Leave the node empty. */
+    dataBufferReset(&pWriter->data);
+
+    return rc;
+  }
+
+  /* At this point, we know that the doclist was small, so do the
+  ** memmove if indicated.
+  */
+  if( nActual<n ){
+    memmove(pWriter->data.pData+iDoclistData+nActual,
+            pWriter->data.pData+iDoclistData+n,
+            pWriter->data.nData-(iDoclistData+n));
+    pWriter->data.nData -= n-nActual;
+  }
+
+  /* Replace written length with actual length. */
+  memcpy(pWriter->data.pData+iDoclistData, c, nActual);
+
+  /* If the node is too large, break things up. */
+  /* TODO(shess) This test matches leafWriterStep(), which does this
+  ** test before it knows the cost to varint-encode the term and
+  ** doclist lengths.  At some point, change to
+  ** pWriter->data.nData>LEAF_MAX.
+  */
+  if( iTermData+nTerm+nActualData>LEAF_MAX ){
+    /* Flush out the leading data as a node */
+    rc = leafWriterInternalFlush(v, pWriter, 0, iTermData);
+    if( rc!=SQLITE_OK ) return rc;
+
+    pWriter->nTermDistinct = nTermDistinct;
+
+    /* Rebuild header using the current term */
+    n = putVarint(pWriter->data.pData, 0);
+    n += putVarint(pWriter->data.pData+n, nTerm);
+    memcpy(pWriter->data.pData+n, pTerm, nTerm);
+    n += nTerm;
+
+    /* There should always be room, because the previous encoding
+    ** included all data necessary to construct the term.
+    */
+    assert( n<iDoclistData );
+    /* So long as STANDALONE_MIN is half or less of LEAF_MAX, the
+    ** following memcpy() is safe (as opposed to needing a memmove).
+    */
+    assert( 2*STANDALONE_MIN<=LEAF_MAX );
+    assert( n+pWriter->data.nData-iDoclistData<iDoclistData );
+    memcpy(pWriter->data.pData+n,
+           pWriter->data.pData+iDoclistData,
+           pWriter->data.nData-iDoclistData);
+    pWriter->data.nData -= iDoclistData-n;
+  }
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData, pWriter->data.nData);
+
+  return SQLITE_OK;
+}
+
+/* Push pTerm[nTerm] along with the doclist data to the leaf layer of
+** %_segments.
+*/
+/* TODO(shess) Revise writeZeroSegment() so that doclists are
+** constructed directly in pWriter->data.
+*/
+static int leafWriterStep(fulltext_vtab *v, LeafWriter *pWriter,
+                          const char *pTerm, int nTerm,
+                          const char *pData, int nData){
+  int rc;
+  DLReader reader;
+
+  dlrInit(&reader, DL_DEFAULT, pData, nData);
+  rc = leafWriterStepMerge(v, pWriter, pTerm, nTerm, &reader, 1);
+  dlrDestroy(&reader);
+
+  return rc;
+}
+
+
+/****************************************************************/
+/* LeafReader is used to iterate over an individual leaf node. */
+typedef struct LeafReader {
+  DataBuffer term;          /* copy of current term. */
+
+  const char *pData;        /* data for current term. */
+  int nData;
+} LeafReader;
+
+static void leafReaderDestroy(LeafReader *pReader){
+  dataBufferDestroy(&pReader->term);
+  SCRAMBLE(pReader);
+}
+
+static int leafReaderAtEnd(LeafReader *pReader){
+  return pReader->nData<=0;
+}
+
+/* Access the current term. */
+static int leafReaderTermBytes(LeafReader *pReader){
+  return pReader->term.nData;
+}
+static const char *leafReaderTerm(LeafReader *pReader){
+  assert( pReader->term.nData>0 );
+  return pReader->term.pData;
+}
+
+/* Access the doclist data for the current term. */
+static int leafReaderDataBytes(LeafReader *pReader){
+  int nData;
+  assert( pReader->term.nData>0 );
+  getVarint32(pReader->pData, &nData);
+  return nData;
+}
+static const char *leafReaderData(LeafReader *pReader){
+  int n, nData;
+  assert( pReader->term.nData>0 );
+  n = getVarint32(pReader->pData, &nData);
+  return pReader->pData+n;
+}
+
+static void leafReaderInit(const char *pData, int nData,
+                           LeafReader *pReader){
+  int nTerm, n;
+
+  assert( nData>0 );
+  assert( pData[0]=='\0' );
+
+  CLEAR(pReader);
+
+  /* Read the first term, skipping the header byte. */
+  n = getVarint32(pData+1, &nTerm);
+  dataBufferInit(&pReader->term, nTerm);
+  dataBufferReplace(&pReader->term, pData+1+n, nTerm);
+
+  /* Position after the first term. */
+  assert( 1+n+nTerm<nData );
+  pReader->pData = pData+1+n+nTerm;
+  pReader->nData = nData-1-n-nTerm;
+}
+
+/* Step the reader forward to the next term. */
+static void leafReaderStep(LeafReader *pReader){
+  int n, nData, nPrefix, nSuffix;
+  assert( !leafReaderAtEnd(pReader) );
+
+  /* Skip previous entry's data block. */
+  n = getVarint32(pReader->pData, &nData);
+  assert( n+nData<=pReader->nData );
+  pReader->pData += n+nData;
+  pReader->nData -= n+nData;
+
+  if( !leafReaderAtEnd(pReader) ){
+    /* Construct the new term using a prefix from the old term plus a
+    ** suffix from the leaf data.
+    */
+    n = getVarint32(pReader->pData, &nPrefix);
+    n += getVarint32(pReader->pData+n, &nSuffix);
+    assert( n+nSuffix<pReader->nData );
+    pReader->term.nData = nPrefix;
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
+
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
+  }
+}
+
+/* strcmp-style comparison of pReader's current term against pTerm.
+** If isPrefix, equality means equal through nTerm bytes.
+*/
+static int leafReaderTermCmp(LeafReader *pReader,
+                             const char *pTerm, int nTerm, int isPrefix){
+  int c, n = pReader->term.nData<nTerm ? pReader->term.nData : nTerm;
+  if( n==0 ){
+    if( pReader->term.nData>0 ) return -1;
+    if(nTerm>0 ) return 1;
+    return 0;
+  }
+
+  c = memcmp(pReader->term.pData, pTerm, n);
+  if( c!=0 ) return c;
+  if( isPrefix && n==nTerm ) return 0;
+  return pReader->term.nData - nTerm;
+}
+
+
+/****************************************************************/
+/* LeavesReader wraps LeafReader to allow iterating over the entire
+** leaf layer of the tree.
+*/
+typedef struct LeavesReader {
+  int idx;                  /* Index within the segment. */
+
+  sqlite3_stmt *pStmt;      /* Statement we're streaming leaves from. */
+  int eof;                  /* we've seen SQLITE_DONE from pStmt. */
+
+  LeafReader leafReader;    /* reader for the current leaf. */
+  DataBuffer rootData;      /* root data for inline. */
+} LeavesReader;
+
+/* Access the current term. */
+static int leavesReaderTermBytes(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderTermBytes(&pReader->leafReader);
+}
+static const char *leavesReaderTerm(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderTerm(&pReader->leafReader);
+}
+
+/* Access the doclist data for the current term. */
+static int leavesReaderDataBytes(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderDataBytes(&pReader->leafReader);
+}
+static const char *leavesReaderData(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderData(&pReader->leafReader);
+}
+
+static int leavesReaderAtEnd(LeavesReader *pReader){
+  return pReader->eof;
+}
+
+/* loadSegmentLeaves() may not read all the way to SQLITE_DONE, thus
+** leaving the statement handle open, which locks the table.
+*/
+/* TODO(shess) This "solution" is not satisfactory.  Really, there
+** should be check-in function for all statement handles which
+** arranges to call sqlite3_reset().  This most likely will require
+** modification to control flow all over the place, though, so for now
+** just punt.
+**
+** Note the the current system assumes that segment merges will run to
+** completion, which is why this particular probably hasn't arisen in
+** this case.  Probably a brittle assumption.
+*/
+static int leavesReaderReset(LeavesReader *pReader){
+  return sqlite3_reset(pReader->pStmt);
+}
+
+static void leavesReaderDestroy(LeavesReader *pReader){
+  leafReaderDestroy(&pReader->leafReader);
+  dataBufferDestroy(&pReader->rootData);
+  SCRAMBLE(pReader);
+}
+
+/* Initialize pReader with the given root data (if iStartBlockid==0
+** the leaf data was entirely contained in the root), or from the
+** stream of blocks between iStartBlockid and iEndBlockid, inclusive.
+*/
+static int leavesReaderInit(fulltext_vtab *v,
+                            int idx,
+                            sqlite_int64 iStartBlockid,
+                            sqlite_int64 iEndBlockid,
+                            const char *pRootData, int nRootData,
+                            LeavesReader *pReader){
+  CLEAR(pReader);
+  pReader->idx = idx;
+
+  dataBufferInit(&pReader->rootData, 0);
+  if( iStartBlockid==0 ){
+    /* Entire leaf level fit in root data. */
+    dataBufferReplace(&pReader->rootData, pRootData, nRootData);
+    leafReaderInit(pReader->rootData.pData, pReader->rootData.nData,
+                   &pReader->leafReader);
+  }else{
+    sqlite3_stmt *s;
+    int rc = sql_get_leaf_statement(v, idx, &s);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_bind_int64(s, 1, iStartBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_bind_int64(s, 2, iEndBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_step(s);
+    if( rc==SQLITE_DONE ){
+      pReader->eof = 1;
+      return SQLITE_OK;
+    }
+    if( rc!=SQLITE_ROW ) return rc;
+
+    pReader->pStmt = s;
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
+  }
+  return SQLITE_OK;
+}
+
+/* Step the current leaf forward to the next term.  If we reach the
+** end of the current leaf, step forward to the next leaf block.
+*/
+static int leavesReaderStep(fulltext_vtab *v, LeavesReader *pReader){
+  assert( !leavesReaderAtEnd(pReader) );
+  leafReaderStep(&pReader->leafReader);
+
+  if( leafReaderAtEnd(&pReader->leafReader) ){
+    int rc;
+    if( pReader->rootData.pData ){
+      pReader->eof = 1;
+      return SQLITE_OK;
+    }
+    rc = sqlite3_step(pReader->pStmt);
+    if( rc!=SQLITE_ROW ){
+      pReader->eof = 1;
+      return rc==SQLITE_DONE ? SQLITE_OK : rc;
+    }
+    leafReaderDestroy(&pReader->leafReader);
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
+  }
+  return SQLITE_OK;
+}
+
+/* Order LeavesReaders by their term, ignoring idx.  Readers at eof
+** always sort to the end.
+*/
+static int leavesReaderTermCmp(LeavesReader *lr1, LeavesReader *lr2){
+  if( leavesReaderAtEnd(lr1) ){
+    if( leavesReaderAtEnd(lr2) ) return 0;
+    return 1;
+  }
+  if( leavesReaderAtEnd(lr2) ) return -1;
+
+  return leafReaderTermCmp(&lr1->leafReader,
+                           leavesReaderTerm(lr2), leavesReaderTermBytes(lr2),
+                           0);
+}
+
+/* Similar to leavesReaderTermCmp(), with additional ordering by idx
+** so that older segments sort before newer segments.
+*/
+static int leavesReaderCmp(LeavesReader *lr1, LeavesReader *lr2){
+  int c = leavesReaderTermCmp(lr1, lr2);
+  if( c!=0 ) return c;
+  return lr1->idx-lr2->idx;
+}
+
+/* Assume that pLr[1]..pLr[nLr] are sorted.  Bubble pLr[0] into its
+** sorted position.
+*/
+static void leavesReaderReorder(LeavesReader *pLr, int nLr){
+  while( nLr>1 && leavesReaderCmp(pLr, pLr+1)>0 ){
+    LeavesReader tmp = pLr[0];
+    pLr[0] = pLr[1];
+    pLr[1] = tmp;
+    nLr--;
+    pLr++;
+  }
+}
+
+/* Initializes pReaders with the segments from level iLevel, returning
+** the number of segments in *piReaders.  Leaves pReaders in sorted
+** order.
+*/
+static int leavesReadersInit(fulltext_vtab *v, int iLevel,
+                             LeavesReader *pReaders, int *piReaders){
+  sqlite3_stmt *s;
+  int i, rc = sql_get_statement(v, SEGDIR_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  i = 0;
+  while( (rc = sqlite3_step(s))==SQLITE_ROW ){
+    sqlite_int64 iStart = sqlite3_column_int64(s, 0);
+    sqlite_int64 iEnd = sqlite3_column_int64(s, 1);
+    const char *pRootData = sqlite3_column_blob(s, 2);
+    int nRootData = sqlite3_column_bytes(s, 2);
+
+    assert( i<MERGE_COUNT );
+    rc = leavesReaderInit(v, i, iStart, iEnd, pRootData, nRootData,
+                          &pReaders[i]);
+    if( rc!=SQLITE_OK ) break;
+
+    i++;
+  }
+  if( rc!=SQLITE_DONE ){
+    while( i-->0 ){
+      leavesReaderDestroy(&pReaders[i]);
+    }
+    return rc;
+  }
+
+  *piReaders = i;
+
+  /* Leave our results sorted by term, then age. */
+  while( i-- ){
+    leavesReaderReorder(pReaders+i, *piReaders-i);
+  }
+  return SQLITE_OK;
+}
+
+/* Merge doclists from pReaders[nReaders] into a single doclist, which
+** is written to pWriter.  Assumes pReaders is ordered oldest to
+** newest.
+*/
+/* TODO(shess) Consider putting this inline in segmentMerge(). */
+static int leavesReadersMerge(fulltext_vtab *v,
+                              LeavesReader *pReaders, int nReaders,
+                              LeafWriter *pWriter){
+  DLReader dlReaders[MERGE_COUNT];
+  const char *pTerm = leavesReaderTerm(pReaders);
+  int i, nTerm = leavesReaderTermBytes(pReaders);
+
+  assert( nReaders<=MERGE_COUNT );
+
+  for(i=0; i<nReaders; i++){
+    dlrInit(&dlReaders[i], DL_DEFAULT,
+            leavesReaderData(pReaders+i),
+            leavesReaderDataBytes(pReaders+i));
+  }
+
+  return leafWriterStepMerge(v, pWriter, pTerm, nTerm, dlReaders, nReaders);
+}
+
+/* Forward ref due to mutual recursion with segdirNextIndex(). */
+static int segmentMerge(fulltext_vtab *v, int iLevel);
+
+/* Put the next available index at iLevel into *pidx.  If iLevel
+** already has MERGE_COUNT segments, they are merged to a higher
+** level to make room.
+*/
+static int segdirNextIndex(fulltext_vtab *v, int iLevel, int *pidx){
+  int rc = segdir_max_index(v, iLevel, pidx);
+  if( rc==SQLITE_DONE ){              /* No segments at iLevel. */
+    *pidx = 0;
+  }else if( rc==SQLITE_ROW ){
+    if( *pidx==(MERGE_COUNT-1) ){
+      rc = segmentMerge(v, iLevel);
+      if( rc!=SQLITE_OK ) return rc;
+      *pidx = 0;
+    }else{
+      (*pidx)++;
+    }
+  }else{
+    return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Merge MERGE_COUNT segments at iLevel into a new segment at
+** iLevel+1.  If iLevel+1 is already full of segments, those will be
+** merged to make room.
+*/
+static int segmentMerge(fulltext_vtab *v, int iLevel){
+  LeafWriter writer;
+  LeavesReader lrs[MERGE_COUNT];
+  int i, rc, idx = 0;
+
+  /* Determine the next available segment index at the next level,
+  ** merging as necessary.
+  */
+  rc = segdirNextIndex(v, iLevel+1, &idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* TODO(shess) This assumes that we'll always see exactly
+  ** MERGE_COUNT segments to merge at a given level.  That will be
+  ** broken if we allow the developer to request preemptive or
+  ** deferred merging.
+  */
+  memset(&lrs, '\0', sizeof(lrs));
+  rc = leavesReadersInit(v, iLevel, lrs, &i);
+  if( rc!=SQLITE_OK ) return rc;
+  assert( i==MERGE_COUNT );
+
+  leafWriterInit(iLevel+1, idx, &writer);
+
+  /* Since leavesReaderReorder() pushes readers at eof to the end,
+  ** when the first reader is empty, all will be empty.
+  */
+  while( !leavesReaderAtEnd(lrs) ){
+    /* Figure out how many readers share their next term. */
+    for(i=1; i<MERGE_COUNT && !leavesReaderAtEnd(lrs+i); i++){
+      if( 0!=leavesReaderTermCmp(lrs, lrs+i) ) break;
+    }
+
+    rc = leavesReadersMerge(v, lrs, i, &writer);
+    if( rc!=SQLITE_OK ) goto err;
+
+    /* Step forward those that were merged. */
+    while( i-->0 ){
+      rc = leavesReaderStep(v, lrs+i);
+      if( rc!=SQLITE_OK ) goto err;
+
+      /* Reorder by term, then by age. */
+      leavesReaderReorder(lrs+i, MERGE_COUNT-i);
+    }
+  }
+
+  for(i=0; i<MERGE_COUNT; i++){
+    leavesReaderDestroy(&lrs[i]);
+  }
+
+  rc = leafWriterFinalize(v, &writer);
+  leafWriterDestroy(&writer);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Delete the merged segment data. */
+  return segdir_delete(v, iLevel);
+
+ err:
+  for(i=0; i<MERGE_COUNT; i++){
+    leavesReaderDestroy(&lrs[i]);
+  }
+  leafWriterDestroy(&writer);
+  return rc;
+}
+
+/* Scan pReader for pTerm/nTerm, and merge the term's doclist over
+** *out (any doclists with duplicate docids overwrite those in *out).
+** Internal function for loadSegmentLeaf().
+*/
+static int loadSegmentLeavesInt(fulltext_vtab *v, LeavesReader *pReader,
+                                const char *pTerm, int nTerm, int isPrefix,
+                                DataBuffer *out){
+  assert( nTerm>0 );
+
+  /* Process while the prefix matches. */
+  while( !leavesReaderAtEnd(pReader) ){
+    /* TODO(shess) Really want leavesReaderTermCmp(), but that name is
+    ** already taken to compare the terms of two LeavesReaders.  Think
+    ** on a better name.  [Meanwhile, break encapsulation rather than
+    ** use a confusing name.]
+    */
+    int rc;
+    int c = leafReaderTermCmp(&pReader->leafReader, pTerm, nTerm, isPrefix);
+    if( c==0 ){
+      const char *pData = leavesReaderData(pReader);
+      int nData = leavesReaderDataBytes(pReader);
+      if( out->nData==0 ){
+        dataBufferReplace(out, pData, nData);
+      }else{
+        DataBuffer result;
+        dataBufferInit(&result, out->nData+nData);
+        docListUnion(out->pData, out->nData, pData, nData, &result);
+        dataBufferDestroy(out);
+        *out = result;
+        /* TODO(shess) Rather than destroy out, we could retain it for
+        ** later reuse.
+        */
+      }
+    }
+    if( c>0 ) break;      /* Past any possible matches. */
+
+    rc = leavesReaderStep(v, pReader);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Call loadSegmentLeavesInt() with pData/nData as input. */
+static int loadSegmentLeaf(fulltext_vtab *v, const char *pData, int nData,
+                           const char *pTerm, int nTerm, int isPrefix,
+                           DataBuffer *out){
+  LeavesReader reader;
+  int rc;
+
+  assert( nData>1 );
+  assert( *pData=='\0' );
+  rc = leavesReaderInit(v, 0, 0, 0, pData, nData, &reader);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = loadSegmentLeavesInt(v, &reader, pTerm, nTerm, isPrefix, out);
+  leavesReaderReset(&reader);
+  leavesReaderDestroy(&reader);
+  return rc;
+}
+
+/* Call loadSegmentLeavesInt() with the leaf nodes from iStartLeaf to
+** iEndLeaf (inclusive) as input, and merge the resulting doclist into
+** out.
+*/
+static int loadSegmentLeaves(fulltext_vtab *v,
+                             sqlite_int64 iStartLeaf, sqlite_int64 iEndLeaf,
+                             const char *pTerm, int nTerm, int isPrefix,
+                             DataBuffer *out){
+  int rc;
+  LeavesReader reader;
+
+  assert( iStartLeaf<=iEndLeaf );
+  rc = leavesReaderInit(v, 0, iStartLeaf, iEndLeaf, NULL, 0, &reader);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = loadSegmentLeavesInt(v, &reader, pTerm, nTerm, isPrefix, out);
+  leavesReaderReset(&reader);
+  leavesReaderDestroy(&reader);
+  return rc;
+}
+
+/* Taking pData/nData as an interior node, find the sequence of child
+** nodes which could include pTerm/nTerm/isPrefix.  Note that the
+** interior node terms logically come between the blocks, so there is
+** one more blockid than there are terms (that block contains terms >=
+** the last interior-node term).
+*/
+/* TODO(shess) The calling code may already know that the end child is
+** not worth calculating, because the end may be in a later sibling
+** node.  Consider whether breaking symmetry is worthwhile.  I suspect
+** it is not worthwhile.
+*/
+static void getChildrenContaining(const char *pData, int nData,
+                                  const char *pTerm, int nTerm, int isPrefix,
+                                  sqlite_int64 *piStartChild,
+                                  sqlite_int64 *piEndChild){
+  InteriorReader reader;
+
+  assert( nData>1 );
+  assert( *pData!='\0' );
+  interiorReaderInit(pData, nData, &reader);
+
+  /* Scan for the first child which could contain pTerm/nTerm. */
+  while( !interiorReaderAtEnd(&reader) ){
+    if( interiorReaderTermCmp(&reader, pTerm, nTerm, 0)>0 ) break;
+    interiorReaderStep(&reader);
+  }
+  *piStartChild = interiorReaderCurrentBlockid(&reader);
+
+  /* Keep scanning to find a term greater than our term, using prefix
+  ** comparison if indicated.  If isPrefix is false, this will be the
+  ** same blockid as the starting block.
+  */
+  while( !interiorReaderAtEnd(&reader) ){
+    if( interiorReaderTermCmp(&reader, pTerm, nTerm, isPrefix)>0 ) break;
+    interiorReaderStep(&reader);
+  }
+  *piEndChild = interiorReaderCurrentBlockid(&reader);
+
+  interiorReaderDestroy(&reader);
+
+  /* Children must ascend, and if !prefix, both must be the same. */
+  assert( *piEndChild>=*piStartChild );
+  assert( isPrefix || *piStartChild==*piEndChild );
+}
+
+/* Read block at iBlockid and pass it with other params to
+** getChildrenContaining().
+*/
+static int loadAndGetChildrenContaining(
+  fulltext_vtab *v,
+  sqlite_int64 iBlockid,
+  const char *pTerm, int nTerm, int isPrefix,
+  sqlite_int64 *piStartChild, sqlite_int64 *piEndChild
+){
+  sqlite3_stmt *s = NULL;
+  int rc;
+
+  assert( iBlockid!=0 );
+  assert( pTerm!=NULL );
+  assert( nTerm!=0 );        /* TODO(shess) Why not allow this? */
+  assert( piStartChild!=NULL );
+  assert( piEndChild!=NULL );
+
+  rc = sql_get_statement(v, BLOCK_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ) return SQLITE_ERROR;
+  if( rc!=SQLITE_ROW ) return rc;
+
+  getChildrenContaining(sqlite3_column_blob(s, 0), sqlite3_column_bytes(s, 0),
+                        pTerm, nTerm, isPrefix, piStartChild, piEndChild);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain
+   * locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+
+  return SQLITE_OK;
+}
+
+/* Traverse the tree represented by pData[nData] looking for
+** pTerm[nTerm], placing its doclist into *out.  This is internal to
+** loadSegment() to make error-handling cleaner.
+*/
+static int loadSegmentInt(fulltext_vtab *v, const char *pData, int nData,
+                          sqlite_int64 iLeavesEnd,
+                          const char *pTerm, int nTerm, int isPrefix,
+                          DataBuffer *out){
+  /* Special case where root is a leaf. */
+  if( *pData=='\0' ){
+    return loadSegmentLeaf(v, pData, nData, pTerm, nTerm, isPrefix, out);
+  }else{
+    int rc;
+    sqlite_int64 iStartChild, iEndChild;
+
+    /* Process pData as an interior node, then loop down the tree
+    ** until we find the set of leaf nodes to scan for the term.
+    */
+    getChildrenContaining(pData, nData, pTerm, nTerm, isPrefix,
+                          &iStartChild, &iEndChild);
+    while( iStartChild>iLeavesEnd ){
+      sqlite_int64 iNextStart, iNextEnd;
+      rc = loadAndGetChildrenContaining(v, iStartChild, pTerm, nTerm, isPrefix,
+                                        &iNextStart, &iNextEnd);
+      if( rc!=SQLITE_OK ) return rc;
+
+      /* If we've branched, follow the end branch, too. */
+      if( iStartChild!=iEndChild ){
+        sqlite_int64 iDummy;
+        rc = loadAndGetChildrenContaining(v, iEndChild, pTerm, nTerm, isPrefix,
+                                          &iDummy, &iNextEnd);
+        if( rc!=SQLITE_OK ) return rc;
+      }
+
+      assert( iNextStart<=iNextEnd );
+      iStartChild = iNextStart;
+      iEndChild = iNextEnd;
+    }
+    assert( iStartChild<=iLeavesEnd );
+    assert( iEndChild<=iLeavesEnd );
+
+    /* Scan through the leaf segments for doclists. */
+    return loadSegmentLeaves(v, iStartChild, iEndChild,
+                             pTerm, nTerm, isPrefix, out);
+  }
+}
+
+/* Call loadSegmentInt() to collect the doclist for pTerm/nTerm, then
+** merge its doclist over *out (any duplicate doclists read from the
+** segment rooted at pData will overwrite those in *out).
+*/
+/* TODO(shess) Consider changing this to determine the depth of the
+** leaves using either the first characters of interior nodes (when
+** ==1, we're one level above the leaves), or the first character of
+** the root (which will describe the height of the tree directly).
+** Either feels somewhat tricky to me.
+*/
+/* TODO(shess) The current merge is likely to be slow for large
+** doclists (though it should process from newest/smallest to
+** oldest/largest, so it may not be that bad).  It might be useful to
+** modify things to allow for N-way merging.  This could either be
+** within a segment, with pairwise merges across segments, or across
+** all segments at once.
+*/
+static int loadSegment(fulltext_vtab *v, const char *pData, int nData,
+                       sqlite_int64 iLeavesEnd,
+                       const char *pTerm, int nTerm, int isPrefix,
+                       DataBuffer *out){
+  DataBuffer result;
+  int rc;
+
+  assert( nData>1 );
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&result, 0);
+  rc = loadSegmentInt(v, pData, nData, iLeavesEnd,
+                      pTerm, nTerm, isPrefix, &result);
+  if( rc==SQLITE_OK && result.nData>0 ){
+    if( out->nData==0 ){
+      DataBuffer tmp = *out;
+      *out = result;
+      result = tmp;
+    }else{
+      DataBuffer merged;
+      DLReader readers[2];
+
+      dlrInit(&readers[0], DL_DEFAULT, out->pData, out->nData);
+      dlrInit(&readers[1], DL_DEFAULT, result.pData, result.nData);
+      dataBufferInit(&merged, out->nData+result.nData);
+      docListMerge(&merged, readers, 2);
+      dataBufferDestroy(out);
+      *out = merged;
+      dlrDestroy(&readers[0]);
+      dlrDestroy(&readers[1]);
+    }
+  }
+  dataBufferDestroy(&result);
+  return rc;
+}
+
+/* Scan the database and merge together the posting lists for the term
+** into *out.
+*/
+static int termSelect(fulltext_vtab *v, int iColumn,
+                      const char *pTerm, int nTerm, int isPrefix,
+                      DocListType iType, DataBuffer *out){
+  DataBuffer doclist;
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SELECT_ALL_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&doclist, 0);
+
+  /* Traverse the segments from oldest to newest so that newer doclist
+  ** elements for given docids overwrite older elements.
+  */
+  while( (rc = sqlite3_step(s))==SQLITE_ROW ){
+    const char *pData = sqlite3_column_blob(s, 0);
+    const int nData = sqlite3_column_bytes(s, 0);
+    const sqlite_int64 iLeavesEnd = sqlite3_column_int64(s, 1);
+    rc = loadSegment(v, pData, nData, iLeavesEnd, pTerm, nTerm, isPrefix,
+                     &doclist);
+    if( rc!=SQLITE_OK ) goto err;
+  }
+  if( rc==SQLITE_DONE ){
+    if( doclist.nData!=0 ){
+      /* TODO(shess) The old term_select_all() code applied the column
+      ** restrict as we merged segments, leading to smaller buffers.
+      ** This is probably worthwhile to bring back, once the new storage
+      ** system is checked in.
+      */
+      if( iColumn==v->nColumn) iColumn = -1;
+      docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
+                  iColumn, iType, out);
+    }
+    rc = SQLITE_OK;
+  }
+
+ err:
+  dataBufferDestroy(&doclist);
+  return rc;
+}
+
+/****************************************************************/
+/* Used to hold hashtable data for sorting. */
+typedef struct TermData {
+  const char *pTerm;
+  int nTerm;
+  DLCollector *pCollector;
+} TermData;
+
+/* Orders TermData elements in strcmp fashion ( <0 for less-than, 0
+** for equal, >0 for greater-than).
+*/
+static int termDataCmp(const void *av, const void *bv){
+  const TermData *a = (const TermData *)av;
+  const TermData *b = (const TermData *)bv;
+  int n = a->nTerm<b->nTerm ? a->nTerm : b->nTerm;
+  int c = memcmp(a->pTerm, b->pTerm, n);
+  if( c!=0 ) return c;
+  return a->nTerm-b->nTerm;
+}
+
+/* Order pTerms data by term, then write a new level 0 segment using
+** LeafWriter.
+*/
+static int writeZeroSegment(fulltext_vtab *v, fts2Hash *pTerms){
+  fts2HashElem *e;
+  int idx, rc, i, n;
+  TermData *pData;
+  LeafWriter writer;
+  DataBuffer dl;
+
+  /* Determine the next index at level 0, merging as necessary. */
+  rc = segdirNextIndex(v, 0, &idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  n = fts2HashCount(pTerms);
+  pData = malloc(n*sizeof(TermData));
+
+  for(i = 0, e = fts2HashFirst(pTerms); e; i++, e = fts2HashNext(e)){
+    assert( i<n );
+    pData[i].pTerm = fts2HashKey(e);
+    pData[i].nTerm = fts2HashKeysize(e);
+    pData[i].pCollector = fts2HashData(e);
+  }
+  assert( i==n );
+
+  /* TODO(shess) Should we allow user-defined collation sequences,
+  ** here?  I think we only need that once we support prefix searches.
+  */
+  if( n>1 ) qsort(pData, n, sizeof(*pData), termDataCmp);
+
+  /* TODO(shess) Refactor so that we can write directly to the segment
+  ** DataBuffer, as happens for segment merges.
+  */
+  leafWriterInit(0, idx, &writer);
+  dataBufferInit(&dl, 0);
+  for(i=0; i<n; i++){
+    dataBufferReset(&dl);
+    dlcAddDoclist(pData[i].pCollector, &dl);
+    rc = leafWriterStep(v, &writer,
+                        pData[i].pTerm, pData[i].nTerm, dl.pData, dl.nData);
+    if( rc!=SQLITE_OK ) goto err;
+  }
+  rc = leafWriterFinalize(v, &writer);
+
+ err:
+  dataBufferDestroy(&dl);
+  free(pData);
+  leafWriterDestroy(&writer);
+  return rc;
+}
+
+/* If pendingTerms has data, free it. */
+static int clearPendingTerms(fulltext_vtab *v){
+  if( v->nPendingData>=0 ){
+    fts2HashElem *e;
+    for(e=fts2HashFirst(&v->pendingTerms); e; e=fts2HashNext(e)){
+      dlcDelete(fts2HashData(e));
+    }
+    fts2HashClear(&v->pendingTerms);
+    v->nPendingData = -1;
+  }
+  return SQLITE_OK;
+}
+
+/* If pendingTerms has data, flush it to a level-zero segment, and
+** free it.
+*/
+static int flushPendingTerms(fulltext_vtab *v){
+  if( v->nPendingData>=0 ){
+    int rc = writeZeroSegment(v, &v->pendingTerms);
+    if( rc==SQLITE_OK ) clearPendingTerms(v);
+    return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* If pendingTerms is "too big", or docid is out of order, flush it.
+** Regardless, be certain that pendingTerms is initialized for use.
+*/
+static int initPendingTerms(fulltext_vtab *v, sqlite_int64 iDocid){
+  /* TODO(shess) Explore whether partially flushing the buffer on
+  ** forced-flush would provide better performance.  I suspect that if
+  ** we ordered the doclists by size and flushed the largest until the
+  ** buffer was half empty, that would let the less frequent terms
+  ** generate longer doclists.
+  */
+  if( iDocid<=v->iPrevDocid || v->nPendingData>kPendingThreshold ){
+    int rc = flushPendingTerms(v);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  if( v->nPendingData<0 ){
+    fts2HashInit(&v->pendingTerms, FTS2_HASH_STRING, 1);
+    v->nPendingData = 0;
+  }
+  v->iPrevDocid = iDocid;
+  return SQLITE_OK;
+}
+
+/* This function implements the xUpdate callback; it is the top-level entry
+ * point for inserting, deleting or updating a row in a full-text table. */
+static int fulltextUpdate(sqlite3_vtab *pVtab, int nArg, sqlite3_value **ppArg,
+                   sqlite_int64 *pRowid){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  int rc;
+
+  TRACE(("FTS2 Update %p\n", pVtab));
+
+  if( nArg<2 ){
+    rc = index_delete(v, sqlite3_value_int64(ppArg[0]));
+  } else if( sqlite3_value_type(ppArg[0]) != SQLITE_NULL ){
+    /* An update:
+     * ppArg[0] = old rowid
+     * ppArg[1] = new rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     */
+    sqlite_int64 rowid = sqlite3_value_int64(ppArg[0]);
+    if( sqlite3_value_type(ppArg[1]) != SQLITE_INTEGER ||
+      sqlite3_value_int64(ppArg[1]) != rowid ){
+      rc = SQLITE_ERROR;  /* we don't allow changing the rowid */
+    } else {
+      assert( nArg==2+v->nColumn+1);
+      rc = index_update(v, rowid, &ppArg[2]);
+    }
+  } else {
+    /* An insert:
+     * ppArg[1] = requested rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     */
+    assert( nArg==2+v->nColumn+1);
+    rc = index_insert(v, ppArg[1], &ppArg[2], pRowid);
+  }
+
+  return rc;
+}
+
+static int fulltextSync(sqlite3_vtab *pVtab){
+  TRACE(("FTS2 xSync()\n"));
+  return flushPendingTerms((fulltext_vtab *)pVtab);
+}
+
+static int fulltextBegin(sqlite3_vtab *pVtab){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  TRACE(("FTS2 xBegin()\n"));
+
+  /* Any buffered updates should have been cleared by the previous
+  ** transaction.
+  */
+  assert( v->nPendingData<0 );
+  return clearPendingTerms(v);
+}
+
+static int fulltextCommit(sqlite3_vtab *pVtab){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  TRACE(("FTS2 xCommit()\n"));
+
+  /* Buffered updates should have been cleared by fulltextSync(). */
+  assert( v->nPendingData<0 );
+  return clearPendingTerms(v);
+}
+
+static int fulltextRollback(sqlite3_vtab *pVtab){
+  TRACE(("FTS2 xRollback()\n"));
+  return clearPendingTerms((fulltext_vtab *)pVtab);
+}
+
+/*
+** Implementation of the snippet() function for FTS2
+*/
+static void snippetFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to html_snippet",-1);
+  }else{
+    const char *zStart = "<b>";
+    const char *zEnd = "</b>";
+    const char *zEllipsis = "<b>...</b>";
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    if( argc>=2 ){
+      zStart = (const char*)sqlite3_value_text(argv[1]);
+      if( argc>=3 ){
+        zEnd = (const char*)sqlite3_value_text(argv[2]);
+        if( argc>=4 ){
+          zEllipsis = (const char*)sqlite3_value_text(argv[3]);
+        }
+      }
+    }
+    snippetAllOffsets(pCursor);
+    snippetText(pCursor, zStart, zEnd, zEllipsis);
+    sqlite3_result_text(pContext, pCursor->snippet.zSnippet,
+                        pCursor->snippet.nSnippet, SQLITE_STATIC);
+  }
+}
+
+/*
+** Implementation of the offsets() function for FTS2
+*/
+static void snippetOffsetsFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to offsets",-1);
+  }else{
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    snippetAllOffsets(pCursor);
+    snippetOffsetText(&pCursor->snippet);
+    sqlite3_result_text(pContext,
+                        pCursor->snippet.zOffset, pCursor->snippet.nOffset,
+                        SQLITE_STATIC);
+  }
+}
+
+/*
+** This routine implements the xFindFunction method for the FTS2
+** virtual table.
+*/
+static int fulltextFindFunction(
+  sqlite3_vtab *pVtab,
+  int nArg,
+  const char *zName,
+  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+  void **ppArg
+){
+  if( strcmp(zName,"snippet")==0 ){
+    *pxFunc = snippetFunc;
+    return 1;
+  }else if( strcmp(zName,"offsets")==0 ){
+    *pxFunc = snippetOffsetsFunc;
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Rename an fts2 table.
+*/
+static int fulltextRename(
+  sqlite3_vtab *pVtab,
+  const char *zName
+){
+  fulltext_vtab *p = (fulltext_vtab *)pVtab;
+  int rc = SQLITE_NOMEM;
+  char *zSql = sqlite3_mprintf(
+    "ALTER TABLE %Q.'%q_content'  RENAME TO '%q_content';"
+    "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';"
+    "ALTER TABLE %Q.'%q_segdir'   RENAME TO '%q_segdir';"
+    , p->zDb, p->zName, zName 
+    , p->zDb, p->zName, zName 
+    , p->zDb, p->zName, zName
+  );
+  if( zSql ){
+    rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+  }
+  return rc;
+}
+
+static const sqlite3_module fts2Module = {
+  /* iVersion      */ 0,
+  /* xCreate       */ fulltextCreate,
+  /* xConnect      */ fulltextConnect,
+  /* xBestIndex    */ fulltextBestIndex,
+  /* xDisconnect   */ fulltextDisconnect,
+  /* xDestroy      */ fulltextDestroy,
+  /* xOpen         */ fulltextOpen,
+  /* xClose        */ fulltextClose,
+  /* xFilter       */ fulltextFilter,
+  /* xNext         */ fulltextNext,
+  /* xEof          */ fulltextEof,
+  /* xColumn       */ fulltextColumn,
+  /* xRowid        */ fulltextRowid,
+  /* xUpdate       */ fulltextUpdate,
+  /* xBegin        */ fulltextBegin,
+  /* xSync         */ fulltextSync,
+  /* xCommit       */ fulltextCommit,
+  /* xRollback     */ fulltextRollback,
+  /* xFindFunction */ fulltextFindFunction,
+  /* xRename */       fulltextRename,
+};
+
+static void hashDestroy(void *p){
+  fts2Hash *pHash = (fts2Hash *)p;
+  sqlite3Fts2HashClear(pHash);
+  sqlite3_free(pHash);
+}
+
+/*
+** The fts2 built-in tokenizers - "simple" and "porter" - are implemented
+** in files fts2_tokenizer1.c and fts2_porter.c respectively. The following
+** two forward declarations are for functions declared in these files
+** used to retrieve the respective implementations.
+**
+** Calling sqlite3Fts2SimpleTokenizerModule() sets the value pointed
+** to by the argument to point a the "simple" tokenizer implementation.
+** Function ...PorterTokenizerModule() sets *pModule to point to the
+** porter tokenizer/stemmer implementation.
+*/
+void sqlite3Fts2SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+void sqlite3Fts2PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+void sqlite3Fts2IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+
+int sqlite3Fts2InitHashTable(sqlite3 *, fts2Hash *, const char *);
+
+/*
+** Initialise the fts2 extension. If this extension is built as part
+** of the sqlite library, then this function is called directly by
+** SQLite. If fts2 is built as a dynamically loadable extension, this
+** function is called by the sqlite3_extension_init() entry point.
+*/
+int sqlite3Fts2Init(sqlite3 *db){
+  int rc = SQLITE_OK;
+  fts2Hash *pHash = 0;
+  const sqlite3_tokenizer_module *pSimple = 0;
+  const sqlite3_tokenizer_module *pPorter = 0;
+  const sqlite3_tokenizer_module *pIcu = 0;
+
+  sqlite3Fts2SimpleTokenizerModule(&pSimple);
+  sqlite3Fts2PorterTokenizerModule(&pPorter);
+#ifdef SQLITE_ENABLE_ICU
+  sqlite3Fts2IcuTokenizerModule(&pIcu);
+#endif
+
+  /* Allocate and initialise the hash-table used to store tokenizers. */
+  pHash = sqlite3_malloc(sizeof(fts2Hash));
+  if( !pHash ){
+    rc = SQLITE_NOMEM;
+  }else{
+    sqlite3Fts2HashInit(pHash, FTS2_HASH_STRING, 1);
+  }
+
+  /* Load the built-in tokenizers into the hash table */
+  if( rc==SQLITE_OK ){
+    if( sqlite3Fts2HashInsert(pHash, "simple", 7, (void *)pSimple)
+     || sqlite3Fts2HashInsert(pHash, "porter", 7, (void *)pPorter) 
+     || (pIcu && sqlite3Fts2HashInsert(pHash, "icu", 4, (void *)pIcu))
+    ){
+      rc = SQLITE_NOMEM;
+    }
+  }
+
+  /* Create the virtual table wrapper around the hash-table and overload 
+  ** the two scalar functions. If this is successful, register the
+  ** module with sqlite.
+  */
+  if( SQLITE_OK==rc 
+   && SQLITE_OK==(rc = sqlite3Fts2InitHashTable(db, pHash, "fts2_tokenizer"))
+   && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
+   && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", -1))
+  ){
+    return sqlite3_create_module_v2(
+        db, "fts2", &fts2Module, (void *)pHash, hashDestroy
+    );
+  }
+
+  /* An error has occured. Delete the hash table and return the error code. */
+  assert( rc!=SQLITE_OK );
+  if( pHash ){
+    sqlite3Fts2HashClear(pHash);
+    sqlite3_free(pHash);
+  }
+  return rc;
+}
+
+#if !SQLITE_CORE
+int sqlite3_extension_init(
+  sqlite3 *db, 
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi)
+  return sqlite3Fts2Init(db);
+}
+#endif
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.h
new file mode 100644
index 0000000..4da4c38
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2.h
@@ -0,0 +1,26 @@
+/*
+** 2006 Oct 10
+**
+** 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 header file is used by programs that want to link against the
+** FTS2 library.  All it does is declare the sqlite3Fts2Init() interface.
+*/
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+int sqlite3Fts2Init(sqlite3 *db);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.c
new file mode 100644
index 0000000..fcd5cc2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.c
@@ -0,0 +1,369 @@
+/*
+** 2001 September 22
+**
+** 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 is the implementation of generic hash-tables used in SQLite.
+** We've modified it slightly to serve as a standalone hash table
+** implementation for the full-text indexing module.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS2 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS2 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "fts2_hash.h"
+
+static void *malloc_and_zero(int n){
+  void *p = malloc(n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+
+/* Turn bulk memory into a hash table object by initializing the
+** fields of the Hash structure.
+**
+** "pNew" is a pointer to the hash table that is to be initialized.
+** keyClass is one of the constants 
+** FTS2_HASH_BINARY or FTS2_HASH_STRING.  The value of keyClass 
+** determines what kind of key the hash table will use.  "copyKey" is
+** true if the hash table should make its own private copy of keys and
+** false if it should just use the supplied pointer.
+*/
+void sqlite3Fts2HashInit(fts2Hash *pNew, int keyClass, int copyKey){
+  assert( pNew!=0 );
+  assert( keyClass>=FTS2_HASH_STRING && keyClass<=FTS2_HASH_BINARY );
+  pNew->keyClass = keyClass;
+  pNew->copyKey = copyKey;
+  pNew->first = 0;
+  pNew->count = 0;
+  pNew->htsize = 0;
+  pNew->ht = 0;
+  pNew->xMalloc = malloc_and_zero;
+  pNew->xFree = free;
+}
+
+/* Remove all entries from a hash table.  Reclaim all memory.
+** Call this routine to delete a hash table or to reset a hash table
+** to the empty state.
+*/
+void sqlite3Fts2HashClear(fts2Hash *pH){
+  fts2HashElem *elem;         /* For looping over all elements of the table */
+
+  assert( pH!=0 );
+  elem = pH->first;
+  pH->first = 0;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = 0;
+  pH->htsize = 0;
+  while( elem ){
+    fts2HashElem *next_elem = elem->next;
+    if( pH->copyKey && elem->pKey ){
+      pH->xFree(elem->pKey);
+    }
+    pH->xFree(elem);
+    elem = next_elem;
+  }
+  pH->count = 0;
+}
+
+/*
+** Hash and comparison functions when the mode is FTS2_HASH_STRING
+*/
+static int strHash(const void *pKey, int nKey){
+  const char *z = (const char *)pKey;
+  int h = 0;
+  if( nKey<=0 ) nKey = (int) strlen(z);
+  while( nKey > 0  ){
+    h = (h<<3) ^ h ^ *z++;
+    nKey--;
+  }
+  return h & 0x7fffffff;
+}
+static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return strncmp((const char*)pKey1,(const char*)pKey2,n1);
+}
+
+/*
+** Hash and comparison functions when the mode is FTS2_HASH_BINARY
+*/
+static int binHash(const void *pKey, int nKey){
+  int h = 0;
+  const char *z = (const char *)pKey;
+  while( nKey-- > 0 ){
+    h = (h<<3) ^ h ^ *(z++);
+  }
+  return h & 0x7fffffff;
+}
+static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return memcmp(pKey1,pKey2,n1);
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** The C syntax in this function definition may be unfamilar to some 
+** programmers, so we provide the following additional explanation:
+**
+** The name of the function is "hashFunction".  The function takes a
+** single parameter "keyClass".  The return value of hashFunction()
+** is a pointer to another function.  Specifically, the return value
+** of hashFunction() is a pointer to a function that takes two parameters
+** with types "const void*" and "int" and returns an "int".
+*/
+static int (*hashFunction(int keyClass))(const void*,int){
+  if( keyClass==FTS2_HASH_STRING ){
+    return &strHash;
+  }else{
+    assert( keyClass==FTS2_HASH_BINARY );
+    return &binHash;
+  }
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** For help in interpreted the obscure C code in the function definition,
+** see the header comment on the previous function.
+*/
+static int (*compareFunction(int keyClass))(const void*,int,const void*,int){
+  if( keyClass==FTS2_HASH_STRING ){
+    return &strCompare;
+  }else{
+    assert( keyClass==FTS2_HASH_BINARY );
+    return &binCompare;
+  }
+}
+
+/* Link an element into the hash table
+*/
+static void insertElement(
+  fts2Hash *pH,            /* The complete hash table */
+  struct _fts2ht *pEntry,  /* The entry into which pNew is inserted */
+  fts2HashElem *pNew       /* The element to be inserted */
+){
+  fts2HashElem *pHead;     /* First element already in pEntry */
+  pHead = pEntry->chain;
+  if( pHead ){
+    pNew->next = pHead;
+    pNew->prev = pHead->prev;
+    if( pHead->prev ){ pHead->prev->next = pNew; }
+    else             { pH->first = pNew; }
+    pHead->prev = pNew;
+  }else{
+    pNew->next = pH->first;
+    if( pH->first ){ pH->first->prev = pNew; }
+    pNew->prev = 0;
+    pH->first = pNew;
+  }
+  pEntry->count++;
+  pEntry->chain = pNew;
+}
+
+
+/* Resize the hash table so that it cantains "new_size" buckets.
+** "new_size" must be a power of 2.  The hash table might fail 
+** to resize if sqliteMalloc() fails.
+*/
+static void rehash(fts2Hash *pH, int new_size){
+  struct _fts2ht *new_ht;          /* The new hash table */
+  fts2HashElem *elem, *next_elem;  /* For looping over existing elements */
+  int (*xHash)(const void*,int);   /* The hash function */
+
+  assert( (new_size & (new_size-1))==0 );
+  new_ht = (struct _fts2ht *)pH->xMalloc( new_size*sizeof(struct _fts2ht) );
+  if( new_ht==0 ) return;
+  if( pH->ht ) pH->xFree(pH->ht);
+  pH->ht = new_ht;
+  pH->htsize = new_size;
+  xHash = hashFunction(pH->keyClass);
+  for(elem=pH->first, pH->first=0; elem; elem = next_elem){
+    int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
+    next_elem = elem->next;
+    insertElement(pH, &new_ht[h], elem);
+  }
+}
+
+/* This function (for internal use only) locates an element in an
+** hash table that matches the given key.  The hash for this key has
+** already been computed and is passed as the 4th parameter.
+*/
+static fts2HashElem *findElementGivenHash(
+  const fts2Hash *pH, /* The pH to be searched */
+  const void *pKey,   /* The key we are searching for */
+  int nKey,
+  int h               /* The hash for this key. */
+){
+  fts2HashElem *elem;            /* Used to loop thru the element list */
+  int count;                     /* Number of elements left to test */
+  int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
+
+  if( pH->ht ){
+    struct _fts2ht *pEntry = &pH->ht[h];
+    elem = pEntry->chain;
+    count = pEntry->count;
+    xCompare = compareFunction(pH->keyClass);
+    while( count-- && elem ){
+      if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
+        return elem;
+      }
+      elem = elem->next;
+    }
+  }
+  return 0;
+}
+
+/* Remove a single entry from the hash table given a pointer to that
+** element and a hash on the element's key.
+*/
+static void removeElementGivenHash(
+  fts2Hash *pH,         /* The pH containing "elem" */
+  fts2HashElem* elem,   /* The element to be removed from the pH */
+  int h                 /* Hash value for the element */
+){
+  struct _fts2ht *pEntry;
+  if( elem->prev ){
+    elem->prev->next = elem->next; 
+  }else{
+    pH->first = elem->next;
+  }
+  if( elem->next ){
+    elem->next->prev = elem->prev;
+  }
+  pEntry = &pH->ht[h];
+  if( pEntry->chain==elem ){
+    pEntry->chain = elem->next;
+  }
+  pEntry->count--;
+  if( pEntry->count<=0 ){
+    pEntry->chain = 0;
+  }
+  if( pH->copyKey && elem->pKey ){
+    pH->xFree(elem->pKey);
+  }
+  pH->xFree( elem );
+  pH->count--;
+  if( pH->count<=0 ){
+    assert( pH->first==0 );
+    assert( pH->count==0 );
+    fts2HashClear(pH);
+  }
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *sqlite3Fts2HashFind(const fts2Hash *pH, const void *pKey, int nKey){
+  int h;                 /* A hash on key */
+  fts2HashElem *elem;    /* The element that matches key */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  if( pH==0 || pH->ht==0 ) return 0;
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  h = (*xHash)(pKey,nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem ? elem->data : 0;
+}
+
+/* Insert an element into the hash table pH.  The key is pKey,nKey
+** and the data is "data".
+**
+** If no element exists with a matching key, then a new
+** element is created.  A copy of the key is made if the copyKey
+** flag is set.  NULL is returned.
+**
+** If another element already exists with the same key, then the
+** new data replaces the old data and the old data is returned.
+** The key is not copied in this instance.  If a malloc fails, then
+** the new data is returned and the hash table is unchanged.
+**
+** If the "data" parameter to this function is NULL, then the
+** element corresponding to "key" is removed from the hash table.
+*/
+void *sqlite3Fts2HashInsert(
+  fts2Hash *pH,        /* The hash table to insert into */
+  const void *pKey,    /* The key */
+  int nKey,            /* Number of bytes in the key */
+  void *data           /* The data */
+){
+  int hraw;                 /* Raw hash value of the key */
+  int h;                    /* the hash of the key modulo hash table size */
+  fts2HashElem *elem;       /* Used to loop thru the element list */
+  fts2HashElem *new_elem;   /* New element added to the pH */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  assert( pH!=0 );
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  hraw = (*xHash)(pKey, nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  elem = findElementGivenHash(pH,pKey,nKey,h);
+  if( elem ){
+    void *old_data = elem->data;
+    if( data==0 ){
+      removeElementGivenHash(pH,elem,h);
+    }else{
+      elem->data = data;
+    }
+    return old_data;
+  }
+  if( data==0 ) return 0;
+  new_elem = (fts2HashElem*)pH->xMalloc( sizeof(fts2HashElem) );
+  if( new_elem==0 ) return data;
+  if( pH->copyKey && pKey!=0 ){
+    new_elem->pKey = pH->xMalloc( nKey );
+    if( new_elem->pKey==0 ){
+      pH->xFree(new_elem);
+      return data;
+    }
+    memcpy((void*)new_elem->pKey, pKey, nKey);
+  }else{
+    new_elem->pKey = (void*)pKey;
+  }
+  new_elem->nKey = nKey;
+  pH->count++;
+  if( pH->htsize==0 ){
+    rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      pH->xFree(new_elem);
+      return data;
+    }
+  }
+  if( pH->count > pH->htsize ){
+    rehash(pH,pH->htsize*2);
+  }
+  assert( pH->htsize>0 );
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  insertElement(pH, &pH->ht[h], new_elem);
+  new_elem->data = data;
+  return 0;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.h
new file mode 100644
index 0000000..97f3529
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_hash.h
@@ -0,0 +1,112 @@
+/*
+** 2001 September 22
+**
+** 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 is the header file for the generic hash-table implemenation
+** used in SQLite.  We've modified it slightly to serve as a standalone
+** hash table implementation for the full-text indexing module.
+**
+*/
+#ifndef _FTS2_HASH_H_
+#define _FTS2_HASH_H_
+
+/* Forward declarations of structures. */
+typedef struct fts2Hash fts2Hash;
+typedef struct fts2HashElem fts2HashElem;
+
+/* A complete hash table is an instance of the following structure.
+** The internals of this structure are intended to be opaque -- client
+** code should not attempt to access or modify the fields of this structure
+** directly.  Change this structure only by using the routines below.
+** However, many of the "procedures" and "functions" for modifying and
+** accessing this structure are really macros, so we can't really make
+** this structure opaque.
+*/
+struct fts2Hash {
+  char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
+  char copyKey;           /* True if copy of key made on insert */
+  int count;              /* Number of entries in this table */
+  fts2HashElem *first;    /* The first element of the array */
+  void *(*xMalloc)(int);  /* malloc() function to use */
+  void (*xFree)(void *);  /* free() function to use */
+  int htsize;             /* Number of buckets in the hash table */
+  struct _fts2ht {        /* the hash table */
+    int count;               /* Number of entries with this hash */
+    fts2HashElem *chain;     /* Pointer to first entry with this hash */
+  } *ht;
+};
+
+/* Each element in the hash table is an instance of the following 
+** structure.  All elements are stored on a single doubly-linked list.
+**
+** Again, this structure is intended to be opaque, but it can't really
+** be opaque because it is used by macros.
+*/
+struct fts2HashElem {
+  fts2HashElem *next, *prev; /* Next and previous elements in the table */
+  void *data;                /* Data associated with this element */
+  void *pKey; int nKey;      /* Key associated with this element */
+};
+
+/*
+** There are 2 different modes of operation for a hash table:
+**
+**   FTS2_HASH_STRING        pKey points to a string that is nKey bytes long
+**                           (including the null-terminator, if any).  Case
+**                           is respected in comparisons.
+**
+**   FTS2_HASH_BINARY        pKey points to binary data nKey bytes long. 
+**                           memcmp() is used to compare keys.
+**
+** A copy of the key is made if the copyKey parameter to fts2HashInit is 1.  
+*/
+#define FTS2_HASH_STRING    1
+#define FTS2_HASH_BINARY    2
+
+/*
+** Access routines.  To delete, insert a NULL pointer.
+*/
+void sqlite3Fts2HashInit(fts2Hash*, int keytype, int copyKey);
+void *sqlite3Fts2HashInsert(fts2Hash*, const void *pKey, int nKey, void *pData);
+void *sqlite3Fts2HashFind(const fts2Hash*, const void *pKey, int nKey);
+void sqlite3Fts2HashClear(fts2Hash*);
+
+/*
+** Shorthand for the functions above
+*/
+#define fts2HashInit   sqlite3Fts2HashInit
+#define fts2HashInsert sqlite3Fts2HashInsert
+#define fts2HashFind   sqlite3Fts2HashFind
+#define fts2HashClear  sqlite3Fts2HashClear
+
+/*
+** Macros for looping over all elements of a hash table.  The idiom is
+** like this:
+**
+**   fts2Hash h;
+**   fts2HashElem *p;
+**   ...
+**   for(p=fts2HashFirst(&h); p; p=fts2HashNext(p)){
+**     SomeStructure *pData = fts2HashData(p);
+**     // do something with pData
+**   }
+*/
+#define fts2HashFirst(H)  ((H)->first)
+#define fts2HashNext(E)   ((E)->next)
+#define fts2HashData(E)   ((E)->data)
+#define fts2HashKey(E)    ((E)->pKey)
+#define fts2HashKeysize(E) ((E)->nKey)
+
+/*
+** Number of entries in a hash table
+*/
+#define fts2HashCount(H)  ((H)->count)
+
+#endif /* _FTS2_HASH_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_icu.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_icu.c
new file mode 100644
index 0000000..ed15f33
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_icu.c
@@ -0,0 +1,257 @@
+/*
+** 2007 June 22
+**
+** 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 implements a tokenizer for fts2 based on the ICU library.
+** 
+** $Id: fts2_icu.c,v 1.1 2007/06/22 15:21:16 danielk1977 Exp $
+*/
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+#ifdef SQLITE_ENABLE_ICU
+
+#include <assert.h>
+#include <string.h>
+#include "fts2_tokenizer.h"
+
+#include <unicode/ubrk.h>
+#include <unicode/ucol.h>
+#include <unicode/ustring.h>
+#include <unicode/utf16.h>
+
+typedef struct IcuTokenizer IcuTokenizer;
+typedef struct IcuCursor IcuCursor;
+
+struct IcuTokenizer {
+  sqlite3_tokenizer base;
+  char *zLocale;
+};
+
+struct IcuCursor {
+  sqlite3_tokenizer_cursor base;
+
+  UBreakIterator *pIter;      /* ICU break-iterator object */
+  int nChar;                  /* Number of UChar elements in pInput */
+  UChar *aChar;               /* Copy of input using utf-16 encoding */
+  int *aOffset;               /* Offsets of each character in utf-8 input */
+
+  int nBuffer;
+  char *zBuffer;
+
+  int iToken;
+};
+
+/*
+** Create a new tokenizer instance.
+*/
+static int icuCreate(
+  int argc,                            /* Number of entries in argv[] */
+  const char * const *argv,            /* Tokenizer creation arguments */
+  sqlite3_tokenizer **ppTokenizer      /* OUT: Created tokenizer */
+){
+  IcuTokenizer *p;
+  int n = 0;
+
+  if( argc>0 ){
+    n = strlen(argv[0])+1;
+  }
+  p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
+  if( !p ){
+    return SQLITE_NOMEM;
+  }
+  memset(p, 0, sizeof(IcuTokenizer));
+
+  if( n ){
+    p->zLocale = (char *)&p[1];
+    memcpy(p->zLocale, argv[0], n);
+  }
+
+  *ppTokenizer = (sqlite3_tokenizer *)p;
+
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int icuDestroy(sqlite3_tokenizer *pTokenizer){
+  IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
+  sqlite3_free(p);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is pInput[0..nBytes-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int icuOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *zInput,                    /* Input string */
+  int nInput,                            /* Length of zInput in bytes */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
+  IcuCursor *pCsr;
+
+  const int32_t opt = U_FOLD_CASE_DEFAULT;
+  UErrorCode status = U_ZERO_ERROR;
+  int nChar;
+
+  UChar32 c;
+  int iInput = 0;
+  int iOut = 0;
+
+  *ppCursor = 0;
+
+  nChar = nInput+1;
+  pCsr = (IcuCursor *)sqlite3_malloc(
+      sizeof(IcuCursor) +                /* IcuCursor */
+      nChar * sizeof(UChar) +            /* IcuCursor.aChar[] */
+      (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
+  );
+  if( !pCsr ){
+    return SQLITE_NOMEM;
+  }
+  memset(pCsr, 0, sizeof(IcuCursor));
+  pCsr->aChar = (UChar *)&pCsr[1];
+  pCsr->aOffset = (int *)&pCsr->aChar[nChar];
+
+  pCsr->aOffset[iOut] = iInput;
+  U8_NEXT(zInput, iInput, nInput, c); 
+  while( c>0 ){
+    int isError = 0;
+    c = u_foldCase(c, opt);
+    U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
+    if( isError ){
+      sqlite3_free(pCsr);
+      return SQLITE_ERROR;
+    }
+    pCsr->aOffset[iOut] = iInput;
+
+    if( iInput<nInput ){
+      U8_NEXT(zInput, iInput, nInput, c);
+    }else{
+      c = 0;
+    }
+  }
+
+  pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
+  if( !U_SUCCESS(status) ){
+    sqlite3_free(pCsr);
+    return SQLITE_ERROR;
+  }
+  pCsr->nChar = iOut;
+
+  ubrk_first(pCsr->pIter);
+  *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to icuOpen().
+*/
+static int icuClose(sqlite3_tokenizer_cursor *pCursor){
+  IcuCursor *pCsr = (IcuCursor *)pCursor;
+  ubrk_close(pCsr->pIter);
+  sqlite3_free(pCsr->zBuffer);
+  sqlite3_free(pCsr);
+  return SQLITE_OK;
+}
+
+/*
+** Extract the next token from a tokenization cursor.
+*/
+static int icuNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
+  const char **ppToken,               /* OUT: *ppToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  IcuCursor *pCsr = (IcuCursor *)pCursor;
+
+  int iStart = 0;
+  int iEnd = 0;
+  int nByte = 0;
+
+  while( iStart==iEnd ){
+    UChar32 c;
+
+    iStart = ubrk_current(pCsr->pIter);
+    iEnd = ubrk_next(pCsr->pIter);
+    if( iEnd==UBRK_DONE ){
+      return SQLITE_DONE;
+    }
+
+    while( iStart<iEnd ){
+      int iWhite = iStart;
+      U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
+      if( u_isspace(c) ){
+        iStart = iWhite;
+      }else{
+        break;
+      }
+    }
+    assert(iStart<=iEnd);
+  }
+
+  do {
+    UErrorCode status = U_ZERO_ERROR;
+    if( nByte ){
+      char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
+      if( !zNew ){
+        return SQLITE_NOMEM;
+      }
+      pCsr->zBuffer = zNew;
+      pCsr->nBuffer = nByte;
+    }
+
+    u_strToUTF8(
+        pCsr->zBuffer, pCsr->nBuffer, &nByte,    /* Output vars */
+        &pCsr->aChar[iStart], iEnd-iStart,       /* Input vars */
+        &status                                  /* Output success/failure */
+    );
+  } while( nByte>pCsr->nBuffer );
+
+  *ppToken = pCsr->zBuffer;
+  *pnBytes = nByte;
+  *piStartOffset = pCsr->aOffset[iStart];
+  *piEndOffset = pCsr->aOffset[iEnd];
+  *piPosition = pCsr->iToken++;
+
+  return SQLITE_OK;
+}
+
+/*
+** The set of routines that implement the simple tokenizer
+*/
+static const sqlite3_tokenizer_module icuTokenizerModule = {
+  0,                           /* iVersion */
+  icuCreate,                   /* xCreate  */
+  icuDestroy,                  /* xCreate  */
+  icuOpen,                     /* xOpen    */
+  icuClose,                    /* xClose   */
+  icuNext,                     /* xNext    */
+};
+
+/*
+** Set *ppModule to point at the implementation of the ICU tokenizer.
+*/
+void sqlite3Fts2IcuTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &icuTokenizerModule;
+}
+
+#endif /* defined(SQLITE_ENABLE_ICU) */
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_porter.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_porter.c
new file mode 100644
index 0000000..dab1849
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_porter.c
@@ -0,0 +1,642 @@
+/*
+** 2006 September 30
+**
+** 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.
+**
+*************************************************************************
+** Implementation of the full-text-search tokenizer that implements
+** a Porter stemmer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS2 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS2 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts2_tokenizer.h"
+
+/*
+** Class derived from sqlite3_tokenizer
+*/
+typedef struct porter_tokenizer {
+  sqlite3_tokenizer base;      /* Base class */
+} porter_tokenizer;
+
+/*
+** Class derived from sqlit3_tokenizer_cursor
+*/
+typedef struct porter_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *zInput;          /* input we are tokenizing */
+  int nInput;                  /* size of the input */
+  int iOffset;                 /* current position in zInput */
+  int iToken;                  /* index of next token to be returned */
+  char *zToken;                /* storage for current token */
+  int nAllocated;              /* space allocated to zToken buffer */
+} porter_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module porterTokenizerModule;
+
+
+/*
+** Create a new tokenizer instance.
+*/
+static int porterCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  porter_tokenizer *t;
+  t = (porter_tokenizer *) calloc(sizeof(*t), 1);
+  if( t==NULL ) return SQLITE_NOMEM;
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int porterDestroy(sqlite3_tokenizer *pTokenizer){
+  free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is zInput[0..nInput-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int porterOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *zInput, int nInput,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  porter_tokenizer_cursor *c;
+
+  c = (porter_tokenizer_cursor *) malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->zInput = zInput;
+  if( zInput==0 ){
+    c->nInput = 0;
+  }else if( nInput<0 ){
+    c->nInput = (int)strlen(zInput);
+  }else{
+    c->nInput = nInput;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->zToken = NULL;               /* no space allocated, yet. */
+  c->nAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** porterOpen() above.
+*/
+static int porterClose(sqlite3_tokenizer_cursor *pCursor){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  free(c->zToken);
+  free(c);
+  return SQLITE_OK;
+}
+/*
+** Vowel or consonant
+*/
+static const char cType[] = {
+   0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,
+   1, 1, 1, 2, 1
+};
+
+/*
+** isConsonant() and isVowel() determine if their first character in
+** the string they point to is a consonant or a vowel, according
+** to Porter ruls.  
+**
+** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'.
+** 'Y' is a consonant unless it follows another consonant,
+** in which case it is a vowel.
+**
+** In these routine, the letters are in reverse order.  So the 'y' rule
+** is that 'y' is a consonant unless it is followed by another
+** consonent.
+*/
+static int isVowel(const char*);
+static int isConsonant(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return j;
+  return z[1]==0 || isVowel(z + 1);
+}
+static int isVowel(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return 1-j;
+  return isConsonant(z + 1);
+}
+
+/*
+** Let any sequence of one or more vowels be represented by V and let
+** C be sequence of one or more consonants.  Then every word can be
+** represented as:
+**
+**           [C] (VC){m} [V]
+**
+** In prose:  A word is an optional consonant followed by zero or
+** vowel-consonant pairs followed by an optional vowel.  "m" is the
+** number of vowel consonant pairs.  This routine computes the value
+** of m for the first i bytes of a word.
+**
+** Return true if the m-value for z is 1 or more.  In other words,
+** return true if z contains at least one vowel that is followed
+** by a consonant.
+**
+** In this routine z[] is in reverse order.  So we are really looking
+** for an instance of of a consonant followed by a vowel.
+*/
+static int m_gt_0(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/* Like mgt0 above except we are looking for a value of m which is
+** exactly 1
+*/
+static int m_eq_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 1;
+  while( isConsonant(z) ){ z++; }
+  return *z==0;
+}
+
+/* Like mgt0 above except we are looking for a value of m>1 instead
+** or m>0
+*/
+static int m_gt_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if there is a vowel anywhere within z[0..n-1]
+*/
+static int hasVowel(const char *z){
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if the word ends in a double consonant.
+**
+** The text is reversed here. So we are really looking at
+** the first two characters of z[].
+*/
+static int doubleConsonant(const char *z){
+  return isConsonant(z) && z[0]==z[1] && isConsonant(z+1);
+}
+
+/*
+** Return TRUE if the word ends with three letters which
+** are consonant-vowel-consonent and where the final consonant
+** is not 'w', 'x', or 'y'.
+**
+** The word is reversed here.  So we are really checking the
+** first three letters and the first one cannot be in [wxy].
+*/
+static int star_oh(const char *z){
+  return
+    z[0]!=0 && isConsonant(z) &&
+    z[0]!='w' && z[0]!='x' && z[0]!='y' &&
+    z[1]!=0 && isVowel(z+1) &&
+    z[2]!=0 && isConsonant(z+2);
+}
+
+/*
+** If the word ends with zFrom and xCond() is true for the stem
+** of the word that preceeds the zFrom ending, then change the 
+** ending to zTo.
+**
+** The input word *pz and zFrom are both in reverse order.  zTo
+** is in normal order. 
+**
+** Return TRUE if zFrom matches.  Return FALSE if zFrom does not
+** match.  Not that TRUE is returned even if xCond() fails and
+** no substitution occurs.
+*/
+static int stem(
+  char **pz,             /* The word being stemmed (Reversed) */
+  const char *zFrom,     /* If the ending matches this... (Reversed) */
+  const char *zTo,       /* ... change the ending to this (not reversed) */
+  int (*xCond)(const char*)   /* Condition that must be true */
+){
+  char *z = *pz;
+  while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
+  if( *zFrom!=0 ) return 0;
+  if( xCond && !xCond(z) ) return 1;
+  while( *zTo ){
+    *(--z) = *(zTo++);
+  }
+  *pz = z;
+  return 1;
+}
+
+/*
+** This is the fallback stemmer used when the porter stemmer is
+** inappropriate.  The input word is copied into the output with
+** US-ASCII case folding.  If the input word is too long (more
+** than 20 bytes if it contains no digits or more than 6 bytes if
+** it contains digits) then word is truncated to 20 or 6 bytes
+** by taking 10 or 3 bytes from the beginning and end.
+*/
+static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, mx, j;
+  int hasDigit = 0;
+  for(i=0; i<nIn; i++){
+    int c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zOut[i] = c - 'A' + 'a';
+    }else{
+      if( c>='0' && c<='9' ) hasDigit = 1;
+      zOut[i] = c;
+    }
+  }
+  mx = hasDigit ? 3 : 10;
+  if( nIn>mx*2 ){
+    for(j=mx, i=nIn-mx; i<nIn; i++, j++){
+      zOut[j] = zOut[i];
+    }
+    i = j;
+  }
+  zOut[i] = 0;
+  *pnOut = i;
+}
+
+
+/*
+** Stem the input word zIn[0..nIn-1].  Store the output in zOut.
+** zOut is at least big enough to hold nIn bytes.  Write the actual
+** size of the output word (exclusive of the '\0' terminator) into *pnOut.
+**
+** Any upper-case characters in the US-ASCII character set ([A-Z])
+** are converted to lower case.  Upper-case UTF characters are
+** unchanged.
+**
+** Words that are longer than about 20 bytes are stemmed by retaining
+** a few bytes from the beginning and the end of the word.  If the
+** word contains digits, 3 bytes are taken from the beginning and
+** 3 bytes from the end.  For long words without digits, 10 bytes
+** are taken from each end.  US-ASCII case folding still applies.
+** 
+** If the input word contains not digits but does characters not 
+** in [a-zA-Z] then no stemming is attempted and this routine just 
+** copies the input into the input into the output with US-ASCII
+** case folding.
+**
+** Stemming never increases the length of the word.  So there is
+** no chance of overflowing the zOut buffer.
+*/
+static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, j, c;
+  char zReverse[28];
+  char *z, *z2;
+  if( nIn<3 || nIn>=sizeof(zReverse)-7 ){
+    /* The word is too big or too small for the porter stemmer.
+    ** Fallback to the copy stemmer */
+    copy_stemmer(zIn, nIn, zOut, pnOut);
+    return;
+  }
+  for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
+    c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zReverse[j] = c + 'a' - 'A';
+    }else if( c>='a' && c<='z' ){
+      zReverse[j] = c;
+    }else{
+      /* The use of a character not in [a-zA-Z] means that we fallback
+      ** to the copy stemmer */
+      copy_stemmer(zIn, nIn, zOut, pnOut);
+      return;
+    }
+  }
+  memset(&zReverse[sizeof(zReverse)-5], 0, 5);
+  z = &zReverse[j+1];
+
+
+  /* Step 1a */
+  if( z[0]=='s' ){
+    if(
+     !stem(&z, "sess", "ss", 0) &&
+     !stem(&z, "sei", "i", 0)  &&
+     !stem(&z, "ss", "ss", 0)
+    ){
+      z++;
+    }
+  }
+
+  /* Step 1b */  
+  z2 = z;
+  if( stem(&z, "dee", "ee", m_gt_0) ){
+    /* Do nothing.  The work was all in the test */
+  }else if( 
+     (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
+      && z!=z2
+  ){
+     if( stem(&z, "ta", "ate", 0) ||
+         stem(&z, "lb", "ble", 0) ||
+         stem(&z, "zi", "ize", 0) ){
+       /* Do nothing.  The work was all in the test */
+     }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
+       z++;
+     }else if( m_eq_1(z) && star_oh(z) ){
+       *(--z) = 'e';
+     }
+  }
+
+  /* Step 1c */
+  if( z[0]=='y' && hasVowel(z+1) ){
+    z[0] = 'i';
+  }
+
+  /* Step 2 */
+  switch( z[1] ){
+   case 'a':
+     stem(&z, "lanoita", "ate", m_gt_0) ||
+     stem(&z, "lanoit", "tion", m_gt_0);
+     break;
+   case 'c':
+     stem(&z, "icne", "ence", m_gt_0) ||
+     stem(&z, "icna", "ance", m_gt_0);
+     break;
+   case 'e':
+     stem(&z, "rezi", "ize", m_gt_0);
+     break;
+   case 'g':
+     stem(&z, "igol", "log", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "ilb", "ble", m_gt_0) ||
+     stem(&z, "illa", "al", m_gt_0) ||
+     stem(&z, "iltne", "ent", m_gt_0) ||
+     stem(&z, "ile", "e", m_gt_0) ||
+     stem(&z, "ilsuo", "ous", m_gt_0);
+     break;
+   case 'o':
+     stem(&z, "noitazi", "ize", m_gt_0) ||
+     stem(&z, "noita", "ate", m_gt_0) ||
+     stem(&z, "rota", "ate", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "msila", "al", m_gt_0) ||
+     stem(&z, "ssenevi", "ive", m_gt_0) ||
+     stem(&z, "ssenluf", "ful", m_gt_0) ||
+     stem(&z, "ssensuo", "ous", m_gt_0);
+     break;
+   case 't':
+     stem(&z, "itila", "al", m_gt_0) ||
+     stem(&z, "itivi", "ive", m_gt_0) ||
+     stem(&z, "itilib", "ble", m_gt_0);
+     break;
+  }
+
+  /* Step 3 */
+  switch( z[0] ){
+   case 'e':
+     stem(&z, "etaci", "ic", m_gt_0) ||
+     stem(&z, "evita", "", m_gt_0)   ||
+     stem(&z, "ezila", "al", m_gt_0);
+     break;
+   case 'i':
+     stem(&z, "itici", "ic", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "laci", "ic", m_gt_0) ||
+     stem(&z, "luf", "", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "ssen", "", m_gt_0);
+     break;
+  }
+
+  /* Step 4 */
+  switch( z[1] ){
+   case 'a':
+     if( z[0]=='l' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'c':
+     if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e')  && m_gt_1(z+4)  ){
+       z += 4;
+     }
+     break;
+   case 'e':
+     if( z[0]=='r' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'i':
+     if( z[0]=='c' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'l':
+     if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
+       z += 4;
+     }
+     break;
+   case 'n':
+     if( z[0]=='t' ){
+       if( z[2]=='a' ){
+         if( m_gt_1(z+3) ){
+           z += 3;
+         }
+       }else if( z[2]=='e' ){
+         stem(&z, "tneme", "", m_gt_1) ||
+         stem(&z, "tnem", "", m_gt_1) ||
+         stem(&z, "tne", "", m_gt_1);
+       }
+     }
+     break;
+   case 'o':
+     if( z[0]=='u' ){
+       if( m_gt_1(z+2) ){
+         z += 2;
+       }
+     }else if( z[3]=='s' || z[3]=='t' ){
+       stem(&z, "noi", "", m_gt_1);
+     }
+     break;
+   case 's':
+     if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 't':
+     stem(&z, "eta", "", m_gt_1) ||
+     stem(&z, "iti", "", m_gt_1);
+     break;
+   case 'u':
+     if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 'v':
+   case 'z':
+     if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+  }
+
+  /* Step 5a */
+  if( z[0]=='e' ){
+    if( m_gt_1(z+1) ){
+      z++;
+    }else if( m_eq_1(z+1) && !star_oh(z+1) ){
+      z++;
+    }
+  }
+
+  /* Step 5b */
+  if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
+    z++;
+  }
+
+  /* z[] is now the stemmed word in reverse order.  Flip it back
+  ** around into forward order and return.
+  */
+  *pnOut = i = strlen(z);
+  zOut[i] = 0;
+  while( *z ){
+    zOut[--i] = *(z++);
+  }
+}
+
+/*
+** Characters that can be part of a token.  We assume any character
+** whose value is greater than 0x80 (any UTF character) can be
+** part of a token.  In other words, delimiters all must have
+** values of 0x7f or lower.
+*/
+static const char porterIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30]))
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to porterOpen().
+*/
+static int porterNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by porterOpen */
+  const char **pzToken,               /* OUT: *pzToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  const char *z = c->zInput;
+
+  while( c->iOffset<c->nInput ){
+    int iStartOffset, ch;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int n = c->iOffset-iStartOffset;
+      if( n>c->nAllocated ){
+        c->nAllocated = n+20;
+        c->zToken = realloc(c->zToken, c->nAllocated);
+        if( c->zToken==NULL ) return SQLITE_NOMEM;
+      }
+      porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
+      *pzToken = c->zToken;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the porter-stemmer tokenizer
+*/
+static const sqlite3_tokenizer_module porterTokenizerModule = {
+  0,
+  porterCreate,
+  porterDestroy,
+  porterOpen,
+  porterClose,
+  porterNext,
+};
+
+/*
+** Allocate a new porter tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts2PorterTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &porterTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.c
new file mode 100644
index 0000000..cbf771b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.c
@@ -0,0 +1,371 @@
+/*
+** 2007 June 22
+**
+** 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 is part of an SQLite module implementing full-text search.
+** This particular file implements the generic tokenizer interface.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS2 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS2 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+
+
+#include "sqlite3.h"
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+#include "fts2_hash.h"
+#include "fts2_tokenizer.h"
+#include <assert.h>
+
+/*
+** Implementation of the SQL scalar function for accessing the underlying 
+** hash table. This function may be called as follows:
+**
+**   SELECT <function-name>(<key-name>);
+**   SELECT <function-name>(<key-name>, <pointer>);
+**
+** where <function-name> is the name passed as the second argument
+** to the sqlite3Fts2InitHashTable() function (e.g. 'fts2_tokenizer').
+**
+** If the <pointer> argument is specified, it must be a blob value
+** containing a pointer to be stored as the hash data corresponding
+** to the string <key-name>. If <pointer> is not specified, then
+** the string <key-name> must already exist in the has table. Otherwise,
+** an error is returned.
+**
+** Whether or not the <pointer> argument is specified, the value returned
+** is a blob containing the pointer stored as the hash data corresponding
+** to string <key-name> (after the hash-table is updated, if applicable).
+*/
+static void scalarFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  fts2Hash *pHash;
+  void *pPtr = 0;
+  const unsigned char *zName;
+  int nName;
+
+  assert( argc==1 || argc==2 );
+
+  pHash = (fts2Hash *)sqlite3_user_data(context);
+
+  zName = sqlite3_value_text(argv[0]);
+  nName = sqlite3_value_bytes(argv[0])+1;
+
+  if( argc==2 ){
+    void *pOld;
+    int n = sqlite3_value_bytes(argv[1]);
+    if( n!=sizeof(pPtr) ){
+      sqlite3_result_error(context, "argument type mismatch", -1);
+      return;
+    }
+    pPtr = *(void **)sqlite3_value_blob(argv[1]);
+    pOld = sqlite3Fts2HashInsert(pHash, (void *)zName, nName, pPtr);
+    if( pOld==pPtr ){
+      sqlite3_result_error(context, "out of memory", -1);
+      return;
+    }
+  }else{
+    pPtr = sqlite3Fts2HashFind(pHash, zName, nName);
+    if( !pPtr ){
+      char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
+      sqlite3_result_error(context, zErr, -1);
+      sqlite3_free(zErr);
+      return;
+    }
+  }
+
+  sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
+}
+
+#ifdef SQLITE_TEST
+
+#include <tcl.h>
+#include <string.h>
+
+/*
+** Implementation of a special SQL scalar function for testing tokenizers 
+** designed to be used in concert with the Tcl testing framework. This
+** function must be called with two arguments:
+**
+**   SELECT <function-name>(<key-name>, <input-string>);
+**   SELECT <function-name>(<key-name>, <pointer>);
+**
+** where <function-name> is the name passed as the second argument
+** to the sqlite3Fts2InitHashTable() function (e.g. 'fts2_tokenizer')
+** concatenated with the string '_test' (e.g. 'fts2_tokenizer_test').
+**
+** The return value is a string that may be interpreted as a Tcl
+** list. For each token in the <input-string>, three elements are
+** added to the returned list. The first is the token position, the 
+** second is the token text (folded, stemmed, etc.) and the third is the
+** substring of <input-string> associated with the token. For example, 
+** using the built-in "simple" tokenizer:
+**
+**   SELECT fts_tokenizer_test('simple', 'I don't see how');
+**
+** will return the string:
+**
+**   "{0 i I 1 dont don't 2 see see 3 how how}"
+**   
+*/
+static void testFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  fts2Hash *pHash;
+  sqlite3_tokenizer_module *p;
+  sqlite3_tokenizer *pTokenizer = 0;
+  sqlite3_tokenizer_cursor *pCsr = 0;
+
+  const char *zErr = 0;
+
+  const char *zName;
+  int nName;
+  const char *zInput;
+  int nInput;
+
+  const char *zArg = 0;
+
+  const char *zToken;
+  int nToken;
+  int iStart;
+  int iEnd;
+  int iPos;
+
+  Tcl_Obj *pRet;
+
+  assert( argc==2 || argc==3 );
+
+  nName = sqlite3_value_bytes(argv[0]);
+  zName = (const char *)sqlite3_value_text(argv[0]);
+  nInput = sqlite3_value_bytes(argv[argc-1]);
+  zInput = (const char *)sqlite3_value_text(argv[argc-1]);
+
+  if( argc==3 ){
+    zArg = (const char *)sqlite3_value_text(argv[1]);
+  }
+
+  pHash = (fts2Hash *)sqlite3_user_data(context);
+  p = (sqlite3_tokenizer_module *)sqlite3Fts2HashFind(pHash, zName, nName+1);
+
+  if( !p ){
+    char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
+    sqlite3_result_error(context, zErr, -1);
+    sqlite3_free(zErr);
+    return;
+  }
+
+  pRet = Tcl_NewObj();
+  Tcl_IncrRefCount(pRet);
+
+  if( SQLITE_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
+    zErr = "error in xCreate()";
+    goto finish;
+  }
+  pTokenizer->pModule = p;
+  if( SQLITE_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
+    zErr = "error in xOpen()";
+    goto finish;
+  }
+  pCsr->pTokenizer = pTokenizer;
+
+  while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
+    zToken = &zInput[iStart];
+    nToken = iEnd-iStart;
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
+  }
+
+  if( SQLITE_OK!=p->xClose(pCsr) ){
+    zErr = "error in xClose()";
+    goto finish;
+  }
+  if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
+    zErr = "error in xDestroy()";
+    goto finish;
+  }
+
+finish:
+  if( zErr ){
+    sqlite3_result_error(context, zErr, -1);
+  }else{
+    sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
+  }
+  Tcl_DecrRefCount(pRet);
+}
+
+static
+int registerTokenizer(
+  sqlite3 *db, 
+  char *zName, 
+  const sqlite3_tokenizer_module *p
+){
+  int rc;
+  sqlite3_stmt *pStmt;
+  const char zSql[] = "SELECT fts2_tokenizer(?, ?)";
+
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+  sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
+  sqlite3_step(pStmt);
+
+  return sqlite3_finalize(pStmt);
+}
+
+static
+int queryTokenizer(
+  sqlite3 *db, 
+  char *zName,  
+  const sqlite3_tokenizer_module **pp
+){
+  int rc;
+  sqlite3_stmt *pStmt;
+  const char zSql[] = "SELECT fts2_tokenizer(?)";
+
+  *pp = 0;
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+  if( SQLITE_ROW==sqlite3_step(pStmt) ){
+    if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+      memcpy(pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+    }
+  }
+
+  return sqlite3_finalize(pStmt);
+}
+
+void sqlite3Fts2SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+
+/*
+** Implementation of the scalar function fts2_tokenizer_internal_test().
+** This function is used for testing only, it is not included in the
+** build unless SQLITE_TEST is defined.
+**
+** The purpose of this is to test that the fts2_tokenizer() function
+** can be used as designed by the C-code in the queryTokenizer and
+** registerTokenizer() functions above. These two functions are repeated
+** in the README.tokenizer file as an example, so it is important to
+** test them.
+**
+** To run the tests, evaluate the fts2_tokenizer_internal_test() scalar
+** function with no arguments. An assert() will fail if a problem is
+** detected. i.e.:
+**
+**     SELECT fts2_tokenizer_internal_test();
+**
+*/
+static void intTestFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int rc;
+  const sqlite3_tokenizer_module *p1;
+  const sqlite3_tokenizer_module *p2;
+  sqlite3 *db = (sqlite3 *)sqlite3_user_data(context);
+
+  /* Test the query function */
+  sqlite3Fts2SimpleTokenizerModule(&p1);
+  rc = queryTokenizer(db, "simple", &p2);
+  assert( rc==SQLITE_OK );
+  assert( p1==p2 );
+  rc = queryTokenizer(db, "nosuchtokenizer", &p2);
+  assert( rc==SQLITE_ERROR );
+  assert( p2==0 );
+  assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
+
+  /* Test the storage function */
+  rc = registerTokenizer(db, "nosuchtokenizer", p1);
+  assert( rc==SQLITE_OK );
+  rc = queryTokenizer(db, "nosuchtokenizer", &p2);
+  assert( rc==SQLITE_OK );
+  assert( p2==p1 );
+
+  sqlite3_result_text(context, "ok", -1, SQLITE_STATIC);
+}
+
+#endif
+
+/*
+** Set up SQL objects in database db used to access the contents of
+** the hash table pointed to by argument pHash. The hash table must
+** been initialised to use string keys, and to take a private copy 
+** of the key when a value is inserted. i.e. by a call similar to:
+**
+**    sqlite3Fts2HashInit(pHash, FTS2_HASH_STRING, 1);
+**
+** This function adds a scalar function (see header comment above
+** scalarFunc() in this file for details) and, if ENABLE_TABLE is
+** defined at compilation time, a temporary virtual table (see header 
+** comment above struct HashTableVtab) to the database schema. Both 
+** provide read/write access to the contents of *pHash.
+**
+** The third argument to this function, zName, is used as the name
+** of both the scalar and, if created, the virtual table.
+*/
+int sqlite3Fts2InitHashTable(
+  sqlite3 *db, 
+  fts2Hash *pHash, 
+  const char *zName
+){
+  int rc = SQLITE_OK;
+  void *p = (void *)pHash;
+  const int any = SQLITE_ANY;
+  char *zTest = 0;
+  char *zTest2 = 0;
+
+#ifdef SQLITE_TEST
+  void *pdb = (void *)db;
+  zTest = sqlite3_mprintf("%s_test", zName);
+  zTest2 = sqlite3_mprintf("%s_internal_test", zName);
+  if( !zTest || !zTest2 ){
+    rc = SQLITE_NOMEM;
+  }
+#endif
+
+  if( rc!=SQLITE_OK
+   || (rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0))
+#ifdef SQLITE_TEST
+   || (rc = sqlite3_create_function(db, zTest, 2, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest, 3, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0))
+#endif
+  );
+
+  sqlite3_free(zTest);
+  sqlite3_free(zTest2);
+  return rc;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.h
new file mode 100644
index 0000000..8c256b2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer.h
@@ -0,0 +1,145 @@
+/*
+** 2006 July 10
+**
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Defines the interface to tokenizers used by fulltext-search.  There
+** are three basic components:
+**
+** sqlite3_tokenizer_module is a singleton defining the tokenizer
+** interface functions.  This is essentially the class structure for
+** tokenizers.
+**
+** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
+** including customization information defined at creation time.
+**
+** sqlite3_tokenizer_cursor is generated by a tokenizer to generate
+** tokens from a particular input.
+*/
+#ifndef _FTS2_TOKENIZER_H_
+#define _FTS2_TOKENIZER_H_
+
+/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
+** If tokenizers are to be allowed to call sqlite3_*() functions, then
+** we will need a way to register the API consistently.
+*/
+#include "sqlite3.h"
+
+/*
+** Structures used by the tokenizer interface. When a new tokenizer
+** implementation is registered, the caller provides a pointer to
+** an sqlite3_tokenizer_module containing pointers to the callback
+** functions that make up an implementation.
+**
+** When an fts2 table is created, it passes any arguments passed to
+** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the
+** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer
+** implementation. The xCreate() function in turn returns an 
+** sqlite3_tokenizer structure representing the specific tokenizer to
+** be used for the fts2 table (customized by the tokenizer clause arguments).
+**
+** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen()
+** method is called. It returns an sqlite3_tokenizer_cursor object
+** that may be used to tokenize a specific input buffer based on
+** the tokenization rules supplied by a specific sqlite3_tokenizer
+** object.
+*/
+typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module;
+typedef struct sqlite3_tokenizer sqlite3_tokenizer;
+typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
+
+struct sqlite3_tokenizer_module {
+
+  /*
+  ** Structure version. Should always be set to 0.
+  */
+  int iVersion;
+
+  /*
+  ** Create a new tokenizer. The values in the argv[] array are the
+  ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL
+  ** TABLE statement that created the fts2 table. For example, if
+  ** the following SQL is executed:
+  **
+  **   CREATE .. USING fts2( ... , tokenizer <tokenizer-name> arg1 arg2)
+  **
+  ** then argc is set to 2, and the argv[] array contains pointers
+  ** to the strings "arg1" and "arg2".
+  **
+  ** This method should return either SQLITE_OK (0), or an SQLite error 
+  ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
+  ** to point at the newly created tokenizer structure. The generic
+  ** sqlite3_tokenizer.pModule variable should not be initialised by
+  ** this callback. The caller will do so.
+  */
+  int (*xCreate)(
+    int argc,                           /* Size of argv array */
+    const char *const*argv,             /* Tokenizer argument strings */
+    sqlite3_tokenizer **ppTokenizer     /* OUT: Created tokenizer */
+  );
+
+  /*
+  ** Destroy an existing tokenizer. The fts2 module calls this method
+  ** exactly once for each successful call to xCreate().
+  */
+  int (*xDestroy)(sqlite3_tokenizer *pTokenizer);
+
+  /*
+  ** Create a tokenizer cursor to tokenize an input buffer. The caller
+  ** is responsible for ensuring that the input buffer remains valid
+  ** until the cursor is closed (using the xClose() method). 
+  */
+  int (*xOpen)(
+    sqlite3_tokenizer *pTokenizer,       /* Tokenizer object */
+    const char *pInput, int nBytes,      /* Input buffer */
+    sqlite3_tokenizer_cursor **ppCursor  /* OUT: Created tokenizer cursor */
+  );
+
+  /*
+  ** Destroy an existing tokenizer cursor. The fts2 module calls this 
+  ** method exactly once for each successful call to xOpen().
+  */
+  int (*xClose)(sqlite3_tokenizer_cursor *pCursor);
+
+  /*
+  ** Retrieve the next token from the tokenizer cursor pCursor. This
+  ** method should either return SQLITE_OK and set the values of the
+  ** "OUT" variables identified below, or SQLITE_DONE to indicate that
+  ** the end of the buffer has been reached, or an SQLite error code.
+  **
+  ** *ppToken should be set to point at a buffer containing the 
+  ** normalized version of the token (i.e. after any case-folding and/or
+  ** stemming has been performed). *pnBytes should be set to the length
+  ** of this buffer in bytes. The input text that generated the token is
+  ** identified by the byte offsets returned in *piStartOffset and
+  ** *piEndOffset.
+  **
+  ** The buffer *ppToken is set to point at is managed by the tokenizer
+  ** implementation. It is only required to be valid until the next call
+  ** to xNext() or xClose(). 
+  */
+  /* TODO(shess) current implementation requires pInput to be
+  ** nul-terminated.  This should either be fixed, or pInput/nBytes
+  ** should be converted to zInput.
+  */
+  int (*xNext)(
+    sqlite3_tokenizer_cursor *pCursor,   /* Tokenizer cursor */
+    const char **ppToken, int *pnBytes,  /* OUT: Normalized text for token */
+    int *piStartOffset,  /* OUT: Byte offset of token in input buffer */
+    int *piEndOffset,    /* OUT: Byte offset of end of token in input buffer */
+    int *piPosition      /* OUT: Number of tokens returned before this one */
+  );
+};
+
+struct sqlite3_tokenizer {
+  const sqlite3_tokenizer_module *pModule;  /* The module for this tokenizer */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+struct sqlite3_tokenizer_cursor {
+  sqlite3_tokenizer *pTokenizer;       /* Tokenizer for this cursor. */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+#endif /* _FTS2_TOKENIZER_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer1.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer1.c
new file mode 100644
index 0000000..540ba27
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/fts2_tokenizer1.c
@@ -0,0 +1,229 @@
+/*
+** 2006 Oct 10
+**
+** 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.
+**
+******************************************************************************
+**
+** Implementation of the "simple" full-text-search tokenizer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS2 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS2 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts2_tokenizer.h"
+
+typedef struct simple_tokenizer {
+  sqlite3_tokenizer base;
+  char delim[128];             /* flag ASCII delimiters */
+} simple_tokenizer;
+
+typedef struct simple_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *pInput;          /* input we are tokenizing */
+  int nBytes;                  /* size of the input */
+  int iOffset;                 /* current position in pInput */
+  int iToken;                  /* index of next token to be returned */
+  char *pToken;                /* storage for current token */
+  int nTokenAllocated;         /* space allocated to zToken buffer */
+} simple_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module simpleTokenizerModule;
+
+static int simpleDelim(simple_tokenizer *t, unsigned char c){
+  return c<0x80 && t->delim[c];
+}
+
+/*
+** Create a new tokenizer instance.
+*/
+static int simpleCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  simple_tokenizer *t;
+
+  t = (simple_tokenizer *) calloc(sizeof(*t), 1);
+  if( t==NULL ) return SQLITE_NOMEM;
+
+  /* TODO(shess) Delimiters need to remain the same from run to run,
+  ** else we need to reindex.  One solution would be a meta-table to
+  ** track such information in the database, then we'd only want this
+  ** information on the initial create.
+  */
+  if( argc>1 ){
+    int i, n = strlen(argv[1]);
+    for(i=0; i<n; i++){
+      unsigned char ch = argv[1][i];
+      /* We explicitly don't support UTF-8 delimiters for now. */
+      if( ch>=0x80 ){
+        free(t);
+        return SQLITE_ERROR;
+      }
+      t->delim[ch] = 1;
+    }
+  } else {
+    /* Mark non-alphanumeric ASCII characters as delimiters */
+    int i;
+    for(i=1; i<0x80; i++){
+      t->delim[i] = !isalnum(i);
+    }
+  }
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
+  free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is pInput[0..nBytes-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int simpleOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *pInput, int nBytes,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  simple_tokenizer_cursor *c;
+
+  c = (simple_tokenizer_cursor *) malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->pInput = pInput;
+  if( pInput==0 ){
+    c->nBytes = 0;
+  }else if( nBytes<0 ){
+    c->nBytes = (int)strlen(pInput);
+  }else{
+    c->nBytes = nBytes;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->pToken = NULL;               /* no space allocated, yet. */
+  c->nTokenAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** simpleOpen() above.
+*/
+static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  free(c->pToken);
+  free(c);
+  return SQLITE_OK;
+}
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to simpleOpen().
+*/
+static int simpleNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
+  const char **ppToken,               /* OUT: *ppToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
+  unsigned char *p = (unsigned char *)c->pInput;
+
+  while( c->iOffset<c->nBytes ){
+    int iStartOffset;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int i, n = c->iOffset-iStartOffset;
+      if( n>c->nTokenAllocated ){
+        c->nTokenAllocated = n+20;
+        c->pToken = realloc(c->pToken, c->nTokenAllocated);
+        if( c->pToken==NULL ) return SQLITE_NOMEM;
+      }
+      for(i=0; i<n; i++){
+        /* TODO(shess) This needs expansion to handle UTF-8
+        ** case-insensitivity.
+        */
+        unsigned char ch = p[iStartOffset+i];
+        c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
+      }
+      *ppToken = c->pToken;
+      *pnBytes = n;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the simple tokenizer
+*/
+static const sqlite3_tokenizer_module simpleTokenizerModule = {
+  0,
+  simpleCreate,
+  simpleDestroy,
+  simpleOpen,
+  simpleClose,
+  simpleNext,
+};
+
+/*
+** Allocate a new simple tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts2SimpleTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &simpleTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts2/mkfts2amal.tcl b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/mkfts2amal.tcl
new file mode 100644
index 0000000..5c8d1e9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts2/mkfts2amal.tcl
@@ -0,0 +1,116 @@
+#!/usr/bin/tclsh
+#
+# This script builds a single C code file holding all of FTS2 code.
+# The name of the output file is fts2amal.c.  To build this file,
+# first do:
+#
+#      make target_source
+#
+# The make target above moves all of the source code files into
+# a subdirectory named "tsrc".  (This script expects to find the files
+# there and will not work if they are not found.)
+#
+# After the "tsrc" directory has been created and populated, run
+# this script:
+#
+#      tclsh mkfts2amal.tcl
+#
+# The amalgamated FTS2 code will be written into fts2amal.c
+#
+
+# Open the output file and write a header comment at the beginning
+# of the file.
+#
+set out [open fts2amal.c w]
+set today [clock format [clock seconds] -format "%Y-%m-%d %H:%M:%S UTC" -gmt 1]
+puts $out [subst \
+{/******************************************************************************
+** This file is an amalgamation of separate C source files from the SQLite
+** Full Text Search extension 2 (fts2).  By combining all the individual C 
+** code  files into this single large file, the entire code can be compiled 
+** as a one translation unit.  This allows many compilers to do optimizations
+** that would not be possible if the files were compiled separately.  It also
+** makes the code easier to import into other projects.
+**
+** This amalgamation was generated on $today.
+*/}]
+
+# These are the header files used by FTS2.  The first time any of these 
+# files are seen in a #include statement in the C code, include the complete
+# text of the file in-line.  The file only needs to be included once.
+#
+foreach hdr {
+   fts2.h
+   fts2_hash.h
+   fts2_tokenizer.h
+   sqlite3.h
+   sqlite3ext.h
+} {
+  set available_hdr($hdr) 1
+}
+
+# 78 stars used for comment formatting.
+set s78 \
+{*****************************************************************************}
+
+# Insert a comment into the code
+#
+proc section_comment {text} {
+  global out s78
+  set n [string length $text]
+  set nstar [expr {60 - $n}]
+  set stars [string range $s78 0 $nstar]
+  puts $out "/************** $text $stars/"
+}
+
+# Read the source file named $filename and write it into the
+# sqlite3.c output file.  If any #include statements are seen,
+# process them approprately.
+#
+proc copy_file {filename} {
+  global seen_hdr available_hdr out
+  set tail [file tail $filename]
+  section_comment "Begin file $tail"
+  set in [open $filename r]
+  while {![eof $in]} {
+    set line [gets $in]
+    if {[regexp {^#\s*include\s+["<]([^">]+)[">]} $line all hdr]} {
+      if {[info exists available_hdr($hdr)]} {
+        if {$available_hdr($hdr)} {
+          section_comment "Include $hdr in the middle of $tail"
+          copy_file tsrc/$hdr
+          section_comment "Continuing where we left off in $tail"
+        }
+      } elseif {![info exists seen_hdr($hdr)]} {
+        set seen_hdr($hdr) 1
+        puts $out $line
+      }
+    } elseif {[regexp {^#ifdef __cplusplus} $line]} {
+      puts $out "#if 0"
+    } elseif {[regexp {^#line} $line]} {
+      # Skip #line directives.
+    } else {
+      puts $out $line
+    }
+  }
+  close $in
+  section_comment "End of $tail"
+}
+
+
+# Process the source files.  Process files containing commonly
+# used subroutines first in order to help the compiler find
+# inlining opportunities.
+#
+foreach file {
+   fts2.c
+   fts2_hash.c
+   fts2_porter.c
+   fts2_tokenizer.c
+   fts2_tokenizer1.c
+   fts2_icu.c
+} {
+  copy_file tsrc/$file
+}
+
+close $out
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Entries b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Entries
new file mode 100644
index 0000000..65354a8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Entries
@@ -0,0 +1,13 @@
+/README.txt/1.1/Mon Aug 20 17:37:03 2007//
+/fts3.h/1.1/Mon Aug 20 17:37:04 2007//
+/fts3_hash.c/1.4/Sat Nov 24 00:41:52 2007//
+/fts3_hash.h/1.2/Thu Sep 20 12:53:28 2007//
+/fts3_icu.c/1.2/Wed Oct 24 21:52:37 2007//
+/fts3_tokenizer.h/1.1/Mon Aug 20 17:37:04 2007//
+/fts3_tokenizer1.c/1.2/Fri Nov 23 17:31:18 2007//
+/README.tokenizers/1.2/Thu Dec 13 21:44:26 2007//
+/mkfts3amal.tcl/1.2/Thu Jan 31 12:32:59 2008//
+/fts3_porter.c/1.2/Fri Feb  1 15:40:34 2008//
+/fts3.c/1.15/Sat Feb  2 16:24:34 2008//
+/fts3_tokenizer.c/1.3/Sat Feb  2 16:24:34 2008//
+D
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Repository b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Repository
new file mode 100644
index 0000000..e8a6ccd
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Repository
@@ -0,0 +1 @@
+sqlite/ext/fts3
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Root b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Root
new file mode 100644
index 0000000..a3ae5d0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/CVS/Root
@@ -0,0 +1 @@
+:pserver:drh@sqlite.org:/sqlite
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.tokenizers b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.tokenizers
new file mode 100644
index 0000000..83d2f9d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.tokenizers
@@ -0,0 +1,133 @@
+
+1. FTS3 Tokenizers
+
+  When creating a new full-text table, FTS3 allows the user to select
+  the text tokenizer implementation to be used when indexing text
+  by specifying a "tokenizer" clause as part of the CREATE VIRTUAL TABLE
+  statement:
+
+    CREATE VIRTUAL TABLE <table-name> USING fts3(
+      <columns ...> [, tokenizer <tokenizer-name> [<tokenizer-args>]]
+    );
+
+  The built-in tokenizers (valid values to pass as <tokenizer name>) are
+  "simple" and "porter".
+
+  <tokenizer-args> should consist of zero or more white-space separated
+  arguments to pass to the selected tokenizer implementation. The 
+  interpretation of the arguments, if any, depends on the individual 
+  tokenizer.
+
+2. Custom Tokenizers
+
+  FTS3 allows users to provide custom tokenizer implementations. The 
+  interface used to create a new tokenizer is defined and described in 
+  the fts3_tokenizer.h source file.
+
+  Registering a new FTS3 tokenizer is similar to registering a new 
+  virtual table module with SQLite. The user passes a pointer to a
+  structure containing pointers to various callback functions that
+  make up the implementation of the new tokenizer type. For tokenizers,
+  the structure (defined in fts3_tokenizer.h) is called
+  "sqlite3_tokenizer_module".
+
+  FTS3 does not expose a C-function that users call to register new
+  tokenizer types with a database handle. Instead, the pointer must
+  be encoded as an SQL blob value and passed to FTS3 through the SQL
+  engine by evaluating a special scalar function, "fts3_tokenizer()".
+  The fts3_tokenizer() function may be called with one or two arguments,
+  as follows:
+
+    SELECT fts3_tokenizer(<tokenizer-name>);
+    SELECT fts3_tokenizer(<tokenizer-name>, <sqlite3_tokenizer_module ptr>);
+  
+  Where <tokenizer-name> is a string identifying the tokenizer and
+  <sqlite3_tokenizer_module ptr> is a pointer to an sqlite3_tokenizer_module
+  structure encoded as an SQL blob. If the second argument is present,
+  it is registered as tokenizer <tokenizer-name> and a copy of it
+  returned. If only one argument is passed, a pointer to the tokenizer
+  implementation currently registered as <tokenizer-name> is returned,
+  encoded as a blob. Or, if no such tokenizer exists, an SQL exception
+  (error) is raised.
+
+  SECURITY: If the fts3 extension is used in an environment where potentially
+    malicious users may execute arbitrary SQL (i.e. gears), they should be
+    prevented from invoking the fts3_tokenizer() function, possibly using the
+    authorisation callback.
+
+  See "Sample code" below for an example of calling the fts3_tokenizer()
+  function from C code.
+
+3. ICU Library Tokenizers
+
+  If this extension is compiled with the SQLITE_ENABLE_ICU pre-processor 
+  symbol defined, then there exists a built-in tokenizer named "icu" 
+  implemented using the ICU library. The first argument passed to the
+  xCreate() method (see fts3_tokenizer.h) of this tokenizer may be
+  an ICU locale identifier. For example "tr_TR" for Turkish as used
+  in Turkey, or "en_AU" for English as used in Australia. For example:
+
+    "CREATE VIRTUAL TABLE thai_text USING fts3(text, tokenizer icu th_TH)"
+
+  The ICU tokenizer implementation is very simple. It splits the input
+  text according to the ICU rules for finding word boundaries and discards
+  any tokens that consist entirely of white-space. This may be suitable
+  for some applications in some locales, but not all. If more complex
+  processing is required, for example to implement stemming or 
+  discard punctuation, this can be done by creating a tokenizer 
+  implementation that uses the ICU tokenizer as part of its implementation.
+
+  When using the ICU tokenizer this way, it is safe to overwrite the
+  contents of the strings returned by the xNext() method (see
+  fts3_tokenizer.h).
+
+4. Sample code.
+
+  The following two code samples illustrate the way C code should invoke
+  the fts3_tokenizer() scalar function:
+
+      int registerTokenizer(
+        sqlite3 *db, 
+        char *zName, 
+        const sqlite3_tokenizer_module *p
+      ){
+        int rc;
+        sqlite3_stmt *pStmt;
+        const char zSql[] = "SELECT fts3_tokenizer(?, ?)";
+      
+        rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+      
+        sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+        sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
+        sqlite3_step(pStmt);
+      
+        return sqlite3_finalize(pStmt);
+      }
+      
+      int queryTokenizer(
+        sqlite3 *db, 
+        char *zName,  
+        const sqlite3_tokenizer_module **pp
+      ){
+        int rc;
+        sqlite3_stmt *pStmt;
+        const char zSql[] = "SELECT fts3_tokenizer(?)";
+      
+        *pp = 0;
+        rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+      
+        sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+        if( SQLITE_ROW==sqlite3_step(pStmt) ){
+          if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+            memcpy(pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+          }
+        }
+      
+        return sqlite3_finalize(pStmt);
+      }
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.txt b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.txt
new file mode 100644
index 0000000..517a2a0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/README.txt
@@ -0,0 +1,4 @@
+This folder contains source code to the second full-text search
+extension for SQLite.  While the API is the same, this version uses a
+substantially different storage schema from fts1, so tables will need
+to be rebuilt.
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.c
new file mode 100644
index 0000000..2aaeb11
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.c
@@ -0,0 +1,6403 @@
+/*
+** 2006 Oct 10
+**
+** 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 is an SQLite module implementing full-text search.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS3 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS3 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
+*/
+
+/* TODO(shess) Consider exporting this comment to an HTML file or the
+** wiki.
+*/
+/* The full-text index is stored in a series of b+tree (-like)
+** structures called segments which map terms to doclists.  The
+** structures are like b+trees in layout, but are constructed from the
+** bottom up in optimal fashion and are not updatable.  Since trees
+** are built from the bottom up, things will be described from the
+** bottom up.
+**
+**
+**** Varints ****
+** The basic unit of encoding is a variable-length integer called a
+** varint.  We encode variable-length integers in little-endian order
+** using seven bits * per byte as follows:
+**
+** KEY:
+**         A = 0xxxxxxx    7 bits of data and one flag bit
+**         B = 1xxxxxxx    7 bits of data and one flag bit
+**
+**  7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** and so on.
+**
+** This is identical to how sqlite encodes varints (see util.c).
+**
+**
+**** Document lists ****
+** A doclist (document list) holds a docid-sorted list of hits for a
+** given term.  Doclists hold docids, and can optionally associate
+** token positions and offsets with docids.
+**
+** A DL_POSITIONS_OFFSETS doclist is stored like this:
+**
+** array {
+**   varint docid;
+**   array {                (position list for column 0)
+**     varint position;     (delta from previous position plus POS_BASE)
+**     varint startOffset;  (delta from previous startOffset)
+**     varint endOffset;    (delta from startOffset)
+**   }
+**   array {
+**     varint POS_COLUMN;   (marks start of position list for new column)
+**     varint column;       (index of new column)
+**     array {
+**       varint position;   (delta from previous position plus POS_BASE)
+**       varint startOffset;(delta from previous startOffset)
+**       varint endOffset;  (delta from startOffset)
+**     }
+**   }
+**   varint POS_END;        (marks end of positions for this document.
+** }
+**
+** Here, array { X } means zero or more occurrences of X, adjacent in
+** memory.  A "position" is an index of a token in the token stream
+** generated by the tokenizer, while an "offset" is a byte offset,
+** both based at 0.  Note that POS_END and POS_COLUMN occur in the
+** same logical place as the position element, and act as sentinals
+** ending a position list array.
+**
+** A DL_POSITIONS doclist omits the startOffset and endOffset
+** information.  A DL_DOCIDS doclist omits both the position and
+** offset information, becoming an array of varint-encoded docids.
+**
+** On-disk data is stored as type DL_DEFAULT, so we don't serialize
+** the type.  Due to how deletion is implemented in the segmentation
+** system, on-disk doclists MUST store at least positions.
+**
+**
+**** Segment leaf nodes ****
+** Segment leaf nodes store terms and doclists, ordered by term.  Leaf
+** nodes are written using LeafWriter, and read using LeafReader (to
+** iterate through a single leaf node's data) and LeavesReader (to
+** iterate through a segment's entire leaf layer).  Leaf nodes have
+** the format:
+**
+** varint iHeight;             (height from leaf level, always 0)
+** varint nTerm;               (length of first term)
+** char pTerm[nTerm];          (content of first term)
+** varint nDoclist;            (length of term's associated doclist)
+** char pDoclist[nDoclist];    (content of doclist)
+** array {
+**                             (further terms are delta-encoded)
+**   varint nPrefix;           (length of prefix shared with previous term)
+**   varint nSuffix;           (length of unshared suffix)
+**   char pTermSuffix[nSuffix];(unshared suffix of next term)
+**   varint nDoclist;          (length of term's associated doclist)
+**   char pDoclist[nDoclist];  (content of doclist)
+** }
+**
+** Here, array { X } means zero or more occurrences of X, adjacent in
+** memory.
+**
+** Leaf nodes are broken into blocks which are stored contiguously in
+** the %_segments table in sorted order.  This means that when the end
+** of a node is reached, the next term is in the node with the next
+** greater node id.
+**
+** New data is spilled to a new leaf node when the current node
+** exceeds LEAF_MAX bytes (default 2048).  New data which itself is
+** larger than STANDALONE_MIN (default 1024) is placed in a standalone
+** node (a leaf node with a single term and doclist).  The goal of
+** these settings is to pack together groups of small doclists while
+** making it efficient to directly access large doclists.  The
+** assumption is that large doclists represent terms which are more
+** likely to be query targets.
+**
+** TODO(shess) It may be useful for blocking decisions to be more
+** dynamic.  For instance, it may make more sense to have a 2.5k leaf
+** node rather than splitting into 2k and .5k nodes.  My intuition is
+** that this might extend through 2x or 4x the pagesize.
+**
+**
+**** Segment interior nodes ****
+** Segment interior nodes store blockids for subtree nodes and terms
+** to describe what data is stored by the each subtree.  Interior
+** nodes are written using InteriorWriter, and read using
+** InteriorReader.  InteriorWriters are created as needed when
+** SegmentWriter creates new leaf nodes, or when an interior node
+** itself grows too big and must be split.  The format of interior
+** nodes:
+**
+** varint iHeight;           (height from leaf level, always >0)
+** varint iBlockid;          (block id of node's leftmost subtree)
+** optional {
+**   varint nTerm;           (length of first term)
+**   char pTerm[nTerm];      (content of first term)
+**   array {
+**                                (further terms are delta-encoded)
+**     varint nPrefix;            (length of shared prefix with previous term)
+**     varint nSuffix;            (length of unshared suffix)
+**     char pTermSuffix[nSuffix]; (unshared suffix of next term)
+**   }
+** }
+**
+** Here, optional { X } means an optional element, while array { X }
+** means zero or more occurrences of X, adjacent in memory.
+**
+** An interior node encodes n terms separating n+1 subtrees.  The
+** subtree blocks are contiguous, so only the first subtree's blockid
+** is encoded.  The subtree at iBlockid will contain all terms less
+** than the first term encoded (or all terms if no term is encoded).
+** Otherwise, for terms greater than or equal to pTerm[i] but less
+** than pTerm[i+1], the subtree for that term will be rooted at
+** iBlockid+i.  Interior nodes only store enough term data to
+** distinguish adjacent children (if the rightmost term of the left
+** child is "something", and the leftmost term of the right child is
+** "wicked", only "w" is stored).
+**
+** New data is spilled to a new interior node at the same height when
+** the current node exceeds INTERIOR_MAX bytes (default 2048).
+** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing
+** interior nodes and making the tree too skinny.  The interior nodes
+** at a given height are naturally tracked by interior nodes at
+** height+1, and so on.
+**
+**
+**** Segment directory ****
+** The segment directory in table %_segdir stores meta-information for
+** merging and deleting segments, and also the root node of the
+** segment's tree.
+**
+** The root node is the top node of the segment's tree after encoding
+** the entire segment, restricted to ROOT_MAX bytes (default 1024).
+** This could be either a leaf node or an interior node.  If the top
+** node requires more than ROOT_MAX bytes, it is flushed to %_segments
+** and a new root interior node is generated (which should always fit
+** within ROOT_MAX because it only needs space for 2 varints, the
+** height and the blockid of the previous root).
+**
+** The meta-information in the segment directory is:
+**   level               - segment level (see below)
+**   idx                 - index within level
+**                       - (level,idx uniquely identify a segment)
+**   start_block         - first leaf node
+**   leaves_end_block    - last leaf node
+**   end_block           - last block (including interior nodes)
+**   root                - contents of root node
+**
+** If the root node is a leaf node, then start_block,
+** leaves_end_block, and end_block are all 0.
+**
+**
+**** Segment merging ****
+** To amortize update costs, segments are groups into levels and
+** merged in matches.  Each increase in level represents exponentially
+** more documents.
+**
+** New documents (actually, document updates) are tokenized and
+** written individually (using LeafWriter) to a level 0 segment, with
+** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
+** level 0 segments are merged into a single level 1 segment.  Level 1
+** is populated like level 0, and eventually MERGE_COUNT level 1
+** segments are merged to a single level 2 segment (representing
+** MERGE_COUNT^2 updates), and so on.
+**
+** A segment merge traverses all segments at a given level in
+** parallel, performing a straightforward sorted merge.  Since segment
+** leaf nodes are written in to the %_segments table in order, this
+** merge traverses the underlying sqlite disk structures efficiently.
+** After the merge, all segment blocks from the merged level are
+** deleted.
+**
+** MERGE_COUNT controls how often we merge segments.  16 seems to be
+** somewhat of a sweet spot for insertion performance.  32 and 64 show
+** very similar performance numbers to 16 on insertion, though they're
+** a tiny bit slower (perhaps due to more overhead in merge-time
+** sorting).  8 is about 20% slower than 16, 4 about 50% slower than
+** 16, 2 about 66% slower than 16.
+**
+** At query time, high MERGE_COUNT increases the number of segments
+** which need to be scanned and merged.  For instance, with 100k docs
+** inserted:
+**
+**    MERGE_COUNT   segments
+**       16           25
+**        8           12
+**        4           10
+**        2            6
+**
+** This appears to have only a moderate impact on queries for very
+** frequent terms (which are somewhat dominated by segment merge
+** costs), and infrequent and non-existent terms still seem to be fast
+** even with many segments.
+**
+** TODO(shess) That said, it would be nice to have a better query-side
+** argument for MERGE_COUNT of 16.  Also, it is possible/likely that
+** optimizations to things like doclist merging will swing the sweet
+** spot around.
+**
+**
+**
+**** Handling of deletions and updates ****
+** Since we're using a segmented structure, with no docid-oriented
+** index into the term index, we clearly cannot simply update the term
+** index when a document is deleted or updated.  For deletions, we
+** write an empty doclist (varint(docid) varint(POS_END)), for updates
+** we simply write the new doclist.  Segment merges overwrite older
+** data for a particular docid with newer data, so deletes or updates
+** will eventually overtake the earlier data and knock it out.  The
+** query logic likewise merges doclists so that newer data knocks out
+** older data.
+**
+** TODO(shess) Provide a VACUUM type operation to clear out all
+** deletions and duplications.  This would basically be a forced merge
+** into a single segment.
+*/
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+#if defined(SQLITE_ENABLE_FTS3) && !defined(SQLITE_CORE)
+# define SQLITE_CORE 1
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts3.h"
+#include "fts3_hash.h"
+#include "fts3_tokenizer.h"
+#ifndef SQLITE_CORE 
+# include "sqlite3ext.h"
+  SQLITE_EXTENSION_INIT1
+#endif
+
+
+/* TODO(shess) MAN, this thing needs some refactoring.  At minimum, it
+** would be nice to order the file better, perhaps something along the
+** lines of:
+**
+**  - utility functions
+**  - table setup functions
+**  - table update functions
+**  - table query functions
+**
+** Put the query functions last because they're likely to reference
+** typedefs or functions from the table update section.
+*/
+
+#if 0
+# define FTSTRACE(A)  printf A; fflush(stdout)
+#else
+# define FTSTRACE(A)
+#endif
+
+/*
+** Default span for NEAR operators.
+*/
+#define SQLITE_FTS3_DEFAULT_NEAR_PARAM 10
+
+/* It is not safe to call isspace(), tolower(), or isalnum() on
+** hi-bit-set characters.  This is the same solution used in the
+** tokenizer.
+*/
+/* TODO(shess) The snippet-generation code should be using the
+** tokenizer-generated tokens rather than doing its own local
+** tokenization.
+*/
+/* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
+static int safe_isspace(char c){
+  return (c&0x80)==0 ? isspace(c) : 0;
+}
+static int safe_tolower(char c){
+  return (c&0x80)==0 ? tolower(c) : c;
+}
+static int safe_isalnum(char c){
+  return (c&0x80)==0 ? isalnum(c) : 0;
+}
+
+typedef enum DocListType {
+  DL_DOCIDS,              /* docids only */
+  DL_POSITIONS,           /* docids + positions */
+  DL_POSITIONS_OFFSETS    /* docids + positions + offsets */
+} DocListType;
+
+/*
+** By default, only positions and not offsets are stored in the doclists.
+** To change this so that offsets are stored too, compile with
+**
+**          -DDL_DEFAULT=DL_POSITIONS_OFFSETS
+**
+** If DL_DEFAULT is set to DL_DOCIDS, your table can only be inserted
+** into (no deletes or updates).
+*/
+#ifndef DL_DEFAULT
+# define DL_DEFAULT DL_POSITIONS
+#endif
+
+enum {
+  POS_END = 0,        /* end of this position list */
+  POS_COLUMN,         /* followed by new column number */
+  POS_BASE
+};
+
+/* MERGE_COUNT controls how often we merge segments (see comment at
+** top of file).
+*/
+#define MERGE_COUNT 16
+
+/* utility functions */
+
+/* CLEAR() and SCRAMBLE() abstract memset() on a pointer to a single
+** record to prevent errors of the form:
+**
+** my_function(SomeType *b){
+**   memset(b, '\0', sizeof(b));  // sizeof(b)!=sizeof(*b)
+** }
+*/
+/* TODO(shess) Obvious candidates for a header file. */
+#define CLEAR(b) memset(b, '\0', sizeof(*(b)))
+
+#ifndef NDEBUG
+#  define SCRAMBLE(b) memset(b, 0x55, sizeof(*(b)))
+#else
+#  define SCRAMBLE(b)
+#endif
+
+/* We may need up to VARINT_MAX bytes to store an encoded 64-bit integer. */
+#define VARINT_MAX 10
+
+/* Write a 64-bit variable-length integer to memory starting at p[0].
+ * The length of data written will be between 1 and VARINT_MAX bytes.
+ * The number of bytes written is returned. */
+static int fts3PutVarint(char *p, sqlite_int64 v){
+  unsigned char *q = (unsigned char *) p;
+  sqlite_uint64 vu = v;
+  do{
+    *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
+    vu >>= 7;
+  }while( vu!=0 );
+  q[-1] &= 0x7f;  /* turn off high bit in final byte */
+  assert( q - (unsigned char *)p <= VARINT_MAX );
+  return (int) (q - (unsigned char *)p);
+}
+
+/* Read a 64-bit variable-length integer from memory starting at p[0].
+ * Return the number of bytes read, or 0 on error.
+ * The value is stored in *v. */
+static int fts3GetVarint(const char *p, sqlite_int64 *v){
+  const unsigned char *q = (const unsigned char *) p;
+  sqlite_uint64 x = 0, y = 1;
+  while( (*q & 0x80) == 0x80 ){
+    x += y * (*q++ & 0x7f);
+    y <<= 7;
+    if( q - (unsigned char *)p >= VARINT_MAX ){  /* bad data */
+      assert( 0 );
+      return 0;
+    }
+  }
+  x += y * (*q++);
+  *v = (sqlite_int64) x;
+  return (int) (q - (unsigned char *)p);
+}
+
+static int fts3GetVarint32(const char *p, int *pi){
+ sqlite_int64 i;
+ int ret = fts3GetVarint(p, &i);
+ *pi = (int) i;
+ assert( *pi==i );
+ return ret;
+}
+
+/*******************************************************************/
+/* DataBuffer is used to collect data into a buffer in piecemeal
+** fashion.  It implements the usual distinction between amount of
+** data currently stored (nData) and buffer capacity (nCapacity).
+**
+** dataBufferInit - create a buffer with given initial capacity.
+** dataBufferReset - forget buffer's data, retaining capacity.
+** dataBufferDestroy - free buffer's data.
+** dataBufferSwap - swap contents of two buffers.
+** dataBufferExpand - expand capacity without adding data.
+** dataBufferAppend - append data.
+** dataBufferAppend2 - append two pieces of data at once.
+** dataBufferReplace - replace buffer's data.
+*/
+typedef struct DataBuffer {
+  char *pData;          /* Pointer to malloc'ed buffer. */
+  int nCapacity;        /* Size of pData buffer. */
+  int nData;            /* End of data loaded into pData. */
+} DataBuffer;
+
+static void dataBufferInit(DataBuffer *pBuffer, int nCapacity){
+  assert( nCapacity>=0 );
+  pBuffer->nData = 0;
+  pBuffer->nCapacity = nCapacity;
+  pBuffer->pData = nCapacity==0 ? NULL : sqlite3_malloc(nCapacity);
+}
+static void dataBufferReset(DataBuffer *pBuffer){
+  pBuffer->nData = 0;
+}
+static void dataBufferDestroy(DataBuffer *pBuffer){
+  if( pBuffer->pData!=NULL ) sqlite3_free(pBuffer->pData);
+  SCRAMBLE(pBuffer);
+}
+static void dataBufferSwap(DataBuffer *pBuffer1, DataBuffer *pBuffer2){
+  DataBuffer tmp = *pBuffer1;
+  *pBuffer1 = *pBuffer2;
+  *pBuffer2 = tmp;
+}
+static void dataBufferExpand(DataBuffer *pBuffer, int nAddCapacity){
+  assert( nAddCapacity>0 );
+  /* TODO(shess) Consider expanding more aggressively.  Note that the
+  ** underlying malloc implementation may take care of such things for
+  ** us already.
+  */
+  if( pBuffer->nData+nAddCapacity>pBuffer->nCapacity ){
+    pBuffer->nCapacity = pBuffer->nData+nAddCapacity;
+    pBuffer->pData = sqlite3_realloc(pBuffer->pData, pBuffer->nCapacity);
+  }
+}
+static void dataBufferAppend(DataBuffer *pBuffer,
+                             const char *pSource, int nSource){
+  assert( nSource>0 && pSource!=NULL );
+  dataBufferExpand(pBuffer, nSource);
+  memcpy(pBuffer->pData+pBuffer->nData, pSource, nSource);
+  pBuffer->nData += nSource;
+}
+static void dataBufferAppend2(DataBuffer *pBuffer,
+                              const char *pSource1, int nSource1,
+                              const char *pSource2, int nSource2){
+  assert( nSource1>0 && pSource1!=NULL );
+  assert( nSource2>0 && pSource2!=NULL );
+  dataBufferExpand(pBuffer, nSource1+nSource2);
+  memcpy(pBuffer->pData+pBuffer->nData, pSource1, nSource1);
+  memcpy(pBuffer->pData+pBuffer->nData+nSource1, pSource2, nSource2);
+  pBuffer->nData += nSource1+nSource2;
+}
+static void dataBufferReplace(DataBuffer *pBuffer,
+                              const char *pSource, int nSource){
+  dataBufferReset(pBuffer);
+  dataBufferAppend(pBuffer, pSource, nSource);
+}
+
+/* StringBuffer is a null-terminated version of DataBuffer. */
+typedef struct StringBuffer {
+  DataBuffer b;            /* Includes null terminator. */
+} StringBuffer;
+
+static void initStringBuffer(StringBuffer *sb){
+  dataBufferInit(&sb->b, 100);
+  dataBufferReplace(&sb->b, "", 1);
+}
+static int stringBufferLength(StringBuffer *sb){
+  return sb->b.nData-1;
+}
+static char *stringBufferData(StringBuffer *sb){
+  return sb->b.pData;
+}
+static void stringBufferDestroy(StringBuffer *sb){
+  dataBufferDestroy(&sb->b);
+}
+
+static void nappend(StringBuffer *sb, const char *zFrom, int nFrom){
+  assert( sb->b.nData>0 );
+  if( nFrom>0 ){
+    sb->b.nData--;
+    dataBufferAppend2(&sb->b, zFrom, nFrom, "", 1);
+  }
+}
+static void append(StringBuffer *sb, const char *zFrom){
+  nappend(sb, zFrom, strlen(zFrom));
+}
+
+/* Append a list of strings separated by commas. */
+static void appendList(StringBuffer *sb, int nString, char **azString){
+  int i;
+  for(i=0; i<nString; ++i){
+    if( i>0 ) append(sb, ", ");
+    append(sb, azString[i]);
+  }
+}
+
+static int endsInWhiteSpace(StringBuffer *p){
+  return stringBufferLength(p)>0 &&
+    safe_isspace(stringBufferData(p)[stringBufferLength(p)-1]);
+}
+
+/* If the StringBuffer ends in something other than white space, add a
+** single space character to the end.
+*/
+static void appendWhiteSpace(StringBuffer *p){
+  if( stringBufferLength(p)==0 ) return;
+  if( !endsInWhiteSpace(p) ) append(p, " ");
+}
+
+/* Remove white space from the end of the StringBuffer */
+static void trimWhiteSpace(StringBuffer *p){
+  while( endsInWhiteSpace(p) ){
+    p->b.pData[--p->b.nData-1] = '\0';
+  }
+}
+
+/*******************************************************************/
+/* DLReader is used to read document elements from a doclist.  The
+** current docid is cached, so dlrDocid() is fast.  DLReader does not
+** own the doclist buffer.
+**
+** dlrAtEnd - true if there's no more data to read.
+** dlrDocid - docid of current document.
+** dlrDocData - doclist data for current document (including docid).
+** dlrDocDataBytes - length of same.
+** dlrAllDataBytes - length of all remaining data.
+** dlrPosData - position data for current document.
+** dlrPosDataLen - length of pos data for current document (incl POS_END).
+** dlrStep - step to current document.
+** dlrInit - initial for doclist of given type against given data.
+** dlrDestroy - clean up.
+**
+** Expected usage is something like:
+**
+**   DLReader reader;
+**   dlrInit(&reader, pData, nData);
+**   while( !dlrAtEnd(&reader) ){
+**     // calls to dlrDocid() and kin.
+**     dlrStep(&reader);
+**   }
+**   dlrDestroy(&reader);
+*/
+typedef struct DLReader {
+  DocListType iType;
+  const char *pData;
+  int nData;
+
+  sqlite_int64 iDocid;
+  int nElement;
+} DLReader;
+
+static int dlrAtEnd(DLReader *pReader){
+  assert( pReader->nData>=0 );
+  return pReader->nData==0;
+}
+static sqlite_int64 dlrDocid(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->iDocid;
+}
+static const char *dlrDocData(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->pData;
+}
+static int dlrDocDataBytes(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nElement;
+}
+static int dlrAllDataBytes(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nData;
+}
+/* TODO(shess) Consider adding a field to track iDocid varint length
+** to make these two functions faster.  This might matter (a tiny bit)
+** for queries.
+*/
+static const char *dlrPosData(DLReader *pReader){
+  sqlite_int64 iDummy;
+  int n = fts3GetVarint(pReader->pData, &iDummy);
+  assert( !dlrAtEnd(pReader) );
+  return pReader->pData+n;
+}
+static int dlrPosDataLen(DLReader *pReader){
+  sqlite_int64 iDummy;
+  int n = fts3GetVarint(pReader->pData, &iDummy);
+  assert( !dlrAtEnd(pReader) );
+  return pReader->nElement-n;
+}
+static void dlrStep(DLReader *pReader){
+  assert( !dlrAtEnd(pReader) );
+
+  /* Skip past current doclist element. */
+  assert( pReader->nElement<=pReader->nData );
+  pReader->pData += pReader->nElement;
+  pReader->nData -= pReader->nElement;
+
+  /* If there is more data, read the next doclist element. */
+  if( pReader->nData!=0 ){
+    sqlite_int64 iDocidDelta;
+    int iDummy, n = fts3GetVarint(pReader->pData, &iDocidDelta);
+    pReader->iDocid += iDocidDelta;
+    if( pReader->iType>=DL_POSITIONS ){
+      assert( n<pReader->nData );
+      while( 1 ){
+        n += fts3GetVarint32(pReader->pData+n, &iDummy);
+        assert( n<=pReader->nData );
+        if( iDummy==POS_END ) break;
+        if( iDummy==POS_COLUMN ){
+          n += fts3GetVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
+        }else if( pReader->iType==DL_POSITIONS_OFFSETS ){
+          n += fts3GetVarint32(pReader->pData+n, &iDummy);
+          n += fts3GetVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
+        }
+      }
+    }
+    pReader->nElement = n;
+    assert( pReader->nElement<=pReader->nData );
+  }
+}
+static void dlrInit(DLReader *pReader, DocListType iType,
+                    const char *pData, int nData){
+  assert( pData!=NULL && nData!=0 );
+  pReader->iType = iType;
+  pReader->pData = pData;
+  pReader->nData = nData;
+  pReader->nElement = 0;
+  pReader->iDocid = 0;
+
+  /* Load the first element's data.  There must be a first element. */
+  dlrStep(pReader);
+}
+static void dlrDestroy(DLReader *pReader){
+  SCRAMBLE(pReader);
+}
+
+#ifndef NDEBUG
+/* Verify that the doclist can be validly decoded.  Also returns the
+** last docid found because it is convenient in other assertions for
+** DLWriter.
+*/
+static void docListValidate(DocListType iType, const char *pData, int nData,
+                            sqlite_int64 *pLastDocid){
+  sqlite_int64 iPrevDocid = 0;
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+  while( nData!=0 ){
+    sqlite_int64 iDocidDelta;
+    int n = fts3GetVarint(pData, &iDocidDelta);
+    iPrevDocid += iDocidDelta;
+    if( iType>DL_DOCIDS ){
+      int iDummy;
+      while( 1 ){
+        n += fts3GetVarint32(pData+n, &iDummy);
+        if( iDummy==POS_END ) break;
+        if( iDummy==POS_COLUMN ){
+          n += fts3GetVarint32(pData+n, &iDummy);
+        }else if( iType>DL_POSITIONS ){
+          n += fts3GetVarint32(pData+n, &iDummy);
+          n += fts3GetVarint32(pData+n, &iDummy);
+        }
+        assert( n<=nData );
+      }
+    }
+    assert( n<=nData );
+    pData += n;
+    nData -= n;
+  }
+  if( pLastDocid ) *pLastDocid = iPrevDocid;
+}
+#define ASSERT_VALID_DOCLIST(i, p, n, o) docListValidate(i, p, n, o)
+#else
+#define ASSERT_VALID_DOCLIST(i, p, n, o) assert( 1 )
+#endif
+
+/*******************************************************************/
+/* DLWriter is used to write doclist data to a DataBuffer.  DLWriter
+** always appends to the buffer and does not own it.
+**
+** dlwInit - initialize to write a given type doclistto a buffer.
+** dlwDestroy - clear the writer's memory.  Does not free buffer.
+** dlwAppend - append raw doclist data to buffer.
+** dlwCopy - copy next doclist from reader to writer.
+** dlwAdd - construct doclist element and append to buffer.
+**    Only apply dlwAdd() to DL_DOCIDS doclists (else use PLWriter).
+*/
+typedef struct DLWriter {
+  DocListType iType;
+  DataBuffer *b;
+  sqlite_int64 iPrevDocid;
+#ifndef NDEBUG
+  int has_iPrevDocid;
+#endif
+} DLWriter;
+
+static void dlwInit(DLWriter *pWriter, DocListType iType, DataBuffer *b){
+  pWriter->b = b;
+  pWriter->iType = iType;
+  pWriter->iPrevDocid = 0;
+#ifndef NDEBUG
+  pWriter->has_iPrevDocid = 0;
+#endif
+}
+static void dlwDestroy(DLWriter *pWriter){
+  SCRAMBLE(pWriter);
+}
+/* iFirstDocid is the first docid in the doclist in pData.  It is
+** needed because pData may point within a larger doclist, in which
+** case the first item would be delta-encoded.
+**
+** iLastDocid is the final docid in the doclist in pData.  It is
+** needed to create the new iPrevDocid for future delta-encoding.  The
+** code could decode the passed doclist to recreate iLastDocid, but
+** the only current user (docListMerge) already has decoded this
+** information.
+*/
+/* TODO(shess) This has become just a helper for docListMerge.
+** Consider a refactor to make this cleaner.
+*/
+static void dlwAppend(DLWriter *pWriter,
+                      const char *pData, int nData,
+                      sqlite_int64 iFirstDocid, sqlite_int64 iLastDocid){
+  sqlite_int64 iDocid = 0;
+  char c[VARINT_MAX];
+  int nFirstOld, nFirstNew;     /* Old and new varint len of first docid. */
+#ifndef NDEBUG
+  sqlite_int64 iLastDocidDelta;
+#endif
+
+  /* Recode the initial docid as delta from iPrevDocid. */
+  nFirstOld = fts3GetVarint(pData, &iDocid);
+  assert( nFirstOld<nData || (nFirstOld==nData && pWriter->iType==DL_DOCIDS) );
+  nFirstNew = fts3PutVarint(c, iFirstDocid-pWriter->iPrevDocid);
+
+  /* Verify that the incoming doclist is valid AND that it ends with
+  ** the expected docid.  This is essential because we'll trust this
+  ** docid in future delta-encoding.
+  */
+  ASSERT_VALID_DOCLIST(pWriter->iType, pData, nData, &iLastDocidDelta);
+  assert( iLastDocid==iFirstDocid-iDocid+iLastDocidDelta );
+
+  /* Append recoded initial docid and everything else.  Rest of docids
+  ** should have been delta-encoded from previous initial docid.
+  */
+  if( nFirstOld<nData ){
+    dataBufferAppend2(pWriter->b, c, nFirstNew,
+                      pData+nFirstOld, nData-nFirstOld);
+  }else{
+    dataBufferAppend(pWriter->b, c, nFirstNew);
+  }
+  pWriter->iPrevDocid = iLastDocid;
+}
+static void dlwCopy(DLWriter *pWriter, DLReader *pReader){
+  dlwAppend(pWriter, dlrDocData(pReader), dlrDocDataBytes(pReader),
+            dlrDocid(pReader), dlrDocid(pReader));
+}
+static void dlwAdd(DLWriter *pWriter, sqlite_int64 iDocid){
+  char c[VARINT_MAX];
+  int n = fts3PutVarint(c, iDocid-pWriter->iPrevDocid);
+
+  /* Docids must ascend. */
+  assert( !pWriter->has_iPrevDocid || iDocid>pWriter->iPrevDocid );
+  assert( pWriter->iType==DL_DOCIDS );
+
+  dataBufferAppend(pWriter->b, c, n);
+  pWriter->iPrevDocid = iDocid;
+#ifndef NDEBUG
+  pWriter->has_iPrevDocid = 1;
+#endif
+}
+
+/*******************************************************************/
+/* PLReader is used to read data from a document's position list.  As
+** the caller steps through the list, data is cached so that varints
+** only need to be decoded once.
+**
+** plrInit, plrDestroy - create/destroy a reader.
+** plrColumn, plrPosition, plrStartOffset, plrEndOffset - accessors
+** plrAtEnd - at end of stream, only call plrDestroy once true.
+** plrStep - step to the next element.
+*/
+typedef struct PLReader {
+  /* These refer to the next position's data.  nData will reach 0 when
+  ** reading the last position, so plrStep() signals EOF by setting
+  ** pData to NULL.
+  */
+  const char *pData;
+  int nData;
+
+  DocListType iType;
+  int iColumn;         /* the last column read */
+  int iPosition;       /* the last position read */
+  int iStartOffset;    /* the last start offset read */
+  int iEndOffset;      /* the last end offset read */
+} PLReader;
+
+static int plrAtEnd(PLReader *pReader){
+  return pReader->pData==NULL;
+}
+static int plrColumn(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iColumn;
+}
+static int plrPosition(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iPosition;
+}
+static int plrStartOffset(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iStartOffset;
+}
+static int plrEndOffset(PLReader *pReader){
+  assert( !plrAtEnd(pReader) );
+  return pReader->iEndOffset;
+}
+static void plrStep(PLReader *pReader){
+  int i, n;
+
+  assert( !plrAtEnd(pReader) );
+
+  if( pReader->nData==0 ){
+    pReader->pData = NULL;
+    return;
+  }
+
+  n = fts3GetVarint32(pReader->pData, &i);
+  if( i==POS_COLUMN ){
+    n += fts3GetVarint32(pReader->pData+n, &pReader->iColumn);
+    pReader->iPosition = 0;
+    pReader->iStartOffset = 0;
+    n += fts3GetVarint32(pReader->pData+n, &i);
+  }
+  /* Should never see adjacent column changes. */
+  assert( i!=POS_COLUMN );
+
+  if( i==POS_END ){
+    pReader->nData = 0;
+    pReader->pData = NULL;
+    return;
+  }
+
+  pReader->iPosition += i-POS_BASE;
+  if( pReader->iType==DL_POSITIONS_OFFSETS ){
+    n += fts3GetVarint32(pReader->pData+n, &i);
+    pReader->iStartOffset += i;
+    n += fts3GetVarint32(pReader->pData+n, &i);
+    pReader->iEndOffset = pReader->iStartOffset+i;
+  }
+  assert( n<=pReader->nData );
+  pReader->pData += n;
+  pReader->nData -= n;
+}
+
+static void plrInit(PLReader *pReader, DLReader *pDLReader){
+  pReader->pData = dlrPosData(pDLReader);
+  pReader->nData = dlrPosDataLen(pDLReader);
+  pReader->iType = pDLReader->iType;
+  pReader->iColumn = 0;
+  pReader->iPosition = 0;
+  pReader->iStartOffset = 0;
+  pReader->iEndOffset = 0;
+  plrStep(pReader);
+}
+static void plrDestroy(PLReader *pReader){
+  SCRAMBLE(pReader);
+}
+
+/*******************************************************************/
+/* PLWriter is used in constructing a document's position list.  As a
+** convenience, if iType is DL_DOCIDS, PLWriter becomes a no-op.
+** PLWriter writes to the associated DLWriter's buffer.
+**
+** plwInit - init for writing a document's poslist.
+** plwDestroy - clear a writer.
+** plwAdd - append position and offset information.
+** plwCopy - copy next position's data from reader to writer.
+** plwTerminate - add any necessary doclist terminator.
+**
+** Calling plwAdd() after plwTerminate() may result in a corrupt
+** doclist.
+*/
+/* TODO(shess) Until we've written the second item, we can cache the
+** first item's information.  Then we'd have three states:
+**
+** - initialized with docid, no positions.
+** - docid and one position.
+** - docid and multiple positions.
+**
+** Only the last state needs to actually write to dlw->b, which would
+** be an improvement in the DLCollector case.
+*/
+typedef struct PLWriter {
+  DLWriter *dlw;
+
+  int iColumn;    /* the last column written */
+  int iPos;       /* the last position written */
+  int iOffset;    /* the last start offset written */
+} PLWriter;
+
+/* TODO(shess) In the case where the parent is reading these values
+** from a PLReader, we could optimize to a copy if that PLReader has
+** the same type as pWriter.
+*/
+static void plwAdd(PLWriter *pWriter, int iColumn, int iPos,
+                   int iStartOffset, int iEndOffset){
+  /* Worst-case space for POS_COLUMN, iColumn, iPosDelta,
+  ** iStartOffsetDelta, and iEndOffsetDelta.
+  */
+  char c[5*VARINT_MAX];
+  int n = 0;
+
+  /* Ban plwAdd() after plwTerminate(). */
+  assert( pWriter->iPos!=-1 );
+
+  if( pWriter->dlw->iType==DL_DOCIDS ) return;
+
+  if( iColumn!=pWriter->iColumn ){
+    n += fts3PutVarint(c+n, POS_COLUMN);
+    n += fts3PutVarint(c+n, iColumn);
+    pWriter->iColumn = iColumn;
+    pWriter->iPos = 0;
+    pWriter->iOffset = 0;
+  }
+  assert( iPos>=pWriter->iPos );
+  n += fts3PutVarint(c+n, POS_BASE+(iPos-pWriter->iPos));
+  pWriter->iPos = iPos;
+  if( pWriter->dlw->iType==DL_POSITIONS_OFFSETS ){
+    assert( iStartOffset>=pWriter->iOffset );
+    n += fts3PutVarint(c+n, iStartOffset-pWriter->iOffset);
+    pWriter->iOffset = iStartOffset;
+    assert( iEndOffset>=iStartOffset );
+    n += fts3PutVarint(c+n, iEndOffset-iStartOffset);
+  }
+  dataBufferAppend(pWriter->dlw->b, c, n);
+}
+static void plwCopy(PLWriter *pWriter, PLReader *pReader){
+  plwAdd(pWriter, plrColumn(pReader), plrPosition(pReader),
+         plrStartOffset(pReader), plrEndOffset(pReader));
+}
+static void plwInit(PLWriter *pWriter, DLWriter *dlw, sqlite_int64 iDocid){
+  char c[VARINT_MAX];
+  int n;
+
+  pWriter->dlw = dlw;
+
+  /* Docids must ascend. */
+  assert( !pWriter->dlw->has_iPrevDocid || iDocid>pWriter->dlw->iPrevDocid );
+  n = fts3PutVarint(c, iDocid-pWriter->dlw->iPrevDocid);
+  dataBufferAppend(pWriter->dlw->b, c, n);
+  pWriter->dlw->iPrevDocid = iDocid;
+#ifndef NDEBUG
+  pWriter->dlw->has_iPrevDocid = 1;
+#endif
+
+  pWriter->iColumn = 0;
+  pWriter->iPos = 0;
+  pWriter->iOffset = 0;
+}
+/* TODO(shess) Should plwDestroy() also terminate the doclist?  But
+** then plwDestroy() would no longer be just a destructor, it would
+** also be doing work, which isn't consistent with the overall idiom.
+** Another option would be for plwAdd() to always append any necessary
+** terminator, so that the output is always correct.  But that would
+** add incremental work to the common case with the only benefit being
+** API elegance.  Punt for now.
+*/
+static void plwTerminate(PLWriter *pWriter){
+  if( pWriter->dlw->iType>DL_DOCIDS ){
+    char c[VARINT_MAX];
+    int n = fts3PutVarint(c, POS_END);
+    dataBufferAppend(pWriter->dlw->b, c, n);
+  }
+#ifndef NDEBUG
+  /* Mark as terminated for assert in plwAdd(). */
+  pWriter->iPos = -1;
+#endif
+}
+static void plwDestroy(PLWriter *pWriter){
+  SCRAMBLE(pWriter);
+}
+
+/*******************************************************************/
+/* DLCollector wraps PLWriter and DLWriter to provide a
+** dynamically-allocated doclist area to use during tokenization.
+**
+** dlcNew - malloc up and initialize a collector.
+** dlcDelete - destroy a collector and all contained items.
+** dlcAddPos - append position and offset information.
+** dlcAddDoclist - add the collected doclist to the given buffer.
+** dlcNext - terminate the current document and open another.
+*/
+typedef struct DLCollector {
+  DataBuffer b;
+  DLWriter dlw;
+  PLWriter plw;
+} DLCollector;
+
+/* TODO(shess) This could also be done by calling plwTerminate() and
+** dataBufferAppend().  I tried that, expecting nominal performance
+** differences, but it seemed to pretty reliably be worth 1% to code
+** it this way.  I suspect it is the incremental malloc overhead (some
+** percentage of the plwTerminate() calls will cause a realloc), so
+** this might be worth revisiting if the DataBuffer implementation
+** changes.
+*/
+static void dlcAddDoclist(DLCollector *pCollector, DataBuffer *b){
+  if( pCollector->dlw.iType>DL_DOCIDS ){
+    char c[VARINT_MAX];
+    int n = fts3PutVarint(c, POS_END);
+    dataBufferAppend2(b, pCollector->b.pData, pCollector->b.nData, c, n);
+  }else{
+    dataBufferAppend(b, pCollector->b.pData, pCollector->b.nData);
+  }
+}
+static void dlcNext(DLCollector *pCollector, sqlite_int64 iDocid){
+  plwTerminate(&pCollector->plw);
+  plwDestroy(&pCollector->plw);
+  plwInit(&pCollector->plw, &pCollector->dlw, iDocid);
+}
+static void dlcAddPos(DLCollector *pCollector, int iColumn, int iPos,
+                      int iStartOffset, int iEndOffset){
+  plwAdd(&pCollector->plw, iColumn, iPos, iStartOffset, iEndOffset);
+}
+
+static DLCollector *dlcNew(sqlite_int64 iDocid, DocListType iType){
+  DLCollector *pCollector = sqlite3_malloc(sizeof(DLCollector));
+  dataBufferInit(&pCollector->b, 0);
+  dlwInit(&pCollector->dlw, iType, &pCollector->b);
+  plwInit(&pCollector->plw, &pCollector->dlw, iDocid);
+  return pCollector;
+}
+static void dlcDelete(DLCollector *pCollector){
+  plwDestroy(&pCollector->plw);
+  dlwDestroy(&pCollector->dlw);
+  dataBufferDestroy(&pCollector->b);
+  SCRAMBLE(pCollector);
+  sqlite3_free(pCollector);
+}
+
+
+/* Copy the doclist data of iType in pData/nData into *out, trimming
+** unnecessary data as we go.  Only columns matching iColumn are
+** copied, all columns copied if iColumn is -1.  Elements with no
+** matching columns are dropped.  The output is an iOutType doclist.
+*/
+/* NOTE(shess) This code is only valid after all doclists are merged.
+** If this is run before merges, then doclist items which represent
+** deletion will be trimmed, and will thus not effect a deletion
+** during the merge.
+*/
+static void docListTrim(DocListType iType, const char *pData, int nData,
+                        int iColumn, DocListType iOutType, DataBuffer *out){
+  DLReader dlReader;
+  DLWriter dlWriter;
+
+  assert( iOutType<=iType );
+
+  dlrInit(&dlReader, iType, pData, nData);
+  dlwInit(&dlWriter, iOutType, out);
+
+  while( !dlrAtEnd(&dlReader) ){
+    PLReader plReader;
+    PLWriter plWriter;
+    int match = 0;
+
+    plrInit(&plReader, &dlReader);
+
+    while( !plrAtEnd(&plReader) ){
+      if( iColumn==-1 || plrColumn(&plReader)==iColumn ){
+        if( !match ){
+          plwInit(&plWriter, &dlWriter, dlrDocid(&dlReader));
+          match = 1;
+        }
+        plwAdd(&plWriter, plrColumn(&plReader), plrPosition(&plReader),
+               plrStartOffset(&plReader), plrEndOffset(&plReader));
+      }
+      plrStep(&plReader);
+    }
+    if( match ){
+      plwTerminate(&plWriter);
+      plwDestroy(&plWriter);
+    }
+
+    plrDestroy(&plReader);
+    dlrStep(&dlReader);
+  }
+  dlwDestroy(&dlWriter);
+  dlrDestroy(&dlReader);
+}
+
+/* Used by docListMerge() to keep doclists in the ascending order by
+** docid, then ascending order by age (so the newest comes first).
+*/
+typedef struct OrderedDLReader {
+  DLReader *pReader;
+
+  /* TODO(shess) If we assume that docListMerge pReaders is ordered by
+  ** age (which we do), then we could use pReader comparisons to break
+  ** ties.
+  */
+  int idx;
+} OrderedDLReader;
+
+/* Order eof to end, then by docid asc, idx desc. */
+static int orderedDLReaderCmp(OrderedDLReader *r1, OrderedDLReader *r2){
+  if( dlrAtEnd(r1->pReader) ){
+    if( dlrAtEnd(r2->pReader) ) return 0;  /* Both atEnd(). */
+    return 1;                              /* Only r1 atEnd(). */
+  }
+  if( dlrAtEnd(r2->pReader) ) return -1;   /* Only r2 atEnd(). */
+
+  if( dlrDocid(r1->pReader)<dlrDocid(r2->pReader) ) return -1;
+  if( dlrDocid(r1->pReader)>dlrDocid(r2->pReader) ) return 1;
+
+  /* Descending on idx. */
+  return r2->idx-r1->idx;
+}
+
+/* Bubble p[0] to appropriate place in p[1..n-1].  Assumes that
+** p[1..n-1] is already sorted.
+*/
+/* TODO(shess) Is this frequent enough to warrant a binary search?
+** Before implementing that, instrument the code to check.  In most
+** current usage, I expect that p[0] will be less than p[1] a very
+** high proportion of the time.
+*/
+static void orderedDLReaderReorder(OrderedDLReader *p, int n){
+  while( n>1 && orderedDLReaderCmp(p, p+1)>0 ){
+    OrderedDLReader tmp = p[0];
+    p[0] = p[1];
+    p[1] = tmp;
+    n--;
+    p++;
+  }
+}
+
+/* Given an array of doclist readers, merge their doclist elements
+** into out in sorted order (by docid), dropping elements from older
+** readers when there is a duplicate docid.  pReaders is assumed to be
+** ordered by age, oldest first.
+*/
+/* TODO(shess) nReaders must be <= MERGE_COUNT.  This should probably
+** be fixed.
+*/
+static void docListMerge(DataBuffer *out,
+                         DLReader *pReaders, int nReaders){
+  OrderedDLReader readers[MERGE_COUNT];
+  DLWriter writer;
+  int i, n;
+  const char *pStart = 0;
+  int nStart = 0;
+  sqlite_int64 iFirstDocid = 0, iLastDocid = 0;
+
+  assert( nReaders>0 );
+  if( nReaders==1 ){
+    dataBufferAppend(out, dlrDocData(pReaders), dlrAllDataBytes(pReaders));
+    return;
+  }
+
+  assert( nReaders<=MERGE_COUNT );
+  n = 0;
+  for(i=0; i<nReaders; i++){
+    assert( pReaders[i].iType==pReaders[0].iType );
+    readers[i].pReader = pReaders+i;
+    readers[i].idx = i;
+    n += dlrAllDataBytes(&pReaders[i]);
+  }
+  /* Conservatively size output to sum of inputs.  Output should end
+  ** up strictly smaller than input.
+  */
+  dataBufferExpand(out, n);
+
+  /* Get the readers into sorted order. */
+  while( i-->0 ){
+    orderedDLReaderReorder(readers+i, nReaders-i);
+  }
+
+  dlwInit(&writer, pReaders[0].iType, out);
+  while( !dlrAtEnd(readers[0].pReader) ){
+    sqlite_int64 iDocid = dlrDocid(readers[0].pReader);
+
+    /* If this is a continuation of the current buffer to copy, extend
+    ** that buffer.  memcpy() seems to be more efficient if it has a
+    ** lots of data to copy.
+    */
+    if( dlrDocData(readers[0].pReader)==pStart+nStart ){
+      nStart += dlrDocDataBytes(readers[0].pReader);
+    }else{
+      if( pStart!=0 ){
+        dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
+      }
+      pStart = dlrDocData(readers[0].pReader);
+      nStart = dlrDocDataBytes(readers[0].pReader);
+      iFirstDocid = iDocid;
+    }
+    iLastDocid = iDocid;
+    dlrStep(readers[0].pReader);
+
+    /* Drop all of the older elements with the same docid. */
+    for(i=1; i<nReaders &&
+             !dlrAtEnd(readers[i].pReader) &&
+             dlrDocid(readers[i].pReader)==iDocid; i++){
+      dlrStep(readers[i].pReader);
+    }
+
+    /* Get the readers back into order. */
+    while( i-->0 ){
+      orderedDLReaderReorder(readers+i, nReaders-i);
+    }
+  }
+
+  /* Copy over any remaining elements. */
+  if( nStart>0 ) dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
+  dlwDestroy(&writer);
+}
+
+/* Helper function for posListUnion().  Compares the current position
+** between left and right, returning as standard C idiom of <0 if
+** left<right, >0 if left>right, and 0 if left==right.  "End" always
+** compares greater.
+*/
+static int posListCmp(PLReader *pLeft, PLReader *pRight){
+  assert( pLeft->iType==pRight->iType );
+  if( pLeft->iType==DL_DOCIDS ) return 0;
+
+  if( plrAtEnd(pLeft) ) return plrAtEnd(pRight) ? 0 : 1;
+  if( plrAtEnd(pRight) ) return -1;
+
+  if( plrColumn(pLeft)<plrColumn(pRight) ) return -1;
+  if( plrColumn(pLeft)>plrColumn(pRight) ) return 1;
+
+  if( plrPosition(pLeft)<plrPosition(pRight) ) return -1;
+  if( plrPosition(pLeft)>plrPosition(pRight) ) return 1;
+  if( pLeft->iType==DL_POSITIONS ) return 0;
+
+  if( plrStartOffset(pLeft)<plrStartOffset(pRight) ) return -1;
+  if( plrStartOffset(pLeft)>plrStartOffset(pRight) ) return 1;
+
+  if( plrEndOffset(pLeft)<plrEndOffset(pRight) ) return -1;
+  if( plrEndOffset(pLeft)>plrEndOffset(pRight) ) return 1;
+
+  return 0;
+}
+
+/* Write the union of position lists in pLeft and pRight to pOut.
+** "Union" in this case meaning "All unique position tuples".  Should
+** work with any doclist type, though both inputs and the output
+** should be the same type.
+*/
+static void posListUnion(DLReader *pLeft, DLReader *pRight, DLWriter *pOut){
+  PLReader left, right;
+  PLWriter writer;
+
+  assert( dlrDocid(pLeft)==dlrDocid(pRight) );
+  assert( pLeft->iType==pRight->iType );
+  assert( pLeft->iType==pOut->iType );
+
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
+  plwInit(&writer, pOut, dlrDocid(pLeft));
+
+  while( !plrAtEnd(&left) || !plrAtEnd(&right) ){
+    int c = posListCmp(&left, &right);
+    if( c<0 ){
+      plwCopy(&writer, &left);
+      plrStep(&left);
+    }else if( c>0 ){
+      plwCopy(&writer, &right);
+      plrStep(&right);
+    }else{
+      plwCopy(&writer, &left);
+      plrStep(&left);
+      plrStep(&right);
+    }
+  }
+
+  plwTerminate(&writer);
+  plwDestroy(&writer);
+  plrDestroy(&left);
+  plrDestroy(&right);
+}
+
+/* Write the union of doclists in pLeft and pRight to pOut.  For
+** docids in common between the inputs, the union of the position
+** lists is written.  Inputs and outputs are always type DL_DEFAULT.
+*/
+static void docListUnion(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ){
+    if( nRight!=0) dataBufferAppend(pOut, pRight, nRight);
+    return;
+  }
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DEFAULT, pLeft, nLeft);
+  dlrInit(&right, DL_DEFAULT, pRight, nRight);
+  dlwInit(&writer, DL_DEFAULT, pOut);
+
+  while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
+    if( dlrAtEnd(&right) ){
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
+    }else if( dlrAtEnd(&left) ){
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
+    }else if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
+    }else if( dlrDocid(&left)>dlrDocid(&right) ){
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
+    }else{
+      posListUnion(&left, &right, &writer);
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* 
+** This function is used as part of the implementation of phrase and
+** NEAR matching.
+**
+** pLeft and pRight are DLReaders positioned to the same docid in
+** lists of type DL_POSITION. This function writes an entry to the
+** DLWriter pOut for each position in pRight that is less than
+** (nNear+1) greater (but not equal to or smaller) than a position 
+** in pLeft. For example, if nNear is 0, and the positions contained
+** by pLeft and pRight are:
+**
+**    pLeft:  5 10 15 20
+**    pRight: 6  9 17 21
+**
+** then the docid is added to pOut. If pOut is of type DL_POSITIONS,
+** then a positionids "6" and "21" are also added to pOut.
+**
+** If boolean argument isSaveLeft is true, then positionids are copied
+** from pLeft instead of pRight. In the example above, the positions "5"
+** and "20" would be added instead of "6" and "21".
+*/
+static void posListPhraseMerge(
+  DLReader *pLeft, 
+  DLReader *pRight,
+  int nNear,
+  int isSaveLeft,
+  DLWriter *pOut
+){
+  PLReader left, right;
+  PLWriter writer;
+  int match = 0;
+
+  assert( dlrDocid(pLeft)==dlrDocid(pRight) );
+  assert( pOut->iType!=DL_POSITIONS_OFFSETS );
+
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
+
+  while( !plrAtEnd(&left) && !plrAtEnd(&right) ){
+    if( plrColumn(&left)<plrColumn(&right) ){
+      plrStep(&left);
+    }else if( plrColumn(&left)>plrColumn(&right) ){
+      plrStep(&right);
+    }else if( plrPosition(&left)>=plrPosition(&right) ){
+      plrStep(&right);
+    }else{
+      if( (plrPosition(&right)-plrPosition(&left))<=(nNear+1) ){
+        if( !match ){
+          plwInit(&writer, pOut, dlrDocid(pLeft));
+          match = 1;
+        }
+        if( !isSaveLeft ){
+          plwAdd(&writer, plrColumn(&right), plrPosition(&right), 0, 0);
+        }else{
+          plwAdd(&writer, plrColumn(&left), plrPosition(&left), 0, 0);
+        }
+        plrStep(&right);
+      }else{
+        plrStep(&left);
+      }
+    }
+  }
+
+  if( match ){
+    plwTerminate(&writer);
+    plwDestroy(&writer);
+  }
+
+  plrDestroy(&left);
+  plrDestroy(&right);
+}
+
+/*
+** Compare the values pointed to by the PLReaders passed as arguments. 
+** Return -1 if the value pointed to by pLeft is considered less than
+** the value pointed to by pRight, +1 if it is considered greater
+** than it, or 0 if it is equal. i.e.
+**
+**     (*pLeft - *pRight)
+**
+** A PLReader that is in the EOF condition is considered greater than
+** any other. If neither argument is in EOF state, the return value of
+** plrColumn() is used. If the plrColumn() values are equal, the
+** comparison is on the basis of plrPosition().
+*/
+static int plrCompare(PLReader *pLeft, PLReader *pRight){
+  assert(!plrAtEnd(pLeft) || !plrAtEnd(pRight));
+
+  if( plrAtEnd(pRight) || plrAtEnd(pLeft) ){
+    return (plrAtEnd(pRight) ? -1 : 1);
+  }
+  if( plrColumn(pLeft)!=plrColumn(pRight) ){
+    return ((plrColumn(pLeft)<plrColumn(pRight)) ? -1 : 1);
+  }
+  if( plrPosition(pLeft)!=plrPosition(pRight) ){
+    return ((plrPosition(pLeft)<plrPosition(pRight)) ? -1 : 1);
+  }
+  return 0;
+}
+
+/* We have two doclists with positions:  pLeft and pRight. Depending
+** on the value of the nNear parameter, perform either a phrase
+** intersection (if nNear==0) or a NEAR intersection (if nNear>0)
+** and write the results into pOut.
+**
+** A phrase intersection means that two documents only match
+** if pLeft.iPos+1==pRight.iPos.
+**
+** A NEAR intersection means that two documents only match if 
+** (abs(pLeft.iPos-pRight.iPos)<nNear).
+**
+** If a NEAR intersection is requested, then the nPhrase argument should
+** be passed the number of tokens in the two operands to the NEAR operator
+** combined. For example:
+**
+**       Query syntax               nPhrase
+**      ------------------------------------
+**       "A B C" NEAR "D E"         5
+**       A NEAR B                   2
+**
+** iType controls the type of data written to pOut.  If iType is
+** DL_POSITIONS, the positions are those from pRight.
+*/
+static void docListPhraseMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  int nNear,            /* 0 for a phrase merge, non-zero for a NEAR merge */
+  int nPhrase,          /* Number of tokens in left+right operands to NEAR */
+  DocListType iType,    /* Type of doclist to write to pOut */
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 || nRight==0 ) return;
+
+  assert( iType!=DL_POSITIONS_OFFSETS );
+
+  dlrInit(&left, DL_POSITIONS, pLeft, nLeft);
+  dlrInit(&right, DL_POSITIONS, pRight, nRight);
+  dlwInit(&writer, iType, pOut);
+
+  while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
+    if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }else{
+      if( nNear==0 ){
+        posListPhraseMerge(&left, &right, 0, 0, &writer);
+      }else{
+        /* This case occurs when two terms (simple terms or phrases) are
+         * connected by a NEAR operator, span (nNear+1). i.e.
+         *
+         *     '"terrible company" NEAR widget'
+         */
+        DataBuffer one = {0, 0, 0};
+        DataBuffer two = {0, 0, 0};
+
+        DLWriter dlwriter2;
+        DLReader dr1 = {0, 0, 0, 0, 0}; 
+        DLReader dr2 = {0, 0, 0, 0, 0};
+
+        dlwInit(&dlwriter2, iType, &one);
+        posListPhraseMerge(&right, &left, nNear-3+nPhrase, 1, &dlwriter2);
+        dlwInit(&dlwriter2, iType, &two);
+        posListPhraseMerge(&left, &right, nNear-1, 0, &dlwriter2);
+
+        if( one.nData) dlrInit(&dr1, iType, one.pData, one.nData);
+        if( two.nData) dlrInit(&dr2, iType, two.pData, two.nData);
+
+        if( !dlrAtEnd(&dr1) || !dlrAtEnd(&dr2) ){
+          PLReader pr1 = {0};
+          PLReader pr2 = {0};
+
+          PLWriter plwriter;
+          plwInit(&plwriter, &writer, dlrDocid(dlrAtEnd(&dr1)?&dr2:&dr1));
+
+          if( one.nData ) plrInit(&pr1, &dr1);
+          if( two.nData ) plrInit(&pr2, &dr2);
+          while( !plrAtEnd(&pr1) || !plrAtEnd(&pr2) ){
+            int iCompare = plrCompare(&pr1, &pr2);
+            switch( iCompare ){
+              case -1:
+                plwCopy(&plwriter, &pr1);
+                plrStep(&pr1);
+                break;
+              case 1:
+                plwCopy(&plwriter, &pr2);
+                plrStep(&pr2);
+                break;
+              case 0:
+                plwCopy(&plwriter, &pr1);
+                plrStep(&pr1);
+                plrStep(&pr2);
+                break;
+            }
+          }
+          plwTerminate(&plwriter);
+        }
+        dataBufferDestroy(&one);
+        dataBufferDestroy(&two);
+      }
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write the intersection of these two doclists into pOut as a
+** DL_DOCIDS doclist.
+*/
+static void docListAndMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 || nRight==0 ) return;
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
+    if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }else{
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write the union of these two doclists into pOut as a
+** DL_DOCIDS doclist.
+*/
+static void docListOrMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ){
+    if( nRight!=0 ) dataBufferAppend(pOut, pRight, nRight);
+    return;
+  }
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
+    if( dlrAtEnd(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+    }else if( dlrAtEnd(&left) ){
+      dlwAdd(&writer, dlrDocid(&right));
+      dlrStep(&right);
+    }else if( dlrDocid(&left)<dlrDocid(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+    }else if( dlrDocid(&right)<dlrDocid(&left) ){
+      dlwAdd(&writer, dlrDocid(&right));
+      dlrStep(&right);
+    }else{
+      dlwAdd(&writer, dlrDocid(&left));
+      dlrStep(&left);
+      dlrStep(&right);
+    }
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+/* We have two DL_DOCIDS doclists:  pLeft and pRight.
+** Write into pOut as DL_DOCIDS doclist containing all documents that
+** occur in pLeft but not in pRight.
+*/
+static void docListExceptMerge(
+  const char *pLeft, int nLeft,
+  const char *pRight, int nRight,
+  DataBuffer *pOut      /* Write the combined doclist here */
+){
+  DLReader left, right;
+  DLWriter writer;
+
+  if( nLeft==0 ) return;
+  if( nRight==0 ){
+    dataBufferAppend(pOut, pLeft, nLeft);
+    return;
+  }
+
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
+  dlwInit(&writer, DL_DOCIDS, pOut);
+
+  while( !dlrAtEnd(&left) ){
+    while( !dlrAtEnd(&right) && dlrDocid(&right)<dlrDocid(&left) ){
+      dlrStep(&right);
+    }
+    if( dlrAtEnd(&right) || dlrDocid(&left)<dlrDocid(&right) ){
+      dlwAdd(&writer, dlrDocid(&left));
+    }
+    dlrStep(&left);
+  }
+
+  dlrDestroy(&left);
+  dlrDestroy(&right);
+  dlwDestroy(&writer);
+}
+
+static char *string_dup_n(const char *s, int n){
+  char *str = sqlite3_malloc(n + 1);
+  memcpy(str, s, n);
+  str[n] = '\0';
+  return str;
+}
+
+/* Duplicate a string; the caller must free() the returned string.
+ * (We don't use strdup() since it is not part of the standard C library and
+ * may not be available everywhere.) */
+static char *string_dup(const char *s){
+  return string_dup_n(s, strlen(s));
+}
+
+/* Format a string, replacing each occurrence of the % character with
+ * zDb.zName.  This may be more convenient than sqlite_mprintf()
+ * when one string is used repeatedly in a format string.
+ * The caller must free() the returned string. */
+static char *string_format(const char *zFormat,
+                           const char *zDb, const char *zName){
+  const char *p;
+  size_t len = 0;
+  size_t nDb = strlen(zDb);
+  size_t nName = strlen(zName);
+  size_t nFullTableName = nDb+1+nName;
+  char *result;
+  char *r;
+
+  /* first compute length needed */
+  for(p = zFormat ; *p ; ++p){
+    len += (*p=='%' ? nFullTableName : 1);
+  }
+  len += 1;  /* for null terminator */
+
+  r = result = sqlite3_malloc(len);
+  for(p = zFormat; *p; ++p){
+    if( *p=='%' ){
+      memcpy(r, zDb, nDb);
+      r += nDb;
+      *r++ = '.';
+      memcpy(r, zName, nName);
+      r += nName;
+    } else {
+      *r++ = *p;
+    }
+  }
+  *r++ = '\0';
+  assert( r == result + len );
+  return result;
+}
+
+static int sql_exec(sqlite3 *db, const char *zDb, const char *zName,
+                    const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  FTSTRACE(("FTS3 sql: %s\n", zCommand));
+  rc = sqlite3_exec(db, zCommand, NULL, 0, NULL);
+  sqlite3_free(zCommand);
+  return rc;
+}
+
+static int sql_prepare(sqlite3 *db, const char *zDb, const char *zName,
+                       sqlite3_stmt **ppStmt, const char *zFormat){
+  char *zCommand = string_format(zFormat, zDb, zName);
+  int rc;
+  FTSTRACE(("FTS3 prepare: %s\n", zCommand));
+  rc = sqlite3_prepare_v2(db, zCommand, -1, ppStmt, NULL);
+  sqlite3_free(zCommand);
+  return rc;
+}
+
+/* end utility functions */
+
+/* Forward reference */
+typedef struct fulltext_vtab fulltext_vtab;
+
+/* A single term in a query is represented by an instances of
+** the following structure. Each word which may match against
+** document content is a term. Operators, like NEAR or OR, are
+** not terms. Query terms are organized as a flat list stored
+** in the Query.pTerms array.
+**
+** If the QueryTerm.nPhrase variable is non-zero, then the QueryTerm
+** is the first in a contiguous string of terms that are either part
+** of the same phrase, or connected by the NEAR operator.
+**
+** If the QueryTerm.nNear variable is non-zero, then the token is followed 
+** by a NEAR operator with span set to (nNear-1). For example, the 
+** following query:
+**
+** The QueryTerm.iPhrase variable stores the index of the token within
+** its phrase, indexed starting at 1, or 1 if the token is not part 
+** of any phrase.
+**
+** For example, the data structure used to represent the following query:
+**
+**     ... MATCH 'sqlite NEAR/5 google NEAR/2 "search engine"'
+**
+** is:
+**
+**     {nPhrase=4, iPhrase=1, nNear=6, pTerm="sqlite"},
+**     {nPhrase=0, iPhrase=1, nNear=3, pTerm="google"},
+**     {nPhrase=0, iPhrase=1, nNear=0, pTerm="search"},
+**     {nPhrase=0, iPhrase=2, nNear=0, pTerm="engine"},
+**
+** compiling the FTS3 syntax to Query structures is done by the parseQuery()
+** function.
+*/
+typedef struct QueryTerm {
+  short int nPhrase; /* How many following terms are part of the same phrase */
+  short int iPhrase; /* This is the i-th term of a phrase. */
+  short int iColumn; /* Column of the index that must match this term */
+  signed char nNear; /* term followed by a NEAR operator with span=(nNear-1) */
+  signed char isOr;  /* this term is preceded by "OR" */
+  signed char isNot; /* this term is preceded by "-" */
+  signed char isPrefix; /* this term is followed by "*" */
+  char *pTerm;       /* text of the term.  '\000' terminated.  malloced */
+  int nTerm;         /* Number of bytes in pTerm[] */
+} QueryTerm;
+
+
+/* A query string is parsed into a Query structure.
+ *
+ * We could, in theory, allow query strings to be complicated
+ * nested expressions with precedence determined by parentheses.
+ * But none of the major search engines do this.  (Perhaps the
+ * feeling is that an parenthesized expression is two complex of
+ * an idea for the average user to grasp.)  Taking our lead from
+ * the major search engines, we will allow queries to be a list
+ * of terms (with an implied AND operator) or phrases in double-quotes,
+ * with a single optional "-" before each non-phrase term to designate
+ * negation and an optional OR connector.
+ *
+ * OR binds more tightly than the implied AND, which is what the
+ * major search engines seem to do.  So, for example:
+ * 
+ *    [one two OR three]     ==>    one AND (two OR three)
+ *    [one OR two three]     ==>    (one OR two) AND three
+ *
+ * A "-" before a term matches all entries that lack that term.
+ * The "-" must occur immediately before the term with in intervening
+ * space.  This is how the search engines do it.
+ *
+ * A NOT term cannot be the right-hand operand of an OR.  If this
+ * occurs in the query string, the NOT is ignored:
+ *
+ *    [one OR -two]          ==>    one OR two
+ *
+ */
+typedef struct Query {
+  fulltext_vtab *pFts;  /* The full text index */
+  int nTerms;           /* Number of terms in the query */
+  QueryTerm *pTerms;    /* Array of terms.  Space obtained from malloc() */
+  int nextIsOr;         /* Set the isOr flag on the next inserted term */
+  int nextIsNear;       /* Set the isOr flag on the next inserted term */
+  int nextColumn;       /* Next word parsed must be in this column */
+  int dfltColumn;       /* The default column */
+} Query;
+
+
+/*
+** An instance of the following structure keeps track of generated
+** matching-word offset information and snippets.
+*/
+typedef struct Snippet {
+  int nMatch;     /* Total number of matches */
+  int nAlloc;     /* Space allocated for aMatch[] */
+  struct snippetMatch { /* One entry for each matching term */
+    char snStatus;       /* Status flag for use while constructing snippets */
+    short int iCol;      /* The column that contains the match */
+    short int iTerm;     /* The index in Query.pTerms[] of the matching term */
+    int iToken;          /* The index of the matching document token */
+    short int nByte;     /* Number of bytes in the term */
+    int iStart;          /* The offset to the first character of the term */
+  } *aMatch;      /* Points to space obtained from malloc */
+  char *zOffset;  /* Text rendering of aMatch[] */
+  int nOffset;    /* strlen(zOffset) */
+  char *zSnippet; /* Snippet text */
+  int nSnippet;   /* strlen(zSnippet) */
+} Snippet;
+
+
+typedef enum QueryType {
+  QUERY_GENERIC,   /* table scan */
+  QUERY_DOCID,     /* lookup by docid */
+  QUERY_FULLTEXT   /* QUERY_FULLTEXT + [i] is a full-text search for column i*/
+} QueryType;
+
+typedef enum fulltext_statement {
+  CONTENT_INSERT_STMT,
+  CONTENT_SELECT_STMT,
+  CONTENT_UPDATE_STMT,
+  CONTENT_DELETE_STMT,
+
+  BLOCK_INSERT_STMT,
+  BLOCK_SELECT_STMT,
+  BLOCK_DELETE_STMT,
+
+  SEGDIR_MAX_INDEX_STMT,
+  SEGDIR_SET_STMT,
+  SEGDIR_SELECT_STMT,
+  SEGDIR_SPAN_STMT,
+  SEGDIR_DELETE_STMT,
+  SEGDIR_SELECT_ALL_STMT,
+
+  MAX_STMT                     /* Always at end! */
+} fulltext_statement;
+
+/* These must exactly match the enum above. */
+/* TODO(shess): Is there some risk that a statement will be used in two
+** cursors at once, e.g.  if a query joins a virtual table to itself?
+** If so perhaps we should move some of these to the cursor object.
+*/
+static const char *const fulltext_zStatement[MAX_STMT] = {
+  /* CONTENT_INSERT */ NULL,  /* generated in contentInsertStatement() */
+  /* CONTENT_SELECT */ NULL,  /* generated in contentSelectStatement() */
+  /* CONTENT_UPDATE */ NULL,  /* generated in contentUpdateStatement() */
+  /* CONTENT_DELETE */ "delete from %_content where docid = ?",
+
+  /* BLOCK_INSERT */
+  "insert into %_segments (blockid, block) values (null, ?)",
+  /* BLOCK_SELECT */ "select block from %_segments where blockid = ?",
+  /* BLOCK_DELETE */ "delete from %_segments where blockid between ? and ?",
+
+  /* SEGDIR_MAX_INDEX */ "select max(idx) from %_segdir where level = ?",
+  /* SEGDIR_SET */ "insert into %_segdir values (?, ?, ?, ?, ?, ?)",
+  /* SEGDIR_SELECT */
+  "select start_block, leaves_end_block, root from %_segdir "
+  " where level = ? order by idx",
+  /* SEGDIR_SPAN */
+  "select min(start_block), max(end_block) from %_segdir "
+  " where level = ? and start_block <> 0",
+  /* SEGDIR_DELETE */ "delete from %_segdir where level = ?",
+  /* SEGDIR_SELECT_ALL */
+  "select root, leaves_end_block from %_segdir order by level desc, idx",
+};
+
+/*
+** A connection to a fulltext index is an instance of the following
+** structure.  The xCreate and xConnect methods create an instance
+** of this structure and xDestroy and xDisconnect free that instance.
+** All other methods receive a pointer to the structure as one of their
+** arguments.
+*/
+struct fulltext_vtab {
+  sqlite3_vtab base;               /* Base class used by SQLite core */
+  sqlite3 *db;                     /* The database connection */
+  const char *zDb;                 /* logical database name */
+  const char *zName;               /* virtual table name */
+  int nColumn;                     /* number of columns in virtual table */
+  char **azColumn;                 /* column names.  malloced */
+  char **azContentColumn;          /* column names in content table; malloced */
+  sqlite3_tokenizer *pTokenizer;   /* tokenizer for inserts and queries */
+
+  /* Precompiled statements which we keep as long as the table is
+  ** open.
+  */
+  sqlite3_stmt *pFulltextStatements[MAX_STMT];
+
+  /* Precompiled statements used for segment merges.  We run a
+  ** separate select across the leaf level of each tree being merged.
+  */
+  sqlite3_stmt *pLeafSelectStmts[MERGE_COUNT];
+  /* The statement used to prepare pLeafSelectStmts. */
+#define LEAF_SELECT \
+  "select block from %_segments where blockid between ? and ? order by blockid"
+
+  /* These buffer pending index updates during transactions.
+  ** nPendingData estimates the memory size of the pending data.  It
+  ** doesn't include the hash-bucket overhead, nor any malloc
+  ** overhead.  When nPendingData exceeds kPendingThreshold, the
+  ** buffer is flushed even before the transaction closes.
+  ** pendingTerms stores the data, and is only valid when nPendingData
+  ** is >=0 (nPendingData<0 means pendingTerms has not been
+  ** initialized).  iPrevDocid is the last docid written, used to make
+  ** certain we're inserting in sorted order.
+  */
+  int nPendingData;
+#define kPendingThreshold (1*1024*1024)
+  sqlite_int64 iPrevDocid;
+  fts3Hash pendingTerms;
+};
+
+/*
+** When the core wants to do a query, it create a cursor using a
+** call to xOpen.  This structure is an instance of a cursor.  It
+** is destroyed by xClose.
+*/
+typedef struct fulltext_cursor {
+  sqlite3_vtab_cursor base;        /* Base class used by SQLite core */
+  QueryType iCursorType;           /* Copy of sqlite3_index_info.idxNum */
+  sqlite3_stmt *pStmt;             /* Prepared statement in use by the cursor */
+  int eof;                         /* True if at End Of Results */
+  Query q;                         /* Parsed query string */
+  Snippet snippet;                 /* Cached snippet for the current row */
+  int iColumn;                     /* Column being searched */
+  DataBuffer result;               /* Doclist results from fulltextQuery */
+  DLReader reader;                 /* Result reader if result not empty */
+} fulltext_cursor;
+
+static struct fulltext_vtab *cursor_vtab(fulltext_cursor *c){
+  return (fulltext_vtab *) c->base.pVtab;
+}
+
+static const sqlite3_module fts3Module;   /* forward declaration */
+
+/* Return a dynamically generated statement of the form
+ *   insert into %_content (docid, ...) values (?, ...)
+ */
+static const char *contentInsertStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "insert into %_content (docid, ");
+  appendList(&sb, v->nColumn, v->azContentColumn);
+  append(&sb, ") values (?");
+  for(i=0; i<v->nColumn; ++i)
+    append(&sb, ", ?");
+  append(&sb, ")");
+  return stringBufferData(&sb);
+}
+
+/* Return a dynamically generated statement of the form
+ *   select <content columns> from %_content where docid = ?
+ */
+static const char *contentSelectStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  initStringBuffer(&sb);
+  append(&sb, "SELECT ");
+  appendList(&sb, v->nColumn, v->azContentColumn);
+  append(&sb, " FROM %_content WHERE docid = ?");
+  return stringBufferData(&sb);
+}
+
+/* Return a dynamically generated statement of the form
+ *   update %_content set [col_0] = ?, [col_1] = ?, ...
+ *                    where docid = ?
+ */
+static const char *contentUpdateStatement(fulltext_vtab *v){
+  StringBuffer sb;
+  int i;
+
+  initStringBuffer(&sb);
+  append(&sb, "update %_content set ");
+  for(i=0; i<v->nColumn; ++i) {
+    if( i>0 ){
+      append(&sb, ", ");
+    }
+    append(&sb, v->azContentColumn[i]);
+    append(&sb, " = ?");
+  }
+  append(&sb, " where docid = ?");
+  return stringBufferData(&sb);
+}
+
+/* Puts a freshly-prepared statement determined by iStmt in *ppStmt.
+** If the indicated statement has never been prepared, it is prepared
+** and cached, otherwise the cached version is reset.
+*/
+static int sql_get_statement(fulltext_vtab *v, fulltext_statement iStmt,
+                             sqlite3_stmt **ppStmt){
+  assert( iStmt<MAX_STMT );
+  if( v->pFulltextStatements[iStmt]==NULL ){
+    const char *zStmt;
+    int rc;
+    switch( iStmt ){
+      case CONTENT_INSERT_STMT:
+        zStmt = contentInsertStatement(v); break;
+      case CONTENT_SELECT_STMT:
+        zStmt = contentSelectStatement(v); break;
+      case CONTENT_UPDATE_STMT:
+        zStmt = contentUpdateStatement(v); break;
+      default:
+        zStmt = fulltext_zStatement[iStmt];
+    }
+    rc = sql_prepare(v->db, v->zDb, v->zName, &v->pFulltextStatements[iStmt],
+                         zStmt);
+    if( zStmt != fulltext_zStatement[iStmt]) sqlite3_free((void *) zStmt);
+    if( rc!=SQLITE_OK ) return rc;
+  } else {
+    int rc = sqlite3_reset(v->pFulltextStatements[iStmt]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pFulltextStatements[iStmt];
+  return SQLITE_OK;
+}
+
+/* Like sqlite3_step(), but convert SQLITE_DONE to SQLITE_OK and
+** SQLITE_ROW to SQLITE_ERROR.  Useful for statements like UPDATE,
+** where we expect no results.
+*/
+static int sql_single_step(sqlite3_stmt *s){
+  int rc = sqlite3_step(s);
+  return (rc==SQLITE_DONE) ? SQLITE_OK : rc;
+}
+
+/* Like sql_get_statement(), but for special replicated LEAF_SELECT
+** statements.
+*/
+/* TODO(shess) Write version for generic statements and then share
+** that between the cached-statement functions.
+*/
+static int sql_get_leaf_statement(fulltext_vtab *v, int idx,
+                                  sqlite3_stmt **ppStmt){
+  assert( idx>=0 && idx<MERGE_COUNT );
+  if( v->pLeafSelectStmts[idx]==NULL ){
+    int rc = sql_prepare(v->db, v->zDb, v->zName, &v->pLeafSelectStmts[idx],
+                         LEAF_SELECT);
+    if( rc!=SQLITE_OK ) return rc;
+  }else{
+    int rc = sqlite3_reset(v->pLeafSelectStmts[idx]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  *ppStmt = v->pLeafSelectStmts[idx];
+  return SQLITE_OK;
+}
+
+/* insert into %_content (docid, ...) values ([docid], [pValues])
+** If the docid contains SQL NULL, then a unique docid will be
+** generated.
+*/
+static int content_insert(fulltext_vtab *v, sqlite3_value *docid,
+                          sqlite3_value **pValues){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_value(s, 1, docid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 2+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  return sql_single_step(s);
+}
+
+/* update %_content set col0 = pValues[0], col1 = pValues[1], ...
+ *                  where docid = [iDocid] */
+static int content_update(fulltext_vtab *v, sqlite3_value **pValues,
+                          sqlite_int64 iDocid){
+  sqlite3_stmt *s;
+  int i;
+  int rc = sql_get_statement(v, CONTENT_UPDATE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i=0; i<v->nColumn; ++i){
+    rc = sqlite3_bind_value(s, 1+i, pValues[i]);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  rc = sqlite3_bind_int64(s, 1+v->nColumn, iDocid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+static void freeStringArray(int nString, const char **pString){
+  int i;
+
+  for (i=0 ; i < nString ; ++i) {
+    if( pString[i]!=NULL ) sqlite3_free((void *) pString[i]);
+  }
+  sqlite3_free((void *) pString);
+}
+
+/* select * from %_content where docid = [iDocid]
+ * The caller must delete the returned array and all strings in it.
+ * null fields will be NULL in the returned array.
+ *
+ * TODO: Perhaps we should return pointer/length strings here for consistency
+ * with other code which uses pointer/length. */
+static int content_select(fulltext_vtab *v, sqlite_int64 iDocid,
+                          const char ***pValues){
+  sqlite3_stmt *s;
+  const char **values;
+  int i;
+  int rc;
+
+  *pValues = NULL;
+
+  rc = sql_get_statement(v, CONTENT_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iDocid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc!=SQLITE_ROW ) return rc;
+
+  values = (const char **) sqlite3_malloc(v->nColumn * sizeof(const char *));
+  for(i=0; i<v->nColumn; ++i){
+    if( sqlite3_column_type(s, i)==SQLITE_NULL ){
+      values[i] = NULL;
+    }else{
+      values[i] = string_dup((char*)sqlite3_column_text(s, i));
+    }
+  }
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ){
+    *pValues = values;
+    return SQLITE_OK;
+  }
+
+  freeStringArray(v->nColumn, values);
+  return rc;
+}
+
+/* delete from %_content where docid = [iDocid ] */
+static int content_delete(fulltext_vtab *v, sqlite_int64 iDocid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, CONTENT_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iDocid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* insert into %_segments values ([pData])
+**   returns assigned blockid in *piBlockid
+*/
+static int block_insert(fulltext_vtab *v, const char *pData, int nData,
+                        sqlite_int64 *piBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, BLOCK_INSERT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 1, pData, nData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+
+  /* blockid column is an alias for rowid. */
+  *piBlockid = sqlite3_last_insert_rowid(v->db);
+  return SQLITE_OK;
+}
+
+/* delete from %_segments
+**   where blockid between [iStartBlockid] and [iEndBlockid]
+**
+** Deletes the range of blocks, inclusive, used to delete the blocks
+** which form a segment.
+*/
+static int block_delete(fulltext_vtab *v,
+                        sqlite_int64 iStartBlockid, sqlite_int64 iEndBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, BLOCK_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iStartBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 2, iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* Returns SQLITE_ROW with *pidx set to the maximum segment idx found
+** at iLevel.  Returns SQLITE_DONE if there are no segments at
+** iLevel.  Otherwise returns an error.
+*/
+static int segdir_max_index(fulltext_vtab *v, int iLevel, int *pidx){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_MAX_INDEX_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  /* Should always get at least one row due to how max() works. */
+  if( rc==SQLITE_DONE ) return SQLITE_DONE;
+  if( rc!=SQLITE_ROW ) return rc;
+
+  /* NULL means that there were no inputs to max(). */
+  if( SQLITE_NULL==sqlite3_column_type(s, 0) ){
+    rc = sqlite3_step(s);
+    if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+    return rc;
+  }
+
+  *pidx = sqlite3_column_int(s, 0);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+  return SQLITE_ROW;
+}
+
+/* insert into %_segdir values (
+**   [iLevel], [idx],
+**   [iStartBlockid], [iLeavesEndBlockid], [iEndBlockid],
+**   [pRootData]
+** )
+*/
+static int segdir_set(fulltext_vtab *v, int iLevel, int idx,
+                      sqlite_int64 iStartBlockid,
+                      sqlite_int64 iLeavesEndBlockid,
+                      sqlite_int64 iEndBlockid,
+                      const char *pRootData, int nRootData){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SET_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 2, idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 3, iStartBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 4, iLeavesEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 5, iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_blob(s, 6, pRootData, nRootData, SQLITE_STATIC);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* Queries %_segdir for the block span of the segments in level
+** iLevel.  Returns SQLITE_DONE if there are no blocks for iLevel,
+** SQLITE_ROW if there are blocks, else an error.
+*/
+static int segdir_span(fulltext_vtab *v, int iLevel,
+                       sqlite_int64 *piStartBlockid,
+                       sqlite_int64 *piEndBlockid){
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SPAN_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ) return SQLITE_DONE;  /* Should never happen */
+  if( rc!=SQLITE_ROW ) return rc;
+
+  /* This happens if all segments at this level are entirely inline. */
+  if( SQLITE_NULL==sqlite3_column_type(s, 0) ){
+    /* We expect only one row.  We must execute another sqlite3_step()
+     * to complete the iteration; otherwise the table will remain locked. */
+    int rc2 = sqlite3_step(s);
+    if( rc2==SQLITE_ROW ) return SQLITE_ERROR;
+    return rc2;
+  }
+
+  *piStartBlockid = sqlite3_column_int64(s, 0);
+  *piEndBlockid = sqlite3_column_int64(s, 1);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+  return SQLITE_ROW;
+}
+
+/* Delete the segment blocks and segment directory records for all
+** segments at iLevel.
+*/
+static int segdir_delete(fulltext_vtab *v, int iLevel){
+  sqlite3_stmt *s;
+  sqlite_int64 iStartBlockid, iEndBlockid;
+  int rc = segdir_span(v, iLevel, &iStartBlockid, &iEndBlockid);
+  if( rc!=SQLITE_ROW && rc!=SQLITE_DONE ) return rc;
+
+  if( rc==SQLITE_ROW ){
+    rc = block_delete(v, iStartBlockid, iEndBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  /* Delete the segment directory itself. */
+  rc = sql_get_statement(v, SEGDIR_DELETE_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return sql_single_step(s);
+}
+
+/* TODO(shess) clearPendingTerms() is far down the file because
+** writeZeroSegment() is far down the file because LeafWriter is far
+** down the file.  Consider refactoring the code to move the non-vtab
+** code above the vtab code so that we don't need this forward
+** reference.
+*/
+static int clearPendingTerms(fulltext_vtab *v);
+
+/*
+** Free the memory used to contain a fulltext_vtab structure.
+*/
+static void fulltext_vtab_destroy(fulltext_vtab *v){
+  int iStmt, i;
+
+  FTSTRACE(("FTS3 Destroy %p\n", v));
+  for( iStmt=0; iStmt<MAX_STMT; iStmt++ ){
+    if( v->pFulltextStatements[iStmt]!=NULL ){
+      sqlite3_finalize(v->pFulltextStatements[iStmt]);
+      v->pFulltextStatements[iStmt] = NULL;
+    }
+  }
+
+  for( i=0; i<MERGE_COUNT; i++ ){
+    if( v->pLeafSelectStmts[i]!=NULL ){
+      sqlite3_finalize(v->pLeafSelectStmts[i]);
+      v->pLeafSelectStmts[i] = NULL;
+    }
+  }
+
+  if( v->pTokenizer!=NULL ){
+    v->pTokenizer->pModule->xDestroy(v->pTokenizer);
+    v->pTokenizer = NULL;
+  }
+
+  clearPendingTerms(v);
+
+  sqlite3_free(v->azColumn);
+  for(i = 0; i < v->nColumn; ++i) {
+    sqlite3_free(v->azContentColumn[i]);
+  }
+  sqlite3_free(v->azContentColumn);
+  sqlite3_free(v);
+}
+
+/*
+** Token types for parsing the arguments to xConnect or xCreate.
+*/
+#define TOKEN_EOF         0    /* End of file */
+#define TOKEN_SPACE       1    /* Any kind of whitespace */
+#define TOKEN_ID          2    /* An identifier */
+#define TOKEN_STRING      3    /* A string literal */
+#define TOKEN_PUNCT       4    /* A single punctuation character */
+
+/*
+** If X is a character that can be used in an identifier then
+** ftsIdChar(X) will be true.  Otherwise it is false.
+**
+** For ASCII, any character with the high-order bit set is
+** allowed in an identifier.  For 7-bit characters, 
+** isFtsIdChar[X] must be 1.
+**
+** Ticket #1066.  the SQL standard does not allow '$' in the
+** middle of identfiers.  But many SQL implementations do. 
+** SQLite will allow '$' in identifiers for compatibility.
+** But the feature is undocumented.
+*/
+static const char isFtsIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define ftsIdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && isFtsIdChar[c-0x20]))
+
+
+/*
+** Return the length of the token that begins at z[0]. 
+** Store the token type in *tokenType before returning.
+*/
+static int ftsGetToken(const char *z, int *tokenType){
+  int i, c;
+  switch( *z ){
+    case 0: {
+      *tokenType = TOKEN_EOF;
+      return 0;
+    }
+    case ' ': case '\t': case '\n': case '\f': case '\r': {
+      for(i=1; safe_isspace(z[i]); i++){}
+      *tokenType = TOKEN_SPACE;
+      return i;
+    }
+    case '`':
+    case '\'':
+    case '"': {
+      int delim = z[0];
+      for(i=1; (c=z[i])!=0; i++){
+        if( c==delim ){
+          if( z[i+1]==delim ){
+            i++;
+          }else{
+            break;
+          }
+        }
+      }
+      *tokenType = TOKEN_STRING;
+      return i + (c!=0);
+    }
+    case '[': {
+      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+    default: {
+      if( !ftsIdChar(*z) ){
+        break;
+      }
+      for(i=1; ftsIdChar(z[i]); i++){}
+      *tokenType = TOKEN_ID;
+      return i;
+    }
+  }
+  *tokenType = TOKEN_PUNCT;
+  return 1;
+}
+
+/*
+** A token extracted from a string is an instance of the following
+** structure.
+*/
+typedef struct FtsToken {
+  const char *z;       /* Pointer to token text.  Not '\000' terminated */
+  short int n;         /* Length of the token text in bytes. */
+} FtsToken;
+
+/*
+** Given a input string (which is really one of the argv[] parameters
+** passed into xConnect or xCreate) split the string up into tokens.
+** Return an array of pointers to '\000' terminated strings, one string
+** for each non-whitespace token.
+**
+** The returned array is terminated by a single NULL pointer.
+**
+** Space to hold the returned array is obtained from a single
+** malloc and should be freed by passing the return value to free().
+** The individual strings within the token list are all a part of
+** the single memory allocation and will all be freed at once.
+*/
+static char **tokenizeString(const char *z, int *pnToken){
+  int nToken = 0;
+  FtsToken *aToken = sqlite3_malloc( strlen(z) * sizeof(aToken[0]) );
+  int n = 1;
+  int e, i;
+  int totalSize = 0;
+  char **azToken;
+  char *zCopy;
+  while( n>0 ){
+    n = ftsGetToken(z, &e);
+    if( e!=TOKEN_SPACE ){
+      aToken[nToken].z = z;
+      aToken[nToken].n = n;
+      nToken++;
+      totalSize += n+1;
+    }
+    z += n;
+  }
+  azToken = (char**)sqlite3_malloc( nToken*sizeof(char*) + totalSize );
+  zCopy = (char*)&azToken[nToken];
+  nToken--;
+  for(i=0; i<nToken; i++){
+    azToken[i] = zCopy;
+    n = aToken[i].n;
+    memcpy(zCopy, aToken[i].z, n);
+    zCopy[n] = 0;
+    zCopy += n+1;
+  }
+  azToken[nToken] = 0;
+  sqlite3_free(aToken);
+  *pnToken = nToken;
+  return azToken;
+}
+
+/*
+** 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.
+**
+** Examples:
+**
+**     "abc"   becomes   abc
+**     'xyz'   becomes   xyz
+**     [pqr]   becomes   pqr
+**     `mno`   becomes   mno
+*/
+static void dequoteString(char *z){
+  int quote;
+  int i, j;
+  if( z==0 ) return;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return;
+  }
+  for(i=1, j=0; z[i]; i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        z[j++] = 0;
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+}
+
+/*
+** The input azIn is a NULL-terminated list of tokens.  Remove the first
+** token and all punctuation tokens.  Remove the quotes from
+** around string literal tokens.
+**
+** Example:
+**
+**     input:      tokenize chinese ( 'simplifed' , 'mixed' )
+**     output:     chinese simplifed mixed
+**
+** Another example:
+**
+**     input:      delimiters ( '[' , ']' , '...' )
+**     output:     [ ] ...
+*/
+static void tokenListToIdList(char **azIn){
+  int i, j;
+  if( azIn ){
+    for(i=0, j=-1; azIn[i]; i++){
+      if( safe_isalnum(azIn[i][0]) || azIn[i][1] ){
+        dequoteString(azIn[i]);
+        if( j>=0 ){
+          azIn[j] = azIn[i];
+        }
+        j++;
+      }
+    }
+    azIn[j] = 0;
+  }
+}
+
+
+/*
+** Find the first alphanumeric token in the string zIn.  Null-terminate
+** this token.  Remove any quotation marks.  And return a pointer to
+** the result.
+*/
+static char *firstToken(char *zIn, char **pzTail){
+  int n, ttype;
+  while(1){
+    n = ftsGetToken(zIn, &ttype);
+    if( ttype==TOKEN_SPACE ){
+      zIn += n;
+    }else if( ttype==TOKEN_EOF ){
+      *pzTail = zIn;
+      return 0;
+    }else{
+      zIn[n] = 0;
+      *pzTail = &zIn[1];
+      dequoteString(zIn);
+      return zIn;
+    }
+  }
+  /*NOTREACHED*/
+}
+
+/* Return true if...
+**
+**   *  s begins with the string t, ignoring case
+**   *  s is longer than t
+**   *  The first character of s beyond t is not a alphanumeric
+** 
+** Ignore leading space in *s.
+**
+** To put it another way, return true if the first token of
+** s[] is t[].
+*/
+static int startsWith(const char *s, const char *t){
+  while( safe_isspace(*s) ){ s++; }
+  while( *t ){
+    if( safe_tolower(*s++)!=safe_tolower(*t++) ) return 0;
+  }
+  return *s!='_' && !safe_isalnum(*s);
+}
+
+/*
+** An instance of this structure defines the "spec" of a
+** full text index.  This structure is populated by parseSpec
+** and use by fulltextConnect and fulltextCreate.
+*/
+typedef struct TableSpec {
+  const char *zDb;         /* Logical database name */
+  const char *zName;       /* Name of the full-text index */
+  int nColumn;             /* Number of columns to be indexed */
+  char **azColumn;         /* Original names of columns to be indexed */
+  char **azContentColumn;  /* Column names for %_content */
+  char **azTokenizer;      /* Name of tokenizer and its arguments */
+} TableSpec;
+
+/*
+** Reclaim all of the memory used by a TableSpec
+*/
+static void clearTableSpec(TableSpec *p) {
+  sqlite3_free(p->azColumn);
+  sqlite3_free(p->azContentColumn);
+  sqlite3_free(p->azTokenizer);
+}
+
+/* Parse a CREATE VIRTUAL TABLE statement, which looks like this:
+ *
+ * CREATE VIRTUAL TABLE email
+ *        USING fts3(subject, body, tokenize mytokenizer(myarg))
+ *
+ * We return parsed information in a TableSpec structure.
+ * 
+ */
+static int parseSpec(TableSpec *pSpec, int argc, const char *const*argv,
+                     char**pzErr){
+  int i, n;
+  char *z, *zDummy;
+  char **azArg;
+  const char *zTokenizer = 0;    /* argv[] entry describing the tokenizer */
+
+  assert( argc>=3 );
+  /* Current interface:
+  ** argv[0] - module name
+  ** argv[1] - database name
+  ** argv[2] - table name
+  ** argv[3..] - columns, optionally followed by tokenizer specification
+  **             and snippet delimiters specification.
+  */
+
+  /* Make a copy of the complete argv[][] array in a single allocation.
+  ** The argv[][] array is read-only and transient.  We can write to the
+  ** copy in order to modify things and the copy is persistent.
+  */
+  CLEAR(pSpec);
+  for(i=n=0; i<argc; i++){
+    n += strlen(argv[i]) + 1;
+  }
+  azArg = sqlite3_malloc( sizeof(char*)*argc + n );
+  if( azArg==0 ){
+    return SQLITE_NOMEM;
+  }
+  z = (char*)&azArg[argc];
+  for(i=0; i<argc; i++){
+    azArg[i] = z;
+    strcpy(z, argv[i]);
+    z += strlen(z)+1;
+  }
+
+  /* Identify the column names and the tokenizer and delimiter arguments
+  ** in the argv[][] array.
+  */
+  pSpec->zDb = azArg[1];
+  pSpec->zName = azArg[2];
+  pSpec->nColumn = 0;
+  pSpec->azColumn = azArg;
+  zTokenizer = "tokenize simple";
+  for(i=3; i<argc; ++i){
+    if( startsWith(azArg[i],"tokenize") ){
+      zTokenizer = azArg[i];
+    }else{
+      z = azArg[pSpec->nColumn] = firstToken(azArg[i], &zDummy);
+      pSpec->nColumn++;
+    }
+  }
+  if( pSpec->nColumn==0 ){
+    azArg[0] = "content";
+    pSpec->nColumn = 1;
+  }
+
+  /*
+  ** Construct the list of content column names.
+  **
+  ** Each content column name will be of the form cNNAAAA
+  ** where NN is the column number and AAAA is the sanitized
+  ** column name.  "sanitized" means that special characters are
+  ** converted to "_".  The cNN prefix guarantees that all column
+  ** names are unique.
+  **
+  ** The AAAA suffix is not strictly necessary.  It is included
+  ** for the convenience of people who might examine the generated
+  ** %_content table and wonder what the columns are used for.
+  */
+  pSpec->azContentColumn = sqlite3_malloc( pSpec->nColumn * sizeof(char *) );
+  if( pSpec->azContentColumn==0 ){
+    clearTableSpec(pSpec);
+    return SQLITE_NOMEM;
+  }
+  for(i=0; i<pSpec->nColumn; i++){
+    char *p;
+    pSpec->azContentColumn[i] = sqlite3_mprintf("c%d%s", i, azArg[i]);
+    for (p = pSpec->azContentColumn[i]; *p ; ++p) {
+      if( !safe_isalnum(*p) ) *p = '_';
+    }
+  }
+
+  /*
+  ** Parse the tokenizer specification string.
+  */
+  pSpec->azTokenizer = tokenizeString(zTokenizer, &n);
+  tokenListToIdList(pSpec->azTokenizer);
+
+  return SQLITE_OK;
+}
+
+/*
+** Generate a CREATE TABLE statement that describes the schema of
+** the virtual table.  Return a pointer to this schema string.
+**
+** Space is obtained from sqlite3_mprintf() and should be freed
+** using sqlite3_free().
+*/
+static char *fulltextSchema(
+  int nColumn,                  /* Number of columns */
+  const char *const* azColumn,  /* List of columns */
+  const char *zTableName        /* Name of the table */
+){
+  int i;
+  char *zSchema, *zNext;
+  const char *zSep = "(";
+  zSchema = sqlite3_mprintf("CREATE TABLE x");
+  for(i=0; i<nColumn; i++){
+    zNext = sqlite3_mprintf("%s%s%Q", zSchema, zSep, azColumn[i]);
+    sqlite3_free(zSchema);
+    zSchema = zNext;
+    zSep = ",";
+  }
+  zNext = sqlite3_mprintf("%s,%Q HIDDEN", zSchema, zTableName);
+  sqlite3_free(zSchema);
+  zSchema = zNext;
+  zNext = sqlite3_mprintf("%s,docid HIDDEN)", zSchema);
+  sqlite3_free(zSchema);
+  return zNext;
+}
+
+/*
+** Build a new sqlite3_vtab structure that will describe the
+** fulltext index defined by spec.
+*/
+static int constructVtab(
+  sqlite3 *db,              /* The SQLite database connection */
+  fts3Hash *pHash,          /* Hash table containing tokenizers */
+  TableSpec *spec,          /* Parsed spec information from parseSpec() */
+  sqlite3_vtab **ppVTab,    /* Write the resulting vtab structure here */
+  char **pzErr              /* Write any error message here */
+){
+  int rc;
+  int n;
+  fulltext_vtab *v = 0;
+  const sqlite3_tokenizer_module *m = NULL;
+  char *schema;
+
+  char const *zTok;         /* Name of tokenizer to use for this fts table */
+  int nTok;                 /* Length of zTok, including nul terminator */
+
+  v = (fulltext_vtab *) sqlite3_malloc(sizeof(fulltext_vtab));
+  if( v==0 ) return SQLITE_NOMEM;
+  CLEAR(v);
+  /* sqlite will initialize v->base */
+  v->db = db;
+  v->zDb = spec->zDb;       /* Freed when azColumn is freed */
+  v->zName = spec->zName;   /* Freed when azColumn is freed */
+  v->nColumn = spec->nColumn;
+  v->azContentColumn = spec->azContentColumn;
+  spec->azContentColumn = 0;
+  v->azColumn = spec->azColumn;
+  spec->azColumn = 0;
+
+  if( spec->azTokenizer==0 ){
+    return SQLITE_NOMEM;
+  }
+
+  zTok = spec->azTokenizer[0]; 
+  if( !zTok ){
+    zTok = "simple";
+  }
+  nTok = strlen(zTok)+1;
+
+  m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zTok, nTok);
+  if( !m ){
+    *pzErr = sqlite3_mprintf("unknown tokenizer: %s", spec->azTokenizer[0]);
+    rc = SQLITE_ERROR;
+    goto err;
+  }
+
+  for(n=0; spec->azTokenizer[n]; n++){}
+  if( n ){
+    rc = m->xCreate(n-1, (const char*const*)&spec->azTokenizer[1],
+                    &v->pTokenizer);
+  }else{
+    rc = m->xCreate(0, 0, &v->pTokenizer);
+  }
+  if( rc!=SQLITE_OK ) goto err;
+  v->pTokenizer->pModule = m;
+
+  /* TODO: verify the existence of backing tables foo_content, foo_term */
+
+  schema = fulltextSchema(v->nColumn, (const char*const*)v->azColumn,
+                          spec->zName);
+  rc = sqlite3_declare_vtab(db, schema);
+  sqlite3_free(schema);
+  if( rc!=SQLITE_OK ) goto err;
+
+  memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
+
+  /* Indicate that the buffer is not live. */
+  v->nPendingData = -1;
+
+  *ppVTab = &v->base;
+  FTSTRACE(("FTS3 Connect %p\n", v));
+
+  return rc;
+
+err:
+  fulltext_vtab_destroy(v);
+  return rc;
+}
+
+static int fulltextConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVTab,
+  char **pzErr
+){
+  TableSpec spec;
+  int rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = constructVtab(db, (fts3Hash *)pAux, &spec, ppVTab, pzErr);
+  clearTableSpec(&spec);
+  return rc;
+}
+
+/* The %_content table holds the text of each document, with
+** the docid column exposed as the SQLite rowid for the table.
+*/
+/* TODO(shess) This comment needs elaboration to match the updated
+** code.  Work it into the top-of-file comment at that time.
+*/
+static int fulltextCreate(sqlite3 *db, void *pAux,
+                          int argc, const char * const *argv,
+                          sqlite3_vtab **ppVTab, char **pzErr){
+  int rc;
+  TableSpec spec;
+  StringBuffer schema;
+  FTSTRACE(("FTS3 Create\n"));
+
+  rc = parseSpec(&spec, argc, argv, pzErr);
+  if( rc!=SQLITE_OK ) return rc;
+
+  initStringBuffer(&schema);
+  append(&schema, "CREATE TABLE %_content(");
+  append(&schema, "  docid INTEGER PRIMARY KEY,");
+  appendList(&schema, spec.nColumn, spec.azContentColumn);
+  append(&schema, ")");
+  rc = sql_exec(db, spec.zDb, spec.zName, stringBufferData(&schema));
+  stringBufferDestroy(&schema);
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = sql_exec(db, spec.zDb, spec.zName,
+                "create table %_segments("
+                "  blockid INTEGER PRIMARY KEY,"
+                "  block blob"
+                ");"
+                );
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = sql_exec(db, spec.zDb, spec.zName,
+                "create table %_segdir("
+                "  level integer,"
+                "  idx integer,"
+                "  start_block integer,"
+                "  leaves_end_block integer,"
+                "  end_block integer,"
+                "  root blob,"
+                "  primary key(level, idx)"
+                ");");
+  if( rc!=SQLITE_OK ) goto out;
+
+  rc = constructVtab(db, (fts3Hash *)pAux, &spec, ppVTab, pzErr);
+
+out:
+  clearTableSpec(&spec);
+  return rc;
+}
+
+/* Decide how to handle an SQL query. */
+static int fulltextBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
+  fulltext_vtab *v = (fulltext_vtab *)pVTab;
+  int i;
+  FTSTRACE(("FTS3 BestIndex\n"));
+
+  for(i=0; i<pInfo->nConstraint; ++i){
+    const struct sqlite3_index_constraint *pConstraint;
+    pConstraint = &pInfo->aConstraint[i];
+    if( pConstraint->usable ) {
+      if( (pConstraint->iColumn==-1 || pConstraint->iColumn==v->nColumn+1) &&
+          pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
+        pInfo->idxNum = QUERY_DOCID;      /* lookup by docid */
+        FTSTRACE(("FTS3 QUERY_DOCID\n"));
+      } else if( pConstraint->iColumn>=0 && pConstraint->iColumn<=v->nColumn &&
+                 pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
+        /* full-text search */
+        pInfo->idxNum = QUERY_FULLTEXT + pConstraint->iColumn;
+        FTSTRACE(("FTS3 QUERY_FULLTEXT %d\n", pConstraint->iColumn));
+      } else continue;
+
+      pInfo->aConstraintUsage[i].argvIndex = 1;
+      pInfo->aConstraintUsage[i].omit = 1;
+
+      /* An arbitrary value for now.
+       * TODO: Perhaps docid matches should be considered cheaper than
+       * full-text searches. */
+      pInfo->estimatedCost = 1.0;   
+
+      return SQLITE_OK;
+    }
+  }
+  pInfo->idxNum = QUERY_GENERIC;
+  return SQLITE_OK;
+}
+
+static int fulltextDisconnect(sqlite3_vtab *pVTab){
+  FTSTRACE(("FTS3 Disconnect %p\n", pVTab));
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextDestroy(sqlite3_vtab *pVTab){
+  fulltext_vtab *v = (fulltext_vtab *)pVTab;
+  int rc;
+
+  FTSTRACE(("FTS3 Destroy %p\n", pVTab));
+  rc = sql_exec(v->db, v->zDb, v->zName,
+                "drop table if exists %_content;"
+                "drop table if exists %_segments;"
+                "drop table if exists %_segdir;"
+                );
+  if( rc!=SQLITE_OK ) return rc;
+
+  fulltext_vtab_destroy((fulltext_vtab *)pVTab);
+  return SQLITE_OK;
+}
+
+static int fulltextOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  fulltext_cursor *c;
+
+  c = (fulltext_cursor *) sqlite3_malloc(sizeof(fulltext_cursor));
+  if( c ){
+    memset(c, 0, sizeof(fulltext_cursor));
+    /* sqlite will initialize c->base */
+    *ppCursor = &c->base;
+    FTSTRACE(("FTS3 Open %p: %p\n", pVTab, c));
+    return SQLITE_OK;
+  }else{
+    return SQLITE_NOMEM;
+  }
+}
+
+
+/* Free all of the dynamically allocated memory held by *q
+*/
+static void queryClear(Query *q){
+  int i;
+  for(i = 0; i < q->nTerms; ++i){
+    sqlite3_free(q->pTerms[i].pTerm);
+  }
+  sqlite3_free(q->pTerms);
+  CLEAR(q);
+}
+
+/* Free all of the dynamically allocated memory held by the
+** Snippet
+*/
+static void snippetClear(Snippet *p){
+  sqlite3_free(p->aMatch);
+  sqlite3_free(p->zOffset);
+  sqlite3_free(p->zSnippet);
+  CLEAR(p);
+}
+/*
+** Append a single entry to the p->aMatch[] log.
+*/
+static void snippetAppendMatch(
+  Snippet *p,               /* Append the entry to this snippet */
+  int iCol, int iTerm,      /* The column and query term */
+  int iToken,               /* Matching token in document */
+  int iStart, int nByte     /* Offset and size of the match */
+){
+  int i;
+  struct snippetMatch *pMatch;
+  if( p->nMatch+1>=p->nAlloc ){
+    p->nAlloc = p->nAlloc*2 + 10;
+    p->aMatch = sqlite3_realloc(p->aMatch, p->nAlloc*sizeof(p->aMatch[0]) );
+    if( p->aMatch==0 ){
+      p->nMatch = 0;
+      p->nAlloc = 0;
+      return;
+    }
+  }
+  i = p->nMatch++;
+  pMatch = &p->aMatch[i];
+  pMatch->iCol = iCol;
+  pMatch->iTerm = iTerm;
+  pMatch->iToken = iToken;
+  pMatch->iStart = iStart;
+  pMatch->nByte = nByte;
+}
+
+/*
+** Sizing information for the circular buffer used in snippetOffsetsOfColumn()
+*/
+#define FTS3_ROTOR_SZ   (32)
+#define FTS3_ROTOR_MASK (FTS3_ROTOR_SZ-1)
+
+/*
+** Add entries to pSnippet->aMatch[] for every match that occurs against
+** document zDoc[0..nDoc-1] which is stored in column iColumn.
+*/
+static void snippetOffsetsOfColumn(
+  Query *pQuery,
+  Snippet *pSnippet,
+  int iColumn,
+  const char *zDoc,
+  int nDoc
+){
+  const sqlite3_tokenizer_module *pTModule;  /* The tokenizer module */
+  sqlite3_tokenizer *pTokenizer;             /* The specific tokenizer */
+  sqlite3_tokenizer_cursor *pTCursor;        /* Tokenizer cursor */
+  fulltext_vtab *pVtab;                /* The full text index */
+  int nColumn;                         /* Number of columns in the index */
+  const QueryTerm *aTerm;              /* Query string terms */
+  int nTerm;                           /* Number of query string terms */  
+  int i, j;                            /* Loop counters */
+  int rc;                              /* Return code */
+  unsigned int match, prevMatch;       /* Phrase search bitmasks */
+  const char *zToken;                  /* Next token from the tokenizer */
+  int nToken;                          /* Size of zToken */
+  int iBegin, iEnd, iPos;              /* Offsets of beginning and end */
+
+  /* The following variables keep a circular buffer of the last
+  ** few tokens */
+  unsigned int iRotor = 0;             /* Index of current token */
+  int iRotorBegin[FTS3_ROTOR_SZ];      /* Beginning offset of token */
+  int iRotorLen[FTS3_ROTOR_SZ];        /* Length of token */
+
+  pVtab = pQuery->pFts;
+  nColumn = pVtab->nColumn;
+  pTokenizer = pVtab->pTokenizer;
+  pTModule = pTokenizer->pModule;
+  rc = pTModule->xOpen(pTokenizer, zDoc, nDoc, &pTCursor);
+  if( rc ) return;
+  pTCursor->pTokenizer = pTokenizer;
+  aTerm = pQuery->pTerms;
+  nTerm = pQuery->nTerms;
+  if( nTerm>=FTS3_ROTOR_SZ ){
+    nTerm = FTS3_ROTOR_SZ - 1;
+  }
+  prevMatch = 0;
+  while(1){
+    rc = pTModule->xNext(pTCursor, &zToken, &nToken, &iBegin, &iEnd, &iPos);
+    if( rc ) break;
+    iRotorBegin[iRotor&FTS3_ROTOR_MASK] = iBegin;
+    iRotorLen[iRotor&FTS3_ROTOR_MASK] = iEnd-iBegin;
+    match = 0;
+    for(i=0; i<nTerm; i++){
+      int iCol;
+      iCol = aTerm[i].iColumn;
+      if( iCol>=0 && iCol<nColumn && iCol!=iColumn ) continue;
+      if( aTerm[i].nTerm>nToken ) continue;
+      if( !aTerm[i].isPrefix && aTerm[i].nTerm<nToken ) continue;
+      assert( aTerm[i].nTerm<=nToken );
+      if( memcmp(aTerm[i].pTerm, zToken, aTerm[i].nTerm) ) continue;
+      if( aTerm[i].iPhrase>1 && (prevMatch & (1<<i))==0 ) continue;
+      match |= 1<<i;
+      if( i==nTerm-1 || aTerm[i+1].iPhrase==1 ){
+        for(j=aTerm[i].iPhrase-1; j>=0; j--){
+          int k = (iRotor-j) & FTS3_ROTOR_MASK;
+          snippetAppendMatch(pSnippet, iColumn, i-j, iPos-j,
+                iRotorBegin[k], iRotorLen[k]);
+        }
+      }
+    }
+    prevMatch = match<<1;
+    iRotor++;
+  }
+  pTModule->xClose(pTCursor);  
+}
+
+/*
+** Remove entries from the pSnippet structure to account for the NEAR
+** operator. When this is called, pSnippet contains the list of token 
+** offsets produced by treating all NEAR operators as AND operators.
+** This function removes any entries that should not be present after
+** accounting for the NEAR restriction. For example, if the queried
+** document is:
+**
+**     "A B C D E A"
+**
+** and the query is:
+** 
+**     A NEAR/0 E
+**
+** then when this function is called the Snippet contains token offsets
+** 0, 4 and 5. This function removes the "0" entry (because the first A
+** is not near enough to an E).
+*/
+static void trimSnippetOffsetsForNear(Query *pQuery, Snippet *pSnippet){
+  int ii;
+  int iDir = 1;
+
+  while(iDir>-2) {
+    assert( iDir==1 || iDir==-1 );
+    for(ii=0; ii<pSnippet->nMatch; ii++){
+      int jj;
+      int nNear;
+      struct snippetMatch *pMatch = &pSnippet->aMatch[ii];
+      QueryTerm *pQueryTerm = &pQuery->pTerms[pMatch->iTerm];
+
+      if( (pMatch->iTerm+iDir)<0 
+       || (pMatch->iTerm+iDir)>=pQuery->nTerms
+      ){
+        continue;
+      }
+     
+      nNear = pQueryTerm->nNear;
+      if( iDir<0 ){
+        nNear = pQueryTerm[-1].nNear;
+      }
+  
+      if( pMatch->iTerm>=0 && nNear ){
+        int isOk = 0;
+        int iNextTerm = pMatch->iTerm+iDir;
+        int iPrevTerm = iNextTerm;
+
+        int iEndToken;
+        int iStartToken;
+
+        if( iDir<0 ){
+          int nPhrase = 1;
+          iStartToken = pMatch->iToken;
+          while( (pMatch->iTerm+nPhrase)<pQuery->nTerms 
+              && pQuery->pTerms[pMatch->iTerm+nPhrase].iPhrase>1 
+          ){
+            nPhrase++;
+          }
+          iEndToken = iStartToken + nPhrase - 1;
+        }else{
+          iEndToken   = pMatch->iToken;
+          iStartToken = pMatch->iToken+1-pQueryTerm->iPhrase;
+        }
+
+        while( pQuery->pTerms[iNextTerm].iPhrase>1 ){
+          iNextTerm--;
+        }
+        while( (iPrevTerm+1)<pQuery->nTerms && 
+               pQuery->pTerms[iPrevTerm+1].iPhrase>1 
+        ){
+          iPrevTerm++;
+        }
+  
+        for(jj=0; isOk==0 && jj<pSnippet->nMatch; jj++){
+          struct snippetMatch *p = &pSnippet->aMatch[jj];
+          if( p->iCol==pMatch->iCol && ((
+               p->iTerm==iNextTerm && 
+               p->iToken>iEndToken && 
+               p->iToken<=iEndToken+nNear
+          ) || (
+               p->iTerm==iPrevTerm && 
+               p->iToken<iStartToken && 
+               p->iToken>=iStartToken-nNear
+          ))){
+            isOk = 1;
+          }
+        }
+        if( !isOk ){
+          for(jj=1-pQueryTerm->iPhrase; jj<=0; jj++){
+            pMatch[jj].iTerm = -1;
+          }
+          ii = -1;
+          iDir = 1;
+        }
+      }
+    }
+    iDir -= 2;
+  }
+}
+
+/*
+** Compute all offsets for the current row of the query.  
+** If the offsets have already been computed, this routine is a no-op.
+*/
+static void snippetAllOffsets(fulltext_cursor *p){
+  int nColumn;
+  int iColumn, i;
+  int iFirst, iLast;
+  fulltext_vtab *pFts;
+
+  if( p->snippet.nMatch ) return;
+  if( p->q.nTerms==0 ) return;
+  pFts = p->q.pFts;
+  nColumn = pFts->nColumn;
+  iColumn = (p->iCursorType - QUERY_FULLTEXT);
+  if( iColumn<0 || iColumn>=nColumn ){
+    iFirst = 0;
+    iLast = nColumn-1;
+  }else{
+    iFirst = iColumn;
+    iLast = iColumn;
+  }
+  for(i=iFirst; i<=iLast; i++){
+    const char *zDoc;
+    int nDoc;
+    zDoc = (const char*)sqlite3_column_text(p->pStmt, i+1);
+    nDoc = sqlite3_column_bytes(p->pStmt, i+1);
+    snippetOffsetsOfColumn(&p->q, &p->snippet, i, zDoc, nDoc);
+  }
+
+  trimSnippetOffsetsForNear(&p->q, &p->snippet);
+}
+
+/*
+** Convert the information in the aMatch[] array of the snippet
+** into the string zOffset[0..nOffset-1].
+*/
+static void snippetOffsetText(Snippet *p){
+  int i;
+  int cnt = 0;
+  StringBuffer sb;
+  char zBuf[200];
+  if( p->zOffset ) return;
+  initStringBuffer(&sb);
+  for(i=0; i<p->nMatch; i++){
+    struct snippetMatch *pMatch = &p->aMatch[i];
+    if( pMatch->iTerm>=0 ){
+      /* If snippetMatch.iTerm is less than 0, then the match was 
+      ** discarded as part of processing the NEAR operator (see the 
+      ** trimSnippetOffsetsForNear() function for details). Ignore 
+      ** it in this case
+      */
+      zBuf[0] = ' ';
+      sprintf(&zBuf[cnt>0], "%d %d %d %d", pMatch->iCol,
+          pMatch->iTerm, pMatch->iStart, pMatch->nByte);
+      append(&sb, zBuf);
+      cnt++;
+    }
+  }
+  p->zOffset = stringBufferData(&sb);
+  p->nOffset = stringBufferLength(&sb);
+}
+
+/*
+** zDoc[0..nDoc-1] is phrase of text.  aMatch[0..nMatch-1] are a set
+** of matching words some of which might be in zDoc.  zDoc is column
+** number iCol.
+**
+** iBreak is suggested spot in zDoc where we could begin or end an
+** excerpt.  Return a value similar to iBreak but possibly adjusted
+** to be a little left or right so that the break point is better.
+*/
+static int wordBoundary(
+  int iBreak,                   /* The suggested break point */
+  const char *zDoc,             /* Document text */
+  int nDoc,                     /* Number of bytes in zDoc[] */
+  struct snippetMatch *aMatch,  /* Matching words */
+  int nMatch,                   /* Number of entries in aMatch[] */
+  int iCol                      /* The column number for zDoc[] */
+){
+  int i;
+  if( iBreak<=10 ){
+    return 0;
+  }
+  if( iBreak>=nDoc-10 ){
+    return nDoc;
+  }
+  for(i=0; i<nMatch && aMatch[i].iCol<iCol; i++){}
+  while( i<nMatch && aMatch[i].iStart+aMatch[i].nByte<iBreak ){ i++; }
+  if( i<nMatch ){
+    if( aMatch[i].iStart<iBreak+10 ){
+      return aMatch[i].iStart;
+    }
+    if( i>0 && aMatch[i-1].iStart+aMatch[i-1].nByte>=iBreak ){
+      return aMatch[i-1].iStart;
+    }
+  }
+  for(i=1; i<=10; i++){
+    if( safe_isspace(zDoc[iBreak-i]) ){
+      return iBreak - i + 1;
+    }
+    if( safe_isspace(zDoc[iBreak+i]) ){
+      return iBreak + i + 1;
+    }
+  }
+  return iBreak;
+}
+
+
+
+/*
+** Allowed values for Snippet.aMatch[].snStatus
+*/
+#define SNIPPET_IGNORE  0   /* It is ok to omit this match from the snippet */
+#define SNIPPET_DESIRED 1   /* We want to include this match in the snippet */
+
+/*
+** Generate the text of a snippet.
+*/
+static void snippetText(
+  fulltext_cursor *pCursor,   /* The cursor we need the snippet for */
+  const char *zStartMark,     /* Markup to appear before each match */
+  const char *zEndMark,       /* Markup to appear after each match */
+  const char *zEllipsis       /* Ellipsis mark */
+){
+  int i, j;
+  struct snippetMatch *aMatch;
+  int nMatch;
+  int nDesired;
+  StringBuffer sb;
+  int tailCol;
+  int tailOffset;
+  int iCol;
+  int nDoc;
+  const char *zDoc;
+  int iStart, iEnd;
+  int tailEllipsis = 0;
+  int iMatch;
+  
+
+  sqlite3_free(pCursor->snippet.zSnippet);
+  pCursor->snippet.zSnippet = 0;
+  aMatch = pCursor->snippet.aMatch;
+  nMatch = pCursor->snippet.nMatch;
+  initStringBuffer(&sb);
+
+  for(i=0; i<nMatch; i++){
+    aMatch[i].snStatus = SNIPPET_IGNORE;
+  }
+  nDesired = 0;
+  for(i=0; i<pCursor->q.nTerms; i++){
+    for(j=0; j<nMatch; j++){
+      if( aMatch[j].iTerm==i ){
+        aMatch[j].snStatus = SNIPPET_DESIRED;
+        nDesired++;
+        break;
+      }
+    }
+  }
+
+  iMatch = 0;
+  tailCol = -1;
+  tailOffset = 0;
+  for(i=0; i<nMatch && nDesired>0; i++){
+    if( aMatch[i].snStatus!=SNIPPET_DESIRED ) continue;
+    nDesired--;
+    iCol = aMatch[i].iCol;
+    zDoc = (const char*)sqlite3_column_text(pCursor->pStmt, iCol+1);
+    nDoc = sqlite3_column_bytes(pCursor->pStmt, iCol+1);
+    iStart = aMatch[i].iStart - 40;
+    iStart = wordBoundary(iStart, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iStart<=10 ){
+      iStart = 0;
+    }
+    if( iCol==tailCol && iStart<=tailOffset+20 ){
+      iStart = tailOffset;
+    }
+    if( (iCol!=tailCol && tailCol>=0) || iStart!=tailOffset ){
+      trimWhiteSpace(&sb);
+      appendWhiteSpace(&sb);
+      append(&sb, zEllipsis);
+      appendWhiteSpace(&sb);
+    }
+    iEnd = aMatch[i].iStart + aMatch[i].nByte + 40;
+    iEnd = wordBoundary(iEnd, zDoc, nDoc, aMatch, nMatch, iCol);
+    if( iEnd>=nDoc-10 ){
+      iEnd = nDoc;
+      tailEllipsis = 0;
+    }else{
+      tailEllipsis = 1;
+    }
+    while( iMatch<nMatch && aMatch[iMatch].iCol<iCol ){ iMatch++; }
+    while( iStart<iEnd ){
+      while( iMatch<nMatch && aMatch[iMatch].iStart<iStart
+             && aMatch[iMatch].iCol<=iCol ){
+        iMatch++;
+      }
+      if( iMatch<nMatch && aMatch[iMatch].iStart<iEnd
+             && aMatch[iMatch].iCol==iCol ){
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].iStart - iStart);
+        iStart = aMatch[iMatch].iStart;
+        append(&sb, zStartMark);
+        nappend(&sb, &zDoc[iStart], aMatch[iMatch].nByte);
+        append(&sb, zEndMark);
+        iStart += aMatch[iMatch].nByte;
+        for(j=iMatch+1; j<nMatch; j++){
+          if( aMatch[j].iTerm==aMatch[iMatch].iTerm
+              && aMatch[j].snStatus==SNIPPET_DESIRED ){
+            nDesired--;
+            aMatch[j].snStatus = SNIPPET_IGNORE;
+          }
+        }
+      }else{
+        nappend(&sb, &zDoc[iStart], iEnd - iStart);
+        iStart = iEnd;
+      }
+    }
+    tailCol = iCol;
+    tailOffset = iEnd;
+  }
+  trimWhiteSpace(&sb);
+  if( tailEllipsis ){
+    appendWhiteSpace(&sb);
+    append(&sb, zEllipsis);
+  }
+  pCursor->snippet.zSnippet = stringBufferData(&sb);
+  pCursor->snippet.nSnippet = stringBufferLength(&sb);
+}
+
+
+/*
+** Close the cursor.  For additional information see the documentation
+** on the xClose method of the virtual table interface.
+*/
+static int fulltextClose(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  FTSTRACE(("FTS3 Close %p\n", c));
+  sqlite3_finalize(c->pStmt);
+  queryClear(&c->q);
+  snippetClear(&c->snippet);
+  if( c->result.nData!=0 ) dlrDestroy(&c->reader);
+  dataBufferDestroy(&c->result);
+  sqlite3_free(c);
+  return SQLITE_OK;
+}
+
+static int fulltextNext(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  int rc;
+
+  FTSTRACE(("FTS3 Next %p\n", pCursor));
+  snippetClear(&c->snippet);
+  if( c->iCursorType < QUERY_FULLTEXT ){
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    switch( rc ){
+      case SQLITE_ROW:
+        c->eof = 0;
+        return SQLITE_OK;
+      case SQLITE_DONE:
+        c->eof = 1;
+        return SQLITE_OK;
+      default:
+        c->eof = 1;
+        return rc;
+    }
+  } else {  /* full-text query */
+    rc = sqlite3_reset(c->pStmt);
+    if( rc!=SQLITE_OK ) return rc;
+
+    if( c->result.nData==0 || dlrAtEnd(&c->reader) ){
+      c->eof = 1;
+      return SQLITE_OK;
+    }
+    rc = sqlite3_bind_int64(c->pStmt, 1, dlrDocid(&c->reader));
+    dlrStep(&c->reader);
+    if( rc!=SQLITE_OK ) return rc;
+    /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
+    rc = sqlite3_step(c->pStmt);
+    if( rc==SQLITE_ROW ){   /* the case we expect */
+      c->eof = 0;
+      return SQLITE_OK;
+    }
+    /* an error occurred; abort */
+    return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
+  }
+}
+
+
+/* TODO(shess) If we pushed LeafReader to the top of the file, or to
+** another file, term_select() could be pushed above
+** docListOfTerm().
+*/
+static int termSelect(fulltext_vtab *v, int iColumn,
+                      const char *pTerm, int nTerm, int isPrefix,
+                      DocListType iType, DataBuffer *out);
+
+/* Return a DocList corresponding to the query term *pTerm.  If *pTerm
+** is the first term of a phrase query, go ahead and evaluate the phrase
+** query and return the doclist for the entire phrase query.
+**
+** The resulting DL_DOCIDS doclist is stored in pResult, which is
+** overwritten.
+*/
+static int docListOfTerm(
+  fulltext_vtab *v,    /* The full text index */
+  int iColumn,         /* column to restrict to.  No restriction if >=nColumn */
+  QueryTerm *pQTerm,   /* Term we are looking for, or 1st term of a phrase */
+  DataBuffer *pResult  /* Write the result here */
+){
+  DataBuffer left, right, new;
+  int i, rc;
+
+  /* No phrase search if no position info. */
+  assert( pQTerm->nPhrase==0 || DL_DEFAULT!=DL_DOCIDS );
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&left, 0);
+  rc = termSelect(v, iColumn, pQTerm->pTerm, pQTerm->nTerm, pQTerm->isPrefix,
+                  (0<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS), &left);
+  if( rc ) return rc;
+  for(i=1; i<=pQTerm->nPhrase && left.nData>0; i++){
+    /* If this token is connected to the next by a NEAR operator, and
+    ** the next token is the start of a phrase, then set nPhraseRight
+    ** to the number of tokens in the phrase. Otherwise leave it at 1.
+    */
+    int nPhraseRight = 1;
+    while( (i+nPhraseRight)<=pQTerm->nPhrase 
+        && pQTerm[i+nPhraseRight].nNear==0 
+    ){
+      nPhraseRight++;
+    }
+
+    dataBufferInit(&right, 0);
+    rc = termSelect(v, iColumn, pQTerm[i].pTerm, pQTerm[i].nTerm,
+                    pQTerm[i].isPrefix, DL_POSITIONS, &right);
+    if( rc ){
+      dataBufferDestroy(&left);
+      return rc;
+    }
+    dataBufferInit(&new, 0);
+    docListPhraseMerge(left.pData, left.nData, right.pData, right.nData,
+                       pQTerm[i-1].nNear, pQTerm[i-1].iPhrase + nPhraseRight,
+                       ((i<pQTerm->nPhrase) ? DL_POSITIONS : DL_DOCIDS),
+                       &new);
+    dataBufferDestroy(&left);
+    dataBufferDestroy(&right);
+    left = new;
+  }
+  *pResult = left;
+  return SQLITE_OK;
+}
+
+/* Add a new term pTerm[0..nTerm-1] to the query *q.
+*/
+static void queryAdd(Query *q, const char *pTerm, int nTerm){
+  QueryTerm *t;
+  ++q->nTerms;
+  q->pTerms = sqlite3_realloc(q->pTerms, q->nTerms * sizeof(q->pTerms[0]));
+  if( q->pTerms==0 ){
+    q->nTerms = 0;
+    return;
+  }
+  t = &q->pTerms[q->nTerms - 1];
+  CLEAR(t);
+  t->pTerm = sqlite3_malloc(nTerm+1);
+  memcpy(t->pTerm, pTerm, nTerm);
+  t->pTerm[nTerm] = 0;
+  t->nTerm = nTerm;
+  t->isOr = q->nextIsOr;
+  t->isPrefix = 0;
+  q->nextIsOr = 0;
+  t->iColumn = q->nextColumn;
+  q->nextColumn = q->dfltColumn;
+}
+
+/*
+** Check to see if the string zToken[0...nToken-1] matches any
+** column name in the virtual table.   If it does,
+** return the zero-indexed column number.  If not, return -1.
+*/
+static int checkColumnSpecifier(
+  fulltext_vtab *pVtab,    /* The virtual table */
+  const char *zToken,      /* Text of the token */
+  int nToken               /* Number of characters in the token */
+){
+  int i;
+  for(i=0; i<pVtab->nColumn; i++){
+    if( memcmp(pVtab->azColumn[i], zToken, nToken)==0
+        && pVtab->azColumn[i][nToken]==0 ){
+      return i;
+    }
+  }
+  return -1;
+}
+
+/*
+** Parse the text at pSegment[0..nSegment-1].  Add additional terms
+** to the query being assemblied in pQuery.
+**
+** inPhrase is true if pSegment[0..nSegement-1] is contained within
+** double-quotes.  If inPhrase is true, then the first term
+** is marked with the number of terms in the phrase less one and
+** OR and "-" syntax is ignored.  If inPhrase is false, then every
+** term found is marked with nPhrase=0 and OR and "-" syntax is significant.
+*/
+static int tokenizeSegment(
+  sqlite3_tokenizer *pTokenizer,          /* The tokenizer to use */
+  const char *pSegment, int nSegment,     /* Query expression being parsed */
+  int inPhrase,                           /* True if within "..." */
+  Query *pQuery                           /* Append results here */
+){
+  const sqlite3_tokenizer_module *pModule = pTokenizer->pModule;
+  sqlite3_tokenizer_cursor *pCursor;
+  int firstIndex = pQuery->nTerms;
+  int iCol;
+  int nTerm = 1;
+  
+  int rc = pModule->xOpen(pTokenizer, pSegment, nSegment, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+  pCursor->pTokenizer = pTokenizer;
+
+  while( 1 ){
+    const char *pToken;
+    int nToken, iBegin, iEnd, iPos;
+
+    rc = pModule->xNext(pCursor,
+                        &pToken, &nToken,
+                        &iBegin, &iEnd, &iPos);
+    if( rc!=SQLITE_OK ) break;
+    if( !inPhrase &&
+        pSegment[iEnd]==':' &&
+         (iCol = checkColumnSpecifier(pQuery->pFts, pToken, nToken))>=0 ){
+      pQuery->nextColumn = iCol;
+      continue;
+    }
+    if( !inPhrase && pQuery->nTerms>0 && nToken==2 
+     && pSegment[iBegin+0]=='O'
+     && pSegment[iBegin+1]=='R' 
+    ){
+      pQuery->nextIsOr = 1;
+      continue;
+    }
+    if( !inPhrase && pQuery->nTerms>0 && !pQuery->nextIsOr && nToken==4 
+      && pSegment[iBegin+0]=='N' 
+      && pSegment[iBegin+1]=='E' 
+      && pSegment[iBegin+2]=='A' 
+      && pSegment[iBegin+3]=='R' 
+    ){
+      QueryTerm *pTerm = &pQuery->pTerms[pQuery->nTerms-1];
+      if( (iBegin+6)<nSegment 
+       && pSegment[iBegin+4] == '/'
+       && pSegment[iBegin+5]>='0' && pSegment[iBegin+5]<='9'
+      ){
+        pTerm->nNear = (pSegment[iBegin+5] - '0');
+        nToken += 2;
+        if( pSegment[iBegin+6]>='0' && pSegment[iBegin+6]<=9 ){
+          pTerm->nNear = pTerm->nNear * 10 + (pSegment[iBegin+6] - '0');
+          iEnd++;
+        }
+        pModule->xNext(pCursor, &pToken, &nToken, &iBegin, &iEnd, &iPos);
+      } else {
+        pTerm->nNear = SQLITE_FTS3_DEFAULT_NEAR_PARAM;
+      }
+      pTerm->nNear++;
+      continue;
+    }
+
+    queryAdd(pQuery, pToken, nToken);
+    if( !inPhrase && iBegin>0 && pSegment[iBegin-1]=='-' ){
+      pQuery->pTerms[pQuery->nTerms-1].isNot = 1;
+    }
+    if( iEnd<nSegment && pSegment[iEnd]=='*' ){
+      pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
+    }
+    pQuery->pTerms[pQuery->nTerms-1].iPhrase = nTerm;
+    if( inPhrase ){
+      nTerm++;
+    }
+  }
+
+  if( inPhrase && pQuery->nTerms>firstIndex ){
+    pQuery->pTerms[firstIndex].nPhrase = pQuery->nTerms - firstIndex - 1;
+  }
+
+  return pModule->xClose(pCursor);
+}
+
+/* Parse a query string, yielding a Query object pQuery.
+**
+** The calling function will need to queryClear() to clean up
+** the dynamically allocated memory held by pQuery.
+*/
+static int parseQuery(
+  fulltext_vtab *v,        /* The fulltext index */
+  const char *zInput,      /* Input text of the query string */
+  int nInput,              /* Size of the input text */
+  int dfltColumn,          /* Default column of the index to match against */
+  Query *pQuery            /* Write the parse results here. */
+){
+  int iInput, inPhrase = 0;
+  int ii;
+  QueryTerm *aTerm;
+
+  if( zInput==0 ) nInput = 0;
+  if( nInput<0 ) nInput = strlen(zInput);
+  pQuery->nTerms = 0;
+  pQuery->pTerms = NULL;
+  pQuery->nextIsOr = 0;
+  pQuery->nextColumn = dfltColumn;
+  pQuery->dfltColumn = dfltColumn;
+  pQuery->pFts = v;
+
+  for(iInput=0; iInput<nInput; ++iInput){
+    int i;
+    for(i=iInput; i<nInput && zInput[i]!='"'; ++i){}
+    if( i>iInput ){
+      tokenizeSegment(v->pTokenizer, zInput+iInput, i-iInput, inPhrase,
+                       pQuery);
+    }
+    iInput = i;
+    if( i<nInput ){
+      assert( zInput[i]=='"' );
+      inPhrase = !inPhrase;
+    }
+  }
+
+  if( inPhrase ){
+    /* unmatched quote */
+    queryClear(pQuery);
+    return SQLITE_ERROR;
+  }
+
+  /* Modify the values of the QueryTerm.nPhrase variables to account for
+  ** the NEAR operator. For the purposes of QueryTerm.nPhrase, phrases
+  ** and tokens connected by the NEAR operator are handled as a single
+  ** phrase. See comments above the QueryTerm structure for details.
+  */
+  aTerm = pQuery->pTerms;
+  for(ii=0; ii<pQuery->nTerms; ii++){
+    if( aTerm[ii].nNear || aTerm[ii].nPhrase ){
+      while (aTerm[ii+aTerm[ii].nPhrase].nNear) {
+        aTerm[ii].nPhrase += (1 + aTerm[ii+aTerm[ii].nPhrase+1].nPhrase);
+      }
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+/* TODO(shess) Refactor the code to remove this forward decl. */
+static int flushPendingTerms(fulltext_vtab *v);
+
+/* Perform a full-text query using the search expression in
+** zInput[0..nInput-1].  Return a list of matching documents
+** in pResult.
+**
+** Queries must match column iColumn.  Or if iColumn>=nColumn
+** they are allowed to match against any column.
+*/
+static int fulltextQuery(
+  fulltext_vtab *v,      /* The full text index */
+  int iColumn,           /* Match against this column by default */
+  const char *zInput,    /* The query string */
+  int nInput,            /* Number of bytes in zInput[] */
+  DataBuffer *pResult,   /* Write the result doclist here */
+  Query *pQuery          /* Put parsed query string here */
+){
+  int i, iNext, rc;
+  DataBuffer left, right, or, new;
+  int nNot = 0;
+  QueryTerm *aTerm;
+
+  /* TODO(shess) Instead of flushing pendingTerms, we could query for
+  ** the relevant term and merge the doclist into what we receive from
+  ** the database.  Wait and see if this is a common issue, first.
+  **
+  ** A good reason not to flush is to not generate update-related
+  ** error codes from here.
+  */
+
+  /* Flush any buffered updates before executing the query. */
+  rc = flushPendingTerms(v);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* TODO(shess) I think that the queryClear() calls below are not
+  ** necessary, because fulltextClose() already clears the query.
+  */
+  rc = parseQuery(v, zInput, nInput, iColumn, pQuery);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Empty or NULL queries return no results. */
+  if( pQuery->nTerms==0 ){
+    dataBufferInit(pResult, 0);
+    return SQLITE_OK;
+  }
+
+  /* Merge AND terms. */
+  /* TODO(shess) I think we can early-exit if( i>nNot && left.nData==0 ). */
+  aTerm = pQuery->pTerms;
+  for(i = 0; i<pQuery->nTerms; i=iNext){
+    if( aTerm[i].isNot ){
+      /* Handle all NOT terms in a separate pass */
+      nNot++;
+      iNext = i + aTerm[i].nPhrase+1;
+      continue;
+    }
+    iNext = i + aTerm[i].nPhrase + 1;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &right);
+    if( rc ){
+      if( i!=nNot ) dataBufferDestroy(&left);
+      queryClear(pQuery);
+      return rc;
+    }
+    while( iNext<pQuery->nTerms && aTerm[iNext].isOr ){
+      rc = docListOfTerm(v, aTerm[iNext].iColumn, &aTerm[iNext], &or);
+      iNext += aTerm[iNext].nPhrase + 1;
+      if( rc ){
+        if( i!=nNot ) dataBufferDestroy(&left);
+        dataBufferDestroy(&right);
+        queryClear(pQuery);
+        return rc;
+      }
+      dataBufferInit(&new, 0);
+      docListOrMerge(right.pData, right.nData, or.pData, or.nData, &new);
+      dataBufferDestroy(&right);
+      dataBufferDestroy(&or);
+      right = new;
+    }
+    if( i==nNot ){           /* first term processed. */
+      left = right;
+    }else{
+      dataBufferInit(&new, 0);
+      docListAndMerge(left.pData, left.nData, right.pData, right.nData, &new);
+      dataBufferDestroy(&right);
+      dataBufferDestroy(&left);
+      left = new;
+    }
+  }
+
+  if( nNot==pQuery->nTerms ){
+    /* We do not yet know how to handle a query of only NOT terms */
+    return SQLITE_ERROR;
+  }
+
+  /* Do the EXCEPT terms */
+  for(i=0; i<pQuery->nTerms;  i += aTerm[i].nPhrase + 1){
+    if( !aTerm[i].isNot ) continue;
+    rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &right);
+    if( rc ){
+      queryClear(pQuery);
+      dataBufferDestroy(&left);
+      return rc;
+    }
+    dataBufferInit(&new, 0);
+    docListExceptMerge(left.pData, left.nData, right.pData, right.nData, &new);
+    dataBufferDestroy(&right);
+    dataBufferDestroy(&left);
+    left = new;
+  }
+
+  *pResult = left;
+  return rc;
+}
+
+/*
+** This is the xFilter interface for the virtual table.  See
+** the virtual table xFilter method documentation for additional
+** information.
+**
+** If idxNum==QUERY_GENERIC then do a full table scan against
+** the %_content table.
+**
+** If idxNum==QUERY_DOCID then do a docid lookup for a single entry
+** in the %_content table.
+**
+** If idxNum>=QUERY_FULLTEXT then use the full text index.  The
+** column on the left-hand side of the MATCH operator is column
+** number idxNum-QUERY_FULLTEXT, 0 indexed.  argv[0] is the right-hand
+** side of the MATCH operator.
+*/
+/* TODO(shess) Upgrade the cursor initialization and destruction to
+** account for fulltextFilter() being called multiple times on the
+** same cursor.  The current solution is very fragile.  Apply fix to
+** fts3 as appropriate.
+*/
+static int fulltextFilter(
+  sqlite3_vtab_cursor *pCursor,     /* The cursor used for this query */
+  int idxNum, const char *idxStr,   /* Which indexing scheme to use */
+  int argc, sqlite3_value **argv    /* Arguments for the indexing scheme */
+){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+  int rc;
+  StringBuffer sb;
+
+  FTSTRACE(("FTS3 Filter %p\n",pCursor));
+
+  initStringBuffer(&sb);
+  append(&sb, "SELECT docid, ");
+  appendList(&sb, v->nColumn, v->azContentColumn);
+  append(&sb, " FROM %_content");
+  if( idxNum!=QUERY_GENERIC ) append(&sb, " WHERE docid = ?");
+  sqlite3_finalize(c->pStmt);
+  rc = sql_prepare(v->db, v->zDb, v->zName, &c->pStmt, stringBufferData(&sb));
+  stringBufferDestroy(&sb);
+  if( rc!=SQLITE_OK ) return rc;
+
+  c->iCursorType = idxNum;
+  switch( idxNum ){
+    case QUERY_GENERIC:
+      break;
+
+    case QUERY_DOCID:
+      rc = sqlite3_bind_int64(c->pStmt, 1, sqlite3_value_int64(argv[0]));
+      if( rc!=SQLITE_OK ) return rc;
+      break;
+
+    default:   /* full-text search */
+    {
+      const char *zQuery = (const char *)sqlite3_value_text(argv[0]);
+      assert( idxNum<=QUERY_FULLTEXT+v->nColumn);
+      assert( argc==1 );
+      queryClear(&c->q);
+      if( c->result.nData!=0 ){
+        /* This case happens if the same cursor is used repeatedly. */
+        dlrDestroy(&c->reader);
+        dataBufferReset(&c->result);
+      }else{
+        dataBufferInit(&c->result, 0);
+      }
+      rc = fulltextQuery(v, idxNum-QUERY_FULLTEXT, zQuery, -1, &c->result, &c->q);
+      if( rc!=SQLITE_OK ) return rc;
+      if( c->result.nData!=0 ){
+        dlrInit(&c->reader, DL_DOCIDS, c->result.pData, c->result.nData);
+      }
+      break;
+    }
+  }
+
+  return fulltextNext(pCursor);
+}
+
+/* This is the xEof method of the virtual table.  The SQLite core
+** calls this routine to find out if it has reached the end of
+** a query's results set.
+*/
+static int fulltextEof(sqlite3_vtab_cursor *pCursor){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  return c->eof;
+}
+
+/* This is the xColumn method of the virtual table.  The SQLite
+** core calls this method during a query when it needs the value
+** of a column from the virtual table.  This method needs to use
+** one of the sqlite3_result_*() routines to store the requested
+** value back in the pContext.
+*/
+static int fulltextColumn(sqlite3_vtab_cursor *pCursor,
+                          sqlite3_context *pContext, int idxCol){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+  fulltext_vtab *v = cursor_vtab(c);
+
+  if( idxCol<v->nColumn ){
+    sqlite3_value *pVal = sqlite3_column_value(c->pStmt, idxCol+1);
+    sqlite3_result_value(pContext, pVal);
+  }else if( idxCol==v->nColumn ){
+    /* The extra column whose name is the same as the table.
+    ** Return a blob which is a pointer to the cursor
+    */
+    sqlite3_result_blob(pContext, &c, sizeof(c), SQLITE_TRANSIENT);
+  }else if( idxCol==v->nColumn+1 ){
+    /* The docid column, which is an alias for rowid. */
+    sqlite3_value *pVal = sqlite3_column_value(c->pStmt, 0);
+    sqlite3_result_value(pContext, pVal);
+  }
+  return SQLITE_OK;
+}
+
+/* This is the xRowid method.  The SQLite core calls this routine to
+** retrieve the rowid for the current row of the result set.  fts3
+** exposes %_content.docid as the rowid for the virtual table.  The
+** rowid should be written to *pRowid.
+*/
+static int fulltextRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
+  fulltext_cursor *c = (fulltext_cursor *) pCursor;
+
+  *pRowid = sqlite3_column_int64(c->pStmt, 0);
+  return SQLITE_OK;
+}
+
+/* Add all terms in [zText] to pendingTerms table.  If [iColumn] > 0,
+** we also store positions and offsets in the hash table using that
+** column number.
+*/
+static int buildTerms(fulltext_vtab *v, sqlite_int64 iDocid,
+                      const char *zText, int iColumn){
+  sqlite3_tokenizer *pTokenizer = v->pTokenizer;
+  sqlite3_tokenizer_cursor *pCursor;
+  const char *pToken;
+  int nTokenBytes;
+  int iStartOffset, iEndOffset, iPosition;
+  int rc;
+
+  rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
+  if( rc!=SQLITE_OK ) return rc;
+
+  pCursor->pTokenizer = pTokenizer;
+  while( SQLITE_OK==(rc=pTokenizer->pModule->xNext(pCursor,
+                                                   &pToken, &nTokenBytes,
+                                                   &iStartOffset, &iEndOffset,
+                                                   &iPosition)) ){
+    DLCollector *p;
+    int nData;                   /* Size of doclist before our update. */
+
+    /* Positions can't be negative; we use -1 as a terminator
+     * internally.  Token can't be NULL or empty. */
+    if( iPosition<0 || pToken == NULL || nTokenBytes == 0 ){
+      rc = SQLITE_ERROR;
+      break;
+    }
+
+    p = fts3HashFind(&v->pendingTerms, pToken, nTokenBytes);
+    if( p==NULL ){
+      nData = 0;
+      p = dlcNew(iDocid, DL_DEFAULT);
+      fts3HashInsert(&v->pendingTerms, pToken, nTokenBytes, p);
+
+      /* Overhead for our hash table entry, the key, and the value. */
+      v->nPendingData += sizeof(struct fts3HashElem)+sizeof(*p)+nTokenBytes;
+    }else{
+      nData = p->b.nData;
+      if( p->dlw.iPrevDocid!=iDocid ) dlcNext(p, iDocid);
+    }
+    if( iColumn>=0 ){
+      dlcAddPos(p, iColumn, iPosition, iStartOffset, iEndOffset);
+    }
+
+    /* Accumulate data added by dlcNew or dlcNext, and dlcAddPos. */
+    v->nPendingData += p->b.nData-nData;
+  }
+
+  /* TODO(shess) Check return?  Should this be able to cause errors at
+  ** this point?  Actually, same question about sqlite3_finalize(),
+  ** though one could argue that failure there means that the data is
+  ** not durable.  *ponder*
+  */
+  pTokenizer->pModule->xClose(pCursor);
+  if( SQLITE_DONE == rc ) return SQLITE_OK;
+  return rc;
+}
+
+/* Add doclists for all terms in [pValues] to pendingTerms table. */
+static int insertTerms(fulltext_vtab *v, sqlite_int64 iDocid,
+                       sqlite3_value **pValues){
+  int i;
+  for(i = 0; i < v->nColumn ; ++i){
+    char *zText = (char*)sqlite3_value_text(pValues[i]);
+    int rc = buildTerms(v, iDocid, zText, i);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Add empty doclists for all terms in the given row's content to
+** pendingTerms.
+*/
+static int deleteTerms(fulltext_vtab *v, sqlite_int64 iDocid){
+  const char **pValues;
+  int i, rc;
+
+  /* TODO(shess) Should we allow such tables at all? */
+  if( DL_DEFAULT==DL_DOCIDS ) return SQLITE_ERROR;
+
+  rc = content_select(v, iDocid, &pValues);
+  if( rc!=SQLITE_OK ) return rc;
+
+  for(i = 0 ; i < v->nColumn; ++i) {
+    rc = buildTerms(v, iDocid, pValues[i], -1);
+    if( rc!=SQLITE_OK ) break;
+  }
+
+  freeStringArray(v->nColumn, pValues);
+  return SQLITE_OK;
+}
+
+/* TODO(shess) Refactor the code to remove this forward decl. */
+static int initPendingTerms(fulltext_vtab *v, sqlite_int64 iDocid);
+
+/* Insert a row into the %_content table; set *piDocid to be the ID of the
+** new row.  Add doclists for terms to pendingTerms.
+*/
+static int index_insert(fulltext_vtab *v, sqlite3_value *pRequestDocid,
+                        sqlite3_value **pValues, sqlite_int64 *piDocid){
+  int rc;
+
+  rc = content_insert(v, pRequestDocid, pValues);  /* execute an SQL INSERT */
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* docid column is an alias for rowid. */
+  *piDocid = sqlite3_last_insert_rowid(v->db);
+  rc = initPendingTerms(v, *piDocid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return insertTerms(v, *piDocid, pValues);
+}
+
+/* Delete a row from the %_content table; add empty doclists for terms
+** to pendingTerms.
+*/
+static int index_delete(fulltext_vtab *v, sqlite_int64 iRow){
+  int rc = initPendingTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = deleteTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  return content_delete(v, iRow);  /* execute an SQL DELETE */
+}
+
+/* Update a row in the %_content table; add delete doclists to
+** pendingTerms for old terms not in the new data, add insert doclists
+** to pendingTerms for terms in the new data.
+*/
+static int index_update(fulltext_vtab *v, sqlite_int64 iRow,
+                        sqlite3_value **pValues){
+  int rc = initPendingTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Generate an empty doclist for each term that previously appeared in this
+   * row. */
+  rc = deleteTerms(v, iRow);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = content_update(v, pValues, iRow);  /* execute an SQL UPDATE */
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Now add positions for terms which appear in the updated row. */
+  return insertTerms(v, iRow, pValues);
+}
+
+/*******************************************************************/
+/* InteriorWriter is used to collect terms and block references into
+** interior nodes in %_segments.  See commentary at top of file for
+** format.
+*/
+
+/* How large interior nodes can grow. */
+#define INTERIOR_MAX 2048
+
+/* Minimum number of terms per interior node (except the root). This
+** prevents large terms from making the tree too skinny - must be >0
+** so that the tree always makes progress.  Note that the min tree
+** fanout will be INTERIOR_MIN_TERMS+1.
+*/
+#define INTERIOR_MIN_TERMS 7
+#if INTERIOR_MIN_TERMS<1
+# error INTERIOR_MIN_TERMS must be greater than 0.
+#endif
+
+/* ROOT_MAX controls how much data is stored inline in the segment
+** directory.
+*/
+/* TODO(shess) Push ROOT_MAX down to whoever is writing things.  It's
+** only here so that interiorWriterRootInfo() and leafWriterRootInfo()
+** can both see it, but if the caller passed it in, we wouldn't even
+** need a define.
+*/
+#define ROOT_MAX 1024
+#if ROOT_MAX<VARINT_MAX*2
+# error ROOT_MAX must have enough space for a header.
+#endif
+
+/* InteriorBlock stores a linked-list of interior blocks while a lower
+** layer is being constructed.
+*/
+typedef struct InteriorBlock {
+  DataBuffer term;           /* Leftmost term in block's subtree. */
+  DataBuffer data;           /* Accumulated data for the block. */
+  struct InteriorBlock *next;
+} InteriorBlock;
+
+static InteriorBlock *interiorBlockNew(int iHeight, sqlite_int64 iChildBlock,
+                                       const char *pTerm, int nTerm){
+  InteriorBlock *block = sqlite3_malloc(sizeof(InteriorBlock));
+  char c[VARINT_MAX+VARINT_MAX];
+  int n;
+
+  if( block ){
+    memset(block, 0, sizeof(*block));
+    dataBufferInit(&block->term, 0);
+    dataBufferReplace(&block->term, pTerm, nTerm);
+
+    n = fts3PutVarint(c, iHeight);
+    n += fts3PutVarint(c+n, iChildBlock);
+    dataBufferInit(&block->data, INTERIOR_MAX);
+    dataBufferReplace(&block->data, c, n);
+  }
+  return block;
+}
+
+#ifndef NDEBUG
+/* Verify that the data is readable as an interior node. */
+static void interiorBlockValidate(InteriorBlock *pBlock){
+  const char *pData = pBlock->data.pData;
+  int nData = pBlock->data.nData;
+  int n, iDummy;
+  sqlite_int64 iBlockid;
+
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+
+  /* Must lead with height of node as a varint(n), n>0 */
+  n = fts3GetVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n<nData );
+  pData += n;
+  nData -= n;
+
+  /* Must contain iBlockid. */
+  n = fts3GetVarint(pData, &iBlockid);
+  assert( n>0 );
+  assert( n<=nData );
+  pData += n;
+  nData -= n;
+
+  /* Zero or more terms of positive length */
+  if( nData!=0 ){
+    /* First term is not delta-encoded. */
+    n = fts3GetVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0);
+    assert( n+iDummy<=nData );
+    pData += n+iDummy;
+    nData -= n+iDummy;
+
+    /* Following terms delta-encoded. */
+    while( nData!=0 ){
+      /* Length of shared prefix. */
+      n = fts3GetVarint32(pData, &iDummy);
+      assert( n>0 );
+      assert( iDummy>=0 );
+      assert( n<nData );
+      pData += n;
+      nData -= n;
+
+      /* Length and data of distinct suffix. */
+      n = fts3GetVarint32(pData, &iDummy);
+      assert( n>0 );
+      assert( iDummy>0 );
+      assert( n+iDummy>0);
+      assert( n+iDummy<=nData );
+      pData += n+iDummy;
+      nData -= n+iDummy;
+    }
+  }
+}
+#define ASSERT_VALID_INTERIOR_BLOCK(x) interiorBlockValidate(x)
+#else
+#define ASSERT_VALID_INTERIOR_BLOCK(x) assert( 1 )
+#endif
+
+typedef struct InteriorWriter {
+  int iHeight;                   /* from 0 at leaves. */
+  InteriorBlock *first, *last;
+  struct InteriorWriter *parentWriter;
+
+  DataBuffer term;               /* Last term written to block "last". */
+  sqlite_int64 iOpeningChildBlock; /* First child block in block "last". */
+#ifndef NDEBUG
+  sqlite_int64 iLastChildBlock;  /* for consistency checks. */
+#endif
+} InteriorWriter;
+
+/* Initialize an interior node where pTerm[nTerm] marks the leftmost
+** term in the tree.  iChildBlock is the leftmost child block at the
+** next level down the tree.
+*/
+static void interiorWriterInit(int iHeight, const char *pTerm, int nTerm,
+                               sqlite_int64 iChildBlock,
+                               InteriorWriter *pWriter){
+  InteriorBlock *block;
+  assert( iHeight>0 );
+  CLEAR(pWriter);
+
+  pWriter->iHeight = iHeight;
+  pWriter->iOpeningChildBlock = iChildBlock;
+#ifndef NDEBUG
+  pWriter->iLastChildBlock = iChildBlock;
+#endif
+  block = interiorBlockNew(iHeight, iChildBlock, pTerm, nTerm);
+  pWriter->last = pWriter->first = block;
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+  dataBufferInit(&pWriter->term, 0);
+}
+
+/* Append the child node rooted at iChildBlock to the interior node,
+** with pTerm[nTerm] as the leftmost term in iChildBlock's subtree.
+*/
+static void interiorWriterAppend(InteriorWriter *pWriter,
+                                 const char *pTerm, int nTerm,
+                                 sqlite_int64 iChildBlock){
+  char c[VARINT_MAX+VARINT_MAX];
+  int n, nPrefix = 0;
+
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+
+  /* The first term written into an interior node is actually
+  ** associated with the second child added (the first child was added
+  ** in interiorWriterInit, or in the if clause at the bottom of this
+  ** function).  That term gets encoded straight up, with nPrefix left
+  ** at 0.
+  */
+  if( pWriter->term.nData==0 ){
+    n = fts3PutVarint(c, nTerm);
+  }else{
+    while( nPrefix<pWriter->term.nData &&
+           pTerm[nPrefix]==pWriter->term.pData[nPrefix] ){
+      nPrefix++;
+    }
+
+    n = fts3PutVarint(c, nPrefix);
+    n += fts3PutVarint(c+n, nTerm-nPrefix);
+  }
+
+#ifndef NDEBUG
+  pWriter->iLastChildBlock++;
+#endif
+  assert( pWriter->iLastChildBlock==iChildBlock );
+
+  /* Overflow to a new block if the new term makes the current block
+  ** too big, and the current block already has enough terms.
+  */
+  if( pWriter->last->data.nData+n+nTerm-nPrefix>INTERIOR_MAX &&
+      iChildBlock-pWriter->iOpeningChildBlock>INTERIOR_MIN_TERMS ){
+    pWriter->last->next = interiorBlockNew(pWriter->iHeight, iChildBlock,
+                                           pTerm, nTerm);
+    pWriter->last = pWriter->last->next;
+    pWriter->iOpeningChildBlock = iChildBlock;
+    dataBufferReset(&pWriter->term);
+  }else{
+    dataBufferAppend2(&pWriter->last->data, c, n,
+                      pTerm+nPrefix, nTerm-nPrefix);
+    dataBufferReplace(&pWriter->term, pTerm, nTerm);
+  }
+  ASSERT_VALID_INTERIOR_BLOCK(pWriter->last);
+}
+
+/* Free the space used by pWriter, including the linked-list of
+** InteriorBlocks, and parentWriter, if present.
+*/
+static int interiorWriterDestroy(InteriorWriter *pWriter){
+  InteriorBlock *block = pWriter->first;
+
+  while( block!=NULL ){
+    InteriorBlock *b = block;
+    block = block->next;
+    dataBufferDestroy(&b->term);
+    dataBufferDestroy(&b->data);
+    sqlite3_free(b);
+  }
+  if( pWriter->parentWriter!=NULL ){
+    interiorWriterDestroy(pWriter->parentWriter);
+    sqlite3_free(pWriter->parentWriter);
+  }
+  dataBufferDestroy(&pWriter->term);
+  SCRAMBLE(pWriter);
+  return SQLITE_OK;
+}
+
+/* If pWriter can fit entirely in ROOT_MAX, return it as the root info
+** directly, leaving *piEndBlockid unchanged.  Otherwise, flush
+** pWriter to %_segments, building a new layer of interior nodes, and
+** recursively ask for their root into.
+*/
+static int interiorWriterRootInfo(fulltext_vtab *v, InteriorWriter *pWriter,
+                                  char **ppRootInfo, int *pnRootInfo,
+                                  sqlite_int64 *piEndBlockid){
+  InteriorBlock *block = pWriter->first;
+  sqlite_int64 iBlockid = 0;
+  int rc;
+
+  /* If we can fit the segment inline */
+  if( block==pWriter->last && block->data.nData<ROOT_MAX ){
+    *ppRootInfo = block->data.pData;
+    *pnRootInfo = block->data.nData;
+    return SQLITE_OK;
+  }
+
+  /* Flush the first block to %_segments, and create a new level of
+  ** interior node.
+  */
+  ASSERT_VALID_INTERIOR_BLOCK(block);
+  rc = block_insert(v, block->data.pData, block->data.nData, &iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+  *piEndBlockid = iBlockid;
+
+  pWriter->parentWriter = sqlite3_malloc(sizeof(*pWriter->parentWriter));
+  interiorWriterInit(pWriter->iHeight+1,
+                     block->term.pData, block->term.nData,
+                     iBlockid, pWriter->parentWriter);
+
+  /* Flush additional blocks and append to the higher interior
+  ** node.
+  */
+  for(block=block->next; block!=NULL; block=block->next){
+    ASSERT_VALID_INTERIOR_BLOCK(block);
+    rc = block_insert(v, block->data.pData, block->data.nData, &iBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+    *piEndBlockid = iBlockid;
+
+    interiorWriterAppend(pWriter->parentWriter,
+                         block->term.pData, block->term.nData, iBlockid);
+  }
+
+  /* Parent node gets the chance to be the root. */
+  return interiorWriterRootInfo(v, pWriter->parentWriter,
+                                ppRootInfo, pnRootInfo, piEndBlockid);
+}
+
+/****************************************************************/
+/* InteriorReader is used to read off the data from an interior node
+** (see comment at top of file for the format).
+*/
+typedef struct InteriorReader {
+  const char *pData;
+  int nData;
+
+  DataBuffer term;          /* previous term, for decoding term delta. */
+
+  sqlite_int64 iBlockid;
+} InteriorReader;
+
+static void interiorReaderDestroy(InteriorReader *pReader){
+  dataBufferDestroy(&pReader->term);
+  SCRAMBLE(pReader);
+}
+
+/* TODO(shess) The assertions are great, but what if we're in NDEBUG
+** and the blob is empty or otherwise contains suspect data?
+*/
+static void interiorReaderInit(const char *pData, int nData,
+                               InteriorReader *pReader){
+  int n, nTerm;
+
+  /* Require at least the leading flag byte */
+  assert( nData>0 );
+  assert( pData[0]!='\0' );
+
+  CLEAR(pReader);
+
+  /* Decode the base blockid, and set the cursor to the first term. */
+  n = fts3GetVarint(pData+1, &pReader->iBlockid);
+  assert( 1+n<=nData );
+  pReader->pData = pData+1+n;
+  pReader->nData = nData-(1+n);
+
+  /* A single-child interior node (such as when a leaf node was too
+  ** large for the segment directory) won't have any terms.
+  ** Otherwise, decode the first term.
+  */
+  if( pReader->nData==0 ){
+    dataBufferInit(&pReader->term, 0);
+  }else{
+    n = fts3GetVarint32(pReader->pData, &nTerm);
+    dataBufferInit(&pReader->term, nTerm);
+    dataBufferReplace(&pReader->term, pReader->pData+n, nTerm);
+    assert( n+nTerm<=pReader->nData );
+    pReader->pData += n+nTerm;
+    pReader->nData -= n+nTerm;
+  }
+}
+
+static int interiorReaderAtEnd(InteriorReader *pReader){
+  return pReader->term.nData==0;
+}
+
+static sqlite_int64 interiorReaderCurrentBlockid(InteriorReader *pReader){
+  return pReader->iBlockid;
+}
+
+static int interiorReaderTermBytes(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+  return pReader->term.nData;
+}
+static const char *interiorReaderTerm(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+  return pReader->term.pData;
+}
+
+/* Step forward to the next term in the node. */
+static void interiorReaderStep(InteriorReader *pReader){
+  assert( !interiorReaderAtEnd(pReader) );
+
+  /* If the last term has been read, signal eof, else construct the
+  ** next term.
+  */
+  if( pReader->nData==0 ){
+    dataBufferReset(&pReader->term);
+  }else{
+    int n, nPrefix, nSuffix;
+
+    n = fts3GetVarint32(pReader->pData, &nPrefix);
+    n += fts3GetVarint32(pReader->pData+n, &nSuffix);
+
+    /* Truncate the current term and append suffix data. */
+    pReader->term.nData = nPrefix;
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
+
+    assert( n+nSuffix<=pReader->nData );
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
+  }
+  pReader->iBlockid++;
+}
+
+/* Compare the current term to pTerm[nTerm], returning strcmp-style
+** results.  If isPrefix, equality means equal through nTerm bytes.
+*/
+static int interiorReaderTermCmp(InteriorReader *pReader,
+                                 const char *pTerm, int nTerm, int isPrefix){
+  const char *pReaderTerm = interiorReaderTerm(pReader);
+  int nReaderTerm = interiorReaderTermBytes(pReader);
+  int c, n = nReaderTerm<nTerm ? nReaderTerm : nTerm;
+
+  if( n==0 ){
+    if( nReaderTerm>0 ) return -1;
+    if( nTerm>0 ) return 1;
+    return 0;
+  }
+
+  c = memcmp(pReaderTerm, pTerm, n);
+  if( c!=0 ) return c;
+  if( isPrefix && n==nTerm ) return 0;
+  return nReaderTerm - nTerm;
+}
+
+/****************************************************************/
+/* LeafWriter is used to collect terms and associated doclist data
+** into leaf blocks in %_segments (see top of file for format info).
+** Expected usage is:
+**
+** LeafWriter writer;
+** leafWriterInit(0, 0, &writer);
+** while( sorted_terms_left_to_process ){
+**   // data is doclist data for that term.
+**   rc = leafWriterStep(v, &writer, pTerm, nTerm, pData, nData);
+**   if( rc!=SQLITE_OK ) goto err;
+** }
+** rc = leafWriterFinalize(v, &writer);
+**err:
+** leafWriterDestroy(&writer);
+** return rc;
+**
+** leafWriterStep() may write a collected leaf out to %_segments.
+** leafWriterFinalize() finishes writing any buffered data and stores
+** a root node in %_segdir.  leafWriterDestroy() frees all buffers and
+** InteriorWriters allocated as part of writing this segment.
+**
+** TODO(shess) Document leafWriterStepMerge().
+*/
+
+/* Put terms with data this big in their own block. */
+#define STANDALONE_MIN 1024
+
+/* Keep leaf blocks below this size. */
+#define LEAF_MAX 2048
+
+typedef struct LeafWriter {
+  int iLevel;
+  int idx;
+  sqlite_int64 iStartBlockid;     /* needed to create the root info */
+  sqlite_int64 iEndBlockid;       /* when we're done writing. */
+
+  DataBuffer term;                /* previous encoded term */
+  DataBuffer data;                /* encoding buffer */
+
+  /* bytes of first term in the current node which distinguishes that
+  ** term from the last term of the previous node.
+  */
+  int nTermDistinct;
+
+  InteriorWriter parentWriter;    /* if we overflow */
+  int has_parent;
+} LeafWriter;
+
+static void leafWriterInit(int iLevel, int idx, LeafWriter *pWriter){
+  CLEAR(pWriter);
+  pWriter->iLevel = iLevel;
+  pWriter->idx = idx;
+
+  dataBufferInit(&pWriter->term, 32);
+
+  /* Start out with a reasonably sized block, though it can grow. */
+  dataBufferInit(&pWriter->data, LEAF_MAX);
+}
+
+#ifndef NDEBUG
+/* Verify that the data is readable as a leaf node. */
+static void leafNodeValidate(const char *pData, int nData){
+  int n, iDummy;
+
+  if( nData==0 ) return;
+  assert( nData>0 );
+  assert( pData!=0 );
+  assert( pData+nData>pData );
+
+  /* Must lead with a varint(0) */
+  n = fts3GetVarint32(pData, &iDummy);
+  assert( iDummy==0 );
+  assert( n>0 );
+  assert( n<nData );
+  pData += n;
+  nData -= n;
+
+  /* Leading term length and data must fit in buffer. */
+  n = fts3GetVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n+iDummy>0 );
+  assert( n+iDummy<nData );
+  pData += n+iDummy;
+  nData -= n+iDummy;
+
+  /* Leading term's doclist length and data must fit. */
+  n = fts3GetVarint32(pData, &iDummy);
+  assert( n>0 );
+  assert( iDummy>0 );
+  assert( n+iDummy>0 );
+  assert( n+iDummy<=nData );
+  ASSERT_VALID_DOCLIST(DL_DEFAULT, pData+n, iDummy, NULL);
+  pData += n+iDummy;
+  nData -= n+iDummy;
+
+  /* Verify that trailing terms and doclists also are readable. */
+  while( nData!=0 ){
+    n = fts3GetVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>=0 );
+    assert( n<nData );
+    pData += n;
+    nData -= n;
+    n = fts3GetVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0 );
+    assert( n+iDummy<nData );
+    pData += n+iDummy;
+    nData -= n+iDummy;
+
+    n = fts3GetVarint32(pData, &iDummy);
+    assert( n>0 );
+    assert( iDummy>0 );
+    assert( n+iDummy>0 );
+    assert( n+iDummy<=nData );
+    ASSERT_VALID_DOCLIST(DL_DEFAULT, pData+n, iDummy, NULL);
+    pData += n+iDummy;
+    nData -= n+iDummy;
+  }
+}
+#define ASSERT_VALID_LEAF_NODE(p, n) leafNodeValidate(p, n)
+#else
+#define ASSERT_VALID_LEAF_NODE(p, n) assert( 1 )
+#endif
+
+/* Flush the current leaf node to %_segments, and adding the resulting
+** blockid and the starting term to the interior node which will
+** contain it.
+*/
+static int leafWriterInternalFlush(fulltext_vtab *v, LeafWriter *pWriter,
+                                   int iData, int nData){
+  sqlite_int64 iBlockid = 0;
+  const char *pStartingTerm;
+  int nStartingTerm, rc, n;
+
+  /* Must have the leading varint(0) flag, plus at least some
+  ** valid-looking data.
+  */
+  assert( nData>2 );
+  assert( iData>=0 );
+  assert( iData+nData<=pWriter->data.nData );
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData+iData, nData);
+
+  rc = block_insert(v, pWriter->data.pData+iData, nData, &iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+  assert( iBlockid!=0 );
+
+  /* Reconstruct the first term in the leaf for purposes of building
+  ** the interior node.
+  */
+  n = fts3GetVarint32(pWriter->data.pData+iData+1, &nStartingTerm);
+  pStartingTerm = pWriter->data.pData+iData+1+n;
+  assert( pWriter->data.nData>iData+1+n+nStartingTerm );
+  assert( pWriter->nTermDistinct>0 );
+  assert( pWriter->nTermDistinct<=nStartingTerm );
+  nStartingTerm = pWriter->nTermDistinct;
+
+  if( pWriter->has_parent ){
+    interiorWriterAppend(&pWriter->parentWriter,
+                         pStartingTerm, nStartingTerm, iBlockid);
+  }else{
+    interiorWriterInit(1, pStartingTerm, nStartingTerm, iBlockid,
+                       &pWriter->parentWriter);
+    pWriter->has_parent = 1;
+  }
+
+  /* Track the span of this segment's leaf nodes. */
+  if( pWriter->iEndBlockid==0 ){
+    pWriter->iEndBlockid = pWriter->iStartBlockid = iBlockid;
+  }else{
+    pWriter->iEndBlockid++;
+    assert( iBlockid==pWriter->iEndBlockid );
+  }
+
+  return SQLITE_OK;
+}
+static int leafWriterFlush(fulltext_vtab *v, LeafWriter *pWriter){
+  int rc = leafWriterInternalFlush(v, pWriter, 0, pWriter->data.nData);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Re-initialize the output buffer. */
+  dataBufferReset(&pWriter->data);
+
+  return SQLITE_OK;
+}
+
+/* Fetch the root info for the segment.  If the entire leaf fits
+** within ROOT_MAX, then it will be returned directly, otherwise it
+** will be flushed and the root info will be returned from the
+** interior node.  *piEndBlockid is set to the blockid of the last
+** interior or leaf node written to disk (0 if none are written at
+** all).
+*/
+static int leafWriterRootInfo(fulltext_vtab *v, LeafWriter *pWriter,
+                              char **ppRootInfo, int *pnRootInfo,
+                              sqlite_int64 *piEndBlockid){
+  /* we can fit the segment entirely inline */
+  if( !pWriter->has_parent && pWriter->data.nData<ROOT_MAX ){
+    *ppRootInfo = pWriter->data.pData;
+    *pnRootInfo = pWriter->data.nData;
+    *piEndBlockid = 0;
+    return SQLITE_OK;
+  }
+
+  /* Flush remaining leaf data. */
+  if( pWriter->data.nData>0 ){
+    int rc = leafWriterFlush(v, pWriter);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+
+  /* We must have flushed a leaf at some point. */
+  assert( pWriter->has_parent );
+
+  /* Tenatively set the end leaf blockid as the end blockid.  If the
+  ** interior node can be returned inline, this will be the final
+  ** blockid, otherwise it will be overwritten by
+  ** interiorWriterRootInfo().
+  */
+  *piEndBlockid = pWriter->iEndBlockid;
+
+  return interiorWriterRootInfo(v, &pWriter->parentWriter,
+                                ppRootInfo, pnRootInfo, piEndBlockid);
+}
+
+/* Collect the rootInfo data and store it into the segment directory.
+** This has the effect of flushing the segment's leaf data to
+** %_segments, and also flushing any interior nodes to %_segments.
+*/
+static int leafWriterFinalize(fulltext_vtab *v, LeafWriter *pWriter){
+  sqlite_int64 iEndBlockid;
+  char *pRootInfo;
+  int rc, nRootInfo;
+
+  rc = leafWriterRootInfo(v, pWriter, &pRootInfo, &nRootInfo, &iEndBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Don't bother storing an entirely empty segment. */
+  if( iEndBlockid==0 && nRootInfo==0 ) return SQLITE_OK;
+
+  return segdir_set(v, pWriter->iLevel, pWriter->idx,
+                    pWriter->iStartBlockid, pWriter->iEndBlockid,
+                    iEndBlockid, pRootInfo, nRootInfo);
+}
+
+static void leafWriterDestroy(LeafWriter *pWriter){
+  if( pWriter->has_parent ) interiorWriterDestroy(&pWriter->parentWriter);
+  dataBufferDestroy(&pWriter->term);
+  dataBufferDestroy(&pWriter->data);
+}
+
+/* Encode a term into the leafWriter, delta-encoding as appropriate.
+** Returns the length of the new term which distinguishes it from the
+** previous term, which can be used to set nTermDistinct when a node
+** boundary is crossed.
+*/
+static int leafWriterEncodeTerm(LeafWriter *pWriter,
+                                const char *pTerm, int nTerm){
+  char c[VARINT_MAX+VARINT_MAX];
+  int n, nPrefix = 0;
+
+  assert( nTerm>0 );
+  while( nPrefix<pWriter->term.nData &&
+         pTerm[nPrefix]==pWriter->term.pData[nPrefix] ){
+    nPrefix++;
+    /* Failing this implies that the terms weren't in order. */
+    assert( nPrefix<nTerm );
+  }
+
+  if( pWriter->data.nData==0 ){
+    /* Encode the node header and leading term as:
+    **  varint(0)
+    **  varint(nTerm)
+    **  char pTerm[nTerm]
+    */
+    n = fts3PutVarint(c, '\0');
+    n += fts3PutVarint(c+n, nTerm);
+    dataBufferAppend2(&pWriter->data, c, n, pTerm, nTerm);
+  }else{
+    /* Delta-encode the term as:
+    **  varint(nPrefix)
+    **  varint(nSuffix)
+    **  char pTermSuffix[nSuffix]
+    */
+    n = fts3PutVarint(c, nPrefix);
+    n += fts3PutVarint(c+n, nTerm-nPrefix);
+    dataBufferAppend2(&pWriter->data, c, n, pTerm+nPrefix, nTerm-nPrefix);
+  }
+  dataBufferReplace(&pWriter->term, pTerm, nTerm);
+
+  return nPrefix+1;
+}
+
+/* Used to avoid a memmove when a large amount of doclist data is in
+** the buffer.  This constructs a node and term header before
+** iDoclistData and flushes the resulting complete node using
+** leafWriterInternalFlush().
+*/
+static int leafWriterInlineFlush(fulltext_vtab *v, LeafWriter *pWriter,
+                                 const char *pTerm, int nTerm,
+                                 int iDoclistData){
+  char c[VARINT_MAX+VARINT_MAX];
+  int iData, n = fts3PutVarint(c, 0);
+  n += fts3PutVarint(c+n, nTerm);
+
+  /* There should always be room for the header.  Even if pTerm shared
+  ** a substantial prefix with the previous term, the entire prefix
+  ** could be constructed from earlier data in the doclist, so there
+  ** should be room.
+  */
+  assert( iDoclistData>=n+nTerm );
+
+  iData = iDoclistData-(n+nTerm);
+  memcpy(pWriter->data.pData+iData, c, n);
+  memcpy(pWriter->data.pData+iData+n, pTerm, nTerm);
+
+  return leafWriterInternalFlush(v, pWriter, iData, pWriter->data.nData-iData);
+}
+
+/* Push pTerm[nTerm] along with the doclist data to the leaf layer of
+** %_segments.
+*/
+static int leafWriterStepMerge(fulltext_vtab *v, LeafWriter *pWriter,
+                               const char *pTerm, int nTerm,
+                               DLReader *pReaders, int nReaders){
+  char c[VARINT_MAX+VARINT_MAX];
+  int iTermData = pWriter->data.nData, iDoclistData;
+  int i, nData, n, nActualData, nActual, rc, nTermDistinct;
+
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData, pWriter->data.nData);
+  nTermDistinct = leafWriterEncodeTerm(pWriter, pTerm, nTerm);
+
+  /* Remember nTermDistinct if opening a new node. */
+  if( iTermData==0 ) pWriter->nTermDistinct = nTermDistinct;
+
+  iDoclistData = pWriter->data.nData;
+
+  /* Estimate the length of the merged doclist so we can leave space
+  ** to encode it.
+  */
+  for(i=0, nData=0; i<nReaders; i++){
+    nData += dlrAllDataBytes(&pReaders[i]);
+  }
+  n = fts3PutVarint(c, nData);
+  dataBufferAppend(&pWriter->data, c, n);
+
+  docListMerge(&pWriter->data, pReaders, nReaders);
+  ASSERT_VALID_DOCLIST(DL_DEFAULT,
+                       pWriter->data.pData+iDoclistData+n,
+                       pWriter->data.nData-iDoclistData-n, NULL);
+
+  /* The actual amount of doclist data at this point could be smaller
+  ** than the length we encoded.  Additionally, the space required to
+  ** encode this length could be smaller.  For small doclists, this is
+  ** not a big deal, we can just use memmove() to adjust things.
+  */
+  nActualData = pWriter->data.nData-(iDoclistData+n);
+  nActual = fts3PutVarint(c, nActualData);
+  assert( nActualData<=nData );
+  assert( nActual<=n );
+
+  /* If the new doclist is big enough for force a standalone leaf
+  ** node, we can immediately flush it inline without doing the
+  ** memmove().
+  */
+  /* TODO(shess) This test matches leafWriterStep(), which does this
+  ** test before it knows the cost to varint-encode the term and
+  ** doclist lengths.  At some point, change to
+  ** pWriter->data.nData-iTermData>STANDALONE_MIN.
+  */
+  if( nTerm+nActualData>STANDALONE_MIN ){
+    /* Push leaf node from before this term. */
+    if( iTermData>0 ){
+      rc = leafWriterInternalFlush(v, pWriter, 0, iTermData);
+      if( rc!=SQLITE_OK ) return rc;
+
+      pWriter->nTermDistinct = nTermDistinct;
+    }
+
+    /* Fix the encoded doclist length. */
+    iDoclistData += n - nActual;
+    memcpy(pWriter->data.pData+iDoclistData, c, nActual);
+
+    /* Push the standalone leaf node. */
+    rc = leafWriterInlineFlush(v, pWriter, pTerm, nTerm, iDoclistData);
+    if( rc!=SQLITE_OK ) return rc;
+
+    /* Leave the node empty. */
+    dataBufferReset(&pWriter->data);
+
+    return rc;
+  }
+
+  /* At this point, we know that the doclist was small, so do the
+  ** memmove if indicated.
+  */
+  if( nActual<n ){
+    memmove(pWriter->data.pData+iDoclistData+nActual,
+            pWriter->data.pData+iDoclistData+n,
+            pWriter->data.nData-(iDoclistData+n));
+    pWriter->data.nData -= n-nActual;
+  }
+
+  /* Replace written length with actual length. */
+  memcpy(pWriter->data.pData+iDoclistData, c, nActual);
+
+  /* If the node is too large, break things up. */
+  /* TODO(shess) This test matches leafWriterStep(), which does this
+  ** test before it knows the cost to varint-encode the term and
+  ** doclist lengths.  At some point, change to
+  ** pWriter->data.nData>LEAF_MAX.
+  */
+  if( iTermData+nTerm+nActualData>LEAF_MAX ){
+    /* Flush out the leading data as a node */
+    rc = leafWriterInternalFlush(v, pWriter, 0, iTermData);
+    if( rc!=SQLITE_OK ) return rc;
+
+    pWriter->nTermDistinct = nTermDistinct;
+
+    /* Rebuild header using the current term */
+    n = fts3PutVarint(pWriter->data.pData, 0);
+    n += fts3PutVarint(pWriter->data.pData+n, nTerm);
+    memcpy(pWriter->data.pData+n, pTerm, nTerm);
+    n += nTerm;
+
+    /* There should always be room, because the previous encoding
+    ** included all data necessary to construct the term.
+    */
+    assert( n<iDoclistData );
+    /* So long as STANDALONE_MIN is half or less of LEAF_MAX, the
+    ** following memcpy() is safe (as opposed to needing a memmove).
+    */
+    assert( 2*STANDALONE_MIN<=LEAF_MAX );
+    assert( n+pWriter->data.nData-iDoclistData<iDoclistData );
+    memcpy(pWriter->data.pData+n,
+           pWriter->data.pData+iDoclistData,
+           pWriter->data.nData-iDoclistData);
+    pWriter->data.nData -= iDoclistData-n;
+  }
+  ASSERT_VALID_LEAF_NODE(pWriter->data.pData, pWriter->data.nData);
+
+  return SQLITE_OK;
+}
+
+/* Push pTerm[nTerm] along with the doclist data to the leaf layer of
+** %_segments.
+*/
+/* TODO(shess) Revise writeZeroSegment() so that doclists are
+** constructed directly in pWriter->data.
+*/
+static int leafWriterStep(fulltext_vtab *v, LeafWriter *pWriter,
+                          const char *pTerm, int nTerm,
+                          const char *pData, int nData){
+  int rc;
+  DLReader reader;
+
+  dlrInit(&reader, DL_DEFAULT, pData, nData);
+  rc = leafWriterStepMerge(v, pWriter, pTerm, nTerm, &reader, 1);
+  dlrDestroy(&reader);
+
+  return rc;
+}
+
+
+/****************************************************************/
+/* LeafReader is used to iterate over an individual leaf node. */
+typedef struct LeafReader {
+  DataBuffer term;          /* copy of current term. */
+
+  const char *pData;        /* data for current term. */
+  int nData;
+} LeafReader;
+
+static void leafReaderDestroy(LeafReader *pReader){
+  dataBufferDestroy(&pReader->term);
+  SCRAMBLE(pReader);
+}
+
+static int leafReaderAtEnd(LeafReader *pReader){
+  return pReader->nData<=0;
+}
+
+/* Access the current term. */
+static int leafReaderTermBytes(LeafReader *pReader){
+  return pReader->term.nData;
+}
+static const char *leafReaderTerm(LeafReader *pReader){
+  assert( pReader->term.nData>0 );
+  return pReader->term.pData;
+}
+
+/* Access the doclist data for the current term. */
+static int leafReaderDataBytes(LeafReader *pReader){
+  int nData;
+  assert( pReader->term.nData>0 );
+  fts3GetVarint32(pReader->pData, &nData);
+  return nData;
+}
+static const char *leafReaderData(LeafReader *pReader){
+  int n, nData;
+  assert( pReader->term.nData>0 );
+  n = fts3GetVarint32(pReader->pData, &nData);
+  return pReader->pData+n;
+}
+
+static void leafReaderInit(const char *pData, int nData,
+                           LeafReader *pReader){
+  int nTerm, n;
+
+  assert( nData>0 );
+  assert( pData[0]=='\0' );
+
+  CLEAR(pReader);
+
+  /* Read the first term, skipping the header byte. */
+  n = fts3GetVarint32(pData+1, &nTerm);
+  dataBufferInit(&pReader->term, nTerm);
+  dataBufferReplace(&pReader->term, pData+1+n, nTerm);
+
+  /* Position after the first term. */
+  assert( 1+n+nTerm<nData );
+  pReader->pData = pData+1+n+nTerm;
+  pReader->nData = nData-1-n-nTerm;
+}
+
+/* Step the reader forward to the next term. */
+static void leafReaderStep(LeafReader *pReader){
+  int n, nData, nPrefix, nSuffix;
+  assert( !leafReaderAtEnd(pReader) );
+
+  /* Skip previous entry's data block. */
+  n = fts3GetVarint32(pReader->pData, &nData);
+  assert( n+nData<=pReader->nData );
+  pReader->pData += n+nData;
+  pReader->nData -= n+nData;
+
+  if( !leafReaderAtEnd(pReader) ){
+    /* Construct the new term using a prefix from the old term plus a
+    ** suffix from the leaf data.
+    */
+    n = fts3GetVarint32(pReader->pData, &nPrefix);
+    n += fts3GetVarint32(pReader->pData+n, &nSuffix);
+    assert( n+nSuffix<pReader->nData );
+    pReader->term.nData = nPrefix;
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
+
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
+  }
+}
+
+/* strcmp-style comparison of pReader's current term against pTerm.
+** If isPrefix, equality means equal through nTerm bytes.
+*/
+static int leafReaderTermCmp(LeafReader *pReader,
+                             const char *pTerm, int nTerm, int isPrefix){
+  int c, n = pReader->term.nData<nTerm ? pReader->term.nData : nTerm;
+  if( n==0 ){
+    if( pReader->term.nData>0 ) return -1;
+    if(nTerm>0 ) return 1;
+    return 0;
+  }
+
+  c = memcmp(pReader->term.pData, pTerm, n);
+  if( c!=0 ) return c;
+  if( isPrefix && n==nTerm ) return 0;
+  return pReader->term.nData - nTerm;
+}
+
+
+/****************************************************************/
+/* LeavesReader wraps LeafReader to allow iterating over the entire
+** leaf layer of the tree.
+*/
+typedef struct LeavesReader {
+  int idx;                  /* Index within the segment. */
+
+  sqlite3_stmt *pStmt;      /* Statement we're streaming leaves from. */
+  int eof;                  /* we've seen SQLITE_DONE from pStmt. */
+
+  LeafReader leafReader;    /* reader for the current leaf. */
+  DataBuffer rootData;      /* root data for inline. */
+} LeavesReader;
+
+/* Access the current term. */
+static int leavesReaderTermBytes(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderTermBytes(&pReader->leafReader);
+}
+static const char *leavesReaderTerm(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderTerm(&pReader->leafReader);
+}
+
+/* Access the doclist data for the current term. */
+static int leavesReaderDataBytes(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderDataBytes(&pReader->leafReader);
+}
+static const char *leavesReaderData(LeavesReader *pReader){
+  assert( !pReader->eof );
+  return leafReaderData(&pReader->leafReader);
+}
+
+static int leavesReaderAtEnd(LeavesReader *pReader){
+  return pReader->eof;
+}
+
+/* loadSegmentLeaves() may not read all the way to SQLITE_DONE, thus
+** leaving the statement handle open, which locks the table.
+*/
+/* TODO(shess) This "solution" is not satisfactory.  Really, there
+** should be check-in function for all statement handles which
+** arranges to call sqlite3_reset().  This most likely will require
+** modification to control flow all over the place, though, so for now
+** just punt.
+**
+** Note the the current system assumes that segment merges will run to
+** completion, which is why this particular probably hasn't arisen in
+** this case.  Probably a brittle assumption.
+*/
+static int leavesReaderReset(LeavesReader *pReader){
+  return sqlite3_reset(pReader->pStmt);
+}
+
+static void leavesReaderDestroy(LeavesReader *pReader){
+  leafReaderDestroy(&pReader->leafReader);
+  dataBufferDestroy(&pReader->rootData);
+  SCRAMBLE(pReader);
+}
+
+/* Initialize pReader with the given root data (if iStartBlockid==0
+** the leaf data was entirely contained in the root), or from the
+** stream of blocks between iStartBlockid and iEndBlockid, inclusive.
+*/
+static int leavesReaderInit(fulltext_vtab *v,
+                            int idx,
+                            sqlite_int64 iStartBlockid,
+                            sqlite_int64 iEndBlockid,
+                            const char *pRootData, int nRootData,
+                            LeavesReader *pReader){
+  CLEAR(pReader);
+  pReader->idx = idx;
+
+  dataBufferInit(&pReader->rootData, 0);
+  if( iStartBlockid==0 ){
+    /* Entire leaf level fit in root data. */
+    dataBufferReplace(&pReader->rootData, pRootData, nRootData);
+    leafReaderInit(pReader->rootData.pData, pReader->rootData.nData,
+                   &pReader->leafReader);
+  }else{
+    sqlite3_stmt *s;
+    int rc = sql_get_leaf_statement(v, idx, &s);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_bind_int64(s, 1, iStartBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_bind_int64(s, 2, iEndBlockid);
+    if( rc!=SQLITE_OK ) return rc;
+
+    rc = sqlite3_step(s);
+    if( rc==SQLITE_DONE ){
+      pReader->eof = 1;
+      return SQLITE_OK;
+    }
+    if( rc!=SQLITE_ROW ) return rc;
+
+    pReader->pStmt = s;
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
+  }
+  return SQLITE_OK;
+}
+
+/* Step the current leaf forward to the next term.  If we reach the
+** end of the current leaf, step forward to the next leaf block.
+*/
+static int leavesReaderStep(fulltext_vtab *v, LeavesReader *pReader){
+  assert( !leavesReaderAtEnd(pReader) );
+  leafReaderStep(&pReader->leafReader);
+
+  if( leafReaderAtEnd(&pReader->leafReader) ){
+    int rc;
+    if( pReader->rootData.pData ){
+      pReader->eof = 1;
+      return SQLITE_OK;
+    }
+    rc = sqlite3_step(pReader->pStmt);
+    if( rc!=SQLITE_ROW ){
+      pReader->eof = 1;
+      return rc==SQLITE_DONE ? SQLITE_OK : rc;
+    }
+    leafReaderDestroy(&pReader->leafReader);
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
+  }
+  return SQLITE_OK;
+}
+
+/* Order LeavesReaders by their term, ignoring idx.  Readers at eof
+** always sort to the end.
+*/
+static int leavesReaderTermCmp(LeavesReader *lr1, LeavesReader *lr2){
+  if( leavesReaderAtEnd(lr1) ){
+    if( leavesReaderAtEnd(lr2) ) return 0;
+    return 1;
+  }
+  if( leavesReaderAtEnd(lr2) ) return -1;
+
+  return leafReaderTermCmp(&lr1->leafReader,
+                           leavesReaderTerm(lr2), leavesReaderTermBytes(lr2),
+                           0);
+}
+
+/* Similar to leavesReaderTermCmp(), with additional ordering by idx
+** so that older segments sort before newer segments.
+*/
+static int leavesReaderCmp(LeavesReader *lr1, LeavesReader *lr2){
+  int c = leavesReaderTermCmp(lr1, lr2);
+  if( c!=0 ) return c;
+  return lr1->idx-lr2->idx;
+}
+
+/* Assume that pLr[1]..pLr[nLr] are sorted.  Bubble pLr[0] into its
+** sorted position.
+*/
+static void leavesReaderReorder(LeavesReader *pLr, int nLr){
+  while( nLr>1 && leavesReaderCmp(pLr, pLr+1)>0 ){
+    LeavesReader tmp = pLr[0];
+    pLr[0] = pLr[1];
+    pLr[1] = tmp;
+    nLr--;
+    pLr++;
+  }
+}
+
+/* Initializes pReaders with the segments from level iLevel, returning
+** the number of segments in *piReaders.  Leaves pReaders in sorted
+** order.
+*/
+static int leavesReadersInit(fulltext_vtab *v, int iLevel,
+                             LeavesReader *pReaders, int *piReaders){
+  sqlite3_stmt *s;
+  int i, rc = sql_get_statement(v, SEGDIR_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int(s, 1, iLevel);
+  if( rc!=SQLITE_OK ) return rc;
+
+  i = 0;
+  while( (rc = sqlite3_step(s))==SQLITE_ROW ){
+    sqlite_int64 iStart = sqlite3_column_int64(s, 0);
+    sqlite_int64 iEnd = sqlite3_column_int64(s, 1);
+    const char *pRootData = sqlite3_column_blob(s, 2);
+    int nRootData = sqlite3_column_bytes(s, 2);
+
+    assert( i<MERGE_COUNT );
+    rc = leavesReaderInit(v, i, iStart, iEnd, pRootData, nRootData,
+                          &pReaders[i]);
+    if( rc!=SQLITE_OK ) break;
+
+    i++;
+  }
+  if( rc!=SQLITE_DONE ){
+    while( i-->0 ){
+      leavesReaderDestroy(&pReaders[i]);
+    }
+    return rc;
+  }
+
+  *piReaders = i;
+
+  /* Leave our results sorted by term, then age. */
+  while( i-- ){
+    leavesReaderReorder(pReaders+i, *piReaders-i);
+  }
+  return SQLITE_OK;
+}
+
+/* Merge doclists from pReaders[nReaders] into a single doclist, which
+** is written to pWriter.  Assumes pReaders is ordered oldest to
+** newest.
+*/
+/* TODO(shess) Consider putting this inline in segmentMerge(). */
+static int leavesReadersMerge(fulltext_vtab *v,
+                              LeavesReader *pReaders, int nReaders,
+                              LeafWriter *pWriter){
+  DLReader dlReaders[MERGE_COUNT];
+  const char *pTerm = leavesReaderTerm(pReaders);
+  int i, nTerm = leavesReaderTermBytes(pReaders);
+
+  assert( nReaders<=MERGE_COUNT );
+
+  for(i=0; i<nReaders; i++){
+    dlrInit(&dlReaders[i], DL_DEFAULT,
+            leavesReaderData(pReaders+i),
+            leavesReaderDataBytes(pReaders+i));
+  }
+
+  return leafWriterStepMerge(v, pWriter, pTerm, nTerm, dlReaders, nReaders);
+}
+
+/* Forward ref due to mutual recursion with segdirNextIndex(). */
+static int segmentMerge(fulltext_vtab *v, int iLevel);
+
+/* Put the next available index at iLevel into *pidx.  If iLevel
+** already has MERGE_COUNT segments, they are merged to a higher
+** level to make room.
+*/
+static int segdirNextIndex(fulltext_vtab *v, int iLevel, int *pidx){
+  int rc = segdir_max_index(v, iLevel, pidx);
+  if( rc==SQLITE_DONE ){              /* No segments at iLevel. */
+    *pidx = 0;
+  }else if( rc==SQLITE_ROW ){
+    if( *pidx==(MERGE_COUNT-1) ){
+      rc = segmentMerge(v, iLevel);
+      if( rc!=SQLITE_OK ) return rc;
+      *pidx = 0;
+    }else{
+      (*pidx)++;
+    }
+  }else{
+    return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* Merge MERGE_COUNT segments at iLevel into a new segment at
+** iLevel+1.  If iLevel+1 is already full of segments, those will be
+** merged to make room.
+*/
+static int segmentMerge(fulltext_vtab *v, int iLevel){
+  LeafWriter writer;
+  LeavesReader lrs[MERGE_COUNT];
+  int i, rc, idx = 0;
+
+  /* Determine the next available segment index at the next level,
+  ** merging as necessary.
+  */
+  rc = segdirNextIndex(v, iLevel+1, &idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* TODO(shess) This assumes that we'll always see exactly
+  ** MERGE_COUNT segments to merge at a given level.  That will be
+  ** broken if we allow the developer to request preemptive or
+  ** deferred merging.
+  */
+  memset(&lrs, '\0', sizeof(lrs));
+  rc = leavesReadersInit(v, iLevel, lrs, &i);
+  if( rc!=SQLITE_OK ) return rc;
+  assert( i==MERGE_COUNT );
+
+  leafWriterInit(iLevel+1, idx, &writer);
+
+  /* Since leavesReaderReorder() pushes readers at eof to the end,
+  ** when the first reader is empty, all will be empty.
+  */
+  while( !leavesReaderAtEnd(lrs) ){
+    /* Figure out how many readers share their next term. */
+    for(i=1; i<MERGE_COUNT && !leavesReaderAtEnd(lrs+i); i++){
+      if( 0!=leavesReaderTermCmp(lrs, lrs+i) ) break;
+    }
+
+    rc = leavesReadersMerge(v, lrs, i, &writer);
+    if( rc!=SQLITE_OK ) goto err;
+
+    /* Step forward those that were merged. */
+    while( i-->0 ){
+      rc = leavesReaderStep(v, lrs+i);
+      if( rc!=SQLITE_OK ) goto err;
+
+      /* Reorder by term, then by age. */
+      leavesReaderReorder(lrs+i, MERGE_COUNT-i);
+    }
+  }
+
+  for(i=0; i<MERGE_COUNT; i++){
+    leavesReaderDestroy(&lrs[i]);
+  }
+
+  rc = leafWriterFinalize(v, &writer);
+  leafWriterDestroy(&writer);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* Delete the merged segment data. */
+  return segdir_delete(v, iLevel);
+
+ err:
+  for(i=0; i<MERGE_COUNT; i++){
+    leavesReaderDestroy(&lrs[i]);
+  }
+  leafWriterDestroy(&writer);
+  return rc;
+}
+
+/* Accumulate the union of *acc and *pData into *acc. */
+static void docListAccumulateUnion(DataBuffer *acc,
+                                   const char *pData, int nData) {
+  DataBuffer tmp = *acc;
+  dataBufferInit(acc, tmp.nData+nData);
+  docListUnion(tmp.pData, tmp.nData, pData, nData, acc);
+  dataBufferDestroy(&tmp);
+}
+
+/* TODO(shess) It might be interesting to explore different merge
+** strategies, here.  For instance, since this is a sorted merge, we
+** could easily merge many doclists in parallel.  With some
+** comprehension of the storage format, we could merge all of the
+** doclists within a leaf node directly from the leaf node's storage.
+** It may be worthwhile to merge smaller doclists before larger
+** doclists, since they can be traversed more quickly - but the
+** results may have less overlap, making them more expensive in a
+** different way.
+*/
+
+/* Scan pReader for pTerm/nTerm, and merge the term's doclist over
+** *out (any doclists with duplicate docids overwrite those in *out).
+** Internal function for loadSegmentLeaf().
+*/
+static int loadSegmentLeavesInt(fulltext_vtab *v, LeavesReader *pReader,
+                                const char *pTerm, int nTerm, int isPrefix,
+                                DataBuffer *out){
+  /* doclist data is accumulated into pBuffers similar to how one does
+  ** increment in binary arithmetic.  If index 0 is empty, the data is
+  ** stored there.  If there is data there, it is merged and the
+  ** results carried into position 1, with further merge-and-carry
+  ** until an empty position is found.
+  */
+  DataBuffer *pBuffers = NULL;
+  int nBuffers = 0, nMaxBuffers = 0, rc;
+
+  assert( nTerm>0 );
+
+  for(rc=SQLITE_OK; rc==SQLITE_OK && !leavesReaderAtEnd(pReader);
+      rc=leavesReaderStep(v, pReader)){
+    /* TODO(shess) Really want leavesReaderTermCmp(), but that name is
+    ** already taken to compare the terms of two LeavesReaders.  Think
+    ** on a better name.  [Meanwhile, break encapsulation rather than
+    ** use a confusing name.]
+    */
+    int c = leafReaderTermCmp(&pReader->leafReader, pTerm, nTerm, isPrefix);
+    if( c>0 ) break;      /* Past any possible matches. */
+    if( c==0 ){
+      const char *pData = leavesReaderData(pReader);
+      int iBuffer, nData = leavesReaderDataBytes(pReader);
+
+      /* Find the first empty buffer. */
+      for(iBuffer=0; iBuffer<nBuffers; ++iBuffer){
+        if( 0==pBuffers[iBuffer].nData ) break;
+      }
+
+      /* Out of buffers, add an empty one. */
+      if( iBuffer==nBuffers ){
+        if( nBuffers==nMaxBuffers ){
+          DataBuffer *p;
+          nMaxBuffers += 20;
+
+          /* Manual realloc so we can handle NULL appropriately. */
+          p = sqlite3_malloc(nMaxBuffers*sizeof(*pBuffers));
+          if( p==NULL ){
+            rc = SQLITE_NOMEM;
+            break;
+          }
+
+          if( nBuffers>0 ){
+            assert(pBuffers!=NULL);
+            memcpy(p, pBuffers, nBuffers*sizeof(*pBuffers));
+            sqlite3_free(pBuffers);
+          }
+          pBuffers = p;
+        }
+        dataBufferInit(&(pBuffers[nBuffers]), 0);
+        nBuffers++;
+      }
+
+      /* At this point, must have an empty at iBuffer. */
+      assert(iBuffer<nBuffers && pBuffers[iBuffer].nData==0);
+
+      /* If empty was first buffer, no need for merge logic. */
+      if( iBuffer==0 ){
+        dataBufferReplace(&(pBuffers[0]), pData, nData);
+      }else{
+        /* pAcc is the empty buffer the merged data will end up in. */
+        DataBuffer *pAcc = &(pBuffers[iBuffer]);
+        DataBuffer *p = &(pBuffers[0]);
+
+        /* Handle position 0 specially to avoid need to prime pAcc
+        ** with pData/nData.
+        */
+        dataBufferSwap(p, pAcc);
+        docListAccumulateUnion(pAcc, pData, nData);
+
+        /* Accumulate remaining doclists into pAcc. */
+        for(++p; p<pAcc; ++p){
+          docListAccumulateUnion(pAcc, p->pData, p->nData);
+
+          /* dataBufferReset() could allow a large doclist to blow up
+          ** our memory requirements.
+          */
+          if( p->nCapacity<1024 ){
+            dataBufferReset(p);
+          }else{
+            dataBufferDestroy(p);
+            dataBufferInit(p, 0);
+          }
+        }
+      }
+    }
+  }
+
+  /* Union all the doclists together into *out. */
+  /* TODO(shess) What if *out is big?  Sigh. */
+  if( rc==SQLITE_OK && nBuffers>0 ){
+    int iBuffer;
+    for(iBuffer=0; iBuffer<nBuffers; ++iBuffer){
+      if( pBuffers[iBuffer].nData>0 ){
+        if( out->nData==0 ){
+          dataBufferSwap(out, &(pBuffers[iBuffer]));
+        }else{
+          docListAccumulateUnion(out, pBuffers[iBuffer].pData,
+                                 pBuffers[iBuffer].nData);
+        }
+      }
+    }
+  }
+
+  while( nBuffers-- ){
+    dataBufferDestroy(&(pBuffers[nBuffers]));
+  }
+  if( pBuffers!=NULL ) sqlite3_free(pBuffers);
+
+  return rc;
+}
+
+/* Call loadSegmentLeavesInt() with pData/nData as input. */
+static int loadSegmentLeaf(fulltext_vtab *v, const char *pData, int nData,
+                           const char *pTerm, int nTerm, int isPrefix,
+                           DataBuffer *out){
+  LeavesReader reader;
+  int rc;
+
+  assert( nData>1 );
+  assert( *pData=='\0' );
+  rc = leavesReaderInit(v, 0, 0, 0, pData, nData, &reader);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = loadSegmentLeavesInt(v, &reader, pTerm, nTerm, isPrefix, out);
+  leavesReaderReset(&reader);
+  leavesReaderDestroy(&reader);
+  return rc;
+}
+
+/* Call loadSegmentLeavesInt() with the leaf nodes from iStartLeaf to
+** iEndLeaf (inclusive) as input, and merge the resulting doclist into
+** out.
+*/
+static int loadSegmentLeaves(fulltext_vtab *v,
+                             sqlite_int64 iStartLeaf, sqlite_int64 iEndLeaf,
+                             const char *pTerm, int nTerm, int isPrefix,
+                             DataBuffer *out){
+  int rc;
+  LeavesReader reader;
+
+  assert( iStartLeaf<=iEndLeaf );
+  rc = leavesReaderInit(v, 0, iStartLeaf, iEndLeaf, NULL, 0, &reader);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = loadSegmentLeavesInt(v, &reader, pTerm, nTerm, isPrefix, out);
+  leavesReaderReset(&reader);
+  leavesReaderDestroy(&reader);
+  return rc;
+}
+
+/* Taking pData/nData as an interior node, find the sequence of child
+** nodes which could include pTerm/nTerm/isPrefix.  Note that the
+** interior node terms logically come between the blocks, so there is
+** one more blockid than there are terms (that block contains terms >=
+** the last interior-node term).
+*/
+/* TODO(shess) The calling code may already know that the end child is
+** not worth calculating, because the end may be in a later sibling
+** node.  Consider whether breaking symmetry is worthwhile.  I suspect
+** it is not worthwhile.
+*/
+static void getChildrenContaining(const char *pData, int nData,
+                                  const char *pTerm, int nTerm, int isPrefix,
+                                  sqlite_int64 *piStartChild,
+                                  sqlite_int64 *piEndChild){
+  InteriorReader reader;
+
+  assert( nData>1 );
+  assert( *pData!='\0' );
+  interiorReaderInit(pData, nData, &reader);
+
+  /* Scan for the first child which could contain pTerm/nTerm. */
+  while( !interiorReaderAtEnd(&reader) ){
+    if( interiorReaderTermCmp(&reader, pTerm, nTerm, 0)>0 ) break;
+    interiorReaderStep(&reader);
+  }
+  *piStartChild = interiorReaderCurrentBlockid(&reader);
+
+  /* Keep scanning to find a term greater than our term, using prefix
+  ** comparison if indicated.  If isPrefix is false, this will be the
+  ** same blockid as the starting block.
+  */
+  while( !interiorReaderAtEnd(&reader) ){
+    if( interiorReaderTermCmp(&reader, pTerm, nTerm, isPrefix)>0 ) break;
+    interiorReaderStep(&reader);
+  }
+  *piEndChild = interiorReaderCurrentBlockid(&reader);
+
+  interiorReaderDestroy(&reader);
+
+  /* Children must ascend, and if !prefix, both must be the same. */
+  assert( *piEndChild>=*piStartChild );
+  assert( isPrefix || *piStartChild==*piEndChild );
+}
+
+/* Read block at iBlockid and pass it with other params to
+** getChildrenContaining().
+*/
+static int loadAndGetChildrenContaining(
+  fulltext_vtab *v,
+  sqlite_int64 iBlockid,
+  const char *pTerm, int nTerm, int isPrefix,
+  sqlite_int64 *piStartChild, sqlite_int64 *piEndChild
+){
+  sqlite3_stmt *s = NULL;
+  int rc;
+
+  assert( iBlockid!=0 );
+  assert( pTerm!=NULL );
+  assert( nTerm!=0 );        /* TODO(shess) Why not allow this? */
+  assert( piStartChild!=NULL );
+  assert( piEndChild!=NULL );
+
+  rc = sql_get_statement(v, BLOCK_SELECT_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_bind_int64(s, 1, iBlockid);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_DONE ) return SQLITE_ERROR;
+  if( rc!=SQLITE_ROW ) return rc;
+
+  getChildrenContaining(sqlite3_column_blob(s, 0), sqlite3_column_bytes(s, 0),
+                        pTerm, nTerm, isPrefix, piStartChild, piEndChild);
+
+  /* We expect only one row.  We must execute another sqlite3_step()
+   * to complete the iteration; otherwise the table will remain
+   * locked. */
+  rc = sqlite3_step(s);
+  if( rc==SQLITE_ROW ) return SQLITE_ERROR;
+  if( rc!=SQLITE_DONE ) return rc;
+
+  return SQLITE_OK;
+}
+
+/* Traverse the tree represented by pData[nData] looking for
+** pTerm[nTerm], placing its doclist into *out.  This is internal to
+** loadSegment() to make error-handling cleaner.
+*/
+static int loadSegmentInt(fulltext_vtab *v, const char *pData, int nData,
+                          sqlite_int64 iLeavesEnd,
+                          const char *pTerm, int nTerm, int isPrefix,
+                          DataBuffer *out){
+  /* Special case where root is a leaf. */
+  if( *pData=='\0' ){
+    return loadSegmentLeaf(v, pData, nData, pTerm, nTerm, isPrefix, out);
+  }else{
+    int rc;
+    sqlite_int64 iStartChild, iEndChild;
+
+    /* Process pData as an interior node, then loop down the tree
+    ** until we find the set of leaf nodes to scan for the term.
+    */
+    getChildrenContaining(pData, nData, pTerm, nTerm, isPrefix,
+                          &iStartChild, &iEndChild);
+    while( iStartChild>iLeavesEnd ){
+      sqlite_int64 iNextStart, iNextEnd;
+      rc = loadAndGetChildrenContaining(v, iStartChild, pTerm, nTerm, isPrefix,
+                                        &iNextStart, &iNextEnd);
+      if( rc!=SQLITE_OK ) return rc;
+
+      /* If we've branched, follow the end branch, too. */
+      if( iStartChild!=iEndChild ){
+        sqlite_int64 iDummy;
+        rc = loadAndGetChildrenContaining(v, iEndChild, pTerm, nTerm, isPrefix,
+                                          &iDummy, &iNextEnd);
+        if( rc!=SQLITE_OK ) return rc;
+      }
+
+      assert( iNextStart<=iNextEnd );
+      iStartChild = iNextStart;
+      iEndChild = iNextEnd;
+    }
+    assert( iStartChild<=iLeavesEnd );
+    assert( iEndChild<=iLeavesEnd );
+
+    /* Scan through the leaf segments for doclists. */
+    return loadSegmentLeaves(v, iStartChild, iEndChild,
+                             pTerm, nTerm, isPrefix, out);
+  }
+}
+
+/* Call loadSegmentInt() to collect the doclist for pTerm/nTerm, then
+** merge its doclist over *out (any duplicate doclists read from the
+** segment rooted at pData will overwrite those in *out).
+*/
+/* TODO(shess) Consider changing this to determine the depth of the
+** leaves using either the first characters of interior nodes (when
+** ==1, we're one level above the leaves), or the first character of
+** the root (which will describe the height of the tree directly).
+** Either feels somewhat tricky to me.
+*/
+/* TODO(shess) The current merge is likely to be slow for large
+** doclists (though it should process from newest/smallest to
+** oldest/largest, so it may not be that bad).  It might be useful to
+** modify things to allow for N-way merging.  This could either be
+** within a segment, with pairwise merges across segments, or across
+** all segments at once.
+*/
+static int loadSegment(fulltext_vtab *v, const char *pData, int nData,
+                       sqlite_int64 iLeavesEnd,
+                       const char *pTerm, int nTerm, int isPrefix,
+                       DataBuffer *out){
+  DataBuffer result;
+  int rc;
+
+  assert( nData>1 );
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&result, 0);
+  rc = loadSegmentInt(v, pData, nData, iLeavesEnd,
+                      pTerm, nTerm, isPrefix, &result);
+  if( rc==SQLITE_OK && result.nData>0 ){
+    if( out->nData==0 ){
+      DataBuffer tmp = *out;
+      *out = result;
+      result = tmp;
+    }else{
+      DataBuffer merged;
+      DLReader readers[2];
+
+      dlrInit(&readers[0], DL_DEFAULT, out->pData, out->nData);
+      dlrInit(&readers[1], DL_DEFAULT, result.pData, result.nData);
+      dataBufferInit(&merged, out->nData+result.nData);
+      docListMerge(&merged, readers, 2);
+      dataBufferDestroy(out);
+      *out = merged;
+      dlrDestroy(&readers[0]);
+      dlrDestroy(&readers[1]);
+    }
+  }
+  dataBufferDestroy(&result);
+  return rc;
+}
+
+/* Scan the database and merge together the posting lists for the term
+** into *out.
+*/
+static int termSelect(fulltext_vtab *v, int iColumn,
+                      const char *pTerm, int nTerm, int isPrefix,
+                      DocListType iType, DataBuffer *out){
+  DataBuffer doclist;
+  sqlite3_stmt *s;
+  int rc = sql_get_statement(v, SEGDIR_SELECT_ALL_STMT, &s);
+  if( rc!=SQLITE_OK ) return rc;
+
+  /* This code should never be called with buffered updates. */
+  assert( v->nPendingData<0 );
+
+  dataBufferInit(&doclist, 0);
+
+  /* Traverse the segments from oldest to newest so that newer doclist
+  ** elements for given docids overwrite older elements.
+  */
+  while( (rc = sqlite3_step(s))==SQLITE_ROW ){
+    const char *pData = sqlite3_column_blob(s, 0);
+    const int nData = sqlite3_column_bytes(s, 0);
+    const sqlite_int64 iLeavesEnd = sqlite3_column_int64(s, 1);
+    rc = loadSegment(v, pData, nData, iLeavesEnd, pTerm, nTerm, isPrefix,
+                     &doclist);
+    if( rc!=SQLITE_OK ) goto err;
+  }
+  if( rc==SQLITE_DONE ){
+    if( doclist.nData!=0 ){
+      /* TODO(shess) The old term_select_all() code applied the column
+      ** restrict as we merged segments, leading to smaller buffers.
+      ** This is probably worthwhile to bring back, once the new storage
+      ** system is checked in.
+      */
+      if( iColumn==v->nColumn) iColumn = -1;
+      docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
+                  iColumn, iType, out);
+    }
+    rc = SQLITE_OK;
+  }
+
+ err:
+  dataBufferDestroy(&doclist);
+  return rc;
+}
+
+/****************************************************************/
+/* Used to hold hashtable data for sorting. */
+typedef struct TermData {
+  const char *pTerm;
+  int nTerm;
+  DLCollector *pCollector;
+} TermData;
+
+/* Orders TermData elements in strcmp fashion ( <0 for less-than, 0
+** for equal, >0 for greater-than).
+*/
+static int termDataCmp(const void *av, const void *bv){
+  const TermData *a = (const TermData *)av;
+  const TermData *b = (const TermData *)bv;
+  int n = a->nTerm<b->nTerm ? a->nTerm : b->nTerm;
+  int c = memcmp(a->pTerm, b->pTerm, n);
+  if( c!=0 ) return c;
+  return a->nTerm-b->nTerm;
+}
+
+/* Order pTerms data by term, then write a new level 0 segment using
+** LeafWriter.
+*/
+static int writeZeroSegment(fulltext_vtab *v, fts3Hash *pTerms){
+  fts3HashElem *e;
+  int idx, rc, i, n;
+  TermData *pData;
+  LeafWriter writer;
+  DataBuffer dl;
+
+  /* Determine the next index at level 0, merging as necessary. */
+  rc = segdirNextIndex(v, 0, &idx);
+  if( rc!=SQLITE_OK ) return rc;
+
+  n = fts3HashCount(pTerms);
+  pData = sqlite3_malloc(n*sizeof(TermData));
+
+  for(i = 0, e = fts3HashFirst(pTerms); e; i++, e = fts3HashNext(e)){
+    assert( i<n );
+    pData[i].pTerm = fts3HashKey(e);
+    pData[i].nTerm = fts3HashKeysize(e);
+    pData[i].pCollector = fts3HashData(e);
+  }
+  assert( i==n );
+
+  /* TODO(shess) Should we allow user-defined collation sequences,
+  ** here?  I think we only need that once we support prefix searches.
+  */
+  if( n>1 ) qsort(pData, n, sizeof(*pData), termDataCmp);
+
+  /* TODO(shess) Refactor so that we can write directly to the segment
+  ** DataBuffer, as happens for segment merges.
+  */
+  leafWriterInit(0, idx, &writer);
+  dataBufferInit(&dl, 0);
+  for(i=0; i<n; i++){
+    dataBufferReset(&dl);
+    dlcAddDoclist(pData[i].pCollector, &dl);
+    rc = leafWriterStep(v, &writer,
+                        pData[i].pTerm, pData[i].nTerm, dl.pData, dl.nData);
+    if( rc!=SQLITE_OK ) goto err;
+  }
+  rc = leafWriterFinalize(v, &writer);
+
+ err:
+  dataBufferDestroy(&dl);
+  sqlite3_free(pData);
+  leafWriterDestroy(&writer);
+  return rc;
+}
+
+/* If pendingTerms has data, free it. */
+static int clearPendingTerms(fulltext_vtab *v){
+  if( v->nPendingData>=0 ){
+    fts3HashElem *e;
+    for(e=fts3HashFirst(&v->pendingTerms); e; e=fts3HashNext(e)){
+      dlcDelete(fts3HashData(e));
+    }
+    fts3HashClear(&v->pendingTerms);
+    v->nPendingData = -1;
+  }
+  return SQLITE_OK;
+}
+
+/* If pendingTerms has data, flush it to a level-zero segment, and
+** free it.
+*/
+static int flushPendingTerms(fulltext_vtab *v){
+  if( v->nPendingData>=0 ){
+    int rc = writeZeroSegment(v, &v->pendingTerms);
+    if( rc==SQLITE_OK ) clearPendingTerms(v);
+    return rc;
+  }
+  return SQLITE_OK;
+}
+
+/* If pendingTerms is "too big", or docid is out of order, flush it.
+** Regardless, be certain that pendingTerms is initialized for use.
+*/
+static int initPendingTerms(fulltext_vtab *v, sqlite_int64 iDocid){
+  /* TODO(shess) Explore whether partially flushing the buffer on
+  ** forced-flush would provide better performance.  I suspect that if
+  ** we ordered the doclists by size and flushed the largest until the
+  ** buffer was half empty, that would let the less frequent terms
+  ** generate longer doclists.
+  */
+  if( iDocid<=v->iPrevDocid || v->nPendingData>kPendingThreshold ){
+    int rc = flushPendingTerms(v);
+    if( rc!=SQLITE_OK ) return rc;
+  }
+  if( v->nPendingData<0 ){
+    fts3HashInit(&v->pendingTerms, FTS3_HASH_STRING, 1);
+    v->nPendingData = 0;
+  }
+  v->iPrevDocid = iDocid;
+  return SQLITE_OK;
+}
+
+/* This function implements the xUpdate callback; it is the top-level entry
+ * point for inserting, deleting or updating a row in a full-text table. */
+static int fulltextUpdate(sqlite3_vtab *pVtab, int nArg, sqlite3_value **ppArg,
+                          sqlite_int64 *pRowid){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  int rc;
+
+  FTSTRACE(("FTS3 Update %p\n", pVtab));
+
+  if( nArg<2 ){
+    rc = index_delete(v, sqlite3_value_int64(ppArg[0]));
+  } else if( sqlite3_value_type(ppArg[0]) != SQLITE_NULL ){
+    /* An update:
+     * ppArg[0] = old rowid
+     * ppArg[1] = new rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     * ppArg[2+v->nColumn+1] = value for docid
+     */
+    sqlite_int64 rowid = sqlite3_value_int64(ppArg[0]);
+    if( sqlite3_value_type(ppArg[1]) != SQLITE_INTEGER ||
+        sqlite3_value_int64(ppArg[1]) != rowid ){
+      rc = SQLITE_ERROR;  /* we don't allow changing the rowid */
+    }else if( sqlite3_value_type(ppArg[2+v->nColumn+1]) != SQLITE_INTEGER ||
+              sqlite3_value_int64(ppArg[2+v->nColumn+1]) != rowid ){
+      rc = SQLITE_ERROR;  /* we don't allow changing the docid */
+    }else{
+      assert( nArg==2+v->nColumn+2);
+      rc = index_update(v, rowid, &ppArg[2]);
+    }
+  } else {
+    /* An insert:
+     * ppArg[1] = requested rowid
+     * ppArg[2..2+v->nColumn-1] = values
+     * ppArg[2+v->nColumn] = value for magic column (we ignore this)
+     * ppArg[2+v->nColumn+1] = value for docid
+     */
+    sqlite3_value *pRequestDocid = ppArg[2+v->nColumn+1];
+    assert( nArg==2+v->nColumn+2);
+    if( SQLITE_NULL != sqlite3_value_type(pRequestDocid) &&
+        SQLITE_NULL != sqlite3_value_type(ppArg[1]) ){
+      /* TODO(shess) Consider allowing this to work if the values are
+      ** identical.  I'm inclined to discourage that usage, though,
+      ** given that both rowid and docid are special columns.  Better
+      ** would be to define one or the other as the default winner,
+      ** but should it be fts3-centric (docid) or SQLite-centric
+      ** (rowid)?
+      */
+      rc = SQLITE_ERROR;
+    }else{
+      if( SQLITE_NULL == sqlite3_value_type(pRequestDocid) ){
+        pRequestDocid = ppArg[1];
+      }
+      rc = index_insert(v, pRequestDocid, &ppArg[2], pRowid);
+    }
+  }
+
+  return rc;
+}
+
+static int fulltextSync(sqlite3_vtab *pVtab){
+  FTSTRACE(("FTS3 xSync()\n"));
+  return flushPendingTerms((fulltext_vtab *)pVtab);
+}
+
+static int fulltextBegin(sqlite3_vtab *pVtab){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  FTSTRACE(("FTS3 xBegin()\n"));
+
+  /* Any buffered updates should have been cleared by the previous
+  ** transaction.
+  */
+  assert( v->nPendingData<0 );
+  return clearPendingTerms(v);
+}
+
+static int fulltextCommit(sqlite3_vtab *pVtab){
+  fulltext_vtab *v = (fulltext_vtab *) pVtab;
+  FTSTRACE(("FTS3 xCommit()\n"));
+
+  /* Buffered updates should have been cleared by fulltextSync(). */
+  assert( v->nPendingData<0 );
+  return clearPendingTerms(v);
+}
+
+static int fulltextRollback(sqlite3_vtab *pVtab){
+  FTSTRACE(("FTS3 xRollback()\n"));
+  return clearPendingTerms((fulltext_vtab *)pVtab);
+}
+
+/*
+** Implementation of the snippet() function for FTS3
+*/
+static void snippetFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to html_snippet",-1);
+  }else{
+    const char *zStart = "<b>";
+    const char *zEnd = "</b>";
+    const char *zEllipsis = "<b>...</b>";
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    if( argc>=2 ){
+      zStart = (const char*)sqlite3_value_text(argv[1]);
+      if( argc>=3 ){
+        zEnd = (const char*)sqlite3_value_text(argv[2]);
+        if( argc>=4 ){
+          zEllipsis = (const char*)sqlite3_value_text(argv[3]);
+        }
+      }
+    }
+    snippetAllOffsets(pCursor);
+    snippetText(pCursor, zStart, zEnd, zEllipsis);
+    sqlite3_result_text(pContext, pCursor->snippet.zSnippet,
+                        pCursor->snippet.nSnippet, SQLITE_STATIC);
+  }
+}
+
+/*
+** Implementation of the offsets() function for FTS3
+*/
+static void snippetOffsetsFunc(
+  sqlite3_context *pContext,
+  int argc,
+  sqlite3_value **argv
+){
+  fulltext_cursor *pCursor;
+  if( argc<1 ) return;
+  if( sqlite3_value_type(argv[0])!=SQLITE_BLOB ||
+      sqlite3_value_bytes(argv[0])!=sizeof(pCursor) ){
+    sqlite3_result_error(pContext, "illegal first argument to offsets",-1);
+  }else{
+    memcpy(&pCursor, sqlite3_value_blob(argv[0]), sizeof(pCursor));
+    snippetAllOffsets(pCursor);
+    snippetOffsetText(&pCursor->snippet);
+    sqlite3_result_text(pContext,
+                        pCursor->snippet.zOffset, pCursor->snippet.nOffset,
+                        SQLITE_STATIC);
+  }
+}
+
+/*
+** This routine implements the xFindFunction method for the FTS3
+** virtual table.
+*/
+static int fulltextFindFunction(
+  sqlite3_vtab *pVtab,
+  int nArg,
+  const char *zName,
+  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+  void **ppArg
+){
+  if( strcmp(zName,"snippet")==0 ){
+    *pxFunc = snippetFunc;
+    return 1;
+  }else if( strcmp(zName,"offsets")==0 ){
+    *pxFunc = snippetOffsetsFunc;
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Rename an fts3 table.
+*/
+static int fulltextRename(
+  sqlite3_vtab *pVtab,
+  const char *zName
+){
+  fulltext_vtab *p = (fulltext_vtab *)pVtab;
+  int rc = SQLITE_NOMEM;
+  char *zSql = sqlite3_mprintf(
+    "ALTER TABLE %Q.'%q_content'  RENAME TO '%q_content';"
+    "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';"
+    "ALTER TABLE %Q.'%q_segdir'   RENAME TO '%q_segdir';"
+    , p->zDb, p->zName, zName 
+    , p->zDb, p->zName, zName 
+    , p->zDb, p->zName, zName
+  );
+  if( zSql ){
+    rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+  }
+  return rc;
+}
+
+static const sqlite3_module fts3Module = {
+  /* iVersion      */ 0,
+  /* xCreate       */ fulltextCreate,
+  /* xConnect      */ fulltextConnect,
+  /* xBestIndex    */ fulltextBestIndex,
+  /* xDisconnect   */ fulltextDisconnect,
+  /* xDestroy      */ fulltextDestroy,
+  /* xOpen         */ fulltextOpen,
+  /* xClose        */ fulltextClose,
+  /* xFilter       */ fulltextFilter,
+  /* xNext         */ fulltextNext,
+  /* xEof          */ fulltextEof,
+  /* xColumn       */ fulltextColumn,
+  /* xRowid        */ fulltextRowid,
+  /* xUpdate       */ fulltextUpdate,
+  /* xBegin        */ fulltextBegin,
+  /* xSync         */ fulltextSync,
+  /* xCommit       */ fulltextCommit,
+  /* xRollback     */ fulltextRollback,
+  /* xFindFunction */ fulltextFindFunction,
+  /* xRename */       fulltextRename,
+};
+
+static void hashDestroy(void *p){
+  fts3Hash *pHash = (fts3Hash *)p;
+  sqlite3Fts3HashClear(pHash);
+  sqlite3_free(pHash);
+}
+
+/*
+** The fts3 built-in tokenizers - "simple" and "porter" - are implemented
+** in files fts3_tokenizer1.c and fts3_porter.c respectively. The following
+** two forward declarations are for functions declared in these files
+** used to retrieve the respective implementations.
+**
+** Calling sqlite3Fts3SimpleTokenizerModule() sets the value pointed
+** to by the argument to point a the "simple" tokenizer implementation.
+** Function ...PorterTokenizerModule() sets *pModule to point to the
+** porter tokenizer/stemmer implementation.
+*/
+void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+
+int sqlite3Fts3InitHashTable(sqlite3 *, fts3Hash *, const char *);
+
+/*
+** Initialise the fts3 extension. If this extension is built as part
+** of the sqlite library, then this function is called directly by
+** SQLite. If fts3 is built as a dynamically loadable extension, this
+** function is called by the sqlite3_extension_init() entry point.
+*/
+int sqlite3Fts3Init(sqlite3 *db){
+  int rc = SQLITE_OK;
+  fts3Hash *pHash = 0;
+  const sqlite3_tokenizer_module *pSimple = 0;
+  const sqlite3_tokenizer_module *pPorter = 0;
+  const sqlite3_tokenizer_module *pIcu = 0;
+
+  sqlite3Fts3SimpleTokenizerModule(&pSimple);
+  sqlite3Fts3PorterTokenizerModule(&pPorter);
+#ifdef SQLITE_ENABLE_ICU
+  sqlite3Fts3IcuTokenizerModule(&pIcu);
+#endif
+
+  /* Allocate and initialise the hash-table used to store tokenizers. */
+  pHash = sqlite3_malloc(sizeof(fts3Hash));
+  if( !pHash ){
+    rc = SQLITE_NOMEM;
+  }else{
+    sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
+  }
+
+  /* Load the built-in tokenizers into the hash table */
+  if( rc==SQLITE_OK ){
+    if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
+     || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter) 
+     || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
+    ){
+      rc = SQLITE_NOMEM;
+    }
+  }
+
+  /* Create the virtual table wrapper around the hash-table and overload 
+  ** the two scalar functions. If this is successful, register the
+  ** module with sqlite.
+  */
+  if( SQLITE_OK==rc 
+   && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
+   && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
+   && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", -1))
+  ){
+    return sqlite3_create_module_v2(
+        db, "fts3", &fts3Module, (void *)pHash, hashDestroy
+    );
+  }
+
+  /* An error has occured. Delete the hash table and return the error code. */
+  assert( rc!=SQLITE_OK );
+  if( pHash ){
+    sqlite3Fts3HashClear(pHash);
+    sqlite3_free(pHash);
+  }
+  return rc;
+}
+
+#if !SQLITE_CORE
+int sqlite3_extension_init(
+  sqlite3 *db, 
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi)
+  return sqlite3Fts3Init(db);
+}
+#endif
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.h
new file mode 100644
index 0000000..c1aa8ca
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3.h
@@ -0,0 +1,26 @@
+/*
+** 2006 Oct 10
+**
+** 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 header file is used by programs that want to link against the
+** FTS3 library.  All it does is declare the sqlite3Fts3Init() interface.
+*/
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+int sqlite3Fts3Init(sqlite3 *db);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.c
new file mode 100644
index 0000000..64bd5d0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.c
@@ -0,0 +1,374 @@
+/*
+** 2001 September 22
+**
+** 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 is the implementation of generic hash-tables used in SQLite.
+** We've modified it slightly to serve as a standalone hash table
+** implementation for the full-text indexing module.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS3 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS3 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sqlite3.h"
+#include "fts3_hash.h"
+
+/*
+** Malloc and Free functions
+*/
+static void *fts3HashMalloc(int n){
+  void *p = sqlite3_malloc(n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+static void fts3HashFree(void *p){
+  sqlite3_free(p);
+}
+
+/* Turn bulk memory into a hash table object by initializing the
+** fields of the Hash structure.
+**
+** "pNew" is a pointer to the hash table that is to be initialized.
+** keyClass is one of the constants 
+** FTS3_HASH_BINARY or FTS3_HASH_STRING.  The value of keyClass 
+** determines what kind of key the hash table will use.  "copyKey" is
+** true if the hash table should make its own private copy of keys and
+** false if it should just use the supplied pointer.
+*/
+void sqlite3Fts3HashInit(fts3Hash *pNew, int keyClass, int copyKey){
+  assert( pNew!=0 );
+  assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
+  pNew->keyClass = keyClass;
+  pNew->copyKey = copyKey;
+  pNew->first = 0;
+  pNew->count = 0;
+  pNew->htsize = 0;
+  pNew->ht = 0;
+}
+
+/* Remove all entries from a hash table.  Reclaim all memory.
+** Call this routine to delete a hash table or to reset a hash table
+** to the empty state.
+*/
+void sqlite3Fts3HashClear(fts3Hash *pH){
+  fts3HashElem *elem;         /* For looping over all elements of the table */
+
+  assert( pH!=0 );
+  elem = pH->first;
+  pH->first = 0;
+  fts3HashFree(pH->ht);
+  pH->ht = 0;
+  pH->htsize = 0;
+  while( elem ){
+    fts3HashElem *next_elem = elem->next;
+    if( pH->copyKey && elem->pKey ){
+      fts3HashFree(elem->pKey);
+    }
+    fts3HashFree(elem);
+    elem = next_elem;
+  }
+  pH->count = 0;
+}
+
+/*
+** Hash and comparison functions when the mode is FTS3_HASH_STRING
+*/
+static int fts3StrHash(const void *pKey, int nKey){
+  const char *z = (const char *)pKey;
+  int h = 0;
+  if( nKey<=0 ) nKey = (int) strlen(z);
+  while( nKey > 0  ){
+    h = (h<<3) ^ h ^ *z++;
+    nKey--;
+  }
+  return h & 0x7fffffff;
+}
+static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return strncmp((const char*)pKey1,(const char*)pKey2,n1);
+}
+
+/*
+** Hash and comparison functions when the mode is FTS3_HASH_BINARY
+*/
+static int fts3BinHash(const void *pKey, int nKey){
+  int h = 0;
+  const char *z = (const char *)pKey;
+  while( nKey-- > 0 ){
+    h = (h<<3) ^ h ^ *(z++);
+  }
+  return h & 0x7fffffff;
+}
+static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return memcmp(pKey1,pKey2,n1);
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** The C syntax in this function definition may be unfamilar to some 
+** programmers, so we provide the following additional explanation:
+**
+** The name of the function is "ftsHashFunction".  The function takes a
+** single parameter "keyClass".  The return value of ftsHashFunction()
+** is a pointer to another function.  Specifically, the return value
+** of ftsHashFunction() is a pointer to a function that takes two parameters
+** with types "const void*" and "int" and returns an "int".
+*/
+static int (*ftsHashFunction(int keyClass))(const void*,int){
+  if( keyClass==FTS3_HASH_STRING ){
+    return &fts3StrHash;
+  }else{
+    assert( keyClass==FTS3_HASH_BINARY );
+    return &fts3BinHash;
+  }
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** For help in interpreted the obscure C code in the function definition,
+** see the header comment on the previous function.
+*/
+static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
+  if( keyClass==FTS3_HASH_STRING ){
+    return &fts3StrCompare;
+  }else{
+    assert( keyClass==FTS3_HASH_BINARY );
+    return &fts3BinCompare;
+  }
+}
+
+/* Link an element into the hash table
+*/
+static void fts3HashInsertElement(
+  fts3Hash *pH,            /* The complete hash table */
+  struct _fts3ht *pEntry,  /* The entry into which pNew is inserted */
+  fts3HashElem *pNew       /* The element to be inserted */
+){
+  fts3HashElem *pHead;     /* First element already in pEntry */
+  pHead = pEntry->chain;
+  if( pHead ){
+    pNew->next = pHead;
+    pNew->prev = pHead->prev;
+    if( pHead->prev ){ pHead->prev->next = pNew; }
+    else             { pH->first = pNew; }
+    pHead->prev = pNew;
+  }else{
+    pNew->next = pH->first;
+    if( pH->first ){ pH->first->prev = pNew; }
+    pNew->prev = 0;
+    pH->first = pNew;
+  }
+  pEntry->count++;
+  pEntry->chain = pNew;
+}
+
+
+/* Resize the hash table so that it cantains "new_size" buckets.
+** "new_size" must be a power of 2.  The hash table might fail 
+** to resize if sqliteMalloc() fails.
+*/
+static void fts3Rehash(fts3Hash *pH, int new_size){
+  struct _fts3ht *new_ht;          /* The new hash table */
+  fts3HashElem *elem, *next_elem;  /* For looping over existing elements */
+  int (*xHash)(const void*,int);   /* The hash function */
+
+  assert( (new_size & (new_size-1))==0 );
+  new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) );
+  if( new_ht==0 ) return;
+  fts3HashFree(pH->ht);
+  pH->ht = new_ht;
+  pH->htsize = new_size;
+  xHash = ftsHashFunction(pH->keyClass);
+  for(elem=pH->first, pH->first=0; elem; elem = next_elem){
+    int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
+    next_elem = elem->next;
+    fts3HashInsertElement(pH, &new_ht[h], elem);
+  }
+}
+
+/* This function (for internal use only) locates an element in an
+** hash table that matches the given key.  The hash for this key has
+** already been computed and is passed as the 4th parameter.
+*/
+static fts3HashElem *fts3FindElementByHash(
+  const fts3Hash *pH, /* The pH to be searched */
+  const void *pKey,   /* The key we are searching for */
+  int nKey,
+  int h               /* The hash for this key. */
+){
+  fts3HashElem *elem;            /* Used to loop thru the element list */
+  int count;                     /* Number of elements left to test */
+  int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
+
+  if( pH->ht ){
+    struct _fts3ht *pEntry = &pH->ht[h];
+    elem = pEntry->chain;
+    count = pEntry->count;
+    xCompare = ftsCompareFunction(pH->keyClass);
+    while( count-- && elem ){
+      if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
+        return elem;
+      }
+      elem = elem->next;
+    }
+  }
+  return 0;
+}
+
+/* Remove a single entry from the hash table given a pointer to that
+** element and a hash on the element's key.
+*/
+static void fts3RemoveElementByHash(
+  fts3Hash *pH,         /* The pH containing "elem" */
+  fts3HashElem* elem,   /* The element to be removed from the pH */
+  int h                 /* Hash value for the element */
+){
+  struct _fts3ht *pEntry;
+  if( elem->prev ){
+    elem->prev->next = elem->next; 
+  }else{
+    pH->first = elem->next;
+  }
+  if( elem->next ){
+    elem->next->prev = elem->prev;
+  }
+  pEntry = &pH->ht[h];
+  if( pEntry->chain==elem ){
+    pEntry->chain = elem->next;
+  }
+  pEntry->count--;
+  if( pEntry->count<=0 ){
+    pEntry->chain = 0;
+  }
+  if( pH->copyKey && elem->pKey ){
+    fts3HashFree(elem->pKey);
+  }
+  fts3HashFree( elem );
+  pH->count--;
+  if( pH->count<=0 ){
+    assert( pH->first==0 );
+    assert( pH->count==0 );
+    fts3HashClear(pH);
+  }
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *sqlite3Fts3HashFind(const fts3Hash *pH, const void *pKey, int nKey){
+  int h;                 /* A hash on key */
+  fts3HashElem *elem;    /* The element that matches key */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  if( pH==0 || pH->ht==0 ) return 0;
+  xHash = ftsHashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  h = (*xHash)(pKey,nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  elem = fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem ? elem->data : 0;
+}
+
+/* Insert an element into the hash table pH.  The key is pKey,nKey
+** and the data is "data".
+**
+** If no element exists with a matching key, then a new
+** element is created.  A copy of the key is made if the copyKey
+** flag is set.  NULL is returned.
+**
+** If another element already exists with the same key, then the
+** new data replaces the old data and the old data is returned.
+** The key is not copied in this instance.  If a malloc fails, then
+** the new data is returned and the hash table is unchanged.
+**
+** If the "data" parameter to this function is NULL, then the
+** element corresponding to "key" is removed from the hash table.
+*/
+void *sqlite3Fts3HashInsert(
+  fts3Hash *pH,        /* The hash table to insert into */
+  const void *pKey,    /* The key */
+  int nKey,            /* Number of bytes in the key */
+  void *data           /* The data */
+){
+  int hraw;                 /* Raw hash value of the key */
+  int h;                    /* the hash of the key modulo hash table size */
+  fts3HashElem *elem;       /* Used to loop thru the element list */
+  fts3HashElem *new_elem;   /* New element added to the pH */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  assert( pH!=0 );
+  xHash = ftsHashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  hraw = (*xHash)(pKey, nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  elem = fts3FindElementByHash(pH,pKey,nKey,h);
+  if( elem ){
+    void *old_data = elem->data;
+    if( data==0 ){
+      fts3RemoveElementByHash(pH,elem,h);
+    }else{
+      elem->data = data;
+    }
+    return old_data;
+  }
+  if( data==0 ) return 0;
+  new_elem = (fts3HashElem*)fts3HashMalloc( sizeof(fts3HashElem) );
+  if( new_elem==0 ) return data;
+  if( pH->copyKey && pKey!=0 ){
+    new_elem->pKey = fts3HashMalloc( nKey );
+    if( new_elem->pKey==0 ){
+      fts3HashFree(new_elem);
+      return data;
+    }
+    memcpy((void*)new_elem->pKey, pKey, nKey);
+  }else{
+    new_elem->pKey = (void*)pKey;
+  }
+  new_elem->nKey = nKey;
+  pH->count++;
+  if( pH->htsize==0 ){
+    fts3Rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      fts3HashFree(new_elem);
+      return data;
+    }
+  }
+  if( pH->count > pH->htsize ){
+    fts3Rehash(pH,pH->htsize*2);
+  }
+  assert( pH->htsize>0 );
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  fts3HashInsertElement(pH, &pH->ht[h], new_elem);
+  new_elem->data = data;
+  return 0;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.h
new file mode 100644
index 0000000..e01954e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_hash.h
@@ -0,0 +1,110 @@
+/*
+** 2001 September 22
+**
+** 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 is the header file for the generic hash-table implemenation
+** used in SQLite.  We've modified it slightly to serve as a standalone
+** hash table implementation for the full-text indexing module.
+**
+*/
+#ifndef _FTS3_HASH_H_
+#define _FTS3_HASH_H_
+
+/* Forward declarations of structures. */
+typedef struct fts3Hash fts3Hash;
+typedef struct fts3HashElem fts3HashElem;
+
+/* A complete hash table is an instance of the following structure.
+** The internals of this structure are intended to be opaque -- client
+** code should not attempt to access or modify the fields of this structure
+** directly.  Change this structure only by using the routines below.
+** However, many of the "procedures" and "functions" for modifying and
+** accessing this structure are really macros, so we can't really make
+** this structure opaque.
+*/
+struct fts3Hash {
+  char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
+  char copyKey;           /* True if copy of key made on insert */
+  int count;              /* Number of entries in this table */
+  fts3HashElem *first;    /* The first element of the array */
+  int htsize;             /* Number of buckets in the hash table */
+  struct _fts3ht {        /* the hash table */
+    int count;               /* Number of entries with this hash */
+    fts3HashElem *chain;     /* Pointer to first entry with this hash */
+  } *ht;
+};
+
+/* Each element in the hash table is an instance of the following 
+** structure.  All elements are stored on a single doubly-linked list.
+**
+** Again, this structure is intended to be opaque, but it can't really
+** be opaque because it is used by macros.
+*/
+struct fts3HashElem {
+  fts3HashElem *next, *prev; /* Next and previous elements in the table */
+  void *data;                /* Data associated with this element */
+  void *pKey; int nKey;      /* Key associated with this element */
+};
+
+/*
+** There are 2 different modes of operation for a hash table:
+**
+**   FTS3_HASH_STRING        pKey points to a string that is nKey bytes long
+**                           (including the null-terminator, if any).  Case
+**                           is respected in comparisons.
+**
+**   FTS3_HASH_BINARY        pKey points to binary data nKey bytes long. 
+**                           memcmp() is used to compare keys.
+**
+** A copy of the key is made if the copyKey parameter to fts3HashInit is 1.  
+*/
+#define FTS3_HASH_STRING    1
+#define FTS3_HASH_BINARY    2
+
+/*
+** Access routines.  To delete, insert a NULL pointer.
+*/
+void sqlite3Fts3HashInit(fts3Hash*, int keytype, int copyKey);
+void *sqlite3Fts3HashInsert(fts3Hash*, const void *pKey, int nKey, void *pData);
+void *sqlite3Fts3HashFind(const fts3Hash*, const void *pKey, int nKey);
+void sqlite3Fts3HashClear(fts3Hash*);
+
+/*
+** Shorthand for the functions above
+*/
+#define fts3HashInit   sqlite3Fts3HashInit
+#define fts3HashInsert sqlite3Fts3HashInsert
+#define fts3HashFind   sqlite3Fts3HashFind
+#define fts3HashClear  sqlite3Fts3HashClear
+
+/*
+** Macros for looping over all elements of a hash table.  The idiom is
+** like this:
+**
+**   fts3Hash h;
+**   fts3HashElem *p;
+**   ...
+**   for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){
+**     SomeStructure *pData = fts3HashData(p);
+**     // do something with pData
+**   }
+*/
+#define fts3HashFirst(H)  ((H)->first)
+#define fts3HashNext(E)   ((E)->next)
+#define fts3HashData(E)   ((E)->data)
+#define fts3HashKey(E)    ((E)->pKey)
+#define fts3HashKeysize(E) ((E)->nKey)
+
+/*
+** Number of entries in a hash table
+*/
+#define fts3HashCount(H)  ((H)->count)
+
+#endif /* _FTS3_HASH_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_icu.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_icu.c
new file mode 100644
index 0000000..e2d040c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_icu.c
@@ -0,0 +1,258 @@
+/*
+** 2007 June 22
+**
+** 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 implements a tokenizer for fts3 based on the ICU library.
+** 
+** $Id: fts3_icu.c,v 1.2 2007/10/24 21:52:37 shess Exp $
+*/
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+#ifdef SQLITE_ENABLE_ICU
+
+#include <assert.h>
+#include <string.h>
+#include "fts3_tokenizer.h"
+
+#include <unicode/ubrk.h>
+#include <unicode/ucol.h>
+#include <unicode/ustring.h>
+#include <unicode/utf16.h>
+
+typedef struct IcuTokenizer IcuTokenizer;
+typedef struct IcuCursor IcuCursor;
+
+struct IcuTokenizer {
+  sqlite3_tokenizer base;
+  char *zLocale;
+};
+
+struct IcuCursor {
+  sqlite3_tokenizer_cursor base;
+
+  UBreakIterator *pIter;      /* ICU break-iterator object */
+  int nChar;                  /* Number of UChar elements in pInput */
+  UChar *aChar;               /* Copy of input using utf-16 encoding */
+  int *aOffset;               /* Offsets of each character in utf-8 input */
+
+  int nBuffer;
+  char *zBuffer;
+
+  int iToken;
+};
+
+/*
+** Create a new tokenizer instance.
+*/
+static int icuCreate(
+  int argc,                            /* Number of entries in argv[] */
+  const char * const *argv,            /* Tokenizer creation arguments */
+  sqlite3_tokenizer **ppTokenizer      /* OUT: Created tokenizer */
+){
+  IcuTokenizer *p;
+  int n = 0;
+
+  if( argc>0 ){
+    n = strlen(argv[0])+1;
+  }
+  p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
+  if( !p ){
+    return SQLITE_NOMEM;
+  }
+  memset(p, 0, sizeof(IcuTokenizer));
+
+  if( n ){
+    p->zLocale = (char *)&p[1];
+    memcpy(p->zLocale, argv[0], n);
+  }
+
+  *ppTokenizer = (sqlite3_tokenizer *)p;
+
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int icuDestroy(sqlite3_tokenizer *pTokenizer){
+  IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
+  sqlite3_free(p);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is pInput[0..nBytes-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int icuOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *zInput,                    /* Input string */
+  int nInput,                            /* Length of zInput in bytes */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
+  IcuCursor *pCsr;
+
+  const int32_t opt = U_FOLD_CASE_DEFAULT;
+  UErrorCode status = U_ZERO_ERROR;
+  int nChar;
+
+  UChar32 c;
+  int iInput = 0;
+  int iOut = 0;
+
+  *ppCursor = 0;
+
+  if( -1 == nInput ) nInput = strlen(nInput);
+  nChar = nInput+1;
+  pCsr = (IcuCursor *)sqlite3_malloc(
+      sizeof(IcuCursor) +                /* IcuCursor */
+      nChar * sizeof(UChar) +            /* IcuCursor.aChar[] */
+      (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
+  );
+  if( !pCsr ){
+    return SQLITE_NOMEM;
+  }
+  memset(pCsr, 0, sizeof(IcuCursor));
+  pCsr->aChar = (UChar *)&pCsr[1];
+  pCsr->aOffset = (int *)&pCsr->aChar[nChar];
+
+  pCsr->aOffset[iOut] = iInput;
+  U8_NEXT(zInput, iInput, nInput, c); 
+  while( c>0 ){
+    int isError = 0;
+    c = u_foldCase(c, opt);
+    U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
+    if( isError ){
+      sqlite3_free(pCsr);
+      return SQLITE_ERROR;
+    }
+    pCsr->aOffset[iOut] = iInput;
+
+    if( iInput<nInput ){
+      U8_NEXT(zInput, iInput, nInput, c);
+    }else{
+      c = 0;
+    }
+  }
+
+  pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
+  if( !U_SUCCESS(status) ){
+    sqlite3_free(pCsr);
+    return SQLITE_ERROR;
+  }
+  pCsr->nChar = iOut;
+
+  ubrk_first(pCsr->pIter);
+  *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to icuOpen().
+*/
+static int icuClose(sqlite3_tokenizer_cursor *pCursor){
+  IcuCursor *pCsr = (IcuCursor *)pCursor;
+  ubrk_close(pCsr->pIter);
+  sqlite3_free(pCsr->zBuffer);
+  sqlite3_free(pCsr);
+  return SQLITE_OK;
+}
+
+/*
+** Extract the next token from a tokenization cursor.
+*/
+static int icuNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
+  const char **ppToken,               /* OUT: *ppToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  IcuCursor *pCsr = (IcuCursor *)pCursor;
+
+  int iStart = 0;
+  int iEnd = 0;
+  int nByte = 0;
+
+  while( iStart==iEnd ){
+    UChar32 c;
+
+    iStart = ubrk_current(pCsr->pIter);
+    iEnd = ubrk_next(pCsr->pIter);
+    if( iEnd==UBRK_DONE ){
+      return SQLITE_DONE;
+    }
+
+    while( iStart<iEnd ){
+      int iWhite = iStart;
+      U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
+      if( u_isspace(c) ){
+        iStart = iWhite;
+      }else{
+        break;
+      }
+    }
+    assert(iStart<=iEnd);
+  }
+
+  do {
+    UErrorCode status = U_ZERO_ERROR;
+    if( nByte ){
+      char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
+      if( !zNew ){
+        return SQLITE_NOMEM;
+      }
+      pCsr->zBuffer = zNew;
+      pCsr->nBuffer = nByte;
+    }
+
+    u_strToUTF8(
+        pCsr->zBuffer, pCsr->nBuffer, &nByte,    /* Output vars */
+        &pCsr->aChar[iStart], iEnd-iStart,       /* Input vars */
+        &status                                  /* Output success/failure */
+    );
+  } while( nByte>pCsr->nBuffer );
+
+  *ppToken = pCsr->zBuffer;
+  *pnBytes = nByte;
+  *piStartOffset = pCsr->aOffset[iStart];
+  *piEndOffset = pCsr->aOffset[iEnd];
+  *piPosition = pCsr->iToken++;
+
+  return SQLITE_OK;
+}
+
+/*
+** The set of routines that implement the simple tokenizer
+*/
+static const sqlite3_tokenizer_module icuTokenizerModule = {
+  0,                           /* iVersion */
+  icuCreate,                   /* xCreate  */
+  icuDestroy,                  /* xCreate  */
+  icuOpen,                     /* xOpen    */
+  icuClose,                    /* xClose   */
+  icuNext,                     /* xNext    */
+};
+
+/*
+** Set *ppModule to point at the implementation of the ICU tokenizer.
+*/
+void sqlite3Fts3IcuTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &icuTokenizerModule;
+}
+
+#endif /* defined(SQLITE_ENABLE_ICU) */
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_porter.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_porter.c
new file mode 100644
index 0000000..6ff67a9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_porter.c
@@ -0,0 +1,642 @@
+/*
+** 2006 September 30
+**
+** 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.
+**
+*************************************************************************
+** Implementation of the full-text-search tokenizer that implements
+** a Porter stemmer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS3 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS3 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts3_tokenizer.h"
+
+/*
+** Class derived from sqlite3_tokenizer
+*/
+typedef struct porter_tokenizer {
+  sqlite3_tokenizer base;      /* Base class */
+} porter_tokenizer;
+
+/*
+** Class derived from sqlit3_tokenizer_cursor
+*/
+typedef struct porter_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *zInput;          /* input we are tokenizing */
+  int nInput;                  /* size of the input */
+  int iOffset;                 /* current position in zInput */
+  int iToken;                  /* index of next token to be returned */
+  char *zToken;                /* storage for current token */
+  int nAllocated;              /* space allocated to zToken buffer */
+} porter_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module porterTokenizerModule;
+
+
+/*
+** Create a new tokenizer instance.
+*/
+static int porterCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  porter_tokenizer *t;
+  t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t));
+  if( t==NULL ) return SQLITE_NOMEM;
+  memset(t, 0, sizeof(*t));
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int porterDestroy(sqlite3_tokenizer *pTokenizer){
+  sqlite3_free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is zInput[0..nInput-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int porterOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *zInput, int nInput,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  porter_tokenizer_cursor *c;
+
+  c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->zInput = zInput;
+  if( zInput==0 ){
+    c->nInput = 0;
+  }else if( nInput<0 ){
+    c->nInput = (int)strlen(zInput);
+  }else{
+    c->nInput = nInput;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->zToken = NULL;               /* no space allocated, yet. */
+  c->nAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** porterOpen() above.
+*/
+static int porterClose(sqlite3_tokenizer_cursor *pCursor){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  sqlite3_free(c->zToken);
+  sqlite3_free(c);
+  return SQLITE_OK;
+}
+/*
+** Vowel or consonant
+*/
+static const char cType[] = {
+   0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,
+   1, 1, 1, 2, 1
+};
+
+/*
+** isConsonant() and isVowel() determine if their first character in
+** the string they point to is a consonant or a vowel, according
+** to Porter ruls.  
+**
+** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'.
+** 'Y' is a consonant unless it follows another consonant,
+** in which case it is a vowel.
+**
+** In these routine, the letters are in reverse order.  So the 'y' rule
+** is that 'y' is a consonant unless it is followed by another
+** consonent.
+*/
+static int isVowel(const char*);
+static int isConsonant(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return j;
+  return z[1]==0 || isVowel(z + 1);
+}
+static int isVowel(const char *z){
+  int j;
+  char x = *z;
+  if( x==0 ) return 0;
+  assert( x>='a' && x<='z' );
+  j = cType[x-'a'];
+  if( j<2 ) return 1-j;
+  return isConsonant(z + 1);
+}
+
+/*
+** Let any sequence of one or more vowels be represented by V and let
+** C be sequence of one or more consonants.  Then every word can be
+** represented as:
+**
+**           [C] (VC){m} [V]
+**
+** In prose:  A word is an optional consonant followed by zero or
+** vowel-consonant pairs followed by an optional vowel.  "m" is the
+** number of vowel consonant pairs.  This routine computes the value
+** of m for the first i bytes of a word.
+**
+** Return true if the m-value for z is 1 or more.  In other words,
+** return true if z contains at least one vowel that is followed
+** by a consonant.
+**
+** In this routine z[] is in reverse order.  So we are really looking
+** for an instance of of a consonant followed by a vowel.
+*/
+static int m_gt_0(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/* Like mgt0 above except we are looking for a value of m which is
+** exactly 1
+*/
+static int m_eq_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 1;
+  while( isConsonant(z) ){ z++; }
+  return *z==0;
+}
+
+/* Like mgt0 above except we are looking for a value of m>1 instead
+** or m>0
+*/
+static int m_gt_1(const char *z){
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isVowel(z) ){ z++; }
+  if( *z==0 ) return 0;
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if there is a vowel anywhere within z[0..n-1]
+*/
+static int hasVowel(const char *z){
+  while( isConsonant(z) ){ z++; }
+  return *z!=0;
+}
+
+/*
+** Return TRUE if the word ends in a double consonant.
+**
+** The text is reversed here. So we are really looking at
+** the first two characters of z[].
+*/
+static int doubleConsonant(const char *z){
+  return isConsonant(z) && z[0]==z[1] && isConsonant(z+1);
+}
+
+/*
+** Return TRUE if the word ends with three letters which
+** are consonant-vowel-consonent and where the final consonant
+** is not 'w', 'x', or 'y'.
+**
+** The word is reversed here.  So we are really checking the
+** first three letters and the first one cannot be in [wxy].
+*/
+static int star_oh(const char *z){
+  return
+    z[0]!=0 && isConsonant(z) &&
+    z[0]!='w' && z[0]!='x' && z[0]!='y' &&
+    z[1]!=0 && isVowel(z+1) &&
+    z[2]!=0 && isConsonant(z+2);
+}
+
+/*
+** If the word ends with zFrom and xCond() is true for the stem
+** of the word that preceeds the zFrom ending, then change the 
+** ending to zTo.
+**
+** The input word *pz and zFrom are both in reverse order.  zTo
+** is in normal order. 
+**
+** Return TRUE if zFrom matches.  Return FALSE if zFrom does not
+** match.  Not that TRUE is returned even if xCond() fails and
+** no substitution occurs.
+*/
+static int stem(
+  char **pz,             /* The word being stemmed (Reversed) */
+  const char *zFrom,     /* If the ending matches this... (Reversed) */
+  const char *zTo,       /* ... change the ending to this (not reversed) */
+  int (*xCond)(const char*)   /* Condition that must be true */
+){
+  char *z = *pz;
+  while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
+  if( *zFrom!=0 ) return 0;
+  if( xCond && !xCond(z) ) return 1;
+  while( *zTo ){
+    *(--z) = *(zTo++);
+  }
+  *pz = z;
+  return 1;
+}
+
+/*
+** This is the fallback stemmer used when the porter stemmer is
+** inappropriate.  The input word is copied into the output with
+** US-ASCII case folding.  If the input word is too long (more
+** than 20 bytes if it contains no digits or more than 6 bytes if
+** it contains digits) then word is truncated to 20 or 6 bytes
+** by taking 10 or 3 bytes from the beginning and end.
+*/
+static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, mx, j;
+  int hasDigit = 0;
+  for(i=0; i<nIn; i++){
+    int c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zOut[i] = c - 'A' + 'a';
+    }else{
+      if( c>='0' && c<='9' ) hasDigit = 1;
+      zOut[i] = c;
+    }
+  }
+  mx = hasDigit ? 3 : 10;
+  if( nIn>mx*2 ){
+    for(j=mx, i=nIn-mx; i<nIn; i++, j++){
+      zOut[j] = zOut[i];
+    }
+    i = j;
+  }
+  zOut[i] = 0;
+  *pnOut = i;
+}
+
+
+/*
+** Stem the input word zIn[0..nIn-1].  Store the output in zOut.
+** zOut is at least big enough to hold nIn bytes.  Write the actual
+** size of the output word (exclusive of the '\0' terminator) into *pnOut.
+**
+** Any upper-case characters in the US-ASCII character set ([A-Z])
+** are converted to lower case.  Upper-case UTF characters are
+** unchanged.
+**
+** Words that are longer than about 20 bytes are stemmed by retaining
+** a few bytes from the beginning and the end of the word.  If the
+** word contains digits, 3 bytes are taken from the beginning and
+** 3 bytes from the end.  For long words without digits, 10 bytes
+** are taken from each end.  US-ASCII case folding still applies.
+** 
+** If the input word contains not digits but does characters not 
+** in [a-zA-Z] then no stemming is attempted and this routine just 
+** copies the input into the input into the output with US-ASCII
+** case folding.
+**
+** Stemming never increases the length of the word.  So there is
+** no chance of overflowing the zOut buffer.
+*/
+static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
+  int i, j, c;
+  char zReverse[28];
+  char *z, *z2;
+  if( nIn<3 || nIn>=sizeof(zReverse)-7 ){
+    /* The word is too big or too small for the porter stemmer.
+    ** Fallback to the copy stemmer */
+    copy_stemmer(zIn, nIn, zOut, pnOut);
+    return;
+  }
+  for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
+    c = zIn[i];
+    if( c>='A' && c<='Z' ){
+      zReverse[j] = c + 'a' - 'A';
+    }else if( c>='a' && c<='z' ){
+      zReverse[j] = c;
+    }else{
+      /* The use of a character not in [a-zA-Z] means that we fallback
+      ** to the copy stemmer */
+      copy_stemmer(zIn, nIn, zOut, pnOut);
+      return;
+    }
+  }
+  memset(&zReverse[sizeof(zReverse)-5], 0, 5);
+  z = &zReverse[j+1];
+
+
+  /* Step 1a */
+  if( z[0]=='s' ){
+    if(
+     !stem(&z, "sess", "ss", 0) &&
+     !stem(&z, "sei", "i", 0)  &&
+     !stem(&z, "ss", "ss", 0)
+    ){
+      z++;
+    }
+  }
+
+  /* Step 1b */  
+  z2 = z;
+  if( stem(&z, "dee", "ee", m_gt_0) ){
+    /* Do nothing.  The work was all in the test */
+  }else if( 
+     (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
+      && z!=z2
+  ){
+     if( stem(&z, "ta", "ate", 0) ||
+         stem(&z, "lb", "ble", 0) ||
+         stem(&z, "zi", "ize", 0) ){
+       /* Do nothing.  The work was all in the test */
+     }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
+       z++;
+     }else if( m_eq_1(z) && star_oh(z) ){
+       *(--z) = 'e';
+     }
+  }
+
+  /* Step 1c */
+  if( z[0]=='y' && hasVowel(z+1) ){
+    z[0] = 'i';
+  }
+
+  /* Step 2 */
+  switch( z[1] ){
+   case 'a':
+     stem(&z, "lanoita", "ate", m_gt_0) ||
+     stem(&z, "lanoit", "tion", m_gt_0);
+     break;
+   case 'c':
+     stem(&z, "icne", "ence", m_gt_0) ||
+     stem(&z, "icna", "ance", m_gt_0);
+     break;
+   case 'e':
+     stem(&z, "rezi", "ize", m_gt_0);
+     break;
+   case 'g':
+     stem(&z, "igol", "log", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "ilb", "ble", m_gt_0) ||
+     stem(&z, "illa", "al", m_gt_0) ||
+     stem(&z, "iltne", "ent", m_gt_0) ||
+     stem(&z, "ile", "e", m_gt_0) ||
+     stem(&z, "ilsuo", "ous", m_gt_0);
+     break;
+   case 'o':
+     stem(&z, "noitazi", "ize", m_gt_0) ||
+     stem(&z, "noita", "ate", m_gt_0) ||
+     stem(&z, "rota", "ate", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "msila", "al", m_gt_0) ||
+     stem(&z, "ssenevi", "ive", m_gt_0) ||
+     stem(&z, "ssenluf", "ful", m_gt_0) ||
+     stem(&z, "ssensuo", "ous", m_gt_0);
+     break;
+   case 't':
+     stem(&z, "itila", "al", m_gt_0) ||
+     stem(&z, "itivi", "ive", m_gt_0) ||
+     stem(&z, "itilib", "ble", m_gt_0);
+     break;
+  }
+
+  /* Step 3 */
+  switch( z[0] ){
+   case 'e':
+     stem(&z, "etaci", "ic", m_gt_0) ||
+     stem(&z, "evita", "", m_gt_0)   ||
+     stem(&z, "ezila", "al", m_gt_0);
+     break;
+   case 'i':
+     stem(&z, "itici", "ic", m_gt_0);
+     break;
+   case 'l':
+     stem(&z, "laci", "ic", m_gt_0) ||
+     stem(&z, "luf", "", m_gt_0);
+     break;
+   case 's':
+     stem(&z, "ssen", "", m_gt_0);
+     break;
+  }
+
+  /* Step 4 */
+  switch( z[1] ){
+   case 'a':
+     if( z[0]=='l' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'c':
+     if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e')  && m_gt_1(z+4)  ){
+       z += 4;
+     }
+     break;
+   case 'e':
+     if( z[0]=='r' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'i':
+     if( z[0]=='c' && m_gt_1(z+2) ){
+       z += 2;
+     }
+     break;
+   case 'l':
+     if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
+       z += 4;
+     }
+     break;
+   case 'n':
+     if( z[0]=='t' ){
+       if( z[2]=='a' ){
+         if( m_gt_1(z+3) ){
+           z += 3;
+         }
+       }else if( z[2]=='e' ){
+         stem(&z, "tneme", "", m_gt_1) ||
+         stem(&z, "tnem", "", m_gt_1) ||
+         stem(&z, "tne", "", m_gt_1);
+       }
+     }
+     break;
+   case 'o':
+     if( z[0]=='u' ){
+       if( m_gt_1(z+2) ){
+         z += 2;
+       }
+     }else if( z[3]=='s' || z[3]=='t' ){
+       stem(&z, "noi", "", m_gt_1);
+     }
+     break;
+   case 's':
+     if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 't':
+     stem(&z, "eta", "", m_gt_1) ||
+     stem(&z, "iti", "", m_gt_1);
+     break;
+   case 'u':
+     if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+   case 'v':
+   case 'z':
+     if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
+       z += 3;
+     }
+     break;
+  }
+
+  /* Step 5a */
+  if( z[0]=='e' ){
+    if( m_gt_1(z+1) ){
+      z++;
+    }else if( m_eq_1(z+1) && !star_oh(z+1) ){
+      z++;
+    }
+  }
+
+  /* Step 5b */
+  if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
+    z++;
+  }
+
+  /* z[] is now the stemmed word in reverse order.  Flip it back
+  ** around into forward order and return.
+  */
+  *pnOut = i = strlen(z);
+  zOut[i] = 0;
+  while( *z ){
+    zOut[--i] = *(z++);
+  }
+}
+
+/*
+** Characters that can be part of a token.  We assume any character
+** whose value is greater than 0x80 (any UTF character) can be
+** part of a token.  In other words, delimiters all must have
+** values of 0x7f or lower.
+*/
+static const char porterIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30]))
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to porterOpen().
+*/
+static int porterNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by porterOpen */
+  const char **pzToken,               /* OUT: *pzToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
+  const char *z = c->zInput;
+
+  while( c->iOffset<c->nInput ){
+    int iStartOffset, ch;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int n = c->iOffset-iStartOffset;
+      if( n>c->nAllocated ){
+        c->nAllocated = n+20;
+        c->zToken = sqlite3_realloc(c->zToken, c->nAllocated);
+        if( c->zToken==NULL ) return SQLITE_NOMEM;
+      }
+      porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
+      *pzToken = c->zToken;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the porter-stemmer tokenizer
+*/
+static const sqlite3_tokenizer_module porterTokenizerModule = {
+  0,
+  porterCreate,
+  porterDestroy,
+  porterOpen,
+  porterClose,
+  porterNext,
+};
+
+/*
+** Allocate a new porter tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts3PorterTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &porterTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.c
new file mode 100644
index 0000000..ef19995
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.c
@@ -0,0 +1,371 @@
+/*
+** 2007 June 22
+**
+** 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 is part of an SQLite module implementing full-text search.
+** This particular file implements the generic tokenizer interface.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS3 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS3 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+#include "sqlite3ext.h"
+#ifndef SQLITE_CORE
+  SQLITE_EXTENSION_INIT1
+#endif
+
+#include "fts3_hash.h"
+#include "fts3_tokenizer.h"
+#include <assert.h>
+
+/*
+** Implementation of the SQL scalar function for accessing the underlying 
+** hash table. This function may be called as follows:
+**
+**   SELECT <function-name>(<key-name>);
+**   SELECT <function-name>(<key-name>, <pointer>);
+**
+** where <function-name> is the name passed as the second argument
+** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer').
+**
+** If the <pointer> argument is specified, it must be a blob value
+** containing a pointer to be stored as the hash data corresponding
+** to the string <key-name>. If <pointer> is not specified, then
+** the string <key-name> must already exist in the has table. Otherwise,
+** an error is returned.
+**
+** Whether or not the <pointer> argument is specified, the value returned
+** is a blob containing the pointer stored as the hash data corresponding
+** to string <key-name> (after the hash-table is updated, if applicable).
+*/
+static void scalarFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  fts3Hash *pHash;
+  void *pPtr = 0;
+  const unsigned char *zName;
+  int nName;
+
+  assert( argc==1 || argc==2 );
+
+  pHash = (fts3Hash *)sqlite3_user_data(context);
+
+  zName = sqlite3_value_text(argv[0]);
+  nName = sqlite3_value_bytes(argv[0])+1;
+
+  if( argc==2 ){
+    void *pOld;
+    int n = sqlite3_value_bytes(argv[1]);
+    if( n!=sizeof(pPtr) ){
+      sqlite3_result_error(context, "argument type mismatch", -1);
+      return;
+    }
+    pPtr = *(void **)sqlite3_value_blob(argv[1]);
+    pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
+    if( pOld==pPtr ){
+      sqlite3_result_error(context, "out of memory", -1);
+      return;
+    }
+  }else{
+    pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
+    if( !pPtr ){
+      char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
+      sqlite3_result_error(context, zErr, -1);
+      sqlite3_free(zErr);
+      return;
+    }
+  }
+
+  sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
+}
+
+#ifdef SQLITE_TEST
+
+#include <tcl.h>
+#include <string.h>
+
+/*
+** Implementation of a special SQL scalar function for testing tokenizers 
+** designed to be used in concert with the Tcl testing framework. This
+** function must be called with two arguments:
+**
+**   SELECT <function-name>(<key-name>, <input-string>);
+**   SELECT <function-name>(<key-name>, <pointer>);
+**
+** where <function-name> is the name passed as the second argument
+** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer')
+** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test').
+**
+** The return value is a string that may be interpreted as a Tcl
+** list. For each token in the <input-string>, three elements are
+** added to the returned list. The first is the token position, the 
+** second is the token text (folded, stemmed, etc.) and the third is the
+** substring of <input-string> associated with the token. For example, 
+** using the built-in "simple" tokenizer:
+**
+**   SELECT fts_tokenizer_test('simple', 'I don't see how');
+**
+** will return the string:
+**
+**   "{0 i I 1 dont don't 2 see see 3 how how}"
+**   
+*/
+static void testFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  fts3Hash *pHash;
+  sqlite3_tokenizer_module *p;
+  sqlite3_tokenizer *pTokenizer = 0;
+  sqlite3_tokenizer_cursor *pCsr = 0;
+
+  const char *zErr = 0;
+
+  const char *zName;
+  int nName;
+  const char *zInput;
+  int nInput;
+
+  const char *zArg = 0;
+
+  const char *zToken;
+  int nToken;
+  int iStart;
+  int iEnd;
+  int iPos;
+
+  Tcl_Obj *pRet;
+
+  assert( argc==2 || argc==3 );
+
+  nName = sqlite3_value_bytes(argv[0]);
+  zName = (const char *)sqlite3_value_text(argv[0]);
+  nInput = sqlite3_value_bytes(argv[argc-1]);
+  zInput = (const char *)sqlite3_value_text(argv[argc-1]);
+
+  if( argc==3 ){
+    zArg = (const char *)sqlite3_value_text(argv[1]);
+  }
+
+  pHash = (fts3Hash *)sqlite3_user_data(context);
+  p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
+
+  if( !p ){
+    char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
+    sqlite3_result_error(context, zErr, -1);
+    sqlite3_free(zErr);
+    return;
+  }
+
+  pRet = Tcl_NewObj();
+  Tcl_IncrRefCount(pRet);
+
+  if( SQLITE_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
+    zErr = "error in xCreate()";
+    goto finish;
+  }
+  pTokenizer->pModule = p;
+  if( SQLITE_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
+    zErr = "error in xOpen()";
+    goto finish;
+  }
+  pCsr->pTokenizer = pTokenizer;
+
+  while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
+    zToken = &zInput[iStart];
+    nToken = iEnd-iStart;
+    Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
+  }
+
+  if( SQLITE_OK!=p->xClose(pCsr) ){
+    zErr = "error in xClose()";
+    goto finish;
+  }
+  if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
+    zErr = "error in xDestroy()";
+    goto finish;
+  }
+
+finish:
+  if( zErr ){
+    sqlite3_result_error(context, zErr, -1);
+  }else{
+    sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
+  }
+  Tcl_DecrRefCount(pRet);
+}
+
+static
+int registerTokenizer(
+  sqlite3 *db, 
+  char *zName, 
+  const sqlite3_tokenizer_module *p
+){
+  int rc;
+  sqlite3_stmt *pStmt;
+  const char zSql[] = "SELECT fts3_tokenizer(?, ?)";
+
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+  sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
+  sqlite3_step(pStmt);
+
+  return sqlite3_finalize(pStmt);
+}
+
+static
+int queryTokenizer(
+  sqlite3 *db, 
+  char *zName,  
+  const sqlite3_tokenizer_module **pp
+){
+  int rc;
+  sqlite3_stmt *pStmt;
+  const char zSql[] = "SELECT fts3_tokenizer(?)";
+
+  *pp = 0;
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+  if( SQLITE_ROW==sqlite3_step(pStmt) ){
+    if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+      memcpy(pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+    }
+  }
+
+  return sqlite3_finalize(pStmt);
+}
+
+void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
+
+/*
+** Implementation of the scalar function fts3_tokenizer_internal_test().
+** This function is used for testing only, it is not included in the
+** build unless SQLITE_TEST is defined.
+**
+** The purpose of this is to test that the fts3_tokenizer() function
+** can be used as designed by the C-code in the queryTokenizer and
+** registerTokenizer() functions above. These two functions are repeated
+** in the README.tokenizer file as an example, so it is important to
+** test them.
+**
+** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar
+** function with no arguments. An assert() will fail if a problem is
+** detected. i.e.:
+**
+**     SELECT fts3_tokenizer_internal_test();
+**
+*/
+static void intTestFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int rc;
+  const sqlite3_tokenizer_module *p1;
+  const sqlite3_tokenizer_module *p2;
+  sqlite3 *db = (sqlite3 *)sqlite3_user_data(context);
+
+  /* Test the query function */
+  sqlite3Fts3SimpleTokenizerModule(&p1);
+  rc = queryTokenizer(db, "simple", &p2);
+  assert( rc==SQLITE_OK );
+  assert( p1==p2 );
+  rc = queryTokenizer(db, "nosuchtokenizer", &p2);
+  assert( rc==SQLITE_ERROR );
+  assert( p2==0 );
+  assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
+
+  /* Test the storage function */
+  rc = registerTokenizer(db, "nosuchtokenizer", p1);
+  assert( rc==SQLITE_OK );
+  rc = queryTokenizer(db, "nosuchtokenizer", &p2);
+  assert( rc==SQLITE_OK );
+  assert( p2==p1 );
+
+  sqlite3_result_text(context, "ok", -1, SQLITE_STATIC);
+}
+
+#endif
+
+/*
+** Set up SQL objects in database db used to access the contents of
+** the hash table pointed to by argument pHash. The hash table must
+** been initialised to use string keys, and to take a private copy 
+** of the key when a value is inserted. i.e. by a call similar to:
+**
+**    sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
+**
+** This function adds a scalar function (see header comment above
+** scalarFunc() in this file for details) and, if ENABLE_TABLE is
+** defined at compilation time, a temporary virtual table (see header 
+** comment above struct HashTableVtab) to the database schema. Both 
+** provide read/write access to the contents of *pHash.
+**
+** The third argument to this function, zName, is used as the name
+** of both the scalar and, if created, the virtual table.
+*/
+int sqlite3Fts3InitHashTable(
+  sqlite3 *db, 
+  fts3Hash *pHash, 
+  const char *zName
+){
+  int rc = SQLITE_OK;
+  void *p = (void *)pHash;
+  const int any = SQLITE_ANY;
+  char *zTest = 0;
+  char *zTest2 = 0;
+
+#ifdef SQLITE_TEST
+  void *pdb = (void *)db;
+  zTest = sqlite3_mprintf("%s_test", zName);
+  zTest2 = sqlite3_mprintf("%s_internal_test", zName);
+  if( !zTest || !zTest2 ){
+    rc = SQLITE_NOMEM;
+  }
+#endif
+
+  if( rc!=SQLITE_OK
+   || (rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0))
+#ifdef SQLITE_TEST
+   || (rc = sqlite3_create_function(db, zTest, 2, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest, 3, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0))
+#endif
+  );
+
+  sqlite3_free(zTest);
+  sqlite3_free(zTest2);
+  return rc;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.h b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.h
new file mode 100644
index 0000000..4faef56
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer.h
@@ -0,0 +1,145 @@
+/*
+** 2006 July 10
+**
+** The author disclaims copyright to this source code.
+**
+*************************************************************************
+** Defines the interface to tokenizers used by fulltext-search.  There
+** are three basic components:
+**
+** sqlite3_tokenizer_module is a singleton defining the tokenizer
+** interface functions.  This is essentially the class structure for
+** tokenizers.
+**
+** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
+** including customization information defined at creation time.
+**
+** sqlite3_tokenizer_cursor is generated by a tokenizer to generate
+** tokens from a particular input.
+*/
+#ifndef _FTS3_TOKENIZER_H_
+#define _FTS3_TOKENIZER_H_
+
+/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
+** If tokenizers are to be allowed to call sqlite3_*() functions, then
+** we will need a way to register the API consistently.
+*/
+#include "sqlite3.h"
+
+/*
+** Structures used by the tokenizer interface. When a new tokenizer
+** implementation is registered, the caller provides a pointer to
+** an sqlite3_tokenizer_module containing pointers to the callback
+** functions that make up an implementation.
+**
+** When an fts3 table is created, it passes any arguments passed to
+** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the
+** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer
+** implementation. The xCreate() function in turn returns an 
+** sqlite3_tokenizer structure representing the specific tokenizer to
+** be used for the fts3 table (customized by the tokenizer clause arguments).
+**
+** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen()
+** method is called. It returns an sqlite3_tokenizer_cursor object
+** that may be used to tokenize a specific input buffer based on
+** the tokenization rules supplied by a specific sqlite3_tokenizer
+** object.
+*/
+typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module;
+typedef struct sqlite3_tokenizer sqlite3_tokenizer;
+typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
+
+struct sqlite3_tokenizer_module {
+
+  /*
+  ** Structure version. Should always be set to 0.
+  */
+  int iVersion;
+
+  /*
+  ** Create a new tokenizer. The values in the argv[] array are the
+  ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL
+  ** TABLE statement that created the fts3 table. For example, if
+  ** the following SQL is executed:
+  **
+  **   CREATE .. USING fts3( ... , tokenizer <tokenizer-name> arg1 arg2)
+  **
+  ** then argc is set to 2, and the argv[] array contains pointers
+  ** to the strings "arg1" and "arg2".
+  **
+  ** This method should return either SQLITE_OK (0), or an SQLite error 
+  ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
+  ** to point at the newly created tokenizer structure. The generic
+  ** sqlite3_tokenizer.pModule variable should not be initialised by
+  ** this callback. The caller will do so.
+  */
+  int (*xCreate)(
+    int argc,                           /* Size of argv array */
+    const char *const*argv,             /* Tokenizer argument strings */
+    sqlite3_tokenizer **ppTokenizer     /* OUT: Created tokenizer */
+  );
+
+  /*
+  ** Destroy an existing tokenizer. The fts3 module calls this method
+  ** exactly once for each successful call to xCreate().
+  */
+  int (*xDestroy)(sqlite3_tokenizer *pTokenizer);
+
+  /*
+  ** Create a tokenizer cursor to tokenize an input buffer. The caller
+  ** is responsible for ensuring that the input buffer remains valid
+  ** until the cursor is closed (using the xClose() method). 
+  */
+  int (*xOpen)(
+    sqlite3_tokenizer *pTokenizer,       /* Tokenizer object */
+    const char *pInput, int nBytes,      /* Input buffer */
+    sqlite3_tokenizer_cursor **ppCursor  /* OUT: Created tokenizer cursor */
+  );
+
+  /*
+  ** Destroy an existing tokenizer cursor. The fts3 module calls this 
+  ** method exactly once for each successful call to xOpen().
+  */
+  int (*xClose)(sqlite3_tokenizer_cursor *pCursor);
+
+  /*
+  ** Retrieve the next token from the tokenizer cursor pCursor. This
+  ** method should either return SQLITE_OK and set the values of the
+  ** "OUT" variables identified below, or SQLITE_DONE to indicate that
+  ** the end of the buffer has been reached, or an SQLite error code.
+  **
+  ** *ppToken should be set to point at a buffer containing the 
+  ** normalized version of the token (i.e. after any case-folding and/or
+  ** stemming has been performed). *pnBytes should be set to the length
+  ** of this buffer in bytes. The input text that generated the token is
+  ** identified by the byte offsets returned in *piStartOffset and
+  ** *piEndOffset.
+  **
+  ** The buffer *ppToken is set to point at is managed by the tokenizer
+  ** implementation. It is only required to be valid until the next call
+  ** to xNext() or xClose(). 
+  */
+  /* TODO(shess) current implementation requires pInput to be
+  ** nul-terminated.  This should either be fixed, or pInput/nBytes
+  ** should be converted to zInput.
+  */
+  int (*xNext)(
+    sqlite3_tokenizer_cursor *pCursor,   /* Tokenizer cursor */
+    const char **ppToken, int *pnBytes,  /* OUT: Normalized text for token */
+    int *piStartOffset,  /* OUT: Byte offset of token in input buffer */
+    int *piEndOffset,    /* OUT: Byte offset of end of token in input buffer */
+    int *piPosition      /* OUT: Number of tokens returned before this one */
+  );
+};
+
+struct sqlite3_tokenizer {
+  const sqlite3_tokenizer_module *pModule;  /* The module for this tokenizer */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+struct sqlite3_tokenizer_cursor {
+  sqlite3_tokenizer *pTokenizer;       /* Tokenizer for this cursor. */
+  /* Tokenizer implementations will typically add additional fields */
+};
+
+#endif /* _FTS3_TOKENIZER_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer1.c b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer1.c
new file mode 100644
index 0000000..da255d9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/fts3_tokenizer1.c
@@ -0,0 +1,230 @@
+/*
+** 2006 Oct 10
+**
+** 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.
+**
+******************************************************************************
+**
+** Implementation of the "simple" full-text-search tokenizer.
+*/
+
+/*
+** The code in this file is only compiled if:
+**
+**     * The FTS3 module is being built as an extension
+**       (in which case SQLITE_CORE is not defined), or
+**
+**     * The FTS3 module is being built into the core of
+**       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
+*/
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fts3_tokenizer.h"
+
+typedef struct simple_tokenizer {
+  sqlite3_tokenizer base;
+  char delim[128];             /* flag ASCII delimiters */
+} simple_tokenizer;
+
+typedef struct simple_tokenizer_cursor {
+  sqlite3_tokenizer_cursor base;
+  const char *pInput;          /* input we are tokenizing */
+  int nBytes;                  /* size of the input */
+  int iOffset;                 /* current position in pInput */
+  int iToken;                  /* index of next token to be returned */
+  char *pToken;                /* storage for current token */
+  int nTokenAllocated;         /* space allocated to zToken buffer */
+} simple_tokenizer_cursor;
+
+
+/* Forward declaration */
+static const sqlite3_tokenizer_module simpleTokenizerModule;
+
+static int simpleDelim(simple_tokenizer *t, unsigned char c){
+  return c<0x80 && t->delim[c];
+}
+
+/*
+** Create a new tokenizer instance.
+*/
+static int simpleCreate(
+  int argc, const char * const *argv,
+  sqlite3_tokenizer **ppTokenizer
+){
+  simple_tokenizer *t;
+
+  t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t));
+  if( t==NULL ) return SQLITE_NOMEM;
+  memset(t, 0, sizeof(*t));
+
+  /* TODO(shess) Delimiters need to remain the same from run to run,
+  ** else we need to reindex.  One solution would be a meta-table to
+  ** track such information in the database, then we'd only want this
+  ** information on the initial create.
+  */
+  if( argc>1 ){
+    int i, n = strlen(argv[1]);
+    for(i=0; i<n; i++){
+      unsigned char ch = argv[1][i];
+      /* We explicitly don't support UTF-8 delimiters for now. */
+      if( ch>=0x80 ){
+        sqlite3_free(t);
+        return SQLITE_ERROR;
+      }
+      t->delim[ch] = 1;
+    }
+  } else {
+    /* Mark non-alphanumeric ASCII characters as delimiters */
+    int i;
+    for(i=1; i<0x80; i++){
+      t->delim[i] = !isalnum(i);
+    }
+  }
+
+  *ppTokenizer = &t->base;
+  return SQLITE_OK;
+}
+
+/*
+** Destroy a tokenizer
+*/
+static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
+  sqlite3_free(pTokenizer);
+  return SQLITE_OK;
+}
+
+/*
+** Prepare to begin tokenizing a particular string.  The input
+** string to be tokenized is pInput[0..nBytes-1].  A cursor
+** used to incrementally tokenize this string is returned in 
+** *ppCursor.
+*/
+static int simpleOpen(
+  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
+  const char *pInput, int nBytes,        /* String to be tokenized */
+  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
+){
+  simple_tokenizer_cursor *c;
+
+  c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
+  if( c==NULL ) return SQLITE_NOMEM;
+
+  c->pInput = pInput;
+  if( pInput==0 ){
+    c->nBytes = 0;
+  }else if( nBytes<0 ){
+    c->nBytes = (int)strlen(pInput);
+  }else{
+    c->nBytes = nBytes;
+  }
+  c->iOffset = 0;                 /* start tokenizing at the beginning */
+  c->iToken = 0;
+  c->pToken = NULL;               /* no space allocated, yet. */
+  c->nTokenAllocated = 0;
+
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tokenization cursor previously opened by a call to
+** simpleOpen() above.
+*/
+static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  sqlite3_free(c->pToken);
+  sqlite3_free(c);
+  return SQLITE_OK;
+}
+
+/*
+** Extract the next token from a tokenization cursor.  The cursor must
+** have been opened by a prior call to simpleOpen().
+*/
+static int simpleNext(
+  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
+  const char **ppToken,               /* OUT: *ppToken is the token text */
+  int *pnBytes,                       /* OUT: Number of bytes in token */
+  int *piStartOffset,                 /* OUT: Starting offset of token */
+  int *piEndOffset,                   /* OUT: Ending offset of token */
+  int *piPosition                     /* OUT: Position integer of token */
+){
+  simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
+  simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
+  unsigned char *p = (unsigned char *)c->pInput;
+
+  while( c->iOffset<c->nBytes ){
+    int iStartOffset;
+
+    /* Scan past delimiter characters */
+    while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    /* Count non-delimiter characters. */
+    iStartOffset = c->iOffset;
+    while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
+      c->iOffset++;
+    }
+
+    if( c->iOffset>iStartOffset ){
+      int i, n = c->iOffset-iStartOffset;
+      if( n>c->nTokenAllocated ){
+        c->nTokenAllocated = n+20;
+        c->pToken = sqlite3_realloc(c->pToken, c->nTokenAllocated);
+        if( c->pToken==NULL ) return SQLITE_NOMEM;
+      }
+      for(i=0; i<n; i++){
+        /* TODO(shess) This needs expansion to handle UTF-8
+        ** case-insensitivity.
+        */
+        unsigned char ch = p[iStartOffset+i];
+        c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
+      }
+      *ppToken = c->pToken;
+      *pnBytes = n;
+      *piStartOffset = iStartOffset;
+      *piEndOffset = c->iOffset;
+      *piPosition = c->iToken++;
+
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_DONE;
+}
+
+/*
+** The set of routines that implement the simple tokenizer
+*/
+static const sqlite3_tokenizer_module simpleTokenizerModule = {
+  0,
+  simpleCreate,
+  simpleDestroy,
+  simpleOpen,
+  simpleClose,
+  simpleNext,
+};
+
+/*
+** Allocate a new simple tokenizer.  Return a pointer to the new
+** tokenizer in *ppModule
+*/
+void sqlite3Fts3SimpleTokenizerModule(
+  sqlite3_tokenizer_module const**ppModule
+){
+  *ppModule = &simpleTokenizerModule;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/fts3/mkfts3amal.tcl b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/mkfts3amal.tcl
new file mode 100644
index 0000000..0590487
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/fts3/mkfts3amal.tcl
@@ -0,0 +1,115 @@
+#!/usr/bin/tclsh
+#
+# This script builds a single C code file holding all of FTS3 code.
+# The name of the output file is fts3amal.c.  To build this file,
+# first do:
+#
+#      make target_source
+#
+# The make target above moves all of the source code files into
+# a subdirectory named "tsrc".  (This script expects to find the files
+# there and will not work if they are not found.)
+#
+# After the "tsrc" directory has been created and populated, run
+# this script:
+#
+#      tclsh mkfts3amal.tcl
+#
+# The amalgamated FTS3 code will be written into fts3amal.c
+#
+
+# Open the output file and write a header comment at the beginning
+# of the file.
+#
+set out [open fts3amal.c w]
+set today [clock format [clock seconds] -format "%Y-%m-%d %H:%M:%S UTC" -gmt 1]
+puts $out [subst \
+{/******************************************************************************
+** This file is an amalgamation of separate C source files from the SQLite
+** Full Text Search extension 2 (fts3).  By combining all the individual C 
+** code  files into this single large file, the entire code can be compiled 
+** as a one translation unit.  This allows many compilers to do optimizations
+** that would not be possible if the files were compiled separately.  It also
+** makes the code easier to import into other projects.
+**
+** This amalgamation was generated on $today.
+*/}]
+
+# These are the header files used by FTS3.  The first time any of these 
+# files are seen in a #include statement in the C code, include the complete
+# text of the file in-line.  The file only needs to be included once.
+#
+foreach hdr {
+   fts3.h
+   fts3_hash.h
+   fts3_tokenizer.h
+   sqlite3.h
+   sqlite3ext.h
+} {
+  set available_hdr($hdr) 1
+}
+
+# 78 stars used for comment formatting.
+set s78 \
+{*****************************************************************************}
+
+# Insert a comment into the code
+#
+proc section_comment {text} {
+  global out s78
+  set n [string length $text]
+  set nstar [expr {60 - $n}]
+  set stars [string range $s78 0 $nstar]
+  puts $out "/************** $text $stars/"
+}
+
+# Read the source file named $filename and write it into the
+# sqlite3.c output file.  If any #include statements are seen,
+# process them approprately.
+#
+proc copy_file {filename} {
+  global seen_hdr available_hdr out
+  set tail [file tail $filename]
+  section_comment "Begin file $tail"
+  set in [open $filename r]
+  while {![eof $in]} {
+    set line [gets $in]
+    if {[regexp {^#\s*include\s+["<]([^">]+)[">]} $line all hdr]} {
+      if {[info exists available_hdr($hdr)]} {
+        if {$available_hdr($hdr)} {
+          section_comment "Include $hdr in the middle of $tail"
+          copy_file tsrc/$hdr
+          section_comment "Continuing where we left off in $tail"
+        }
+      } elseif {![info exists seen_hdr($hdr)]} {
+        set seen_hdr($hdr) 1
+        puts $out $line
+      }
+    } elseif {[regexp {^#ifdef __cplusplus} $line]} {
+      puts $out "#if 0"
+    } elseif {[regexp {^#line} $line]} {
+      # Skip #line directives.
+    } else {
+      puts $out $line
+    }
+  }
+  close $in
+  section_comment "End of $tail"
+}
+
+
+# Process the source files.  Process files containing commonly
+# used subroutines first in order to help the compiler find
+# inlining opportunities.
+#
+foreach file {
+   fts3.c
+   fts3_hash.c
+   fts3_porter.c
+   fts3_tokenizer.c
+   fts3_tokenizer1.c
+} {
+  copy_file tsrc/$file
+}
+
+close $out
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Entries b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Entries
new file mode 100644
index 0000000..bd8993c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Entries
@@ -0,0 +1,3 @@
+/README.txt/1.2/Fri Jun 22 15:21:16 2007//
+/icu.c/1.7/Thu Dec 13 21:54:11 2007//
+D
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Repository b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Repository
new file mode 100644
index 0000000..e07a9e2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Repository
@@ -0,0 +1 @@
+sqlite/ext/icu
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Root b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Root
new file mode 100644
index 0000000..a3ae5d0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/icu/CVS/Root
@@ -0,0 +1 @@
+:pserver:drh@sqlite.org:/sqlite
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/icu/README.txt b/client/src/thirdparty/sqlite-3.4.2/ext/icu/README.txt
new file mode 100644
index 0000000..5c995cc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/icu/README.txt
@@ -0,0 +1,170 @@
+
+This directory contains source code for the SQLite "ICU" extension, an
+integration of the "International Components for Unicode" library with
+SQLite. Documentation follows.
+
+    1. Features
+    
+        1.1  SQL Scalars upper() and lower()
+        1.2  Unicode Aware LIKE Operator
+        1.3  ICU Collation Sequences
+        1.4  SQL REGEXP Operator
+    
+    2. Compilation and Usage
+    
+    3. Bugs, Problems and Security Issues
+    
+        3.1  The "case_sensitive_like" Pragma
+        3.2  The SQLITE_MAX_LIKE_PATTERN_LENGTH Macro
+        3.3  Collation Sequence Security Issue
+
+
+1. FEATURES
+
+  1.1  SQL Scalars upper() and lower()
+
+    SQLite's built-in implementations of these two functions only 
+    provide case mapping for the 26 letters used in the English
+    language. The ICU based functions provided by this extension
+    provide case mapping, where defined, for the full range of 
+    unicode characters.
+
+    ICU provides two types of case mapping, "general" case mapping and
+    "language specific". Refer to ICU documentation for the differences
+    between the two. Specifically:
+
+       http://www.icu-project.org/userguide/caseMappings.html
+       http://www.icu-project.org/userguide/posix.html#case_mappings
+
+    To utilise "general" case mapping, the upper() or lower() scalar 
+    functions are invoked with one argument:
+
+        upper('ABC') -> 'abc'
+        lower('abc') -> 'ABC'
+
+    To access ICU "language specific" case mapping, upper() or lower()
+    should be invoked with two arguments. The second argument is the name
+    of the locale to use. Passing an empty string ("") or SQL NULL value
+    as the second argument is the same as invoking the 1 argument version
+    of upper() or lower():
+
+        lower('I', 'en_us') -> 'i'
+        lower('I', 'tr_tr') -> 'ı' (small dotless i)
+
+  1.2  Unicode Aware LIKE Operator
+
+    Similarly to the upper() and lower() functions, the built-in SQLite LIKE
+    operator understands case equivalence for the 26 letters of the English
+    language alphabet. The implementation of LIKE included in this
+    extension uses the ICU function u_foldCase() to provide case
+    independent comparisons for the full range of unicode characters.  
+
+    The U_FOLD_CASE_DEFAULT flag is passed to u_foldCase(), meaning the
+    dotless 'I' character used in the Turkish language is considered
+    to be in the same equivalence class as the dotted 'I' character
+    used by many languages (including English).
+
+  1.3  ICU Collation Sequences
+
+    A special SQL scalar function, icu_load_collation() is provided that 
+    may be used to register ICU collation sequences with SQLite. It
+    is always called with exactly two arguments, the ICU locale 
+    identifying the collation sequence to ICU, and the name of the
+    SQLite collation sequence to create. For example, to create an
+    SQLite collation sequence named "turkish" using Turkish language
+    sorting rules, the SQL statement:
+
+        SELECT icu_load_collation('tr_TR', 'turkish');
+
+    Or, for Australian English:
+
+        SELECT icu_load_collation('en_AU', 'australian');
+
+    The identifiers "turkish" and "australian" may then be used
+    as collation sequence identifiers in SQL statements:
+
+        CREATE TABLE aust_turkish_penpals(
+          australian_penpal_name TEXT COLLATE australian,
+          turkish_penpal_name    TEXT COLLATE turkish
+        );
+  
+  1.4 SQL REGEXP Operator
+
+    This extension provides an implementation of the SQL binary
+    comparision operator "REGEXP", based on the regular expression functions
+    provided by the ICU library. The syntax of the operator is as described
+    in SQLite documentation:
+
+        <string> REGEXP <re-pattern>
+
+    This extension uses the ICU defaults for regular expression matching
+    behaviour. Specifically, this means that:
+
+        * Matching is case-sensitive,
+        * Regular expression comments are not allowed within patterns, and
+        * The '^' and '$' characters match the beginning and end of the
+          <string> argument, not the beginning and end of lines within
+          the <string> argument.
+
+    Even more specifically, the value passed to the "flags" parameter
+    of ICU C function uregex_open() is 0.
+
+
+2  COMPILATION AND USAGE
+
+  The easiest way to compile and use the ICU extension is to build
+  and use it as a dynamically loadable SQLite extension. To do this
+  using gcc on *nix:
+
+    gcc -shared icu.c `icu-config --ldflags` -o libSqliteIcu.so
+
+  You may need to add "-I" flags so that gcc can find sqlite3ext.h
+  and sqlite3.h. The resulting shared lib, libSqliteIcu.so, may be
+  loaded into sqlite in the same way as any other dynamically loadable
+  extension.
+
+
+3 BUGS, PROBLEMS AND SECURITY ISSUES
+
+  3.1 The "case_sensitive_like" Pragma
+
+    This extension does not work well with the "case_sensitive_like"
+    pragma. If this pragma is used before the ICU extension is loaded,
+    then the pragma has no effect. If the pragma is used after the ICU
+    extension is loaded, then SQLite ignores the ICU implementation and
+    always uses the built-in LIKE operator.
+
+    The ICU extension LIKE operator is always case insensitive.
+
+  3.2 The SQLITE_MAX_LIKE_PATTERN_LENGTH Macro
+
+    Passing very long patterns to the built-in SQLite LIKE operator can
+    cause a stack overflow. To curb this problem, SQLite defines the
+    SQLITE_MAX_LIKE_PATTERN_LENGTH macro as the maximum length of a
+    pattern in bytes (irrespective of encoding). The default value is
+    defined in internal header file "limits.h".
+    
+    The ICU extension LIKE implementation suffers from the same 
+    problem and uses the same solution. However, since the ICU extension
+    code does not include the SQLite file "limits.h", modifying
+    the default value therein does not affect the ICU extension.
+    The default value of SQLITE_MAX_LIKE_PATTERN_LENGTH used by
+    the ICU extension LIKE operator is 50000, defined in source 
+    file "icu.c".
+
+  3.3 Collation Sequence Security Issue
+
+    Internally, SQLite assumes that indices stored in database files
+    are sorted according to the collation sequence indicated by the
+    SQL schema. Changing the definition of a collation sequence after
+    an index has been built is therefore equivalent to database
+    corruption. The SQLite library is not very well tested under
+    these conditions, and may contain potential buffer overruns
+    or other programming errors that could be exploited by a malicious
+    programmer.
+
+    If the ICU extension is used in an environment where potentially
+    malicious users may execute arbitrary SQL (i.e. gears), they
+    should be prevented from invoking the icu_load_collation() function,
+    possibly using the authorisation callback.
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/ext/icu/icu.c b/client/src/thirdparty/sqlite-3.4.2/ext/icu/icu.c
new file mode 100644
index 0000000..c673341
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ext/icu/icu.c
@@ -0,0 +1,499 @@
+/*
+** 2007 May 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: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
+**
+** This file implements an integration between the ICU library 
+** ("International Components for Unicode", an open-source library 
+** for handling unicode data) and SQLite. The integration uses 
+** ICU to provide the following to SQLite:
+**
+**   * An implementation of the SQL regexp() function (and hence REGEXP
+**     operator) using the ICU uregex_XX() APIs.
+**
+**   * Implementations of the SQL scalar upper() and lower() functions
+**     for case mapping.
+**
+**   * Integration of ICU and SQLite collation seqences.
+**
+**   * An implementation of the LIKE operator that uses ICU to 
+**     provide case-independent matching.
+*/
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)
+
+/* Include ICU headers */
+#include <unicode/utypes.h>
+#include <unicode/uregex.h>
+#include <unicode/ustring.h>
+#include <unicode/ucol.h>
+
+#include <assert.h>
+
+#ifndef SQLITE_CORE
+  #include "sqlite3ext.h"
+  SQLITE_EXTENSION_INIT1
+#else
+  #include "sqlite3.h"
+#endif
+
+/*
+** Maximum length (in bytes) of the pattern in a LIKE or GLOB
+** operator.
+*/
+#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
+# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
+#endif
+
+/*
+** Version of sqlite3_free() that is always a function, never a macro.
+*/
+static void xFree(void *p){
+  sqlite3_free(p);
+}
+
+/*
+** Compare two UTF-8 strings for equality where the first string is
+** a "LIKE" expression. Return true (1) if they are the same and 
+** false (0) if they are different.
+*/
+static int icuLikeCompare(
+  const uint8_t *zPattern,   /* LIKE pattern */
+  const uint8_t *zString,    /* The UTF-8 string to compare against */
+  const UChar32 uEsc         /* The escape character */
+){
+  static const int MATCH_ONE = (UChar32)'_';
+  static const int MATCH_ALL = (UChar32)'%';
+
+  int iPattern = 0;       /* Current byte index in zPattern */
+  int iString = 0;        /* Current byte index in zString */
+
+  int prevEscape = 0;     /* True if the previous character was uEsc */
+
+  while( zPattern[iPattern]!=0 ){
+
+    /* Read (and consume) the next character from the input pattern. */
+    UChar32 uPattern;
+    U8_NEXT_UNSAFE(zPattern, iPattern, uPattern);
+    assert(uPattern!=0);
+
+    /* There are now 4 possibilities:
+    **
+    **     1. uPattern is an unescaped match-all character "%",
+    **     2. uPattern is an unescaped match-one character "_",
+    **     3. uPattern is an unescaped escape character, or
+    **     4. uPattern is to be handled as an ordinary character
+    */
+    if( !prevEscape && uPattern==MATCH_ALL ){
+      /* Case 1. */
+      uint8_t c;
+
+      /* Skip any MATCH_ALL or MATCH_ONE characters that follow a
+      ** MATCH_ALL. For each MATCH_ONE, skip one character in the 
+      ** test string.
+      */
+      while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){
+        if( c==MATCH_ONE ){
+          if( zString[iString]==0 ) return 0;
+          U8_FWD_1_UNSAFE(zString, iString);
+        }
+        iPattern++;
+      }
+
+      if( zPattern[iPattern]==0 ) return 1;
+
+      while( zString[iString] ){
+        if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){
+          return 1;
+        }
+        U8_FWD_1_UNSAFE(zString, iString);
+      }
+      return 0;
+
+    }else if( !prevEscape && uPattern==MATCH_ONE ){
+      /* Case 2. */
+      if( zString[iString]==0 ) return 0;
+      U8_FWD_1_UNSAFE(zString, iString);
+
+    }else if( !prevEscape && uPattern==uEsc){
+      /* Case 3. */
+      prevEscape = 1;
+
+    }else{
+      /* Case 4. */
+      UChar32 uString;
+      U8_NEXT_UNSAFE(zString, iString, uString);
+      uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);
+      uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);
+      if( uString!=uPattern ){
+        return 0;
+      }
+      prevEscape = 0;
+    }
+  }
+
+  return zString[iString]==0;
+}
+
+/*
+** Implementation of the like() SQL function.  This function implements
+** the build-in LIKE operator.  The first argument to the function is the
+** pattern and the second argument is the string.  So, the SQL statements:
+**
+**       A LIKE B
+**
+** is implemented as like(B, A). If there is an escape character E, 
+**
+**       A LIKE B ESCAPE E
+**
+** is mapped to like(B, A, E).
+*/
+static void icuLikeFunc(
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv
+){
+  const unsigned char *zA = sqlite3_value_text(argv[0]);
+  const unsigned char *zB = sqlite3_value_text(argv[1]);
+  UChar32 uEsc = 0;
+
+  /* Limit the length of the LIKE or GLOB pattern to avoid problems
+  ** of deep recursion and N*N behavior in patternCompare().
+  */
+  if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
+    sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
+    return;
+  }
+
+
+  if( argc==3 ){
+    /* The escape character string must consist of a single UTF-8 character.
+    ** Otherwise, return an error.
+    */
+    int nE= sqlite3_value_bytes(argv[2]);
+    const unsigned char *zE = sqlite3_value_text(argv[2]);
+    int i = 0;
+    if( zE==0 ) return;
+    U8_NEXT(zE, i, nE, uEsc);
+    if( i!=nE){
+      sqlite3_result_error(context, 
+          "ESCAPE expression must be a single character", -1);
+      return;
+    }
+  }
+
+  if( zA && zB ){
+    sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc));
+  }
+}
+
+/*
+** This function is called when an ICU function called from within
+** the implementation of an SQL scalar function returns an error.
+**
+** The scalar function context passed as the first argument is 
+** loaded with an error message based on the following two args.
+*/
+static void icuFunctionError(
+  sqlite3_context *pCtx,       /* SQLite scalar function context */
+  const char *zName,           /* Name of ICU function that failed */
+  UErrorCode e                 /* Error code returned by ICU function */
+){
+  char zBuf[128];
+  sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
+  zBuf[127] = '\0';
+  sqlite3_result_error(pCtx, zBuf, -1);
+}
+
+/*
+** Function to delete compiled regexp objects. Registered as
+** a destructor function with sqlite3_set_auxdata().
+*/
+static void icuRegexpDelete(void *p){
+  URegularExpression *pExpr = (URegularExpression *)p;
+  uregex_close(pExpr);
+}
+
+/*
+** Implementation of SQLite REGEXP operator. This scalar function takes
+** two arguments. The first is a regular expression pattern to compile
+** the second is a string to match against that pattern. If either 
+** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
+** is 1 if the string matches the pattern, or 0 otherwise.
+**
+** SQLite maps the regexp() function to the regexp() operator such
+** that the following two are equivalent:
+**
+**     zString REGEXP zPattern
+**     regexp(zPattern, zString)
+**
+** Uses the following ICU regexp APIs:
+**
+**     uregex_open()
+**     uregex_matches()
+**     uregex_close()
+*/
+static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
+  UErrorCode status = U_ZERO_ERROR;
+  URegularExpression *pExpr;
+  UBool res;
+  const UChar *zString = sqlite3_value_text16(apArg[1]);
+
+  /* If the left hand side of the regexp operator is NULL, 
+  ** then the result is also NULL. 
+  */
+  if( !zString ){
+    return;
+  }
+
+  pExpr = sqlite3_get_auxdata(p, 0);
+  if( !pExpr ){
+    const UChar *zPattern = sqlite3_value_text16(apArg[0]);
+    if( !zPattern ){
+      return;
+    }
+    pExpr = uregex_open(zPattern, -1, 0, 0, &status);
+
+    if( U_SUCCESS(status) ){
+      sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
+    }else{
+      assert(!pExpr);
+      icuFunctionError(p, "uregex_open", status);
+      return;
+    }
+  }
+
+  /* Configure the text that the regular expression operates on. */
+  uregex_setText(pExpr, zString, -1, &status);
+  if( !U_SUCCESS(status) ){
+    icuFunctionError(p, "uregex_setText", status);
+    return;
+  }
+
+  /* Attempt the match */
+  res = uregex_matches(pExpr, 0, &status);
+  if( !U_SUCCESS(status) ){
+    icuFunctionError(p, "uregex_matches", status);
+    return;
+  }
+
+  /* Set the text that the regular expression operates on to a NULL
+  ** pointer. This is not really necessary, but it is tidier than 
+  ** leaving the regular expression object configured with an invalid
+  ** pointer after this function returns.
+  */
+  uregex_setText(pExpr, 0, 0, &status);
+
+  /* Return 1 or 0. */
+  sqlite3_result_int(p, res ? 1 : 0);
+}
+
+/*
+** Implementations of scalar functions for case mapping - upper() and 
+** lower(). Function upper() converts its input to upper-case (ABC).
+** Function lower() converts to lower-case (abc).
+**
+** ICU provides two types of case mapping, "general" case mapping and
+** "language specific". Refer to ICU documentation for the differences
+** between the two.
+**
+** To utilise "general" case mapping, the upper() or lower() scalar 
+** functions are invoked with one argument:
+**
+**     upper('ABC') -> 'abc'
+**     lower('abc') -> 'ABC'
+**
+** To access ICU "language specific" case mapping, upper() or lower()
+** should be invoked with two arguments. The second argument is the name
+** of the locale to use. Passing an empty string ("") or SQL NULL value
+** as the second argument is the same as invoking the 1 argument version
+** of upper() or lower().
+**
+**     lower('I', 'en_us') -> 'i'
+**     lower('I', 'tr_tr') -> 'ı' (small dotless i)
+**
+** http://www.icu-project.org/userguide/posix.html#case_mappings
+*/
+static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
+  const UChar *zInput;
+  UChar *zOutput;
+  int nInput;
+  int nOutput;
+
+  UErrorCode status = U_ZERO_ERROR;
+  const char *zLocale = 0;
+
+  assert(nArg==1 || nArg==2);
+  if( nArg==2 ){
+    zLocale = (const char *)sqlite3_value_text(apArg[1]);
+  }
+
+  zInput = sqlite3_value_text16(apArg[0]);
+  if( !zInput ){
+    return;
+  }
+  nInput = sqlite3_value_bytes16(apArg[0]);
+
+  nOutput = nInput * 2 + 2;
+  zOutput = sqlite3_malloc(nOutput);
+  if( !zOutput ){
+    return;
+  }
+
+  if( sqlite3_user_data(p) ){
+    u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
+  }else{
+    u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
+  }
+
+  if( !U_SUCCESS(status) ){
+    icuFunctionError(p, "u_strToLower()/u_strToUpper", status);
+    return;
+  }
+
+  sqlite3_result_text16(p, zOutput, -1, xFree);
+}
+
+/*
+** Collation sequence destructor function. The pCtx argument points to
+** a UCollator structure previously allocated using ucol_open().
+*/
+static void icuCollationDel(void *pCtx){
+  UCollator *p = (UCollator *)pCtx;
+  ucol_close(p);
+}
+
+/*
+** Collation sequence comparison function. The pCtx argument points to
+** a UCollator structure previously allocated using ucol_open().
+*/
+static int icuCollationColl(
+  void *pCtx,
+  int nLeft,
+  const void *zLeft,
+  int nRight,
+  const void *zRight
+){
+  UCollationResult res;
+  UCollator *p = (UCollator *)pCtx;
+  res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
+  switch( res ){
+    case UCOL_LESS:    return -1;
+    case UCOL_GREATER: return +1;
+    case UCOL_EQUAL:   return 0;
+  }
+  assert(!"Unexpected return value from ucol_strcoll()");
+  return 0;
+}
+
+/*
+** Implementation of the scalar function icu_load_collation().
+**
+** This scalar function is used to add ICU collation based collation 
+** types to an SQLite database connection. It is intended to be called
+** as follows:
+**
+**     SELECT icu_load_collation(<locale>, <collation-name>);
+**
+** Where <locale> is a string containing an ICU locale identifier (i.e.
+** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
+** collation sequence to create.
+*/
+static void icuLoadCollation(
+  sqlite3_context *p, 
+  int nArg, 
+  sqlite3_value **apArg
+){
+  sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
+  UErrorCode status = U_ZERO_ERROR;
+  const char *zLocale;      /* Locale identifier - (eg. "jp_JP") */
+  const char *zName;        /* SQL Collation sequence name (eg. "japanese") */
+  UCollator *pUCollator;    /* ICU library collation object */
+  int rc;                   /* Return code from sqlite3_create_collation_x() */
+
+  assert(nArg==2);
+  zLocale = (const char *)sqlite3_value_text(apArg[0]);
+  zName = (const char *)sqlite3_value_text(apArg[1]);
+
+  if( !zLocale || !zName ){
+    return;
+  }
+
+  pUCollator = ucol_open(zLocale, &status);
+  if( !U_SUCCESS(status) ){
+    icuFunctionError(p, "ucol_open", status);
+    return;
+  }
+  assert(p);
+
+  rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, 
+      icuCollationColl, icuCollationDel
+  );
+  if( rc!=SQLITE_OK ){
+    ucol_close(pUCollator);
+    sqlite3_result_error(p, "Error registering collation function", -1);
+  }
+}
+
+/*
+** Register the ICU extension functions with database db.
+*/
+int sqlite3IcuInit(sqlite3 *db){
+  struct IcuScalar {
+    const char *zName;                        /* Function name */
+    int nArg;                                 /* Number of arguments */
+    int enc;                                  /* Optimal text encoding */
+    void *pContext;                           /* sqlite3_user_data() context */
+    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
+  } scalars[] = {
+    {"regexp",-1, SQLITE_ANY,          0, icuRegexpFunc},
+
+    {"lower",  1, SQLITE_UTF16,        0, icuCaseFunc16},
+    {"lower",  2, SQLITE_UTF16,        0, icuCaseFunc16},
+    {"upper",  1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
+    {"upper",  2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
+
+    {"lower",  1, SQLITE_UTF8,         0, icuCaseFunc16},
+    {"lower",  2, SQLITE_UTF8,         0, icuCaseFunc16},
+    {"upper",  1, SQLITE_UTF8,  (void*)1, icuCaseFunc16},
+    {"upper",  2, SQLITE_UTF8,  (void*)1, icuCaseFunc16},
+
+    {"like",   2, SQLITE_UTF8,         0, icuLikeFunc},
+    {"like",   3, SQLITE_UTF8,         0, icuLikeFunc},
+
+    {"icu_load_collation",  2, SQLITE_UTF8, (void*)db, icuLoadCollation},
+  };
+
+  int rc = SQLITE_OK;
+  int i;
+
+  for(i=0; rc==SQLITE_OK && i<(sizeof(scalars)/sizeof(struct IcuScalar)); i++){
+    struct IcuScalar *p = &scalars[i];
+    rc = sqlite3_create_function(
+        db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
+    );
+  }
+
+  return rc;
+}
+
+#if !SQLITE_CORE
+int sqlite3_extension_init(
+  sqlite3 *db, 
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi)
+  return sqlite3IcuInit(db);
+}
+#endif
+
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/install.sh b/client/src/thirdparty/sqlite-3.4.2/install.sh
new file mode 100644
index 0000000..e9de238
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/install.sh
@@ -0,0 +1,251 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.  It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+		chmodcmd=""
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0
diff --git a/client/src/thirdparty/sqlite-3.4.2/libtool b/client/src/thirdparty/sqlite-3.4.2/libtool
new file mode 100644
index 0000000..ef332c5
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/libtool
@@ -0,0 +1,7625 @@
+#! /dev/env/DJDIR/bin/sh.exe
+
+# libtoolT - Provide generalized library-building support services.
+# Generated automatically by  (GNU  )
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
+# Free Software Foundation, Inc.
+#
+# This file is part of GNU Libtool:
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# A sed program that does not truncate output.
+SED="/dev/e/djgpp/bin/sed"
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="/dev/e/djgpp/bin/sed -e 1s/^X//"
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# The names of the tagged configurations supported by this script.
+available_tags=" CXX"
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Libtool was configured on host SCHREIBTISCH_GP:
+
+# Shell to use when invoking shell scripts.
+SHELL="/dev/env/DJDIR/bin/sh.exe"
+
+# Whether or not to build shared libraries.
+build_libtool_libs=no
+
+# Whether or not to build static libraries.
+build_old_libs=yes
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=yes
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=no
+
+# Whether or not to optimize for fast installation.
+fast_install=needless
+
+# The host system.
+host_alias=
+host=i386-pc-msdosdjgpp
+host_os=msdosdjgpp
+
+# The build system.
+build_alias=
+build=i386-pc-msdosdjgpp
+build_os=msdosdjgpp
+
+# An echo program that does not interpret backslashes.
+echo="echo"
+
+# The archiver.
+AR="ar"
+AR_FLAGS="cru"
+
+# A C compiler.
+LTCC="gcc"
+
+# LTCC compiler flags.
+LTCFLAGS="-g -O2"
+
+# A language-specific compiler.
+CC="gcc"
+
+# Is the compiler the GNU C compiler?
+with_gcc=yes
+
+# An ERE matcher.
+EGREP="grep -E"
+
+# The linker used to build libraries.
+LD="e:/djgpp/bin/ld.exe"
+
+# Whether we need hard or soft links.
+LN_S="ln"
+
+# A BSD-compatible nm program.
+NM="/dev/e/djgpp/bin/nm -B"
+
+# A symbol stripping program
+STRIP="strip"
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=file
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="dlltool"
+
+# Used on cygwin: object dumper.
+OBJDUMP="objdump"
+
+# Used on cygwin: assembler.
+AS="as"
+
+# The name of the directory that contains temporary libtool files.
+objdir=.libs
+
+# How to create reloadable object files.
+reload_flag=" -r"
+reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
+
+# How to pass a linker flag through the compiler.
+wl="-Wl,"
+
+# Object file suffix (normally "o").
+objext="o"
+
+# Old archive suffix (normally "a").
+libext="a"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='.so'
+
+# Executable file suffix (normally "").
+exeext=""
+
+# Additional compiler flags for building library objects.
+pic_flag=""
+pic_mode=default
+
+# What is the maximum length of a command?
+max_cmd_len=12288
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o="yes"
+
+# Must we lock files when doing compilation?
+need_locks="no"
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=unknown
+
+# Do we need a version for libraries?
+need_version=unknown
+
+# Whether dlopen is supported.
+dlopen_support=unknown
+
+# Whether dlopen of programs is supported.
+dlopen_self=unknown
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=unknown
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag="-static"
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=" -fno-builtin"
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=""
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=""
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=""
+
+# Library versioning type.
+version_type=none
+
+# Format of library name prefix.
+libname_spec="lib\$name"
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=""
+
+# The coded name of the library, if different from the real name.
+soname_spec=""
+
+# Commands used to build and install an old-style archive.
+RANLIB="ranlib"
+old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib"
+old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
+old_postuninstall_cmds=""
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=""
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=""
+
+# Commands used to build and install a shared archive.
+archive_cmds=""
+archive_expsym_cmds=""
+postinstall_cmds=""
+postuninstall_cmds=""
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=""
+module_expsym_cmds=""
+
+# Commands to strip libraries.
+old_striplib="strip --strip-debug"
+striplib="strip --strip-unneeded"
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects=""
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=""
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=""
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps=""
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=""
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method="unknown"
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd="\$MAGIC_CMD"
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=""
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=""
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=""
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=""
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe="sed -n -e 's/^.*[ 	]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ 	][ 	]*_\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 _\\2 \\2/p'"
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'"
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (lt_ptr) \\&\\2},/p'"
+
+# This is the shared library runtime path variable.
+runpath_var=
+
+# This is the shared library path variable.
+shlibpath_var=
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=unknown
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=unsupported
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=no
+
+# Flag to hardcode $libdir into a binary during linking.
+# This must work even if $libdir does not exist.
+hardcode_libdir_flag_spec=""
+
+# If ld is used when linking, flag to hardcode $libdir into
+# a binary during linking. This must work even if $libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=""
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=""
+
+# Set to yes if using DIR/libNAME during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=no
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=no
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=unsupported
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=no
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="PATH   GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=unknown
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=" =e:/djgpp/bin/../lib/gcc/djgpp/4.53/ e:/djgpp/bin/../lib/gcc/ e:/djgpp/net/watt/lib /djgpp/4.53/ e:/djgpp/net/watt/lib / e:/djgpp/lib/djgpp/4.53/ e:/djgpp/lib/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../../djgpp/lib/djgpp/4.53/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../../djgpp/lib/ e:/djgpp/lib/djgpp/4.53/ e:/djgpp/lib/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../djgpp/4.53/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../"
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+
+# Fix the shell variable $srcfile for the compiler.
+fix_srcfile_path=""
+
+# Set to yes if exported symbols are required.
+always_export_symbols=no
+
+# The commands to list exported symbols.
+export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=""
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms="_GLOBAL_OFFSET_TABLE_"
+
+# Symbols that must always be exported.
+include_expsyms=""
+
+# ### END LIBTOOL CONFIG
+
+# ltmain.sh - Provide generalized library-building support services.
+# NOTE: Changing this file will not affect anything until you rerun configure.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+basename="s,^.*/,,g"
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
+
+# define SED for historic ltconfig's generated by Libtool 1.3
+test -z "$SED" && SED=sed
+
+# The name of this program:
+progname=`echo "$progpath" | $SED $basename`
+modename="$progname"
+
+# Global variables:
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+
+PROGRAM=ltmain.sh
+PACKAGE=libtool
+VERSION=1.5.22
+TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
+
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes.
+if test -n "${ZSH_VERSION+set}" ; then
+  setopt NO_GLOB_SUBST
+fi
+# Same for EGREP, and just to be sure, do LTCC as well
+if test "X$EGREP" = X ; then
+    EGREP=egrep
+fi
+if test "X$LTCC" = X ; then
+    LTCC=${CC-gcc}
+fi
+
+# Check that we have a working $echo.
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell, and then maybe $echo will work.
+  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit $EXIT_SUCCESS
+fi
+
+default_mode=
+help="Try \`$progname --help' for more information."
+magic="%%%MAGIC variable%%%"
+mkdir="mkdir"
+mv="mv -f"
+rm="rm -f"
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed="${SED}"' -e 1s/^X//'
+sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  SP2NL='tr \040 \012'
+  NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  SP2NL='tr \100 \n'
+  NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+# NLS nuisances.
+# Only set LANG and LC_ALL to C if already set.
+# These must not be set unconditionally because not all systems understand
+# e.g. LANG=C (notably SCO).
+# We save the old values to restore during execute mode.
+if test "${LC_ALL+set}" = set; then
+  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
+fi
+if test "${LANG+set}" = set; then
+  save_LANG="$LANG"; LANG=C; export LANG
+fi
+
+# Make sure IFS has a sensible default
+lt_nl='
+'
+IFS=" 	$lt_nl"
+
+if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+  $echo "$modename: not configured to build any kind of library" 1>&2
+  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+  exit $EXIT_FAILURE
+fi
+
+# Global variables.
+mode=$default_mode
+nonopt=
+prev=
+prevopt=
+run=
+show="$echo"
+show_help=
+execute_dlfiles=
+duplicate_deps=no
+preserve_args=
+lo2o="s/\\.lo\$/.${objext}/"
+o2lo="s/\\.${objext}\$/.lo/"
+
+if test -z "$max_cmd_len"; then
+  i=0
+  testring="ABCD"
+  new_result=
+  
+  # If test is not a shell built-in, we'll probably end up computing a
+  # maximum length that is only half of the actual maximum length, but
+  # we can't tell.
+  while (test "X"`$SHELL $0 --fallback-echo "X$testring" 2>/dev/null` \
+             = "XX$testring") >/dev/null 2>&1 &&
+          new_result=`expr "X$testring" : ".*" 2>&1` &&
+          max_cmd_len="$new_result" &&
+          test "$i" != 17 # 1/2 MB should be enough
+  do
+    i=`expr $i + 1`
+    testring="$testring$testring"
+  done
+  testring=
+  # Add a significant safety factor because C++ compilers can tack on massive
+  # amounts of additional arguments before passing them to the linker.
+  # It appears as though 1/2 is a usable value.
+  max_cmd_len=`expr $max_cmd_len \/ 2`
+fi
+
+#####################################
+# Shell function definitions:
+# This seems to be the best place for them
+
+# func_mktempdir [string]
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, STRING is the basename for that directory.
+func_mktempdir ()
+{
+    my_template="${TMPDIR-/tmp}/${1-$progname}"
+
+    if test "$run" = ":"; then
+      # Return a directory name, but don't create it in dry-run mode
+      my_tmpdir="${my_template}-$$"
+    else
+
+      # If mktemp works, use that first and foremost
+      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$my_tmpdir"; then
+	# Failing that, at least try and use $RANDOM to avoid a race
+	my_tmpdir="${my_template}-${RANDOM-0}$$"
+
+	save_mktempdir_umask=`umask`
+	umask 0077
+	$mkdir "$my_tmpdir"
+	umask $save_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$my_tmpdir" || {
+        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
+	exit $EXIT_FAILURE
+      }
+    fi
+
+    $echo "X$my_tmpdir" | $Xsed
+}
+
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+func_win32_libid ()
+{
+  win32_libid_type="unknown"
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
+      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+      win32_nmres=`eval $NM -f posix -A $1 | \
+	$SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $echo $win32_libid_type
+}
+
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	case $arg in
+	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	CC_quoted="$CC_quoted $arg"
+      done
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	    # Double-quote args containing other shell metacharacters.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    CC_quoted="$CC_quoted $arg"
+	  done
+	    # user sometimes does CC=<HOST>-gcc so we need to match that to 'gcc'
+	    trimedcc=`echo ${CC} | $SED -e "s/${host}-//g"`
+	    # and sometimes libtool has CC=<HOST>-gcc but user does CC=gcc
+	    extendcc=${host}-${CC}
+	    # and sometimes libtool has CC=<OLDHOST>-gcc but user has CC=<NEWHOST>-gcc  
+	    # (Gentoo-specific hack because we always export $CHOST)
+	    mungedcc=${CHOST-${host}}-${trimedcc}
+	    case "$@ " in
+	      "cc "* | " cc "* | "${host}-cc "* | " ${host}-cc "*|\
+	      "gcc "* | " gcc "* | "${host}-gcc "* | " ${host}-gcc "*)
+	      tagname=CC
+	      break ;;
+	      "$trimedcc "* | " $trimedcc "* | "`$echo $trimedcc` "* | " `$echo $trimedcc` "*|\
+	      "$extendcc "* | " $extendcc "* | "`$echo $extendcc` "* | " `$echo $extendcc` "*|\
+	      "$mungedcc "* | " $mungedcc "* | "`$echo $mungedcc` "* | " `$echo $mungedcc` "*|\
+	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  $echo "$modename: unable to infer tagged configuration"
+	  $echo "$modename: specify a tag with \`--tag'" 1>&2
+	  exit $EXIT_FAILURE
+#        else
+#          $echo "$modename: using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    f_ex_an_ar_dir="$1"; shift
+    f_ex_an_ar_oldlib="$1"
+
+    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
+    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
+      exit $EXIT_FAILURE
+    fi
+}
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    my_gentop="$1"; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=""
+    my_xlib=""
+    my_xabs=""
+    my_xdir=""
+    my_status=""
+
+    $show "${rm}r $my_gentop"
+    $run ${rm}r "$my_gentop"
+    $show "$mkdir $my_gentop"
+    $run $mkdir "$my_gentop"
+    my_status=$?
+    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
+      exit $my_status
+    fi
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
+      my_xdir="$my_gentop/$my_xlib"
+
+      $show "${rm}r $my_xdir"
+      $run ${rm}r "$my_xdir"
+      $show "$mkdir $my_xdir"
+      $run $mkdir "$my_xdir"
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
+	exit $exit_status
+      fi
+      case $host in
+      *-darwin*)
+	$show "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	if test -z "$run"; then
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
+	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
+	  if test -n "$darwin_arches"; then 
+	    darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    $show "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches ; do
+	      mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
+	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+	      cd "$darwin_curdir"
+	      $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+	    done # $darwin_arches
+      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
+	      lipo -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    ${rm}r unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd "$darwin_orig_dir"
+ 	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	fi # $run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+        ;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
+    done
+    func_extract_archives_result="$my_oldobjs"
+}
+# End of Shell function definitions
+#####################################
+
+# Darwin sucks
+eval std_shrext=\"$shrext_cmds\"
+
+disable_libs=no
+
+# Parse our command line options once, thoroughly.
+while test "$#" -gt 0
+do
+  arg="$1"
+  shift
+
+  case $arg in
+  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$prev"; then
+    case $prev in
+    execute_dlfiles)
+      execute_dlfiles="$execute_dlfiles $arg"
+      ;;
+    tag)
+      tagname="$arg"
+      preserve_args="${preserve_args}=$arg"
+
+      # Check whether tagname contains only valid characters
+      case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+	$echo "$progname: invalid tag name: $tagname" 1>&2
+	exit $EXIT_FAILURE
+	;;
+      esac
+
+      case $tagname in
+      CC)
+	# Don't test for the "default" C tag, as we know, it's there, but
+	# not specially marked.
+	;;
+      *)
+	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
+	  taglist="$taglist $tagname"
+	  # Evaluate the configuration.
+	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
+	else
+	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
+	fi
+	;;
+      esac
+      ;;
+    *)
+      eval "$prev=\$arg"
+      ;;
+    esac
+
+    prev=
+    prevopt=
+    continue
+  fi
+
+  # Have we seen a non-optional argument yet?
+  case $arg in
+  --help)
+    show_help=yes
+    ;;
+
+  --version)
+    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
+    $echo
+    $echo "Copyright (C) 2005  Free Software Foundation, Inc."
+    $echo "This is free software; see the source for copying conditions.  There is NO"
+    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+    exit $?
+    ;;
+
+  --config)
+    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
+    done
+    exit $?
+    ;;
+
+  --debug)
+    $echo "$progname: enabling shell trace mode"
+    set -x
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --dry-run | -n)
+    run=:
+    ;;
+
+  --features)
+    $echo "host: $host"
+    if test "$build_libtool_libs" = yes; then
+      $echo "enable shared libraries"
+    else
+      $echo "disable shared libraries"
+    fi
+    if test "$build_old_libs" = yes; then
+      $echo "enable static libraries"
+    else
+      $echo "disable static libraries"
+    fi
+    exit $?
+    ;;
+
+  --finish) mode="finish" ;;
+
+  --mode) prevopt="--mode" prev=mode ;;
+  --mode=*) mode="$optarg" ;;
+
+  --preserve-dup-deps) duplicate_deps="yes" ;;
+
+  --quiet | --silent)
+    show=:
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --tag)
+    prevopt="--tag"
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+  --tag=*)
+    set tag "$optarg" ${1+"$@"}
+    shift
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+
+  -dlopen)
+    prevopt="-dlopen"
+    prev=execute_dlfiles
+    ;;
+
+  -*)
+    $echo "$modename: unrecognized option \`$arg'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+
+  *)
+    nonopt="$arg"
+    break
+    ;;
+  esac
+done
+
+if test -n "$prevopt"; then
+  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+fi
+
+case $disable_libs in
+no) 
+  ;;
+shared)
+  build_libtool_libs=no
+  build_old_libs=yes
+  ;;
+static)
+  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+  ;;
+esac
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+if test -z "$show_help"; then
+
+  # Infer the operation mode.
+  if test -z "$mode"; then
+    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
+    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
+    case $nonopt in
+    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
+      mode=link
+      for arg
+      do
+	case $arg in
+	-c)
+	   mode=compile
+	   break
+	   ;;
+	esac
+      done
+      ;;
+    *db | *dbx | *strace | *truss)
+      mode=execute
+      ;;
+    *install*|cp|mv)
+      mode=install
+      ;;
+    *rm)
+      mode=uninstall
+      ;;
+    *)
+      # If we have no mode, but dlfiles were specified, then do execute mode.
+      test -n "$execute_dlfiles" && mode=execute
+
+      # Just use the default operation mode.
+      if test -z "$mode"; then
+	if test -n "$nonopt"; then
+	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
+	else
+	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
+	fi
+      fi
+      ;;
+    esac
+  fi
+
+  # Only execute mode is allowed to have -dlopen flags.
+  if test -n "$execute_dlfiles" && test "$mode" != execute; then
+    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+
+  # Change the help message to a mode-specific one.
+  generic_help="$help"
+  help="Try \`$modename --help --mode=$mode' for more information."
+
+  # These modes are in order of execution frequency so that they run quickly.
+  case $mode in
+  # libtool compile mode
+  compile)
+    modename="$modename: compile"
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg="$arg"
+	arg_mode=normal
+	;;
+
+      target )
+	libobj="$arg"
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  if test -n "$libobj" ; then
+	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-static | -prefer-pic | -prefer-non-pic)
+	  later="$later $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
+	  lastarg=
+	  save_ifs="$IFS"; IFS=','
+ 	  for arg in $args; do
+	    IFS="$save_ifs"
+
+	    # Double-quote args containing other shell metacharacters.
+	    # Many Bourne shells cannot handle close brackets correctly
+	    # in scan sets, so we specify it separately.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    lastarg="$lastarg $arg"
+	  done
+	  IFS="$save_ifs"
+	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
+
+	  # Add the arguments to base_compile.
+	  base_compile="$base_compile $lastarg"
+	  continue
+	  ;;
+
+	* )
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg="$srcfile"
+	  srcfile="$arg"
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
+
+      case $lastarg in
+      # Double-quote args containing other shell metacharacters.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, and some SunOS ksh mistreat backslash-escaping
+      # in scan sets (worked around with variable expansion),
+      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
+      # at all, so we specify them separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	lastarg="\"$lastarg\""
+	;;
+      esac
+
+      base_compile="$base_compile $lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      $echo "$modename: you must specify an argument for -Xcompile"
+      exit $EXIT_FAILURE
+      ;;
+    target)
+      $echo "$modename: you must specify a target with \`-o'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *)
+      # Get the name of the library object.
+      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    xform='[cCFSifmso]'
+    case $libobj in
+    *.ada) xform=ada ;;
+    *.adb) xform=adb ;;
+    *.ads) xform=ads ;;
+    *.asm) xform=asm ;;
+    *.c++) xform=c++ ;;
+    *.cc) xform=cc ;;
+    *.ii) xform=ii ;;
+    *.class) xform=class ;;
+    *.cpp) xform=cpp ;;
+    *.cxx) xform=cxx ;;
+    *.f90) xform=f90 ;;
+    *.for) xform=for ;;
+    *.java) xform=java ;;
+    esac
+
+    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
+
+    case $libobj in
+    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
+    *)
+      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -static)
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
+    case $qlibobj in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qlibobj="\"$qlibobj\"" ;;
+    esac
+    test "X$libobj" != "X$qlibobj" \
+	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' 	&()|`$[]' \
+	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
+    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$xdir" = "X$obj"; then
+      xdir=
+    else
+      xdir=$xdir/
+    fi
+    lobj=${xdir}$objdir/$objname
+
+    if test -z "$base_compile"; then
+      $echo "$modename: you must specify a compilation command" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Delete any leftover library objects.
+    if test "$build_old_libs" = yes; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    $run $rm $removelist
+    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2*)
+      pic_mode=default
+      ;;
+    esac
+    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test "$compiler_c_o" = no; then
+      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
+      lockfile="$output_obj.lock"
+      removelist="$removelist $output_obj $lockfile"
+      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test "$need_locks" = yes; then
+      until $run ln "$srcfile" "$lockfile" 2>/dev/null; do
+	$show "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test "$need_locks" = warn; then
+      if test -f "$lockfile"; then
+	$echo "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+      $echo "$srcfile" > "$lockfile"
+    fi
+
+    if test -n "$fix_srcfile_path"; then
+      eval srcfile=\"$fix_srcfile_path\"
+    fi
+    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
+    case $qsrcfile in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      qsrcfile="\"$qsrcfile\"" ;;
+    esac
+
+    $run $rm "$libobj" "${libobj}T"
+
+    # Create a libtool object file (analogous to a ".la" file),
+    # but don't create it if we're doing a dry run.
+    test -z "$run" && cat > ${libobj}T <<EOF
+# $libobj - a libtool object file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+EOF
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test "$build_libtool_libs" = yes; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test "$pic_mode" != no; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      if test ! -d "${xdir}$objdir"; then
+	$show "$mkdir ${xdir}$objdir"
+	$run $mkdir ${xdir}$objdir
+	exit_status=$?
+	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
+	  exit $exit_status
+	fi
+      fi
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	command="$command -o $lobj"
+      fi
+
+      $run $rm "$lobj" "$output_obj"
+
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	test -n "$output_obj" && $run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	$show "$mv $output_obj $lobj"
+	if $run $mv $output_obj $lobj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the PIC object to the libtool object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object='$objdir/$objname'
+
+EOF
+
+      # Allow error messages only from the first compilation.
+      if test "$suppress_opt" = yes; then
+        suppress_output=' >/dev/null 2>&1'
+      fi
+    else
+      # No PIC object so indicate it doesn't exist in the libtool
+      # object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object=none
+
+EOF
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test "$build_old_libs" = yes; then
+      if test "$pic_mode" != yes; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test "$compiler_c_o" = yes; then
+	command="$command -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      command="$command$suppress_output"
+      $run $rm "$obj" "$output_obj"
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	$show "$mv $output_obj $obj"
+	if $run $mv $output_obj $obj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object='$objname'
+
+EOF
+    else
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object=none
+
+EOF
+    fi
+
+    $run $mv "${libobj}T" "${libobj}"
+
+    # Unlock the critical section if it was locked
+    if test "$need_locks" != no; then
+      $run $rm "$lockfile"
+    fi
+
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool link mode
+  link | relink)
+    modename="$modename: link"
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # which system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll which has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args="$nonopt"
+    base_compile="$nonopt $@"
+    compile_command="$nonopt"
+    finalize_command="$nonopt"
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+
+    avoid_version=no
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    non_pic_objects=
+    notinst_path= # paths that contain not-installed libtool libraries
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=no
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -all-static | -static)
+	if test "X$arg" = "X-all-static"; then
+	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	else
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	fi
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg="$1"
+      shift
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
+	;;
+      *) qarg=$arg ;;
+      esac
+      libtool_args="$libtool_args $qarg"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  compile_command="$compile_command @OUTPUT@"
+	  finalize_command="$finalize_command @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	dlfiles|dlprefiles)
+	  if test "$preload" = no; then
+	    # Add the symbol object into the linking commands.
+	    compile_command="$compile_command @SYMFILE@"
+	    finalize_command="$finalize_command @SYMFILE@"
+	    preload=yes
+	  fi
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test "$dlself" = no; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test "$prev" = dlprefiles; then
+	      dlself=yes
+	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test "$prev" = dlfiles; then
+	      dlfiles="$dlfiles $arg"
+	    else
+	      dlprefiles="$dlprefiles $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols="$arg"
+	  if test ! -f "$arg"; then
+	    $echo "$modename: symbol file \`$arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir="$arg"
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release="-$arg"
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat $save_arg`
+	    do
+#	      moreargs="$moreargs $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		# If there is no directory component, then add one.
+		case $arg in
+		*/* | *\\*) . $arg ;;
+		*) . ./$arg ;;
+		esac
+
+		if test -z "$pic_object" || \
+		   test -z "$non_pic_object" ||
+		   test "$pic_object" = none && \
+		   test "$non_pic_object" = none; then
+		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+
+		# Extract subdirectory from the argument.
+		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		if test "X$xdir" = "X$arg"; then
+		  xdir=
+		else
+		  xdir="$xdir/"
+		fi
+
+		if test "$pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object="$xdir$pic_object"
+
+		  if test "$prev" = dlfiles; then
+		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		      dlfiles="$dlfiles $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test "$prev" = dlprefiles; then
+		    # Preload the old-style object.
+		    dlprefiles="$dlprefiles $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  libobjs="$libobjs $pic_object"
+		  arg="$pic_object"
+		fi
+
+		# Non-PIC object.
+		if test "$non_pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object="$xdir$non_pic_object"
+
+		  # A standard non-PIC object
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		  if test -z "$pic_object" || test "$pic_object" = none ; then
+		    arg="$non_pic_object"
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object="$pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if test -z "$run"; then
+		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+		  exit $EXIT_FAILURE
+		else
+		  # Dry-run case.
+
+		  # Extract subdirectory from the argument.
+		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		  if test "X$xdir" = "X$arg"; then
+		    xdir=
+		  else
+		    xdir="$xdir/"
+		  fi
+
+		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+		  libobjs="$libobjs $pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      fi
+	    done
+	  else
+	    $echo "$modename: link input file \`$save_arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    $echo "$modename: only absolute run-paths are allowed" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	  if test "$prev" = rpath; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) rpath="$rpath $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) xrpath="$xrpath $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	xcompiler)
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $wl$qarg"
+	  prev=
+	  compile_command="$compile_command $wl$qarg"
+	  finalize_command="$finalize_command $wl$qarg"
+	  continue
+	  ;;
+	xcclinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	shrext)
+  	  shrext_cmds="$arg"
+	  prev=
+	  continue
+	  ;;
+	darwin_framework|darwin_framework_skip)
+	  test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  prev=
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg="$arg"
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  compile_command="$compile_command $link_static_flag"
+	  finalize_command="$finalize_command $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
+	continue
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  $echo "$modename: more than one -exported-symbols argument is not allowed"
+	  exit $EXIT_FAILURE
+	fi
+	if test "X$arg" = "X-export-symbols"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework|-arch|-isysroot)
+	case " $CC " in
+	  *" ${arg} ${1} "* | *" ${arg}	${1} "*) 
+		prev=darwin_framework_skip ;;
+	  *) compiler_flags="$compiler_flags $arg"
+	     prev=darwin_framework ;;
+	esac
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -L[A-Z][A-Z]*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  if test -z "$absdir"; then
+	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
+	    absdir="$dir"
+	    notinst_path="$notinst_path $dir"
+	  fi
+	  dir="$absdir"
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "*) ;;
+	*)
+	  deplibs="$deplibs -L$dir"
+	  lib_search_path="$lib_search_path $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C and math libraries are in the System framework
+	    deplibs="$deplibs -framework System"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  esac
+	elif test "X$arg" = "X-lc_r"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	deplibs="$deplibs $arg"
+	continue
+	;;
+
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      -model)
+	compile_command="$compile_command $arg"
+	compiler_flags="$compiler_flags $arg"
+	finalize_command="$finalize_command $arg"
+	prev=xcompiler
+	continue
+	;;
+
+     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	compiler_flags="$compiler_flags $arg"
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
+      # -r[0-9][0-9]* specifies the processor on the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
+      # +DA*, +DD* enable 64-bit mode on the HP compiler
+      # -q* pass through compiler args for the IBM compiler
+      # -m* pass through architecture-specific compiler args for GCC
+      # -m*, -t[45]*, -txscale* pass through architecture-specific
+      # compiler args for GCC
+      # -pg pass through profiling flag for GCC
+      # @file GCC response files
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*|-pg| \
+      -t[45]*|-txscale*|@*)
+
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+        compile_command="$compile_command $arg"
+        finalize_command="$finalize_command $arg"
+        compiler_flags="$compiler_flags $arg"
+        continue
+        ;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # in order for the loader to find any dlls it needs.
+	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
+	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  $echo "$modename: only absolute run-paths are allowed" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) xrpath="$xrpath $dir" ;;
+	esac
+	continue
+	;;
+
+      -static)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -Wc,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Wl,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $wl$flag"
+	  linker_flags="$linker_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+
+      *.$objext)
+	# A standard object.
+	objs="$objs $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  # If there is no directory component, then add one.
+	  case $arg in
+	  */* | *\\*) . $arg ;;
+	  *) . ./$arg ;;
+	  esac
+
+	  if test -z "$pic_object" || \
+	     test -z "$non_pic_object" ||
+	     test "$pic_object" = none && \
+	     test "$non_pic_object" = none; then
+	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	  if test "X$xdir" = "X$arg"; then
+	    xdir=
+ 	  else
+	    xdir="$xdir/"
+	  fi
+
+	  if test "$pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    pic_object="$xdir$pic_object"
+
+	    if test "$prev" = dlfiles; then
+	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		dlfiles="$dlfiles $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test "$prev" = dlprefiles; then
+	      # Preload the old-style object.
+	      dlprefiles="$dlprefiles $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    libobjs="$libobjs $pic_object"
+	    arg="$pic_object"
+	  fi
+
+	  # Non-PIC object.
+	  if test "$non_pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object="$xdir$non_pic_object"
+
+	    # A standard non-PIC object
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	    if test -z "$pic_object" || test "$pic_object" = none ; then
+	      arg="$non_pic_object"
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object="$pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if test -z "$run"; then
+	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+	    exit $EXIT_FAILURE
+	  else
+	    # Dry-run case.
+
+	    # Extract subdirectory from the argument.
+	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	    if test "X$xdir" = "X$arg"; then
+	      xdir=
+	    else
+	      xdir="$xdir/"
+	    fi
+
+	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+	    libobjs="$libobjs $pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	deplibs="$deplibs $arg"
+	old_deplibs="$old_deplibs $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	if test "$prev" = dlfiles; then
+	  # This library was specified with -dlopen.
+	  dlfiles="$dlfiles $arg"
+	  prev=
+	elif test "$prev" = dlprefiles; then
+	  # The library was specified with -dlpreopen.
+	  dlprefiles="$dlprefiles $arg"
+	  prev=
+	else
+	  deplibs="$deplibs $arg"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+      fi
+    done # argument parsing loop
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      compile_command="$compile_command $arg"
+      finalize_command="$finalize_command $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
+    libobjs_save="$libobjs"
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$output_objdir" = "X$output"; then
+      output_objdir="$objdir"
+    else
+      output_objdir="$output_objdir/$objdir"
+    fi
+    # Create the object directory.
+    if test ! -d "$output_objdir"; then
+      $show "$mkdir $output_objdir"
+      $run $mkdir $output_objdir
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
+	exit $exit_status
+      fi
+    fi
+
+    # Determine the type of output
+    case $output in
+    "")
+      $echo "$modename: you must specify an output file" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    case $host in
+    *cygwin* | *mingw* | *pw32*)
+      # don't eliminate duplications in $postdeps and $predeps
+      duplicate_compiler_generated_deps=yes
+      ;;
+    *)
+      duplicate_compiler_generated_deps=$duplicate_deps
+      ;;
+    esac
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if test "X$duplicate_deps" = "Xyes" ; then
+	case "$libs " in
+	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	esac
+      fi
+      libs="$libs $deplib"
+    done
+
+    if test "$linkmode" = lib; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
+	  esac
+	  pre_post_deps="$pre_post_deps $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    case $linkmode in
+    lib)
+	passes="conv link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=no
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+    for pass in $passes; do
+      if test "$linkmode,$pass" = "lib,link" ||
+	 test "$linkmode,$pass" = "prog,scan"; then
+	libs="$deplibs"
+	deplibs=
+      fi
+      if test "$linkmode" = prog; then
+	case $pass in
+	dlopen) libs="$dlfiles" ;;
+	dlpreopen) libs="$dlprefiles" ;;
+	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+	esac
+      fi
+      if test "$pass" = dlopen; then
+	# Collect dlpreopened libraries
+	save_deplibs="$deplibs"
+	deplibs=
+      fi
+      for deplib in $libs; do
+	lib=
+	found=no
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	  if test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    compiler_flags="$compiler_flags $deplib"
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test "$linkmode" != lib && test "$linkmode" != prog; then
+	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
+	    continue
+	  fi
+	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
+	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib="$searchdir/lib${name}${search_ext}"
+	      if test -f "$lib"; then
+		if test "$search_ext" = ".la"; then
+		  found=yes
+		else
+		  found=no
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if test "$found" != yes; then
+	    # deplib doesn't seem to be a libtool library
+	    if test "$linkmode,$pass" = "prog,link"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  else # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if (${SED} -e '2q' $lib |
+                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		  library_names=
+		  old_library=
+		  case $lib in
+		  */* | *\\*) . $lib ;;
+		  *) . ./$lib ;;
+		  esac
+		  for l in $old_library $library_names; do
+		    ll="$l"
+		  done
+		  if test "X$ll" = "X$old_library" ; then # only static version available
+		    found=no
+		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+		    test "X$ladir" = "X$lib" && ladir="."
+		    lib=$ladir/$old_library
+		    if test "$linkmode,$pass" = "prog,link"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+	        ;;
+	      *) ;;
+	      esac
+	    fi
+	  fi
+	  ;; # -l
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test "$pass" = conv && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  prog)
+	    if test "$pass" = conv; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test "$pass" = scan; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  *)
+	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test "$pass" = link; then
+	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) xrpath="$xrpath $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la) lib="$deplib" ;;
+	*.$libext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    valid_a_lib=no
+	    case $deplibs_check_method in
+	      match_pattern*)
+		set dummy $deplibs_check_method
+	        match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+		if eval $echo \"$deplib\" 2>/dev/null \
+		    | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		  valid_a_lib=yes
+		fi
+		;;
+	      pass_all)
+		valid_a_lib=yes
+		;;
+            esac
+	    if test "$valid_a_lib" != yes; then
+	      $echo
+	      $echo "*** Warning: Trying to link with static lib archive $deplib."
+	      $echo "*** I have the capability to make that library automatically link in when"
+	      $echo "*** you link to this library.  But I can only do this if you have a"
+	      $echo "*** shared version of the library, which you do not appear to have"
+	      $echo "*** because the file extensions .$libext of this argument makes me believe"
+	      $echo "*** that it is just a static archive that I should not used here."
+	    else
+	      $echo
+	      $echo "*** Warning: Linking the shared library $output against the"
+	      $echo "*** static library $deplib is not portable!"
+	      deplibs="$deplib $deplibs"
+	    fi
+	    continue
+	    ;;
+	  prog)
+	    if test "$pass" != link; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	  elif test "$linkmode" = prog; then
+	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      newdlprefiles="$newdlprefiles $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      newdlfiles="$newdlfiles $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=yes
+	  continue
+	  ;;
+	esac # case $deplib
+	if test "$found" = yes || test -f "$lib"; then :
+	else
+	  $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$ladir" = "X$lib" && ladir="."
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	case $lib in
+	*/* | *\\*) . $lib ;;
+	*) . ./$lib ;;
+	esac
+
+	if test "$linkmode,$pass" = "lib,link" ||
+	   test "$linkmode,$pass" = "prog,scan" ||
+	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
+	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
+	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
+	fi
+
+	if test "$pass" = conv; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	      exit $EXIT_FAILURE
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    convenience="$convenience $ladir/$objdir/$old_library"
+	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+              if test "X$duplicate_deps" = "Xyes" ; then
+	        case "$tmp_libs " in
+	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	        esac
+              fi
+	      tmp_libs="$tmp_libs $deplib"
+	    done
+	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
+	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	for l in $old_library $library_names; do
+	  linklib="$l"
+	done
+	if test -z "$linklib"; then
+	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# This library was specified with -dlopen.
+	if test "$pass" = dlopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  if test -z "$dlname" ||
+	     test "$dlopen_support" != yes ||
+	     test "$build_libtool_libs" = no; then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    dlprefiles="$dlprefiles $lib $dependency_libs"
+	  else
+	    newdlfiles="$newdlfiles $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
+	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
+	    abs_ladir="$ladir"
+	  fi
+	  ;;
+	esac
+	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+
+	# Find the relevant object directory and library name.
+	if test "X$installed" = Xyes; then
+	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    libdir="$abs_ladir"
+	  else
+	    dir="$libdir"
+	    absdir="$libdir"
+	  fi
+	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  else
+	    dir="$ladir/$objdir"
+	    absdir="$abs_ladir/$objdir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  fi
+	fi # $installed = yes
+	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+
+	# This library was specified with -dlpreopen.
+	if test "$pass" = dlpreopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  # Prefer using a static library (so that no silly _DYNAMIC symbols
+	  # are required to link).
+	  if test -n "$old_library"; then
+	    newdlprefiles="$newdlprefiles $dir/$old_library"
+	  # Otherwise, use the dlname, so that lt_dlopen finds it.
+	  elif test -n "$dlname"; then
+	    newdlprefiles="$newdlprefiles $dir/$dlname"
+	  else
+	    newdlprefiles="$newdlprefiles $dir/$linklib"
+	  fi
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test "$linkmode" = lib; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test "$linkmode" = prog && test "$pass" != link; then
+	  newlib_search_path="$newlib_search_path $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=no
+	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
+	     test "$build_libtool_libs" = no; then
+	    linkalldeplibs=yes
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
+	    esac
+	    # Need to link against all dependency_libs?
+	    if test "$linkalldeplibs" = yes; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test "$linkmode,$pass" = "prog,link"; then
+	  if test -n "$library_names" &&
+	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
+	      # Make sure the rpath contains only unique directories.
+	      case "$temp_rpath " in
+	      *" $dir "*) ;;
+	      *" $absdir "*) ;;
+	      *) temp_rpath="$temp_rpath $absdir" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if test "$alldeplibs" = yes &&
+	     { test "$deplibs_check_method" = pass_all ||
+	       { test "$build_libtool_libs" = yes &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test "$use_static_libs" = built && test "$installed" = yes ; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
+	  if test "$installed" = no; then
+	    notinst_deplibs="$notinst_deplibs $lib"
+	    need_relink=yes
+	  fi
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on
+	  # some systems (darwin)
+	  if test "$shouldnotlink" = yes && test "$pass" = link ; then
+	    $echo
+	    if test "$linkmode" = prog; then
+	      $echo "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $echo "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $echo "*** $linklib is not portable!"
+	  fi
+	  if test "$linkmode" = lib &&
+	     test "$hardcode_into_libs" = yes; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    realname="$2"
+	    shift; shift
+	    libname=`eval \\$echo \"$libname_spec\"`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname="$dlname"
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw*)
+		major=`expr $current - $age`
+		versuffix="-$major"
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname="$realname"
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot="$soname"
+	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
+	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      $show "extracting exported symbol list from \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$extract_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      $show "generating import library for \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$old_archive_from_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test "$linkmode" = prog || test "$mode" != relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test "$hardcode_direct" = no; then
+		add="$dir/$linklib"
+		case $host in
+		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
+		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+		    *-*-unixware7*) add_dir="-L$dir" ;;
+		  *-*-darwin* )
+		    # if the lib is a module then we can not link against
+		    # it, someone is ignoring the new warnings I added
+		    if /usr/bin/file -L $add 2> /dev/null |
+                      $EGREP ": [^:]* bundle" >/dev/null ; then
+		      $echo "** Warning, lib $linklib is a module, not a shared library"
+		      if test -z "$old_library" ; then
+		        $echo
+		        $echo "** And there doesn't seem to be a static archive available"
+		        $echo "** The link will probably fail, sorry"
+		      else
+		        add="$dir/$old_library"
+		      fi
+		    fi
+		esac
+	      elif test "$hardcode_minus_L" = no; then
+		case $host in
+		*-*-sunos*) add_shlibpath="$dir" ;;
+		esac
+		add_dir="-L$dir"
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = no; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test "$hardcode_direct" = yes; then
+		add="$dir/$linklib"
+	      elif test "$hardcode_minus_L" = yes; then
+		add_dir="-L$dir"
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    [\\/]*)
+		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = yes; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test "$lib_linked" != yes; then
+	      $echo "$modename: configuration error: unsupported hardcode properties"
+	      exit $EXIT_FAILURE
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test "$hardcode_direct" != yes && \
+		 test "$hardcode_minus_L" != yes && \
+		 test "$hardcode_shlibpath_var" = yes; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test "$linkmode" = prog || test "$mode" = relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test "$hardcode_direct" = yes; then
+	      add="$libdir/$linklib"
+	    elif test "$hardcode_minus_L" = yes; then
+	      add_dir="-L$libdir"
+	      add="-l$name"
+	    elif test "$hardcode_shlibpath_var" = yes; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+	      esac
+	      add="-l$name"
+	    elif test "$hardcode_automatic" = yes; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
+	        add="$inst_prefix_dir$libdir/$linklib"
+	      else
+	        add="$libdir/$linklib"
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir="-L$libdir"
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  [\\/]*)
+		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add="-l$name"
+	    fi
+
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test "$linkmode" = prog; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test "$hardcode_direct" != unsupported; then
+	    test -n "$old_library" && linklib="$old_library"
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test "$build_libtool_libs" = yes; then
+	  # Not a shared library
+	  if test "$deplibs_check_method" != pass_all; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    $echo
+	    $echo "*** Warning: This system can not link to static lib archive $lib."
+	    $echo "*** I have the capability to make that library automatically link in when"
+	    $echo "*** you link to this library.  But I can only do this if you have a"
+	    $echo "*** shared version of the library, which you do not appear to have."
+	    if test "$module" = yes; then
+	      $echo "*** But as you try to build a module library, libtool will still create "
+	      $echo "*** a static module, that should work as long as the dlopening application"
+	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		$echo
+		$echo "*** However, this would only work if libtool was able to extract symbol"
+		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		$echo "*** not find such a program.  So, this module is probably useless."
+		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test "$build_old_libs" = no; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test "$linkmode" = lib; then
+	  if test -n "$dependency_libs" &&
+	     { test "$hardcode_into_libs" != yes ||
+	       test "$build_old_libs" = yes ||
+	       test "$link_static" = yes; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) xrpath="$xrpath $temp_xrpath";;
+		   esac;;
+	      *) temp_deplibs="$temp_deplibs $libdir";;
+	      esac
+	    done
+	    dependency_libs="$temp_deplibs"
+	  fi
+
+	  newlib_search_path="$newlib_search_path $absdir"
+	  # Link against this library
+	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done
+
+	  if test "$link_all_deplibs" != no; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      -L*) path="$deplib" ;;
+	      *.la)
+		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
+		test "X$dir" = "X$deplib" && dir="."
+		# We need an absolute path.
+		case $dir in
+		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
+		    absdir="$dir"
+		  fi
+		  ;;
+		esac
+		if grep "^installed=no" $deplib > /dev/null; then
+		  path="$absdir/$objdir"
+		else
+		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  if test -z "$libdir"; then
+		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		    exit $EXIT_FAILURE
+		  fi
+		  if test "$absdir" != "$libdir"; then
+		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
+		  fi
+		  path="$absdir"
+		fi
+		depdepl=
+		case $host in
+		*-*-darwin*)
+		  # we do not want to link against static libs,
+		  # but need to link against shared
+		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names" ; then
+		    for tmp in $deplibrary_names ; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$path/$depdepl" ; then
+		      depdepl="$path/$depdepl"
+		    fi
+		    # do not add paths which are already there
+		    case " $newlib_search_path " in
+		    *" $path "*) ;;
+		    *) newlib_search_path="$newlib_search_path $path";;
+		    esac
+		  fi
+		  path=""
+		  ;;
+		*)
+		  path="-L$path"
+		  ;;
+		esac
+		;;
+	      -l*)
+		case $host in
+		*-*-darwin*)
+		  # Again, we only want to link against shared libraries
+		  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
+		  for tmp in $newlib_search_path ; do
+		    if test -f "$tmp/lib$tmp_libs.dylib" ; then
+		      eval depdepl="$tmp/lib$tmp_libs.dylib"
+		      break
+		    fi
+		  done
+		  path=""
+		  ;;
+		*) continue ;;
+		esac
+		;;
+	      *) continue ;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	      case " $deplibs " in
+	      *" $depdepl "*) ;;
+	      *) deplibs="$depdepl $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      dependency_libs="$newdependency_libs"
+      if test "$pass" = dlpreopen; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test "$pass" != dlopen; then
+	if test "$pass" != conv; then
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) lib_search_path="$lib_search_path $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	fi
+
+	if test "$linkmode,$pass" != "prog,link"; then
+	  vars="deplibs"
+	else
+	  vars="compile_deplibs finalize_deplibs"
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) tmp_libs="$tmp_libs $deplib" ;;
+	      esac
+	      ;;
+	    *) tmp_libs="$tmp_libs $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs ; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=""
+	  ;;
+	esac
+	if test -n "$i" ; then
+	  tmp_libs="$tmp_libs $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test "$linkmode" = prog; then
+      dlfiles="$newdlfiles"
+      dlprefiles="$newdlprefiles"
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
+      fi
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs="$output"
+      objs="$objs$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form `libNAME.la'.
+      case $outputname in
+      lib*)
+	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	if test "$module" = no; then
+	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	if test "$need_lib_prefix" != no; then
+	  # Add the "lib" prefix for modules if required
+	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test "$deplibs_check_method" != pass_all; then
+	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
+	  exit $EXIT_FAILURE
+	else
+	  $echo
+	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
+	  $echo "*** objects $objs is not portable!"
+	  libobjs="$libobjs $objs"
+	fi
+      fi
+
+      if test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
+      fi
+
+      set dummy $rpath
+      if test "$#" -gt 2; then
+	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
+      fi
+      install_libdir="$2"
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test "$build_libtool_libs" = yes; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a `.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	if test -n "$vinfo"; then
+	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
+	fi
+
+	if test -n "$release"; then
+	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
+	fi
+      else
+
+	# Parse the version information argument.
+	save_ifs="$IFS"; IFS=':'
+	set dummy $vinfo 0 0 0
+	IFS="$save_ifs"
+
+	if test -n "$8"; then
+	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major="$2"
+	  number_minor="$3"
+	  number_revision="$4"
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # which has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  darwin|linux|osf|windows)
+	    current=`expr $number_major + $number_minor`
+	    age="$number_minor"
+	    revision="$number_revision"
+	    ;;
+	  freebsd-aout|freebsd-elf|sunos)
+	    current="$number_major"
+	    revision="$number_minor"
+	    age="0"
+	    ;;
+	  irix|nonstopux)
+	    current=`expr $number_major + $number_minor - 1`
+	    age="$number_minor"
+	    revision="$number_minor"
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current="$2"
+	  revision="$3"
+	  age="$4"
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $revision in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $age in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  # Darwin ld doesn't like 0 for these options...
+	  minor_current=`expr $current + 1`
+	  verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
+	  ;;
+
+	freebsd-aout)
+	  major=".$current"
+	  versuffix=".$current.$revision";
+	  ;;
+
+	freebsd-elf)
+	  major=".$current"
+	  versuffix=".$current";
+	  ;;
+
+	irix | nonstopux)
+	  major=`expr $current - $age + 1`
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring="$verstring_prefix$major.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test "$loop" -ne 0; do
+	    iface=`expr $revision - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring_prefix$major.$iface:$verstring"
+	  done
+
+	  # Before this point, $major must not contain `.'.
+	  major=.$major
+	  versuffix="$major.$revision"
+	  ;;
+
+	linux)
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  ;;
+
+	osf)
+	  major=.`expr $current - $age`
+	  versuffix=".$current.$age.$revision"
+	  verstring="$current.$age.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test "$loop" -ne 0; do
+	    iface=`expr $current - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring:${iface}.0"
+	  done
+
+	  # Make executables depend on our current version.
+	  verstring="$verstring:${current}.0"
+	  ;;
+
+	sunos)
+	  major=".$current"
+	  versuffix=".$current.$revision"
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 filesystems.
+	  major=`expr $current - $age`
+	  versuffix="-$major"
+	  ;;
+
+	*)
+	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
+	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring="0.0"
+	    ;;
+	  esac
+	  if test "$need_version" = no; then
+	    versuffix=
+	  else
+	    versuffix=".0.0"
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test "$avoid_version" = yes && test "$need_version" = no; then
+	  major=
+	  versuffix=
+	  verstring=""
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test "$allow_undefined" = yes; then
+	  if test "$allow_undefined_flag" = unsupported; then
+	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
+	    build_libtool_libs=no
+	    build_old_libs=yes
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag="$no_undefined_flag"
+	fi
+      fi
+
+      if test "$mode" != relink; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$echo "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
+	       if test "X$precious_files_regex" != "X"; then
+	         if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+	         then
+		   continue
+		 fi
+	       fi
+	       removelist="$removelist $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	if test -n "$removelist"; then
+	  $show "${rm}r $removelist"
+	  $run ${rm}r $removelist
+	fi
+      fi
+
+      # Now set the variables for building old libraries.
+      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+	oldlibs="$oldlibs $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      for path in $notinst_path; do
+	lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
+	deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
+	dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
+      done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  temp_xrpath="$temp_xrpath -R$libdir"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles="$dlfiles"
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) dlfiles="$dlfiles $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles="$dlprefiles"
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) dlprefiles="$dlprefiles $lib" ;;
+	esac
+      done
+
+      if test "$build_libtool_libs" = yes; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C library is in the System framework
+	    deplibs="$deplibs -framework System"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+ 	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test "$build_libtool_need_lc" = "yes"; then
+	      deplibs="$deplibs -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=""
+	versuffix=""
+	major=""
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $rm conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $rm conftest
+	  $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
+	  if test "$?" -eq 0 ; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" -ne "0"; then
+		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    newdeplibs="$newdeplibs $i"
+		    i=""
+		    ;;
+		  esac
+	        fi
+		if test -n "$i" ; then
+		  libname=`eval \\$echo \"$libname_spec\"`
+		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		  set dummy $deplib_matches
+		  deplib_match=$2
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		    newdeplibs="$newdeplibs $i"
+		  else
+		    droppeddeps=yes
+		    $echo
+		    $echo "*** Warning: dynamic linker does not accept needed library $i."
+		    $echo "*** I have the capability to make that library automatically link in when"
+		    $echo "*** you link to this library.  But I can only do this if you have a"
+		    $echo "*** shared version of the library, which I believe you do not have"
+		    $echo "*** because a test_compile did reveal that the linker did not use it for"
+		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" != "0"; then
+		$rm conftest
+		$LTCC $LTCFLAGS -o conftest conftest.c $i
+		# Did it work?
+		if test "$?" -eq 0 ; then
+		  ldd_output=`ldd conftest`
+		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      newdeplibs="$newdeplibs $i"
+		      i=""
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i" ; then
+		    libname=`eval \\$echo \"$libname_spec\"`
+		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		    set dummy $deplib_matches
+		    deplib_match=$2
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		      newdeplibs="$newdeplibs $i"
+		    else
+		      droppeddeps=yes
+		      $echo
+		      $echo "*** Warning: dynamic linker does not accept needed library $i."
+		      $echo "*** I have the capability to make that library automatically link in when"
+		      $echo "*** you link to this library.  But I can only do this if you have a"
+		      $echo "*** shared version of the library, which you do not appear to have"
+		      $echo "*** because a test_compile did reveal that the linker did not use this one"
+		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  $echo
+		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
+		  $echo "***  make it link in!  You will probably need to install it or some"
+		  $echo "*** library that it depends on before this library will be fully"
+		  $echo "*** functional.  Installing it before continuing would be even better."
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method
+	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+            if test "$name" != "" && test  "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null \
+			 | grep " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib="$potent_lib"
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
+			case $potliblink in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
+			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+			esac
+		      done
+		      # It is ok to link against an archive when
+		      # building a shared library.
+		      if $AR -t $potlib > /dev/null 2>&1; then
+		        newdeplibs="$newdeplibs $a_deplib"
+		        a_deplib=""
+		        break 2
+		      fi
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
+			 | ${SED} 10q \
+			 | $EGREP "$file_magic_regex" > /dev/null; then
+			newdeplibs="$newdeplibs $a_deplib"
+			a_deplib=""
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+	    if test -n "$name" && test "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib="$potent_lib" # see symlink-check above in file_magic test
+		    if eval $echo \"$potent_lib\" 2>/dev/null \
+		        | ${SED} 10q \
+		        | $EGREP "$match_pattern_regex" > /dev/null; then
+		      newdeplibs="$newdeplibs $a_deplib"
+		      a_deplib=""
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=""
+	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
+	    -e 's/ -[LR][^ ]*//g'`
+	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	    for i in $predeps $postdeps ; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
+	    done
+	  fi
+	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
+	    | grep . >/dev/null; then
+	    $echo
+	    if test "X$deplibs_check_method" = "Xnone"; then
+	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      $echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    $echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	  fi
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.[012])
+	  # On Rhapsody replace the C library is the System framework
+	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	  ;;
+	esac
+
+	if test "$droppeddeps" = yes; then
+	  if test "$module" = yes; then
+	    $echo
+	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
+	    $echo "*** a static module, that should work as long as the dlopening"
+	    $echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      $echo
+	      $echo "*** However, this would only work if libtool was able to extract symbol"
+	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      $echo "*** not find such a program.  So, this module is probably useless."
+	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test "$build_old_libs" = no; then
+	      oldlibs="$output_objdir/$libname.$libext"
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    $echo "*** The inter-library dependencies that have been dropped here will be"
+	    $echo "*** automatically added whenever a program is linked with this library"
+	    $echo "*** or is declared to -dlopen it."
+
+	    if test "$allow_undefined" = no; then
+	      $echo
+	      $echo "*** Since this library must not contain undefined symbols,"
+	      $echo "*** because either the platform does not support them or"
+	      $echo "*** it was explicitly requested with -no-undefined,"
+	      $echo "*** libtool will only create a static version of it."
+	      if test "$build_old_libs" = no; then
+		oldlibs="$output_objdir/$libname.$libext"
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      deplibs="$new_libs"
+
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test "$build_libtool_libs" = yes; then
+	if test "$hardcode_into_libs" = yes; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath="$finalize_rpath"
+	  test "$mode" != relink && rpath="$compile_rpath$rpath"
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs="$libdir"
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		dep_rpath="$dep_rpath $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) perm_rpath="$perm_rpath $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir="$hardcode_libdirs"
+	    if test -n "$hardcode_libdir_flag_spec_ld"; then
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
+	    else
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
+	    fi
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      rpath="$rpath$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath="$finalize_shlibpath"
+	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	realname="$2"
+	shift; shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname="$realname"
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib="$output_objdir/$realname"
+	linknames=
+	for link
+	do
+	  linknames="$linknames $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      eval cmd=\"$cmd\"
+	      if len=`expr "X$cmd" : ".*"` &&
+	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	        $show "$cmd"
+	        $run eval "$cmd" || exit $?
+	        skipped_export=false
+	      else
+	        # The command line is too long to execute in one step.
+	        $show "using reloadable object file for export list..."
+	        skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS="$save_ifs"
+	    if test -n "$export_symbols_regex"; then
+	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
+	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
+	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+		case " $convenience " in
+		*" $test_deplib "*) ;;
+		*)
+			tmp_deplibs="$tmp_deplibs $test_deplib"
+			;;
+		esac
+	done
+	deplibs="$tmp_deplibs"
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  else
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    libobjs="$libobjs $func_extract_archives_result"
+	  fi
+	fi
+	
+	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  linker_flags="$linker_flags $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test "$module" = yes && test -n "$module_cmds" ; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	  eval test_cmds=\"$archive_expsym_cmds\"
+	  cmds=$archive_expsym_cmds
+	else
+	  eval test_cmds=\"$archive_cmds\"
+	  cmds=$archive_cmds
+	  fi
+	fi
+
+	if test "X$skipped_export" != "X:" &&
+	   len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise.
+	  $echo "creating reloadable object files..."
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  output_la=`$echo "X$output" | $Xsed -e "$basename"`
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  delfiles=
+	  last_robj=
+	  k=1
+	  output=$output_objdir/$output_la-${k}.$objext
+	  # Loop over the list of objects to be linked.
+	  for obj in $save_libobjs
+	  do
+	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
+	    if test "X$objlist" = X ||
+	       { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+		 test "$len" -le "$max_cmd_len"; }; then
+	      objlist="$objlist $obj"
+	    else
+	      # The command $test_cmds is almost too long, add a
+	      # command to the queue.
+	      if test "$k" -eq 1 ; then
+		# The first file doesn't have a previous command to add.
+		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
+	      else
+		# All subsequent reloadable object files will link in
+		# the last one created.
+		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
+	      fi
+	      last_robj=$output_objdir/$output_la-${k}.$objext
+	      k=`expr $k + 1`
+	      output=$output_objdir/$output_la-${k}.$objext
+	      objlist=$obj
+	      len=1
+	    fi
+	  done
+	  # Handle the remaining objects by creating one last
+	  # reloadable object file.  All subsequent reloadable object
+	  # files will link in the last one created.
+	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
+
+	  if ${skipped_export-false}; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    libobjs=$output
+	    # Append the command to create the export file.
+	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
+          fi
+
+	  # Set up a command to remove the reloadable object files
+	  # after they are used.
+	  i=0
+	  while test "$i" -lt "$k"
+	  do
+	    i=`expr $i + 1`
+	    delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
+	  done
+
+	  $echo "creating a temporary reloadable object file: $output"
+
+	  # Loop through the commands generated above and execute them.
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $concat_cmds; do
+	    IFS="$save_ifs"
+	    $show "$cmd"
+	    $run eval "$cmd" || exit $?
+	  done
+	  IFS="$save_ifs"
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test "$module" = yes && test -n "$module_cmds" ; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    cmds=$archive_expsym_cmds
+	  else
+	    cmds=$archive_cmds
+	    fi
+	  fi
+
+	  # Append the command to remove the reloadable object files
+	  # to the just-reset $cmds.
+	  eval cmds=\"\$cmds~\$rm $delfiles\"
+	fi
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test "$mode" = relink; then
+	      $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS="$save_ifs"
+
+	# Restore the uninstalled library and exit
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      $show "${rm}r $gentop"
+	      $run ${rm}r "$gentop"
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
+	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test "$module" = yes || test "$export_dynamic" = yes; then
+	  # On all known operating systems, these are identical.
+	  dlname="$soname"
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
+      fi
+
+      case $output in
+      *.lo)
+	if test -n "$objs$old_deplibs"; then
+	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	libobj="$output"
+	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
+	;;
+      *)
+	libobj=
+	obj="$output"
+	;;
+      esac
+
+      # Delete the old objects.
+      $run $rm $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # reload_cmds runs $LD directly, so let us get rid of
+      # -Wl from whole_archive_flag_spec
+      wl=
+
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
+	else
+	  gentop="$output_objdir/${obj}x"
+	  generated="$generated $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # Create the old-style object.
+      reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+
+      output="$obj"
+      cmds=$reload_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$build_libtool_libs" != yes; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $run eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test -n "$pic_flag" || test "$pic_mode" != default; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output="$libobj"
+	cmds=$reload_cmds
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || exit $?
+	done
+	IFS="$save_ifs"
+      fi
+
+      if test -n "$gentop"; then
+	$show "${rm}r $gentop"
+	$run ${rm}r $gentop
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
+      esac
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
+      fi
+
+      if test "$preload" = yes; then
+	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
+	   test "$dlopen_self_static" = unknown; then
+	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
+	fi
+      fi
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.[012])
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	;;
+      esac
+
+      case $host in
+      *darwin*)
+        # Don't allow lazy linking, it breaks C++ global constructors
+        if test "$tagname" = CXX ; then
+        compile_command="$compile_command ${wl}-bind_at_load"
+        finalize_command="$finalize_command ${wl}-bind_at_load"
+        fi
+        ;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      compile_deplibs="$new_libs"
+
+
+      compile_command="$compile_command $compile_deplibs"
+      finalize_command="$finalize_command $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) perm_rpath="$perm_rpath $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath="$rpath"
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath="$rpath"
+
+      if test -n "$libobjs" && test "$build_old_libs" = yes; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+      fi
+
+      dlsyms=
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	  dlsyms="${outputname}S.c"
+	else
+	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
+	fi
+      fi
+
+      if test -n "$dlsyms"; then
+	case $dlsyms in
+	"") ;;
+	*.c)
+	  # Discover the nlist of each of the dlfiles.
+	  nlist="$output_objdir/${outputname}.nm"
+
+	  $show "$rm $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Parse the name list into a source file.
+	  $show "creating $output_objdir/$dlsyms"
+
+	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
+/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
+/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+/* Prevent the only kind of declaration conflicts we can make. */
+#define lt_preloaded_symbols some_other_symbol
+
+/* External symbol declarations for the compiler. */\
+"
+
+	  if test "$dlself" = yes; then
+	    $show "generating symbol list for \`$output'"
+
+	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
+
+	    # Add our own program objects to the symbol list.
+	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	    for arg in $progfiles; do
+	      $show "extracting global C symbols from \`$arg'"
+	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	    done
+
+	    if test -n "$exclude_expsyms"; then
+	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    if test -n "$export_symbols_regex"; then
+	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    # Prepare the list of exported symbols
+	    if test -z "$export_symbols"; then
+	      export_symbols="$output_objdir/$outputname.exp"
+	      $run $rm $export_symbols
+	      $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    else
+	      $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      $run eval 'mv "$nlist"T "$nlist"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    fi
+	  fi
+
+	  for arg in $dlprefiles; do
+	    $show "extracting global C symbols from \`$arg'"
+	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
+	    $run eval '$echo ": $name " >> "$nlist"'
+	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -z "$run"; then
+	    # Make sure we have at least an empty file.
+	    test -f "$nlist" || : > "$nlist"
+
+	    if test -n "$exclude_expsyms"; then
+	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	      $mv "$nlist"T "$nlist"
+	    fi
+
+	    # Try sorting and uniquifying the output.
+	    if grep -v "^: " < "$nlist" |
+		if sort -k 3 </dev/null >/dev/null 2>&1; then
+		  sort -k 3
+		else
+		  sort +2
+		fi |
+		uniq > "$nlist"S; then
+	      :
+	    else
+	      grep -v "^: " < "$nlist" > "$nlist"S
+	    fi
+
+	    if test -f "$nlist"S; then
+	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
+	    else
+	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
+	    fi
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+
+#undef lt_preloaded_symbols
+
+#if defined (__STDC__) && __STDC__
+# define lt_ptr void *
+#else
+# define lt_ptr char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+"
+
+	    case $host in
+	    *cygwin* | *mingw* )
+	  $echo >> "$output_objdir/$dlsyms" "\
+/* DATA imports from DLLs on WIN32 can't be const, because
+   runtime relocations are performed -- see ld's documentation
+   on pseudo-relocs */
+struct {
+"
+	      ;;
+	    * )
+	  $echo >> "$output_objdir/$dlsyms" "\
+const struct {
+"
+	      ;;
+	    esac
+
+
+	  $echo >> "$output_objdir/$dlsyms" "\
+  const char *name;
+  lt_ptr address;
+}
+lt_preloaded_symbols[] =
+{\
+"
+
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+  {0, (lt_ptr) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	  fi
+
+	  pic_flag_for_symtable=
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
+	    esac;;
+	  *-*-hpux*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag";;
+	    esac
+	  esac
+
+	  # Now compile the dynamic symbol file.
+	  $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
+	  $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
+
+	  # Clean up the generated files.
+	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Transform the symbol file into the correct name.
+          case $host in
+          *cygwin* | *mingw* )
+            if test -f "$output_objdir/${outputname}.def" ; then
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+            else
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+             fi
+            ;;
+          * )
+            compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            ;;
+          esac
+	  ;;
+	*)
+	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      else
+	# We keep going just in case the user didn't refer to
+	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+	# really was required.
+
+	# Nullify the symbol file.
+	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
+	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+      fi
+
+      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
+	# Replace the output file specification.
+	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	link_command="$compile_command$compile_rpath"
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	$show "$link_command"
+	$run eval "$link_command"
+	exit_status=$?
+
+	# Delete the generated files.
+	if test -n "$dlsyms"; then
+	  $show "$rm $output_objdir/${outputname}S.${objext}"
+	  $run $rm "$output_objdir/${outputname}S.${objext}"
+	fi
+
+	exit $exit_status
+      fi
+
+      if test -n "$shlibpath_var"; then
+	# We should set the shlibpath_var
+	rpath=
+	for dir in $temp_rpath; do
+	  case $dir in
+	  [\\/]* | [A-Za-z]:[\\/]*)
+	    # Absolute path.
+	    rpath="$rpath$dir:"
+	    ;;
+	  *)
+	    # Relative path: add a thisdir entry.
+	    rpath="$rpath\$thisdir/$dir:"
+	    ;;
+	  esac
+	done
+	temp_rpath="$rpath"
+      fi
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test "$no_install" = yes; then
+	# We don't need to create a wrapper script.
+	link_command="$compile_var$compile_command$compile_rpath"
+	# Replace the output file specification.
+	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$run $rm $output
+	# Link the executable and exit
+	$show "$link_command"
+	$run eval "$link_command" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$hardcode_action" = relink; then
+	# Fast installation is not supported
+	link_command="$compile_var$compile_command$compile_rpath"
+	relink_command="$finalize_var$finalize_command$finalize_rpath"
+
+	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
+	$echo "$modename: \`$output' will be relinked during installation" 1>&2
+      else
+	if test "$fast_install" != no; then
+	  link_command="$finalize_var$compile_command$finalize_rpath"
+	  if test "$fast_install" = yes; then
+	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+	  else
+	    # fast_install is set to needless
+	    relink_command=
+	  fi
+	else
+	  link_command="$compile_var$compile_command$compile_rpath"
+	  relink_command="$finalize_var$finalize_command$finalize_rpath"
+	fi
+      fi
+
+      # Replace the output file specification.
+      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      $show "$link_command"
+      $run eval "$link_command" || exit $?
+
+      # Now create the wrapper script.
+      $show "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Quote $echo for shipping.
+      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
+	case $progpath in
+	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
+	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
+	esac
+	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
+      else
+	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if our run command is non-null.
+      if test -z "$run"; then
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+            output_name=`basename $output`
+            output_path=`dirname $output`
+            cwrappersource="$output_path/$objdir/lt-$output_name.c"
+            cwrapper="$output_path/$output_name.exe"
+            $rm $cwrappersource $cwrapper
+            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    cat > $cwrappersource <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+
+   Currently, it simply execs the wrapper *script* "/bin/sh $output",
+   but could eventually absorb all of the scripts functionality and
+   exec $objdir/$outputname directly.
+*/
+EOF
+	    cat >> $cwrappersource<<"EOF"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/stat.h>
+
+#if defined(PATH_MAX)
+# define LT_PATHMAX PATH_MAX
+#elif defined(MAXPATHLEN)
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
+  defined (__OS2__)
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free ((void *) stale); stale = 0; } \
+} while (0)
+
+/* -DDEBUG is fairly common in CFLAGS.  */
+#undef DEBUG
+#if defined DEBUGWRAPPER
+# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
+#else
+# define DEBUG(format, ...)
+#endif
+
+const char *program_name = NULL;
+
+void * xmalloc (size_t num);
+char * xstrdup (const char *string);
+const char * base_name (const char *name);
+char * find_executable(const char *wrapper);
+int    check_executable(const char *path);
+char * strendzap(char *str, const char *pat);
+void lt_fatal (const char *message, ...);
+
+int
+main (int argc, char *argv[])
+{
+  char **newargz;
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  DEBUG("(main) argv[0]      : %s\n",argv[0]);
+  DEBUG("(main) program_name : %s\n",program_name);
+  newargz = XMALLOC(char *, argc+2);
+EOF
+
+            cat >> $cwrappersource <<EOF
+  newargz[0] = (char *) xstrdup("$SHELL");
+EOF
+
+            cat >> $cwrappersource <<"EOF"
+  newargz[1] = find_executable(argv[0]);
+  if (newargz[1] == NULL)
+    lt_fatal("Couldn't find %s", argv[0]);
+  DEBUG("(main) found exe at : %s\n",newargz[1]);
+  /* we know the script has the same name, without the .exe */
+  /* so make sure newargz[1] doesn't end in .exe */
+  strendzap(newargz[1],".exe");
+  for (i = 1; i < argc; i++)
+    newargz[i+1] = xstrdup(argv[i]);
+  newargz[argc+1] = NULL;
+
+  for (i=0; i<argc+1; i++)
+  {
+    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
+    ;
+  }
+
+EOF
+
+            case $host_os in
+              mingw*)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",(char const **)newargz);
+EOF
+              ;;
+              *)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",newargz);
+EOF
+              ;;
+            esac
+
+            cat >> $cwrappersource <<"EOF"
+  return 127;
+}
+
+void *
+xmalloc (size_t num)
+{
+  void * p = (void *) malloc (num);
+  if (!p)
+    lt_fatal ("Memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
+;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable(const char * path)
+{
+  struct stat st;
+
+  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0) &&
+      (
+        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
+#if defined (S_IXOTH)
+       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
+#endif
+#if defined (S_IXGRP)
+       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
+#endif
+       ((st.st_mode & S_IXUSR) == S_IXUSR))
+      )
+    return 1;
+  else
+    return 0;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise */
+char *
+find_executable (const char* wrapper)
+{
+  int has_slash = 0;
+  const char* p;
+  const char* p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  int tmp_len;
+  char* concat_name;
+
+  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
+  {
+    concat_name = xstrdup (wrapper);
+    if (check_executable(concat_name))
+      return concat_name;
+    XFREE(concat_name);
+  }
+  else
+  {
+#endif
+    if (IS_DIR_SEPARATOR (wrapper[0]))
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable(concat_name))
+        return concat_name;
+      XFREE(concat_name);
+    }
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+    {
+      has_slash = 1;
+      break;
+    }
+  if (!has_slash)
+  {
+    /* no slashes; search PATH */
+    const char* path = getenv ("PATH");
+    if (path != NULL)
+    {
+      for (p = path; *p; p = p_next)
+      {
+        const char* q;
+        size_t p_len;
+        for (q = p; *q; q++)
+          if (IS_PATH_SEPARATOR(*q))
+            break;
+        p_len = q - p;
+        p_next = (*q == '\0' ? q : q + 1);
+        if (p_len == 0)
+        {
+          /* empty path: current directory */
+          if (getcwd (tmp, LT_PATHMAX) == NULL)
+            lt_fatal ("getcwd failed");
+          tmp_len = strlen(tmp);
+          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, tmp, tmp_len);
+          concat_name[tmp_len] = '/';
+          strcpy (concat_name + tmp_len + 1, wrapper);
+        }
+        else
+        {
+          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, p, p_len);
+          concat_name[p_len] = '/';
+          strcpy (concat_name + p_len + 1, wrapper);
+        }
+        if (check_executable(concat_name))
+          return concat_name;
+        XFREE(concat_name);
+      }
+    }
+    /* not found in PATH; assume curdir */
+  }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal ("getcwd failed");
+  tmp_len = strlen(tmp);
+  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable(concat_name))
+    return concat_name;
+  XFREE(concat_name);
+  return NULL;
+}
+
+char *
+strendzap(char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert(str != NULL);
+  assert(pat != NULL);
+
+  len = strlen(str);
+  patlen = strlen(pat);
+
+  if (patlen <= len)
+  {
+    str += len - patlen;
+    if (strcmp(str, pat) == 0)
+      *str = '\0';
+  }
+  return str;
+}
+
+static void
+lt_error_core (int exit_status, const char * mode,
+          const char * message, va_list ap)
+{
+  fprintf (stderr, "%s: %s: ", program_name, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
+  va_end (ap);
+}
+EOF
+          # we should really use a build-platform specific compiler
+          # here, but OTOH, the wrappers (shell script and this C one)
+          # are only useful if you want to execute the "real" binary.
+          # Since the "real" binary is built for $host, then this
+          # wrapper might as well be built for $host, too.
+          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
+          ;;
+        esac
+        $rm $output
+        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
+
+	$echo > $output "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='${SED} -e 1s/^X//'
+sed_quote_subst='$sed_quote_subst'
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variable:
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$echo are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    echo=\"$qecho\"
+    file=\"\$0\"
+    # Make sure echo works.
+    if test \"X\$1\" = X--no-reexec; then
+      # Discard the --no-reexec flag, and continue.
+      shift
+    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
+      # Yippee, \$echo works!
+      :
+    else
+      # Restart under the correct shell, and then maybe \$echo will work.
+      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
+    fi
+  fi\
+"
+	$echo >> $output "\
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
+  done
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test "$fast_install" = yes; then
+	  $echo >> $output "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" || \\
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $mkdir \"\$progdir\"
+    else
+      $rm \"\$progdir/\$file\"
+    fi"
+
+	  $echo >> $output "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	$echo \"\$relink_command_output\" >&2
+	$rm \"\$progdir/\$file\"
+	exit $EXIT_FAILURE
+      fi
+    fi
+
+    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $rm \"\$progdir/\$program\";
+      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $rm \"\$progdir/\$file\"
+  fi"
+	else
+	  $echo >> $output "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$echo >> $output "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# Export our shlibpath_var if we have one.
+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $echo >> $output "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	# fixup the dll searchpath if we need to.
+	if test -n "$dllsearchpath"; then
+	  $echo >> $output "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	$echo >> $output "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+
+      # Make sure env LD_LIBRARY_PATH does not mess us up
+      if test -n \"\${LD_LIBRARY_PATH+set}\"; then
+        export LD_LIBRARY_PATH=\$progdir:\$LD_LIBRARY_PATH
+      fi
+"
+	case $host in
+	# Backslashes separate directories on plain windows
+	*-*-mingw | *-*-os2*)
+	  $echo >> $output "\
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+	  ;;
+
+	*)
+	  $echo >> $output "\
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+	  ;;
+	esac
+	$echo >> $output "\
+      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
+      exit $EXIT_FAILURE
+    fi
+  else
+    # The program doesn't exist.
+    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+    \$echo \"This script is just a wrapper for \$program.\" 1>&2
+    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi\
+"
+	chmod +x $output
+      fi
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      if test "$build_libtool_libs" = convenience; then
+	oldobjs="$libobjs_save"
+	addlibs="$convenience"
+	build_libtool_libs=no
+      else
+	if test "$build_libtool_libs" = module; then
+	  oldobjs="$libobjs_save"
+	  build_libtool_libs=no
+	else
+	  oldobjs="$old_deplibs $non_pic_objects"
+	fi
+	addlibs="$old_convenience"
+      fi
+
+      if test -n "$addlibs"; then
+	gentop="$output_objdir/${outputname}x"
+	generated="$generated $gentop"
+
+	func_extract_archives $gentop $addlibs
+	oldobjs="$oldobjs $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+       cmds=$old_archive_from_new_cmds
+      else
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  $echo "copying selected object files to avoid basename conflicts..."
+
+	  if test -z "$gentop"; then
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    $show "${rm}r $gentop"
+	    $run ${rm}r "$gentop"
+	    $show "$mkdir $gentop"
+	    $run $mkdir "$gentop"
+	    exit_status=$?
+	    if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
+	      exit $exit_status
+	    fi
+	  fi
+
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *[\ /]"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		counter=`expr $counter + 1`
+		case " $oldobjs " in
+		*[\ /]"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      $run ln "$obj" "$gentop/$newobj" ||
+	      $run cp "$obj" "$gentop/$newobj"
+	      oldobjs="$oldobjs $gentop/$newobj"
+	      ;;
+	    *) oldobjs="$oldobjs $obj" ;;
+	    esac
+	  done
+	fi
+
+	eval cmds=\"$old_archive_cmds\"
+
+	if len=`expr "X$cmds" : ".*"` &&
+	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  $echo "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  for obj in $save_oldobjs
+	  do
+	    oldobjs="$objlist $obj"
+	    objlist="$objlist $obj"
+	    eval test_cmds=\"$old_archive_cmds\"
+	    if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	       test "$len" -le "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj" ; then
+	        RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
+	      objlist=
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test "X$oldobjs" = "X" ; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+        eval cmd=\"$cmd\"
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$generated"; then
+      $show "${rm}r$generated"
+      $run ${rm}r$generated
+    fi
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test "$build_old_libs" = yes && old_library="$libname.$libext"
+      $show "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      if test "$hardcode_automatic" = yes ; then
+	relink_command=
+      fi
+
+
+      # Only create the output if not a dry run.
+      if test -z "$run"; then
+	for installed in no yes; do
+	  if test "$installed" = yes; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output="$output_objdir/$outputname"i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
+		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		if test -z "$libdir"; then
+		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+		if test "X$EGREP" = X ; then
+			EGREP=egrep
+		fi
+		# We do not want portage's install root ($D) present.  Check only for
+		# this if the .la is being installed.
+		if test "$installed" = yes && test "$D"; then
+		  eval mynewdependency_lib=`echo "$libdir/$name" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+		else
+		  mynewdependency_lib="$libdir/$name"
+		fi
+		# Do not add duplicates
+		if test "$mynewdependency_lib"; then
+		  my_little_ninja_foo_1=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
+		  if test -z "$my_little_ninja_foo_1"; then
+		    newdependency_libs="$newdependency_libs $mynewdependency_lib"
+		  fi
+		fi
+		;;
+		  *)
+		if test "$installed" = yes; then
+		  # Rather use S=WORKDIR if our version of portage supports it.
+		  # This is because some ebuild (gcc) do not use $S as buildroot.
+		  if test "$PWORKDIR"; then
+		    S="$PWORKDIR"
+		  fi
+		  # We do not want portage's build root ($S) present.
+		  my_little_ninja_foo_2=`echo $deplib |$EGREP -e "$S"`
+		  # We do not want portage's install root ($D) present.
+		  my_little_ninja_foo_3=`echo $deplib |$EGREP -e "$D"`
+		  if test -n "$my_little_ninja_foo_2" && test "$S"; then
+		    mynewdependency_lib=""
+		  elif test -n "$my_little_ninja_foo_3" && test "$D"; then
+		    eval mynewdependency_lib=`echo "$deplib" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+		  else
+		    mynewdependency_lib="$deplib"
+		  fi
+		else
+		  mynewdependency_lib="$deplib"
+		fi
+		# Do not add duplicates
+		if test "$mynewdependency_lib"; then
+		  my_little_ninja_foo_4=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
+		  if test -z "$my_little_ninja_foo_4"; then
+			newdependency_libs="$newdependency_libs $mynewdependency_lib"
+		  fi
+		fi
+		;;
+	      esac
+	    done
+	    dependency_libs="$newdependency_libs"
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlfiles="$newdlfiles $libdir/$name"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlprefiles="$newdlprefiles $libdir/$name"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlfiles="$newdlfiles $abs"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlprefiles="$newdlprefiles $abs"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  fi
+	  $rm $output
+	  # place dlname in correct position for cygwin
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
+	  esac
+	  # Do not add duplicates
+	  if test "$installed" = yes && test "$D"; then
+	    install_libdir=`echo "$install_libdir" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+	  fi
+	  $echo > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test "$installed" = no && test "$need_relink" = yes; then
+	    $echo >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      fi
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
+      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool install mode
+  install)
+    modename="$modename: install"
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
+       # Allow the use of GNU shtool's install command.
+       $echo "X$nonopt" | grep shtool > /dev/null; then
+      # Aesthetically quote it.
+      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$arg "
+      arg="$1"
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+    case $arg in
+    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      arg="\"$arg\""
+      ;;
+    esac
+    install_prog="$install_prog$arg"
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=no
+    stripme=
+    for arg
+    do
+      if test -n "$dest"; then
+	files="$files $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=yes ;;
+      -f) 
+      	case " $install_prog " in
+	*[\\\ /]cp\ *) ;;
+	*) prev=$arg ;;
+	esac
+	;;
+      -g | -m | -o) prev=$arg ;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$install_prog $arg"
+    done
+
+    if test -z "$install_prog"; then
+      $echo "$modename: you must specify an install program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prev' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	$echo "$modename: no file or destination specified" 1>&2
+      else
+	$echo "$modename: you must specify a destination" 1>&2
+      fi
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Strip any trailing slash from the destination.
+    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=yes
+    if test "$isdir" = yes; then
+      destdir="$dest"
+      destname=
+    else
+      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
+      test "X$destdir" = "X$dest" && destdir=.
+      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files
+      if test "$#" -gt 2; then
+	$echo "$modename: \`$dest' is not a directory" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+    fi
+    case $destdir in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	staticlibs="$staticlibs $file"
+	;;
+
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	library_names=
+	old_library=
+	relink_command=
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) current_libdirs="$current_libdirs $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) future_libdirs="$future_libdirs $libdir" ;;
+	  esac
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
+	test "X$dir" = "X$file/" && dir=
+	dir="$dir$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  if test "$inst_prefix_dir" = "$destdir"; then
+	    $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  $echo "$modename: warning: relinking \`$file'" 1>&2
+	  $show "$relink_command"
+	  if $run eval "$relink_command"; then :
+	  else
+	    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names
+	if test -n "$2"; then
+	  realname="$2"
+	  shift
+	  shift
+
+	  srcname="$realname"
+	  test -n "$relink_command" && srcname="$realname"T
+
+	  # Install the shared library and build the symlinks.
+	  $show "$install_prog $dir/$srcname $destdir/$realname"
+	  $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
+	  if test -n "$stripme" && test -n "$striplib"; then
+	    $show "$striplib $destdir/$realname"
+	    $run eval "$striplib $destdir/$realname" || exit $?
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try `ln -sf' first, because the `ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      if test "$linkname" != "$realname"; then
+                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+	      fi
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib="$destdir/$realname"
+	  cmds=$postinstall_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || {
+	      lt_exit=$?
+
+	      # Restore the uninstalled library and exit
+	      if test "$mode" = relink; then
+		$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	      fi
+
+	      exit $lt_exit
+	    }
+	  done
+	  IFS="$save_ifs"
+	fi
+
+	# Install the pseudo-library for information purposes.
+	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	instname="$dir/$name"i
+	$show "$install_prog $instname $destdir/$name"
+	$run eval "$install_prog $instname $destdir/$name" || exit $?
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
+	  ;;
+	*.$objext)
+	  staticdest="$destfile"
+	  destfile=
+	  ;;
+	*)
+	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	if test -n "$destfile"; then
+	  $show "$install_prog $file $destfile"
+	  $run eval "$install_prog $file $destfile" || exit $?
+	fi
+
+	# Install the old object if enabled.
+	if test "$build_old_libs" = yes; then
+	  # Deduce the name of the old-style object file.
+	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
+
+	  $show "$install_prog $staticobj $staticdest"
+	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=""
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      file=`$echo $file|${SED} 's,.exe$,,'`
+	      stripped_ext=".exe"
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin*|*mingw*)
+	    wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  # Check the variables that should have been set.
+	  if test -z "$notinst_deplibs"; then
+	    $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  finalize=yes
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      # If there is no directory component, then add one.
+	      case $lib in
+	      */* | *\\*) . $lib ;;
+	      *) . ./$lib ;;
+	      esac
+	    fi
+	    libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
+	      finalize=no
+	    fi
+	  done
+
+	  relink_command=
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  outputname=
+	  if test "$fast_install" = no && test -n "$relink_command"; then
+	    if test "$finalize" = yes && test -z "$run"; then
+	      tmpdir=`func_mktempdir`
+	      file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
+	      outputname="$tmpdir/$file"
+	      # Replace the output file specification.
+	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+
+	      $show "$relink_command"
+	      if $run eval "$relink_command"; then :
+	      else
+		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+		${rm}r "$tmpdir"
+		continue
+	      fi
+	      file="$outputname"
+	    else
+	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
+	    fi
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway 
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
+	    ;;
+	  esac
+	  ;;
+	esac
+	$show "$install_prog$stripme $file $destfile"
+	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
+	test -n "$outputname" && ${rm}r "$tmpdir"
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+
+      # Set up the ranlib parameters.
+      oldlib="$destdir/$name"
+
+      $show "$install_prog $file $oldlib"
+      $run eval "$install_prog \$file \$oldlib" || exit $?
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	$show "$old_striplib $oldlib"
+	$run eval "$old_striplib $oldlib" || exit $?
+      fi
+
+      # Do each command in the postinstall commands.
+      cmds=$old_postinstall_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$future_libdirs"; then
+      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
+    fi
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      test -n "$run" && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool finish mode
+  finish)
+    modename="$modename: finish"
+    libdirs="$nonopt"
+    admincmds=
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for dir
+      do
+	libdirs="$libdirs $dir"
+      done
+
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  cmds=$finish_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || admincmds="$admincmds
+       $cmd"
+	  done
+	  IFS="$save_ifs"
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $run eval "$cmds" || admincmds="$admincmds
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    test "$show" = : && exit $EXIT_SUCCESS
+
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    $echo "Libraries have been installed in:"
+    for libdir in $libdirs; do
+      $echo "   $libdir"
+    done
+    $echo
+    $echo "If you ever happen to want to link against installed libraries"
+    $echo "in a given directory, LIBDIR, you must either use libtool, and"
+    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+    $echo "flag during linking and do at least one of the following:"
+    if test -n "$shlibpath_var"; then
+      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+      $echo "     during execution"
+    fi
+    if test -n "$runpath_var"; then
+      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+      $echo "     during linking"
+    fi
+    if test -n "$hardcode_libdir_flag_spec"; then
+      libdir=LIBDIR
+      eval flag=\"$hardcode_libdir_flag_spec\"
+
+      $echo "   - use the \`$flag' linker flag"
+    fi
+    if test -n "$admincmds"; then
+      $echo "   - have your system administrator run these commands:$admincmds"
+    fi
+    if test -f /etc/ld.so.conf; then
+      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+    fi
+    $echo
+    $echo "See any operating system documentation about shared libraries for"
+    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool execute mode
+  execute)
+    modename="$modename: execute"
+
+    # The first argument is the command name.
+    cmd="$nonopt"
+    if test -z "$cmd"; then
+      $echo "$modename: you must specify a COMMAND" 1>&2
+      $echo "$help"
+      exit $EXIT_FAILURE
+    fi
+
+    # Handle -dlopen flags immediately.
+    for file in $execute_dlfiles; do
+      if test ! -f "$file"; then
+	$echo "$modename: \`$file' is not a file" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+
+      dir=
+      case $file in
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
+	  continue
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  dir="$dir/$objdir"
+	else
+	  $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+	;;
+
+      *)
+	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir="$absdir"
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic="$magic"
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -*) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  # If there is no directory component, then add one.
+	  case $file in
+	  */* | *\\*) . $file ;;
+	  *) . ./$file ;;
+	  esac
+
+	  # Transform arg to wrapped name.
+	  file="$progdir/$program"
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
+      args="$args \"$file\""
+    done
+
+    if test -z "$run"; then
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      if test "${save_LC_ALL+set}" = set; then
+	LC_ALL="$save_LC_ALL"; export LC_ALL
+      fi
+      if test "${save_LANG+set}" = set; then
+	LANG="$save_LANG"; export LANG
+      fi
+
+      # Now prepare to actually exec the command.
+      exec_cmd="\$cmd$args"
+    else
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
+	$echo "export $shlibpath_var"
+      fi
+      $echo "$cmd$args"
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool clean and uninstall mode
+  clean | uninstall)
+    modename="$modename: $mode"
+    rm="$nonopt"
+    files=
+    rmforce=
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    for arg
+    do
+      case $arg in
+      -f) rm="$rm $arg"; rmforce=yes ;;
+      -*) rm="$rm $arg" ;;
+      *) files="$files $arg" ;;
+      esac
+    done
+
+    if test -z "$rm"; then
+      $echo "$modename: you must specify an RM program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    rmdirs=
+
+    origobjdir="$objdir"
+    for file in $files; do
+      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+      if test "X$dir" = "X$file"; then
+	dir=.
+	objdir="$origobjdir"
+      else
+	objdir="$dir/$origobjdir"
+      fi
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+      test "$mode" = uninstall && objdir="$dir"
+
+      # Remember objdir for removal later, being careful to avoid duplicates
+      if test "$mode" = clean; then
+	case " $rmdirs " in
+	  *" $objdir "*) ;;
+	  *) rmdirs="$rmdirs $objdir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if (test -L "$file") >/dev/null 2>&1 \
+	|| (test -h "$file") >/dev/null 2>&1 \
+	|| test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif test "$rmforce" = yes; then
+	continue
+      fi
+
+      rmfiles="$file"
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  . $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    rmfiles="$rmfiles $objdir/$n"
+	  done
+	  test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
+
+	  case "$mode" in
+	  clean)
+	    case "  $library_names " in
+	    # "  " in the beginning catches empty $dlname
+	    *" $dlname "*) ;;
+	    *) rmfiles="$rmfiles $objdir/$dlname" ;;
+	    esac
+	     test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      cmds=$postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      cmds=$old_postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+
+	  # Read the .lo file
+	  . $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" \
+	     && test "$pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" \
+	     && test "$non_pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test "$mode" = clean ; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    file=`$echo $file|${SED} 's,.exe$,,'`
+	    noexename=`$echo $name|${SED} 's,.exe$,,'`
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    rmfiles="$rmfiles $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	    relink_command=
+	    . $dir/$noexename
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
+	    if test "$fast_install" = yes && test -n "$relink_command"; then
+	      rmfiles="$rmfiles $objdir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name" ; then
+	      rmfiles="$rmfiles $objdir/lt-${noexename}.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      $show "$rm $rmfiles"
+      $run $rm $rmfiles || exit_status=1
+    done
+    objdir="$origobjdir"
+
+    # Try to remove the ${objdir}s in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	$show "rmdir $dir"
+	$run rmdir $dir >/dev/null 2>&1
+      fi
+    done
+
+    exit $exit_status
+    ;;
+
+  "")
+    $echo "$modename: you must specify a MODE" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+  esac
+
+  if test -z "$exec_cmd"; then
+    $echo "$modename: invalid operation mode \`$mode'" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi # test -z "$show_help"
+
+if test -n "$exec_cmd"; then
+  eval exec $exec_cmd
+  exit $EXIT_FAILURE
+fi
+
+# We need to display help for each of the modes.
+case $mode in
+"") $echo \
+"Usage: $modename [OPTION]... [MODE-ARG]...
+
+Provide generalized library-building support services.
+
+    --config          show all configuration variables
+    --debug           enable verbose shell tracing
+-n, --dry-run         display commands without modifying any files
+    --features        display basic configuration information and exit
+    --finish          same as \`--mode=finish'
+    --help            display this help message and exit
+    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
+    --quiet           same as \`--silent'
+    --silent          don't print informational messages
+    --tag=TAG         use configuration variables from tag TAG
+    --version         print version information
+
+MODE must be one of the following:
+
+      clean           remove files from the build directory
+      compile         compile a source file into a libtool object
+      execute         automatically set library path, then run a program
+      finish          complete the installation of libtool libraries
+      install         install libraries or executables
+      link            create a library or an executable
+      uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
+a more detailed description of MODE.
+
+Report bugs to <bug-libtool@gnu.org>."
+  exit $EXIT_SUCCESS
+  ;;
+
+clean)
+  $echo \
+"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+compile)
+  $echo \
+"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -prefer-pic       try to building PIC objects only
+  -prefer-non-pic   try to building non-PIC objects only
+  -static           always build a \`.o' file suitable for static linking
+
+COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix \`.c' with the
+library object suffix, \`.lo'."
+  ;;
+
+execute)
+  $echo \
+"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to \`-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+  ;;
+
+finish)
+  $echo \
+"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the \`--dry-run' option if you just want to see what would be executed."
+  ;;
+
+install)
+  $echo \
+"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the \`install' or \`cp' program.
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+  ;;
+
+link)
+  $echo \
+"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+		    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+		    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  Use a list of object files found in FILE to specify objects
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -static           do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+		    specify library version info [each variable defaults to 0]
+
+All other options (arguments beginning with \`-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in \`.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
+only library objects (\`.lo' files) may be specified, and \`-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
+using \`ar' and \`ranlib', or on Windows using \`lib'.
+
+If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+is created, otherwise an executable program is created."
+  ;;
+
+uninstall)
+  $echo \
+"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+*)
+  $echo "$modename: invalid operation mode \`$mode'" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+  ;;
+esac
+
+$echo
+$echo "Try \`$modename --help' for more information about other modes."
+
+exit $?
+
+# The TAGs below are defined such that we never get into a situation
+# in which we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+disable_libs=shared
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+disable_libs=static
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
+# ### BEGIN LIBTOOL TAG CONFIG: CXX
+
+# Libtool was configured on host SCHREIBTISCH_GP:
+
+# Shell to use when invoking shell scripts.
+SHELL="/dev/env/DJDIR/bin/sh.exe"
+
+# Whether or not to build shared libraries.
+build_libtool_libs=no
+
+# Whether or not to build static libraries.
+build_old_libs=yes
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=no
+
+# Whether or not to disallow shared libs when runtime libs are static
+allow_libtool_libs_with_static_runtimes=no
+
+# Whether or not to optimize for fast installation.
+fast_install=needless
+
+# The host system.
+host_alias=
+host=i386-pc-msdosdjgpp
+host_os=msdosdjgpp
+
+# The build system.
+build_alias=
+build=i386-pc-msdosdjgpp
+build_os=msdosdjgpp
+
+# An echo program that does not interpret backslashes.
+echo="echo"
+
+# The archiver.
+AR="ar"
+AR_FLAGS="cru"
+
+# A C compiler.
+LTCC="gcc"
+
+# LTCC compiler flags.
+LTCFLAGS="-g -O2"
+
+# A language-specific compiler.
+CC="gpp"
+
+# Is the compiler the GNU C compiler?
+with_gcc=yes
+
+# An ERE matcher.
+EGREP="grep -E"
+
+# The linker used to build libraries.
+LD="e:/djgpp/bin/ld.exe"
+
+# Whether we need hard or soft links.
+LN_S="ln"
+
+# A BSD-compatible nm program.
+NM="/dev/e/djgpp/bin/nm -B"
+
+# A symbol stripping program
+STRIP="strip"
+
+# Used to examine libraries when file_magic_cmd begins "file"
+MAGIC_CMD=file
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="dlltool"
+
+# Used on cygwin: object dumper.
+OBJDUMP="objdump"
+
+# Used on cygwin: assembler.
+AS="as"
+
+# The name of the directory that contains temporary libtool files.
+objdir=.libs
+
+# How to create reloadable object files.
+reload_flag=" -r"
+reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
+
+# How to pass a linker flag through the compiler.
+wl="-Wl,"
+
+# Object file suffix (normally "o").
+objext="o"
+
+# Old archive suffix (normally "a").
+libext="a"
+
+# Shared library suffix (normally ".so").
+shrext_cmds='.so'
+
+# Executable file suffix (normally "").
+exeext=""
+
+# Additional compiler flags for building library objects.
+pic_flag=""
+pic_mode=default
+
+# What is the maximum length of a command?
+max_cmd_len=12288
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o="yes"
+
+# Must we lock files when doing compilation?
+need_locks="no"
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=unknown
+
+# Do we need a version for libraries?
+need_version=unknown
+
+# Whether dlopen is supported.
+dlopen_support=unknown
+
+# Whether dlopen of programs is supported.
+dlopen_self=unknown
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=unknown
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag="-static"
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=" -fno-builtin"
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec="\${wl}--export-dynamic"
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=""
+
+# Library versioning type.
+version_type=none
+
+# Format of library name prefix.
+libname_spec="lib\$name"
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=""
+
+# The coded name of the library, if different from the real name.
+soname_spec=""
+
+# Commands used to build and install an old-style archive.
+RANLIB="ranlib"
+old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib"
+old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
+old_postuninstall_cmds=""
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=""
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=""
+
+# Commands used to build and install a shared archive.
+archive_cmds="\$CC -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
+archive_expsym_cmds="\$CC -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-retain-symbols-file \$wl\$export_symbols -o \$lib"
+postinstall_cmds=""
+postuninstall_cmds=""
+
+# Commands used to build a loadable module (assumed same as above if empty)
+module_cmds=""
+module_expsym_cmds=""
+
+# Commands to strip libraries.
+old_striplib="strip --strip-debug"
+striplib="strip --strip-unneeded"
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predep_objects="e:/djgpp/lib/crt0.o"
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdep_objects=""
+
+# Dependencies to place before the objects being linked to create a
+# shared library.
+predeps=""
+
+# Dependencies to place after the objects being linked to create a
+# shared library.
+postdeps="-lstdcxx -lm -lgcc -lc -lgcc"
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path="-Le:/djgpp/bin/../lib/gcc/djgpp/4.53 -Le:/djgpp/bin/../lib/gcc -Le:/djgpp/net/watt/lib -Le:/djgpp/lib -Le:/djgpp/bin/../lib/gcc/djgpp/4.53/../../.."
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method="unknown"
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd="\$MAGIC_CMD"
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=""
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=""
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=""
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=""
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe="sed -n -e 's/^.*[ 	]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ 	][ 	]*_\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 _\\2 \\2/p'"
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'"
+
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (lt_ptr) \\&\\2},/p'"
+
+# This is the shared library runtime path variable.
+runpath_var=
+
+# This is the shared library path variable.
+shlibpath_var=
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=unknown
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=immediate
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=no
+
+# Flag to hardcode $libdir into a binary during linking.
+# This must work even if $libdir does not exist.
+hardcode_libdir_flag_spec="\${wl}--rpath \${wl}\$libdir"
+
+# If ld is used when linking, flag to hardcode $libdir into
+# a binary during linking. This must work even if $libdir does
+# not exist.
+hardcode_libdir_flag_spec_ld=""
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=""
+
+# Set to yes if using DIR/libNAME during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=no
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=no
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=unsupported
+
+# Set to yes if building a shared library automatically hardcodes DIR into the library
+# and all subsequent libraries and executables linked against it.
+hardcode_automatic=no
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at relink time.
+variables_saved_for_relink="PATH   GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=unknown
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=" =e:/djgpp/bin/../lib/gcc/djgpp/4.53/ e:/djgpp/bin/../lib/gcc/ e:/djgpp/net/watt/lib /djgpp/4.53/ e:/djgpp/net/watt/lib / e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../../djgpp/lib/djgpp/4.53/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../../djgpp/lib/ e:/djgpp/lib/djgpp/4.53/ e:/djgpp/lib/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../djgpp/4.53/ e:/djgpp/bin/../lib/gcc/djgpp/4.53/../../../"
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+
+# Fix the shell variable $srcfile for the compiler.
+fix_srcfile_path=""
+
+# Set to yes if exported symbols are required.
+always_export_symbols=no
+
+# The commands to list exported symbols.
+export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=""
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=""
+
+# Symbols that must always be exported.
+include_expsyms=""
+
+# ### END LIBTOOL TAG CONFIG: CXX
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/ltmain.sh b/client/src/thirdparty/sqlite-3.4.2/ltmain.sh
new file mode 100644
index 0000000..8f7a6ac
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/ltmain.sh
@@ -0,0 +1,6971 @@
+# ltmain.sh - Provide generalized library-building support services.
+# NOTE: Changing this file will not affect anything until you rerun configure.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+basename="s,^.*/,,g"
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
+
+# define SED for historic ltconfig's generated by Libtool 1.3
+test -z "$SED" && SED=sed
+
+# The name of this program:
+progname=`echo "$progpath" | $SED $basename`
+modename="$progname"
+
+# Global variables:
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+
+PROGRAM=ltmain.sh
+PACKAGE=libtool
+VERSION=1.5.22
+TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
+
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes.
+if test -n "${ZSH_VERSION+set}" ; then
+  setopt NO_GLOB_SUBST
+fi
+# Same for EGREP, and just to be sure, do LTCC as well
+if test "X$EGREP" = X ; then
+    EGREP=egrep
+fi
+if test "X$LTCC" = X ; then
+    LTCC=${CC-gcc}
+fi
+
+# Check that we have a working $echo.
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell, and then maybe $echo will work.
+  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit $EXIT_SUCCESS
+fi
+
+default_mode=
+help="Try \`$progname --help' for more information."
+magic="%%%MAGIC variable%%%"
+mkdir="mkdir"
+mv="mv -f"
+rm="rm -f"
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed="${SED}"' -e 1s/^X//'
+sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  SP2NL='tr \040 \012'
+  NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  SP2NL='tr \100 \n'
+  NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+# NLS nuisances.
+# Only set LANG and LC_ALL to C if already set.
+# These must not be set unconditionally because not all systems understand
+# e.g. LANG=C (notably SCO).
+# We save the old values to restore during execute mode.
+if test "${LC_ALL+set}" = set; then
+  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
+fi
+if test "${LANG+set}" = set; then
+  save_LANG="$LANG"; LANG=C; export LANG
+fi
+
+# Make sure IFS has a sensible default
+lt_nl='
+'
+IFS=" 	$lt_nl"
+
+if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+  $echo "$modename: not configured to build any kind of library" 1>&2
+  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+  exit $EXIT_FAILURE
+fi
+
+# Global variables.
+mode=$default_mode
+nonopt=
+prev=
+prevopt=
+run=
+show="$echo"
+show_help=
+execute_dlfiles=
+duplicate_deps=no
+preserve_args=
+lo2o="s/\\.lo\$/.${objext}/"
+o2lo="s/\\.${objext}\$/.lo/"
+
+if test -z "$max_cmd_len"; then
+  i=0
+  testring="ABCD"
+  new_result=
+  
+  # If test is not a shell built-in, we'll probably end up computing a
+  # maximum length that is only half of the actual maximum length, but
+  # we can't tell.
+  while (test "X"`$SHELL $0 --fallback-echo "X$testring" 2>/dev/null` \
+             = "XX$testring") >/dev/null 2>&1 &&
+          new_result=`expr "X$testring" : ".*" 2>&1` &&
+          max_cmd_len="$new_result" &&
+          test "$i" != 17 # 1/2 MB should be enough
+  do
+    i=`expr $i + 1`
+    testring="$testring$testring"
+  done
+  testring=
+  # Add a significant safety factor because C++ compilers can tack on massive
+  # amounts of additional arguments before passing them to the linker.
+  # It appears as though 1/2 is a usable value.
+  max_cmd_len=`expr $max_cmd_len \/ 2`
+fi
+
+#####################################
+# Shell function definitions:
+# This seems to be the best place for them
+
+# func_mktempdir [string]
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, STRING is the basename for that directory.
+func_mktempdir ()
+{
+    my_template="${TMPDIR-/tmp}/${1-$progname}"
+
+    if test "$run" = ":"; then
+      # Return a directory name, but don't create it in dry-run mode
+      my_tmpdir="${my_template}-$$"
+    else
+
+      # If mktemp works, use that first and foremost
+      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$my_tmpdir"; then
+	# Failing that, at least try and use $RANDOM to avoid a race
+	my_tmpdir="${my_template}-${RANDOM-0}$$"
+
+	save_mktempdir_umask=`umask`
+	umask 0077
+	$mkdir "$my_tmpdir"
+	umask $save_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$my_tmpdir" || {
+        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
+	exit $EXIT_FAILURE
+      }
+    fi
+
+    $echo "X$my_tmpdir" | $Xsed
+}
+
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+func_win32_libid ()
+{
+  win32_libid_type="unknown"
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
+      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+      win32_nmres=`eval $NM -f posix -A $1 | \
+	$SED -n -e '1,100{/ I /{s,.*,import,;p;q;};}'`
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $echo $win32_libid_type
+}
+
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	case $arg in
+	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	CC_quoted="$CC_quoted $arg"
+      done
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	    # Double-quote args containing other shell metacharacters.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    CC_quoted="$CC_quoted $arg"
+	  done
+	    # user sometimes does CC=<HOST>-gcc so we need to match that to 'gcc'
+	    trimedcc=`echo ${CC} | $SED -e "s/${host}-//g"`
+	    # and sometimes libtool has CC=<HOST>-gcc but user does CC=gcc
+	    extendcc=${host}-${CC}
+	    # and sometimes libtool has CC=<OLDHOST>-gcc but user has CC=<NEWHOST>-gcc  
+	    # (Gentoo-specific hack because we always export $CHOST)
+	    mungedcc=${CHOST-${host}}-${trimedcc}
+	    case "$@ " in
+	      "cc "* | " cc "* | "${host}-cc "* | " ${host}-cc "*|\
+	      "gcc "* | " gcc "* | "${host}-gcc "* | " ${host}-gcc "*)
+	      tagname=CC
+	      break ;;
+	      "$trimedcc "* | " $trimedcc "* | "`$echo $trimedcc` "* | " `$echo $trimedcc` "*|\
+	      "$extendcc "* | " $extendcc "* | "`$echo $extendcc` "* | " `$echo $extendcc` "*|\
+	      "$mungedcc "* | " $mungedcc "* | "`$echo $mungedcc` "* | " `$echo $mungedcc` "*|\
+	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  $echo "$modename: unable to infer tagged configuration"
+	  $echo "$modename: specify a tag with \`--tag'" 1>&2
+	  exit $EXIT_FAILURE
+#        else
+#          $echo "$modename: using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    f_ex_an_ar_dir="$1"; shift
+    f_ex_an_ar_oldlib="$1"
+
+    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
+    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
+      exit $EXIT_FAILURE
+    fi
+}
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    my_gentop="$1"; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=""
+    my_xlib=""
+    my_xabs=""
+    my_xdir=""
+    my_status=""
+
+    $show "${rm}r $my_gentop"
+    $run ${rm}r "$my_gentop"
+    $show "$mkdir $my_gentop"
+    $run $mkdir "$my_gentop"
+    my_status=$?
+    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
+      exit $my_status
+    fi
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
+      my_xdir="$my_gentop/$my_xlib"
+
+      $show "${rm}r $my_xdir"
+      $run ${rm}r "$my_xdir"
+      $show "$mkdir $my_xdir"
+      $run $mkdir "$my_xdir"
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
+	exit $exit_status
+      fi
+      case $host in
+      *-darwin*)
+	$show "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	if test -z "$run"; then
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
+	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
+	  if test -n "$darwin_arches"; then 
+	    darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    $show "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches ; do
+	      mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
+	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+	      cd "$darwin_curdir"
+	      $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+	    done # $darwin_arches
+      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
+	      lipo -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    ${rm}r unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd "$darwin_orig_dir"
+ 	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	fi # $run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+        ;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
+    done
+    func_extract_archives_result="$my_oldobjs"
+}
+# End of Shell function definitions
+#####################################
+
+# Darwin sucks
+eval std_shrext=\"$shrext_cmds\"
+
+disable_libs=no
+
+# Parse our command line options once, thoroughly.
+while test "$#" -gt 0
+do
+  arg="$1"
+  shift
+
+  case $arg in
+  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$prev"; then
+    case $prev in
+    execute_dlfiles)
+      execute_dlfiles="$execute_dlfiles $arg"
+      ;;
+    tag)
+      tagname="$arg"
+      preserve_args="${preserve_args}=$arg"
+
+      # Check whether tagname contains only valid characters
+      case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+	$echo "$progname: invalid tag name: $tagname" 1>&2
+	exit $EXIT_FAILURE
+	;;
+      esac
+
+      case $tagname in
+      CC)
+	# Don't test for the "default" C tag, as we know, it's there, but
+	# not specially marked.
+	;;
+      *)
+	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
+	  taglist="$taglist $tagname"
+	  # Evaluate the configuration.
+	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
+	else
+	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
+	fi
+	;;
+      esac
+      ;;
+    *)
+      eval "$prev=\$arg"
+      ;;
+    esac
+
+    prev=
+    prevopt=
+    continue
+  fi
+
+  # Have we seen a non-optional argument yet?
+  case $arg in
+  --help)
+    show_help=yes
+    ;;
+
+  --version)
+    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
+    $echo
+    $echo "Copyright (C) 2005  Free Software Foundation, Inc."
+    $echo "This is free software; see the source for copying conditions.  There is NO"
+    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+    exit $?
+    ;;
+
+  --config)
+    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
+    done
+    exit $?
+    ;;
+
+  --debug)
+    $echo "$progname: enabling shell trace mode"
+    set -x
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --dry-run | -n)
+    run=:
+    ;;
+
+  --features)
+    $echo "host: $host"
+    if test "$build_libtool_libs" = yes; then
+      $echo "enable shared libraries"
+    else
+      $echo "disable shared libraries"
+    fi
+    if test "$build_old_libs" = yes; then
+      $echo "enable static libraries"
+    else
+      $echo "disable static libraries"
+    fi
+    exit $?
+    ;;
+
+  --finish) mode="finish" ;;
+
+  --mode) prevopt="--mode" prev=mode ;;
+  --mode=*) mode="$optarg" ;;
+
+  --preserve-dup-deps) duplicate_deps="yes" ;;
+
+  --quiet | --silent)
+    show=:
+    preserve_args="$preserve_args $arg"
+    ;;
+
+  --tag)
+    prevopt="--tag"
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+  --tag=*)
+    set tag "$optarg" ${1+"$@"}
+    shift
+    prev=tag
+    preserve_args="$preserve_args --tag"
+    ;;
+
+  -dlopen)
+    prevopt="-dlopen"
+    prev=execute_dlfiles
+    ;;
+
+  -*)
+    $echo "$modename: unrecognized option \`$arg'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+
+  *)
+    nonopt="$arg"
+    break
+    ;;
+  esac
+done
+
+if test -n "$prevopt"; then
+  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+fi
+
+case $disable_libs in
+no) 
+  ;;
+shared)
+  build_libtool_libs=no
+  build_old_libs=yes
+  ;;
+static)
+  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+  ;;
+esac
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+if test -z "$show_help"; then
+
+  # Infer the operation mode.
+  if test -z "$mode"; then
+    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
+    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
+    case $nonopt in
+    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
+      mode=link
+      for arg
+      do
+	case $arg in
+	-c)
+	   mode=compile
+	   break
+	   ;;
+	esac
+      done
+      ;;
+    *db | *dbx | *strace | *truss)
+      mode=execute
+      ;;
+    *install*|cp|mv)
+      mode=install
+      ;;
+    *rm)
+      mode=uninstall
+      ;;
+    *)
+      # If we have no mode, but dlfiles were specified, then do execute mode.
+      test -n "$execute_dlfiles" && mode=execute
+
+      # Just use the default operation mode.
+      if test -z "$mode"; then
+	if test -n "$nonopt"; then
+	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
+	else
+	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
+	fi
+      fi
+      ;;
+    esac
+  fi
+
+  # Only execute mode is allowed to have -dlopen flags.
+  if test -n "$execute_dlfiles" && test "$mode" != execute; then
+    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
+    $echo "$help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+
+  # Change the help message to a mode-specific one.
+  generic_help="$help"
+  help="Try \`$modename --help --mode=$mode' for more information."
+
+  # These modes are in order of execution frequency so that they run quickly.
+  case $mode in
+  # libtool compile mode
+  compile)
+    modename="$modename: compile"
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg="$arg"
+	arg_mode=normal
+	;;
+
+      target )
+	libobj="$arg"
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  if test -n "$libobj" ; then
+	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-static | -prefer-pic | -prefer-non-pic)
+	  later="$later $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
+	  lastarg=
+	  save_ifs="$IFS"; IFS=','
+ 	  for arg in $args; do
+	    IFS="$save_ifs"
+
+	    # Double-quote args containing other shell metacharacters.
+	    # Many Bourne shells cannot handle close brackets correctly
+	    # in scan sets, so we specify it separately.
+	    case $arg in
+	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	      arg="\"$arg\""
+	      ;;
+	    esac
+	    lastarg="$lastarg $arg"
+	  done
+	  IFS="$save_ifs"
+	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
+
+	  # Add the arguments to base_compile.
+	  base_compile="$base_compile $lastarg"
+	  continue
+	  ;;
+
+	* )
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg="$srcfile"
+	  srcfile="$arg"
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
+
+      case $lastarg in
+      # Double-quote args containing other shell metacharacters.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, and some SunOS ksh mistreat backslash-escaping
+      # in scan sets (worked around with variable expansion),
+      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
+      # at all, so we specify them separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	lastarg="\"$lastarg\""
+	;;
+      esac
+
+      base_compile="$base_compile $lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      $echo "$modename: you must specify an argument for -Xcompile"
+      exit $EXIT_FAILURE
+      ;;
+    target)
+      $echo "$modename: you must specify a target with \`-o'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *)
+      # Get the name of the library object.
+      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    xform='[cCFSifmso]'
+    case $libobj in
+    *.ada) xform=ada ;;
+    *.adb) xform=adb ;;
+    *.ads) xform=ads ;;
+    *.asm) xform=asm ;;
+    *.c++) xform=c++ ;;
+    *.cc) xform=cc ;;
+    *.ii) xform=ii ;;
+    *.class) xform=class ;;
+    *.cpp) xform=cpp ;;
+    *.cxx) xform=cxx ;;
+    *.f90) xform=f90 ;;
+    *.for) xform=for ;;
+    *.java) xform=java ;;
+    esac
+
+    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
+
+    case $libobj in
+    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
+    *)
+      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -static)
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
+    case $qlibobj in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qlibobj="\"$qlibobj\"" ;;
+    esac
+    test "X$libobj" != "X$qlibobj" \
+	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' 	&()|`$[]' \
+	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
+    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$xdir" = "X$obj"; then
+      xdir=
+    else
+      xdir=$xdir/
+    fi
+    lobj=${xdir}$objdir/$objname
+
+    if test -z "$base_compile"; then
+      $echo "$modename: you must specify a compilation command" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Delete any leftover library objects.
+    if test "$build_old_libs" = yes; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    $run $rm $removelist
+    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2*)
+      pic_mode=default
+      ;;
+    esac
+    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test "$compiler_c_o" = no; then
+      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
+      lockfile="$output_obj.lock"
+      removelist="$removelist $output_obj $lockfile"
+      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test "$need_locks" = yes; then
+      until $run ln "$srcfile" "$lockfile" 2>/dev/null; do
+	$show "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test "$need_locks" = warn; then
+      if test -f "$lockfile"; then
+	$echo "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+      $echo "$srcfile" > "$lockfile"
+    fi
+
+    if test -n "$fix_srcfile_path"; then
+      eval srcfile=\"$fix_srcfile_path\"
+    fi
+    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
+    case $qsrcfile in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      qsrcfile="\"$qsrcfile\"" ;;
+    esac
+
+    $run $rm "$libobj" "${libobj}T"
+
+    # Create a libtool object file (analogous to a ".la" file),
+    # but don't create it if we're doing a dry run.
+    test -z "$run" && cat > ${libobj}T <<EOF
+# $libobj - a libtool object file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+EOF
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test "$build_libtool_libs" = yes; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test "$pic_mode" != no; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      if test ! -d "${xdir}$objdir"; then
+	$show "$mkdir ${xdir}$objdir"
+	$run $mkdir ${xdir}$objdir
+	exit_status=$?
+	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
+	  exit $exit_status
+	fi
+      fi
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	command="$command -o $lobj"
+      fi
+
+      $run $rm "$lobj" "$output_obj"
+
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	test -n "$output_obj" && $run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	$show "$mv $output_obj $lobj"
+	if $run $mv $output_obj $lobj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the PIC object to the libtool object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object='$objdir/$objname'
+
+EOF
+
+      # Allow error messages only from the first compilation.
+      if test "$suppress_opt" = yes; then
+        suppress_output=' >/dev/null 2>&1'
+      fi
+    else
+      # No PIC object so indicate it doesn't exist in the libtool
+      # object file.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+pic_object=none
+
+EOF
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test "$build_old_libs" = yes; then
+      if test "$pic_mode" != yes; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test "$compiler_c_o" = yes; then
+	command="$command -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      command="$command$suppress_output"
+      $run $rm "$obj" "$output_obj"
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      if test "$need_locks" = warn &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	$show "$mv $output_obj $obj"
+	if $run $mv $output_obj $obj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object='$objname'
+
+EOF
+    else
+      # Append the name of the non-PIC object the libtool object file.
+      # Only append if the libtool object file exists.
+      test -z "$run" && cat >> ${libobj}T <<EOF
+# Name of the non-PIC object.
+non_pic_object=none
+
+EOF
+    fi
+
+    $run $mv "${libobj}T" "${libobj}"
+
+    # Unlock the critical section if it was locked
+    if test "$need_locks" != no; then
+      $run $rm "$lockfile"
+    fi
+
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool link mode
+  link | relink)
+    modename="$modename: link"
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # which system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll which has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args="$nonopt"
+    base_compile="$nonopt $@"
+    compile_command="$nonopt"
+    finalize_command="$nonopt"
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+
+    avoid_version=no
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    non_pic_objects=
+    notinst_path= # paths that contain not-installed libtool libraries
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=no
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -all-static | -static)
+	if test "X$arg" = "X-all-static"; then
+	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	else
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	fi
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg="$1"
+      shift
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
+	;;
+      *) qarg=$arg ;;
+      esac
+      libtool_args="$libtool_args $qarg"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  compile_command="$compile_command @OUTPUT@"
+	  finalize_command="$finalize_command @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	dlfiles|dlprefiles)
+	  if test "$preload" = no; then
+	    # Add the symbol object into the linking commands.
+	    compile_command="$compile_command @SYMFILE@"
+	    finalize_command="$finalize_command @SYMFILE@"
+	    preload=yes
+	  fi
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test "$dlself" = no; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test "$prev" = dlprefiles; then
+	      dlself=yes
+	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test "$prev" = dlfiles; then
+	      dlfiles="$dlfiles $arg"
+	    else
+	      dlprefiles="$dlprefiles $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols="$arg"
+	  if test ! -f "$arg"; then
+	    $echo "$modename: symbol file \`$arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir="$arg"
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release="-$arg"
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat $save_arg`
+	    do
+#	      moreargs="$moreargs $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		# If there is no directory component, then add one.
+		case $arg in
+		*/* | *\\*) . $arg ;;
+		*) . ./$arg ;;
+		esac
+
+		if test -z "$pic_object" || \
+		   test -z "$non_pic_object" ||
+		   test "$pic_object" = none && \
+		   test "$non_pic_object" = none; then
+		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+
+		# Extract subdirectory from the argument.
+		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		if test "X$xdir" = "X$arg"; then
+		  xdir=
+		else
+		  xdir="$xdir/"
+		fi
+
+		if test "$pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object="$xdir$pic_object"
+
+		  if test "$prev" = dlfiles; then
+		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		      dlfiles="$dlfiles $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test "$prev" = dlprefiles; then
+		    # Preload the old-style object.
+		    dlprefiles="$dlprefiles $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  libobjs="$libobjs $pic_object"
+		  arg="$pic_object"
+		fi
+
+		# Non-PIC object.
+		if test "$non_pic_object" != none; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object="$xdir$non_pic_object"
+
+		  # A standard non-PIC object
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		  if test -z "$pic_object" || test "$pic_object" = none ; then
+		    arg="$non_pic_object"
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object="$pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if test -z "$run"; then
+		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+		  exit $EXIT_FAILURE
+		else
+		  # Dry-run case.
+
+		  # Extract subdirectory from the argument.
+		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+		  if test "X$xdir" = "X$arg"; then
+		    xdir=
+		  else
+		    xdir="$xdir/"
+		  fi
+
+		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+		  libobjs="$libobjs $pic_object"
+		  non_pic_objects="$non_pic_objects $non_pic_object"
+		fi
+	      fi
+	    done
+	  else
+	    $echo "$modename: link input file \`$save_arg' does not exist"
+	    exit $EXIT_FAILURE
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    $echo "$modename: only absolute run-paths are allowed" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	  if test "$prev" = rpath; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) rpath="$rpath $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) xrpath="$xrpath $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	xcompiler)
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $wl$qarg"
+	  prev=
+	  compile_command="$compile_command $wl$qarg"
+	  finalize_command="$finalize_command $wl$qarg"
+	  continue
+	  ;;
+	xcclinker)
+	  linker_flags="$linker_flags $qarg"
+	  compiler_flags="$compiler_flags $qarg"
+	  prev=
+	  compile_command="$compile_command $qarg"
+	  finalize_command="$finalize_command $qarg"
+	  continue
+	  ;;
+	shrext)
+  	  shrext_cmds="$arg"
+	  prev=
+	  continue
+	  ;;
+	darwin_framework|darwin_framework_skip)
+	  test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  prev=
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg="$arg"
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  compile_command="$compile_command $link_static_flag"
+	  finalize_command="$finalize_command $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
+	continue
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  $echo "$modename: more than one -exported-symbols argument is not allowed"
+	  exit $EXIT_FAILURE
+	fi
+	if test "X$arg" = "X-export-symbols"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework|-arch|-isysroot)
+	case " $CC " in
+	  *" ${arg} ${1} "* | *" ${arg}	${1} "*) 
+		prev=darwin_framework_skip ;;
+	  *) compiler_flags="$compiler_flags $arg"
+	     prev=darwin_framework ;;
+	esac
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -L[A-Z][A-Z]*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  compile_command="$compile_command $arg"
+	  finalize_command="$finalize_command $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  if test -z "$absdir"; then
+	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
+	    absdir="$dir"
+	    notinst_path="$notinst_path $dir"
+	  fi
+	  dir="$absdir"
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "*) ;;
+	*)
+	  deplibs="$deplibs -L$dir"
+	  lib_search_path="$lib_search_path $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C and math libraries are in the System framework
+	    deplibs="$deplibs -framework System"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  esac
+	elif test "X$arg" = "X-lc_r"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	deplibs="$deplibs $arg"
+	continue
+	;;
+
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      -model)
+	compile_command="$compile_command $arg"
+	compiler_flags="$compiler_flags $arg"
+	finalize_command="$finalize_command $arg"
+	prev=xcompiler
+	continue
+	;;
+
+     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	compiler_flags="$compiler_flags $arg"
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
+      # -r[0-9][0-9]* specifies the processor on the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
+      # +DA*, +DD* enable 64-bit mode on the HP compiler
+      # -q* pass through compiler args for the IBM compiler
+      # -m* pass through architecture-specific compiler args for GCC
+      # -m*, -t[45]*, -txscale* pass through architecture-specific
+      # compiler args for GCC
+      # -pg pass through profiling flag for GCC
+      # @file GCC response files
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*|-pg| \
+      -t[45]*|-txscale*|@*)
+
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+        compile_command="$compile_command $arg"
+        finalize_command="$finalize_command $arg"
+        compiler_flags="$compiler_flags $arg"
+        continue
+        ;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # in order for the loader to find any dlls it needs.
+	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
+	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  $echo "$modename: only absolute run-paths are allowed" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) xrpath="$xrpath $dir" ;;
+	esac
+	continue
+	;;
+
+      -static)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -Wc,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Wl,*)
+	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
+	arg=
+	save_ifs="$IFS"; IFS=','
+	for flag in $args; do
+	  IFS="$save_ifs"
+	  case $flag in
+	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	    flag="\"$flag\""
+	    ;;
+	  esac
+	  arg="$arg $wl$flag"
+	  compiler_flags="$compiler_flags $wl$flag"
+	  linker_flags="$linker_flags $flag"
+	done
+	IFS="$save_ifs"
+	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+
+      *.$objext)
+	# A standard object.
+	objs="$objs $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  # If there is no directory component, then add one.
+	  case $arg in
+	  */* | *\\*) . $arg ;;
+	  *) . ./$arg ;;
+	  esac
+
+	  if test -z "$pic_object" || \
+	     test -z "$non_pic_object" ||
+	     test "$pic_object" = none && \
+	     test "$non_pic_object" = none; then
+	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	  if test "X$xdir" = "X$arg"; then
+	    xdir=
+ 	  else
+	    xdir="$xdir/"
+	  fi
+
+	  if test "$pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    pic_object="$xdir$pic_object"
+
+	    if test "$prev" = dlfiles; then
+	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+		dlfiles="$dlfiles $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test "$prev" = dlprefiles; then
+	      # Preload the old-style object.
+	      dlprefiles="$dlprefiles $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    libobjs="$libobjs $pic_object"
+	    arg="$pic_object"
+	  fi
+
+	  # Non-PIC object.
+	  if test "$non_pic_object" != none; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object="$xdir$non_pic_object"
+
+	    # A standard non-PIC object
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	    if test -z "$pic_object" || test "$pic_object" = none ; then
+	      arg="$non_pic_object"
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object="$pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if test -z "$run"; then
+	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
+	    exit $EXIT_FAILURE
+	  else
+	    # Dry-run case.
+
+	    # Extract subdirectory from the argument.
+	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	    if test "X$xdir" = "X$arg"; then
+	      xdir=
+	    else
+	      xdir="$xdir/"
+	    fi
+
+	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
+	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
+	    libobjs="$libobjs $pic_object"
+	    non_pic_objects="$non_pic_objects $non_pic_object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	deplibs="$deplibs $arg"
+	old_deplibs="$old_deplibs $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	if test "$prev" = dlfiles; then
+	  # This library was specified with -dlopen.
+	  dlfiles="$dlfiles $arg"
+	  prev=
+	elif test "$prev" = dlprefiles; then
+	  # The library was specified with -dlpreopen.
+	  dlprefiles="$dlprefiles $arg"
+	  prev=
+	else
+	  deplibs="$deplibs $arg"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case $arg in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+      fi
+    done # argument parsing loop
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      compile_command="$compile_command $arg"
+      finalize_command="$finalize_command $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
+    libobjs_save="$libobjs"
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
+    if test "X$output_objdir" = "X$output"; then
+      output_objdir="$objdir"
+    else
+      output_objdir="$output_objdir/$objdir"
+    fi
+    # Create the object directory.
+    if test ! -d "$output_objdir"; then
+      $show "$mkdir $output_objdir"
+      $run $mkdir $output_objdir
+      exit_status=$?
+      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
+	exit $exit_status
+      fi
+    fi
+
+    # Determine the type of output
+    case $output in
+    "")
+      $echo "$modename: you must specify an output file" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    case $host in
+    *cygwin* | *mingw* | *pw32*)
+      # don't eliminate duplications in $postdeps and $predeps
+      duplicate_compiler_generated_deps=yes
+      ;;
+    *)
+      duplicate_compiler_generated_deps=$duplicate_deps
+      ;;
+    esac
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if test "X$duplicate_deps" = "Xyes" ; then
+	case "$libs " in
+	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	esac
+      fi
+      libs="$libs $deplib"
+    done
+
+    if test "$linkmode" = lib; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
+	  esac
+	  pre_post_deps="$pre_post_deps $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    case $linkmode in
+    lib)
+	passes="conv link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
+	    exit $EXIT_FAILURE
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=no
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+    for pass in $passes; do
+      if test "$linkmode,$pass" = "lib,link" ||
+	 test "$linkmode,$pass" = "prog,scan"; then
+	libs="$deplibs"
+	deplibs=
+      fi
+      if test "$linkmode" = prog; then
+	case $pass in
+	dlopen) libs="$dlfiles" ;;
+	dlpreopen) libs="$dlprefiles" ;;
+	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+	esac
+      fi
+      if test "$pass" = dlopen; then
+	# Collect dlpreopened libraries
+	save_deplibs="$deplibs"
+	deplibs=
+      fi
+      for deplib in $libs; do
+	lib=
+	found=no
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
+	  if test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    compiler_flags="$compiler_flags $deplib"
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test "$linkmode" != lib && test "$linkmode" != prog; then
+	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
+	    continue
+	  fi
+	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
+	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib="$searchdir/lib${name}${search_ext}"
+	      if test -f "$lib"; then
+		if test "$search_ext" = ".la"; then
+		  found=yes
+		else
+		  found=no
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if test "$found" != yes; then
+	    # deplib doesn't seem to be a libtool library
+	    if test "$linkmode,$pass" = "prog,link"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  else # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if (${SED} -e '2q' $lib |
+                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+		  library_names=
+		  old_library=
+		  case $lib in
+		  */* | *\\*) . $lib ;;
+		  *) . ./$lib ;;
+		  esac
+		  for l in $old_library $library_names; do
+		    ll="$l"
+		  done
+		  if test "X$ll" = "X$old_library" ; then # only static version available
+		    found=no
+		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+		    test "X$ladir" = "X$lib" && ladir="."
+		    lib=$ladir/$old_library
+		    if test "$linkmode,$pass" = "prog,link"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+	        ;;
+	      *) ;;
+	      esac
+	    fi
+	  fi
+	  ;; # -l
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test "$pass" = conv && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  prog)
+	    if test "$pass" = conv; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test "$pass" = scan; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+	    ;;
+	  *)
+	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test "$pass" = link; then
+	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) xrpath="$xrpath $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la) lib="$deplib" ;;
+	*.$libext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    valid_a_lib=no
+	    case $deplibs_check_method in
+	      match_pattern*)
+		set dummy $deplibs_check_method
+	        match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+		if eval $echo \"$deplib\" 2>/dev/null \
+		    | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		  valid_a_lib=yes
+		fi
+		;;
+	      pass_all)
+		valid_a_lib=yes
+		;;
+            esac
+	    if test "$valid_a_lib" != yes; then
+	      $echo
+	      $echo "*** Warning: Trying to link with static lib archive $deplib."
+	      $echo "*** I have the capability to make that library automatically link in when"
+	      $echo "*** you link to this library.  But I can only do this if you have a"
+	      $echo "*** shared version of the library, which you do not appear to have"
+	      $echo "*** because the file extensions .$libext of this argument makes me believe"
+	      $echo "*** that it is just a static archive that I should not used here."
+	    else
+	      $echo
+	      $echo "*** Warning: Linking the shared library $output against the"
+	      $echo "*** static library $deplib is not portable!"
+	      deplibs="$deplib $deplibs"
+	    fi
+	    continue
+	    ;;
+	  prog)
+	    if test "$pass" != link; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test "$pass" = conv; then
+	    deplibs="$deplib $deplibs"
+	  elif test "$linkmode" = prog; then
+	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      newdlprefiles="$newdlprefiles $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      newdlfiles="$newdlfiles $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=yes
+	  continue
+	  ;;
+	esac # case $deplib
+	if test "$found" = yes || test -f "$lib"; then :
+	else
+	  $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$ladir" = "X$lib" && ladir="."
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	case $lib in
+	*/* | *\\*) . $lib ;;
+	*) . ./$lib ;;
+	esac
+
+	if test "$linkmode,$pass" = "lib,link" ||
+	   test "$linkmode,$pass" = "prog,scan" ||
+	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
+	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
+	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
+	fi
+
+	if test "$pass" = conv; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	      exit $EXIT_FAILURE
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    convenience="$convenience $ladir/$objdir/$old_library"
+	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+              if test "X$duplicate_deps" = "Xyes" ; then
+	        case "$tmp_libs " in
+	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	        esac
+              fi
+	      tmp_libs="$tmp_libs $deplib"
+	    done
+	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
+	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	for l in $old_library $library_names; do
+	  linklib="$l"
+	done
+	if test -z "$linklib"; then
+	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# This library was specified with -dlopen.
+	if test "$pass" = dlopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  if test -z "$dlname" ||
+	     test "$dlopen_support" != yes ||
+	     test "$build_libtool_libs" = no; then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    dlprefiles="$dlprefiles $lib $dependency_libs"
+	  else
+	    newdlfiles="$newdlfiles $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
+	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
+	    abs_ladir="$ladir"
+	  fi
+	  ;;
+	esac
+	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+
+	# Find the relevant object directory and library name.
+	if test "X$installed" = Xyes; then
+	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    libdir="$abs_ladir"
+	  else
+	    dir="$libdir"
+	    absdir="$libdir"
+	  fi
+	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir="$ladir"
+	    absdir="$abs_ladir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  else
+	    dir="$ladir/$objdir"
+	    absdir="$abs_ladir/$objdir"
+	    # Remove this search path later
+	    notinst_path="$notinst_path $abs_ladir"
+	  fi
+	fi # $installed = yes
+	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+
+	# This library was specified with -dlpreopen.
+	if test "$pass" = dlpreopen; then
+	  if test -z "$libdir"; then
+	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	  # Prefer using a static library (so that no silly _DYNAMIC symbols
+	  # are required to link).
+	  if test -n "$old_library"; then
+	    newdlprefiles="$newdlprefiles $dir/$old_library"
+	  # Otherwise, use the dlname, so that lt_dlopen finds it.
+	  elif test -n "$dlname"; then
+	    newdlprefiles="$newdlprefiles $dir/$dlname"
+	  else
+	    newdlprefiles="$newdlprefiles $dir/$linklib"
+	  fi
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test "$linkmode" = lib; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test "$linkmode,$pass" = "prog,link"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test "$linkmode" = prog && test "$pass" != link; then
+	  newlib_search_path="$newlib_search_path $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=no
+	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
+	     test "$build_libtool_libs" = no; then
+	    linkalldeplibs=yes
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
+	    esac
+	    # Need to link against all dependency_libs?
+	    if test "$linkalldeplibs" = yes; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test "$linkmode,$pass" = "prog,link"; then
+	  if test -n "$library_names" &&
+	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
+	      # Make sure the rpath contains only unique directories.
+	      case "$temp_rpath " in
+	      *" $dir "*) ;;
+	      *" $absdir "*) ;;
+	      *) temp_rpath="$temp_rpath $absdir" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if test "$alldeplibs" = yes &&
+	     { test "$deplibs_check_method" = pass_all ||
+	       { test "$build_libtool_libs" = yes &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test "$use_static_libs" = built && test "$installed" = yes ; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
+	  if test "$installed" = no; then
+	    notinst_deplibs="$notinst_deplibs $lib"
+	    need_relink=yes
+	  fi
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on
+	  # some systems (darwin)
+	  if test "$shouldnotlink" = yes && test "$pass" = link ; then
+	    $echo
+	    if test "$linkmode" = prog; then
+	      $echo "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $echo "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $echo "*** $linklib is not portable!"
+	  fi
+	  if test "$linkmode" = lib &&
+	     test "$hardcode_into_libs" = yes; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) compile_rpath="$compile_rpath $absdir"
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) finalize_rpath="$finalize_rpath $libdir"
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    realname="$2"
+	    shift; shift
+	    libname=`eval \\$echo \"$libname_spec\"`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname="$dlname"
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw*)
+		major=`expr $current - $age`
+		versuffix="-$major"
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname="$realname"
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot="$soname"
+	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
+	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      $show "extracting exported symbol list from \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$extract_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      $show "generating import library for \`$soname'"
+	      save_ifs="$IFS"; IFS='~'
+	      cmds=$old_archive_from_expsyms_cmds
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd" || exit $?
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test "$linkmode" = prog || test "$mode" != relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test "$hardcode_direct" = no; then
+		add="$dir/$linklib"
+		case $host in
+		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
+		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+		    *-*-unixware7*) add_dir="-L$dir" ;;
+		  *-*-darwin* )
+		    # if the lib is a module then we can not link against
+		    # it, someone is ignoring the new warnings I added
+		    if /usr/bin/file -L $add 2> /dev/null |
+                      $EGREP ": [^:]* bundle" >/dev/null ; then
+		      $echo "** Warning, lib $linklib is a module, not a shared library"
+		      if test -z "$old_library" ; then
+		        $echo
+		        $echo "** And there doesn't seem to be a static archive available"
+		        $echo "** The link will probably fail, sorry"
+		      else
+		        add="$dir/$old_library"
+		      fi
+		    fi
+		esac
+	      elif test "$hardcode_minus_L" = no; then
+		case $host in
+		*-*-sunos*) add_shlibpath="$dir" ;;
+		esac
+		add_dir="-L$dir"
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = no; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test "$hardcode_direct" = yes; then
+		add="$dir/$linklib"
+	      elif test "$hardcode_minus_L" = yes; then
+		add_dir="-L$dir"
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    [\\/]*)
+		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add="-l$name"
+	      elif test "$hardcode_shlibpath_var" = yes; then
+		add_shlibpath="$dir"
+		add="-l$name"
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test "$lib_linked" != yes; then
+	      $echo "$modename: configuration error: unsupported hardcode properties"
+	      exit $EXIT_FAILURE
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test "$hardcode_direct" != yes && \
+		 test "$hardcode_minus_L" != yes && \
+		 test "$hardcode_shlibpath_var" = yes; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test "$linkmode" = prog || test "$mode" = relink; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test "$hardcode_direct" = yes; then
+	      add="$libdir/$linklib"
+	    elif test "$hardcode_minus_L" = yes; then
+	      add_dir="-L$libdir"
+	      add="-l$name"
+	    elif test "$hardcode_shlibpath_var" = yes; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+	      esac
+	      add="-l$name"
+	    elif test "$hardcode_automatic" = yes; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
+	        add="$inst_prefix_dir$libdir/$linklib"
+	      else
+	        add="$libdir/$linklib"
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir="-L$libdir"
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  [\\/]*)
+		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add="-l$name"
+	    fi
+
+	    if test "$linkmode" = prog; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test "$linkmode" = prog; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test "$hardcode_direct" != unsupported; then
+	    test -n "$old_library" && linklib="$old_library"
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test "$build_libtool_libs" = yes; then
+	  # Not a shared library
+	  if test "$deplibs_check_method" != pass_all; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    $echo
+	    $echo "*** Warning: This system can not link to static lib archive $lib."
+	    $echo "*** I have the capability to make that library automatically link in when"
+	    $echo "*** you link to this library.  But I can only do this if you have a"
+	    $echo "*** shared version of the library, which you do not appear to have."
+	    if test "$module" = yes; then
+	      $echo "*** But as you try to build a module library, libtool will still create "
+	      $echo "*** a static module, that should work as long as the dlopening application"
+	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		$echo
+		$echo "*** However, this would only work if libtool was able to extract symbol"
+		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		$echo "*** not find such a program.  So, this module is probably useless."
+		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test "$build_old_libs" = no; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test "$linkmode" = lib; then
+	  if test -n "$dependency_libs" &&
+	     { test "$hardcode_into_libs" != yes ||
+	       test "$build_old_libs" = yes ||
+	       test "$link_static" = yes; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) xrpath="$xrpath $temp_xrpath";;
+		   esac;;
+	      *) temp_deplibs="$temp_deplibs $libdir";;
+	      esac
+	    done
+	    dependency_libs="$temp_deplibs"
+	  fi
+
+	  newlib_search_path="$newlib_search_path $absdir"
+	  # Link against this library
+	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    if test "X$duplicate_deps" = "Xyes" ; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+	      esac
+	    fi
+	    tmp_libs="$tmp_libs $deplib"
+	  done
+
+	  if test "$link_all_deplibs" != no; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      -L*) path="$deplib" ;;
+	      *.la)
+		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
+		test "X$dir" = "X$deplib" && dir="."
+		# We need an absolute path.
+		case $dir in
+		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
+		    absdir="$dir"
+		  fi
+		  ;;
+		esac
+		if grep "^installed=no" $deplib > /dev/null; then
+		  path="$absdir/$objdir"
+		else
+		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  if test -z "$libdir"; then
+		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		    exit $EXIT_FAILURE
+		  fi
+		  if test "$absdir" != "$libdir"; then
+		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
+		  fi
+		  path="$absdir"
+		fi
+		depdepl=
+		case $host in
+		*-*-darwin*)
+		  # we do not want to link against static libs,
+		  # but need to link against shared
+		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names" ; then
+		    for tmp in $deplibrary_names ; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$path/$depdepl" ; then
+		      depdepl="$path/$depdepl"
+		    fi
+		    # do not add paths which are already there
+		    case " $newlib_search_path " in
+		    *" $path "*) ;;
+		    *) newlib_search_path="$newlib_search_path $path";;
+		    esac
+		  fi
+		  path=""
+		  ;;
+		*)
+		  path="-L$path"
+		  ;;
+		esac
+		;;
+	      -l*)
+		case $host in
+		*-*-darwin*)
+		  # Again, we only want to link against shared libraries
+		  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
+		  for tmp in $newlib_search_path ; do
+		    if test -f "$tmp/lib$tmp_libs.dylib" ; then
+		      eval depdepl="$tmp/lib$tmp_libs.dylib"
+		      break
+		    fi
+		  done
+		  path=""
+		  ;;
+		*) continue ;;
+		esac
+		;;
+	      *) continue ;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	      case " $deplibs " in
+	      *" $depdepl "*) ;;
+	      *) deplibs="$depdepl $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      dependency_libs="$newdependency_libs"
+      if test "$pass" = dlpreopen; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test "$pass" != dlopen; then
+	if test "$pass" != conv; then
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) lib_search_path="$lib_search_path $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	fi
+
+	if test "$linkmode,$pass" != "prog,link"; then
+	  vars="deplibs"
+	else
+	  vars="compile_deplibs finalize_deplibs"
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) tmp_libs="$tmp_libs $deplib" ;;
+	      esac
+	      ;;
+	    *) tmp_libs="$tmp_libs $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs ; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=""
+	  ;;
+	esac
+	if test -n "$i" ; then
+	  tmp_libs="$tmp_libs $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test "$linkmode" = prog; then
+      dlfiles="$newdlfiles"
+      dlprefiles="$newdlprefiles"
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
+      fi
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs="$output"
+      objs="$objs$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form `libNAME.la'.
+      case $outputname in
+      lib*)
+	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	if test "$module" = no; then
+	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	if test "$need_lib_prefix" != no; then
+	  # Add the "lib" prefix for modules if required
+	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test "$deplibs_check_method" != pass_all; then
+	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
+	  exit $EXIT_FAILURE
+	else
+	  $echo
+	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
+	  $echo "*** objects $objs is not portable!"
+	  libobjs="$libobjs $objs"
+	fi
+      fi
+
+      if test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
+      fi
+
+      set dummy $rpath
+      if test "$#" -gt 2; then
+	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
+      fi
+      install_libdir="$2"
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test "$build_libtool_libs" = yes; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a `.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	if test -n "$vinfo"; then
+	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
+	fi
+
+	if test -n "$release"; then
+	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
+	fi
+      else
+
+	# Parse the version information argument.
+	save_ifs="$IFS"; IFS=':'
+	set dummy $vinfo 0 0 0
+	IFS="$save_ifs"
+
+	if test -n "$8"; then
+	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major="$2"
+	  number_minor="$3"
+	  number_revision="$4"
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # which has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  darwin|linux|osf|windows)
+	    current=`expr $number_major + $number_minor`
+	    age="$number_minor"
+	    revision="$number_revision"
+	    ;;
+	  freebsd-aout|freebsd-elf|sunos)
+	    current="$number_major"
+	    revision="$number_minor"
+	    age="0"
+	    ;;
+	  irix|nonstopux)
+	    current=`expr $number_major + $number_minor - 1`
+	    age="$number_minor"
+	    revision="$number_minor"
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current="$2"
+	  revision="$3"
+	  age="$4"
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $revision in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	case $age in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  # Darwin ld doesn't like 0 for these options...
+	  minor_current=`expr $current + 1`
+	  verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
+	  ;;
+
+	freebsd-aout)
+	  major=".$current"
+	  versuffix=".$current.$revision";
+	  ;;
+
+	freebsd-elf)
+	  major=".$current"
+	  versuffix=".$current";
+	  ;;
+
+	irix | nonstopux)
+	  major=`expr $current - $age + 1`
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring="$verstring_prefix$major.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test "$loop" -ne 0; do
+	    iface=`expr $revision - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring_prefix$major.$iface:$verstring"
+	  done
+
+	  # Before this point, $major must not contain `.'.
+	  major=.$major
+	  versuffix="$major.$revision"
+	  ;;
+
+	linux)
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  ;;
+
+	osf)
+	  major=.`expr $current - $age`
+	  versuffix=".$current.$age.$revision"
+	  verstring="$current.$age.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test "$loop" -ne 0; do
+	    iface=`expr $current - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring:${iface}.0"
+	  done
+
+	  # Make executables depend on our current version.
+	  verstring="$verstring:${current}.0"
+	  ;;
+
+	sunos)
+	  major=".$current"
+	  versuffix=".$current.$revision"
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 filesystems.
+	  major=`expr $current - $age`
+	  versuffix="-$major"
+	  ;;
+
+	*)
+	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
+	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring="0.0"
+	    ;;
+	  esac
+	  if test "$need_version" = no; then
+	    versuffix=
+	  else
+	    versuffix=".0.0"
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test "$avoid_version" = yes && test "$need_version" = no; then
+	  major=
+	  versuffix=
+	  verstring=""
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test "$allow_undefined" = yes; then
+	  if test "$allow_undefined_flag" = unsupported; then
+	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
+	    build_libtool_libs=no
+	    build_old_libs=yes
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag="$no_undefined_flag"
+	fi
+      fi
+
+      if test "$mode" != relink; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$echo "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
+	       if test "X$precious_files_regex" != "X"; then
+	         if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+	         then
+		   continue
+		 fi
+	       fi
+	       removelist="$removelist $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	if test -n "$removelist"; then
+	  $show "${rm}r $removelist"
+	  $run ${rm}r $removelist
+	fi
+      fi
+
+      # Now set the variables for building old libraries.
+      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+	oldlibs="$oldlibs $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      for path in $notinst_path; do
+	lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
+	deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
+	dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
+      done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  temp_xrpath="$temp_xrpath -R$libdir"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles="$dlfiles"
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) dlfiles="$dlfiles $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles="$dlprefiles"
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) dlprefiles="$dlprefiles $lib" ;;
+	esac
+      done
+
+      if test "$build_libtool_libs" = yes; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C library is in the System framework
+	    deplibs="$deplibs -framework System"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+ 	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test "$build_libtool_need_lc" = "yes"; then
+	      deplibs="$deplibs -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=""
+	versuffix=""
+	major=""
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $rm conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $rm conftest
+	  $LTCC $LTCFLAGS -o conftest conftest.c $deplibs
+	  if test "$?" -eq 0 ; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" -ne "0"; then
+		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    newdeplibs="$newdeplibs $i"
+		    i=""
+		    ;;
+		  esac
+	        fi
+		if test -n "$i" ; then
+		  libname=`eval \\$echo \"$libname_spec\"`
+		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		  set dummy $deplib_matches
+		  deplib_match=$2
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		    newdeplibs="$newdeplibs $i"
+		  else
+		    droppeddeps=yes
+		    $echo
+		    $echo "*** Warning: dynamic linker does not accept needed library $i."
+		    $echo "*** I have the capability to make that library automatically link in when"
+		    $echo "*** you link to this library.  But I can only do this if you have a"
+		    $echo "*** shared version of the library, which I believe you do not have"
+		    $echo "*** because a test_compile did reveal that the linker did not use it for"
+		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      name=`expr $i : '-l\(.*\)'`
+	      # If $name is empty we are operating on a -L argument.
+              if test "$name" != "" && test "$name" != "0"; then
+		$rm conftest
+		$LTCC $LTCFLAGS -o conftest conftest.c $i
+		# Did it work?
+		if test "$?" -eq 0 ; then
+		  ldd_output=`ldd conftest`
+		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      newdeplibs="$newdeplibs $i"
+		      i=""
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i" ; then
+		    libname=`eval \\$echo \"$libname_spec\"`
+		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		    set dummy $deplib_matches
+		    deplib_match=$2
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		      newdeplibs="$newdeplibs $i"
+		    else
+		      droppeddeps=yes
+		      $echo
+		      $echo "*** Warning: dynamic linker does not accept needed library $i."
+		      $echo "*** I have the capability to make that library automatically link in when"
+		      $echo "*** you link to this library.  But I can only do this if you have a"
+		      $echo "*** shared version of the library, which you do not appear to have"
+		      $echo "*** because a test_compile did reveal that the linker did not use this one"
+		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  $echo
+		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
+		  $echo "***  make it link in!  You will probably need to install it or some"
+		  $echo "*** library that it depends on before this library will be fully"
+		  $echo "*** functional.  Installing it before continuing would be even better."
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method
+	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+            if test "$name" != "" && test  "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null \
+			 | grep " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib="$potent_lib"
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
+			case $potliblink in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
+			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+			esac
+		      done
+		      # It is ok to link against an archive when
+		      # building a shared library.
+		      if $AR -t $potlib > /dev/null 2>&1; then
+		        newdeplibs="$newdeplibs $a_deplib"
+		        a_deplib=""
+		        break 2
+		      fi
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
+			 | ${SED} 10q \
+			 | $EGREP "$file_magic_regex" > /dev/null; then
+			newdeplibs="$newdeplibs $a_deplib"
+			a_deplib=""
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    name=`expr $a_deplib : '-l\(.*\)'`
+	    # If $name is empty we are operating on a -L argument.
+	    if test -n "$name" && test "$name" != "0"; then
+	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  newdeplibs="$newdeplibs $a_deplib"
+		  a_deplib=""
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib="$potent_lib" # see symlink-check above in file_magic test
+		    if eval $echo \"$potent_lib\" 2>/dev/null \
+		        | ${SED} 10q \
+		        | $EGREP "$match_pattern_regex" > /dev/null; then
+		      newdeplibs="$newdeplibs $a_deplib"
+		      a_deplib=""
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		$echo
+		$echo "*** Warning: linker path does not have real file for library $a_deplib."
+		$echo "*** I have the capability to make that library automatically link in when"
+		$echo "*** you link to this library.  But I can only do this if you have a"
+		$echo "*** shared version of the library, which you do not appear to have"
+		$echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib" ; then
+		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $echo "*** with $libname and none of the candidates passed a file format test"
+		  $echo "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=""
+	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
+	    -e 's/ -[LR][^ ]*//g'`
+	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+	    for i in $predeps $postdeps ; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
+	    done
+	  fi
+	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
+	    | grep . >/dev/null; then
+	    $echo
+	    if test "X$deplibs_check_method" = "Xnone"; then
+	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      $echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    $echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	  fi
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.[012])
+	  # On Rhapsody replace the C library is the System framework
+	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	  ;;
+	esac
+
+	if test "$droppeddeps" = yes; then
+	  if test "$module" = yes; then
+	    $echo
+	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
+	    $echo "*** a static module, that should work as long as the dlopening"
+	    $echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      $echo
+	      $echo "*** However, this would only work if libtool was able to extract symbol"
+	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      $echo "*** not find such a program.  So, this module is probably useless."
+	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test "$build_old_libs" = no; then
+	      oldlibs="$output_objdir/$libname.$libext"
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    $echo "*** The inter-library dependencies that have been dropped here will be"
+	    $echo "*** automatically added whenever a program is linked with this library"
+	    $echo "*** or is declared to -dlopen it."
+
+	    if test "$allow_undefined" = no; then
+	      $echo
+	      $echo "*** Since this library must not contain undefined symbols,"
+	      $echo "*** because either the platform does not support them or"
+	      $echo "*** it was explicitly requested with -no-undefined,"
+	      $echo "*** libtool will only create a static version of it."
+	      if test "$build_old_libs" = no; then
+		oldlibs="$output_objdir/$libname.$libext"
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      deplibs="$new_libs"
+
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test "$build_libtool_libs" = yes; then
+	if test "$hardcode_into_libs" = yes; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath="$finalize_rpath"
+	  test "$mode" != relink && rpath="$compile_rpath$rpath"
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs="$libdir"
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		dep_rpath="$dep_rpath $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) perm_rpath="$perm_rpath $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir="$hardcode_libdirs"
+	    if test -n "$hardcode_libdir_flag_spec_ld"; then
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
+	    else
+	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
+	    fi
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      rpath="$rpath$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath="$finalize_shlibpath"
+	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	realname="$2"
+	shift; shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname="$realname"
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib="$output_objdir/$realname"
+	linknames=
+	for link
+	do
+	  linknames="$linknames $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      eval cmd=\"$cmd\"
+	      if len=`expr "X$cmd" : ".*"` &&
+	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	        $show "$cmd"
+	        $run eval "$cmd" || exit $?
+	        skipped_export=false
+	      else
+	        # The command line is too long to execute in one step.
+	        $show "using reloadable object file for export list..."
+	        skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS="$save_ifs"
+	    if test -n "$export_symbols_regex"; then
+	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
+	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
+	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+		case " $convenience " in
+		*" $test_deplib "*) ;;
+		*)
+			tmp_deplibs="$tmp_deplibs $test_deplib"
+			;;
+		esac
+	done
+	deplibs="$tmp_deplibs"
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  else
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    libobjs="$libobjs $func_extract_archives_result"
+	  fi
+	fi
+	
+	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  linker_flags="$linker_flags $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test "$module" = yes && test -n "$module_cmds" ; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	  eval test_cmds=\"$archive_expsym_cmds\"
+	  cmds=$archive_expsym_cmds
+	else
+	  eval test_cmds=\"$archive_cmds\"
+	  cmds=$archive_cmds
+	  fi
+	fi
+
+	if test "X$skipped_export" != "X:" &&
+	   len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise.
+	  $echo "creating reloadable object files..."
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  output_la=`$echo "X$output" | $Xsed -e "$basename"`
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  delfiles=
+	  last_robj=
+	  k=1
+	  output=$output_objdir/$output_la-${k}.$objext
+	  # Loop over the list of objects to be linked.
+	  for obj in $save_libobjs
+	  do
+	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
+	    if test "X$objlist" = X ||
+	       { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+		 test "$len" -le "$max_cmd_len"; }; then
+	      objlist="$objlist $obj"
+	    else
+	      # The command $test_cmds is almost too long, add a
+	      # command to the queue.
+	      if test "$k" -eq 1 ; then
+		# The first file doesn't have a previous command to add.
+		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
+	      else
+		# All subsequent reloadable object files will link in
+		# the last one created.
+		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
+	      fi
+	      last_robj=$output_objdir/$output_la-${k}.$objext
+	      k=`expr $k + 1`
+	      output=$output_objdir/$output_la-${k}.$objext
+	      objlist=$obj
+	      len=1
+	    fi
+	  done
+	  # Handle the remaining objects by creating one last
+	  # reloadable object file.  All subsequent reloadable object
+	  # files will link in the last one created.
+	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
+
+	  if ${skipped_export-false}; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    libobjs=$output
+	    # Append the command to create the export file.
+	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
+          fi
+
+	  # Set up a command to remove the reloadable object files
+	  # after they are used.
+	  i=0
+	  while test "$i" -lt "$k"
+	  do
+	    i=`expr $i + 1`
+	    delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
+	  done
+
+	  $echo "creating a temporary reloadable object file: $output"
+
+	  # Loop through the commands generated above and execute them.
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $concat_cmds; do
+	    IFS="$save_ifs"
+	    $show "$cmd"
+	    $run eval "$cmd" || exit $?
+	  done
+	  IFS="$save_ifs"
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test "$module" = yes && test -n "$module_cmds" ; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    cmds=$archive_expsym_cmds
+	  else
+	    cmds=$archive_cmds
+	    fi
+	  fi
+
+	  # Append the command to remove the reloadable object files
+	  # to the just-reset $cmds.
+	  eval cmds=\"\$cmds~\$rm $delfiles\"
+	fi
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test "$mode" = relink; then
+	      $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS="$save_ifs"
+
+	# Restore the uninstalled library and exit
+	if test "$mode" = relink; then
+	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      $show "${rm}r $gentop"
+	      $run ${rm}r "$gentop"
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
+	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test "$module" = yes || test "$export_dynamic" = yes; then
+	  # On all known operating systems, these are identical.
+	  dlname="$soname"
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
+      fi
+
+      case $output in
+      *.lo)
+	if test -n "$objs$old_deplibs"; then
+	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	libobj="$output"
+	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
+	;;
+      *)
+	libobj=
+	obj="$output"
+	;;
+      esac
+
+      # Delete the old objects.
+      $run $rm $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # reload_cmds runs $LD directly, so let us get rid of
+      # -Wl from whole_archive_flag_spec
+      wl=
+
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
+	else
+	  gentop="$output_objdir/${obj}x"
+	  generated="$generated $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # Create the old-style object.
+      reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+
+      output="$obj"
+      cmds=$reload_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$build_libtool_libs" != yes; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $run eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test -n "$pic_flag" || test "$pic_mode" != default; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output="$libobj"
+	cmds=$reload_cmds
+	save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  eval cmd=\"$cmd\"
+	  $show "$cmd"
+	  $run eval "$cmd" || exit $?
+	done
+	IFS="$save_ifs"
+      fi
+
+      if test -n "$gentop"; then
+	$show "${rm}r $gentop"
+	$run ${rm}r $gentop
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
+      esac
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
+      fi
+
+      if test "$preload" = yes; then
+	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
+	   test "$dlopen_self_static" = unknown; then
+	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
+	fi
+      fi
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.[012])
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
+	;;
+      esac
+
+      case $host in
+      *darwin*)
+        # Don't allow lazy linking, it breaks C++ global constructors
+        if test "$tagname" = CXX ; then
+        compile_command="$compile_command ${wl}-bind_at_load"
+        finalize_command="$finalize_command ${wl}-bind_at_load"
+        fi
+        ;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    new_libs="$new_libs -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) new_libs="$new_libs $deplib" ;;
+	  esac
+	  ;;
+	*) new_libs="$new_libs $deplib" ;;
+	esac
+      done
+      compile_deplibs="$new_libs"
+
+
+      compile_command="$compile_command $compile_deplibs"
+      finalize_command="$finalize_command $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) perm_rpath="$perm_rpath $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
+	  testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath="$rpath"
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath="$rpath"
+
+      if test -n "$libobjs" && test "$build_old_libs" = yes; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+      fi
+
+      dlsyms=
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	  dlsyms="${outputname}S.c"
+	else
+	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
+	fi
+      fi
+
+      if test -n "$dlsyms"; then
+	case $dlsyms in
+	"") ;;
+	*.c)
+	  # Discover the nlist of each of the dlfiles.
+	  nlist="$output_objdir/${outputname}.nm"
+
+	  $show "$rm $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Parse the name list into a source file.
+	  $show "creating $output_objdir/$dlsyms"
+
+	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
+/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
+/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+/* Prevent the only kind of declaration conflicts we can make. */
+#define lt_preloaded_symbols some_other_symbol
+
+/* External symbol declarations for the compiler. */\
+"
+
+	  if test "$dlself" = yes; then
+	    $show "generating symbol list for \`$output'"
+
+	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
+
+	    # Add our own program objects to the symbol list.
+	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	    for arg in $progfiles; do
+	      $show "extracting global C symbols from \`$arg'"
+	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	    done
+
+	    if test -n "$exclude_expsyms"; then
+	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    if test -n "$export_symbols_regex"; then
+	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    # Prepare the list of exported symbols
+	    if test -z "$export_symbols"; then
+	      export_symbols="$output_objdir/$outputname.exp"
+	      $run $rm $export_symbols
+	      $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    else
+	      $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      $run eval 'mv "$nlist"T "$nlist"'
+              case $host in
+              *cygwin* | *mingw* )
+	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+		$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+                ;;
+              esac
+	    fi
+	  fi
+
+	  for arg in $dlprefiles; do
+	    $show "extracting global C symbols from \`$arg'"
+	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
+	    $run eval '$echo ": $name " >> "$nlist"'
+	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -z "$run"; then
+	    # Make sure we have at least an empty file.
+	    test -f "$nlist" || : > "$nlist"
+
+	    if test -n "$exclude_expsyms"; then
+	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	      $mv "$nlist"T "$nlist"
+	    fi
+
+	    # Try sorting and uniquifying the output.
+	    if grep -v "^: " < "$nlist" |
+		if sort -k 3 </dev/null >/dev/null 2>&1; then
+		  sort -k 3
+		else
+		  sort +2
+		fi |
+		uniq > "$nlist"S; then
+	      :
+	    else
+	      grep -v "^: " < "$nlist" > "$nlist"S
+	    fi
+
+	    if test -f "$nlist"S; then
+	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
+	    else
+	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
+	    fi
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+
+#undef lt_preloaded_symbols
+
+#if defined (__STDC__) && __STDC__
+# define lt_ptr void *
+#else
+# define lt_ptr char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+"
+
+	    case $host in
+	    *cygwin* | *mingw* )
+	  $echo >> "$output_objdir/$dlsyms" "\
+/* DATA imports from DLLs on WIN32 can't be const, because
+   runtime relocations are performed -- see ld's documentation
+   on pseudo-relocs */
+struct {
+"
+	      ;;
+	    * )
+	  $echo >> "$output_objdir/$dlsyms" "\
+const struct {
+"
+	      ;;
+	    esac
+
+
+	  $echo >> "$output_objdir/$dlsyms" "\
+  const char *name;
+  lt_ptr address;
+}
+lt_preloaded_symbols[] =
+{\
+"
+
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+  {0, (lt_ptr) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	  fi
+
+	  pic_flag_for_symtable=
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
+	    esac;;
+	  *-*-hpux*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag";;
+	    esac
+	  esac
+
+	  # Now compile the dynamic symbol file.
+	  $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
+	  $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
+
+	  # Clean up the generated files.
+	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Transform the symbol file into the correct name.
+          case $host in
+          *cygwin* | *mingw* )
+            if test -f "$output_objdir/${outputname}.def" ; then
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%"`
+            else
+              compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+              finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+             fi
+            ;;
+          * )
+            compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+            ;;
+          esac
+	  ;;
+	*)
+	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      else
+	# We keep going just in case the user didn't refer to
+	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+	# really was required.
+
+	# Nullify the symbol file.
+	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
+	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+      fi
+
+      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
+	# Replace the output file specification.
+	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	link_command="$compile_command$compile_rpath"
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	$show "$link_command"
+	$run eval "$link_command"
+	exit_status=$?
+
+	# Delete the generated files.
+	if test -n "$dlsyms"; then
+	  $show "$rm $output_objdir/${outputname}S.${objext}"
+	  $run $rm "$output_objdir/${outputname}S.${objext}"
+	fi
+
+	exit $exit_status
+      fi
+
+      if test -n "$shlibpath_var"; then
+	# We should set the shlibpath_var
+	rpath=
+	for dir in $temp_rpath; do
+	  case $dir in
+	  [\\/]* | [A-Za-z]:[\\/]*)
+	    # Absolute path.
+	    rpath="$rpath$dir:"
+	    ;;
+	  *)
+	    # Relative path: add a thisdir entry.
+	    rpath="$rpath\$thisdir/$dir:"
+	    ;;
+	  esac
+	done
+	temp_rpath="$rpath"
+      fi
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test "$no_install" = yes; then
+	# We don't need to create a wrapper script.
+	link_command="$compile_var$compile_command$compile_rpath"
+	# Replace the output file specification.
+	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$run $rm $output
+	# Link the executable and exit
+	$show "$link_command"
+	$run eval "$link_command" || exit $?
+	exit $EXIT_SUCCESS
+      fi
+
+      if test "$hardcode_action" = relink; then
+	# Fast installation is not supported
+	link_command="$compile_var$compile_command$compile_rpath"
+	relink_command="$finalize_var$finalize_command$finalize_rpath"
+
+	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
+	$echo "$modename: \`$output' will be relinked during installation" 1>&2
+      else
+	if test "$fast_install" != no; then
+	  link_command="$finalize_var$compile_command$finalize_rpath"
+	  if test "$fast_install" = yes; then
+	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+	  else
+	    # fast_install is set to needless
+	    relink_command=
+	  fi
+	else
+	  link_command="$compile_var$compile_command$compile_rpath"
+	  relink_command="$finalize_var$finalize_command$finalize_rpath"
+	fi
+      fi
+
+      # Replace the output file specification.
+      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      $show "$link_command"
+      $run eval "$link_command" || exit $?
+
+      # Now create the wrapper script.
+      $show "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Quote $echo for shipping.
+      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
+	case $progpath in
+	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
+	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
+	esac
+	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
+      else
+	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if our run command is non-null.
+      if test -z "$run"; then
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+            output_name=`basename $output`
+            output_path=`dirname $output`
+            cwrappersource="$output_path/$objdir/lt-$output_name.c"
+            cwrapper="$output_path/$output_name.exe"
+            $rm $cwrappersource $cwrapper
+            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    cat > $cwrappersource <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+
+   Currently, it simply execs the wrapper *script* "/bin/sh $output",
+   but could eventually absorb all of the scripts functionality and
+   exec $objdir/$outputname directly.
+*/
+EOF
+	    cat >> $cwrappersource<<"EOF"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/stat.h>
+
+#if defined(PATH_MAX)
+# define LT_PATHMAX PATH_MAX
+#elif defined(MAXPATHLEN)
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
+  defined (__OS2__)
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free ((void *) stale); stale = 0; } \
+} while (0)
+
+/* -DDEBUG is fairly common in CFLAGS.  */
+#undef DEBUG
+#if defined DEBUGWRAPPER
+# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
+#else
+# define DEBUG(format, ...)
+#endif
+
+const char *program_name = NULL;
+
+void * xmalloc (size_t num);
+char * xstrdup (const char *string);
+const char * base_name (const char *name);
+char * find_executable(const char *wrapper);
+int    check_executable(const char *path);
+char * strendzap(char *str, const char *pat);
+void lt_fatal (const char *message, ...);
+
+int
+main (int argc, char *argv[])
+{
+  char **newargz;
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  DEBUG("(main) argv[0]      : %s\n",argv[0]);
+  DEBUG("(main) program_name : %s\n",program_name);
+  newargz = XMALLOC(char *, argc+2);
+EOF
+
+            cat >> $cwrappersource <<EOF
+  newargz[0] = (char *) xstrdup("$SHELL");
+EOF
+
+            cat >> $cwrappersource <<"EOF"
+  newargz[1] = find_executable(argv[0]);
+  if (newargz[1] == NULL)
+    lt_fatal("Couldn't find %s", argv[0]);
+  DEBUG("(main) found exe at : %s\n",newargz[1]);
+  /* we know the script has the same name, without the .exe */
+  /* so make sure newargz[1] doesn't end in .exe */
+  strendzap(newargz[1],".exe");
+  for (i = 1; i < argc; i++)
+    newargz[i+1] = xstrdup(argv[i]);
+  newargz[argc+1] = NULL;
+
+  for (i=0; i<argc+1; i++)
+  {
+    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
+    ;
+  }
+
+EOF
+
+            case $host_os in
+              mingw*)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",(char const **)newargz);
+EOF
+              ;;
+              *)
+                cat >> $cwrappersource <<EOF
+  execv("$SHELL",newargz);
+EOF
+              ;;
+            esac
+
+            cat >> $cwrappersource <<"EOF"
+  return 127;
+}
+
+void *
+xmalloc (size_t num)
+{
+  void * p = (void *) malloc (num);
+  if (!p)
+    lt_fatal ("Memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
+;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable(const char * path)
+{
+  struct stat st;
+
+  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0) &&
+      (
+        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
+#if defined (S_IXOTH)
+       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
+#endif
+#if defined (S_IXGRP)
+       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
+#endif
+       ((st.st_mode & S_IXUSR) == S_IXUSR))
+      )
+    return 1;
+  else
+    return 0;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise */
+char *
+find_executable (const char* wrapper)
+{
+  int has_slash = 0;
+  const char* p;
+  const char* p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  int tmp_len;
+  char* concat_name;
+
+  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
+  {
+    concat_name = xstrdup (wrapper);
+    if (check_executable(concat_name))
+      return concat_name;
+    XFREE(concat_name);
+  }
+  else
+  {
+#endif
+    if (IS_DIR_SEPARATOR (wrapper[0]))
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable(concat_name))
+        return concat_name;
+      XFREE(concat_name);
+    }
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+  }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+    {
+      has_slash = 1;
+      break;
+    }
+  if (!has_slash)
+  {
+    /* no slashes; search PATH */
+    const char* path = getenv ("PATH");
+    if (path != NULL)
+    {
+      for (p = path; *p; p = p_next)
+      {
+        const char* q;
+        size_t p_len;
+        for (q = p; *q; q++)
+          if (IS_PATH_SEPARATOR(*q))
+            break;
+        p_len = q - p;
+        p_next = (*q == '\0' ? q : q + 1);
+        if (p_len == 0)
+        {
+          /* empty path: current directory */
+          if (getcwd (tmp, LT_PATHMAX) == NULL)
+            lt_fatal ("getcwd failed");
+          tmp_len = strlen(tmp);
+          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, tmp, tmp_len);
+          concat_name[tmp_len] = '/';
+          strcpy (concat_name + tmp_len + 1, wrapper);
+        }
+        else
+        {
+          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
+          memcpy (concat_name, p, p_len);
+          concat_name[p_len] = '/';
+          strcpy (concat_name + p_len + 1, wrapper);
+        }
+        if (check_executable(concat_name))
+          return concat_name;
+        XFREE(concat_name);
+      }
+    }
+    /* not found in PATH; assume curdir */
+  }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal ("getcwd failed");
+  tmp_len = strlen(tmp);
+  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable(concat_name))
+    return concat_name;
+  XFREE(concat_name);
+  return NULL;
+}
+
+char *
+strendzap(char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert(str != NULL);
+  assert(pat != NULL);
+
+  len = strlen(str);
+  patlen = strlen(pat);
+
+  if (patlen <= len)
+  {
+    str += len - patlen;
+    if (strcmp(str, pat) == 0)
+      *str = '\0';
+  }
+  return str;
+}
+
+static void
+lt_error_core (int exit_status, const char * mode,
+          const char * message, va_list ap)
+{
+  fprintf (stderr, "%s: %s: ", program_name, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
+  va_end (ap);
+}
+EOF
+          # we should really use a build-platform specific compiler
+          # here, but OTOH, the wrappers (shell script and this C one)
+          # are only useful if you want to execute the "real" binary.
+          # Since the "real" binary is built for $host, then this
+          # wrapper might as well be built for $host, too.
+          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
+          ;;
+        esac
+        $rm $output
+        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
+
+	$echo > $output "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='${SED} -e 1s/^X//'
+sed_quote_subst='$sed_quote_subst'
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variable:
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$echo are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    echo=\"$qecho\"
+    file=\"\$0\"
+    # Make sure echo works.
+    if test \"X\$1\" = X--no-reexec; then
+      # Discard the --no-reexec flag, and continue.
+      shift
+    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
+      # Yippee, \$echo works!
+      :
+    else
+      # Restart under the correct shell, and then maybe \$echo will work.
+      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
+    fi
+  fi\
+"
+	$echo >> $output "\
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
+  done
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test "$fast_install" = yes; then
+	  $echo >> $output "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" || \\
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $mkdir \"\$progdir\"
+    else
+      $rm \"\$progdir/\$file\"
+    fi"
+
+	  $echo >> $output "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	$echo \"\$relink_command_output\" >&2
+	$rm \"\$progdir/\$file\"
+	exit $EXIT_FAILURE
+      fi
+    fi
+
+    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $rm \"\$progdir/\$program\";
+      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $rm \"\$progdir/\$file\"
+  fi"
+	else
+	  $echo >> $output "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$echo >> $output "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# Export our shlibpath_var if we have one.
+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $echo >> $output "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	# fixup the dll searchpath if we need to.
+	if test -n "$dllsearchpath"; then
+	  $echo >> $output "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	$echo >> $output "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+
+      # Make sure env LD_LIBRARY_PATH does not mess us up
+      if test -n \"\${LD_LIBRARY_PATH+set}\"; then
+        export LD_LIBRARY_PATH=\$progdir:\$LD_LIBRARY_PATH
+      fi
+"
+	case $host in
+	# Backslashes separate directories on plain windows
+	*-*-mingw | *-*-os2*)
+	  $echo >> $output "\
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+	  ;;
+
+	*)
+	  $echo >> $output "\
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+	  ;;
+	esac
+	$echo >> $output "\
+      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
+      exit $EXIT_FAILURE
+    fi
+  else
+    # The program doesn't exist.
+    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+    \$echo \"This script is just a wrapper for \$program.\" 1>&2
+    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi\
+"
+	chmod +x $output
+      fi
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      if test "$build_libtool_libs" = convenience; then
+	oldobjs="$libobjs_save"
+	addlibs="$convenience"
+	build_libtool_libs=no
+      else
+	if test "$build_libtool_libs" = module; then
+	  oldobjs="$libobjs_save"
+	  build_libtool_libs=no
+	else
+	  oldobjs="$old_deplibs $non_pic_objects"
+	fi
+	addlibs="$old_convenience"
+      fi
+
+      if test -n "$addlibs"; then
+	gentop="$output_objdir/${outputname}x"
+	generated="$generated $gentop"
+
+	func_extract_archives $gentop $addlibs
+	oldobjs="$oldobjs $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+       cmds=$old_archive_from_new_cmds
+      else
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  $echo "copying selected object files to avoid basename conflicts..."
+
+	  if test -z "$gentop"; then
+	    gentop="$output_objdir/${outputname}x"
+	    generated="$generated $gentop"
+
+	    $show "${rm}r $gentop"
+	    $run ${rm}r "$gentop"
+	    $show "$mkdir $gentop"
+	    $run $mkdir "$gentop"
+	    exit_status=$?
+	    if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
+	      exit $exit_status
+	    fi
+	  fi
+
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *[\ /]"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		counter=`expr $counter + 1`
+		case " $oldobjs " in
+		*[\ /]"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      $run ln "$obj" "$gentop/$newobj" ||
+	      $run cp "$obj" "$gentop/$newobj"
+	      oldobjs="$oldobjs $gentop/$newobj"
+	      ;;
+	    *) oldobjs="$oldobjs $obj" ;;
+	    esac
+	  done
+	fi
+
+	eval cmds=\"$old_archive_cmds\"
+
+	if len=`expr "X$cmds" : ".*"` &&
+	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  $echo "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  for obj in $save_oldobjs
+	  do
+	    oldobjs="$objlist $obj"
+	    objlist="$objlist $obj"
+	    eval test_cmds=\"$old_archive_cmds\"
+	    if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
+	       test "$len" -le "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj" ; then
+	        RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
+	      objlist=
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test "X$oldobjs" = "X" ; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+        eval cmd=\"$cmd\"
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$generated"; then
+      $show "${rm}r$generated"
+      $run ${rm}r$generated
+    fi
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test "$build_old_libs" = yes && old_library="$libname.$libext"
+      $show "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
+	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      if test "$hardcode_automatic" = yes ; then
+	relink_command=
+      fi
+
+
+      # Only create the output if not a dry run.
+      if test -z "$run"; then
+	for installed in no yes; do
+	  if test "$installed" = yes; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output="$output_objdir/$outputname"i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
+		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		if test -z "$libdir"; then
+		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
+		  exit $EXIT_FAILURE
+		fi
+		if test "X$EGREP" = X ; then
+			EGREP=egrep
+		fi
+		# We do not want portage's install root ($D) present.  Check only for
+		# this if the .la is being installed.
+		if test "$installed" = yes && test "$D"; then
+		  eval mynewdependency_lib=`echo "$libdir/$name" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+		else
+		  mynewdependency_lib="$libdir/$name"
+		fi
+		# Do not add duplicates
+		if test "$mynewdependency_lib"; then
+		  my_little_ninja_foo_1=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
+		  if test -z "$my_little_ninja_foo_1"; then
+		    newdependency_libs="$newdependency_libs $mynewdependency_lib"
+		  fi
+		fi
+		;;
+		  *)
+		if test "$installed" = yes; then
+		  # Rather use S=WORKDIR if our version of portage supports it.
+		  # This is because some ebuild (gcc) do not use $S as buildroot.
+		  if test "$PWORKDIR"; then
+		    S="$PWORKDIR"
+		  fi
+		  # We do not want portage's build root ($S) present.
+		  my_little_ninja_foo_2=`echo $deplib |$EGREP -e "$S"`
+		  # We do not want portage's install root ($D) present.
+		  my_little_ninja_foo_3=`echo $deplib |$EGREP -e "$D"`
+		  if test -n "$my_little_ninja_foo_2" && test "$S"; then
+		    mynewdependency_lib=""
+		  elif test -n "$my_little_ninja_foo_3" && test "$D"; then
+		    eval mynewdependency_lib=`echo "$deplib" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+		  else
+		    mynewdependency_lib="$deplib"
+		  fi
+		else
+		  mynewdependency_lib="$deplib"
+		fi
+		# Do not add duplicates
+		if test "$mynewdependency_lib"; then
+		  my_little_ninja_foo_4=`echo $newdependency_libs |$EGREP -e "$mynewdependency_lib"`
+		  if test -z "$my_little_ninja_foo_4"; then
+			newdependency_libs="$newdependency_libs $mynewdependency_lib"
+		  fi
+		fi
+		;;
+	      esac
+	    done
+	    dependency_libs="$newdependency_libs"
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlfiles="$newdlfiles $libdir/$name"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
+	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+	      if test -z "$libdir"; then
+		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+		exit $EXIT_FAILURE
+	      fi
+	      newdlprefiles="$newdlprefiles $libdir/$name"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlfiles="$newdlfiles $abs"
+	    done
+	    dlfiles="$newdlfiles"
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      newdlprefiles="$newdlprefiles $abs"
+	    done
+	    dlprefiles="$newdlprefiles"
+	  fi
+	  $rm $output
+	  # place dlname in correct position for cygwin
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
+	  esac
+	  # Do not add duplicates
+	  if test "$installed" = yes && test "$D"; then
+	    install_libdir=`echo "$install_libdir" |sed -e "s:$D:/:g" -e 's:/\+:/:g'`
+	  fi
+	  $echo > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test "$installed" = no && test "$need_relink" = yes; then
+	    $echo >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      fi
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
+      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool install mode
+  install)
+    modename="$modename: install"
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
+       # Allow the use of GNU shtool's install command.
+       $echo "X$nonopt" | grep shtool > /dev/null; then
+      # Aesthetically quote it.
+      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$arg "
+      arg="$1"
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+    case $arg in
+    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+      arg="\"$arg\""
+      ;;
+    esac
+    install_prog="$install_prog$arg"
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=no
+    stripme=
+    for arg
+    do
+      if test -n "$dest"; then
+	files="$files $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=yes ;;
+      -f) 
+      	case " $install_prog " in
+	*[\\\ /]cp\ *) ;;
+	*) prev=$arg ;;
+	esac
+	;;
+      -g | -m | -o) prev=$arg ;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+      case $arg in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$install_prog $arg"
+    done
+
+    if test -z "$install_prog"; then
+      $echo "$modename: you must specify an install program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prev' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	$echo "$modename: no file or destination specified" 1>&2
+      else
+	$echo "$modename: you must specify a destination" 1>&2
+      fi
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    # Strip any trailing slash from the destination.
+    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=yes
+    if test "$isdir" = yes; then
+      destdir="$dest"
+      destname=
+    else
+      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
+      test "X$destdir" = "X$dest" && destdir=.
+      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files
+      if test "$#" -gt 2; then
+	$echo "$modename: \`$dest' is not a directory" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+    fi
+    case $destdir in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	staticlibs="$staticlibs $file"
+	;;
+
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	library_names=
+	old_library=
+	relink_command=
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) current_libdirs="$current_libdirs $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) future_libdirs="$future_libdirs $libdir" ;;
+	  esac
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
+	test "X$dir" = "X$file/" && dir=
+	dir="$dir$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  if test "$inst_prefix_dir" = "$destdir"; then
+	    $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  $echo "$modename: warning: relinking \`$file'" 1>&2
+	  $show "$relink_command"
+	  if $run eval "$relink_command"; then :
+	  else
+	    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names
+	if test -n "$2"; then
+	  realname="$2"
+	  shift
+	  shift
+
+	  srcname="$realname"
+	  test -n "$relink_command" && srcname="$realname"T
+
+	  # Install the shared library and build the symlinks.
+	  $show "$install_prog $dir/$srcname $destdir/$realname"
+	  $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
+	  if test -n "$stripme" && test -n "$striplib"; then
+	    $show "$striplib $destdir/$realname"
+	    $run eval "$striplib $destdir/$realname" || exit $?
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try `ln -sf' first, because the `ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      if test "$linkname" != "$realname"; then
+                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
+	      fi
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib="$destdir/$realname"
+	  cmds=$postinstall_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || {
+	      lt_exit=$?
+
+	      # Restore the uninstalled library and exit
+	      if test "$mode" = relink; then
+		$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
+	      fi
+
+	      exit $lt_exit
+	    }
+	  done
+	  IFS="$save_ifs"
+	fi
+
+	# Install the pseudo-library for information purposes.
+	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	instname="$dir/$name"i
+	$show "$install_prog $instname $destdir/$name"
+	$run eval "$install_prog $instname $destdir/$name" || exit $?
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
+	  ;;
+	*.$objext)
+	  staticdest="$destfile"
+	  destfile=
+	  ;;
+	*)
+	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	if test -n "$destfile"; then
+	  $show "$install_prog $file $destfile"
+	  $run eval "$install_prog $file $destfile" || exit $?
+	fi
+
+	# Install the old object if enabled.
+	if test "$build_old_libs" = yes; then
+	  # Deduce the name of the old-style object file.
+	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
+
+	  $show "$install_prog $staticobj $staticdest"
+	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=""
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      file=`$echo $file|${SED} 's,.exe$,,'`
+	      stripped_ext=".exe"
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin*|*mingw*)
+	    wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  # Check the variables that should have been set.
+	  if test -z "$notinst_deplibs"; then
+	    $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
+	    exit $EXIT_FAILURE
+	  fi
+
+	  finalize=yes
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      # If there is no directory component, then add one.
+	      case $lib in
+	      */* | *\\*) . $lib ;;
+	      *) . ./$lib ;;
+	      esac
+	    fi
+	    libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
+	      finalize=no
+	    fi
+	  done
+
+	  relink_command=
+	  # Note that it is not necessary on cygwin/mingw to append a dot to
+	  # foo even if both foo and FILE.exe exist: automatic-append-.exe
+	  # behavior happens only for exec(3), not for open(2)!  Also, sourcing
+	  # `FILE.' does not work on cygwin managed mounts.
+	  #
+	  # If there is no directory component, then add one.
+	  case $wrapper in
+	  */* | *\\*) . ${wrapper} ;;
+	  *) . ./${wrapper} ;;
+	  esac
+
+	  outputname=
+	  if test "$fast_install" = no && test -n "$relink_command"; then
+	    if test "$finalize" = yes && test -z "$run"; then
+	      tmpdir=`func_mktempdir`
+	      file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
+	      outputname="$tmpdir/$file"
+	      # Replace the output file specification.
+	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+
+	      $show "$relink_command"
+	      if $run eval "$relink_command"; then :
+	      else
+		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+		${rm}r "$tmpdir"
+		continue
+	      fi
+	      file="$outputname"
+	    else
+	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
+	    fi
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway 
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
+	    ;;
+	  esac
+	  ;;
+	esac
+	$show "$install_prog$stripme $file $destfile"
+	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
+	test -n "$outputname" && ${rm}r "$tmpdir"
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+
+      # Set up the ranlib parameters.
+      oldlib="$destdir/$name"
+
+      $show "$install_prog $file $oldlib"
+      $run eval "$install_prog \$file \$oldlib" || exit $?
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	$show "$old_striplib $oldlib"
+	$run eval "$old_striplib $oldlib" || exit $?
+      fi
+
+      # Do each command in the postinstall commands.
+      cmds=$old_postinstall_cmds
+      save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	eval cmd=\"$cmd\"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$future_libdirs"; then
+      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
+    fi
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      test -n "$run" && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool finish mode
+  finish)
+    modename="$modename: finish"
+    libdirs="$nonopt"
+    admincmds=
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for dir
+      do
+	libdirs="$libdirs $dir"
+      done
+
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  cmds=$finish_cmds
+	  save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    eval cmd=\"$cmd\"
+	    $show "$cmd"
+	    $run eval "$cmd" || admincmds="$admincmds
+       $cmd"
+	  done
+	  IFS="$save_ifs"
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $run eval "$cmds" || admincmds="$admincmds
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    test "$show" = : && exit $EXIT_SUCCESS
+
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    $echo "Libraries have been installed in:"
+    for libdir in $libdirs; do
+      $echo "   $libdir"
+    done
+    $echo
+    $echo "If you ever happen to want to link against installed libraries"
+    $echo "in a given directory, LIBDIR, you must either use libtool, and"
+    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+    $echo "flag during linking and do at least one of the following:"
+    if test -n "$shlibpath_var"; then
+      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+      $echo "     during execution"
+    fi
+    if test -n "$runpath_var"; then
+      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+      $echo "     during linking"
+    fi
+    if test -n "$hardcode_libdir_flag_spec"; then
+      libdir=LIBDIR
+      eval flag=\"$hardcode_libdir_flag_spec\"
+
+      $echo "   - use the \`$flag' linker flag"
+    fi
+    if test -n "$admincmds"; then
+      $echo "   - have your system administrator run these commands:$admincmds"
+    fi
+    if test -f /etc/ld.so.conf; then
+      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+    fi
+    $echo
+    $echo "See any operating system documentation about shared libraries for"
+    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
+    $echo "X----------------------------------------------------------------------" | $Xsed
+    exit $EXIT_SUCCESS
+    ;;
+
+  # libtool execute mode
+  execute)
+    modename="$modename: execute"
+
+    # The first argument is the command name.
+    cmd="$nonopt"
+    if test -z "$cmd"; then
+      $echo "$modename: you must specify a COMMAND" 1>&2
+      $echo "$help"
+      exit $EXIT_FAILURE
+    fi
+
+    # Handle -dlopen flags immediately.
+    for file in $execute_dlfiles; do
+      if test ! -f "$file"; then
+	$echo "$modename: \`$file' is not a file" 1>&2
+	$echo "$help" 1>&2
+	exit $EXIT_FAILURE
+      fi
+
+      dir=
+      case $file in
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+
+	# If there is no directory component, then add one.
+	case $file in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
+	  continue
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  dir="$dir/$objdir"
+	else
+	  $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
+	  exit $EXIT_FAILURE
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+	;;
+
+      *)
+	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir="$absdir"
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic="$magic"
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -*) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  # If there is no directory component, then add one.
+	  case $file in
+	  */* | *\\*) . $file ;;
+	  *) . ./$file ;;
+	  esac
+
+	  # Transform arg to wrapped name.
+	  file="$progdir/$program"
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
+      args="$args \"$file\""
+    done
+
+    if test -z "$run"; then
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      if test "${save_LC_ALL+set}" = set; then
+	LC_ALL="$save_LC_ALL"; export LC_ALL
+      fi
+      if test "${save_LANG+set}" = set; then
+	LANG="$save_LANG"; export LANG
+      fi
+
+      # Now prepare to actually exec the command.
+      exec_cmd="\$cmd$args"
+    else
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
+	$echo "export $shlibpath_var"
+      fi
+      $echo "$cmd$args"
+      exit $EXIT_SUCCESS
+    fi
+    ;;
+
+  # libtool clean and uninstall mode
+  clean | uninstall)
+    modename="$modename: $mode"
+    rm="$nonopt"
+    files=
+    rmforce=
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    for arg
+    do
+      case $arg in
+      -f) rm="$rm $arg"; rmforce=yes ;;
+      -*) rm="$rm $arg" ;;
+      *) files="$files $arg" ;;
+      esac
+    done
+
+    if test -z "$rm"; then
+      $echo "$modename: you must specify an RM program" 1>&2
+      $echo "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+
+    rmdirs=
+
+    origobjdir="$objdir"
+    for file in $files; do
+      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+      if test "X$dir" = "X$file"; then
+	dir=.
+	objdir="$origobjdir"
+      else
+	objdir="$dir/$origobjdir"
+      fi
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+      test "$mode" = uninstall && objdir="$dir"
+
+      # Remember objdir for removal later, being careful to avoid duplicates
+      if test "$mode" = clean; then
+	case " $rmdirs " in
+	  *" $objdir "*) ;;
+	  *) rmdirs="$rmdirs $objdir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if (test -L "$file") >/dev/null 2>&1 \
+	|| (test -h "$file") >/dev/null 2>&1 \
+	|| test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif test "$rmforce" = yes; then
+	continue
+      fi
+
+      rmfiles="$file"
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  . $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    rmfiles="$rmfiles $objdir/$n"
+	  done
+	  test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
+
+	  case "$mode" in
+	  clean)
+	    case "  $library_names " in
+	    # "  " in the beginning catches empty $dlname
+	    *" $dlname "*) ;;
+	    *) rmfiles="$rmfiles $objdir/$dlname" ;;
+	    esac
+	     test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      cmds=$postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      cmds=$old_postuninstall_cmds
+	      save_ifs="$IFS"; IFS='~'
+	      for cmd in $cmds; do
+		IFS="$save_ifs"
+		eval cmd=\"$cmd\"
+		$show "$cmd"
+		$run eval "$cmd"
+		if test "$?" -ne 0 && test "$rmforce" != yes; then
+		  exit_status=1
+		fi
+	      done
+	      IFS="$save_ifs"
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+
+	  # Read the .lo file
+	  . $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" \
+	     && test "$pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" \
+	     && test "$non_pic_object" != none; then
+	    rmfiles="$rmfiles $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test "$mode" = clean ; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    file=`$echo $file|${SED} 's,.exe$,,'`
+	    noexename=`$echo $name|${SED} 's,.exe$,,'`
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    rmfiles="$rmfiles $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	    relink_command=
+	    . $dir/$noexename
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
+	    if test "$fast_install" = yes && test -n "$relink_command"; then
+	      rmfiles="$rmfiles $objdir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name" ; then
+	      rmfiles="$rmfiles $objdir/lt-${noexename}.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      $show "$rm $rmfiles"
+      $run $rm $rmfiles || exit_status=1
+    done
+    objdir="$origobjdir"
+
+    # Try to remove the ${objdir}s in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	$show "rmdir $dir"
+	$run rmdir $dir >/dev/null 2>&1
+      fi
+    done
+
+    exit $exit_status
+    ;;
+
+  "")
+    $echo "$modename: you must specify a MODE" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+    ;;
+  esac
+
+  if test -z "$exec_cmd"; then
+    $echo "$modename: invalid operation mode \`$mode'" 1>&2
+    $echo "$generic_help" 1>&2
+    exit $EXIT_FAILURE
+  fi
+fi # test -z "$show_help"
+
+if test -n "$exec_cmd"; then
+  eval exec $exec_cmd
+  exit $EXIT_FAILURE
+fi
+
+# We need to display help for each of the modes.
+case $mode in
+"") $echo \
+"Usage: $modename [OPTION]... [MODE-ARG]...
+
+Provide generalized library-building support services.
+
+    --config          show all configuration variables
+    --debug           enable verbose shell tracing
+-n, --dry-run         display commands without modifying any files
+    --features        display basic configuration information and exit
+    --finish          same as \`--mode=finish'
+    --help            display this help message and exit
+    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
+    --quiet           same as \`--silent'
+    --silent          don't print informational messages
+    --tag=TAG         use configuration variables from tag TAG
+    --version         print version information
+
+MODE must be one of the following:
+
+      clean           remove files from the build directory
+      compile         compile a source file into a libtool object
+      execute         automatically set library path, then run a program
+      finish          complete the installation of libtool libraries
+      install         install libraries or executables
+      link            create a library or an executable
+      uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
+a more detailed description of MODE.
+
+Report bugs to <bug-libtool@gnu.org>."
+  exit $EXIT_SUCCESS
+  ;;
+
+clean)
+  $echo \
+"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+compile)
+  $echo \
+"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -prefer-pic       try to building PIC objects only
+  -prefer-non-pic   try to building non-PIC objects only
+  -static           always build a \`.o' file suitable for static linking
+
+COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix \`.c' with the
+library object suffix, \`.lo'."
+  ;;
+
+execute)
+  $echo \
+"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to \`-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+  ;;
+
+finish)
+  $echo \
+"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the \`--dry-run' option if you just want to see what would be executed."
+  ;;
+
+install)
+  $echo \
+"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the \`install' or \`cp' program.
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+  ;;
+
+link)
+  $echo \
+"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+		    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+		    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  Use a list of object files found in FILE to specify objects
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -static           do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+		    specify library version info [each variable defaults to 0]
+
+All other options (arguments beginning with \`-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in \`.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
+only library objects (\`.lo' files) may be specified, and \`-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
+using \`ar' and \`ranlib', or on Windows using \`lib'.
+
+If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+is created, otherwise an executable program is created."
+  ;;
+
+uninstall)
+  $echo \
+"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+*)
+  $echo "$modename: invalid operation mode \`$mode'" 1>&2
+  $echo "$help" 1>&2
+  exit $EXIT_FAILURE
+  ;;
+esac
+
+$echo
+$echo "Try \`$modename --help' for more information about other modes."
+
+exit $?
+
+# The TAGs below are defined such that we never get into a situation
+# in which we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+disable_libs=shared
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+disable_libs=static
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
diff --git a/client/src/thirdparty/sqlite-3.4.2/main.mk b/client/src/thirdparty/sqlite-3.4.2/main.mk
new file mode 100644
index 0000000..5b1fe53
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/main.mk
@@ -0,0 +1,486 @@
+###############################################################################
+# The following macros should be defined before this script is
+# invoked:
+#
+# TOP              The toplevel directory of the source tree.  This is the
+#                  directory that contains this "Makefile.in" and the
+#                  "configure.in" script.
+#
+# BCC              C Compiler and options for use in building executables that
+#                  will run on the platform that is doing the build.
+#
+# THREADLIB        Specify any extra linker options needed to make the library
+#                  thread safe
+#
+# OPTS             Extra compiler command-line options.
+#
+# EXE              The suffix to add to executable files.  ".exe" for windows
+#                  and "" for Unix.
+#
+# TCC              C Compiler and options for use in building executables that 
+#                  will run on the target platform.  This is usually the same
+#                  as BCC, unless you are cross-compiling.
+#
+# AR               Tools used to build a static library.
+# RANLIB
+#
+# TCL_FLAGS        Extra compiler options needed for programs that use the
+#                  TCL library.
+#
+# LIBTCL           Linker options needed to link against the TCL library.
+#
+# READLINE_FLAGS   Compiler options needed for programs that use the
+#                  readline() library.
+#
+# LIBREADLINE      Linker options needed by programs using readline() must
+#                  link against.
+#
+# NAWK             Nawk compatible awk program.  Older (obsolete?) solaris
+#                  systems need this to avoid using the original AT&T AWK.
+#
+# Once the macros above are defined, the rest of this make script will
+# build the SQLite library and testing tools.
+################################################################################
+
+# This is how we compile
+#
+TCCX = $(TCC) $(OPTS) -I. -I$(TOP)/src
+
+# Object files for the SQLite library.
+#
+LIBOBJ+= alter.o analyze.o attach.o auth.o btmutex.o btree.o build.o \
+         callback.o complete.o date.o delete.o \
+         expr.o fault.o func.o hash.o insert.o journal.o loadext.o \
+         main.o malloc.o mem1.o mem2.o mem3.o mem4.o mutex.o mutex_os2.o \
+         mutex_unix.o mutex_w32.o \
+         opcodes.o os.o os_os2.o os_unix.o os_win.o \
+         pager.o parse.o pragma.o prepare.o printf.o random.o \
+         select.o table.o $(TCLOBJ) tokenize.o trigger.o \
+         update.o util.o vacuum.o \
+         vdbe.o vdbeapi.o vdbeaux.o vdbeblob.o vdbefifo.o vdbemem.o \
+         where.o utf.o legacy.o vtab.o
+
+EXTOBJ = icu.o
+EXTOBJ += fts1.o \
+	  fts1_hash.o \
+	  fts1_tokenizer1.o \
+	  fts1_porter.o
+EXTOBJ += fts2.o \
+	  fts2_hash.o \
+	  fts2_icu.o \
+	  fts2_porter.o \
+          fts2_tokenizer.o \
+	  fts2_tokenizer1.o
+EXTOBJ += fts3.o \
+	  fts3_hash.o \
+	  fts3_icu.o \
+	  fts3_porter.o \
+          fts3_tokenizer.o \
+	  fts3_tokenizer1.o
+
+# All of the source code files.
+#
+SRC = \
+  $(TOP)/src/alter.c \
+  $(TOP)/src/analyze.c \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/auth.c \
+  $(TOP)/src/btmutex.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/btree.h \
+  $(TOP)/src/btreeInt.h \
+  $(TOP)/src/build.c \
+  $(TOP)/src/callback.c \
+  $(TOP)/src/complete.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/delete.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/fault.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/hash.c \
+  $(TOP)/src/hash.h \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/journal.c \
+  $(TOP)/src/legacy.c \
+  $(TOP)/src/loadext.c \
+  $(TOP)/src/main.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/mem1.c \
+  $(TOP)/src/mem2.c \
+  $(TOP)/src/mem3.c \
+  $(TOP)/src/mem4.c \
+  $(TOP)/src/mutex.c \
+  $(TOP)/src/mutex.h \
+  $(TOP)/src/mutex_os2.c \
+  $(TOP)/src/mutex_unix.c \
+  $(TOP)/src/mutex_w32.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os.h \
+  $(TOP)/src/os_common.h \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pager.h \
+  $(TOP)/src/parse.y \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/shell.c \
+  $(TOP)/src/sqlite.h.in \
+  $(TOP)/src/sqlite3ext.h \
+  $(TOP)/src/sqliteInt.h \
+  $(TOP)/src/sqliteLimit.h \
+  $(TOP)/src/table.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/trigger.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/update.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vacuum.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbe.h \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbeblob.c \
+  $(TOP)/src/vdbefifo.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/vdbeInt.h \
+  $(TOP)/src/vtab.c \
+  $(TOP)/src/where.c
+
+# Source code for extensions
+#
+SRC += \
+  $(TOP)/ext/fts1/fts1.c \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.c \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_porter.c \
+  $(TOP)/ext/fts1/fts1_tokenizer.h \
+  $(TOP)/ext/fts1/fts1_tokenizer1.c
+SRC += \
+  $(TOP)/ext/fts2/fts2.c \
+  $(TOP)/ext/fts2/fts2.h \
+  $(TOP)/ext/fts2/fts2_hash.c \
+  $(TOP)/ext/fts2/fts2_hash.h \
+  $(TOP)/ext/fts2/fts2_icu.c \
+  $(TOP)/ext/fts2/fts2_porter.c \
+  $(TOP)/ext/fts2/fts2_tokenizer.h \
+  $(TOP)/ext/fts2/fts2_tokenizer.c \
+  $(TOP)/ext/fts2/fts2_tokenizer1.c
+SRC += \
+  $(TOP)/ext/fts3/fts3.c \
+  $(TOP)/ext/fts3/fts3.h \
+  $(TOP)/ext/fts3/fts3_hash.c \
+  $(TOP)/ext/fts3/fts3_hash.h \
+  $(TOP)/ext/fts3/fts3_icu.c \
+  $(TOP)/ext/fts3/fts3_porter.c \
+  $(TOP)/ext/fts3/fts3_tokenizer.h \
+  $(TOP)/ext/fts3/fts3_tokenizer.c \
+  $(TOP)/ext/fts3/fts3_tokenizer1.c
+SRC += \
+  $(TOP)/ext/icu/icu.c
+
+
+# Generated source code files
+#
+SRC += \
+  keywordhash.h \
+  opcodes.c \
+  opcodes.h \
+  parse.c \
+  parse.h \
+  sqlite3.h
+
+
+# Source code to the test files.
+#
+TESTSRC = \
+  $(TOP)/src/test1.c \
+  $(TOP)/src/test2.c \
+  $(TOP)/src/test3.c \
+  $(TOP)/src/test4.c \
+  $(TOP)/src/test5.c \
+  $(TOP)/src/test6.c \
+  $(TOP)/src/test7.c \
+  $(TOP)/src/test8.c \
+  $(TOP)/src/test9.c \
+  $(TOP)/src/test_autoext.c \
+  $(TOP)/src/test_async.c \
+  $(TOP)/src/test_btree.c \
+  $(TOP)/src/test_config.c \
+  $(TOP)/src/test_devsym.c \
+  $(TOP)/src/test_hexio.c \
+  $(TOP)/src/test_malloc.c \
+  $(TOP)/src/test_md5.c \
+  $(TOP)/src/test_onefile.c \
+  $(TOP)/src/test_schema.c \
+  $(TOP)/src/test_server.c \
+  $(TOP)/src/test_tclvar.c \
+  $(TOP)/src/test_thread.c \
+
+#TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c
+#TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c
+
+TESTSRC2 = \
+  $(TOP)/src/attach.c $(TOP)/src/btree.c $(TOP)/src/build.c $(TOP)/src/date.c  \
+  $(TOP)/src/expr.c $(TOP)/src/func.c $(TOP)/src/insert.c $(TOP)/src/os.c      \
+  $(TOP)/src/os_os2.c $(TOP)/src/os_unix.c $(TOP)/src/os_win.c                 \
+  $(TOP)/src/pager.c $(TOP)/src/pragma.c $(TOP)/src/prepare.c                  \
+  $(TOP)/src/printf.c $(TOP)/src/random.c                                      \
+  $(TOP)/src/select.c $(TOP)/src/tokenize.c                                    \
+  $(TOP)/src/utf.c $(TOP)/src/util.c $(TOP)/src/vdbeapi.c $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbe.c $(TOP)/src/vdbemem.c $(TOP)/src/where.c parse.c
+
+# Header files used by all library source files.
+#
+HDR = \
+   $(TOP)/src/btree.h \
+   $(TOP)/src/btreeInt.h \
+   $(TOP)/src/hash.h \
+   keywordhash.h \
+   $(TOP)/src/mutex.h \
+   opcodes.h \
+   $(TOP)/src/os.h \
+   $(TOP)/src/os_common.h \
+   $(TOP)/src/pager.h \
+   parse.h  \
+   sqlite3.h  \
+   $(TOP)/src/sqlite3ext.h \
+   $(TOP)/src/sqliteInt.h  \
+   $(TOP)/src/sqliteLimit.h \
+   $(TOP)/src/vdbe.h \
+   $(TOP)/src/vdbeInt.h 
+
+# Header files used by extensions
+#
+EXTHDR += \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_tokenizer.h
+EXTHDR += \
+  $(TOP)/ext/fts2/fts2.h \
+  $(TOP)/ext/fts2/fts2_hash.h \
+  $(TOP)/ext/fts2/fts2_tokenizer.h
+EXTHDR += \
+  $(TOP)/ext/fts3/fts3.h \
+  $(TOP)/ext/fts3/fts3_hash.h \
+  $(TOP)/ext/fts3/fts3_tokenizer.h
+
+# This is the default Makefile target.  The objects listed here
+# are what get build when you type just "make" with no arguments.
+#
+all:	sqlite3.h libsqlite3.a sqlite3$(EXE)
+
+libsqlite3.a:	$(LIBOBJ)
+	$(AR) libsqlite3.a $(LIBOBJ)
+	$(RANLIB) libsqlite3.a
+
+sqlite3$(EXE):	$(TOP)/src/shell.c libsqlite3.a sqlite3.h
+	$(TCCX) $(READLINE_FLAGS) -o sqlite3$(EXE)                  \
+		$(TOP)/src/shell.c                                  \
+		libsqlite3.a $(LIBREADLINE) $(TLIBS) $(THREADLIB)
+
+objects: $(LIBOBJ_ORIG)
+
+# This target creates a directory named "tsrc" and fills it with
+# copies of all of the C source code and header files needed to
+# build on the target system.  Some of the C source code and header
+# files are automatically generated.  This target takes care of
+# all that automatic generation.
+#
+target_source:	$(SRC)
+	rm -rf tsrc
+	mkdir tsrc
+	cp -f $(SRC) tsrc
+	rm tsrc/sqlite.h.in tsrc/parse.y
+	touch target_source
+
+sqlite3.c:	target_source $(TOP)/tool/mksqlite3c.tcl
+	tclsh $(TOP)/tool/mksqlite3c.tcl
+	cp sqlite3.c tclsqlite3.c
+	cat $(TOP)/src/tclsqlite.c >>tclsqlite3.c
+
+fts2amal.c:	target_source $(TOP)/ext/fts2/mkfts2amal.tcl
+	tclsh $(TOP)/ext/fts2/mkfts2amal.tcl
+
+fts3amal.c:	target_source $(TOP)/ext/fts3/mkfts3amal.tcl
+	tclsh $(TOP)/ext/fts3/mkfts3amal.tcl
+
+# Rules to build the LEMON compiler generator
+#
+lemon:	$(TOP)/tool/lemon.c $(TOP)/tool/lempar.c
+	$(BCC) -o lemon $(TOP)/tool/lemon.c
+	cp $(TOP)/tool/lempar.c .
+
+# Rules to build individual *.o files from files in the src directory.
+#
+%.o: %.c $(HDR)
+	$(TCCX) -c $<
+
+# Rules to build individual *.o files from generated *.c files. This
+# applies to:
+#
+#     parse.o
+#     opcodes.o
+#
+%.o: $(TOP)/src/%.c $(HDR)
+	$(TCCX) -c $<
+
+tclsqlite.o:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(TCCX) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c
+
+
+
+# Rules to build opcodes.c and opcodes.h
+#
+opcodes.c:	opcodes.h $(TOP)/mkopcodec.awk
+	sort -n -b -k 3 opcodes.h | $(NAWK) -f $(TOP)/mkopcodec.awk >opcodes.c
+
+opcodes.h:	parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
+	cat parse.h $(TOP)/src/vdbe.c |$(NAWK) -f $(TOP)/mkopcodeh.awk >opcodes.h
+
+
+# Rules to build parse.c and parse.h - the outputs of lemon.
+#
+parse.h:	parse.c
+
+parse.c:	$(TOP)/src/parse.y lemon $(TOP)/addopcodes.awk
+	cp $(TOP)/src/parse.y .
+	rm -f parse.h
+	./lemon $(OPTS) parse.y
+	mv parse.h parse.h.temp
+	awk -f $(TOP)/addopcodes.awk parse.h.temp >parse.h
+
+sqlite3.h:	$(TOP)/src/sqlite.h.in 
+	sed -e s/--VERS--/`cat ${TOP}/VERSION`/ \
+	    -e s/--VERSION-NUMBER--/`cat ${TOP}/VERSION | sed 's/[^0-9]/ /g' | $(NAWK) '{printf "%d%03d%03d",$$1,$$2,$$3}'`/ \
+                 $(TOP)/src/sqlite.h.in >sqlite3.h
+
+keywordhash.h:	$(TOP)/tool/mkkeywordhash.c
+	$(BCC) -o mkkeywordhash $(OPTS) $(TOP)/tool/mkkeywordhash.c
+	./mkkeywordhash >keywordhash.h
+
+
+
+# Rules to build the extension objects.
+#
+icu.o:	$(TOP)/ext/icu/icu.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/icu/icu.c
+
+fts2.o:	$(TOP)/ext/fts2/fts2.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2.c
+
+fts2_hash.o:	$(TOP)/ext/fts2/fts2_hash.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_hash.c
+
+fts2_icu.o:	$(TOP)/ext/fts2/fts2_icu.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_icu.c
+
+fts2_porter.o:	$(TOP)/ext/fts2/fts2_porter.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_porter.c
+
+fts2_tokenizer.o:	$(TOP)/ext/fts2/fts2_tokenizer.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_tokenizer.c
+
+fts2_tokenizer1.o:	$(TOP)/ext/fts2/fts2_tokenizer1.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_tokenizer1.c
+
+fts3.o:	$(TOP)/ext/fts3/fts3.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3.c
+
+fts3_hash.o:	$(TOP)/ext/fts3/fts3_hash.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_hash.c
+
+fts3_icu.o:	$(TOP)/ext/fts3/fts3_icu.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_icu.c
+
+fts3_porter.o:	$(TOP)/ext/fts3/fts3_porter.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_porter.c
+
+fts3_tokenizer.o:	$(TOP)/ext/fts3/fts3_tokenizer.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer.c
+
+fts3_tokenizer1.o:	$(TOP)/ext/fts3/fts3_tokenizer1.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer1.c
+
+
+# Rules for building test programs and for running tests
+#
+tclsqlite3:	$(TOP)/src/tclsqlite.c libsqlite3.a
+	$(TCCX) $(TCL_FLAGS) -DTCLSH=1 -o tclsqlite3 \
+		$(TOP)/src/tclsqlite.c libsqlite3.a $(LIBTCL) $(THREADLIB)
+
+
+# Rules to build the 'testfixture' application.
+#
+TESTFIXTURE_FLAGS  = -DTCLSH=1 -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1
+TESTFIXTURE_FLAGS += -DSQLITE_SERVER=1 -DSQLITE_PRIVATE="" -DSQLITE_CORE 
+
+testfixture$(EXE): $(TESTSRC2) libsqlite3.a $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+		$(TESTSRC) $(TESTSRC2) $(TOP)/src/tclsqlite.c                \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB) libsqlite3.a
+
+amalgamation-testfixture$(EXE): sqlite3.c $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c                  \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB)
+
+fts3-testfixture$(EXE): sqlite3.c fts3amal.c $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+	-DSQLITE_ENABLE_FTS3=1                                               \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c fts3amal.c       \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB)
+
+fulltest:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/all.test
+
+soaktest:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/all.test -soak 1
+
+test:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/quick.test
+
+sqlite3_analyzer$(EXE):	$(TOP)/src/tclsqlite.c sqlite3.c $(TESTSRC) \
+			$(TOP)/tool/spaceanal.tcl
+	sed \
+	  -e '/^#/d' \
+	  -e 's,\\,\\\\,g' \
+	  -e 's,",\\",g' \
+	  -e 's,^,",' \
+	  -e 's,$$,\\n",' \
+	  $(TOP)/tool/spaceanal.tcl >spaceanal_tcl.h
+	$(TCCX) $(TCL_FLAGS)                  $(TESTFIXTURE_FLAGS)                                 \
+		-DTCLSH=2 -DSQLITE_TEST=1 -DSQLITE_DEBUG=1 -DSQLITE_PRIVATE="" \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c                    \
+		-o sqlite3_analyzer$(EXE)                                      \
+		$(LIBTCL) $(THREADLIB)
+
+TEST_EXTENSION = $(SHPREFIX)testloadext.$(SO)
+$(TEST_EXTENSION): $(TOP)/src/test_loadext.c
+	$(MKSHLIB) $(TOP)/src/test_loadext.c -o $(TEST_EXTENSION)
+
+extensiontest: testfixture$(EXE) $(TEST_EXTENSION)
+	./testfixture$(EXE) $(TOP)/test/loadext.test
+
+
+# Standard install and cleanup targets
+#
+install:	sqlite3 libsqlite3.a sqlite3.h
+	mv sqlite3 /usr/bin
+	mv libsqlite3.a /usr/lib
+	mv sqlite3.h /usr/include
+
+clean:	
+	rm -f *.o sqlite3 libsqlite3.a sqlite3.h opcodes.*
+	rm -f lemon lempar.c parse.* sqlite*.tar.gz mkkeywordhash keywordhash.h
+	rm -f $(PUBLISH)
+	rm -f *.da *.bb *.bbg gmon.out
+	rm -rf tsrc target_source
+	rm -f testloadext.dll libtestloadext.so
+	rm -f sqlite3.c fts?amal.c
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkdll.sh b/client/src/thirdparty/sqlite-3.4.2/mkdll.sh
new file mode 100644
index 0000000..ed1e741
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkdll.sh
@@ -0,0 +1,46 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite into a DLL.
+#
+# Two separate DLLs are generated.  "sqlite3.dll" is the core
+# library.  "tclsqlite3.dll" contains the TCL bindings and is the
+# library that is loaded into TCL in order to run SQLite.
+#
+make sqlite3.c
+PATH=$PATH:/opt/mingw/bin
+TCLDIR=/home/drh/tcltk/846/win/846win
+TCLSTUBLIB=$TCLDIR/libtcl84stub.a
+OPTS='-DUSE_TCL_STUBS=1 -DSQLITE_THREADSAFE=1 -DBUILD_sqlite=1 -DOS_WIN=1'
+OPTS="$OPTS -DSQLITE_ENABLE_FTS3=1"
+CC="i386-mingw32msvc-gcc -Os $OPTS -Itsrc -I$TCLDIR"
+NM="i386-mingw32msvc-nm"
+CMD="$CC -c sqlite3.c"
+echo $CMD
+$CMD
+CMD="$CC -c tclsqlite3.c"
+echo $CMD
+$CMD
+echo 'EXPORTS' >tclsqlite3.def
+$NM tclsqlite3.o | grep ' T ' >temp1
+grep '_Init$' temp1 >temp2
+grep '_SafeInit$' temp1 >>temp2
+grep ' T _sqlite3_' temp1 >>temp2
+echo 'EXPORTS' >tclsqlite3.def
+sed 's/^.* T _//' temp2 | sort | uniq >>tclsqlite3.def
+i386-mingw32msvc-dllwrap \
+     --def tclsqlite3.def -v --export-all \
+     --driver-name i386-mingw32msvc-gcc \
+     --dlltool-name i386-mingw32msvc-dlltool \
+     --as i386-mingw32msvc-as \
+     --target i386-mingw32 \
+     -dllname tclsqlite3.dll -lmsvcrt tclsqlite3.o $TCLSTUBLIB
+$NM sqlite3.o | grep ' T ' >temp1
+echo 'EXPORTS' >sqlite3.def
+grep ' _sqlite3_' temp1 | sed 's/^.* _//' >>sqlite3.def
+i386-mingw32msvc-dllwrap \
+     --def sqlite3.def -v --export-all \
+     --driver-name i386-mingw32msvc-gcc \
+     --dlltool-name i386-mingw32msvc-dlltool \
+     --as i386-mingw32msvc-as \
+     --target i386-mingw32 \
+     -dllname sqlite3.dll -lmsvcrt sqlite3.o
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkextu.sh b/client/src/thirdparty/sqlite-3.4.2/mkextu.sh
new file mode 100644
index 0000000..1d96897
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkextu.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite into a shared library on Linux.
+#
+# Two separate shared libraries are generated.  "sqlite3.so" is the core
+# library.  "tclsqlite3.so" contains the TCL bindings and is the
+# library that is loaded into TCL in order to run SQLite.
+#
+CFLAGS=-O2 -Wall
+make fts2amal.c
+echo gcc $CFLAGS -shared fts2amal.c -o fts2.so
+gcc $CFLAGS -shared fts2amal.c -o fts2.so
+strip fts2.so
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkextw.sh b/client/src/thirdparty/sqlite-3.4.2/mkextw.sh
new file mode 100644
index 0000000..3332f91
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkextw.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite extensions into DLLs.
+#
+make fts2amal.c
+PATH=$PATH:/opt/mingw/bin
+OPTS='-DTHREADSAFE=1 -DBUILD_sqlite=1 -DOS_WIN=1'
+CC="i386-mingw32msvc-gcc -O2 $OPTS -Itsrc"
+NM="i386-mingw32msvc-nm"
+CMD="$CC -c fts2amal.c"
+echo $CMD
+$CMD
+echo 'EXPORTS' >fts2.def
+echo 'sqlite3_extension_init' >>fts2.def
+i386-mingw32msvc-dllwrap \
+     --def fts2.def -v --export-all \
+     --driver-name i386-mingw32msvc-gcc \
+     --dlltool-name i386-mingw32msvc-dlltool \
+     --as i386-mingw32msvc-as \
+     --target i386-mingw32 \
+     -dllname fts2.dll -lmsvcrt fts2amal.o
+zip fts2dll.zip fts2.dll fts2.def
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkopcodc.awk b/client/src/thirdparty/sqlite-3.4.2/mkopcodc.awk
new file mode 100644
index 0000000..ec80953
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkopcodc.awk
@@ -0,0 +1,31 @@
+#!/usr/bin/awk -f
+#
+# This AWK script scans the opcodes.h file (which is itself generated by
+# another awk script) and uses the information gleaned to create the
+# opcodes.c source file.
+#
+# Opcodes.c contains strings which are the symbolic names for the various
+# opcodes used by the VDBE.  These strings are used when disassembling a
+# VDBE program during tracing or as a result of the EXPLAIN keyword.
+#
+BEGIN {
+  print "/* Automatically generated.  Do not edit */"
+  print "/* See the mkopcodec.awk script for details. */"
+  printf "#if !defined(SQLITE_OMIT_EXPLAIN)"
+  printf    " || !defined(NDEBUG)"
+  printf    " || defined(VDBE_PROFILE)"
+  print     " || defined(SQLITE_DEBUG)"
+  print "const char *sqlite3OpcodeName(int i){"
+  print " static const char *const azName[] = { \"?\","
+}
+/define OP_/ {
+  sub("OP_","",$2)
+  i++
+  printf "     /* %3d */ \"%s\",\n", $3, $2
+}
+END {
+  print "  };"
+  print "  return azName[i];"
+  print "}"
+  print "#endif"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkopcodec.awk b/client/src/thirdparty/sqlite-3.4.2/mkopcodec.awk
new file mode 100644
index 0000000..ec80953
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkopcodec.awk
@@ -0,0 +1,31 @@
+#!/usr/bin/awk -f
+#
+# This AWK script scans the opcodes.h file (which is itself generated by
+# another awk script) and uses the information gleaned to create the
+# opcodes.c source file.
+#
+# Opcodes.c contains strings which are the symbolic names for the various
+# opcodes used by the VDBE.  These strings are used when disassembling a
+# VDBE program during tracing or as a result of the EXPLAIN keyword.
+#
+BEGIN {
+  print "/* Automatically generated.  Do not edit */"
+  print "/* See the mkopcodec.awk script for details. */"
+  printf "#if !defined(SQLITE_OMIT_EXPLAIN)"
+  printf    " || !defined(NDEBUG)"
+  printf    " || defined(VDBE_PROFILE)"
+  print     " || defined(SQLITE_DEBUG)"
+  print "const char *sqlite3OpcodeName(int i){"
+  print " static const char *const azName[] = { \"?\","
+}
+/define OP_/ {
+  sub("OP_","",$2)
+  i++
+  printf "     /* %3d */ \"%s\",\n", $3, $2
+}
+END {
+  print "  };"
+  print "  return azName[i];"
+  print "}"
+  print "#endif"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkopcodeh.awk b/client/src/thirdparty/sqlite-3.4.2/mkopcodeh.awk
new file mode 100644
index 0000000..796a7af
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkopcodeh.awk
@@ -0,0 +1,157 @@
+#!/usr/bin/awk -f
+#
+# Generate the file opcodes.h.
+#
+# This AWK script scans a concatenation of the parse.h output file from the
+# parser and the vdbe.c source file in order to generate the opcodes numbers
+# for all opcodes.  
+#
+# The lines of the vdbe.c that we are interested in are of the form:
+#
+#       case OP_aaaa:      /* same as TK_bbbbb */
+#
+# The TK_ comment is optional.  If it is present, then the value assigned to
+# the OP_ is the same as the TK_ value.  If missing, the OP_ value is assigned
+# a small integer that is different from every other OP_ value.
+#
+# We go to the trouble of making some OP_ values the same as TK_ values
+# as an optimization.  During parsing, things like expression operators
+# are coded with TK_ values such as TK_ADD, TK_DIVIDE, and so forth.  Later
+# during code generation, we need to generate corresponding opcodes like
+# OP_Add and OP_Divide.  By making TK_ADD==OP_Add and TK_DIVIDE==OP_Divide,
+# code to translate from one to the other is avoided.  This makes the
+# code generator run (infinitesimally) faster and more importantly it makes
+# the library footprint smaller.
+#
+# This script also scans for lines of the form:
+#
+#       case OP_aaaa:       /* no-push */
+#
+# When the no-push comment is found on an opcode, it means that that
+# opcode does not leave a result on the stack.  By identifying which
+# opcodes leave results on the stack it is possible to determine a
+# much smaller upper bound on the size of the stack.  This allows
+# a smaller stack to be allocated, which is important to embedded
+# systems with limited memory space.  This script generates a series
+# of "NOPUSH_MASK" defines that contain bitmaps of opcodes that leave
+# results on the stack.  The NOPUSH_MASK defines are used in vdbeaux.c
+# to help determine the maximum stack size.
+#
+
+
+# Remember the TK_ values from the parse.h file
+/^#define TK_/ {
+  tk[$2] = 0+$3
+}
+
+# Scan for "case OP_aaaa:" lines in the vdbe.c file
+/^case OP_/ {
+  name = $2
+  sub(/:/,"",name)
+  sub("\r","",name)
+  op[name] = -1
+  jump[name] = 0
+  out2_prerelease[name] = 0
+  in1[name] = 0
+  in2[name] = 0
+  in3[name] = 0
+  out3[name] = 0
+  for(i=3; i<NF; i++){
+    if($i=="same" && $(i+1)=="as"){
+      sym = $(i+2)
+      sub(/,/,"",sym)
+      op[name] = tk[sym]
+      used[op[name]] = 1
+      sameas[op[name]] = sym
+    }
+    x = $i
+    sub(",","",x)
+    if(x=="jump"){
+      jump[name] = 1
+    }else if(x=="out2-prerelease"){
+      out2_prerelease[name] = 1
+    }else if(x=="in1"){
+      in1[name] = 1
+    }else if(x=="in2"){
+      in2[name] = 1
+    }else if(x=="in3"){
+      in3[name] = 1
+    }else if(x=="out3"){
+      out3[name] = 1
+    }
+  }
+}
+
+# Assign numbers to all opcodes and output the result.
+END {
+  cnt = 0
+  max = 0
+  print "/* Automatically generated.  Do not edit */"
+  print "/* See the mkopcodeh.awk script for details */"
+  op["OP_Noop"] = -1;
+  op["OP_Explain"] = -1;
+  for(name in op){
+    if( op[name]<0 ){
+      cnt++
+      while( used[cnt] ) cnt++
+      op[name] = cnt
+    }
+    used[op[name]] = 1;
+    if( op[name]>max ) max = op[name]
+    printf "#define %-25s %15d", name, op[name]
+    if( sameas[op[name]] ) {
+      printf "   /* same as %-12s*/", sameas[op[name]]
+    } 
+    printf "\n"
+
+  }
+  seenUnused = 0;
+  for(i=1; i<max; i++){
+    if( !used[i] ){
+      if( !seenUnused ){
+        printf "\n/* The following opcode values are never used */\n"
+        seenUnused = 1
+      }
+      printf "#define %-25s %15d\n", sprintf( "OP_NotUsed_%-3d", i ), i
+    }
+  }
+
+  # Generate the bitvectors:
+  #
+  #  bit 0:     jump
+  #  bit 1:     pushes a result onto stack
+  #  bit 2:     output to p1.  release p1 before opcode runs
+  #
+  for(i=0; i<=max; i++) bv[i] = 0;
+  for(name in op){
+    x = op[name]
+    a0 = a1 = a2 = a3 = a4 = a5 = a6 = a7 = 0
+    # a8 = a9 = a10 = a11 = a12 = a13 = a14 = a15 = 0
+    if( jump[name] ) a0 = 1;
+    if( out2_prerelease[name] ) a1 = 2;
+    if( in1[name] ) a2 = 4;
+    if( in2[name] ) a3 = 8;
+    if( in3[name] ) a4 = 16;
+    if( out3[name] ) a5 = 32;
+    # bv[x] = a0+a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
+    bv[x] = a0+a1+a2+a3+a4+a5+a6+a7;
+  }
+  print "\n"
+  print "/* Properties such as \"out2\" or \"jump\" that are specified in"
+  print "** comments following the \"case\" for each opcode in the vdbe.c"
+  print "** are encoded into bitvectors as follows:"
+  print "*/"
+  print "#define OPFLG_JUMP            0x0001  /* jump:  P2 holds jmp target */"
+  print "#define OPFLG_OUT2_PRERELEASE 0x0002  /* out2-prerelease: */"
+  print "#define OPFLG_IN1             0x0004  /* in1:   P1 is an input */"
+  print "#define OPFLG_IN2             0x0008  /* in2:   P2 is an input */"
+  print "#define OPFLG_IN3             0x0010  /* in3:   P3 is an input */"
+  print "#define OPFLG_OUT3            0x0020  /* out3:  P3 is an output */"
+  print "#define OPFLG_INITIALIZER {\\"
+  for(i=0; i<=max; i++){
+    if( i%8==0 ) printf("/* %3d */",i)
+    printf " 0x%02x,", bv[i]
+    if( i%8==7 ) printf("\\\n");
+  }
+  print "}"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/mkso.sh b/client/src/thirdparty/sqlite-3.4.2/mkso.sh
new file mode 100644
index 0000000..9050d74
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/mkso.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite into a shared library on Linux.
+#
+# Two separate shared libraries are generated.  "sqlite3.so" is the core
+# library.  "tclsqlite3.so" contains the TCL bindings and is the
+# library that is loaded into TCL in order to run SQLite.
+#
+make target_source
+cd tsrc
+rm shell.c
+TCLDIR=/home/drh/tcltk/846/linux/846linux
+TCLSTUBLIB=$TCLDIR/libtclstub8.4g.a
+OPTS='-DUSE_TCL_STUBS=1 -DNDEBUG=1 -DHAVE_DLOPEN=1'
+for i in *.c; do
+  if test $i != 'keywordhash.c'; then
+    CMD="cc -fPIC $OPTS -O2 -I. -I$TCLDIR -c $i"
+    echo $CMD
+    $CMD
+  fi
+done
+echo gcc -shared *.o $TCLSTUBLIB -o tclsqlite3.so
+gcc -shared *.o $TCLSTUBLIB -o tclsqlite3.so
+strip tclsqlite3.so
+rm tclsqlite.c tclsqlite.o
+echo gcc -shared *.o -o sqlite3.so
+gcc -shared *.o -o sqlite3.so
+strip sqlite3.so
+cd ..
diff --git a/client/src/thirdparty/sqlite-3.4.2/notesDOS.txt b/client/src/thirdparty/sqlite-3.4.2/notesDOS.txt
new file mode 100644
index 0000000..72b1e84
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/notesDOS.txt
@@ -0,0 +1,18 @@
+This is SQLite-3.5.6 compiled with DJGPP
+
+SQLite is a small SQL database which you can link with your application program.
+For details see: www.sqlite.org
+
+The binaries sqlite3.exe and libsqlite3.a are in the examples directory. The
+sqlite3.exe is a tool to generate and manipulate databases, libsqlite3.a is
+the library to link with your application program.
+
+Otherwise this directory contains the source for SQLite-3.5.6.
+
+Compile with:
+sh configure --disable-tcl --disable-threadsafe
+make
+
+I tested many versions of SQLite and this does work best with DOS.
+
+20th Feb. 2013 Georg Potthast
diff --git a/client/src/thirdparty/sqlite-3.4.2/publish.sh b/client/src/thirdparty/sqlite-3.4.2/publish.sh
new file mode 100644
index 0000000..138f3d9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/publish.sh
@@ -0,0 +1,132 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite and package everything up
+# so that it is ready to move to the SQLite website.
+#
+
+# Set srcdir to the name of the directory that contains the publish.sh
+# script.
+#
+srcdir=`echo "$0" | sed 's%\(^.*\)/[^/][^/]*$%\1%'`
+
+# Get the makefile.
+#
+cp $srcdir/Makefile.linux-gcc ./Makefile
+chmod +x $srcdir/install-sh
+
+# Get the current version number - needed to help build filenames
+#
+VERS=`cat $srcdir/VERSION`
+VERSW=`sed 's/\./_/g' $srcdir/VERSION`
+echo "VERSIONS: $VERS $VERSW"
+
+# Start by building an sqlite shell for linux.
+#
+make clean
+make sqlite3.c
+CFLAGS="-Os -DSQLITE_ENABLE_FTS3=1 -DSQLITE_THREADSAFE=0"
+echo '***** '"COMPILING sqlite3-$VERS.bin..."
+gcc $CFLAGS -Itsrc sqlite3.c tsrc/shell.c -o sqlite3 -ldl
+strip sqlite3
+mv sqlite3 sqlite3-$VERS.bin
+gzip sqlite3-$VERS.bin
+chmod 644 sqlite3-$VERS.bin.gz
+mv sqlite3-$VERS.bin.gz doc
+
+# Build a source archive useful for windows.
+#
+make target_source
+cd tsrc
+echo '***** BUILDING preprocessed source archives'
+rm fts[12]* icu*
+rm -f ../doc/sqlite-source-$VERSW.zip
+zip ../doc/sqlite-source-$VERSW.zip *
+cd ..
+cp tsrc/sqlite3.h tsrc/sqlite3ext.h .
+pwd
+zip doc/sqlite-amalgamation-$VERSW.zip sqlite3.c sqlite3.h sqlite3ext.h
+
+# Build the sqlite.so and tclsqlite.so shared libraries
+# under Linux
+#
+TCLDIR=/home/drh/tcltk/846/linux/846linux
+TCLSTUBLIB=$TCLDIR/libtclstub8.4g.a
+CFLAGS="-Os -DSQLITE_ENABLE_FTS3=1 -DHAVE_LOCALTIME_R=1 -DHAVE_GMTIME_R=1"
+echo '***** BUILDING shared libraries for linux'
+gcc $CFLAGS -shared tclsqlite3.c $TCLSTUBLIB -o tclsqlite3.so -lpthread
+strip tclsqlite3.so
+chmod 644 tclsqlite3.so
+mv tclsqlite3.so tclsqlite-$VERS.so
+gzip tclsqlite-$VERS.so
+mv tclsqlite-$VERS.so.gz doc
+gcc $CFLAGS -shared sqlite3.c -o sqlite3.so -lpthread
+strip sqlite3.so
+chmod 644 sqlite3.so
+mv sqlite3.so sqlite-$VERS.so
+gzip sqlite-$VERS.so
+mv sqlite-$VERS.so.gz doc
+
+
+# Build the tclsqlite3.dll and sqlite3.dll shared libraries.
+#
+. $srcdir/mkdll.sh
+echo '***** PACKAGING shared libraries for windows'
+echo zip doc/tclsqlite-$VERSW.zip tclsqlite3.dll
+zip doc/tclsqlite-$VERSW.zip tclsqlite3.dll
+echo zip doc/sqlitedll-$VERSW.zip sqlite3.dll sqlite3.def
+zip doc/sqlitedll-$VERSW.zip sqlite3.dll sqlite3.def
+
+# Build the sqlite.exe executable for windows.
+#
+OPTS='-DSTATIC_BUILD=1 -DNDEBUG=1 -DSQLITE_THREADSAFE=0'
+OPTS="$OPTS -DSQLITE_ENABLE_FTS3=1"
+i386-mingw32msvc-gcc -Os $OPTS -Itsrc -I$TCLDIR sqlite3.c tsrc/shell.c \
+      -o sqlite3.exe
+zip doc/sqlite-$VERSW.zip sqlite3.exe
+
+# Construct a tarball of the source tree
+#
+echo '***** BUILDING source archive'
+ORIGIN=`pwd`
+cd $srcdir
+cd ..
+mv sqlite sqlite-$VERS
+EXCLUDE=`find sqlite-$VERS -print | egrep (CVS|www/|art/|doc/|contrib/) | sed 's,^, --exclude ,'`
+tar czf $ORIGIN/doc/sqlite-$VERS.tar.gz $EXCLUDE sqlite-$VERS
+mv sqlite-$VERS sqlite
+cd $ORIGIN
+
+#
+# Build RPMS (binary) and Source RPM
+#
+
+# Make sure we are properly setup to build RPMs
+#
+echo "%HOME %{expand:%%(cd; pwd)}" > $HOME/.rpmmacros
+echo "%_topdir %{HOME}/rpm" >> $HOME/.rpmmacros
+mkdir $HOME/rpm
+mkdir $HOME/rpm/BUILD
+mkdir $HOME/rpm/SOURCES
+mkdir $HOME/rpm/RPMS
+mkdir $HOME/rpm/SRPMS
+mkdir $HOME/rpm/SPECS
+
+# create the spec file from the template
+sed s/SQLITE_VERSION/$VERS/g $srcdir/spec.template > $HOME/rpm/SPECS/sqlite.spec
+
+# copy the source tarball to the rpm directory
+cp doc/sqlite-$VERS.tar.gz $HOME/rpm/SOURCES/.
+
+# build all the rpms
+rpm -ba $HOME/rpm/SPECS/sqlite.spec >& rpm-$vers.log
+
+# copy the RPMs into the build directory.
+mv $HOME/rpm/RPMS/i386/sqlite*-$vers*.rpm doc
+mv $HOME/rpm/SRPMS/sqlite-$vers*.rpm doc
+
+# Build the website
+#
+#cp $srcdir/../historical/* doc
+#make doc
+#cd doc
+#chmod 644 *.gz
diff --git a/client/src/thirdparty/sqlite-3.4.2/publish_osx.sh b/client/src/thirdparty/sqlite-3.4.2/publish_osx.sh
new file mode 100644
index 0000000..508b623
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/publish_osx.sh
@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# This script is used to compile SQLite and package everything up
+# so that it is ready to move to the SQLite website.
+#
+
+# Set srcdir to the name of the directory that contains the publish.sh
+# script.
+#
+srcdir=`echo "$0" | sed 's%\(^.*\)/[^/][^/]*$%\1%'`
+
+# Get the makefile.
+#
+cp $srcdir/Makefile.linux-gcc ./Makefile
+chmod +x $srcdir/install-sh
+
+# Get the current version number - needed to help build filenames
+#
+VERS=`cat $srcdir/VERSION`
+VERSW=`sed 's/\./_/g' $srcdir/VERSION`
+echo "VERSIONS: $VERS $VERSW"
+
+# Start by building an sqlite shell for linux.
+#
+make clean
+make sqlite3.c
+CFLAGS="-Os -DSQLITE_ENABLE_FTS3=1 -DSQLITE_THREADSAFE=0"
+NAME=sqlite3-$VERS-osx-x86.bin
+echo '***** '"COMPILING $NAME..."
+gcc $CFLAGS -Itsrc sqlite3.c tsrc/shell.c -o $NAME -ldl
+strip $NAME
+chmod 644 $NAME
+gzip $NAME
+mkdir -p doc
+mv $NAME.gz doc
diff --git a/client/src/thirdparty/sqlite-3.4.2/spec.template b/client/src/thirdparty/sqlite-3.4.2/spec.template
new file mode 100644
index 0000000..24c5eae
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/spec.template
@@ -0,0 +1,62 @@
+%define name sqlite
+%define version SQLITE_VERSION
+%define release 1
+
+Name: %{name}
+Summary: SQLite is a C library that implements an embeddable SQL database engine
+Version: %{version}
+Release: %{release}
+Source: %{name}-%{version}.tar.gz
+Group: System/Libraries
+URL: http://www.hwaci.com/sw/sqlite/
+License: Public Domain
+BuildRoot: %{_tmppath}/%{name}-%{version}-root
+
+%description
+SQLite is a C library that implements an embeddable SQL database engine.
+Programs that link with the SQLite library can have SQL database access
+without running a separate RDBMS process. The distribution comes with a
+standalone command-line access program (sqlite) that can be used to
+administer an SQLite database and which serves as an example of how to
+use the SQLite library.
+
+%package -n %{name}-devel
+Summary: Header files and libraries for developing apps which will use sqlite
+Group: Development/C
+Requires: %{name} = %{version}-%{release}
+
+%description -n %{name}-devel
+The sqlite-devel package contains the header files and libraries needed
+to develop programs that use the sqlite database library.
+
+%prep
+%setup -q -n %{name}
+
+%build
+CFLAGS="%optflags -DNDEBUG=1" CXXFLAGS="%optflags -DNDEBUG=1" ./configure --prefix=%{_prefix}
+
+make
+make doc
+
+%install
+install -d $RPM_BUILD_ROOT/%{_prefix}
+install -d $RPM_BUILD_ROOT/%{_prefix}/bin
+install -d $RPM_BUILD_ROOT/%{_prefix}/include
+install -d $RPM_BUILD_ROOT/%{_prefix}/lib
+make install prefix=$RPM_BUILD_ROOT/%{_prefix}
+
+%clean
+rm -fr $RPM_BUILD_ROOT
+
+%files
+%defattr(-, root, root)
+%{_libdir}/*.so*
+%{_bindir}/*
+
+%files -n %{name}-devel
+%defattr(-, root, root)
+%{_libdir}/pkgconfig/sqlite3.pc
+%{_libdir}/*.a
+%{_libdir}/*.la
+%{_includedir}/*
+%doc doc/*
diff --git a/client/src/thirdparty/sqlite-3.4.2/sqlite.pc.in b/client/src/thirdparty/sqlite-3.4.2/sqlite.pc.in
new file mode 100644
index 0000000..16ed41c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/sqlite.pc.in
@@ -0,0 +1,12 @@
+# Package Information for pkg-config
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: SQLite
+Description: SQL database engine
+Version: @VERSION@
+Libs: -L${libdir} -lsqlite
+Cflags: -I${includedir}
diff --git a/client/src/thirdparty/sqlite-3.4.2/sqlite3.1 b/client/src/thirdparty/sqlite-3.4.2/sqlite3.1
new file mode 100644
index 0000000..785995b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/sqlite3.1
@@ -0,0 +1,229 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.\" First parameter, NAME, should be all caps
+.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
+.\" other parameters are allowed: see man(7), man(1)
+.TH SQLITE3 1 "Mon Apr 15 23:49:17 2002"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+.B sqlite3 
+\- A command line interface for SQLite version 3
+
+.SH SYNOPSIS
+.B sqlite3
+.RI [ options ]
+.RI [ databasefile ]
+.RI [ SQL ]
+
+.SH SUMMARY
+.PP
+.B sqlite3
+is a terminal-based front-end to the SQLite library that can evaluate
+queries interactively and display the results in multiple formats.
+.B sqlite3
+can also be used within shell scripts and other applications to provide
+batch processing features.
+
+.SH DESCRIPTION
+To start a
+.B sqlite3
+interactive session, invoke the
+.B sqlite3
+command and optionally provide the name of a database file.  If the
+database file does not exist, it will be created.  If the database file
+does exist, it will be opened.
+
+For example, to create a new database file named "mydata.db", create
+a table named "memos" and insert a couple of records into that table:
+.sp
+$ 
+.B sqlite3 mydata.db
+.br
+SQLite version 3.1.3
+.br
+Enter ".help" for instructions
+.br
+sqlite>
+.B create table memos(text, priority INTEGER);
+.br
+sqlite>
+.B insert into memos values('deliver project description', 10);
+.br
+sqlite>
+.B insert into memos values('lunch with Christine', 100);
+.br
+sqlite>
+.B select * from memos;
+.br
+deliver project description|10
+.br
+lunch with Christine|100
+.br
+sqlite>
+.sp
+
+If no database name is supplied, the ATTACH sql command can be used
+to attach to existing or create new database files.  ATTACH can also
+be used to attach to multiple databases within the same interactive
+session.  This is useful for migrating data between databases,
+possibly changing the schema along the way.
+
+Optionally, a SQL statement or set of SQL statements can be supplied as
+a single argument.  Multiple statements should be separated by
+semi-colons.
+
+For example:
+.sp
+$ 
+.B sqlite3 -line mydata.db 'select * from memos where priority > 20;'
+.br
+    text = lunch with Christine
+.br
+priority = 100
+.br
+.sp
+
+.SS SQLITE META-COMMANDS
+.PP
+The interactive interpreter offers a set of meta-commands that can be
+used to control the output format, examine the currently attached
+database files, or perform administrative operations upon the
+attached databases (such as rebuilding indices).   Meta-commands are
+always prefixed with a dot (.).
+
+A list of available meta-commands can be viewed at any time by issuing
+the '.help' command.  For example:
+.sp
+sqlite>
+.B .help
+.nf
+.cc |
+.databases             List names and files of attached databases
+.dump ?TABLE? ...      Dump the database in an SQL text format
+.echo ON|OFF           Turn command echo on or off
+.exit                  Exit this program
+.explain ON|OFF        Turn output mode suitable for EXPLAIN on or off.
+.header(s) ON|OFF      Turn display of headers on or off
+.help                  Show this message
+.import FILE TABLE     Import data from FILE into TABLE
+.indices TABLE         Show names of all indices on TABLE
+.mode MODE ?TABLE?     Set output mode where MODE is one of:
+                         csv      Comma-separated values
+                         column   Left-aligned columns.  (See .width)
+                         html     HTML <table> code
+                         insert   SQL insert statements for TABLE
+                         line     One value per line
+                         list     Values delimited by .separator string
+                         tabs     Tab-separated values
+                         tcl      TCL list elements
+.nullvalue STRING      Print STRING in place of NULL values
+.output FILENAME       Send output to FILENAME
+.output stdout         Send output to the screen
+.prompt MAIN CONTINUE  Replace the standard prompts
+.quit                  Exit this program
+.read FILENAME         Execute SQL in FILENAME
+.schema ?TABLE?        Show the CREATE statements
+.separator STRING      Change separator used by output mode and .import
+.show                  Show the current values for various settings
+.tables ?PATTERN?      List names of tables matching a LIKE pattern
+.timeout MS            Try opening locked tables for MS milliseconds
+.width NUM NUM ...     Set column widths for "column" mode
+sqlite>
+|cc .
+.sp
+.fi
+
+.SH OPTIONS
+.B sqlite3
+has the following options:
+.TP
+.BI \-init\ file
+Read and execute commands from
+.I file
+, which can contain a mix of SQL statements and meta-commands.
+.TP
+.B \-echo
+Print commands before execution.
+.TP
+.B \-[no]header
+Turn headers on or off.
+.TP
+.B \-column
+Query results will be displayed in a table like form, using
+whitespace characters to separate the columns and align the
+output.
+.TP
+.B \-html
+Query results will be output as simple HTML tables.
+.TP
+.B \-line
+Query results will be displayed with one value per line, rows
+separated by a blank line.  Designed to be easily parsed by
+scripts or other programs
+.TP
+.B \-list
+Query results will be displayed with the separator (|, by default)
+character between each field value.  The default.
+.TP
+.BI \-separator\  separator
+Set output field separator.  Default is '|'.
+.TP
+.BI \-nullvalue\  string
+Set string used to represent NULL values.  Default is ''
+(empty string).
+.TP
+.B \-version
+Show SQLite version.
+.TP
+.B \-help
+Show help on options and exit.
+
+
+.SH INIT FILE
+.B sqlite3
+reads an initialization file to set the configuration of the
+interactive environment.  Throughout initialization, any previously
+specified setting can be overridden.  The sequence of initialization is
+as follows:
+
+o The default configuration is established as follows:
+
+.sp
+.nf
+.cc |
+mode            = LIST
+separator       = "|"
+main prompt     = "sqlite> "
+continue prompt = "   ...> "
+|cc .
+.sp
+.fi
+
+o If the file 
+.B ~/.sqliterc
+exists, it is processed first.
+can be found in the user's home directory, it is
+read and processed.  It should generally only contain meta-commands.
+
+o If the -init option is present, the specified file is processed.
+
+o All other command line options are processed.
+
+.SH SEE ALSO
+http://www.sqlite.org/
+.br
+The sqlite-doc package
+.SH AUTHOR
+This manual page was originally written by Andreas Rottmann
+<rotty@debian.org>, for the Debian GNU/Linux system (but may be used
+by others).   It was subsequently revised by Bill Bumgarner <bbum@mac.com>.
diff --git a/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc b/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc
new file mode 100644
index 0000000..9eea007
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc
@@ -0,0 +1,13 @@
+# Package Information for pkg-config
+
+prefix=/dev/env/DJDIR
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: SQLite
+Description: SQL database engine
+Version: 3.5
+Libs: -L${libdir} -lsqlite3
+Libs.private: -lpthread
+Cflags: -I${includedir}
diff --git a/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc.in b/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc.in
new file mode 100644
index 0000000..2de6eff
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/sqlite3.pc.in
@@ -0,0 +1,13 @@
+# Package Information for pkg-config
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: SQLite
+Description: SQL database engine
+Version: @VERSION@
+Libs: -L${libdir} -lsqlite3
+Libs.private: -lpthread
+Cflags: -I${includedir}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/alter.c b/client/src/thirdparty/sqlite-3.4.2/src/alter.c
new file mode 100644
index 0000000..63b0bd7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/alter.c
@@ -0,0 +1,630 @@
+/*
+** 2005 February 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.
+**
+*************************************************************************
+** This file contains C code routines that used to generate VDBE code
+** that implements the ALTER TABLE command.
+**
+** $Id: alter.c,v 1.41 2008/01/25 15:04:48 drh 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.
+*/
+#ifndef SQLITE_OMIT_ALTERTABLE
+
+
+/*
+** This function is used by SQL generated to implement the 
+** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
+** CREATE INDEX command. The second is a table name. The table name in 
+** the CREATE TABLE or CREATE INDEX statement is replaced with the third
+** argument and the result returned. Examples:
+**
+** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
+**     -> 'CREATE TABLE def(a, b, c)'
+**
+** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
+**     -> 'CREATE INDEX i ON def(a, b, c)'
+*/
+static void renameTableFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char const *zSql = sqlite3_value_text(argv[0]);
+  unsigned char const *zTableName = sqlite3_value_text(argv[1]);
+
+  int token;
+  Token tname;
+  unsigned char const *zCsr = zSql;
+  int len = 0;
+  char *zRet;
+
+  sqlite3 *db = sqlite3_user_data(context);
+
+  /* The principle used to locate the table name in the CREATE TABLE 
+  ** statement is that the table name is the first token that is immediatedly
+  ** followed by a left parenthesis - TK_LP - or "USING" TK_USING.
+  */
+  if( zSql ){
+    do {
+      if( !*zCsr ){
+        /* Ran out of input before finding an opening bracket. Return NULL. */
+        return;
+      }
+
+      /* Store the token that zCsr points to in tname. */
+      tname.z = zCsr;
+      tname.n = len;
+
+      /* Advance zCsr to the next token. Store that token type in 'token',
+      ** and its length in 'len' (to be used next iteration of this loop).
+      */
+      do {
+        zCsr += len;
+        len = sqlite3GetToken(zCsr, &token);
+      } while( token==TK_SPACE );
+      assert( len>0 );
+    } while( token!=TK_LP && token!=TK_USING );
+
+    zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql, 
+       zTableName, tname.z+tname.n);
+    sqlite3_result_text(context, zRet, -1, sqlite3_free);
+  }
+}
+
+#ifndef SQLITE_OMIT_TRIGGER
+/* This function is used by SQL generated to implement the
+** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER 
+** statement. The second is a table name. The table name in the CREATE 
+** TRIGGER statement is replaced with the third argument and the result 
+** returned. This is analagous to renameTableFunc() above, except for CREATE
+** TRIGGER, not CREATE INDEX and CREATE TABLE.
+*/
+static void renameTriggerFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char const *zSql = sqlite3_value_text(argv[0]);
+  unsigned char const *zTableName = sqlite3_value_text(argv[1]);
+
+  int token;
+  Token tname;
+  int dist = 3;
+  unsigned char const *zCsr = zSql;
+  int len = 0;
+  char *zRet;
+
+  sqlite3 *db = sqlite3_user_data(context);
+
+  /* The principle used to locate the table name in the CREATE TRIGGER 
+  ** statement is that the table name is the first token that is immediatedly
+  ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
+  ** of TK_WHEN, TK_BEGIN or TK_FOR.
+  */
+  if( zSql ){
+    do {
+
+      if( !*zCsr ){
+        /* Ran out of input before finding the table name. Return NULL. */
+        return;
+      }
+
+      /* Store the token that zCsr points to in tname. */
+      tname.z = zCsr;
+      tname.n = len;
+
+      /* Advance zCsr to the next token. Store that token type in 'token',
+      ** and its length in 'len' (to be used next iteration of this loop).
+      */
+      do {
+        zCsr += len;
+        len = sqlite3GetToken(zCsr, &token);
+      }while( token==TK_SPACE );
+      assert( len>0 );
+
+      /* Variable 'dist' stores the number of tokens read since the most
+      ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN 
+      ** token is read and 'dist' equals 2, the condition stated above
+      ** to be met.
+      **
+      ** Note that ON cannot be a database, table or column name, so
+      ** there is no need to worry about syntax like 
+      ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
+      */
+      dist++;
+      if( token==TK_DOT || token==TK_ON ){
+        dist = 0;
+      }
+    } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
+
+    /* Variable tname now contains the token that is the old table-name
+    ** in the CREATE TRIGGER statement.
+    */
+    zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql, 
+       zTableName, tname.z+tname.n);
+    sqlite3_result_text(context, zRet, -1, sqlite3_free);
+  }
+}
+#endif   /* !SQLITE_OMIT_TRIGGER */
+
+/*
+** Register built-in functions used to help implement ALTER TABLE
+*/
+void sqlite3AlterFunctions(sqlite3 *db){
+  static const struct {
+     char *zName;
+     signed char nArg;
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
+  } aFuncs[] = {
+    { "sqlite_rename_table",    2, renameTableFunc},
+#ifndef SQLITE_OMIT_TRIGGER
+    { "sqlite_rename_trigger",  2, renameTriggerFunc},
+#endif
+  };
+  int i;
+
+  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
+    sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
+        SQLITE_UTF8, (void *)db, aFuncs[i].xFunc, 0, 0);
+  }
+}
+
+/*
+** Generate the text of a WHERE expression which can be used to select all
+** temporary triggers on table pTab from the sqlite_temp_master table. If
+** table pTab has no temporary triggers, or is itself stored in the 
+** temporary database, NULL is returned.
+*/
+static char *whereTempTriggers(Parse *pParse, Table *pTab){
+  Trigger *pTrig;
+  char *zWhere = 0;
+  char *tmp = 0;
+  const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
+
+  /* If the table is not located in the temp-db (in which case NULL is 
+  ** returned, loop through the tables list of triggers. For each trigger
+  ** that is not part of the temp-db schema, add a clause to the WHERE 
+  ** expression being built up in zWhere.
+  */
+  if( pTab->pSchema!=pTempSchema ){
+    sqlite3 *db = pParse->db;
+    for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){
+      if( pTrig->pSchema==pTempSchema ){
+        if( !zWhere ){
+          zWhere = sqlite3MPrintf(db, "name=%Q", pTrig->name);
+        }else{
+          tmp = zWhere;
+          zWhere = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, pTrig->name);
+          sqlite3_free(tmp);
+        }
+      }
+    }
+  }
+  return zWhere;
+}
+
+/*
+** Generate code to drop and reload the internal representation of table
+** pTab from the database, including triggers and temporary triggers.
+** Argument zName is the name of the table in the database schema at
+** the time the generated code is executed. This can be different from
+** pTab->zName if this function is being called to code part of an 
+** "ALTER TABLE RENAME TO" statement.
+*/
+static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
+  Vdbe *v;
+  char *zWhere;
+  int iDb;                   /* Index of database containing pTab */
+#ifndef SQLITE_OMIT_TRIGGER
+  Trigger *pTrig;
+#endif
+
+  v = sqlite3GetVdbe(pParse);
+  if( !v ) return;
+  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  assert( iDb>=0 );
+
+#ifndef SQLITE_OMIT_TRIGGER
+  /* Drop any table triggers from the internal schema. */
+  for(pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext){
+    int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
+    assert( iTrigDb==iDb || iTrigDb==1 );
+    sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->name, 0);
+  }
+#endif
+
+  /* Drop the table and index from the internal schema */
+  sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
+
+  /* Reload the table, index and permanent trigger schemas. */
+  zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
+  if( !zWhere ) return;
+  sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
+
+#ifndef SQLITE_OMIT_TRIGGER
+  /* Now, if the table is not stored in the temp database, reload any temp 
+  ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined. 
+  */
+  if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
+    sqlite3VdbeAddOp4(v, OP_ParseSchema, 1, 0, 0, zWhere, P4_DYNAMIC);
+  }
+#endif
+}
+
+/*
+** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" 
+** command. 
+*/
+void sqlite3AlterRenameTable(
+  Parse *pParse,            /* Parser context. */
+  SrcList *pSrc,            /* The table to rename. */
+  Token *pName              /* The new table name. */
+){
+  int iDb;                  /* Database that contains the table */
+  char *zDb;                /* Name of database iDb */
+  Table *pTab;              /* Table being renamed */
+  char *zName = 0;          /* NULL-terminated version of pName */ 
+  sqlite3 *db = pParse->db; /* Database connection */
+  int nTabName;             /* Number of UTF-8 characters in zTabName */
+  const char *zTabName;     /* Original name of the table */
+  Vdbe *v;
+#ifndef SQLITE_OMIT_TRIGGER
+  char *zWhere = 0;         /* Where clause to locate temp triggers */
+#endif
+  int isVirtualRename = 0;  /* True if this is a v-table with an xRename() */
+  
+  if( db->mallocFailed ) goto exit_rename_table;
+  assert( pSrc->nSrc==1 );
+  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
+
+  pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
+  if( !pTab ) goto exit_rename_table;
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  zDb = db->aDb[iDb].zName;
+
+  /* Get a NULL terminated version of the new table name. */
+  zName = sqlite3NameFromToken(db, pName);
+  if( !zName ) goto exit_rename_table;
+
+  /* Check that a table or index named 'zName' does not already exist
+  ** in database iDb. If so, this is an error.
+  */
+  if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
+    sqlite3ErrorMsg(pParse, 
+        "there is already another table or index with this name: %s", zName);
+    goto exit_rename_table;
+  }
+
+  /* Make sure it is not a system table being altered, or a reserved name
+  ** that the table is being renamed to.
+  */
+  if( strlen(pTab->zName)>6 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ){
+    sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
+    goto exit_rename_table;
+  }
+  if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
+    goto exit_rename_table;
+  }
+
+#ifndef SQLITE_OMIT_VIEW
+  if( pTab->pSelect ){
+    sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
+    goto exit_rename_table;
+  }
+#endif
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  /* Invoke the authorization callback. */
+  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
+    goto exit_rename_table;
+  }
+#endif
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
+    goto exit_rename_table;
+  }
+  if( IsVirtual(pTab) && pTab->pMod->pModule->xRename ){
+    isVirtualRename = 1;
+  }
+#endif
+
+  /* Begin a transaction and code the VerifyCookie for database iDb. 
+  ** Then modify the schema cookie (since the ALTER TABLE modifies the
+  ** schema). Open a statement transaction if the table is a virtual
+  ** table.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ){
+    goto exit_rename_table;
+  }
+  sqlite3BeginWriteOperation(pParse, isVirtualRename, iDb);
+  sqlite3ChangeCookie(pParse, iDb);
+
+  /* If this is a virtual table, invoke the xRename() function if
+  ** one is defined. The xRename() callback will modify the names
+  ** of any resources used by the v-table implementation (including other
+  ** SQLite tables) that are identified by the name of the virtual table.
+  */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( isVirtualRename ){
+    int i = ++pParse->nMem;
+    sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
+    sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pTab->pVtab, P4_VTAB);
+  }
+#endif
+
+  /* figure out how many UTF-8 characters are in zName */
+  zTabName = pTab->zName;
+  nTabName = sqlite3Utf8CharLen(zTabName, -1);
+
+  /* Modify the sqlite_master table to use the new table name. */
+  sqlite3NestedParse(pParse,
+      "UPDATE %Q.%s SET "
+#ifdef SQLITE_OMIT_TRIGGER
+          "sql = sqlite_rename_table(sql, %Q), "
+#else
+          "sql = CASE "
+            "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
+            "ELSE sqlite_rename_table(sql, %Q) END, "
+#endif
+          "tbl_name = %Q, "
+          "name = CASE "
+            "WHEN type='table' THEN %Q "
+            "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
+             "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
+            "ELSE name END "
+      "WHERE tbl_name=%Q AND "
+          "(type='table' OR type='index' OR type='trigger');", 
+      zDb, SCHEMA_TABLE(iDb), zName, zName, zName, 
+#ifndef SQLITE_OMIT_TRIGGER
+      zName,
+#endif
+      zName, nTabName, zTabName
+  );
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+  /* If the sqlite_sequence table exists in this database, then update 
+  ** it with the new table name.
+  */
+  if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
+    sqlite3NestedParse(pParse,
+        "UPDATE %Q.sqlite_sequence set name = %Q WHERE name = %Q",
+        zDb, zName, pTab->zName);
+  }
+#endif
+
+#ifndef SQLITE_OMIT_TRIGGER
+  /* If there are TEMP triggers on this table, modify the sqlite_temp_master
+  ** table. Don't do this if the table being ALTERed is itself located in
+  ** the temp database.
+  */
+  if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
+    sqlite3NestedParse(pParse, 
+        "UPDATE sqlite_temp_master SET "
+            "sql = sqlite_rename_trigger(sql, %Q), "
+            "tbl_name = %Q "
+            "WHERE %s;", zName, zName, zWhere);
+    sqlite3_free(zWhere);
+  }
+#endif
+
+  /* Drop and reload the internal table schema. */
+  reloadTableSchema(pParse, pTab, zName);
+
+exit_rename_table:
+  sqlite3SrcListDelete(pSrc);
+  sqlite3_free(zName);
+}
+
+
+/*
+** This function is called after an "ALTER TABLE ... ADD" statement
+** has been parsed. Argument pColDef contains the text of the new
+** column definition.
+**
+** The Table structure pParse->pNewTable was extended to include
+** the new column during parsing.
+*/
+void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
+  Table *pNew;              /* Copy of pParse->pNewTable */
+  Table *pTab;              /* Table being altered */
+  int iDb;                  /* Database number */
+  const char *zDb;          /* Database name */
+  const char *zTab;         /* Table name */
+  char *zCol;               /* Null-terminated column definition */
+  Column *pCol;             /* The new column */
+  Expr *pDflt;              /* Default value for the new column */
+  sqlite3 *db;              /* The database connection; */
+
+  if( pParse->nErr ) return;
+  pNew = pParse->pNewTable;
+  assert( pNew );
+
+  db = pParse->db;
+  assert( sqlite3BtreeHoldsAllMutexes(db) );
+  iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
+  zDb = db->aDb[iDb].zName;
+  zTab = pNew->zName;
+  pCol = &pNew->aCol[pNew->nCol-1];
+  pDflt = pCol->pDflt;
+  pTab = sqlite3FindTable(db, zTab, zDb);
+  assert( pTab );
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  /* Invoke the authorization callback. */
+  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
+    return;
+  }
+#endif
+
+  /* If the default value for the new column was specified with a 
+  ** literal NULL, then set pDflt to 0. This simplifies checking
+  ** for an SQL NULL default below.
+  */
+  if( pDflt && pDflt->op==TK_NULL ){
+    pDflt = 0;
+  }
+
+  /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
+  ** If there is a NOT NULL constraint, then the default value for the
+  ** column must not be NULL.
+  */
+  if( pCol->isPrimKey ){
+    sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
+    return;
+  }
+  if( pNew->pIndex ){
+    sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
+    return;
+  }
+  if( pCol->notNull && !pDflt ){
+    sqlite3ErrorMsg(pParse, 
+        "Cannot add a NOT NULL column with default value NULL");
+    return;
+  }
+
+  /* Ensure the default expression is something that sqlite3ValueFromExpr()
+  ** can handle (i.e. not CURRENT_TIME etc.)
+  */
+  if( pDflt ){
+    sqlite3_value *pVal;
+    if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
+      db->mallocFailed = 1;
+      return;
+    }
+    if( !pVal ){
+      sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
+      return;
+    }
+    sqlite3ValueFree(pVal);
+  }
+
+  /* Modify the CREATE TABLE statement. */
+  zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
+  if( zCol ){
+    char *zEnd = &zCol[pColDef->n-1];
+    while( (zEnd>zCol && *zEnd==';') || isspace(*(unsigned char *)zEnd) ){
+      *zEnd-- = '\0';
+    }
+    sqlite3NestedParse(pParse, 
+        "UPDATE %Q.%s SET "
+          "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
+        "WHERE type = 'table' AND name = %Q", 
+      zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
+      zTab
+    );
+    sqlite3_free(zCol);
+  }
+
+  /* If the default value of the new column is NULL, then set the file
+  ** format to 2. If the default value of the new column is not NULL,
+  ** the file format becomes 3.
+  */
+  sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
+
+  /* Reload the schema of the modified table. */
+  reloadTableSchema(pParse, pTab, pTab->zName);
+}
+
+/*
+** This function is called by the parser after the table-name in
+** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument 
+** pSrc is the full-name of the table being altered.
+**
+** This routine makes a (partial) copy of the Table structure
+** for the table being altered and sets Parse.pNewTable to point
+** to it. Routines called by the parser as the column definition
+** is parsed (i.e. sqlite3AddColumn()) add the new Column data to 
+** the copy. The copy of the Table structure is deleted by tokenize.c 
+** after parsing is finished.
+**
+** Routine sqlite3AlterFinishAddColumn() will be called to complete
+** coding the "ALTER TABLE ... ADD" statement.
+*/
+void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
+  Table *pNew;
+  Table *pTab;
+  Vdbe *v;
+  int iDb;
+  int i;
+  int nAlloc;
+  sqlite3 *db = pParse->db;
+
+  /* Look up the table being altered. */
+  assert( pParse->pNewTable==0 );
+  assert( sqlite3BtreeHoldsAllMutexes(db) );
+  if( db->mallocFailed ) goto exit_begin_add_column;
+  pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
+  if( !pTab ) goto exit_begin_add_column;
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( IsVirtual(pTab) ){
+    sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
+    goto exit_begin_add_column;
+  }
+#endif
+
+  /* Make sure this is not an attempt to ALTER a view. */
+  if( pTab->pSelect ){
+    sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
+    goto exit_begin_add_column;
+  }
+
+  assert( pTab->addColOffset>0 );
+  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+
+  /* Put a copy of the Table struct in Parse.pNewTable for the
+  ** sqlite3AddColumn() function and friends to modify.
+  */
+  pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
+  if( !pNew ) goto exit_begin_add_column;
+  pParse->pNewTable = pNew;
+  pNew->nRef = 1;
+  pNew->nCol = pTab->nCol;
+  assert( pNew->nCol>0 );
+  nAlloc = (((pNew->nCol-1)/8)*8)+8;
+  assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
+  pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
+  pNew->zName = sqlite3DbStrDup(db, pTab->zName);
+  if( !pNew->aCol || !pNew->zName ){
+    db->mallocFailed = 1;
+    goto exit_begin_add_column;
+  }
+  memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
+  for(i=0; i<pNew->nCol; i++){
+    Column *pCol = &pNew->aCol[i];
+    pCol->zName = sqlite3DbStrDup(db, pCol->zName);
+    pCol->zColl = 0;
+    pCol->zType = 0;
+    pCol->pDflt = 0;
+  }
+  pNew->pSchema = db->aDb[iDb].pSchema;
+  pNew->addColOffset = pTab->addColOffset;
+  pNew->nRef = 1;
+
+  /* Begin a transaction and increment the schema cookie.  */
+  sqlite3BeginWriteOperation(pParse, 0, iDb);
+  v = sqlite3GetVdbe(pParse);
+  if( !v ) goto exit_begin_add_column;
+  sqlite3ChangeCookie(pParse, iDb);
+
+exit_begin_add_column:
+  sqlite3SrcListDelete(pSrc);
+  return;
+}
+#endif  /* SQLITE_ALTER_TABLE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/analyze.c b/client/src/thirdparty/sqlite-3.4.2/src/analyze.c
new file mode 100644
index 0000000..4168fe6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/analyze.c
@@ -0,0 +1,425 @@
+/*
+** 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.41 2008/01/25 15:04:49 drh Exp $
+*/
+#ifndef SQLITE_OMIT_ANALYZE
+#include "sqliteInt.h"
+
+/*
+** This routine generates code that opens the sqlite_stat1 table on cursor
+** iStatCur.
+**
+** If the sqlite_stat1 tables does not previously exist, it is created.
+** If it does previously exist, all entires associated with table zWhere
+** are removed.  If zWhere==0 then all entries are removed.
+*/
+static void openStatTable(
+  Parse *pParse,          /* Parsing context */
+  int iDb,                /* The database we are looking in */
+  int iStatCur,           /* Open the sqlite_stat1 table on this cursor */
+  const char *zWhere      /* Delete entries associated with this table */
+){
+  sqlite3 *db = pParse->db;
+  Db *pDb;
+  int iRootPage;
+  int createStat1 = 0;
+  Table *pStat;
+  Vdbe *v = sqlite3GetVdbe(pParse);
+
+  if( v==0 ) return;
+  assert( sqlite3BtreeHoldsAllMutexes(db) );
+  assert( sqlite3VdbeDb(v)==db );
+  pDb = &db->aDb[iDb];
+  if( (pStat = sqlite3FindTable(db, "sqlite_stat1", pDb->zName))==0 ){
+    /* The sqlite_stat1 tables does not exist.  Create it.  
+    ** Note that a side-effect of the CREATE TABLE statement is to leave
+    ** the rootpage of the new table in register pParse->regRoot.  This is
+    ** important because the OpenWrite opcode below will be needing it. */
+    sqlite3NestedParse(pParse,
+      "CREATE TABLE %Q.sqlite_stat1(tbl,idx,stat)",
+      pDb->zName
+    );
+    iRootPage = pParse->regRoot;
+    createStat1 = 1;  /* Cause rootpage to be taken from top of stack */
+  }else if( zWhere ){
+    /* The sqlite_stat1 table exists.  Delete all entries associated with
+    ** the table zWhere. */
+    sqlite3NestedParse(pParse,
+       "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q",
+       pDb->zName, zWhere
+    );
+    iRootPage = pStat->tnum;
+  }else{
+    /* The sqlite_stat1 table already exists.  Delete all rows. */
+    iRootPage = pStat->tnum;
+    sqlite3VdbeAddOp2(v, OP_Clear, pStat->tnum, iDb);
+  }
+
+  /* Open the sqlite_stat1 table for writing. Unless it was created
+  ** by this vdbe program, lock it for writing at the shared-cache level. 
+  ** If this vdbe did create the sqlite_stat1 table, then it must have 
+  ** already obtained a schema-lock, making the write-lock redundant.
+  */
+  if( !createStat1 ){
+    sqlite3TableLock(pParse, iDb, iRootPage, 1, "sqlite_stat1");
+  }
+  sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur, iRootPage, iDb);
+  sqlite3VdbeChangeP5(v, createStat1);
+  sqlite3VdbeAddOp2(v, OP_SetNumColumns, iStatCur, 3);
+}
+
+/*
+** Generate code to do an analysis of all indices associated with
+** a single table.
+*/
+static void analyzeOneTable(
+  Parse *pParse,   /* Parser context */
+  Table *pTab,     /* Table whose indices are to be analyzed */
+  int iStatCur,    /* Cursor that writes to the sqlite_stat1 table */
+  int iMem         /* Available memory locations begin here */
+){
+  Index *pIdx;     /* An index to being analyzed */
+  int iIdxCur;     /* Cursor number for index being analyzed */
+  int nCol;        /* Number of columns in the index */
+  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 */
+  int iDb;         /* Index of database containing pTab */
+
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 || pTab==0 || pTab->pIndex==0 ){
+    /* Do no analysis for tables that have no indices */
+    return;
+  }
+  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  assert( iDb>=0 );
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
+      pParse->db->aDb[iDb].zName ) ){
+    return;
+  }
+#endif
+
+  /* Establish a read-lock on the table at the shared-cache level. */
+  sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
+
+  iIdxCur = pParse->nTab;
+  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
+    int regFields;    /* Register block for building records */
+    int regRec;       /* Register holding completed record */
+    int regTemp;      /* Temporary use register */
+    int regCol;       /* Content of a column from the table being analyzed */
+    int regRowid;     /* Rowid for the inserted record */
+    int regF2;
+
+    /* Open a cursor to the index to be analyzed
+    */
+    assert( iDb==sqlite3SchemaToIndex(pParse->db, pIdx->pSchema) );
+    sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb,
+        (char *)pKey, P4_KEYINFO_HANDOFF);
+    VdbeComment((v, "%s", pIdx->zName));
+    nCol = pIdx->nColumn;
+    regFields = iMem+nCol*2;
+    regTemp = regRowid = regCol = regFields+3;
+    regRec = regCol+1;
+    if( regRec>pParse->nMem ){
+      pParse->nMem = regRec;
+    }
+    sqlite3VdbeAddOp2(v, OP_SetNumColumns, iIdxCur, nCol+1);
+
+    /* Memory cells are used as follows:
+    **
+    **    mem[iMem]:             The total number of rows in the table.
+    **    mem[iMem+1]:           Number of distinct values in column 1
+    **    ...
+    **    mem[iMem+nCol]:        Number of distinct values in column N
+    **    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.
+    */
+    for(i=0; i<=nCol; i++){
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem+i);
+    }
+    for(i=0; i<nCol; i++){
+      sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
+    }
+
+    /* Do the analysis.
+    */
+    endOfLoop = sqlite3VdbeMakeLabel(v);
+    sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop);
+    topOfLoop = sqlite3VdbeCurrentAddr(v);
+    sqlite3VdbeAddOp2(v, OP_AddImm, iMem, 1);
+    for(i=0; i<nCol; i++){
+      sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol);
+      sqlite3VdbeAddOp3(v, OP_Ne, regCol, 0, iMem+nCol+i+1);
+      /**** TODO:  add collating sequence *****/
+      sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
+    }
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);
+    for(i=0; i<nCol; i++){
+      sqlite3VdbeJumpHere(v, topOfLoop + 2*(i + 1));
+      sqlite3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1);
+      sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
+    }
+    sqlite3VdbeResolveLabel(v, endOfLoop);
+    sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);
+    sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
+
+    /* Store the results.  
+    **
+    ** The result is a single row of the sqlite_stat1 table.  The first
+    ** two columns are the names of the table and index.  The third column
+    ** is a string composed of a list of integer statistics about the
+    ** index.  The first integer in the list is the total number of entires
+    ** in the index.  There is one additional integer in the list for each
+    ** column of the table.  This additional integer is a guess of how many
+    ** rows of the table the index will select.  If D is the count of distinct
+    ** values and K is the total number of rows, then the integer is computed
+    ** as:
+    **
+    **        I = (K+D-1)/D
+    **
+    ** If K==0 then no entry is made into the sqlite_stat1 table.  
+    ** If K>0 then it is always the case the D>0 so division by zero
+    ** is never possible.
+    */
+    addr = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);
+    sqlite3VdbeAddOp4(v, OP_String8, 0, regFields, 0, pTab->zName, 0);
+    sqlite3VdbeAddOp4(v, OP_String8, 0, regFields+1, 0, pIdx->zName, 0);
+    regF2 = regFields+2;
+    sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regF2);
+    for(i=0; i<nCol; i++){
+      sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0);
+      sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
+      sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp);
+      sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1);
+      sqlite3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp);
+      sqlite3VdbeAddOp1(v, OP_ToInt, regTemp);
+      sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
+    }
+    sqlite3VdbeAddOp4(v, OP_MakeRecord, regFields, 3, regRec, "aaa", 0);
+    sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid);
+    sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);
+    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
+    sqlite3VdbeJumpHere(v, addr);
+  }
+}
+
+/*
+** Generate code that will cause the most recent index analysis to
+** be laoded into internal hash tables where is can be used.
+*/
+static void loadAnalysis(Parse *pParse, int iDb){
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
+  }
+}
+
+/*
+** Generate code that will do an analysis of an entire database
+*/
+static void analyzeDatabase(Parse *pParse, int iDb){
+  sqlite3 *db = pParse->db;
+  Schema *pSchema = db->aDb[iDb].pSchema;    /* Schema of database iDb */
+  HashElem *k;
+  int iStatCur;
+  int iMem;
+
+  sqlite3BeginWriteOperation(pParse, 0, iDb);
+  iStatCur = pParse->nTab++;
+  openStatTable(pParse, iDb, iStatCur, 0);
+  iMem = pParse->nMem+1;
+  for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
+    Table *pTab = (Table*)sqliteHashData(k);
+    analyzeOneTable(pParse, pTab, iStatCur, iMem);
+  }
+  loadAnalysis(pParse, iDb);
+}
+
+/*
+** Generate code that will do an analysis of a single table in
+** a database.
+*/
+static void analyzeTable(Parse *pParse, Table *pTab){
+  int iDb;
+  int iStatCur;
+
+  assert( pTab!=0 );
+  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  sqlite3BeginWriteOperation(pParse, 0, iDb);
+  iStatCur = pParse->nTab++;
+  openStatTable(pParse, iDb, iStatCur, pTab->zName);
+  analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem+1);
+  loadAnalysis(pParse, iDb);
+}
+
+/*
+** Generate code for the ANALYZE command.  The parser calls this routine
+** when it recognizes an ANALYZE command.
+**
+**        ANALYZE                            -- 1
+**        ANALYZE  <database>                -- 2
+**        ANALYZE  ?<database>.?<tablename>  -- 3
+**
+** Form 1 causes all indices in all attached databases to be analyzed.
+** Form 2 analyzes all indices the single database named.
+** Form 3 analyzes all indices associated with the named table.
+*/
+void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
+  sqlite3 *db = pParse->db;
+  int iDb;
+  int i;
+  char *z, *zDb;
+  Table *pTab;
+  Token *pTableName;
+
+  /* Read the database schema. If an error occurs, leave an error message
+  ** and code in pParse and return NULL. */
+  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    return;
+  }
+
+  if( pName1==0 ){
+    /* Form 1:  Analyze everything */
+    for(i=0; i<db->nDb; i++){
+      if( i==1 ) continue;  /* Do not analyze the TEMP database */
+      analyzeDatabase(pParse, i);
+    }
+  }else if( pName2==0 || pName2->n==0 ){
+    /* Form 2:  Analyze the database or table named */
+    iDb = sqlite3FindDb(db, pName1);
+    if( iDb>=0 ){
+      analyzeDatabase(pParse, iDb);
+    }else{
+      z = sqlite3NameFromToken(db, pName1);
+      if( z ){
+        pTab = sqlite3LocateTable(pParse, 0, z, 0);
+        sqlite3_free(z);
+        if( pTab ){
+          analyzeTable(pParse, pTab);
+        }
+      }
+    }
+  }else{
+    /* Form 3: Analyze the fully qualified table name */
+    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
+    if( iDb>=0 ){
+      zDb = db->aDb[iDb].zName;
+      z = sqlite3NameFromToken(db, pTableName);
+      if( z ){
+        pTab = sqlite3LocateTable(pParse, 0, z, zDb);
+        sqlite3_free(z);
+        if( pTab ){
+          analyzeTable(pParse, pTab);
+        }
+      }
+    }   
+  }
+}
+
+/*
+** Used to pass information from the analyzer reader through to the
+** callback routine.
+*/
+typedef struct analysisInfo analysisInfo;
+struct analysisInfo {
+  sqlite3 *db;
+  const char *zDatabase;
+};
+
+/*
+** This callback is invoked once for each index when reading the
+** sqlite_stat1 table.  
+**
+**     argv[0] = name of the index
+**     argv[1] = results of analysis - on integer for each column
+*/
+static int analysisLoader(void *pData, int argc, char **argv, char **azNotUsed){
+  analysisInfo *pInfo = (analysisInfo*)pData;
+  Index *pIndex;
+  int i, c;
+  unsigned int v;
+  const char *z;
+
+  assert( argc==2 );
+  if( argv==0 || argv[0]==0 || argv[1]==0 ){
+    return 0;
+  }
+  pIndex = sqlite3FindIndex(pInfo->db, argv[0], pInfo->zDatabase);
+  if( pIndex==0 ){
+    return 0;
+  }
+  z = argv[1];
+  for(i=0; *z && i<=pIndex->nColumn; i++){
+    v = 0;
+    while( (c=z[0])>='0' && c<='9' ){
+      v = v*10 + c - '0';
+      z++;
+    }
+    pIndex->aiRowEst[i] = v;
+    if( *z==' ' ) z++;
+  }
+  return 0;
+}
+
+/*
+** Load the content of the sqlite_stat1 table into the index hash tables.
+*/
+int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
+  analysisInfo sInfo;
+  HashElem *i;
+  char *zSql;
+  int rc;
+
+  assert( iDb>=0 && iDb<db->nDb );
+  assert( db->aDb[iDb].pBt!=0 );
+  assert( sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
+
+  /* Clear any prior statistics */
+  for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
+    Index *pIdx = sqliteHashData(i);
+    sqlite3DefaultRowEst(pIdx);
+  }
+
+  /* Check to make sure the sqlite_stat1 table existss */
+  sInfo.db = db;
+  sInfo.zDatabase = db->aDb[iDb].zName;
+  if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
+     return SQLITE_ERROR;
+  }
+
+
+  /* Load new statistics out of the sqlite_stat1 table */
+  zSql = sqlite3MPrintf(db, "SELECT idx, stat FROM %Q.sqlite_stat1",
+                        sInfo.zDatabase);
+  (void)sqlite3SafetyOff(db);
+  rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
+  (void)sqlite3SafetyOn(db);
+  sqlite3_free(zSql);
+  return rc;
+}
+
+
+#endif /* SQLITE_OMIT_ANALYZE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/attach.c b/client/src/thirdparty/sqlite-3.4.2/src/attach.c
new file mode 100644
index 0000000..67a34b7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/attach.c
@@ -0,0 +1,527 @@
+/*
+** 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.71 2008/02/06 14:11:35 drh Exp $
+*/
+#include "sqliteInt.h"
+
+#ifndef SQLITE_OMIT_ATTACH
+/*
+** Resolve an expression that was part of an ATTACH or DETACH statement. This
+** is slightly different from resolving a normal SQL expression, because simple
+** identifiers are treated as strings, not possible column names or aliases.
+**
+** i.e. if the parser sees:
+**
+**     ATTACH DATABASE abc AS def
+**
+** it treats the two expressions as literal strings 'abc' and 'def' instead of
+** looking for columns of the same name.
+**
+** This only applies to the root node of pExpr, so the statement:
+**
+**     ATTACH DATABASE abc||def AS 'db2'
+**
+** will fail because neither abc or def can be resolved.
+*/
+static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
+{
+  int rc = SQLITE_OK;
+  if( pExpr ){
+    if( pExpr->op!=TK_ID ){
+      rc = sqlite3ExprResolveNames(pName, pExpr);
+      if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
+        sqlite3ErrorMsg(pName->pParse, "invalid name: \"%T\"", &pExpr->span);
+        return SQLITE_ERROR;
+      }
+    }else{
+      pExpr->op = TK_STRING;
+    }
+  }
+  return rc;
+}
+
+/*
+** An SQL user-function registered to do the work of an ATTACH statement. The
+** three arguments to the function come directly from an attach statement:
+**
+**     ATTACH DATABASE x AS y KEY z
+**
+**     SELECT sqlite_attach(x, y, z)
+**
+** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
+** third argument.
+*/
+static void attachFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int i;
+  int rc = 0;
+  sqlite3 *db = sqlite3_user_data(context);
+  const char *zName;
+  const char *zFile;
+  Db *aNew;
+  char *zErrDyn = 0;
+  char zErr[128];
+
+  zFile = (const char *)sqlite3_value_text(argv[0]);
+  zName = (const char *)sqlite3_value_text(argv[1]);
+  if( zFile==0 ) zFile = "";
+  if( zName==0 ) zName = "";
+
+  /* Check for the following errors:
+  **
+  **     * Too many attached databases,
+  **     * Transaction currently open
+  **     * Specified database name already being used.
+  */
+  if( db->nDb>=SQLITE_MAX_ATTACHED+2 ){
+    sqlite3_snprintf(
+      sizeof(zErr), zErr, "too many attached databases - max %d", 
+      SQLITE_MAX_ATTACHED
+    );
+    goto attach_error;
+  }
+  if( !db->autoCommit ){
+    sqlite3_snprintf(sizeof(zErr), zErr,
+                     "cannot ATTACH database within transaction");
+    goto attach_error;
+  }
+  for(i=0; i<db->nDb; i++){
+    char *z = db->aDb[i].zName;
+    if( z && zName && sqlite3StrICmp(z, zName)==0 ){
+      sqlite3_snprintf(sizeof(zErr), zErr, 
+                       "database %s is already in use", zName);
+      goto attach_error;
+    }
+  }
+
+  /* Allocate the new entry in the db->aDb[] array and initialise the schema
+  ** hash tables.
+  */
+  if( db->aDb==db->aDbStatic ){
+    aNew = sqlite3_malloc( sizeof(db->aDb[0])*3 );
+    if( aNew==0 ){
+      db->mallocFailed = 1;
+      return;
+    }
+    memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
+  }else{
+    aNew = sqlite3_realloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
+    if( aNew==0 ){
+      db->mallocFailed = 1;
+      return;
+    } 
+  }
+  db->aDb = aNew;
+  aNew = &db->aDb[db->nDb++];
+  memset(aNew, 0, sizeof(*aNew));
+
+  /* Open the database file. If the btree is successfully opened, use
+  ** it to obtain the database schema. At this point the schema may
+  ** or may not be initialised.
+  */
+  rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,
+                           db->openFlags | SQLITE_OPEN_MAIN_DB,
+                           &aNew->pBt);
+  if( rc==SQLITE_OK ){
+    aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
+    if( !aNew->pSchema ){
+      rc = SQLITE_NOMEM;
+    }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
+      sqlite3_snprintf(sizeof(zErr), zErr, 
+        "attached databases must use the same text encoding as main database");
+      goto attach_error;
+    }
+    sqlite3PagerLockingMode(sqlite3BtreePager(aNew->pBt), db->dfltLockMode);
+  }
+  aNew->zName = sqlite3DbStrDup(db, zName);
+  aNew->safety_level = 3;
+
+#if SQLITE_HAS_CODEC
+  {
+    extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
+    extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
+    int nKey;
+    char *zKey;
+    int t = sqlite3_value_type(argv[2]);
+    switch( t ){
+      case SQLITE_INTEGER:
+      case SQLITE_FLOAT:
+        zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
+        rc = SQLITE_ERROR;
+        break;
+        
+      case SQLITE_TEXT:
+      case SQLITE_BLOB:
+        nKey = sqlite3_value_bytes(argv[2]);
+        zKey = (char *)sqlite3_value_blob(argv[2]);
+        sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
+        break;
+
+      case SQLITE_NULL:
+        /* No key specified.  Use the key from the main database */
+        sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
+        sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
+        break;
+    }
+  }
+#endif
+
+  /* If the file was opened successfully, read the schema for the new database.
+  ** If this fails, or if opening the file failed, then close the file and 
+  ** remove the entry from the db->aDb[] array. i.e. put everything back the way
+  ** we found it.
+  */
+  if( rc==SQLITE_OK ){
+    (void)sqlite3SafetyOn(db);
+    sqlite3BtreeEnterAll(db);
+    rc = sqlite3Init(db, &zErrDyn);
+    sqlite3BtreeLeaveAll(db);
+    (void)sqlite3SafetyOff(db);
+  }
+  if( rc ){
+    int iDb = db->nDb - 1;
+    assert( iDb>=2 );
+    if( db->aDb[iDb].pBt ){
+      sqlite3BtreeClose(db->aDb[iDb].pBt);
+      db->aDb[iDb].pBt = 0;
+      db->aDb[iDb].pSchema = 0;
+    }
+    sqlite3ResetInternalSchema(db, 0);
+    db->nDb = iDb;
+    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
+      db->mallocFailed = 1;
+      sqlite3_snprintf(sizeof(zErr),zErr, "out of memory");
+    }else{
+      sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile);
+    }
+    goto attach_error;
+  }
+  
+  return;
+
+attach_error:
+  /* Return an error if we get here */
+  if( zErrDyn ){
+    sqlite3_result_error(context, zErrDyn, -1);
+    sqlite3_free(zErrDyn);
+  }else{
+    zErr[sizeof(zErr)-1] = 0;
+    sqlite3_result_error(context, zErr, -1);
+  }
+  if( rc ) sqlite3_result_error_code(context, rc);
+}
+
+/*
+** An SQL user-function registered to do the work of an DETACH statement. The
+** three arguments to the function come directly from a detach statement:
+**
+**     DETACH DATABASE x
+**
+**     SELECT sqlite_detach(x)
+*/
+static void detachFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const char *zName = (const char *)sqlite3_value_text(argv[0]);
+  sqlite3 *db = sqlite3_user_data(context);
+  int i;
+  Db *pDb = 0;
+  char zErr[128];
+
+  if( zName==0 ) zName = "";
+  for(i=0; i<db->nDb; i++){
+    pDb = &db->aDb[i];
+    if( pDb->pBt==0 ) continue;
+    if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
+  }
+
+  if( i>=db->nDb ){
+    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
+    goto detach_error;
+  }
+  if( i<2 ){
+    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
+    goto detach_error;
+  }
+  if( !db->autoCommit ){
+    sqlite3_snprintf(sizeof(zErr), zErr,
+                     "cannot DETACH database within transaction");
+    goto detach_error;
+  }
+  if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){
+    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
+    goto detach_error;
+  }
+
+  sqlite3BtreeClose(pDb->pBt);
+  pDb->pBt = 0;
+  pDb->pSchema = 0;
+  sqlite3ResetInternalSchema(db, 0);
+  return;
+
+detach_error:
+  sqlite3_result_error(context, zErr, -1);
+}
+
+/*
+** This procedure generates VDBE code for a single invocation of either the
+** sqlite_detach() or sqlite_attach() SQL user functions.
+*/
+static void codeAttach(
+  Parse *pParse,       /* The parser context */
+  int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */
+  const char *zFunc,   /* Either "sqlite_attach" or "sqlite_detach */
+  int nFunc,           /* Number of args to pass to zFunc */
+  Expr *pAuthArg,      /* Expression to pass to authorization callback */
+  Expr *pFilename,     /* Name of database file */
+  Expr *pDbname,       /* Name of the database to use internally */
+  Expr *pKey           /* Database key for encryption extension */
+){
+  int rc;
+  NameContext sName;
+  Vdbe *v;
+  FuncDef *pFunc;
+  sqlite3* db = pParse->db;
+  int regArgs;
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  assert( db->mallocFailed || pAuthArg );
+  if( pAuthArg ){
+    char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);
+    if( !zAuthArg ){
+      goto attach_end;
+    }
+    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
+    sqlite3_free(zAuthArg);
+    if(rc!=SQLITE_OK ){
+      goto attach_end;
+    }
+  }
+#endif /* SQLITE_OMIT_AUTHORIZATION */
+
+  memset(&sName, 0, sizeof(NameContext));
+  sName.pParse = pParse;
+
+  if( 
+      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
+      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
+      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
+  ){
+    pParse->nErr++;
+    goto attach_end;
+  }
+
+  v = sqlite3GetVdbe(pParse);
+  regArgs = sqlite3GetTempRange(pParse, 3);
+  sqlite3ExprCode(pParse, pFilename, regArgs);
+  sqlite3ExprCode(pParse, pDbname, regArgs+1);
+  sqlite3ExprCode(pParse, pKey, regArgs+2);
+
+  assert( v || db->mallocFailed );
+  if( v ){
+    sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs);
+    sqlite3VdbeChangeP5(v, nFunc);
+    pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);
+    sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
+
+    /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
+    ** statement only). For DETACH, set it to false (expire all existing
+    ** statements).
+    */
+    sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
+  }
+  
+attach_end:
+  sqlite3ExprDelete(pFilename);
+  sqlite3ExprDelete(pDbname);
+  sqlite3ExprDelete(pKey);
+}
+
+/*
+** Called by the parser to compile a DETACH statement.
+**
+**     DETACH pDbname
+*/
+void sqlite3Detach(Parse *pParse, Expr *pDbname){
+  codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname);
+}
+
+/*
+** Called by the parser to compile an ATTACH statement.
+**
+**     ATTACH p AS pDbname KEY pKey
+*/
+void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
+  codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey);
+}
+#endif /* SQLITE_OMIT_ATTACH */
+
+/*
+** Register the functions sqlite_attach and sqlite_detach.
+*/
+void sqlite3AttachFunctions(sqlite3 *db){
+#ifndef SQLITE_OMIT_ATTACH
+  static const int enc = SQLITE_UTF8;
+  sqlite3CreateFunc(db, "sqlite_attach", 3, enc, db, attachFunc, 0, 0);
+  sqlite3CreateFunc(db, "sqlite_detach", 1, enc, db, detachFunc, 0, 0);
+#endif
+}
+
+/*
+** Initialize a DbFixer structure.  This routine must be called prior
+** to passing the structure to one of the sqliteFixAAAA() routines below.
+**
+** The return value indicates whether or not fixation is required.  TRUE
+** means we do need to fix the database references, FALSE means we do not.
+*/
+int sqlite3FixInit(
+  DbFixer *pFix,      /* The fixer to be initialized */
+  Parse *pParse,      /* Error messages will be written here */
+  int iDb,            /* This is the database that must be used */
+  const char *zType,  /* "view", "trigger", or "index" */
+  const Token *pName  /* Name of the view, trigger, or index */
+){
+  sqlite3 *db;
+
+  if( iDb<0 || iDb==1 ) return 0;
+  db = pParse->db;
+  assert( db->nDb>iDb );
+  pFix->pParse = pParse;
+  pFix->zDb = db->aDb[iDb].zName;
+  pFix->zType = zType;
+  pFix->pName = pName;
+  return 1;
+}
+
+/*
+** The following set of routines walk through the parse tree and assign
+** a specific database to all table references where the database name
+** was left unspecified in the original SQL statement.  The pFix structure
+** must have been initialized by a prior call to sqlite3FixInit().
+**
+** These routines are used to make sure that an index, trigger, or
+** view in one database does not refer to objects in a different database.
+** (Exception: indices, triggers, and views in the TEMP database are
+** allowed to refer to anything.)  If a reference is explicitly made
+** to an object in a different database, an error message is added to
+** pParse->zErrMsg and these routines return non-zero.  If everything
+** checks out, these routines return 0.
+*/
+int sqlite3FixSrcList(
+  DbFixer *pFix,       /* Context of the fixation */
+  SrcList *pList       /* The Source list to check and modify */
+){
+  int i;
+  const char *zDb;
+  struct SrcList_item *pItem;
+
+  if( pList==0 ) return 0;
+  zDb = pFix->zDb;
+  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
+    if( pItem->zDatabase==0 ){
+      pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
+    }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){
+      sqlite3ErrorMsg(pFix->pParse,
+         "%s %T cannot reference objects in database %s",
+         pFix->zType, pFix->pName, pItem->zDatabase);
+      return 1;
+    }
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
+    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
+    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
+#endif
+  }
+  return 0;
+}
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
+int sqlite3FixSelect(
+  DbFixer *pFix,       /* Context of the fixation */
+  Select *pSelect      /* The SELECT statement to be fixed to one database */
+){
+  while( pSelect ){
+    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
+      return 1;
+    }
+    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
+      return 1;
+    }
+    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
+      return 1;
+    }
+    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
+      return 1;
+    }
+    pSelect = pSelect->pPrior;
+  }
+  return 0;
+}
+int sqlite3FixExpr(
+  DbFixer *pFix,     /* Context of the fixation */
+  Expr *pExpr        /* The expression to be fixed to one database */
+){
+  while( pExpr ){
+    if( sqlite3FixSelect(pFix, pExpr->pSelect) ){
+      return 1;
+    }
+    if( sqlite3FixExprList(pFix, pExpr->pList) ){
+      return 1;
+    }
+    if( sqlite3FixExpr(pFix, pExpr->pRight) ){
+      return 1;
+    }
+    pExpr = pExpr->pLeft;
+  }
+  return 0;
+}
+int sqlite3FixExprList(
+  DbFixer *pFix,     /* Context of the fixation */
+  ExprList *pList    /* The expression to be fixed to one database */
+){
+  int i;
+  struct ExprList_item *pItem;
+  if( pList==0 ) return 0;
+  for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
+    if( sqlite3FixExpr(pFix, pItem->pExpr) ){
+      return 1;
+    }
+  }
+  return 0;
+}
+#endif
+
+#ifndef SQLITE_OMIT_TRIGGER
+int sqlite3FixTriggerStep(
+  DbFixer *pFix,     /* Context of the fixation */
+  TriggerStep *pStep /* The trigger step be fixed to one database */
+){
+  while( pStep ){
+    if( sqlite3FixSelect(pFix, pStep->pSelect) ){
+      return 1;
+    }
+    if( sqlite3FixExpr(pFix, pStep->pWhere) ){
+      return 1;
+    }
+    if( sqlite3FixExprList(pFix, pStep->pExprList) ){
+      return 1;
+    }
+    pStep = pStep->pNext;
+  }
+  return 0;
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/auth.c b/client/src/thirdparty/sqlite-3.4.2/src/auth.c
new file mode 100644
index 0000000..5630c23
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/auth.c
@@ -0,0 +1,234 @@
+/*
+** 2003 January 11
+**
+** 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 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.29 2007/09/18 15:55:07 drh Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** All of the code in this file may be omitted by defining a single
+** macro.
+*/
+#ifndef SQLITE_OMIT_AUTHORIZATION
+
+/*
+** Set or clear the access authorization function.
+**
+** The access authorization function is be called during the compilation
+** phase to verify that the user has read and/or write access permission on
+** various fields of the database.  The first argument to the auth function
+** is a copy of the 3rd argument to this routine.  The second argument
+** to the auth function is one of these constants:
+**
+**       SQLITE_CREATE_INDEX
+**       SQLITE_CREATE_TABLE
+**       SQLITE_CREATE_TEMP_INDEX
+**       SQLITE_CREATE_TEMP_TABLE
+**       SQLITE_CREATE_TEMP_TRIGGER
+**       SQLITE_CREATE_TEMP_VIEW
+**       SQLITE_CREATE_TRIGGER
+**       SQLITE_CREATE_VIEW
+**       SQLITE_DELETE
+**       SQLITE_DROP_INDEX
+**       SQLITE_DROP_TABLE
+**       SQLITE_DROP_TEMP_INDEX
+**       SQLITE_DROP_TEMP_TABLE
+**       SQLITE_DROP_TEMP_TRIGGER
+**       SQLITE_DROP_TEMP_VIEW
+**       SQLITE_DROP_TRIGGER
+**       SQLITE_DROP_VIEW
+**       SQLITE_INSERT
+**       SQLITE_PRAGMA
+**       SQLITE_READ
+**       SQLITE_SELECT
+**       SQLITE_TRANSACTION
+**       SQLITE_UPDATE
+**
+** The third and fourth arguments to the auth function are the name of
+** the table and the column that are being accessed.  The auth function
+** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE.  If
+** SQLITE_OK is returned, it means that access is allowed.  SQLITE_DENY
+** means that the SQL statement will never-run - the sqlite3_exec() call
+** will return with an error.  SQLITE_IGNORE means that the SQL statement
+** should run but attempts to read the specified column will return NULL
+** and attempts to write the column will be ignored.
+**
+** Setting the auth function to NULL disables this hook.  The default
+** setting of the auth function is NULL.
+*/
+int sqlite3_set_authorizer(
+  sqlite3 *db,
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
+  void *pArg
+){
+  sqlite3_mutex_enter(db->mutex);
+  db->xAuth = xAuth;
+  db->pAuthArg = pArg;
+  sqlite3ExpirePreparedStatements(db);
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Write an error message into pParse->zErrMsg that explains that the
+** user-supplied authorization function returned an illegal value.
+*/
+static void sqliteAuthBadReturnCode(Parse *pParse, int rc){
+  sqlite3ErrorMsg(pParse, "illegal return value (%d) from the "
+    "authorization function - should be SQLITE_OK, SQLITE_IGNORE, "
+    "or SQLITE_DENY", rc);
+  pParse->rc = SQLITE_ERROR;
+}
+
+/*
+** The pExpr should be a TK_COLUMN expression.  The table referred to
+** is in pTabList or else it is the NEW or OLD table of a trigger.  
+** Check to see if it is OK to read this particular column.
+**
+** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN 
+** instruction into a TK_NULL.  If the auth function returns SQLITE_DENY,
+** then generate an error.
+*/
+void sqlite3AuthRead(
+  Parse *pParse,        /* The parser context */
+  Expr *pExpr,          /* The expression to check authorization on */
+  Schema *pSchema,      /* The schema of the expression */
+  SrcList *pTabList     /* All table that pExpr might refer to */
+){
+  sqlite3 *db = pParse->db;
+  int rc;
+  Table *pTab = 0;      /* The table being read */
+  const char *zCol;     /* Name of the column of the table */
+  int iSrc;             /* Index in pTabList->a[] of table being read */
+  const char *zDBase;   /* Name of database being accessed */
+  TriggerStack *pStack; /* The stack of current triggers */
+  int iDb;              /* The index of the database the expression refers to */
+
+  if( db->xAuth==0 ) return;
+  if( pExpr->op!=TK_COLUMN ) return;
+  iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
+  if( iDb<0 ){
+    /* An attempt to read a column out of a subquery or other
+    ** temporary table. */
+    return;
+  }
+  for(iSrc=0; pTabList && iSrc<pTabList->nSrc; iSrc++){
+    if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break;
+  }
+  if( iSrc>=0 && pTabList && iSrc<pTabList->nSrc ){
+    pTab = pTabList->a[iSrc].pTab;
+  }else if( (pStack = pParse->trigStack)!=0 ){
+    /* This must be an attempt to read the NEW or OLD pseudo-tables
+    ** of a trigger.
+    */
+    assert( pExpr->iTable==pStack->newIdx || pExpr->iTable==pStack->oldIdx );
+    pTab = pStack->pTab;
+  }
+  if( pTab==0 ) return;
+  if( pExpr->iColumn>=0 ){
+    assert( pExpr->iColumn<pTab->nCol );
+    zCol = pTab->aCol[pExpr->iColumn].zName;
+  }else if( pTab->iPKey>=0 ){
+    assert( pTab->iPKey<pTab->nCol );
+    zCol = pTab->aCol[pTab->iPKey].zName;
+  }else{
+    zCol = "ROWID";
+  }
+  assert( iDb>=0 && iDb<db->nDb );
+  zDBase = db->aDb[iDb].zName;
+  rc = db->xAuth(db->pAuthArg, SQLITE_READ, pTab->zName, zCol, zDBase, 
+                 pParse->zAuthContext);
+  if( rc==SQLITE_IGNORE ){
+    pExpr->op = TK_NULL;
+  }else if( rc==SQLITE_DENY ){
+    if( db->nDb>2 || iDb!=0 ){
+      sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited", 
+         zDBase, pTab->zName, zCol);
+    }else{
+      sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited",pTab->zName,zCol);
+    }
+    pParse->rc = SQLITE_AUTH;
+  }else if( rc!=SQLITE_OK ){
+    sqliteAuthBadReturnCode(pParse, rc);
+  }
+}
+
+/*
+** Do an authorization check using the code and arguments given.  Return
+** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY.  If SQLITE_DENY
+** is returned, then the error count and error message in pParse are
+** modified appropriately.
+*/
+int sqlite3AuthCheck(
+  Parse *pParse,
+  int code,
+  const char *zArg1,
+  const char *zArg2,
+  const char *zArg3
+){
+  sqlite3 *db = pParse->db;
+  int rc;
+
+  /* Don't do any authorization checks if the database is initialising
+  ** or if the parser is being invoked from within sqlite3_declare_vtab.
+  */
+  if( db->init.busy || IN_DECLARE_VTAB ){
+    return SQLITE_OK;
+  }
+
+  if( db->xAuth==0 ){
+    return SQLITE_OK;
+  }
+  rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
+  if( rc==SQLITE_DENY ){
+    sqlite3ErrorMsg(pParse, "not authorized");
+    pParse->rc = SQLITE_AUTH;
+  }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
+    rc = SQLITE_DENY;
+    sqliteAuthBadReturnCode(pParse, rc);
+  }
+  return rc;
+}
+
+/*
+** Push an authorization context.  After this routine is called, the
+** zArg3 argument to authorization callbacks will be zContext until
+** popped.  Or if pParse==0, this routine is a no-op.
+*/
+void sqlite3AuthContextPush(
+  Parse *pParse,
+  AuthContext *pContext, 
+  const char *zContext
+){
+  pContext->pParse = pParse;
+  if( pParse ){
+    pContext->zAuthContext = pParse->zAuthContext;
+    pParse->zAuthContext = zContext;
+  }
+}
+
+/*
+** Pop an authorization context that was previously pushed
+** by sqlite3AuthContextPush
+*/
+void sqlite3AuthContextPop(AuthContext *pContext){
+  if( pContext->pParse ){
+    pContext->pParse->zAuthContext = pContext->zAuthContext;
+    pContext->pParse = 0;
+  }
+}
+
+#endif /* SQLITE_OMIT_AUTHORIZATION */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/btmutex.c b/client/src/thirdparty/sqlite-3.4.2/src/btmutex.c
new file mode 100644
index 0000000..58a1b56
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/btmutex.c
@@ -0,0 +1,317 @@
+/*
+** 2007 August 27
+**
+** 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: btmutex.c,v 1.9 2008/01/23 12:52:41 drh Exp $
+**
+** This file contains code used to implement mutexes on Btree objects.
+** This code really belongs in btree.c.  But btree.c is getting too
+** big and we want to break it down some.  This packaged seemed like
+** a good breakout.
+*/
+#include "btreeInt.h"
+#if SQLITE_THREADSAFE && !defined(SQLITE_OMIT_SHARED_CACHE)
+
+
+/*
+** Enter a mutex on the given BTree object.
+**
+** If the object is not sharable, then no mutex is ever required
+** and this routine is a no-op.  The underlying mutex is non-recursive.
+** But we keep a reference count in Btree.wantToLock so the behavior
+** of this interface is recursive.
+**
+** To avoid deadlocks, multiple Btrees are locked in the same order
+** by all database connections.  The p->pNext is a list of other
+** Btrees belonging to the same database connection as the p Btree
+** which need to be locked after p.  If we cannot get a lock on
+** p, then first unlock all of the others on p->pNext, then wait
+** for the lock to become available on p, then relock all of the
+** subsequent Btrees that desire a lock.
+*/
+void sqlite3BtreeEnter(Btree *p){
+  Btree *pLater;
+
+  /* Some basic sanity checking on the Btree.  The list of Btrees
+  ** connected by pNext and pPrev should be in sorted order by
+  ** Btree.pBt value. All elements of the list should belong to
+  ** the same connection. Only shared Btrees are on the list. */
+  assert( p->pNext==0 || p->pNext->pBt>p->pBt );
+  assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
+  assert( p->pNext==0 || p->pNext->db==p->db );
+  assert( p->pPrev==0 || p->pPrev->db==p->db );
+  assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
+
+  /* Check for locking consistency */
+  assert( !p->locked || p->wantToLock>0 );
+  assert( p->sharable || p->wantToLock==0 );
+
+  /* We should already hold a lock on the database connection */
+  assert( sqlite3_mutex_held(p->db->mutex) );
+
+  if( !p->sharable ) return;
+  p->wantToLock++;
+  if( p->locked ) return;
+
+#ifndef SQLITE_MUTEX_NOOP
+  /* In most cases, we should be able to acquire the lock we
+  ** want without having to go throught the ascending lock
+  ** procedure that follows.  Just be sure not to block.
+  */
+  if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
+    p->locked = 1;
+    return;
+  }
+
+  /* To avoid deadlock, first release all locks with a larger
+  ** BtShared address.  Then acquire our lock.  Then reacquire
+  ** the other BtShared locks that we used to hold in ascending
+  ** order.
+  */
+  for(pLater=p->pNext; pLater; pLater=pLater->pNext){
+    assert( pLater->sharable );
+    assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
+    assert( !pLater->locked || pLater->wantToLock>0 );
+    if( pLater->locked ){
+      sqlite3_mutex_leave(pLater->pBt->mutex);
+      pLater->locked = 0;
+    }
+  }
+  sqlite3_mutex_enter(p->pBt->mutex);
+  p->locked = 1;
+  for(pLater=p->pNext; pLater; pLater=pLater->pNext){
+    if( pLater->wantToLock ){
+      sqlite3_mutex_enter(pLater->pBt->mutex);
+      pLater->locked = 1;
+    }
+  }
+#endif /* SQLITE_MUTEX_NOOP */
+}
+
+/*
+** Exit the recursive mutex on a Btree.
+*/
+void sqlite3BtreeLeave(Btree *p){
+  if( p->sharable ){
+    assert( p->wantToLock>0 );
+    p->wantToLock--;
+    if( p->wantToLock==0 ){
+      assert( p->locked );
+      sqlite3_mutex_leave(p->pBt->mutex);
+      p->locked = 0;
+    }
+  }
+}
+
+#ifndef NDEBUG
+/*
+** Return true if the BtShared mutex is held on the btree.  
+**
+** This routine makes no determination one why or another if the
+** database connection mutex is held.
+**
+** This routine is used only from within assert() statements.
+*/
+int sqlite3BtreeHoldsMutex(Btree *p){
+  return (p->sharable==0 ||
+             (p->locked && p->wantToLock && sqlite3_mutex_held(p->pBt->mutex)));
+}
+#endif
+
+
+#ifndef SQLITE_OMIT_INCRBLOB
+/*
+** Enter and leave a mutex on a Btree given a cursor owned by that
+** Btree.  These entry points are used by incremental I/O and can be
+** omitted if that module is not used.
+*/
+void sqlite3BtreeEnterCursor(BtCursor *pCur){
+  sqlite3BtreeEnter(pCur->pBtree);
+}
+void sqlite3BtreeLeaveCursor(BtCursor *pCur){
+  sqlite3BtreeLeave(pCur->pBtree);
+}
+#endif /* SQLITE_OMIT_INCRBLOB */
+
+
+/*
+** Enter the mutex on every Btree associated with a database
+** connection.  This is needed (for example) prior to parsing
+** a statement since we will be comparing table and column names
+** against all schemas and we do not want those schemas being
+** reset out from under us.
+**
+** There is a corresponding leave-all procedures.
+**
+** Enter the mutexes in accending order by BtShared pointer address
+** to avoid the possibility of deadlock when two threads with
+** two or more btrees in common both try to lock all their btrees
+** at the same instant.
+*/
+void sqlite3BtreeEnterAll(sqlite3 *db){
+  int i;
+  Btree *p, *pLater;
+  assert( sqlite3_mutex_held(db->mutex) );
+  for(i=0; i<db->nDb; i++){
+    p = db->aDb[i].pBt;
+    if( p && p->sharable ){
+      p->wantToLock++;
+      if( !p->locked ){
+        assert( p->wantToLock==1 );
+        while( p->pPrev ) p = p->pPrev;
+        while( p->locked && p->pNext ) p = p->pNext;
+        for(pLater = p->pNext; pLater; pLater=pLater->pNext){
+          if( pLater->locked ){
+            sqlite3_mutex_leave(pLater->pBt->mutex);
+            pLater->locked = 0;
+          }
+        }
+        while( p ){
+          sqlite3_mutex_enter(p->pBt->mutex);
+          p->locked++;
+          p = p->pNext;
+        }
+      }
+    }
+  }
+}
+void sqlite3BtreeLeaveAll(sqlite3 *db){
+  int i;
+  Btree *p;
+  assert( sqlite3_mutex_held(db->mutex) );
+  for(i=0; i<db->nDb; i++){
+    p = db->aDb[i].pBt;
+    if( p && p->sharable ){
+      assert( p->wantToLock>0 );
+      p->wantToLock--;
+      if( p->wantToLock==0 ){
+        assert( p->locked );
+        sqlite3_mutex_leave(p->pBt->mutex);
+        p->locked = 0;
+      }
+    }
+  }
+}
+
+#ifndef NDEBUG
+/*
+** Return true if the current thread holds the database connection
+** mutex and all required BtShared mutexes.
+**
+** This routine is used inside assert() statements only.
+*/
+int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){
+  int i;
+  if( !sqlite3_mutex_held(db->mutex) ){
+    return 0;
+  }
+  for(i=0; i<db->nDb; i++){
+    Btree *p;
+    p = db->aDb[i].pBt;
+    if( p && p->sharable &&
+         (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
+      return 0;
+    }
+  }
+  return 1;
+}
+#endif /* NDEBUG */
+
+/*
+** Potentially dd a new Btree pointer to a BtreeMutexArray.
+** Really only add the Btree if it can possibly be shared with
+** another database connection.
+**
+** The Btrees are kept in sorted order by pBtree->pBt.  That
+** way when we go to enter all the mutexes, we can enter them
+** in order without every having to backup and retry and without
+** worrying about deadlock.
+**
+** The number of shared btrees will always be small (usually 0 or 1)
+** so an insertion sort is an adequate algorithm here.
+*/
+void sqlite3BtreeMutexArrayInsert(BtreeMutexArray *pArray, Btree *pBtree){
+  int i, j;
+  BtShared *pBt;
+  if( pBtree==0 || pBtree->sharable==0 ) return;
+#ifndef NDEBUG
+  {
+    for(i=0; i<pArray->nMutex; i++){
+      assert( pArray->aBtree[i]!=pBtree );
+    }
+  }
+#endif
+  assert( pArray->nMutex>=0 );
+  assert( pArray->nMutex<sizeof(pArray->aBtree)/sizeof(pArray->aBtree[0])-1 );
+  pBt = pBtree->pBt;
+  for(i=0; i<pArray->nMutex; i++){
+    assert( pArray->aBtree[i]!=pBtree );
+    if( pArray->aBtree[i]->pBt>pBt ){
+      for(j=pArray->nMutex; j>i; j--){
+        pArray->aBtree[j] = pArray->aBtree[j-1];
+      }
+      pArray->aBtree[i] = pBtree;
+      pArray->nMutex++;
+      return;
+    }
+  }
+  pArray->aBtree[pArray->nMutex++] = pBtree;
+}
+
+/*
+** Enter the mutex of every btree in the array.  This routine is
+** called at the beginning of sqlite3VdbeExec().  The mutexes are
+** exited at the end of the same function.
+*/
+void sqlite3BtreeMutexArrayEnter(BtreeMutexArray *pArray){
+  int i;
+  for(i=0; i<pArray->nMutex; i++){
+    Btree *p = pArray->aBtree[i];
+    /* Some basic sanity checking */
+    assert( i==0 || pArray->aBtree[i-1]->pBt<p->pBt );
+    assert( !p->locked || p->wantToLock>0 );
+
+    /* We should already hold a lock on the database connection */
+    assert( sqlite3_mutex_held(p->db->mutex) );
+
+    p->wantToLock++;
+    if( !p->locked && p->sharable ){
+      sqlite3_mutex_enter(p->pBt->mutex);
+      p->locked = 1;
+    }
+  }
+}
+
+/*
+** Leave the mutex of every btree in the group.
+*/
+void sqlite3BtreeMutexArrayLeave(BtreeMutexArray *pArray){
+  int i;
+  for(i=0; i<pArray->nMutex; i++){
+    Btree *p = pArray->aBtree[i];
+    /* Some basic sanity checking */
+    assert( i==0 || pArray->aBtree[i-1]->pBt<p->pBt );
+    assert( p->locked || !p->sharable );
+    assert( p->wantToLock>0 );
+
+    /* We should already hold a lock on the database connection */
+    assert( sqlite3_mutex_held(p->db->mutex) );
+
+    p->wantToLock--;
+    if( p->wantToLock==0 && p->locked ){
+      sqlite3_mutex_leave(p->pBt->mutex);
+      p->locked = 0;
+    }
+  }
+}
+
+
+#endif  /* SQLITE_THREADSAFE && !SQLITE_OMIT_SHARED_CACHE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/btree.c b/client/src/thirdparty/sqlite-3.4.2/src/btree.c
new file mode 100644
index 0000000..dd0e724
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/btree.c
@@ -0,0 +1,6943 @@
+/*
+** 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.438 2008/01/31 14:54:44 drh Exp $
+**
+** This file implements a external (disk-based) database using BTrees.
+** See the header comment on "btreeInt.h" for additional information.
+** Including a description of file format and an overview of operation.
+*/
+#include "btreeInt.h"
+
+/*
+** The header string that appears at the beginning of every
+** SQLite database.
+*/
+static const char zMagicHeader[] = SQLITE_FILE_HEADER;
+
+/*
+** Set this global variable to 1 to enable tracing using the TRACE
+** macro.
+*/
+#if SQLITE_TEST
+int sqlite3_btree_trace=0;  /* True to enable tracing */
+#endif
+
+
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** A flag to indicate whether or not shared cache is enabled.  Also,
+** a list of BtShared objects that are eligible for participation
+** in shared cache.  The variables have file scope during normal builds,
+** but the test harness needs to access these variables so we make them
+** global for test builds.
+*/
+#ifdef SQLITE_TEST
+BtShared *sqlite3SharedCacheList = 0;
+int sqlite3SharedCacheEnabled = 0;
+#else
+static BtShared *sqlite3SharedCacheList = 0;
+static int sqlite3SharedCacheEnabled = 0;
+#endif
+#endif /* SQLITE_OMIT_SHARED_CACHE */
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** Enable or disable the shared pager and schema features.
+**
+** This routine has no effect on existing database connections.
+** The shared cache setting effects only future calls to
+** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
+*/
+int sqlite3_enable_shared_cache(int enable){
+  sqlite3SharedCacheEnabled = enable;
+  return SQLITE_OK;
+}
+#endif
+
+
+/*
+** Forward declaration
+*/
+static int checkReadLocks(Btree*,Pgno,BtCursor*);
+
+
+#ifdef SQLITE_OMIT_SHARED_CACHE
+  /*
+  ** The functions queryTableLock(), lockTable() and unlockAllTables()
+  ** manipulate entries in the BtShared.pLock linked list used to store
+  ** shared-cache table level locks. If the library is compiled with the
+  ** shared-cache feature disabled, then there is only ever one user
+  ** of each BtShared structure and so this locking is not necessary. 
+  ** So define the lock related functions as no-ops.
+  */
+  #define queryTableLock(a,b,c) SQLITE_OK
+  #define lockTable(a,b,c) SQLITE_OK
+  #define unlockAllTables(a)
+#endif
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** Query to see if btree handle p may obtain a lock of type eLock 
+** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
+** SQLITE_OK if the lock may be obtained (by calling lockTable()), or
+** SQLITE_LOCKED if not.
+*/
+static int queryTableLock(Btree *p, Pgno iTab, u8 eLock){
+  BtShared *pBt = p->pBt;
+  BtLock *pIter;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+  
+  /* This is a no-op if the shared-cache is not enabled */
+  if( !p->sharable ){
+    return SQLITE_OK;
+  }
+
+  /* If some other connection is holding an exclusive lock, the
+  ** requested lock may not be obtained.
+  */
+  if( pBt->pExclusive && pBt->pExclusive!=p ){
+    return SQLITE_LOCKED;
+  }
+
+  /* This (along with lockTable()) is where the ReadUncommitted flag is
+  ** dealt with. If the caller is querying for a read-lock and the flag is
+  ** set, it is unconditionally granted - even if there are write-locks
+  ** on the table. If a write-lock is requested, the ReadUncommitted flag
+  ** is not considered.
+  **
+  ** In function lockTable(), if a read-lock is demanded and the 
+  ** ReadUncommitted flag is set, no entry is added to the locks list 
+  ** (BtShared.pLock).
+  **
+  ** To summarize: If the ReadUncommitted flag is set, then read cursors do
+  ** not create or respect table locks. The locking procedure for a 
+  ** write-cursor does not change.
+  */
+  if( 
+    !p->db || 
+    0==(p->db->flags&SQLITE_ReadUncommitted) || 
+    eLock==WRITE_LOCK ||
+    iTab==MASTER_ROOT
+  ){
+    for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
+      if( pIter->pBtree!=p && pIter->iTable==iTab && 
+          (pIter->eLock!=eLock || eLock!=READ_LOCK) ){
+        return SQLITE_LOCKED;
+      }
+    }
+  }
+  return SQLITE_OK;
+}
+#endif /* !SQLITE_OMIT_SHARED_CACHE */
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** Add a lock on the table with root-page iTable to the shared-btree used
+** by Btree handle p. Parameter eLock must be either READ_LOCK or 
+** WRITE_LOCK.
+**
+** SQLITE_OK is returned if the lock is added successfully. SQLITE_BUSY and
+** SQLITE_NOMEM may also be returned.
+*/
+static int lockTable(Btree *p, Pgno iTable, u8 eLock){
+  BtShared *pBt = p->pBt;
+  BtLock *pLock = 0;
+  BtLock *pIter;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+
+  /* This is a no-op if the shared-cache is not enabled */
+  if( !p->sharable ){
+    return SQLITE_OK;
+  }
+
+  assert( SQLITE_OK==queryTableLock(p, iTable, eLock) );
+
+  /* If the read-uncommitted flag is set and a read-lock is requested,
+  ** return early without adding an entry to the BtShared.pLock list. See
+  ** comment in function queryTableLock() for more info on handling 
+  ** the ReadUncommitted flag.
+  */
+  if( 
+    (p->db) && 
+    (p->db->flags&SQLITE_ReadUncommitted) && 
+    (eLock==READ_LOCK) &&
+    iTable!=MASTER_ROOT
+  ){
+    return SQLITE_OK;
+  }
+
+  /* First search the list for an existing lock on this table. */
+  for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
+    if( pIter->iTable==iTable && pIter->pBtree==p ){
+      pLock = pIter;
+      break;
+    }
+  }
+
+  /* If the above search did not find a BtLock struct associating Btree p
+  ** with table iTable, allocate one and link it into the list.
+  */
+  if( !pLock ){
+    pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
+    if( !pLock ){
+      return SQLITE_NOMEM;
+    }
+    pLock->iTable = iTable;
+    pLock->pBtree = p;
+    pLock->pNext = pBt->pLock;
+    pBt->pLock = pLock;
+  }
+
+  /* Set the BtLock.eLock variable to the maximum of the current lock
+  ** and the requested lock. This means if a write-lock was already held
+  ** and a read-lock requested, we don't incorrectly downgrade the lock.
+  */
+  assert( WRITE_LOCK>READ_LOCK );
+  if( eLock>pLock->eLock ){
+    pLock->eLock = eLock;
+  }
+
+  return SQLITE_OK;
+}
+#endif /* !SQLITE_OMIT_SHARED_CACHE */
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** Release all the table locks (locks obtained via calls to the lockTable()
+** procedure) held by Btree handle p.
+*/
+static void unlockAllTables(Btree *p){
+  BtShared *pBt = p->pBt;
+  BtLock **ppIter = &pBt->pLock;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+  assert( p->sharable || 0==*ppIter );
+
+  while( *ppIter ){
+    BtLock *pLock = *ppIter;
+    assert( pBt->pExclusive==0 || pBt->pExclusive==pLock->pBtree );
+    if( pLock->pBtree==p ){
+      *ppIter = pLock->pNext;
+      sqlite3_free(pLock);
+    }else{
+      ppIter = &pLock->pNext;
+    }
+  }
+
+  if( pBt->pExclusive==p ){
+    pBt->pExclusive = 0;
+  }
+}
+#endif /* SQLITE_OMIT_SHARED_CACHE */
+
+static void releasePage(MemPage *pPage);  /* Forward reference */
+
+/*
+** Verify that the cursor holds a mutex on the BtShared
+*/
+#ifndef NDEBUG
+static int cursorHoldsMutex(BtCursor *p){
+  return sqlite3_mutex_held(p->pBt->mutex);
+}
+#endif
+
+
+#ifndef SQLITE_OMIT_INCRBLOB
+/*
+** Invalidate the overflow page-list cache for cursor pCur, if any.
+*/
+static void invalidateOverflowCache(BtCursor *pCur){
+  assert( cursorHoldsMutex(pCur) );
+  sqlite3_free(pCur->aOverflow);
+  pCur->aOverflow = 0;
+}
+
+/*
+** Invalidate the overflow page-list cache for all cursors opened
+** on the shared btree structure pBt.
+*/
+static void invalidateAllOverflowCache(BtShared *pBt){
+  BtCursor *p;
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  for(p=pBt->pCursor; p; p=p->pNext){
+    invalidateOverflowCache(p);
+  }
+}
+#else
+  #define invalidateOverflowCache(x)
+  #define invalidateAllOverflowCache(x)
+#endif
+
+/*
+** Save the current cursor position in the variables BtCursor.nKey 
+** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
+*/
+static int saveCursorPosition(BtCursor *pCur){
+  int rc;
+
+  assert( CURSOR_VALID==pCur->eState );
+  assert( 0==pCur->pKey );
+  assert( cursorHoldsMutex(pCur) );
+
+  rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
+
+  /* If this is an intKey table, then the above call to BtreeKeySize()
+  ** stores the integer key in pCur->nKey. In this case this value is
+  ** all that is required. Otherwise, if pCur is not open on an intKey
+  ** table, then malloc space for and store the pCur->nKey bytes of key 
+  ** data.
+  */
+  if( rc==SQLITE_OK && 0==pCur->pPage->intKey){
+    void *pKey = sqlite3_malloc(pCur->nKey);
+    if( pKey ){
+      rc = sqlite3BtreeKey(pCur, 0, pCur->nKey, pKey);
+      if( rc==SQLITE_OK ){
+        pCur->pKey = pKey;
+      }else{
+        sqlite3_free(pKey);
+      }
+    }else{
+      rc = SQLITE_NOMEM;
+    }
+  }
+  assert( !pCur->pPage->intKey || !pCur->pKey );
+
+  if( rc==SQLITE_OK ){
+    releasePage(pCur->pPage);
+    pCur->pPage = 0;
+    pCur->eState = CURSOR_REQUIRESEEK;
+  }
+
+  invalidateOverflowCache(pCur);
+  return rc;
+}
+
+/*
+** Save the positions of all cursors except pExcept open on the table 
+** with root-page iRoot. Usually, this is called just before cursor
+** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
+*/
+static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
+  BtCursor *p;
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  assert( pExcept==0 || pExcept->pBt==pBt );
+  for(p=pBt->pCursor; p; p=p->pNext){
+    if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) && 
+        p->eState==CURSOR_VALID ){
+      int rc = saveCursorPosition(p);
+      if( SQLITE_OK!=rc ){
+        return rc;
+      }
+    }
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Clear the current cursor position.
+*/
+static void clearCursorPosition(BtCursor *pCur){
+  assert( cursorHoldsMutex(pCur) );
+  sqlite3_free(pCur->pKey);
+  pCur->pKey = 0;
+  pCur->eState = CURSOR_INVALID;
+}
+
+/*
+** Restore the cursor to the position it was in (or as close to as possible)
+** when saveCursorPosition() was called. Note that this call deletes the 
+** saved position info stored by saveCursorPosition(), so there can be
+** at most one effective restoreOrClearCursorPosition() call after each 
+** saveCursorPosition().
+**
+** If the second argument argument - doSeek - is false, then instead of 
+** returning the cursor to its saved position, any saved position is deleted
+** and the cursor state set to CURSOR_INVALID.
+*/
+int sqlite3BtreeRestoreOrClearCursorPosition(BtCursor *pCur){
+  int rc;
+  assert( cursorHoldsMutex(pCur) );
+  assert( pCur->eState>=CURSOR_REQUIRESEEK );
+  if( pCur->eState==CURSOR_FAULT ){
+    return pCur->skip;
+  }
+#ifndef SQLITE_OMIT_INCRBLOB
+  if( pCur->isIncrblobHandle ){
+    return SQLITE_ABORT;
+  }
+#endif
+  pCur->eState = CURSOR_INVALID;
+  rc = sqlite3BtreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skip);
+  if( rc==SQLITE_OK ){
+    sqlite3_free(pCur->pKey);
+    pCur->pKey = 0;
+    assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
+  }
+  return rc;
+}
+
+#define restoreOrClearCursorPosition(p) \
+  (p->eState>=CURSOR_REQUIRESEEK ? \
+         sqlite3BtreeRestoreOrClearCursorPosition(p) : \
+         SQLITE_OK)
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+/*
+** Given a page number of a regular database page, return the page
+** number for the pointer-map page that contains the entry for the
+** input page number.
+*/
+static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
+  int nPagesPerMapPage, iPtrMap, ret;
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  nPagesPerMapPage = (pBt->usableSize/5)+1;
+  iPtrMap = (pgno-2)/nPagesPerMapPage;
+  ret = (iPtrMap*nPagesPerMapPage) + 2; 
+  if( ret==PENDING_BYTE_PAGE(pBt) ){
+    ret++;
+  }
+  return ret;
+}
+
+/*
+** Write an entry into the pointer map.
+**
+** This routine updates the pointer map entry for page number 'key'
+** so that it maps to type 'eType' and parent page number 'pgno'.
+** An error code is returned if something goes wrong, otherwise SQLITE_OK.
+*/
+static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){
+  DbPage *pDbPage;  /* The pointer map page */
+  u8 *pPtrmap;      /* The pointer map data */
+  Pgno iPtrmap;     /* The pointer map page number */
+  int offset;       /* Offset in pointer map page */
+  int rc;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  /* The master-journal page number must never be used as a pointer map page */
+  assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
+
+  assert( pBt->autoVacuum );
+  if( key==0 ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+  iPtrmap = PTRMAP_PAGENO(pBt, key);
+  rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  offset = PTRMAP_PTROFFSET(pBt, key);
+  pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
+
+  if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
+    TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
+    rc = sqlite3PagerWrite(pDbPage);
+    if( rc==SQLITE_OK ){
+      pPtrmap[offset] = eType;
+      put4byte(&pPtrmap[offset+1], parent);
+    }
+  }
+
+  sqlite3PagerUnref(pDbPage);
+  return rc;
+}
+
+/*
+** Read an entry from the pointer map.
+**
+** This routine retrieves the pointer map entry for page 'key', writing
+** the type and parent page number to *pEType and *pPgno respectively.
+** An error code is returned if something goes wrong, otherwise SQLITE_OK.
+*/
+static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
+  DbPage *pDbPage;   /* The pointer map page */
+  int iPtrmap;       /* Pointer map page index */
+  u8 *pPtrmap;       /* Pointer map page data */
+  int offset;        /* Offset of entry in pointer map */
+  int rc;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+
+  iPtrmap = PTRMAP_PAGENO(pBt, key);
+  rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
+  if( rc!=0 ){
+    return rc;
+  }
+  pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
+
+  offset = PTRMAP_PTROFFSET(pBt, key);
+  assert( pEType!=0 );
+  *pEType = pPtrmap[offset];
+  if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
+
+  sqlite3PagerUnref(pDbPage);
+  if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT;
+  return SQLITE_OK;
+}
+
+#endif /* SQLITE_OMIT_AUTOVACUUM */
+
+/*
+** Given a btree page and a cell index (0 means the first cell on
+** the page, 1 means the second cell, and so forth) return a pointer
+** to the cell content.
+**
+** This routine works only for pages that do not contain overflow cells.
+*/
+#define findCell(pPage, iCell) \
+  ((pPage)->aData + get2byte(&(pPage)->aData[(pPage)->cellOffset+2*(iCell)]))
+#ifdef SQLITE_TEST
+u8 *sqlite3BtreeFindCell(MemPage *pPage, int iCell){
+  assert( iCell>=0 );
+  assert( iCell<get2byte(&pPage->aData[pPage->hdrOffset+3]) );
+  return findCell(pPage, iCell);
+}
+#endif
+
+/*
+** This a more complex version of sqlite3BtreeFindCell() that works for
+** pages that do contain overflow cells.  See insert
+*/
+static u8 *findOverflowCell(MemPage *pPage, int iCell){
+  int i;
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  for(i=pPage->nOverflow-1; i>=0; i--){
+    int k;
+    struct _OvflCell *pOvfl;
+    pOvfl = &pPage->aOvfl[i];
+    k = pOvfl->idx;
+    if( k<=iCell ){
+      if( k==iCell ){
+        return pOvfl->pCell;
+      }
+      iCell--;
+    }
+  }
+  return findCell(pPage, iCell);
+}
+
+/*
+** Parse a cell content block and fill in the CellInfo structure.  There
+** are two versions of this function.  sqlite3BtreeParseCell() takes a 
+** cell index as the second argument and sqlite3BtreeParseCellPtr() 
+** takes a pointer to the body of the cell as its second argument.
+**
+** Within this file, the parseCell() macro can be called instead of
+** sqlite3BtreeParseCellPtr(). Using some compilers, this will be faster.
+*/
+void sqlite3BtreeParseCellPtr(
+  MemPage *pPage,         /* Page containing the cell */
+  u8 *pCell,              /* Pointer to the cell text. */
+  CellInfo *pInfo         /* Fill in this structure */
+){
+  int n;                  /* Number bytes in cell content header */
+  u32 nPayload;           /* Number of bytes of cell payload */
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+
+  pInfo->pCell = pCell;
+  assert( pPage->leaf==0 || pPage->leaf==1 );
+  n = pPage->childPtrSize;
+  assert( n==4-4*pPage->leaf );
+  if( pPage->hasData ){
+    n += getVarint32(&pCell[n], &nPayload);
+  }else{
+    nPayload = 0;
+  }
+  pInfo->nData = nPayload;
+  if( pPage->intKey ){
+    n += getVarint(&pCell[n], (u64 *)&pInfo->nKey);
+  }else{
+    u32 x;
+    n += getVarint32(&pCell[n], &x);
+    pInfo->nKey = x;
+    nPayload += x;
+  }
+  pInfo->nPayload = nPayload;
+  pInfo->nHeader = n;
+  if( nPayload<=pPage->maxLocal ){
+    /* This is the (easy) common case where the entire payload fits
+    ** on the local page.  No overflow is required.
+    */
+    int nSize;          /* Total size of cell content in bytes */
+    pInfo->nLocal = nPayload;
+    pInfo->iOverflow = 0;
+    nSize = nPayload + n;
+    if( nSize<4 ){
+      nSize = 4;        /* Minimum cell size is 4 */
+    }
+    pInfo->nSize = nSize;
+  }else{
+    /* If the payload will not fit completely on the local page, we have
+    ** to decide how much to store locally and how much to spill onto
+    ** overflow pages.  The strategy is to minimize the amount of unused
+    ** space on overflow pages while keeping the amount of local storage
+    ** in between minLocal and maxLocal.
+    **
+    ** Warning:  changing the way overflow payload is distributed in any
+    ** way will result in an incompatible file format.
+    */
+    int minLocal;  /* Minimum amount of payload held locally */
+    int maxLocal;  /* Maximum amount of payload held locally */
+    int surplus;   /* Overflow payload available for local storage */
+
+    minLocal = pPage->minLocal;
+    maxLocal = pPage->maxLocal;
+    surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
+    if( surplus <= maxLocal ){
+      pInfo->nLocal = surplus;
+    }else{
+      pInfo->nLocal = minLocal;
+    }
+    pInfo->iOverflow = pInfo->nLocal + n;
+    pInfo->nSize = pInfo->iOverflow + 4;
+  }
+}
+#define parseCell(pPage, iCell, pInfo) \
+  sqlite3BtreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo))
+void sqlite3BtreeParseCell(
+  MemPage *pPage,         /* Page containing the cell */
+  int iCell,              /* The cell index.  First cell is 0 */
+  CellInfo *pInfo         /* Fill in this structure */
+){
+  parseCell(pPage, iCell, pInfo);
+}
+
+/*
+** Compute the total number of bytes that a Cell needs in the cell
+** data area of the btree-page.  The return number includes the cell
+** data header and the local payload, but not any overflow page or
+** the space used by the cell pointer.
+*/
+#ifndef NDEBUG
+static int cellSize(MemPage *pPage, int iCell){
+  CellInfo info;
+  sqlite3BtreeParseCell(pPage, iCell, &info);
+  return info.nSize;
+}
+#endif
+static int cellSizePtr(MemPage *pPage, u8 *pCell){
+  CellInfo info;
+  sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+  return info.nSize;
+}
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+/*
+** If the cell pCell, part of page pPage contains a pointer
+** to an overflow page, insert an entry into the pointer-map
+** for the overflow page.
+*/
+static int ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell){
+  if( pCell ){
+    CellInfo info;
+    sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+    assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
+    if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
+      Pgno ovfl = get4byte(&pCell[info.iOverflow]);
+      return ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno);
+    }
+  }
+  return SQLITE_OK;
+}
+/*
+** If the cell with index iCell on page pPage contains a pointer
+** to an overflow page, insert an entry into the pointer-map
+** for the overflow page.
+*/
+static int ptrmapPutOvfl(MemPage *pPage, int iCell){
+  u8 *pCell;
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  pCell = findOverflowCell(pPage, iCell);
+  return ptrmapPutOvflPtr(pPage, pCell);
+}
+#endif
+
+
+/*
+** Defragment the page given.  All Cells are moved to the
+** end of the page and all free space is collected into one
+** big FreeBlk that occurs in between the header and cell
+** pointer array and the cell content area.
+*/
+static int defragmentPage(MemPage *pPage){
+  int i;                     /* Loop counter */
+  int pc;                    /* Address of a i-th cell */
+  int addr;                  /* Offset of first byte after cell pointer array */
+  int hdr;                   /* Offset to the page header */
+  int size;                  /* Size of a cell */
+  int usableSize;            /* Number of usable bytes on a page */
+  int cellOffset;            /* Offset to the cell pointer array */
+  int brk;                   /* Offset to the cell content area */
+  int nCell;                 /* Number of cells on the page */
+  unsigned char *data;       /* The page data */
+  unsigned char *temp;       /* Temp area for cell content */
+
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+  assert( pPage->pBt!=0 );
+  assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
+  assert( pPage->nOverflow==0 );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
+  data = pPage->aData;
+  hdr = pPage->hdrOffset;
+  cellOffset = pPage->cellOffset;
+  nCell = pPage->nCell;
+  assert( nCell==get2byte(&data[hdr+3]) );
+  usableSize = pPage->pBt->usableSize;
+  brk = get2byte(&data[hdr+5]);
+  memcpy(&temp[brk], &data[brk], usableSize - brk);
+  brk = usableSize;
+  for(i=0; i<nCell; i++){
+    u8 *pAddr;     /* The i-th cell pointer */
+    pAddr = &data[cellOffset + i*2];
+    pc = get2byte(pAddr);
+    assert( pc<pPage->pBt->usableSize );
+    size = cellSizePtr(pPage, &temp[pc]);
+    brk -= size;
+    memcpy(&data[brk], &temp[pc], size);
+    put2byte(pAddr, brk);
+  }
+  assert( brk>=cellOffset+2*nCell );
+  put2byte(&data[hdr+5], brk);
+  data[hdr+1] = 0;
+  data[hdr+2] = 0;
+  data[hdr+7] = 0;
+  addr = cellOffset+2*nCell;
+  memset(&data[addr], 0, brk-addr);
+  return SQLITE_OK;
+}
+
+/*
+** Allocate nByte bytes of space on a page.
+**
+** Return the index into pPage->aData[] of the first byte of
+** the new allocation. Or return 0 if there is not enough free
+** space on the page to satisfy the allocation request.
+**
+** If the page contains nBytes of free space but does not contain
+** nBytes of contiguous free space, then this routine automatically
+** calls defragementPage() to consolidate all free space before 
+** allocating the new chunk.
+*/
+static int allocateSpace(MemPage *pPage, int nByte){
+  int addr, pc, hdr;
+  int size;
+  int nFrag;
+  int top;
+  int nCell;
+  int cellOffset;
+  unsigned char *data;
+  
+  data = pPage->aData;
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+  assert( pPage->pBt );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( nByte<4 ) nByte = 4;
+  if( pPage->nFree<nByte || pPage->nOverflow>0 ) return 0;
+  pPage->nFree -= nByte;
+  hdr = pPage->hdrOffset;
+
+  nFrag = data[hdr+7];
+  if( nFrag<60 ){
+    /* Search the freelist looking for a slot big enough to satisfy the
+    ** space request. */
+    addr = hdr+1;
+    while( (pc = get2byte(&data[addr]))>0 ){
+      size = get2byte(&data[pc+2]);
+      if( size>=nByte ){
+        if( size<nByte+4 ){
+          memcpy(&data[addr], &data[pc], 2);
+          data[hdr+7] = nFrag + size - nByte;
+          return pc;
+        }else{
+          put2byte(&data[pc+2], size-nByte);
+          return pc + size - nByte;
+        }
+      }
+      addr = pc;
+    }
+  }
+
+  /* Allocate memory from the gap in between the cell pointer array
+  ** and the cell content area.
+  */
+  top = get2byte(&data[hdr+5]);
+  nCell = get2byte(&data[hdr+3]);
+  cellOffset = pPage->cellOffset;
+  if( nFrag>=60 || cellOffset + 2*nCell > top - nByte ){
+    if( defragmentPage(pPage) ) return 0;
+    top = get2byte(&data[hdr+5]);
+  }
+  top -= nByte;
+  assert( cellOffset + 2*nCell <= top );
+  put2byte(&data[hdr+5], top);
+  return top;
+}
+
+/*
+** Return a section of the pPage->aData to the freelist.
+** The first byte of the new free block is pPage->aDisk[start]
+** and the size of the block is "size" bytes.
+**
+** Most of the effort here is involved in coalesing adjacent
+** free blocks into a single big free block.
+*/
+static void freeSpace(MemPage *pPage, int start, int size){
+  int addr, pbegin, hdr;
+  unsigned char *data = pPage->aData;
+
+  assert( pPage->pBt!=0 );
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+  assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) );
+  assert( (start + size)<=pPage->pBt->usableSize );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( size<4 ) size = 4;
+
+#ifdef SQLITE_SECURE_DELETE
+  /* Overwrite deleted information with zeros when the SECURE_DELETE 
+  ** option is enabled at compile-time */
+  memset(&data[start], 0, size);
+#endif
+
+  /* Add the space back into the linked list of freeblocks */
+  hdr = pPage->hdrOffset;
+  addr = hdr + 1;
+  while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
+    assert( pbegin<=pPage->pBt->usableSize-4 );
+    assert( pbegin>addr );
+    addr = pbegin;
+  }
+  assert( pbegin<=pPage->pBt->usableSize-4 );
+  assert( pbegin>addr || pbegin==0 );
+  put2byte(&data[addr], start);
+  put2byte(&data[start], pbegin);
+  put2byte(&data[start+2], size);
+  pPage->nFree += size;
+
+  /* Coalesce adjacent free blocks */
+  addr = pPage->hdrOffset + 1;
+  while( (pbegin = get2byte(&data[addr]))>0 ){
+    int pnext, psize;
+    assert( pbegin>addr );
+    assert( pbegin<=pPage->pBt->usableSize-4 );
+    pnext = get2byte(&data[pbegin]);
+    psize = get2byte(&data[pbegin+2]);
+    if( pbegin + psize + 3 >= pnext && pnext>0 ){
+      int frag = pnext - (pbegin+psize);
+      assert( frag<=data[pPage->hdrOffset+7] );
+      data[pPage->hdrOffset+7] -= frag;
+      put2byte(&data[pbegin], get2byte(&data[pnext]));
+      put2byte(&data[pbegin+2], pnext+get2byte(&data[pnext+2])-pbegin);
+    }else{
+      addr = pbegin;
+    }
+  }
+
+  /* If the cell content area begins with a freeblock, remove it. */
+  if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
+    int top;
+    pbegin = get2byte(&data[hdr+1]);
+    memcpy(&data[hdr+1], &data[pbegin], 2);
+    top = get2byte(&data[hdr+5]);
+    put2byte(&data[hdr+5], top + get2byte(&data[pbegin+2]));
+  }
+}
+
+/*
+** Decode the flags byte (the first byte of the header) for a page
+** and initialize fields of the MemPage structure accordingly.
+*/
+static void decodeFlags(MemPage *pPage, int flagByte){
+  BtShared *pBt;     /* A copy of pPage->pBt */
+
+  assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  pPage->intKey = (flagByte & (PTF_INTKEY|PTF_LEAFDATA))!=0;
+  pPage->zeroData = (flagByte & PTF_ZERODATA)!=0;
+  pPage->leaf = (flagByte & PTF_LEAF)!=0;
+  pPage->childPtrSize = 4*(pPage->leaf==0);
+  pBt = pPage->pBt;
+  if( flagByte & PTF_LEAFDATA ){
+    pPage->leafData = 1;
+    pPage->maxLocal = pBt->maxLeaf;
+    pPage->minLocal = pBt->minLeaf;
+  }else{
+    pPage->leafData = 0;
+    pPage->maxLocal = pBt->maxLocal;
+    pPage->minLocal = pBt->minLocal;
+  }
+  pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData));
+}
+
+/*
+** Initialize the auxiliary information for a disk block.
+**
+** The pParent parameter must be a pointer to the MemPage which
+** is the parent of the page being initialized.  The root of a
+** BTree has no parent and so for that page, pParent==NULL.
+**
+** Return SQLITE_OK on success.  If we see that the page does
+** not contain a well-formed database page, then return 
+** SQLITE_CORRUPT.  Note that a return of SQLITE_OK does not
+** guarantee that the page is well-formed.  It only shows that
+** we failed to detect any corruption.
+*/
+int sqlite3BtreeInitPage(
+  MemPage *pPage,        /* The page to be initialized */
+  MemPage *pParent       /* The parent.  Might be NULL */
+){
+  int pc;            /* Address of a freeblock within pPage->aData[] */
+  int hdr;           /* Offset to beginning of page header */
+  u8 *data;          /* Equal to pPage->aData */
+  BtShared *pBt;        /* The main btree structure */
+  int usableSize;    /* Amount of usable space on each page */
+  int cellOffset;    /* Offset from start of page to first cell pointer */
+  int nFree;         /* Number of unused bytes on the page */
+  int top;           /* First byte of the cell content area */
+
+  pBt = pPage->pBt;
+  assert( pBt!=0 );
+  assert( pParent==0 || pParent->pBt==pBt );
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
+  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
+  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
+  if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){
+    /* The parent page should never change unless the file is corrupt */
+    return SQLITE_CORRUPT_BKPT;
+  }
+  if( pPage->isInit ) return SQLITE_OK;
+  if( pPage->pParent==0 && pParent!=0 ){
+    pPage->pParent = pParent;
+    sqlite3PagerRef(pParent->pDbPage);
+  }
+  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;
+  }
+  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;
+  }
+
+  /* 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; 
+    }
+    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; 
+    }
+    nFree += size;
+    pc = next;
+  }
+  pPage->nFree = nFree;
+  if( nFree>=usableSize ){
+    /* Free space cannot exceed total page size */
+    return SQLITE_CORRUPT_BKPT; 
+  }
+
+  pPage->isInit = 1;
+  return SQLITE_OK;
+}
+
+/*
+** Set up a raw page so that it looks like a database page holding
+** no entries.
+*/
+static void zeroPage(MemPage *pPage, int flags){
+  unsigned char *data = pPage->aData;
+  BtShared *pBt = pPage->pBt;
+  int hdr = pPage->hdrOffset;
+  int first;
+
+  assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
+  assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
+  assert( sqlite3PagerGetData(pPage->pDbPage) == data );
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  memset(&data[hdr], 0, pBt->usableSize - hdr);
+  data[hdr] = flags;
+  first = hdr + 8 + 4*((flags&PTF_LEAF)==0);
+  memset(&data[hdr+1], 0, 4);
+  data[hdr+7] = 0;
+  put2byte(&data[hdr+5], pBt->usableSize);
+  pPage->nFree = pBt->usableSize - first;
+  decodeFlags(pPage, flags);
+  pPage->hdrOffset = hdr;
+  pPage->cellOffset = first;
+  pPage->nOverflow = 0;
+  pPage->idxShift = 0;
+  pPage->nCell = 0;
+  pPage->isInit = 1;
+}
+
+/*
+** Get a page from the pager.  Initialize the MemPage.pBt and
+** MemPage.aData elements if needed.
+**
+** If the noContent flag is set, it means that we do not care about
+** the content of the page at this time.  So do not go to the disk
+** to fetch the content.  Just fill in the content with zeros for now.
+** If in the future we call sqlite3PagerWrite() on this page, that
+** means we have started to be concerned about content and the disk
+** read should occur at that point.
+*/
+int sqlite3BtreeGetPage(
+  BtShared *pBt,       /* The btree */
+  Pgno pgno,           /* Number of the page to fetch */
+  MemPage **ppPage,    /* Return the page in this parameter */
+  int noContent        /* Do not load page content if true */
+){
+  int rc;
+  MemPage *pPage;
+  DbPage *pDbPage;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
+  if( rc ) return rc;
+  pPage = (MemPage *)sqlite3PagerGetExtra(pDbPage);
+  pPage->aData = sqlite3PagerGetData(pDbPage);
+  pPage->pDbPage = pDbPage;
+  pPage->pBt = pBt;
+  pPage->pgno = pgno;
+  pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
+  *ppPage = pPage;
+  return SQLITE_OK;
+}
+
+/*
+** Get a page from the pager and initialize it.  This routine
+** is just a convenience wrapper around separate calls to
+** sqlite3BtreeGetPage() and sqlite3BtreeInitPage().
+*/
+static int getAndInitPage(
+  BtShared *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;
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  if( pgno==0 ){
+    return SQLITE_CORRUPT_BKPT; 
+  }
+  rc = sqlite3BtreeGetPage(pBt, pgno, ppPage, 0);
+  if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
+    rc = sqlite3BtreeInitPage(*ppPage, pParent);
+  }
+  return rc;
+}
+
+/*
+** Release a MemPage.  This should be called once for each prior
+** call to sqlite3BtreeGetPage.
+*/
+static void releasePage(MemPage *pPage){
+  if( pPage ){
+    assert( pPage->aData );
+    assert( pPage->pBt );
+    assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
+    assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
+    assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+    sqlite3PagerUnref(pPage->pDbPage);
+  }
+}
+
+/*
+** This routine is called when the reference count for a page
+** reaches zero.  We need to unref the pParent pointer when that
+** happens.
+*/
+static void pageDestructor(DbPage *pData, int pageSize){
+  MemPage *pPage;
+  assert( (pageSize & 7)==0 );
+  pPage = (MemPage *)sqlite3PagerGetExtra(pData);
+  assert( pPage->isInit==0 || sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( pPage->pParent ){
+    MemPage *pParent = pPage->pParent;
+    assert( pParent->pBt==pPage->pBt );
+    pPage->pParent = 0;
+    releasePage(pParent);
+  }
+  pPage->isInit = 0;
+}
+
+/*
+** During a rollback, when the pager reloads information into the cache
+** so that the cache is restored to its original state at the start of
+** the transaction, for each page restored this routine is called.
+**
+** This routine needs to reset the extra data section at the end of the
+** page to agree with the restored data.
+*/
+static void pageReinit(DbPage *pData, int pageSize){
+  MemPage *pPage;
+  assert( (pageSize & 7)==0 );
+  pPage = (MemPage *)sqlite3PagerGetExtra(pData);
+  if( pPage->isInit ){
+    assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+    pPage->isInit = 0;
+    sqlite3BtreeInitPage(pPage, pPage->pParent);
+  }
+}
+
+/*
+** Invoke the busy handler for a btree.
+*/
+static int sqlite3BtreeInvokeBusyHandler(void *pArg, int n){
+  BtShared *pBt = (BtShared*)pArg;
+  assert( pBt->db );
+  assert( sqlite3_mutex_held(pBt->db->mutex) );
+  return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
+}
+
+/*
+** Open a database file.
+** 
+** zFilename is the name of the database file.  If zFilename is NULL
+** a new database with a random name is created.  This randomly named
+** database file will be deleted when sqlite3BtreeClose() is called.
+** If zFilename is ":memory:" then an in-memory database is created
+** that is automatically destroyed when it is closed.
+*/
+int sqlite3BtreeOpen(
+  const char *zFilename,  /* Name of the file containing the BTree database */
+  sqlite3 *db,            /* Associated database handle */
+  Btree **ppBtree,        /* Pointer to new Btree object written here */
+  int flags,              /* Options */
+  int vfsFlags            /* Flags passed through to sqlite3_vfs.xOpen() */
+){
+  sqlite3_vfs *pVfs;      /* The VFS to use for this btree */
+  BtShared *pBt = 0;      /* Shared part of btree structure */
+  Btree *p;               /* Handle to return */
+  int rc = SQLITE_OK;
+  int nReserve;
+  unsigned char zDbHeader[100];
+
+  /* Set the variable isMemdb to true for an in-memory database, or 
+  ** false for a file-based database. This symbol is only required if
+  ** either of the shared-data or autovacuum features are compiled 
+  ** into the library.
+  */
+#if !defined(SQLITE_OMIT_SHARED_CACHE) || !defined(SQLITE_OMIT_AUTOVACUUM)
+  #ifdef SQLITE_OMIT_MEMORYDB
+    const int isMemdb = 0;
+  #else
+    const int isMemdb = zFilename && !strcmp(zFilename, ":memory:");
+  #endif
+#endif
+
+  assert( db!=0 );
+  assert( sqlite3_mutex_held(db->mutex) );
+
+  pVfs = db->pVfs;
+  p = sqlite3MallocZero(sizeof(Btree));
+  if( !p ){
+    return SQLITE_NOMEM;
+  }
+  p->inTrans = TRANS_NONE;
+  p->db = db;
+
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
+  /*
+  ** If this Btree is a candidate for shared cache, try to find an
+  ** existing BtShared object that we can share with
+  */
+  if( (flags & BTREE_PRIVATE)==0
+   && isMemdb==0
+   && (db->flags & SQLITE_Vtab)==0
+   && zFilename && zFilename[0]
+  ){
+    if( sqlite3SharedCacheEnabled ){
+      int nFullPathname = pVfs->mxPathname+1;
+      char *zFullPathname = (char *)sqlite3_malloc(nFullPathname);
+      sqlite3_mutex *mutexShared;
+      p->sharable = 1;
+      if( db ){
+        db->flags |= SQLITE_SharedCache;
+      }
+      if( !zFullPathname ){
+        sqlite3_free(p);
+        return SQLITE_NOMEM;
+      }
+      sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname);
+      mutexShared = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+      sqlite3_mutex_enter(mutexShared);
+      for(pBt=sqlite3SharedCacheList; pBt; pBt=pBt->pNext){
+        assert( pBt->nRef>0 );
+        if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
+                 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
+          p->pBt = pBt;
+          pBt->nRef++;
+          break;
+        }
+      }
+      sqlite3_mutex_leave(mutexShared);
+      sqlite3_free(zFullPathname);
+    }
+#ifdef SQLITE_DEBUG
+    else{
+      /* In debug mode, we mark all persistent databases as sharable
+      ** even when they are not.  This exercises the locking code and
+      ** gives more opportunity for asserts(sqlite3_mutex_held())
+      ** statements to find locking problems.
+      */
+      p->sharable = 1;
+    }
+#endif
+  }
+#endif
+  if( pBt==0 ){
+    /*
+    ** The following asserts make sure that structures used by the btree are
+    ** the right size.  This is to guard against size changes that result
+    ** when compiling on a different architecture.
+    */
+    assert( sizeof(i64)==8 || sizeof(i64)==4 );
+    assert( sizeof(u64)==8 || sizeof(u64)==4 );
+    assert( sizeof(u32)==4 );
+    assert( sizeof(u16)==2 );
+    assert( sizeof(Pgno)==4 );
+  
+    pBt = sqlite3MallocZero( sizeof(*pBt) );
+    if( pBt==0 ){
+      rc = SQLITE_NOMEM;
+      goto btree_open_out;
+    }
+    pBt->busyHdr.xFunc = sqlite3BtreeInvokeBusyHandler;
+    pBt->busyHdr.pArg = pBt;
+    rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
+                          EXTRA_SIZE, flags, vfsFlags);
+    if( rc==SQLITE_OK ){
+      rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
+    }
+    if( rc!=SQLITE_OK ){
+      goto btree_open_out;
+    }
+    sqlite3PagerSetBusyhandler(pBt->pPager, &pBt->busyHdr);
+    p->pBt = pBt;
+  
+    sqlite3PagerSetDestructor(pBt->pPager, pageDestructor);
+    sqlite3PagerSetReiniter(pBt->pPager, pageReinit);
+    pBt->pCursor = 0;
+    pBt->pPage1 = 0;
+    pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager);
+    pBt->pageSize = get2byte(&zDbHeader[16]);
+    if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
+         || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
+      pBt->pageSize = 0;
+      sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
+      pBt->maxEmbedFrac = 64;   /* 25% */
+      pBt->minEmbedFrac = 32;   /* 12.5% */
+      pBt->minLeafFrac = 32;    /* 12.5% */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      /* If the magic name ":memory:" will create an in-memory database, then
+      ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
+      ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
+      ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
+      ** regular file-name. In this case the auto-vacuum applies as per normal.
+      */
+      if( zFilename && !isMemdb ){
+        pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
+        pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
+      }
+#endif
+      nReserve = 0;
+    }else{
+      nReserve = zDbHeader[20];
+      pBt->maxEmbedFrac = zDbHeader[21];
+      pBt->minEmbedFrac = zDbHeader[22];
+      pBt->minLeafFrac = zDbHeader[23];
+      pBt->pageSizeFixed = 1;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
+      pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
+#endif
+    }
+    pBt->usableSize = pBt->pageSize - nReserve;
+    assert( (pBt->pageSize & 7)==0 );  /* 8-byte alignment of pageSize */
+    sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
+   
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
+    /* Add the new BtShared object to the linked list sharable BtShareds.
+    */
+    if( p->sharable ){
+      sqlite3_mutex *mutexShared;
+      pBt->nRef = 1;
+      mutexShared = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+      if( SQLITE_THREADSAFE ){
+        pBt->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
+        if( pBt->mutex==0 ){
+          rc = SQLITE_NOMEM;
+          db->mallocFailed = 0;
+          goto btree_open_out;
+        }
+      }
+      sqlite3_mutex_enter(mutexShared);
+      pBt->pNext = sqlite3SharedCacheList;
+      sqlite3SharedCacheList = pBt;
+      sqlite3_mutex_leave(mutexShared);
+    }
+#endif
+  }
+
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
+  /* If the new Btree uses a sharable pBtShared, then link the new
+  ** Btree into the list of all sharable Btrees for the same connection.
+  ** The list is kept in ascending order by pBt address.
+  */
+  if( p->sharable ){
+    int i;
+    Btree *pSib;
+    for(i=0; i<db->nDb; i++){
+      if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
+        while( pSib->pPrev ){ pSib = pSib->pPrev; }
+        if( p->pBt<pSib->pBt ){
+          p->pNext = pSib;
+          p->pPrev = 0;
+          pSib->pPrev = p;
+        }else{
+          while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
+            pSib = pSib->pNext;
+          }
+          p->pNext = pSib->pNext;
+          p->pPrev = pSib;
+          if( p->pNext ){
+            p->pNext->pPrev = p;
+          }
+          pSib->pNext = p;
+        }
+        break;
+      }
+    }
+  }
+#endif
+  *ppBtree = p;
+
+btree_open_out:
+  if( rc!=SQLITE_OK ){
+    if( pBt && pBt->pPager ){
+      sqlite3PagerClose(pBt->pPager);
+    }
+    sqlite3_free(pBt);
+    sqlite3_free(p);
+    *ppBtree = 0;
+  }
+  return rc;
+}
+
+/*
+** Decrement the BtShared.nRef counter.  When it reaches zero,
+** remove the BtShared structure from the sharing list.  Return
+** true if the BtShared.nRef counter reaches zero and return
+** false if it is still positive.
+*/
+static int removeFromSharingList(BtShared *pBt){
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  sqlite3_mutex *pMaster;
+  BtShared *pList;
+  int removed = 0;
+
+  assert( sqlite3_mutex_notheld(pBt->mutex) );
+  pMaster = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_mutex_enter(pMaster);
+  pBt->nRef--;
+  if( pBt->nRef<=0 ){
+    if( sqlite3SharedCacheList==pBt ){
+      sqlite3SharedCacheList = pBt->pNext;
+    }else{
+      pList = sqlite3SharedCacheList;
+      while( pList && pList->pNext!=pBt ){
+        pList=pList->pNext;
+      }
+      if( pList ){
+        pList->pNext = pBt->pNext;
+      }
+    }
+    if( SQLITE_THREADSAFE ){
+      sqlite3_mutex_free(pBt->mutex);
+    }
+    removed = 1;
+  }
+  sqlite3_mutex_leave(pMaster);
+  return removed;
+#else
+  return 1;
+#endif
+}
+
+/*
+** Close an open database and invalidate all cursors.
+*/
+int sqlite3BtreeClose(Btree *p){
+  BtShared *pBt = p->pBt;
+  BtCursor *pCur;
+
+  /* Close all cursors opened via this handle.  */
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  pCur = pBt->pCursor;
+  while( pCur ){
+    BtCursor *pTmp = pCur;
+    pCur = pCur->pNext;
+    if( pTmp->pBtree==p ){
+      sqlite3BtreeCloseCursor(pTmp);
+    }
+  }
+
+  /* Rollback any active transaction and free the handle structure.
+  ** The call to sqlite3BtreeRollback() drops any table-locks held by
+  ** this handle.
+  */
+  sqlite3BtreeRollback(p);
+  sqlite3BtreeLeave(p);
+
+  /* If there are still other outstanding references to the shared-btree
+  ** structure, return now. The remainder of this procedure cleans 
+  ** up the shared-btree.
+  */
+  assert( p->wantToLock==0 && p->locked==0 );
+  if( !p->sharable || removeFromSharingList(pBt) ){
+    /* The pBt is no longer on the sharing list, so we can access
+    ** it without having to hold the mutex.
+    **
+    ** Clean out and delete the BtShared object.
+    */
+    assert( !pBt->pCursor );
+    sqlite3PagerClose(pBt->pPager);
+    if( pBt->xFreeSchema && pBt->pSchema ){
+      pBt->xFreeSchema(pBt->pSchema);
+    }
+    sqlite3_free(pBt->pSchema);
+    sqlite3_free(pBt);
+  }
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  assert( p->wantToLock==0 );
+  assert( p->locked==0 );
+  if( p->pPrev ) p->pPrev->pNext = p->pNext;
+  if( p->pNext ) p->pNext->pPrev = p->pPrev;
+#endif
+
+  sqlite3_free(p);
+  return SQLITE_OK;
+}
+
+/*
+** Change the limit on the number of pages allowed in the cache.
+**
+** The maximum number of cache pages is set to the absolute
+** value of mxPage.  If mxPage is negative, the pager will
+** operate asynchronously - it will not stop to do fsync()s
+** to insure data is written to the disk surface before
+** continuing.  Transactions still work if synchronous is off,
+** and the database cannot be corrupted if this program
+** crashes.  But if the operating system crashes or there is
+** an abrupt power failure when synchronous is off, the database
+** could be left in an inconsistent and unrecoverable state.
+** Synchronous is on by default so database corruption is not
+** normally a worry.
+*/
+int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
+  BtShared *pBt = p->pBt;
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  sqlite3BtreeEnter(p);
+  sqlite3PagerSetCachesize(pBt->pPager, mxPage);
+  sqlite3BtreeLeave(p);
+  return SQLITE_OK;
+}
+
+/*
+** Change the way data is synced to disk in order to increase or decrease
+** how well the database resists damage due to OS crashes and power
+** failures.  Level 1 is the same as asynchronous (no syncs() occur and
+** there is a high probability of damage)  Level 2 is the default.  There
+** is a very low but non-zero probability of damage.  Level 3 reduces the
+** probability of damage to near zero but with a write performance reduction.
+*/
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){
+  BtShared *pBt = p->pBt;
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  sqlite3BtreeEnter(p);
+  sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync);
+  sqlite3BtreeLeave(p);
+  return SQLITE_OK;
+}
+#endif
+
+/*
+** Return TRUE if the given btree is set to safety level 1.  In other
+** words, return TRUE if no sync() occurs on the disk files.
+*/
+int sqlite3BtreeSyncDisabled(Btree *p){
+  BtShared *pBt = p->pBt;
+  int rc;
+  assert( sqlite3_mutex_held(p->db->mutex) );  
+  sqlite3BtreeEnter(p);
+  assert( pBt && pBt->pPager );
+  rc = sqlite3PagerNosync(pBt->pPager);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
+/*
+** Change the default pages size and the number of reserved bytes per page.
+**
+** The page size must be a power of 2 between 512 and 65536.  If the page
+** size supplied does not meet this constraint then the page size is not
+** changed.
+**
+** Page sizes are constrained to be a power of two so that the region
+** of the database file used for locking (beginning at PENDING_BYTE,
+** the first byte past the 1GB boundary, 0x40000000) needs to occur
+** at the beginning of a page.
+**
+** If parameter nReserve is less than zero, then the number of reserved
+** bytes per page is left unchanged.
+*/
+int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){
+  int rc = SQLITE_OK;
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  if( pBt->pageSizeFixed ){
+    sqlite3BtreeLeave(p);
+    return SQLITE_READONLY;
+  }
+  if( nReserve<0 ){
+    nReserve = pBt->pageSize - pBt->usableSize;
+  }
+  if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
+        ((pageSize-1)&pageSize)==0 ){
+    assert( (pageSize & 7)==0 );
+    assert( !pBt->pPage1 && !pBt->pCursor );
+    pBt->pageSize = pageSize;
+    rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
+  }
+  pBt->usableSize = pBt->pageSize - nReserve;
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Return the currently defined page size
+*/
+int sqlite3BtreeGetPageSize(Btree *p){
+  return p->pBt->pageSize;
+}
+int sqlite3BtreeGetReserve(Btree *p){
+  int n;
+  sqlite3BtreeEnter(p);
+  n = p->pBt->pageSize - p->pBt->usableSize;
+  sqlite3BtreeLeave(p);
+  return n;
+}
+
+/*
+** Set the maximum page count for a database if mxPage is positive.
+** No changes are made if mxPage is 0 or negative.
+** Regardless of the value of mxPage, return the maximum page count.
+*/
+int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
+  int n;
+  sqlite3BtreeEnter(p);
+  n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
+  sqlite3BtreeLeave(p);
+  return n;
+}
+#endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */
+
+/*
+** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
+** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
+** is disabled. The default value for the auto-vacuum property is 
+** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
+*/
+int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  return SQLITE_READONLY;
+#else
+  BtShared *pBt = p->pBt;
+  int rc = SQLITE_OK;
+  int av = (autoVacuum?1:0);
+
+  sqlite3BtreeEnter(p);
+  if( pBt->pageSizeFixed && av!=pBt->autoVacuum ){
+    rc = SQLITE_READONLY;
+  }else{
+    pBt->autoVacuum = av;
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+#endif
+}
+
+/*
+** Return the value of the 'auto-vacuum' property. If auto-vacuum is 
+** enabled 1 is returned. Otherwise 0.
+*/
+int sqlite3BtreeGetAutoVacuum(Btree *p){
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  return BTREE_AUTOVACUUM_NONE;
+#else
+  int rc;
+  sqlite3BtreeEnter(p);
+  rc = (
+    (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
+    (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
+    BTREE_AUTOVACUUM_INCR
+  );
+  sqlite3BtreeLeave(p);
+  return rc;
+#endif
+}
+
+
+/*
+** Get a reference to pPage1 of the database file.  This will
+** also acquire a readlock on that file.
+**
+** SQLITE_OK is returned on success.  If the file is not a
+** well-formed database file, then SQLITE_CORRUPT is returned.
+** SQLITE_BUSY is returned if the database is locked.  SQLITE_NOMEM
+** is returned if we run out of memory. 
+*/
+static int lockBtree(BtShared *pBt){
+  int rc, pageSize;
+  MemPage *pPage1;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  if( pBt->pPage1 ) return SQLITE_OK;
+  rc = sqlite3BtreeGetPage(pBt, 1, &pPage1, 0);
+  if( rc!=SQLITE_OK ) return rc;
+  
+
+  /* Do some checking to help insure the file we opened really is
+  ** a valid database file. 
+  */
+  rc = SQLITE_NOTADB;
+  if( sqlite3PagerPagecount(pBt->pPager)>0 ){
+    u8 *page1 = pPage1->aData;
+    if( memcmp(page1, zMagicHeader, 16)!=0 ){
+      goto page1_init_failed;
+    }
+    if( page1[18]>1 ){
+      pBt->readOnly = 1;
+    }
+    if( page1[19]>1 ){
+      goto page1_init_failed;
+    }
+    pageSize = get2byte(&page1[16]);
+    if( ((pageSize-1)&pageSize)!=0 || pageSize<512 ||
+        (SQLITE_MAX_PAGE_SIZE<32768 && pageSize>SQLITE_MAX_PAGE_SIZE)
+    ){
+      goto page1_init_failed;
+    }
+    assert( (pageSize & 7)==0 );
+    pBt->pageSize = pageSize;
+    pBt->usableSize = pageSize - page1[20];
+    if( pBt->usableSize<500 ){
+      goto page1_init_failed;
+    }
+    pBt->maxEmbedFrac = page1[21];
+    pBt->minEmbedFrac = page1[22];
+    pBt->minLeafFrac = page1[23];
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
+    pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
+#endif
+  }
+
+  /* maxLocal is the maximum amount of payload to store locally for
+  ** a cell.  Make sure it is small enough so that at least minFanout
+  ** cells can will fit on one page.  We assume a 10-byte page header.
+  ** Besides the payload, the cell must store:
+  **     2-byte pointer to the cell
+  **     4-byte child pointer
+  **     9-byte nKey value
+  **     4-byte nData value
+  **     4-byte overflow page pointer
+  ** So a cell consists of a 2-byte poiner, a header which is as much as
+  ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
+  ** page pointer.
+  */
+  pBt->maxLocal = (pBt->usableSize-12)*pBt->maxEmbedFrac/255 - 23;
+  pBt->minLocal = (pBt->usableSize-12)*pBt->minEmbedFrac/255 - 23;
+  pBt->maxLeaf = pBt->usableSize - 35;
+  pBt->minLeaf = (pBt->usableSize-12)*pBt->minLeafFrac/255 - 23;
+  if( pBt->minLocal>pBt->maxLocal || pBt->maxLocal<0 ){
+    goto page1_init_failed;
+  }
+  assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
+  pBt->pPage1 = pPage1;
+  return SQLITE_OK;
+
+page1_init_failed:
+  releasePage(pPage1);
+  pBt->pPage1 = 0;
+  return rc;
+}
+
+/*
+** This routine works like lockBtree() except that it also invokes the
+** busy callback if there is lock contention.
+*/
+static int lockBtreeWithRetry(Btree *pRef){
+  int rc = SQLITE_OK;
+
+  assert( sqlite3BtreeHoldsMutex(pRef) );
+  if( pRef->inTrans==TRANS_NONE ){
+    u8 inTransaction = pRef->pBt->inTransaction;
+    btreeIntegrity(pRef);
+    rc = sqlite3BtreeBeginTrans(pRef, 0);
+    pRef->pBt->inTransaction = inTransaction;
+    pRef->inTrans = TRANS_NONE;
+    if( rc==SQLITE_OK ){
+      pRef->pBt->nTransaction--;
+    }
+    btreeIntegrity(pRef);
+  }
+  return rc;
+}
+       
+
+/*
+** If there are no outstanding cursors and we are not in the middle
+** of a transaction but there is a read lock on the database, then
+** this routine unrefs the first page of the database file which 
+** has the effect of releasing the read lock.
+**
+** If there are any outstanding cursors, this routine is a no-op.
+**
+** If there is a transaction in progress, this routine is a no-op.
+*/
+static void unlockBtreeIfUnused(BtShared *pBt){
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){
+    if( sqlite3PagerRefcount(pBt->pPager)>=1 ){
+      assert( pBt->pPage1->aData );
+#if 0
+      if( pBt->pPage1->aData==0 ){
+        MemPage *pPage = pBt->pPage1;
+        pPage->aData = sqlite3PagerGetData(pPage->pDbPage);
+        pPage->pBt = pBt;
+        pPage->pgno = 1;
+      }
+#endif
+      releasePage(pBt->pPage1);
+    }
+    pBt->pPage1 = 0;
+    pBt->inStmt = 0;
+  }
+}
+
+/*
+** Create a new database by initializing the first page of the
+** file.
+*/
+static int newDatabase(BtShared *pBt){
+  MemPage *pP1;
+  unsigned char *data;
+  int rc;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  if( sqlite3PagerPagecount(pBt->pPager)>0 ) return SQLITE_OK;
+  pP1 = pBt->pPage1;
+  assert( pP1!=0 );
+  data = pP1->aData;
+  rc = sqlite3PagerWrite(pP1->pDbPage);
+  if( rc ) return rc;
+  memcpy(data, zMagicHeader, sizeof(zMagicHeader));
+  assert( sizeof(zMagicHeader)==16 );
+  put2byte(&data[16], pBt->pageSize);
+  data[18] = 1;
+  data[19] = 1;
+  data[20] = pBt->pageSize - pBt->usableSize;
+  data[21] = pBt->maxEmbedFrac;
+  data[22] = pBt->minEmbedFrac;
+  data[23] = pBt->minLeafFrac;
+  memset(&data[24], 0, 100-24);
+  zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
+  pBt->pageSizeFixed = 1;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
+  assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
+  put4byte(&data[36 + 4*4], pBt->autoVacuum);
+  put4byte(&data[36 + 7*4], pBt->incrVacuum);
+#endif
+  return SQLITE_OK;
+}
+
+/*
+** Attempt to start a new transaction. A write-transaction
+** is started if the second argument is nonzero, otherwise a read-
+** transaction.  If the second argument is 2 or more and exclusive
+** transaction is started, meaning that no other process is allowed
+** to access the database.  A preexisting transaction may not be
+** upgraded to exclusive by calling this routine a second time - the
+** exclusivity flag only works for a new transaction.
+**
+** A write-transaction must be started before attempting any 
+** changes to the database.  None of the following routines 
+** will work unless a transaction is started first:
+**
+**      sqlite3BtreeCreateTable()
+**      sqlite3BtreeCreateIndex()
+**      sqlite3BtreeClearTable()
+**      sqlite3BtreeDropTable()
+**      sqlite3BtreeInsert()
+**      sqlite3BtreeDelete()
+**      sqlite3BtreeUpdateMeta()
+**
+** If an initial attempt to acquire the lock fails because of lock contention
+** and the database was previously unlocked, then invoke the busy handler
+** if there is one.  But if there was previously a read-lock, do not
+** invoke the busy handler - just return SQLITE_BUSY.  SQLITE_BUSY is 
+** returned when there is already a read-lock in order to avoid a deadlock.
+**
+** Suppose there are two processes A and B.  A has a read lock and B has
+** a reserved lock.  B tries to promote to exclusive but is blocked because
+** of A's read lock.  A tries to promote to reserved but is blocked by B.
+** One or the other of the two processes must give way or there can be
+** no progress.  By returning SQLITE_BUSY and not invoking the busy callback
+** when A already has a read lock, we encourage A to give up and let B
+** proceed.
+*/
+int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
+  BtShared *pBt = p->pBt;
+  int rc = SQLITE_OK;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  btreeIntegrity(p);
+
+  /* If the btree is already in a write-transaction, or it
+  ** is already in a read-transaction and a read-transaction
+  ** is requested, this is a no-op.
+  */
+  if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
+    goto trans_begun;
+  }
+
+  /* Write transactions are not possible on a read-only database */
+  if( pBt->readOnly && wrflag ){
+    rc = SQLITE_READONLY;
+    goto trans_begun;
+  }
+
+  /* If another database handle has already opened a write transaction 
+  ** on this shared-btree structure and a second write transaction is
+  ** requested, return SQLITE_BUSY.
+  */
+  if( pBt->inTransaction==TRANS_WRITE && wrflag ){
+    rc = SQLITE_BUSY;
+    goto trans_begun;
+  }
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  if( wrflag>1 ){
+    BtLock *pIter;
+    for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
+      if( pIter->pBtree!=p ){
+        rc = SQLITE_BUSY;
+        goto trans_begun;
+      }
+    }
+  }
+#endif
+
+  do {
+    if( pBt->pPage1==0 ){
+      rc = lockBtree(pBt);
+    }
+
+    if( rc==SQLITE_OK && wrflag ){
+      if( pBt->readOnly ){
+        rc = SQLITE_READONLY;
+      }else{
+        rc = sqlite3PagerBegin(pBt->pPage1->pDbPage, wrflag>1);
+        if( rc==SQLITE_OK ){
+          rc = newDatabase(pBt);
+        }
+      }
+    }
+  
+    if( rc==SQLITE_OK ){
+      if( wrflag ) pBt->inStmt = 0;
+    }else{
+      unlockBtreeIfUnused(pBt);
+    }
+  }while( rc==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
+          sqlite3BtreeInvokeBusyHandler(pBt, 0) );
+
+  if( rc==SQLITE_OK ){
+    if( p->inTrans==TRANS_NONE ){
+      pBt->nTransaction++;
+    }
+    p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
+    if( p->inTrans>pBt->inTransaction ){
+      pBt->inTransaction = p->inTrans;
+    }
+#ifndef SQLITE_OMIT_SHARED_CACHE
+    if( wrflag>1 ){
+      assert( !pBt->pExclusive );
+      pBt->pExclusive = p;
+    }
+#endif
+  }
+
+
+trans_begun:
+  btreeIntegrity(p);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+
+/*
+** Set the pointer-map entries for all children of page pPage. Also, if
+** pPage contains cells that point to overflow pages, set the pointer
+** map entries for the overflow pages as well.
+*/
+static int setChildPtrmaps(MemPage *pPage){
+  int i;                             /* Counter variable */
+  int nCell;                         /* Number of cells in page pPage */
+  int rc;                            /* Return code */
+  BtShared *pBt = pPage->pBt;
+  int isInitOrig = pPage->isInit;
+  Pgno pgno = pPage->pgno;
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  rc = sqlite3BtreeInitPage(pPage, pPage->pParent);
+  if( rc!=SQLITE_OK ){
+    goto set_child_ptrmaps_out;
+  }
+  nCell = pPage->nCell;
+
+  for(i=0; i<nCell; i++){
+    u8 *pCell = findCell(pPage, i);
+
+    rc = ptrmapPutOvflPtr(pPage, pCell);
+    if( rc!=SQLITE_OK ){
+      goto set_child_ptrmaps_out;
+    }
+
+    if( !pPage->leaf ){
+      Pgno childPgno = get4byte(pCell);
+      rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
+      if( rc!=SQLITE_OK ) goto set_child_ptrmaps_out;
+    }
+  }
+
+  if( !pPage->leaf ){
+    Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
+    rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
+  }
+
+set_child_ptrmaps_out:
+  pPage->isInit = isInitOrig;
+  return rc;
+}
+
+/*
+** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow
+** page, is a pointer to page iFrom. Modify this pointer so that it points to
+** iTo. Parameter eType describes the type of pointer to be modified, as 
+** follows:
+**
+** PTRMAP_BTREE:     pPage is a btree-page. The pointer points at a child 
+**                   page of pPage.
+**
+** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
+**                   page pointed to by one of the cells on pPage.
+**
+** 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){
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  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_BKPT;
+    }
+    put4byte(pPage->aData, iTo);
+  }else{
+    int isInitOrig = pPage->isInit;
+    int i;
+    int nCell;
+
+    sqlite3BtreeInitPage(pPage, 0);
+    nCell = pPage->nCell;
+
+    for(i=0; i<nCell; i++){
+      u8 *pCell = findCell(pPage, i);
+      if( eType==PTRMAP_OVERFLOW1 ){
+        CellInfo info;
+        sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+        if( info.iOverflow ){
+          if( iFrom==get4byte(&pCell[info.iOverflow]) ){
+            put4byte(&pCell[info.iOverflow], iTo);
+            break;
+          }
+        }
+      }else{
+        if( get4byte(pCell)==iFrom ){
+          put4byte(pCell, iTo);
+          break;
+        }
+      }
+    }
+  
+    if( i==nCell ){
+      if( eType!=PTRMAP_BTREE || 
+          get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
+        return SQLITE_CORRUPT_BKPT;
+      }
+      put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
+    }
+
+    pPage->isInit = isInitOrig;
+  }
+  return SQLITE_OK;
+}
+
+
+/*
+** Move the open database page pDbPage to location iFreePage in the 
+** database. The pDbPage reference remains valid.
+*/
+static int relocatePage(
+  BtShared *pBt,           /* Btree */
+  MemPage *pDbPage,        /* Open page to move */
+  u8 eType,                /* Pointer map 'type' entry for pDbPage */
+  Pgno iPtrPage,           /* Pointer map 'page-no' entry for pDbPage */
+  Pgno iFreePage           /* The location to move pDbPage to */
+){
+  MemPage *pPtrPage;   /* The page that contains a pointer to pDbPage */
+  Pgno iDbPage = pDbPage->pgno;
+  Pager *pPager = pBt->pPager;
+  int rc;
+
+  assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || 
+      eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  assert( pDbPage->pBt==pBt );
+
+  /* Move page iDbPage from its current location to page number iFreePage */
+  TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", 
+      iDbPage, iFreePage, iPtrPage, eType));
+  rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  pDbPage->pgno = iFreePage;
+
+  /* If pDbPage was a btree-page, then it may have child pages and/or cells
+  ** that point to overflow pages. The pointer map entries for all these
+  ** pages need to be changed.
+  **
+  ** If pDbPage is an overflow page, then the first 4 bytes may store a
+  ** pointer to a subsequent overflow page. If this is the case, then
+  ** the pointer map needs to be updated for the subsequent overflow page.
+  */
+  if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
+    rc = setChildPtrmaps(pDbPage);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+  }else{
+    Pgno nextOvfl = get4byte(pDbPage->aData);
+    if( nextOvfl!=0 ){
+      rc = ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+    }
+  }
+
+  /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
+  ** that it points at iFreePage. Also fix the pointer map entry for
+  ** iPtrPage.
+  */
+  if( eType!=PTRMAP_ROOTPAGE ){
+    rc = sqlite3BtreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    rc = sqlite3PagerWrite(pPtrPage->pDbPage);
+    if( rc!=SQLITE_OK ){
+      releasePage(pPtrPage);
+      return rc;
+    }
+    rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
+    releasePage(pPtrPage);
+    if( rc==SQLITE_OK ){
+      rc = ptrmapPut(pBt, iFreePage, eType, iPtrPage);
+    }
+  }
+  return rc;
+}
+
+/* Forward declaration required by incrVacuumStep(). */
+static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
+
+/*
+** Perform a single step of an incremental-vacuum. If successful,
+** return SQLITE_OK. If there is no work to do (and therefore no
+** point in calling this function again), return SQLITE_DONE.
+**
+** More specificly, this function attempts to re-organize the 
+** database so that the last page of the file currently in use
+** is no longer in use.
+**
+** If the nFin parameter is non-zero, the implementation assumes
+** that the caller will keep calling incrVacuumStep() until
+** it returns SQLITE_DONE or an error, and that nFin is the
+** number of pages the database file will contain after this 
+** process is complete.
+*/
+static int incrVacuumStep(BtShared *pBt, Pgno nFin){
+  Pgno iLastPg;             /* Last page in the database */
+  Pgno nFreeList;           /* Number of pages still on the free-list */
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  iLastPg = pBt->nTrunc;
+  if( iLastPg==0 ){
+    iLastPg = sqlite3PagerPagecount(pBt->pPager);
+  }
+
+  if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
+    int rc;
+    u8 eType;
+    Pgno iPtrPage;
+
+    nFreeList = get4byte(&pBt->pPage1->aData[36]);
+    if( nFreeList==0 || nFin==iLastPg ){
+      return SQLITE_DONE;
+    }
+
+    rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    if( eType==PTRMAP_ROOTPAGE ){
+      return SQLITE_CORRUPT_BKPT;
+    }
+
+    if( eType==PTRMAP_FREEPAGE ){
+      if( nFin==0 ){
+        /* Remove the page from the files free-list. This is not required
+        ** if nFin is non-zero. In that case, the free-list will be
+        ** truncated to zero after this function returns, so it doesn't 
+        ** matter if it still contains some garbage entries.
+        */
+        Pgno iFreePg;
+        MemPage *pFreePg;
+        rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        assert( iFreePg==iLastPg );
+        releasePage(pFreePg);
+      }
+    } else {
+      Pgno iFreePg;             /* Index of free page to move pLastPg to */
+      MemPage *pLastPg;
+
+      rc = sqlite3BtreeGetPage(pBt, iLastPg, &pLastPg, 0);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+
+      /* If nFin is zero, this loop runs exactly once and page pLastPg
+      ** is swapped with the first free page pulled off the free list.
+      **
+      ** On the other hand, if nFin is greater than zero, then keep
+      ** looping until a free-page located within the first nFin pages
+      ** of the file is found.
+      */
+      do {
+        MemPage *pFreePg;
+        rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
+        if( rc!=SQLITE_OK ){
+          releasePage(pLastPg);
+          return rc;
+        }
+        releasePage(pFreePg);
+      }while( nFin!=0 && iFreePg>nFin );
+      assert( iFreePg<iLastPg );
+      
+      rc = sqlite3PagerWrite(pLastPg->pDbPage);
+      if( rc==SQLITE_OK ){
+        rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg);
+      }
+      releasePage(pLastPg);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+    }
+  }
+
+  pBt->nTrunc = iLastPg - 1;
+  while( pBt->nTrunc==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, pBt->nTrunc) ){
+    pBt->nTrunc--;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** A write-transaction must be opened before calling this function.
+** It performs a single unit of work towards an incremental vacuum.
+**
+** If the incremental vacuum is finished after this function has run,
+** SQLITE_DONE is returned. If it is not finished, but no error occured,
+** SQLITE_OK is returned. Otherwise an SQLite error code. 
+*/
+int sqlite3BtreeIncrVacuum(Btree *p){
+  int rc;
+  BtShared *pBt = p->pBt;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
+  if( !pBt->autoVacuum ){
+    rc = SQLITE_DONE;
+  }else{
+    invalidateAllOverflowCache(pBt);
+    rc = incrVacuumStep(pBt, 0);
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** This routine is called prior to sqlite3PagerCommit when a transaction
+** is commited for an auto-vacuum database.
+**
+** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
+** the database file should be truncated to during the commit process. 
+** i.e. the database has been reorganized so that only the first *pnTrunc
+** pages are in use.
+*/
+static int autoVacuumCommit(BtShared *pBt, Pgno *pnTrunc){
+  int rc = SQLITE_OK;
+  Pager *pPager = pBt->pPager;
+#ifndef NDEBUG
+  int nRef = sqlite3PagerRefcount(pPager);
+#endif
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  invalidateAllOverflowCache(pBt);
+  assert(pBt->autoVacuum);
+  if( !pBt->incrVacuum ){
+    Pgno nFin = 0;
+
+    if( pBt->nTrunc==0 ){
+      Pgno nFree;
+      Pgno nPtrmap;
+      const int pgsz = pBt->pageSize;
+      Pgno nOrig = sqlite3PagerPagecount(pBt->pPager);
+
+      if( PTRMAP_ISPAGE(pBt, nOrig) ){
+        return SQLITE_CORRUPT_BKPT;
+      }
+      if( nOrig==PENDING_BYTE_PAGE(pBt) ){
+        nOrig--;
+      }
+      nFree = get4byte(&pBt->pPage1->aData[36]);
+      nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+pgsz/5)/(pgsz/5);
+      nFin = nOrig - nFree - nPtrmap;
+      if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<=PENDING_BYTE_PAGE(pBt) ){
+        nFin--;
+      }
+      while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
+        nFin--;
+      }
+    }
+
+    while( rc==SQLITE_OK ){
+      rc = incrVacuumStep(pBt, nFin);
+    }
+    if( rc==SQLITE_DONE ){
+      assert(nFin==0 || pBt->nTrunc==0 || nFin<=pBt->nTrunc);
+      rc = SQLITE_OK;
+      if( pBt->nTrunc ){
+        rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
+        put4byte(&pBt->pPage1->aData[32], 0);
+        put4byte(&pBt->pPage1->aData[36], 0);
+        pBt->nTrunc = nFin;
+      }
+    }
+    if( rc!=SQLITE_OK ){
+      sqlite3PagerRollback(pPager);
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    *pnTrunc = pBt->nTrunc;
+    pBt->nTrunc = 0;
+  }
+  assert( nRef==sqlite3PagerRefcount(pPager) );
+  return rc;
+}
+
+#endif
+
+/*
+** This routine does the first phase of a two-phase commit.  This routine
+** causes a rollback journal to be created (if it does not already exist)
+** and populated with enough information so that if a power loss occurs
+** the database can be restored to its original state by playing back
+** the journal.  Then the contents of the journal are flushed out to
+** the disk.  After the journal is safely on oxide, the changes to the
+** database are written into the database file and flushed to oxide.
+** At the end of this call, the rollback journal still exists on the
+** disk and we are still holding all locks, so the transaction has not
+** committed.  See sqlite3BtreeCommit() for the second phase of the
+** commit process.
+**
+** This call is a no-op if no write-transaction is currently active on pBt.
+**
+** Otherwise, sync the database file for the btree pBt. zMaster points to
+** the name of a master journal file that should be written into the
+** individual journal file, or is NULL, indicating no master journal file 
+** (single database transaction).
+**
+** When this is called, the master journal should already have been
+** created, populated with this journal pointer and synced to disk.
+**
+** Once this is routine has returned, the only thing required to commit
+** the write-transaction for this database file is to delete the journal.
+*/
+int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
+  int rc = SQLITE_OK;
+  if( p->inTrans==TRANS_WRITE ){
+    BtShared *pBt = p->pBt;
+    Pgno nTrunc = 0;
+    sqlite3BtreeEnter(p);
+    pBt->db = p->db;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pBt->autoVacuum ){
+      rc = autoVacuumCommit(pBt, &nTrunc); 
+      if( rc!=SQLITE_OK ){
+        sqlite3BtreeLeave(p);
+        return rc;
+      }
+    }
+#endif
+    rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, nTrunc);
+    sqlite3BtreeLeave(p);
+  }
+  return rc;
+}
+
+/*
+** Commit the transaction currently in progress.
+**
+** This routine implements the second phase of a 2-phase commit.  The
+** sqlite3BtreeSync() routine does the first phase and should be invoked
+** prior to calling this routine.  The sqlite3BtreeSync() routine did
+** all the work of writing information out to disk and flushing the
+** contents so that they are written onto the disk platter.  All this
+** routine has to do is delete or truncate the rollback journal
+** (which causes the transaction to commit) and drop locks.
+**
+** This will release the write lock on the database file.  If there
+** are no active cursors, it also releases the read lock.
+*/
+int sqlite3BtreeCommitPhaseTwo(Btree *p){
+  BtShared *pBt = p->pBt;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  btreeIntegrity(p);
+
+  /* If the handle has a write-transaction open, commit the shared-btrees 
+  ** transaction and set the shared state to TRANS_READ.
+  */
+  if( p->inTrans==TRANS_WRITE ){
+    int rc;
+    assert( pBt->inTransaction==TRANS_WRITE );
+    assert( pBt->nTransaction>0 );
+    rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
+    if( rc!=SQLITE_OK ){
+      sqlite3BtreeLeave(p);
+      return rc;
+    }
+    pBt->inTransaction = TRANS_READ;
+    pBt->inStmt = 0;
+  }
+  unlockAllTables(p);
+
+  /* If the handle has any kind of transaction open, decrement the transaction
+  ** count of the shared btree. If the transaction count reaches 0, set
+  ** the shared state to TRANS_NONE. The unlockBtreeIfUnused() call below
+  ** will unlock the pager.
+  */
+  if( p->inTrans!=TRANS_NONE ){
+    pBt->nTransaction--;
+    if( 0==pBt->nTransaction ){
+      pBt->inTransaction = TRANS_NONE;
+    }
+  }
+
+  /* Set the handles current transaction state to TRANS_NONE and unlock
+  ** the pager if this call closed the only read or write transaction.
+  */
+  p->inTrans = TRANS_NONE;
+  unlockBtreeIfUnused(pBt);
+
+  btreeIntegrity(p);
+  sqlite3BtreeLeave(p);
+  return SQLITE_OK;
+}
+
+/*
+** Do both phases of a commit.
+*/
+int sqlite3BtreeCommit(Btree *p){
+  int rc;
+  sqlite3BtreeEnter(p);
+  rc = sqlite3BtreeCommitPhaseOne(p, 0);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3BtreeCommitPhaseTwo(p);
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+#ifndef NDEBUG
+/*
+** Return the number of write-cursors open on this handle. This is for use
+** in assert() expressions, so it is only compiled if NDEBUG is not
+** defined.
+**
+** For the purposes of this routine, a write-cursor is any cursor that
+** is capable of writing to the databse.  That means the cursor was
+** originally opened for writing and the cursor has not be disabled
+** by having its state changed to CURSOR_FAULT.
+*/
+static int countWriteCursors(BtShared *pBt){
+  BtCursor *pCur;
+  int r = 0;
+  for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
+    if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++; 
+  }
+  return r;
+}
+#endif
+
+/*
+** This routine sets the state to CURSOR_FAULT and the error
+** code to errCode for every cursor on BtShared that pBtree
+** references.
+**
+** Every cursor is tripped, including cursors that belong
+** to other database connections that happen to be sharing
+** the cache with pBtree.
+**
+** This routine gets called when a rollback occurs.
+** All cursors using the same cache must be tripped
+** to prevent them from trying to use the btree after
+** the rollback.  The rollback may have deleted tables
+** or moved root pages, so it is not sufficient to
+** save the state of the cursor.  The cursor must be
+** invalidated.
+*/
+void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
+  BtCursor *p;
+  sqlite3BtreeEnter(pBtree);
+  for(p=pBtree->pBt->pCursor; p; p=p->pNext){
+    clearCursorPosition(p);
+    p->eState = CURSOR_FAULT;
+    p->skip = errCode;
+  }
+  sqlite3BtreeLeave(pBtree);
+}
+
+/*
+** Rollback the transaction in progress.  All cursors will be
+** invalided by this operation.  Any attempt to use a cursor
+** that was open at the beginning of this operation will result
+** in an error.
+**
+** This will release the write lock on the database file.  If there
+** are no active cursors, it also releases the read lock.
+*/
+int sqlite3BtreeRollback(Btree *p){
+  int rc;
+  BtShared *pBt = p->pBt;
+  MemPage *pPage1;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  rc = saveAllCursors(pBt, 0, 0);
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  if( rc!=SQLITE_OK ){
+    /* This is a horrible situation. An IO or malloc() error occured whilst
+    ** trying to save cursor positions. If this is an automatic rollback (as
+    ** the result of a constraint, malloc() failure or IO error) then 
+    ** the cache may be internally inconsistent (not contain valid trees) so
+    ** we cannot simply return the error to the caller. Instead, abort 
+    ** all queries that may be using any of the cursors that failed to save.
+    */
+    sqlite3BtreeTripAllCursors(p, rc);
+  }
+#endif
+  btreeIntegrity(p);
+  unlockAllTables(p);
+
+  if( p->inTrans==TRANS_WRITE ){
+    int rc2;
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    pBt->nTrunc = 0;
+#endif
+
+    assert( TRANS_WRITE==pBt->inTransaction );
+    rc2 = sqlite3PagerRollback(pBt->pPager);
+    if( rc2!=SQLITE_OK ){
+      rc = rc2;
+    }
+
+    /* The rollback may have destroyed the pPage1->aData value.  So
+    ** call sqlite3BtreeGetPage() on page 1 again to make
+    ** sure pPage1->aData is set correctly. */
+    if( sqlite3BtreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
+      releasePage(pPage1);
+    }
+    assert( countWriteCursors(pBt)==0 );
+    pBt->inTransaction = TRANS_READ;
+  }
+
+  if( p->inTrans!=TRANS_NONE ){
+    assert( pBt->nTransaction>0 );
+    pBt->nTransaction--;
+    if( 0==pBt->nTransaction ){
+      pBt->inTransaction = TRANS_NONE;
+    }
+  }
+
+  p->inTrans = TRANS_NONE;
+  pBt->inStmt = 0;
+  unlockBtreeIfUnused(pBt);
+
+  btreeIntegrity(p);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Start a statement subtransaction.  The subtransaction can
+** can be rolled back independently of the main transaction.
+** You must start a transaction before starting a subtransaction.
+** The subtransaction is ended automatically if the main transaction
+** commits or rolls back.
+**
+** Only one subtransaction may be active at a time.  It is an error to try
+** to start a new subtransaction if another subtransaction is already active.
+**
+** Statement subtransactions are used around individual SQL statements
+** that are contained within a BEGIN...COMMIT block.  If a constraint
+** error occurs within the statement, the effect of that one statement
+** can be rolled back without having to rollback the entire transaction.
+*/
+int sqlite3BtreeBeginStmt(Btree *p){
+  int rc;
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  if( (p->inTrans!=TRANS_WRITE) || pBt->inStmt ){
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+  }else{
+    assert( pBt->inTransaction==TRANS_WRITE );
+    rc = pBt->readOnly ? SQLITE_OK : sqlite3PagerStmtBegin(pBt->pPager);
+    pBt->inStmt = 1;
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+
+/*
+** Commit the statment subtransaction currently in progress.  If no
+** subtransaction is active, this is a no-op.
+*/
+int sqlite3BtreeCommitStmt(Btree *p){
+  int rc;
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  if( pBt->inStmt && !pBt->readOnly ){
+    rc = sqlite3PagerStmtCommit(pBt->pPager);
+  }else{
+    rc = SQLITE_OK;
+  }
+  pBt->inStmt = 0;
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Rollback the active statement subtransaction.  If no subtransaction
+** is active this routine is a no-op.
+**
+** All cursors will be invalidated by this operation.  Any attempt
+** to use a cursor that was open at the beginning of this operation
+** will result in an error.
+*/
+int sqlite3BtreeRollbackStmt(Btree *p){
+  int rc = SQLITE_OK;
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  if( pBt->inStmt && !pBt->readOnly ){
+    rc = sqlite3PagerStmtRollback(pBt->pPager);
+    assert( countWriteCursors(pBt)==0 );
+    pBt->inStmt = 0;
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Default key comparison function to be used if no comparison function
+** is specified on the sqlite3BtreeCursor() call.
+*/
+static int dfltCompare(
+  void *NotUsed,             /* User data is not used */
+  int n1, const void *p1,    /* First key to compare */
+  int n2, const void *p2     /* Second key to compare */
+){
+  int c;
+  c = memcmp(p1, p2, n1<n2 ? n1 : n2);
+  if( c==0 ){
+    c = n1 - n2;
+  }
+  return c;
+}
+
+/*
+** Create a new cursor for the BTree whose root is on the page
+** iTable.  The act of acquiring a cursor gets a read lock on 
+** the database file.
+**
+** If wrFlag==0, then the cursor can only be used for reading.
+** If wrFlag==1, then the cursor can be used for reading or for
+** writing if other conditions for writing are also met.  These
+** are the conditions that must be met in order for writing to
+** be allowed:
+**
+** 1:  The cursor must have been opened with wrFlag==1
+**
+** 2:  Other database connections that share the same pager cache
+**     but which are not in the READ_UNCOMMITTED state may not have
+**     cursors open with wrFlag==0 on the same table.  Otherwise
+**     the changes made by this write cursor would be visible to
+**     the read cursors in the other database connection.
+**
+** 3:  The database must be writable (not on read-only media)
+**
+** 4:  There must be an active transaction.
+**
+** No checking is done to make sure that page iTable really is the
+** root page of a b-tree.  If it is not, then the cursor acquired
+** will not work correctly.
+**
+** The comparison function must be logically the same for every cursor
+** on a particular table.  Changing the comparison function will result
+** in incorrect operations.  If the comparison function is NULL, a
+** default comparison function is used.  The comparison function is
+** always ignored for INTKEY tables.
+*/
+static int btreeCursor(
+  Btree *p,                                   /* The btree */
+  int iTable,                                 /* Root page of table to open */
+  int wrFlag,                                 /* 1 to write. 0 read-only */
+  int (*xCmp)(void*,int,const void*,int,const void*), /* Key Comparison func */
+  void *pArg,                                 /* First arg to xCompare() */
+  BtCursor **ppCur                            /* Write new cursor here */
+){
+  int rc;
+  BtCursor *pCur;
+  BtShared *pBt = p->pBt;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+  *ppCur = 0;
+  if( wrFlag ){
+    if( pBt->readOnly ){
+      return SQLITE_READONLY;
+    }
+    if( checkReadLocks(p, iTable, 0) ){
+      return SQLITE_LOCKED;
+    }
+  }
+
+  if( pBt->pPage1==0 ){
+    rc = lockBtreeWithRetry(p);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    if( pBt->readOnly && wrFlag ){
+      return SQLITE_READONLY;
+    }
+  }
+  pCur = sqlite3MallocZero( sizeof(*pCur) );
+  if( pCur==0 ){
+    rc = SQLITE_NOMEM;
+    goto create_cursor_exception;
+  }
+  pCur->pgnoRoot = (Pgno)iTable;
+  if( iTable==1 && sqlite3PagerPagecount(pBt->pPager)==0 ){
+    rc = SQLITE_EMPTY;
+    goto create_cursor_exception;
+  }
+  rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->pPage, 0);
+  if( rc!=SQLITE_OK ){
+    goto create_cursor_exception;
+  }
+
+  /* Now that no other errors can occur, finish filling in the BtCursor
+  ** variables, link the cursor into the BtShared list and set *ppCur (the
+  ** output argument to this function).
+  */
+  pCur->xCompare = xCmp ? xCmp : dfltCompare;
+  pCur->pArg = pArg;
+  pCur->pBtree = p;
+  pCur->pBt = pBt;
+  pCur->wrFlag = wrFlag;
+  pCur->pNext = pBt->pCursor;
+  if( pCur->pNext ){
+    pCur->pNext->pPrev = pCur;
+  }
+  pBt->pCursor = pCur;
+  pCur->eState = CURSOR_INVALID;
+  *ppCur = pCur;
+
+  return SQLITE_OK;
+
+create_cursor_exception:
+  if( pCur ){
+    releasePage(pCur->pPage);
+    sqlite3_free(pCur);
+  }
+  unlockBtreeIfUnused(pBt);
+  return rc;
+}
+int sqlite3BtreeCursor(
+  Btree *p,                                   /* The btree */
+  int iTable,                                 /* Root page of table to open */
+  int wrFlag,                                 /* 1 to write. 0 read-only */
+  int (*xCmp)(void*,int,const void*,int,const void*), /* Key Comparison func */
+  void *pArg,                                 /* First arg to xCompare() */
+  BtCursor **ppCur                            /* Write new cursor here */
+){
+  int rc;
+  sqlite3BtreeEnter(p);
+  p->pBt->db = p->db;
+  rc = btreeCursor(p, iTable, wrFlag, xCmp, pArg, ppCur);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+
+/*
+** Close a cursor.  The read lock on the database file is released
+** when the last cursor is closed.
+*/
+int sqlite3BtreeCloseCursor(BtCursor *pCur){
+  BtShared *pBt = pCur->pBt;
+  Btree *pBtree = pCur->pBtree;
+
+  sqlite3BtreeEnter(pBtree);
+  pBt->db = pBtree->db;
+  clearCursorPosition(pCur);
+  if( pCur->pPrev ){
+    pCur->pPrev->pNext = pCur->pNext;
+  }else{
+    pBt->pCursor = pCur->pNext;
+  }
+  if( pCur->pNext ){
+    pCur->pNext->pPrev = pCur->pPrev;
+  }
+  releasePage(pCur->pPage);
+  unlockBtreeIfUnused(pBt);
+  invalidateOverflowCache(pCur);
+  sqlite3_free(pCur);
+  sqlite3BtreeLeave(pBtree);
+  return SQLITE_OK;
+}
+
+/*
+** Make a temporary cursor by filling in the fields of pTempCur.
+** The temporary cursor is not on the cursor list for the Btree.
+*/
+void sqlite3BtreeGetTempCursor(BtCursor *pCur, BtCursor *pTempCur){
+  assert( cursorHoldsMutex(pCur) );
+  memcpy(pTempCur, pCur, sizeof(*pCur));
+  pTempCur->pNext = 0;
+  pTempCur->pPrev = 0;
+  if( pTempCur->pPage ){
+    sqlite3PagerRef(pTempCur->pPage->pDbPage);
+  }
+}
+
+/*
+** Delete a temporary cursor such as was made by the CreateTemporaryCursor()
+** function above.
+*/
+void sqlite3BtreeReleaseTempCursor(BtCursor *pCur){
+  assert( cursorHoldsMutex(pCur) );
+  if( pCur->pPage ){
+    sqlite3PagerUnref(pCur->pPage->pDbPage);
+  }
+}
+
+/*
+** Make sure the BtCursor* given in the argument has a valid
+** BtCursor.info structure.  If it is not already valid, call
+** sqlite3BtreeParseCell() to fill it in.
+**
+** BtCursor.info is a cache of the information in the current cell.
+** Using this cache reduces the number of calls to sqlite3BtreeParseCell().
+**
+** 2007-06-25:  There is a bug in some versions of MSVC that cause the
+** compiler to crash when getCellInfo() is implemented as a macro.
+** But there is a measureable speed advantage to using the macro on gcc
+** (when less compiler optimizations like -Os or -O0 are used and the
+** compiler is not doing agressive inlining.)  So we use a real function
+** for MSVC and a macro for everything else.  Ticket #2457.
+*/
+#ifndef NDEBUG
+  static void assertCellInfo(BtCursor *pCur){
+    CellInfo info;
+    memset(&info, 0, sizeof(info));
+    sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &info);
+    assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
+  }
+#else
+  #define assertCellInfo(x)
+#endif
+#ifdef _MSC_VER
+  /* Use a real function in MSVC to work around bugs in that compiler. */
+  static void getCellInfo(BtCursor *pCur){
+    if( pCur->info.nSize==0 ){
+      sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &pCur->info);
+    }else{
+      assertCellInfo(pCur);
+    }
+  }
+#else /* if not _MSC_VER */
+  /* Use a macro in all other compilers so that the function is inlined */
+#define getCellInfo(pCur)                                               \
+  if( pCur->info.nSize==0 ){                                            \
+    sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &pCur->info);         \
+  }else{                                                                \
+    assertCellInfo(pCur);                                               \
+  }
+#endif /* _MSC_VER */
+
+/*
+** Set *pSize to the size of the buffer needed to hold the value of
+** the key for the current entry.  If the cursor is not pointing
+** to a valid entry, *pSize is set to 0. 
+**
+** For a table with the INTKEY flag set, this routine returns the key
+** itself, not the number of bytes in the key.
+*/
+int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc==SQLITE_OK ){
+    assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
+    if( pCur->eState==CURSOR_INVALID ){
+      *pSize = 0;
+    }else{
+      getCellInfo(pCur);
+      *pSize = pCur->info.nKey;
+    }
+  }
+  return rc;
+}
+
+/*
+** Set *pSize to the number of bytes of data in the entry the
+** cursor currently points to.  Always return SQLITE_OK.
+** Failure is not possible.  If the cursor is not currently
+** pointing to an entry (which can happen, for example, if
+** the database is empty) then *pSize is set to 0.
+*/
+int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc==SQLITE_OK ){
+    assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
+    if( pCur->eState==CURSOR_INVALID ){
+      /* Not pointing at a valid entry - set *pSize to 0. */
+      *pSize = 0;
+    }else{
+      getCellInfo(pCur);
+      *pSize = pCur->info.nData;
+    }
+  }
+  return rc;
+}
+
+/*
+** Given the page number of an overflow page in the database (parameter
+** ovfl), this function finds the page number of the next page in the 
+** linked list of overflow pages. If possible, it uses the auto-vacuum
+** pointer-map data instead of reading the content of page ovfl to do so. 
+**
+** If an error occurs an SQLite error code is returned. Otherwise:
+**
+** Unless pPgnoNext is NULL, the page number of the next overflow 
+** page in the linked list is written to *pPgnoNext. If page ovfl
+** is the last page in its linked list, *pPgnoNext is set to zero. 
+**
+** If ppPage is not NULL, *ppPage is set to the MemPage* handle
+** for page ovfl. The underlying pager page may have been requested
+** with the noContent flag set, so the page data accessable via
+** this handle may not be trusted.
+*/
+static int getOverflowPage(
+  BtShared *pBt, 
+  Pgno ovfl,                   /* Overflow page */
+  MemPage **ppPage,            /* OUT: MemPage handle */
+  Pgno *pPgnoNext              /* OUT: Next overflow page number */
+){
+  Pgno next = 0;
+  int rc;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  /* One of these must not be NULL. Otherwise, why call this function? */
+  assert(ppPage || pPgnoNext);
+
+  /* If pPgnoNext is NULL, then this function is being called to obtain
+  ** a MemPage* reference only. No page-data is required in this case.
+  */
+  if( !pPgnoNext ){
+    return sqlite3BtreeGetPage(pBt, ovfl, ppPage, 1);
+  }
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  /* Try to find the next page in the overflow list using the
+  ** autovacuum pointer-map pages. Guess that the next page in 
+  ** the overflow list is page number (ovfl+1). If that guess turns 
+  ** out to be wrong, fall back to loading the data of page 
+  ** number ovfl to determine the next page number.
+  */
+  if( pBt->autoVacuum ){
+    Pgno pgno;
+    Pgno iGuess = ovfl+1;
+    u8 eType;
+
+    while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
+      iGuess++;
+    }
+
+    if( iGuess<=sqlite3PagerPagecount(pBt->pPager) ){
+      rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      if( eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
+        next = iGuess;
+      }
+    }
+  }
+#endif
+
+  if( next==0 || ppPage ){
+    MemPage *pPage = 0;
+
+    rc = sqlite3BtreeGetPage(pBt, ovfl, &pPage, next!=0);
+    assert(rc==SQLITE_OK || pPage==0);
+    if( next==0 && rc==SQLITE_OK ){
+      next = get4byte(pPage->aData);
+    }
+
+    if( ppPage ){
+      *ppPage = pPage;
+    }else{
+      releasePage(pPage);
+    }
+  }
+  *pPgnoNext = next;
+
+  return rc;
+}
+
+/*
+** Copy data from a buffer to a page, or from a page to a buffer.
+**
+** pPayload is a pointer to data stored on database page pDbPage.
+** If argument eOp is false, then nByte bytes of data are copied
+** from pPayload to the buffer pointed at by pBuf. If eOp is true,
+** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
+** of data are copied from the buffer pBuf to pPayload.
+**
+** SQLITE_OK is returned on success, otherwise an error code.
+*/
+static int copyPayload(
+  void *pPayload,           /* Pointer to page data */
+  void *pBuf,               /* Pointer to buffer */
+  int nByte,                /* Number of bytes to copy */
+  int eOp,                  /* 0 -> copy from page, 1 -> copy to page */
+  DbPage *pDbPage           /* Page containing pPayload */
+){
+  if( eOp ){
+    /* Copy data from buffer to page (a write operation) */
+    int rc = sqlite3PagerWrite(pDbPage);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    memcpy(pPayload, pBuf, nByte);
+  }else{
+    /* Copy data from page to buffer (a read operation) */
+    memcpy(pBuf, pPayload, nByte);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** This function is used to read or overwrite payload information
+** for the entry that the pCur cursor is pointing to. If the eOp
+** parameter is 0, this is a read operation (data copied into
+** buffer pBuf). If it is non-zero, a write (data copied from
+** buffer pBuf).
+**
+** A total of "amt" bytes are read or written beginning at "offset".
+** Data is read to or from the buffer pBuf.
+**
+** This routine does not make a distinction between key and data.
+** It just reads or writes bytes from the payload area.  Data might 
+** appear on the main page or be scattered out on multiple overflow 
+** pages.
+**
+** If the BtCursor.isIncrblobHandle flag is set, and the current
+** cursor entry uses one or more overflow pages, this function
+** allocates space for and lazily popluates the overflow page-list 
+** cache array (BtCursor.aOverflow). Subsequent calls use this
+** cache to make seeking to the supplied offset more efficient.
+**
+** Once an overflow page-list cache has been allocated, it may be
+** invalidated if some other cursor writes to the same table, or if
+** the cursor is moved to a different row. Additionally, in auto-vacuum
+** mode, the following events may invalidate an overflow page-list cache.
+**
+**   * An incremental vacuum,
+**   * A commit in auto_vacuum="full" mode,
+**   * Creating a table (may require moving an overflow page).
+*/
+static int accessPayload(
+  BtCursor *pCur,      /* Cursor pointing to entry to read from */
+  int offset,          /* Begin reading this far into payload */
+  int amt,             /* Read this many bytes */
+  unsigned char *pBuf, /* Write the bytes into this buffer */ 
+  int skipKey,         /* offset begins at data if this is true */
+  int eOp              /* zero to read. non-zero to write. */
+){
+  unsigned char *aPayload;
+  int rc = SQLITE_OK;
+  u32 nKey;
+  int iIdx = 0;
+  MemPage *pPage = pCur->pPage;     /* Btree page of current cursor entry */
+  BtShared *pBt;                   /* Btree this cursor belongs to */
+
+  assert( pPage );
+  assert( pCur->eState==CURSOR_VALID );
+  assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
+  assert( offset>=0 );
+  assert( cursorHoldsMutex(pCur) );
+
+  getCellInfo(pCur);
+  aPayload = pCur->info.pCell + pCur->info.nHeader;
+  nKey = (pPage->intKey ? 0 : pCur->info.nKey);
+
+  if( skipKey ){
+    offset += nKey;
+  }
+  if( offset+amt > nKey+pCur->info.nData ){
+    /* Trying to read or write past the end of the data is an error */
+    return SQLITE_ERROR;
+  }
+
+  /* Check if data must be read/written to/from the btree page itself. */
+  if( offset<pCur->info.nLocal ){
+    int a = amt;
+    if( a+offset>pCur->info.nLocal ){
+      a = pCur->info.nLocal - offset;
+    }
+    rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
+    offset = 0;
+    pBuf += a;
+    amt -= a;
+  }else{
+    offset -= pCur->info.nLocal;
+  }
+
+  pBt = pCur->pBt;
+  if( rc==SQLITE_OK && amt>0 ){
+    const int ovflSize = pBt->usableSize - 4;  /* Bytes content per ovfl page */
+    Pgno nextPage;
+
+    nextPage = get4byte(&aPayload[pCur->info.nLocal]);
+
+#ifndef SQLITE_OMIT_INCRBLOB
+    /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[]
+    ** has not been allocated, allocate it now. The array is sized at
+    ** one entry for each overflow page in the overflow chain. The
+    ** page number of the first overflow page is stored in aOverflow[0],
+    ** etc. A value of 0 in the aOverflow[] array means "not yet known"
+    ** (the cache is lazily populated).
+    */
+    if( pCur->isIncrblobHandle && !pCur->aOverflow ){
+      int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
+      pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
+      if( nOvfl && !pCur->aOverflow ){
+        rc = SQLITE_NOMEM;
+      }
+    }
+
+    /* If the overflow page-list cache has been allocated and the
+    ** entry for the first required overflow page is valid, skip
+    ** directly to it.
+    */
+    if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
+      iIdx = (offset/ovflSize);
+      nextPage = pCur->aOverflow[iIdx];
+      offset = (offset%ovflSize);
+    }
+#endif
+
+    for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
+
+#ifndef SQLITE_OMIT_INCRBLOB
+      /* If required, populate the overflow page-list cache. */
+      if( pCur->aOverflow ){
+        assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
+        pCur->aOverflow[iIdx] = nextPage;
+      }
+#endif
+
+      if( offset>=ovflSize ){
+        /* The only reason to read this page is to obtain the page
+        ** number for the next page in the overflow chain. The page
+        ** data is not required. So first try to lookup the overflow
+        ** page-list cache, if any, then fall back to the getOverflowPage()
+        ** function.
+        */
+#ifndef SQLITE_OMIT_INCRBLOB
+        if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
+          nextPage = pCur->aOverflow[iIdx+1];
+        } else 
+#endif
+          rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
+        offset -= ovflSize;
+      }else{
+        /* Need to read this page properly. It contains some of the
+        ** range of data that is being read (eOp==0) or written (eOp!=0).
+        */
+        DbPage *pDbPage;
+        int a = amt;
+        rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
+        if( rc==SQLITE_OK ){
+          aPayload = sqlite3PagerGetData(pDbPage);
+          nextPage = get4byte(aPayload);
+          if( a + offset > ovflSize ){
+            a = ovflSize - offset;
+          }
+          rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
+          sqlite3PagerUnref(pDbPage);
+          offset = 0;
+          amt -= a;
+          pBuf += a;
+        }
+      }
+    }
+  }
+
+  if( rc==SQLITE_OK && amt>0 ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+  return rc;
+}
+
+/*
+** 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){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc==SQLITE_OK ){
+    assert( pCur->eState==CURSOR_VALID );
+    assert( pCur->pPage!=0 );
+    if( pCur->pPage->intKey ){
+      return SQLITE_CORRUPT_BKPT;
+    }
+    assert( pCur->pPage->intKey==0 );
+    assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
+    rc = accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0, 0);
+  }
+  return rc;
+}
+
+/*
+** Read part of the data 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 sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc==SQLITE_OK ){
+    assert( pCur->eState==CURSOR_VALID );
+    assert( pCur->pPage!=0 );
+    assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
+    rc = accessPayload(pCur, offset, amt, pBuf, 1, 0);
+  }
+  return rc;
+}
+
+/*
+** Return a pointer to payload information from the entry that the 
+** pCur cursor is pointing to.  The pointer is to the beginning of
+** the key if skipKey==0 and it points to the beginning of data if
+** skipKey==1.  The number of bytes of available key/data is written
+** into *pAmt.  If *pAmt==0, then the value returned will not be
+** a valid pointer.
+**
+** This routine is an optimization.  It is common for the entire key
+** and data to fit on the local page and for there to be no overflow
+** pages.  When that is so, this routine can be used to access the
+** key and data without making a copy.  If the key and/or data spills
+** onto overflow pages, then accessPayload() must be used to reassembly
+** the key/data and copy it into a preallocated buffer.
+**
+** The pointer returned by this routine looks directly into the cached
+** page of the database.  The data might change or move the next time
+** any btree routine is called.
+*/
+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;
+  u32 nKey;
+  int nLocal;
+
+  assert( pCur!=0 && pCur->pPage!=0 );
+  assert( pCur->eState==CURSOR_VALID );
+  assert( cursorHoldsMutex(pCur) );
+  pPage = pCur->pPage;
+  assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
+  getCellInfo(pCur);
+  aPayload = pCur->info.pCell;
+  aPayload += pCur->info.nHeader;
+  if( pPage->intKey ){
+    nKey = 0;
+  }else{
+    nKey = pCur->info.nKey;
+  }
+  if( skipKey ){
+    aPayload += nKey;
+    nLocal = pCur->info.nLocal - nKey;
+  }else{
+    nLocal = pCur->info.nLocal;
+    if( nLocal>nKey ){
+      nLocal = nKey;
+    }
+  }
+  *pAmt = nLocal;
+  return aPayload;
+}
+
+
+/*
+** For the entry that cursor pCur is point to, return as
+** many bytes of the key or data as are available on the local
+** b-tree page.  Write the number of available bytes into *pAmt.
+**
+** The pointer returned is ephemeral.  The key/data may move
+** or be destroyed on the next call to any Btree routine,
+** including calls from other threads against the same cache.
+** Hence, a mutex on the BtShared should be held prior to calling
+** this routine.
+**
+** These routines is used to get quick access to key and data
+** in the common case where no overflow pages are used.
+*/
+const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
+  assert( cursorHoldsMutex(pCur) );
+  if( pCur->eState==CURSOR_VALID ){
+    return (const void*)fetchPayload(pCur, pAmt, 0);
+  }
+  return 0;
+}
+const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
+  assert( cursorHoldsMutex(pCur) );
+  if( pCur->eState==CURSOR_VALID ){
+    return (const void*)fetchPayload(pCur, pAmt, 1);
+  }
+  return 0;
+}
+
+
+/*
+** Move the cursor down to a new child page.  The newPgno argument is the
+** page number of the child page to move to.
+*/
+static int moveToChild(BtCursor *pCur, u32 newPgno){
+  int rc;
+  MemPage *pNewPage;
+  MemPage *pOldPage;
+  BtShared *pBt = pCur->pBt;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( pCur->eState==CURSOR_VALID );
+  rc = getAndInitPage(pBt, newPgno, &pNewPage, pCur->pPage);
+  if( rc ) return rc;
+  pNewPage->idxParent = pCur->idx;
+  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;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Return true if the page is the virtual root of its table.
+**
+** The virtual root page is the root page for most tables.  But
+** for the table rooted on page 1, sometime the real root page
+** is empty except for the right-pointer.  In such cases the
+** virtual root page is the page that the right-pointer of page
+** 1 is pointing to.
+*/
+int sqlite3BtreeIsRootPage(MemPage *pPage){
+  MemPage *pParent;
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  pParent = pPage->pParent;
+  if( pParent==0 ) return 1;
+  if( pParent->pgno>1 ) return 0;
+  if( get2byte(&pParent->aData[pParent->hdrOffset+3])==0 ) return 1;
+  return 0;
+}
+
+/*
+** Move the cursor up to the parent page.
+**
+** 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.
+*/
+void sqlite3BtreeMoveToParent(BtCursor *pCur){
+  MemPage *pParent;
+  MemPage *pPage;
+  int idxParent;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( pCur->eState==CURSOR_VALID );
+  pPage = pCur->pPage;
+  assert( pPage!=0 );
+  assert( !sqlite3BtreeIsRootPage(pPage) );
+  pParent = pPage->pParent;
+  assert( pParent!=0 );
+  idxParent = pPage->idxParent;
+  sqlite3PagerRef(pParent->pDbPage);
+  releasePage(pPage);
+  pCur->pPage = pParent;
+  pCur->info.nSize = 0;
+  assert( pParent->idxShift==0 );
+  pCur->idx = idxParent;
+}
+
+/*
+** Move the cursor to the root page
+*/
+static int moveToRoot(BtCursor *pCur){
+  MemPage *pRoot;
+  int rc = SQLITE_OK;
+  Btree *p = pCur->pBtree;
+  BtShared *pBt = p->pBt;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
+  assert( CURSOR_VALID   < CURSOR_REQUIRESEEK );
+  assert( CURSOR_FAULT   > CURSOR_REQUIRESEEK );
+  if( pCur->eState>=CURSOR_REQUIRESEEK ){
+    if( pCur->eState==CURSOR_FAULT ){
+      return pCur->skip;
+    }
+    clearCursorPosition(pCur);
+  }
+  pRoot = pCur->pPage;
+  if( pRoot && pRoot->pgno==pCur->pgnoRoot ){
+    assert( pRoot->isInit );
+  }else{
+    if( 
+      SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pRoot, 0))
+    ){
+      pCur->eState = CURSOR_INVALID;
+      return rc;
+    }
+    releasePage(pCur->pPage);
+    pCur->pPage = pRoot;
+  }
+  pCur->idx = 0;
+  pCur->info.nSize = 0;
+  if( pRoot->nCell==0 && !pRoot->leaf ){
+    Pgno subpage;
+    assert( pRoot->pgno==1 );
+    subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
+    assert( subpage>0 );
+    pCur->eState = CURSOR_VALID;
+    rc = moveToChild(pCur, subpage);
+  }
+  pCur->eState = ((pCur->pPage->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
+  return rc;
+}
+
+/*
+** Move the cursor down to the left-most leaf entry beneath the
+** entry to which it is currently pointing.
+**
+** The left-most leaf is the one with the smallest key - the first
+** in ascending order.
+*/
+static int moveToLeftmost(BtCursor *pCur){
+  Pgno pgno;
+  int rc = SQLITE_OK;
+  MemPage *pPage;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( pCur->eState==CURSOR_VALID );
+  while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
+    assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
+    pgno = get4byte(findCell(pPage, pCur->idx));
+    rc = moveToChild(pCur, pgno);
+  }
+  return rc;
+}
+
+/*
+** Move the cursor down to the right-most leaf entry beneath the
+** page to which it is currently pointing.  Notice the difference
+** between moveToLeftmost() and moveToRightmost().  moveToLeftmost()
+** finds the left-most entry beneath the *entry* whereas moveToRightmost()
+** finds the right-most entry beneath the *page*.
+**
+** The right-most entry is the one with the largest key - the last
+** key in ascending order.
+*/
+static int moveToRightmost(BtCursor *pCur){
+  Pgno pgno;
+  int rc = SQLITE_OK;
+  MemPage *pPage;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( pCur->eState==CURSOR_VALID );
+  while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
+    pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
+    pCur->idx = pPage->nCell;
+    rc = moveToChild(pCur, pgno);
+  }
+  if( rc==SQLITE_OK ){
+    pCur->idx = pPage->nCell - 1;
+    pCur->info.nSize = 0;
+  }
+  return SQLITE_OK;
+}
+
+/* Move the cursor to the first entry in the table.  Return SQLITE_OK
+** on success.  Set *pRes to 0 if the cursor actually points to something
+** or set *pRes to 1 if the table is empty.
+*/
+int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  rc = moveToRoot(pCur);
+  if( rc==SQLITE_OK ){
+    if( pCur->eState==CURSOR_INVALID ){
+      assert( pCur->pPage->nCell==0 );
+      *pRes = 1;
+      rc = SQLITE_OK;
+    }else{
+      assert( pCur->pPage->nCell>0 );
+      *pRes = 0;
+      rc = moveToLeftmost(pCur);
+    }
+  }
+  return rc;
+}
+
+/* Move the cursor to the last entry in the table.  Return SQLITE_OK
+** on success.  Set *pRes to 0 if the cursor actually points to something
+** or set *pRes to 1 if the table is empty.
+*/
+int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
+  int rc;
+ 
+  assert( cursorHoldsMutex(pCur) );
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  rc = moveToRoot(pCur);
+  if( rc==SQLITE_OK ){
+    if( CURSOR_INVALID==pCur->eState ){
+      assert( pCur->pPage->nCell==0 );
+      *pRes = 1;
+    }else{
+      assert( pCur->eState==CURSOR_VALID );
+      *pRes = 0;
+      rc = moveToRightmost(pCur);
+    }
+  }
+  return rc;
+}
+
+/* Move the cursor so that it points to an entry near pKey/nKey.
+** Return a success code.
+**
+** For INTKEY tables, only the nKey parameter is used.  pKey is
+** ignored.  For other tables, nKey is the number of bytes of data
+** in pKey.  The comparison function specified when the cursor was
+** created is used to compare keys.
+**
+** If an exact match is not found, then the cursor is always
+** left pointing at a leaf page which would hold the entry if it
+** were present.  The cursor might point to an entry that comes
+** before or after the key.
+**
+** The result of comparing the key with the entry to which the
+** cursor is written to *pRes if pRes!=NULL.  The meaning of
+** this value is as follows:
+**
+**     *pRes<0      The cursor is left pointing at an entry that
+**                  is smaller than pKey or if the table is empty
+**                  and the cursor is therefore left point to nothing.
+**
+**     *pRes==0     The cursor is left pointing at an entry that
+**                  exactly matches pKey.
+**
+**     *pRes>0      The cursor is left pointing at an entry that
+**                  is larger than pKey.
+**
+*/
+int sqlite3BtreeMoveto(
+  BtCursor *pCur,        /* The cursor to be moved */
+  const void *pKey,      /* The key content for indices.  Not used by tables */
+  i64 nKey,              /* Size of pKey.  Or the key for tables */
+  int biasRight,         /* If true, bias the search to the high end */
+  int *pRes              /* Search result flag */
+){
+  int rc;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  rc = moveToRoot(pCur);
+  if( rc ){
+    return rc;
+  }
+  assert( pCur->pPage );
+  assert( pCur->pPage->isInit );
+  if( pCur->eState==CURSOR_INVALID ){
+    *pRes = -1;
+    assert( pCur->pPage->nCell==0 );
+    return SQLITE_OK;
+  }
+  for(;;){
+    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_BKPT;
+    }
+    if( biasRight ){
+      pCur->idx = upr;
+    }else{
+      pCur->idx = (upr+lwr)/2;
+    }
+    if( lwr<=upr ) for(;;){
+      void *pCellKey;
+      i64 nCellKey;
+      pCur->info.nSize = 0;
+      if( pPage->intKey ){
+        u8 *pCell;
+        pCell = findCell(pPage, pCur->idx) + pPage->childPtrSize;
+        if( pPage->hasData ){
+          u32 dummy;
+          pCell += getVarint32(pCell, &dummy);
+        }
+        getVarint(pCell, (u64 *)&nCellKey);
+        if( nCellKey<nKey ){
+          c = -1;
+        }else if( nCellKey>nKey ){
+          c = +1;
+        }else{
+          c = 0;
+        }
+      }else{
+        int available;
+        pCellKey = (void *)fetchPayload(pCur, &available, 0);
+        nCellKey = pCur->info.nKey;
+        if( available>=nCellKey ){
+          c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey);
+        }else{
+          pCellKey = sqlite3_malloc( nCellKey );
+          if( pCellKey==0 ) return SQLITE_NOMEM;
+          rc = sqlite3BtreeKey(pCur, 0, nCellKey, (void *)pCellKey);
+          c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey);
+          sqlite3_free(pCellKey);
+          if( rc ){
+            return rc;
+          }
+        }
+      }
+      if( c==0 ){
+        if( pPage->leafData && !pPage->leaf ){
+          lwr = pCur->idx;
+          upr = lwr - 1;
+          break;
+        }else{
+          if( pRes ) *pRes = 0;
+          return SQLITE_OK;
+        }
+      }
+      if( c<0 ){
+        lwr = pCur->idx+1;
+      }else{
+        upr = pCur->idx-1;
+      }
+      if( lwr>upr ){
+        break;
+      }
+      pCur->idx = (lwr+upr)/2;
+    }
+    assert( lwr==upr+1 );
+    assert( pPage->isInit );
+    if( pPage->leaf ){
+      chldPg = 0;
+    }else if( lwr>=pPage->nCell ){
+      chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
+    }else{
+      chldPg = get4byte(findCell(pPage, lwr));
+    }
+    if( chldPg==0 ){
+      assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
+      if( pRes ) *pRes = c;
+      return SQLITE_OK;
+    }
+    pCur->idx = lwr;
+    pCur->info.nSize = 0;
+    rc = moveToChild(pCur, chldPg);
+    if( rc ){
+      return rc;
+    }
+  }
+  /* NOT REACHED */
+}
+
+
+/*
+** Return TRUE if the cursor is not pointing at an entry of the table.
+**
+** TRUE will be returned after a call to sqlite3BtreeNext() moves
+** past the last entry in the table or sqlite3BtreePrev() moves past
+** the first entry.  TRUE is also returned if the table is empty.
+*/
+int sqlite3BtreeEof(BtCursor *pCur){
+  /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
+  ** have been deleted? This API will need to change to return an error code
+  ** as well as the boolean result value.
+  */
+  return (CURSOR_VALID!=pCur->eState);
+}
+
+/*
+** Return the database connection handle for a cursor.
+*/
+sqlite3 *sqlite3BtreeCursorDb(const BtCursor *pCur){
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  return pCur->pBtree->db;
+}
+
+/*
+** Advance the cursor to the next entry in the database.  If
+** successful then set *pRes=0.  If the cursor
+** was already pointing to the last entry in the database before
+** this routine was called, then set *pRes=1.
+*/
+static int btreeNext(BtCursor *pCur, int *pRes){
+  int rc;
+  MemPage *pPage;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  assert( pRes!=0 );
+  pPage = pCur->pPage;
+  if( CURSOR_INVALID==pCur->eState ){
+    *pRes = 1;
+    return SQLITE_OK;
+  }
+  if( pCur->skip>0 ){
+    pCur->skip = 0;
+    *pRes = 0;
+    return SQLITE_OK;
+  }
+  pCur->skip = 0;
+
+  assert( pPage->isInit );
+  assert( pCur->idx<pPage->nCell );
+
+  pCur->idx++;
+  pCur->info.nSize = 0;
+  if( pCur->idx>=pPage->nCell ){
+    if( !pPage->leaf ){
+      rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
+      if( rc ) return rc;
+      rc = moveToLeftmost(pCur);
+      *pRes = 0;
+      return rc;
+    }
+    do{
+      if( sqlite3BtreeIsRootPage(pPage) ){
+        *pRes = 1;
+        pCur->eState = CURSOR_INVALID;
+        return SQLITE_OK;
+      }
+      sqlite3BtreeMoveToParent(pCur);
+      pPage = pCur->pPage;
+    }while( pCur->idx>=pPage->nCell );
+    *pRes = 0;
+    if( pPage->leafData ){
+      rc = sqlite3BtreeNext(pCur, pRes);
+    }else{
+      rc = SQLITE_OK;
+    }
+    return rc;
+  }
+  *pRes = 0;
+  if( pPage->leaf ){
+    return SQLITE_OK;
+  }
+  rc = moveToLeftmost(pCur);
+  return rc;
+}
+int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
+  int rc;
+  assert( cursorHoldsMutex(pCur) );
+  rc = btreeNext(pCur, pRes);
+  return rc;
+}
+
+
+/*
+** Step the cursor to the back to the previous entry in the database.  If
+** successful then set *pRes=0.  If the cursor
+** was already pointing to the first entry in the database before
+** this routine was called, then set *pRes=1.
+*/
+static int btreePrevious(BtCursor *pCur, int *pRes){
+  int rc;
+  Pgno pgno;
+  MemPage *pPage;
+
+  assert( cursorHoldsMutex(pCur) );
+  rc = restoreOrClearCursorPosition(pCur);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  if( CURSOR_INVALID==pCur->eState ){
+    *pRes = 1;
+    return SQLITE_OK;
+  }
+  if( pCur->skip<0 ){
+    pCur->skip = 0;
+    *pRes = 0;
+    return SQLITE_OK;
+  }
+  pCur->skip = 0;
+
+  pPage = pCur->pPage;
+  assert( pPage->isInit );
+  assert( pCur->idx>=0 );
+  if( !pPage->leaf ){
+    pgno = get4byte( findCell(pPage, pCur->idx) );
+    rc = moveToChild(pCur, pgno);
+    if( rc ){
+      return rc;
+    }
+    rc = moveToRightmost(pCur);
+  }else{
+    while( pCur->idx==0 ){
+      if( sqlite3BtreeIsRootPage(pPage) ){
+        pCur->eState = CURSOR_INVALID;
+        *pRes = 1;
+        return SQLITE_OK;
+      }
+      sqlite3BtreeMoveToParent(pCur);
+      pPage = pCur->pPage;
+    }
+    pCur->idx--;
+    pCur->info.nSize = 0;
+    if( pPage->leafData && !pPage->leaf ){
+      rc = sqlite3BtreePrevious(pCur, pRes);
+    }else{
+      rc = SQLITE_OK;
+    }
+  }
+  *pRes = 0;
+  return rc;
+}
+int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
+  int rc;
+  assert( cursorHoldsMutex(pCur) );
+  rc = btreePrevious(pCur, pRes);
+  return rc;
+}
+
+/*
+** Allocate a new page from the database file.
+**
+** The new page is marked as dirty.  (In other words, sqlite3PagerWrite()
+** has already been called on the new page.)  The new page has also
+** been referenced and the calling routine is responsible for calling
+** sqlite3PagerUnref() on the new page when it is done.
+**
+** SQLITE_OK is returned on success.  Any other return value indicates
+** an error.  *ppPage and *pPgno are undefined in the event of an error.
+** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
+**
+** If the "nearby" parameter is not 0, then a (feeble) effort is made to 
+** locate a page close to the page number "nearby".  This can be used in an
+** attempt to keep related pages close to each other in the database file,
+** which in turn can make database access faster.
+**
+** If the "exact" parameter is not 0, and the page-number nearby exists 
+** anywhere on the free-list, then it is guarenteed to be returned. This
+** is only used by auto-vacuum databases when allocating a new table.
+*/
+static int allocateBtreePage(
+  BtShared *pBt, 
+  MemPage **ppPage, 
+  Pgno *pPgno, 
+  Pgno nearby,
+  u8 exact
+){
+  MemPage *pPage1;
+  int rc;
+  int n;     /* Number of pages on the freelist */
+  int k;     /* Number of leaves on the trunk of the freelist */
+  MemPage *pTrunk = 0;
+  MemPage *pPrevTrunk = 0;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  pPage1 = pBt->pPage1;
+  n = get4byte(&pPage1->aData[36]);
+  if( n>0 ){
+    /* There are pages on the freelist.  Reuse one of those pages. */
+    Pgno iTrunk;
+    u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
+    
+    /* If the 'exact' parameter was true and a query of the pointer-map
+    ** shows that the page 'nearby' is somewhere on the free-list, then
+    ** the entire-list will be searched for that page.
+    */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( exact && nearby<=sqlite3PagerPagecount(pBt->pPager) ){
+      u8 eType;
+      assert( nearby>0 );
+      assert( pBt->autoVacuum );
+      rc = ptrmapGet(pBt, nearby, &eType, 0);
+      if( rc ) return rc;
+      if( eType==PTRMAP_FREEPAGE ){
+        searchList = 1;
+      }
+      *pPgno = nearby;
+    }
+#endif
+
+    /* Decrement the free-list count by 1. Set iTrunk to the index of the
+    ** first free-list trunk page. iPrevTrunk is initially 1.
+    */
+    rc = sqlite3PagerWrite(pPage1->pDbPage);
+    if( rc ) return rc;
+    put4byte(&pPage1->aData[36], n-1);
+
+    /* The code within this loop is run only once if the 'searchList' variable
+    ** is not true. Otherwise, it runs once for each trunk-page on the
+    ** free-list until the page 'nearby' is located.
+    */
+    do {
+      pPrevTrunk = pTrunk;
+      if( pPrevTrunk ){
+        iTrunk = get4byte(&pPrevTrunk->aData[0]);
+      }else{
+        iTrunk = get4byte(&pPage1->aData[32]);
+      }
+      rc = sqlite3BtreeGetPage(pBt, iTrunk, &pTrunk, 0);
+      if( rc ){
+        pTrunk = 0;
+        goto end_allocate_page;
+      }
+
+      k = get4byte(&pTrunk->aData[4]);
+      if( k==0 && !searchList ){
+        /* The trunk has no leaves and the list is not being searched. 
+        ** So extract the trunk page itself and use it as the newly 
+        ** allocated page */
+        assert( pPrevTrunk==0 );
+        rc = sqlite3PagerWrite(pTrunk->pDbPage);
+        if( rc ){
+          goto end_allocate_page;
+        }
+        *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 */
+        rc = SQLITE_CORRUPT_BKPT;
+        goto end_allocate_page;
+#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;
+        searchList = 0;
+        rc = sqlite3PagerWrite(pTrunk->pDbPage);
+        if( rc ){
+          goto end_allocate_page;
+        }
+        if( k==0 ){
+          if( !pPrevTrunk ){
+            memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
+          }else{
+            memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
+          }
+        }else{
+          /* The trunk page is required by the caller but it contains 
+          ** pointers to free-list leaves. The first leaf becomes a trunk
+          ** page in this case.
+          */
+          MemPage *pNewTrunk;
+          Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
+          rc = sqlite3BtreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
+          if( rc!=SQLITE_OK ){
+            goto end_allocate_page;
+          }
+          rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
+          if( rc!=SQLITE_OK ){
+            releasePage(pNewTrunk);
+            goto end_allocate_page;
+          }
+          memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
+          put4byte(&pNewTrunk->aData[4], k-1);
+          memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
+          releasePage(pNewTrunk);
+          if( !pPrevTrunk ){
+            put4byte(&pPage1->aData[32], iNewTrunk);
+          }else{
+            rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
+            if( rc ){
+              goto end_allocate_page;
+            }
+            put4byte(&pPrevTrunk->aData[0], iNewTrunk);
+          }
+        }
+        pTrunk = 0;
+        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
+#endif
+      }else{
+        /* Extract a leaf from the trunk */
+        int closest;
+        Pgno iPage;
+        unsigned char *aData = pTrunk->aData;
+        rc = sqlite3PagerWrite(pTrunk->pDbPage);
+        if( rc ){
+          goto end_allocate_page;
+        }
+        if( nearby>0 ){
+          int i, dist;
+          closest = 0;
+          dist = get4byte(&aData[8]) - nearby;
+          if( dist<0 ) dist = -dist;
+          for(i=1; i<k; i++){
+            int d2 = get4byte(&aData[8+i*4]) - nearby;
+            if( d2<0 ) d2 = -d2;
+            if( d2<dist ){
+              closest = i;
+              dist = d2;
+            }
+          }
+        }else{
+          closest = 0;
+        }
+
+        iPage = get4byte(&aData[8+closest*4]);
+        if( !searchList || iPage==nearby ){
+          *pPgno = iPage;
+          if( *pPgno>sqlite3PagerPagecount(pBt->pPager) ){
+            /* Free page off the end of the file */
+            return SQLITE_CORRUPT_BKPT;
+          }
+          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);
+          }
+          put4byte(&aData[4], k-1);
+          rc = sqlite3BtreeGetPage(pBt, *pPgno, ppPage, 1);
+          if( rc==SQLITE_OK ){
+            sqlite3PagerDontRollback((*ppPage)->pDbPage);
+            rc = sqlite3PagerWrite((*ppPage)->pDbPage);
+            if( rc!=SQLITE_OK ){
+              releasePage(*ppPage);
+            }
+          }
+          searchList = 0;
+        }
+      }
+      releasePage(pPrevTrunk);
+      pPrevTrunk = 0;
+    }while( searchList );
+  }else{
+    /* There are no pages on the freelist, so create a new page at the
+    ** end of the file */
+    *pPgno = sqlite3PagerPagecount(pBt->pPager) + 1;
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pBt->nTrunc ){
+      /* An incr-vacuum has already run within this transaction. So the
+      ** page to allocate is not from the physical end of the file, but
+      ** at pBt->nTrunc. 
+      */
+      *pPgno = pBt->nTrunc+1;
+      if( *pPgno==PENDING_BYTE_PAGE(pBt) ){
+        (*pPgno)++;
+      }
+    }
+    if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){
+      /* If *pPgno refers to a pointer-map page, allocate two new pages
+      ** at the end of the file instead of one. The first allocated page
+      ** becomes a new pointer-map page, the second is used by the caller.
+      */
+      TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", *pPgno));
+      assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
+      (*pPgno)++;
+      if( *pPgno==PENDING_BYTE_PAGE(pBt) ){ (*pPgno)++; }
+    }
+    if( pBt->nTrunc ){
+      pBt->nTrunc = *pPgno;
+    }
+#endif
+
+    assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
+    rc = sqlite3BtreeGetPage(pBt, *pPgno, ppPage, 0);
+    if( rc ) return rc;
+    rc = sqlite3PagerWrite((*ppPage)->pDbPage);
+    if( rc!=SQLITE_OK ){
+      releasePage(*ppPage);
+    }
+    TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
+  }
+
+  assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
+
+end_allocate_page:
+  releasePage(pTrunk);
+  releasePage(pPrevTrunk);
+  return rc;
+}
+
+/*
+** Add a page of the database file to the freelist.
+**
+** sqlite3PagerUnref() is NOT called for pPage.
+*/
+static int freePage(MemPage *pPage){
+  BtShared *pBt = pPage->pBt;
+  MemPage *pPage1 = pBt->pPage1;
+  int rc, n, k;
+
+  /* Prepare the page for freeing */
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  assert( pPage->pgno>1 );
+  pPage->isInit = 0;
+  releasePage(pPage->pParent);
+  pPage->pParent = 0;
+
+  /* Increment the free page count on pPage1 */
+  rc = sqlite3PagerWrite(pPage1->pDbPage);
+  if( rc ) return rc;
+  n = get4byte(&pPage1->aData[36]);
+  put4byte(&pPage1->aData[36], n+1);
+
+#ifdef SQLITE_SECURE_DELETE
+  /* If the SQLITE_SECURE_DELETE compile-time option is enabled, then
+  ** always fully overwrite deleted information with zeros.
+  */
+  rc = sqlite3PagerWrite(pPage->pDbPage);
+  if( rc ) return rc;
+  memset(pPage->aData, 0, pPage->pBt->pageSize);
+#endif
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  /* If the database supports auto-vacuum, write an entry in the pointer-map
+  ** to indicate that the page is free.
+  */
+  if( pBt->autoVacuum ){
+    rc = ptrmapPut(pBt, pPage->pgno, PTRMAP_FREEPAGE, 0);
+    if( rc ) return rc;
+  }
+#endif
+
+  if( n==0 ){
+    /* This is the first free page */
+    rc = sqlite3PagerWrite(pPage->pDbPage);
+    if( rc ) return rc;
+    memset(pPage->aData, 0, 8);
+    put4byte(&pPage1->aData[32], pPage->pgno);
+    TRACE(("FREE-PAGE: %d first\n", pPage->pgno));
+  }else{
+    /* Other free pages already exist.  Retrive the first trunk page
+    ** of the freelist and find out how many leaves it has. */
+    MemPage *pTrunk;
+    rc = sqlite3BtreeGetPage(pBt, get4byte(&pPage1->aData[32]), &pTrunk, 0);
+    if( rc ) return rc;
+    k = get4byte(&pTrunk->aData[4]);
+    if( k>=pBt->usableSize/4 - 8 ){
+      /* The trunk is full.  Turn the page being freed into a new
+      ** trunk page with no leaves. */
+      rc = sqlite3PagerWrite(pPage->pDbPage);
+      if( rc==SQLITE_OK ){
+        put4byte(pPage->aData, pTrunk->pgno);
+        put4byte(&pPage->aData[4], 0);
+        put4byte(&pPage1->aData[32], pPage->pgno);
+        TRACE(("FREE-PAGE: %d new trunk page replacing %d\n",
+                pPage->pgno, pTrunk->pgno));
+      }
+    }else if( k<0 ){
+      rc = SQLITE_CORRUPT;
+    }else{
+      /* Add the newly freed page as a leaf on the current trunk */
+      rc = sqlite3PagerWrite(pTrunk->pDbPage);
+      if( rc==SQLITE_OK ){
+        put4byte(&pTrunk->aData[4], k+1);
+        put4byte(&pTrunk->aData[8+k*4], pPage->pgno);
+#ifndef SQLITE_SECURE_DELETE
+        sqlite3PagerDontWrite(pPage->pDbPage);
+#endif
+      }
+      TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
+    }
+    releasePage(pTrunk);
+  }
+  return rc;
+}
+
+/*
+** Free any overflow pages associated with the given Cell.
+*/
+static int clearCell(MemPage *pPage, unsigned char *pCell){
+  BtShared *pBt = pPage->pBt;
+  CellInfo info;
+  Pgno ovflPgno;
+  int rc;
+  int nOvfl;
+  int ovflPageSize;
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+  if( info.iOverflow==0 ){
+    return SQLITE_OK;  /* No overflow pages. Return without doing anything */
+  }
+  ovflPgno = get4byte(&pCell[info.iOverflow]);
+  ovflPageSize = pBt->usableSize - 4;
+  nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize;
+  assert( ovflPgno==0 || nOvfl>0 );
+  while( nOvfl-- ){
+    MemPage *pOvfl;
+    if( ovflPgno==0 || ovflPgno>sqlite3PagerPagecount(pBt->pPager) ){
+      return SQLITE_CORRUPT_BKPT;
+    }
+
+    rc = getOverflowPage(pBt, ovflPgno, &pOvfl, (nOvfl==0)?0:&ovflPgno);
+    if( rc ) return rc;
+    rc = freePage(pOvfl);
+    sqlite3PagerUnref(pOvfl->pDbPage);
+    if( rc ) return rc;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Create the byte sequence used to represent a cell on page pPage
+** and write that byte sequence into pCell[].  Overflow pages are
+** allocated and filled in as necessary.  The calling procedure
+** is responsible for making sure sufficient space has been allocated
+** for pCell[].
+**
+** Note that pCell does not necessary need to point to the pPage->aData
+** area.  pCell might point to some temporary storage.  The cell will
+** be constructed in this temporary area then copied into pPage->aData
+** later.
+*/
+static int fillInCell(
+  MemPage *pPage,                /* The page that contains the cell */
+  unsigned char *pCell,          /* Complete text of the cell */
+  const void *pKey, i64 nKey,    /* The key */
+  const void *pData,int nData,   /* The data */
+  int nZero,                     /* Extra zero bytes to append to pData */
+  int *pnSize                    /* Write cell size here */
+){
+  int nPayload;
+  const u8 *pSrc;
+  int nSrc, n, rc;
+  int spaceLeft;
+  MemPage *pOvfl = 0;
+  MemPage *pToRelease = 0;
+  unsigned char *pPrior;
+  unsigned char *pPayload;
+  BtShared *pBt = pPage->pBt;
+  Pgno pgnoOvfl = 0;
+  int nHeader;
+  CellInfo info;
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+
+  /* Fill in the header. */
+  nHeader = 0;
+  if( !pPage->leaf ){
+    nHeader += 4;
+  }
+  if( pPage->hasData ){
+    nHeader += putVarint(&pCell[nHeader], nData+nZero);
+  }else{
+    nData = nZero = 0;
+  }
+  nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
+  sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+  assert( info.nHeader==nHeader );
+  assert( info.nKey==nKey );
+  assert( info.nData==nData+nZero );
+  
+  /* Fill in the payload */
+  nPayload = nData + nZero;
+  if( pPage->intKey ){
+    pSrc = pData;
+    nSrc = nData;
+    nData = 0;
+  }else{
+    nPayload += nKey;
+    pSrc = pKey;
+    nSrc = nKey;
+  }
+  *pnSize = info.nSize;
+  spaceLeft = info.nLocal;
+  pPayload = &pCell[nHeader];
+  pPrior = &pCell[info.iOverflow];
+
+  while( nPayload>0 ){
+    if( spaceLeft==0 ){
+      int isExact = 0;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
+      if( pBt->autoVacuum ){
+        do{
+          pgnoOvfl++;
+        } while( 
+          PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) 
+        );
+        if( pgnoOvfl>1 ){
+          /* isExact = 1; */
+        }
+      }
+#endif
+      rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, isExact);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      /* If the database supports auto-vacuum, and the second or subsequent
+      ** overflow page is being allocated, add an entry to the pointer-map
+      ** for that page now. 
+      **
+      ** If this is the first overflow page, then write a partial entry 
+      ** to the pointer-map. If we write nothing to this pointer-map slot,
+      ** then the optimistic overflow chain processing in clearCell()
+      ** may misinterpret the uninitialised values and delete the
+      ** wrong pages from the database.
+      */
+      if( pBt->autoVacuum && rc==SQLITE_OK ){
+        u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
+        rc = ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap);
+        if( rc ){
+          releasePage(pOvfl);
+        }
+      }
+#endif
+      if( rc ){
+        releasePage(pToRelease);
+        return rc;
+      }
+      put4byte(pPrior, pgnoOvfl);
+      releasePage(pToRelease);
+      pToRelease = pOvfl;
+      pPrior = pOvfl->aData;
+      put4byte(pPrior, 0);
+      pPayload = &pOvfl->aData[4];
+      spaceLeft = pBt->usableSize - 4;
+    }
+    n = nPayload;
+    if( n>spaceLeft ) n = spaceLeft;
+    if( nSrc>0 ){
+      if( n>nSrc ) n = nSrc;
+      assert( pSrc );
+      memcpy(pPayload, pSrc, n);
+    }else{
+      memset(pPayload, 0, n);
+    }
+    nPayload -= n;
+    pPayload += n;
+    pSrc += n;
+    nSrc -= n;
+    spaceLeft -= n;
+    if( nSrc==0 ){
+      nSrc = nData;
+      pSrc = pData;
+    }
+  }
+  releasePage(pToRelease);
+  return SQLITE_OK;
+}
+
+/*
+** Change the MemPage.pParent pointer on the page whose number is
+** given in the second argument so that MemPage.pParent holds the
+** pointer in the third argument.
+*/
+static int reparentPage(BtShared *pBt, Pgno pgno, MemPage *pNewParent, int idx){
+  MemPage *pThis;
+  DbPage *pDbPage;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  assert( pNewParent!=0 );
+  if( pgno==0 ) return SQLITE_OK;
+  assert( pBt->pPager!=0 );
+  pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
+  if( pDbPage ){
+    pThis = (MemPage *)sqlite3PagerGetExtra(pDbPage);
+    if( pThis->isInit ){
+      assert( pThis->aData==sqlite3PagerGetData(pDbPage) );
+      if( pThis->pParent!=pNewParent ){
+        if( pThis->pParent ) sqlite3PagerUnref(pThis->pParent->pDbPage);
+        pThis->pParent = pNewParent;
+        sqlite3PagerRef(pNewParent->pDbPage);
+      }
+      pThis->idxParent = idx;
+    }
+    sqlite3PagerUnref(pDbPage);
+  }
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( pBt->autoVacuum ){
+    return ptrmapPut(pBt, pgno, PTRMAP_BTREE, pNewParent->pgno);
+  }
+#endif
+  return SQLITE_OK;
+}
+
+
+
+/*
+** Change the pParent pointer of all children of pPage to point back
+** to pPage.
+**
+** In other words, for every child of pPage, invoke reparentPage()
+** to make sure that each child knows that pPage is its parent.
+**
+** This routine gets called after you memcpy() one page into
+** another.
+*/
+static int reparentChildPages(MemPage *pPage){
+  int i;
+  BtShared *pBt = pPage->pBt;
+  int rc = SQLITE_OK;
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( pPage->leaf ) return SQLITE_OK;
+
+  for(i=0; i<pPage->nCell; i++){
+    u8 *pCell = findCell(pPage, i);
+    if( !pPage->leaf ){
+      rc = reparentPage(pBt, get4byte(pCell), pPage, i);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+  }
+  if( !pPage->leaf ){
+    rc = reparentPage(pBt, get4byte(&pPage->aData[pPage->hdrOffset+8]), 
+       pPage, i);
+    pPage->idxShift = 0;
+  }
+  return rc;
+}
+
+/*
+** Remove the i-th cell from pPage.  This routine effects pPage only.
+** The cell content is not freed or deallocated.  It is assumed that
+** the cell content has been copied someplace else.  This routine just
+** removes the reference to the cell from pPage.
+**
+** "sz" must be the number of bytes in the cell.
+*/
+static void dropCell(MemPage *pPage, int idx, int sz){
+  int i;          /* Loop counter */
+  int pc;         /* Offset to cell content of cell being deleted */
+  u8 *data;       /* pPage->aData */
+  u8 *ptr;        /* Used to move bytes around within data[] */
+
+  assert( idx>=0 && idx<pPage->nCell );
+  assert( sz==cellSize(pPage, idx) );
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  data = pPage->aData;
+  ptr = &data[pPage->cellOffset + 2*idx];
+  pc = get2byte(ptr);
+  assert( pc>10 && pc+sz<=pPage->pBt->usableSize );
+  freeSpace(pPage, pc, sz);
+  for(i=idx+1; i<pPage->nCell; i++, ptr+=2){
+    ptr[0] = ptr[2];
+    ptr[1] = ptr[3];
+  }
+  pPage->nCell--;
+  put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
+  pPage->nFree += 2;
+  pPage->idxShift = 1;
+}
+
+/*
+** Insert a new cell on pPage at cell index "i".  pCell points to the
+** content of the cell.
+**
+** If the cell content will fit on the page, then put it there.  If it
+** will not fit, then make a copy of the cell content into pTemp if
+** pTemp is not null.  Regardless of pTemp, allocate a new entry
+** in pPage->aOvfl[] and make it point to the cell content (either
+** in pTemp or the original pCell) and also record its index. 
+** Allocating a new entry in pPage->aCell[] implies that 
+** pPage->nOverflow is incremented.
+**
+** If nSkip is non-zero, then do not copy the first nSkip bytes of the
+** cell. The caller will overwrite them after this function returns. If
+** nSkip is non-zero, then pCell may not point to an invalid memory location 
+** (but pCell+nSkip is always valid).
+*/
+static int insertCell(
+  MemPage *pPage,   /* Page into which we are copying */
+  int i,            /* New cell becomes the i-th cell of the page */
+  u8 *pCell,        /* Content of the new cell */
+  int sz,           /* Bytes of content in pCell */
+  u8 *pTemp,        /* Temp storage space for pCell, if needed */
+  u8 nSkip          /* Do not write the first nSkip bytes of the cell */
+){
+  int idx;          /* Where to write new cell content in data[] */
+  int j;            /* Loop counter */
+  int top;          /* First byte of content for any cell in data[] */
+  int end;          /* First byte past the last cell pointer in data[] */
+  int ins;          /* Index in data[] where new cell pointer is inserted */
+  int hdr;          /* Offset into data[] of the page header */
+  int cellOffset;   /* Address of first cell pointer in data[] */
+  u8 *data;         /* The content of the whole page */
+  u8 *ptr;          /* Used for moving information around in data[] */
+
+  assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
+  assert( sz==cellSizePtr(pPage, pCell) );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( pPage->nOverflow || sz+2>pPage->nFree ){
+    if( pTemp ){
+      memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
+      pCell = pTemp;
+    }
+    j = pPage->nOverflow++;
+    assert( j<sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0]) );
+    pPage->aOvfl[j].pCell = pCell;
+    pPage->aOvfl[j].idx = i;
+    pPage->nFree = 0;
+  }else{
+    int rc = sqlite3PagerWrite(pPage->pDbPage);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    assert( sqlite3PagerIswriteable(pPage->pDbPage) );
+    data = pPage->aData;
+    hdr = pPage->hdrOffset;
+    top = get2byte(&data[hdr+5]);
+    cellOffset = pPage->cellOffset;
+    end = cellOffset + 2*pPage->nCell + 2;
+    ins = cellOffset + 2*i;
+    if( end > top - sz ){
+      rc = defragmentPage(pPage);
+      if( rc!=SQLITE_OK ) return rc;
+      top = get2byte(&data[hdr+5]);
+      assert( end + sz <= top );
+    }
+    idx = allocateSpace(pPage, sz);
+    assert( idx>0 );
+    assert( end <= get2byte(&data[hdr+5]) );
+    pPage->nCell++;
+    pPage->nFree -= 2;
+    memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
+    for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){
+      ptr[0] = ptr[-2];
+      ptr[1] = ptr[-1];
+    }
+    put2byte(&data[ins], idx);
+    put2byte(&data[hdr+3], pPage->nCell);
+    pPage->idxShift = 1;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pPage->pBt->autoVacuum ){
+      /* The cell may contain a pointer to an overflow page. If so, write
+      ** the entry for the overflow page into the pointer map.
+      */
+      CellInfo info;
+      sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+      assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
+      if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
+        Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
+        rc = ptrmapPut(pPage->pBt, pgnoOvfl, PTRMAP_OVERFLOW1, pPage->pgno);
+        if( rc!=SQLITE_OK ) return rc;
+      }
+    }
+#endif
+  }
+
+  return SQLITE_OK;
+}
+
+/*
+** Add a list of cells to a page.  The page should be initially empty.
+** The cells are guaranteed to fit on the page.
+*/
+static void assemblePage(
+  MemPage *pPage,   /* The page to be assemblied */
+  int nCell,        /* The number of cells to add to this page */
+  u8 **apCell,      /* Pointers to cell bodies */
+  int *aSize        /* Sizes of the cells */
+){
+  int i;            /* Loop counter */
+  int totalSize;    /* Total size of all cells */
+  int hdr;          /* Index of page header */
+  int cellptr;      /* Address of next cell pointer */
+  int cellbody;     /* Address of next cell body */
+  u8 *data;         /* Data for the page */
+
+  assert( pPage->nOverflow==0 );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  totalSize = 0;
+  for(i=0; i<nCell; i++){
+    totalSize += aSize[i];
+  }
+  assert( totalSize+2*nCell<=pPage->nFree );
+  assert( pPage->nCell==0 );
+  cellptr = pPage->cellOffset;
+  data = pPage->aData;
+  hdr = pPage->hdrOffset;
+  put2byte(&data[hdr+3], nCell);
+  if( nCell ){
+    cellbody = allocateSpace(pPage, totalSize);
+    assert( cellbody>0 );
+    assert( pPage->nFree >= 2*nCell );
+    pPage->nFree -= 2*nCell;
+    for(i=0; i<nCell; i++){
+      put2byte(&data[cellptr], cellbody);
+      memcpy(&data[cellbody], apCell[i], aSize[i]);
+      cellptr += 2;
+      cellbody += aSize[i];
+    }
+    assert( cellbody==pPage->pBt->usableSize );
+  }
+  pPage->nCell = nCell;
+}
+
+/*
+** The following parameters determine how many adjacent pages get involved
+** in a balancing operation.  NN is the number of neighbors on either side
+** of the page that participate in the balancing operation.  NB is the
+** total number of pages that participate, including the target page and
+** NN neighbors on either side.
+**
+** The minimum value of NN is 1 (of course).  Increasing NN above 1
+** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
+** in exchange for a larger degradation in INSERT and UPDATE performance.
+** The value of NN appears to give the best results overall.
+*/
+#define NN 1             /* Number of neighbors on either side of pPage */
+#define NB (NN*2+1)      /* Total pages involved in the balance */
+
+/* Forward reference */
+static int balance(MemPage*, int);
+
+#ifndef SQLITE_OMIT_QUICKBALANCE
+/*
+** This version of balance() handles the common special case where
+** a new entry is being inserted on the extreme right-end of the
+** tree, in other words, when the new entry will become the largest
+** entry in the tree.
+**
+** Instead of trying balance the 3 right-most leaf pages, just add
+** a new page to the right-hand side and put the one new entry in
+** that page.  This leaves the right side of the tree somewhat
+** unbalanced.  But odds are that we will be inserting new entries
+** at the end soon afterwards so the nearly empty page will quickly
+** fill up.  On average.
+**
+** pPage is the leaf page which is the right-most page in the tree.
+** pParent is its parent.  pPage must have a single overflow entry
+** which is also the right-most entry on the page.
+*/
+static int balance_quick(MemPage *pPage, MemPage *pParent){
+  int rc;
+  MemPage *pNew;
+  Pgno pgnoNew;
+  u8 *pCell;
+  int szCell;
+  CellInfo info;
+  BtShared *pBt = pPage->pBt;
+  int parentIdx = pParent->nCell;   /* pParent new divider cell index */
+  int parentSize;                   /* Size of new divider cell */
+  u8 parentCell[64];                /* Space for the new divider cell */
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+
+  /* Allocate a new page. Insert the overflow cell from pPage
+  ** into it. Then remove the overflow cell from pPage.
+  */
+  rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  pCell = pPage->aOvfl[0].pCell;
+  szCell = cellSizePtr(pPage, pCell);
+  zeroPage(pNew, pPage->aData[0]);
+  assemblePage(pNew, 1, &pCell, &szCell);
+  pPage->nOverflow = 0;
+
+  /* Set the parent of the newly allocated page to pParent. */
+  pNew->pParent = pParent;
+  sqlite3PagerRef(pParent->pDbPage);
+
+  /* pPage is currently the right-child of pParent. Change this
+  ** so that the right-child is the new page allocated above and
+  ** pPage is the next-to-right child. 
+  */
+  assert( pPage->nCell>0 );
+  pCell = findCell(pPage, pPage->nCell-1);
+  sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+  rc = fillInCell(pParent, parentCell, 0, info.nKey, 0, 0, 0, &parentSize);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  assert( parentSize<64 );
+  rc = insertCell(pParent, parentIdx, parentCell, parentSize, 0, 4);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  put4byte(findOverflowCell(pParent,parentIdx), pPage->pgno);
+  put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  /* If this is an auto-vacuum database, update the pointer map
+  ** with entries for the new page, and any pointer from the 
+  ** cell on the page to an overflow page.
+  */
+  if( pBt->autoVacuum ){
+    rc = ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno);
+    if( rc==SQLITE_OK ){
+      rc = ptrmapPutOvfl(pNew, 0);
+    }
+    if( rc!=SQLITE_OK ){
+      releasePage(pNew);
+      return rc;
+    }
+  }
+#endif
+
+  /* Release the reference to the new page and balance the parent page,
+  ** in case the divider cell inserted caused it to become overfull.
+  */
+  releasePage(pNew);
+  return balance(pParent, 0);
+}
+#endif /* SQLITE_OMIT_QUICKBALANCE */
+
+/*
+** This routine redistributes Cells on pPage and up to NN*2 siblings
+** of pPage so that all pages have about the same amount of free space.
+** Usually NN siblings on either side of pPage is used in the balancing,
+** though more siblings might come from one side if pPage is the first
+** or last child of its parent.  If pPage has fewer than 2*NN siblings
+** (something which can only happen if pPage is the root page or a 
+** child of root) then all available siblings participate in the balancing.
+**
+** The number of siblings of pPage might be increased or decreased by one or
+** two in an effort to keep pages nearly full but not over full. The root page
+** is special and is allowed to be nearly empty. If pPage is 
+** the root page, then the depth of the tree might be increased
+** or decreased by one, as necessary, to keep the root page from being
+** overfull or completely empty.
+**
+** Note that when this routine is called, some of the Cells on pPage
+** might not actually be stored in pPage->aData[].  This can happen
+** if the page is overfull.  Part of the job of this routine is to
+** make sure all Cells for pPage once again fit in pPage->aData[].
+**
+** In the course of balancing the siblings of pPage, the parent of pPage
+** might become overfull or underfull.  If that happens, then this routine
+** is called recursively on the parent.
+**
+** If this routine fails for any reason, it might leave the database
+** in a corrupted state.  So if this routine fails, the database should
+** be rolled back.
+*/
+static int balance_nonroot(MemPage *pPage){
+  MemPage *pParent;            /* The parent of pPage */
+  BtShared *pBt;               /* The whole database */
+  int nCell = 0;               /* Number of cells in apCell[] */
+  int nMaxCells = 0;           /* Allocated size of apCell, szCell, aFrom. */
+  int nOld;                    /* Number of pages in apOld[] */
+  int nNew;                    /* Number of pages in apNew[] */
+  int nDiv;                    /* Number of cells in apDiv[] */
+  int i, j, k;                 /* Loop counters */
+  int idx;                     /* Index of pPage in pParent->aCell[] */
+  int nxDiv;                   /* Next divider slot in pParent->aCell[] */
+  int rc;                      /* The return code */
+  int leafCorrection;          /* 4 if pPage is a leaf.  0 if not */
+  int leafData;                /* True if pPage is a leaf of a LEAFDATA tree */
+  int usableSpace;             /* Bytes in pPage beyond the header */
+  int pageFlags;               /* Value of pPage->aData[0] */
+  int subtotal;                /* Subtotal of bytes in cells on one page */
+  int iSpace = 0;              /* First unused byte of aSpace[] */
+  MemPage *apOld[NB];          /* pPage and up to two siblings */
+  Pgno pgnoOld[NB];            /* Page numbers for each page in apOld[] */
+  MemPage *apCopy[NB];         /* Private copies of apOld[] pages */
+  MemPage *apNew[NB+2];        /* pPage and up to NB siblings after balancing */
+  Pgno pgnoNew[NB+2];          /* Page numbers for each page in apNew[] */
+  u8 *apDiv[NB];               /* Divider cells in pParent */
+  int cntNew[NB+2];            /* Index in aCell[] of cell after i-th page */
+  int szNew[NB+2];             /* Combined size of cells place on i-th page */
+  u8 **apCell = 0;             /* All cells begin balanced */
+  int *szCell;                 /* Local size of all cells in apCell[] */
+  u8 *aCopy[NB];               /* Space for holding data of apCopy[] */
+  u8 *aSpace;                  /* Space to hold copies of dividers cells */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  u8 *aFrom = 0;
+#endif
+
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+
+  /* 
+  ** Find the parent page.
+  */
+  assert( pPage->isInit );
+  assert( sqlite3PagerIswriteable(pPage->pDbPage) || pPage->nOverflow==1 );
+  pBt = pPage->pBt;
+  pParent = pPage->pParent;
+  assert( pParent );
+  if( SQLITE_OK!=(rc = sqlite3PagerWrite(pParent->pDbPage)) ){
+    return rc;
+  }
+  TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
+
+#ifndef SQLITE_OMIT_QUICKBALANCE
+  /*
+  ** A special case:  If a new entry has just been inserted into a
+  ** table (that is, a btree with integer keys and all data at the leaves)
+  ** and the new entry is the right-most entry in the tree (it has the
+  ** largest key) then use the special balance_quick() routine for
+  ** balancing.  balance_quick() is much faster and results in a tighter
+  ** packing of data in the common case.
+  */
+  if( pPage->leaf &&
+      pPage->intKey &&
+      pPage->leafData &&
+      pPage->nOverflow==1 &&
+      pPage->aOvfl[0].idx==pPage->nCell &&
+      pPage->pParent->pgno!=1 &&
+      get4byte(&pParent->aData[pParent->hdrOffset+8])==pPage->pgno
+  ){
+    /*
+    ** TODO: Check the siblings to the left of pPage. It may be that
+    ** they are not full and no new page is required.
+    */
+    return balance_quick(pPage, pParent);
+  }
+#endif
+
+  if( SQLITE_OK!=(rc = sqlite3PagerWrite(pPage->pDbPage)) ){
+    return rc;
+  }
+
+  /*
+  ** Find the cell in the parent page whose left child points back
+  ** to pPage.  The "idx" variable is the index of that cell.  If pPage
+  ** is the rightmost child of pParent then set idx to pParent->nCell 
+  */
+  if( pParent->idxShift ){
+    Pgno pgno;
+    pgno = pPage->pgno;
+    assert( pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
+    for(idx=0; idx<pParent->nCell; idx++){
+      if( get4byte(findCell(pParent, idx))==pgno ){
+        break;
+      }
+    }
+    assert( idx<pParent->nCell
+             || get4byte(&pParent->aData[pParent->hdrOffset+8])==pgno );
+  }else{
+    idx = pPage->idxParent;
+  }
+
+  /*
+  ** Initialize variables so that it will be safe to jump
+  ** directly to balance_cleanup at any moment.
+  */
+  nOld = nNew = 0;
+  sqlite3PagerRef(pParent->pDbPage);
+
+  /*
+  ** Find sibling pages to pPage and the cells in pParent that divide
+  ** the siblings.  An attempt is made to find NN siblings on either
+  ** side of pPage.  More siblings are taken from one side, however, if
+  ** pPage there are fewer than NN siblings on the other side.  If pParent
+  ** has NB or fewer children then all children of pParent are taken.
+  */
+  nxDiv = idx - NN;
+  if( nxDiv + NB > pParent->nCell ){
+    nxDiv = pParent->nCell - NB + 1;
+  }
+  if( nxDiv<0 ){
+    nxDiv = 0;
+  }
+  nDiv = 0;
+  for(i=0, k=nxDiv; i<NB; i++, k++){
+    if( k<pParent->nCell ){
+      apDiv[i] = findCell(pParent, k);
+      nDiv++;
+      assert( !pParent->leaf );
+      pgnoOld[i] = get4byte(apDiv[i]);
+    }else if( k==pParent->nCell ){
+      pgnoOld[i] = get4byte(&pParent->aData[pParent->hdrOffset+8]);
+    }else{
+      break;
+    }
+    rc = getAndInitPage(pBt, pgnoOld[i], &apOld[i], pParent);
+    if( rc ) goto balance_cleanup;
+    apOld[i]->idxParent = k;
+    apCopy[i] = 0;
+    assert( i==nOld );
+    nOld++;
+    nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
+  }
+
+  /* Make nMaxCells a multiple of 2 in order to preserve 8-byte
+  ** alignment */
+  nMaxCells = (nMaxCells + 1)&~1;
+
+  /*
+  ** Allocate space for memory structures
+  */
+  apCell = sqlite3_malloc( 
+       nMaxCells*sizeof(u8*)                           /* apCell */
+     + nMaxCells*sizeof(int)                           /* szCell */
+     + ROUND8(sizeof(MemPage))*NB                      /* aCopy */
+     + pBt->pageSize*(5+NB)                            /* aSpace */
+     + (ISAUTOVACUUM ? nMaxCells : 0)                  /* aFrom */
+  );
+  if( apCell==0 ){
+    rc = SQLITE_NOMEM;
+    goto balance_cleanup;
+  }
+  szCell = (int*)&apCell[nMaxCells];
+  aCopy[0] = (u8*)&szCell[nMaxCells];
+  assert( ((aCopy[0] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
+  for(i=1; i<NB; i++){
+    aCopy[i] = &aCopy[i-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
+    assert( ((aCopy[i] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
+  }
+  aSpace = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
+  assert( ((aSpace - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( pBt->autoVacuum ){
+    aFrom = &aSpace[5*pBt->pageSize];
+  }
+#endif
+  
+  /*
+  ** Make copies of the content of pPage and its siblings into aOld[].
+  ** The rest of this function will use data from the copies rather
+  ** that the original pages since the original pages will be in the
+  ** process of being overwritten.
+  */
+  for(i=0; i<nOld; i++){
+    MemPage *p = apCopy[i] = (MemPage*)aCopy[i];
+    memcpy(p, apOld[i], sizeof(MemPage));
+    p->aData = (void*)&p[1];
+    memcpy(p->aData, apOld[i]->aData, pBt->pageSize);
+  }
+
+  /*
+  ** Load pointers to all cells on sibling pages and the divider cells
+  ** into the local apCell[] array.  Make copies of the divider cells
+  ** into space obtained form aSpace[] and remove the the divider Cells
+  ** from pParent.
+  **
+  ** If the siblings are on leaf pages, then the child pointers of the
+  ** divider cells are stripped from the cells before they are copied
+  ** into aSpace[].  In this way, all cells in apCell[] are without
+  ** child pointers.  If siblings are not leaves, then all cell in
+  ** apCell[] include child pointers.  Either way, all cells in apCell[]
+  ** are alike.
+  **
+  ** leafCorrection:  4 if pPage is a leaf.  0 if pPage is not a leaf.
+  **       leafData:  1 if pPage holds key+data and pParent holds only keys.
+  */
+  nCell = 0;
+  leafCorrection = pPage->leaf*4;
+  leafData = pPage->leafData && pPage->leaf;
+  for(i=0; i<nOld; i++){
+    MemPage *pOld = apCopy[i];
+    int limit = pOld->nCell+pOld->nOverflow;
+    for(j=0; j<limit; j++){
+      assert( nCell<nMaxCells );
+      apCell[nCell] = findOverflowCell(pOld, j);
+      szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      if( pBt->autoVacuum ){
+        int a;
+        aFrom[nCell] = i;
+        for(a=0; a<pOld->nOverflow; a++){
+          if( pOld->aOvfl[a].pCell==apCell[nCell] ){
+            aFrom[nCell] = 0xFF;
+            break;
+          }
+        }
+      }
+#endif
+      nCell++;
+    }
+    if( i<nOld-1 ){
+      int sz = cellSizePtr(pParent, apDiv[i]);
+      if( leafData ){
+        /* With the LEAFDATA flag, pParent cells hold only INTKEYs that
+        ** are duplicates of keys on the child pages.  We need to remove
+        ** the divider cells from pParent, but the dividers cells are not
+        ** added to apCell[] because they are duplicates of child cells.
+        */
+        dropCell(pParent, nxDiv, sz);
+      }else{
+        u8 *pTemp;
+        assert( nCell<nMaxCells );
+        szCell[nCell] = sz;
+        pTemp = &aSpace[iSpace];
+        iSpace += sz;
+        assert( iSpace<=pBt->pageSize*5 );
+        memcpy(pTemp, apDiv[i], sz);
+        apCell[nCell] = pTemp+leafCorrection;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+        if( pBt->autoVacuum ){
+          aFrom[nCell] = 0xFF;
+        }
+#endif
+        dropCell(pParent, nxDiv, sz);
+        szCell[nCell] -= leafCorrection;
+        assert( get4byte(pTemp)==pgnoOld[i] );
+        if( !pOld->leaf ){
+          assert( leafCorrection==0 );
+          /* The right pointer of the child page pOld becomes the left
+          ** pointer of the divider cell */
+          memcpy(apCell[nCell], &pOld->aData[pOld->hdrOffset+8], 4);
+        }else{
+          assert( leafCorrection==4 );
+          if( szCell[nCell]<4 ){
+            /* Do not allow any cells smaller than 4 bytes. */
+            szCell[nCell] = 4;
+          }
+        }
+        nCell++;
+      }
+    }
+  }
+
+  /*
+  ** Figure out the number of pages needed to hold all nCell cells.
+  ** Store this number in "k".  Also compute szNew[] which is the total
+  ** size of all cells on the i-th page and cntNew[] which is the index
+  ** in apCell[] of the cell that divides page i from page i+1.  
+  ** cntNew[k] should equal nCell.
+  **
+  ** Values computed by this block:
+  **
+  **           k: The total number of sibling pages
+  **    szNew[i]: Spaced used on the i-th sibling page.
+  **   cntNew[i]: Index in apCell[] and szCell[] for the first cell to
+  **              the right of the i-th sibling page.
+  ** usableSpace: Number of bytes of space available on each sibling.
+  ** 
+  */
+  usableSpace = pBt->usableSize - 12 + leafCorrection;
+  for(subtotal=k=i=0; i<nCell; i++){
+    assert( i<nMaxCells );
+    subtotal += szCell[i] + 2;
+    if( subtotal > usableSpace ){
+      szNew[k] = subtotal - szCell[i];
+      cntNew[k] = i;
+      if( leafData ){ i--; }
+      subtotal = 0;
+      k++;
+    }
+  }
+  szNew[k] = subtotal;
+  cntNew[k] = nCell;
+  k++;
+
+  /*
+  ** The packing computed by the previous block is biased toward the siblings
+  ** on the left side.  The left siblings are always nearly full, while the
+  ** right-most sibling might be nearly empty.  This block of code attempts
+  ** to adjust the packing of siblings to get a better balance.
+  **
+  ** This adjustment is more than an optimization.  The packing above might
+  ** be so out of balance as to be illegal.  For example, the right-most
+  ** sibling might be completely empty.  This adjustment is not optional.
+  */
+  for(i=k-1; i>0; i--){
+    int szRight = szNew[i];  /* Size of sibling on the right */
+    int szLeft = szNew[i-1]; /* Size of sibling on the left */
+    int r;              /* Index of right-most cell in left sibling */
+    int d;              /* Index of first cell to the left of right sibling */
+
+    r = cntNew[i-1] - 1;
+    d = r + 1 - leafData;
+    assert( d<nMaxCells );
+    assert( r<nMaxCells );
+    while( szRight==0 || szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
+      szRight += szCell[d] + 2;
+      szLeft -= szCell[r] + 2;
+      cntNew[i-1]--;
+      r = cntNew[i-1] - 1;
+      d = r + 1 - leafData;
+    }
+    szNew[i] = szRight;
+    szNew[i-1] = szLeft;
+  }
+
+  /* Either we found one or more cells (cntnew[0])>0) or we are the
+  ** a virtual root page.  A virtual root page is when the real root
+  ** page is page 1 and we are the only child of that page.
+  */
+  assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
+
+  /*
+  ** Allocate k new pages.  Reuse old pages where possible.
+  */
+  assert( pPage->pgno>1 );
+  pageFlags = pPage->aData[0];
+  for(i=0; i<k; i++){
+    MemPage *pNew;
+    if( i<nOld ){
+      pNew = apNew[i] = apOld[i];
+      pgnoNew[i] = pgnoOld[i];
+      apOld[i] = 0;
+      rc = sqlite3PagerWrite(pNew->pDbPage);
+      nNew++;
+      if( rc ) goto balance_cleanup;
+    }else{
+      assert( i>0 );
+      rc = allocateBtreePage(pBt, &pNew, &pgnoNew[i], pgnoNew[i-1], 0);
+      if( rc ) goto balance_cleanup;
+      apNew[i] = pNew;
+      nNew++;
+    }
+    zeroPage(pNew, pageFlags);
+  }
+
+  /* Free any old pages that were not reused as new pages.
+  */
+  while( i<nOld ){
+    rc = freePage(apOld[i]);
+    if( rc ) goto balance_cleanup;
+    releasePage(apOld[i]);
+    apOld[i] = 0;
+    i++;
+  }
+
+  /*
+  ** Put the new pages in accending order.  This helps to
+  ** keep entries in the disk file in order so that a scan
+  ** of the table is a linear scan through the file.  That
+  ** in turn helps the operating system to deliver pages
+  ** from the disk more rapidly.
+  **
+  ** An O(n^2) insertion sort algorithm is used, but since
+  ** n is never more than NB (a small constant), that should
+  ** not be a problem.
+  **
+  ** When NB==3, this one optimization makes the database
+  ** about 25% faster for large insertions and deletions.
+  */
+  for(i=0; i<k-1; i++){
+    int minV = pgnoNew[i];
+    int minI = i;
+    for(j=i+1; j<k; j++){
+      if( pgnoNew[j]<(unsigned)minV ){
+        minI = j;
+        minV = pgnoNew[j];
+      }
+    }
+    if( minI>i ){
+      int t;
+      MemPage *pT;
+      t = pgnoNew[i];
+      pT = apNew[i];
+      pgnoNew[i] = pgnoNew[minI];
+      apNew[i] = apNew[minI];
+      pgnoNew[minI] = t;
+      apNew[minI] = pT;
+    }
+  }
+  TRACE(("BALANCE: old: %d %d %d  new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
+    pgnoOld[0], 
+    nOld>=2 ? pgnoOld[1] : 0,
+    nOld>=3 ? pgnoOld[2] : 0,
+    pgnoNew[0], szNew[0],
+    nNew>=2 ? pgnoNew[1] : 0, nNew>=2 ? szNew[1] : 0,
+    nNew>=3 ? pgnoNew[2] : 0, nNew>=3 ? szNew[2] : 0,
+    nNew>=4 ? pgnoNew[3] : 0, nNew>=4 ? szNew[3] : 0,
+    nNew>=5 ? pgnoNew[4] : 0, nNew>=5 ? szNew[4] : 0));
+
+  /*
+  ** Evenly distribute the data in apCell[] across the new pages.
+  ** Insert divider cells into pParent as necessary.
+  */
+  j = 0;
+  for(i=0; i<nNew; i++){
+    /* Assemble the new sibling page. */
+    MemPage *pNew = apNew[i];
+    assert( j<nMaxCells );
+    assert( pNew->pgno==pgnoNew[i] );
+    assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
+    assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
+    assert( pNew->nOverflow==0 );
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    /* If this is an auto-vacuum database, update the pointer map entries
+    ** that point to the siblings that were rearranged. These can be: left
+    ** children of cells, the right-child of the page, or overflow pages
+    ** pointed to by cells.
+    */
+    if( pBt->autoVacuum ){
+      for(k=j; k<cntNew[i]; k++){
+        assert( k<nMaxCells );
+        if( aFrom[k]==0xFF || apCopy[aFrom[k]]->pgno!=pNew->pgno ){
+          rc = ptrmapPutOvfl(pNew, k-j);
+          if( rc!=SQLITE_OK ){
+            goto balance_cleanup;
+          }
+        }
+      }
+    }
+#endif
+
+    j = cntNew[i];
+
+    /* If the sibling page assembled above was not the right-most sibling,
+    ** insert a divider cell into the parent page.
+    */
+    if( i<nNew-1 && j<nCell ){
+      u8 *pCell;
+      u8 *pTemp;
+      int sz;
+
+      assert( j<nMaxCells );
+      pCell = apCell[j];
+      sz = szCell[j] + leafCorrection;
+      if( !pNew->leaf ){
+        memcpy(&pNew->aData[8], pCell, 4);
+        pTemp = 0;
+      }else if( leafData ){
+        /* If the tree is a leaf-data tree, and the siblings are leaves, 
+        ** then there is no divider cell in apCell[]. Instead, the divider 
+        ** cell consists of the integer key for the right-most cell of 
+        ** the sibling-page assembled above only.
+        */
+        CellInfo info;
+        j--;
+        sqlite3BtreeParseCellPtr(pNew, apCell[j], &info);
+        pCell = &aSpace[iSpace];
+        fillInCell(pParent, pCell, 0, info.nKey, 0, 0, 0, &sz);
+        iSpace += sz;
+        assert( iSpace<=pBt->pageSize*5 );
+        pTemp = 0;
+      }else{
+        pCell -= 4;
+        pTemp = &aSpace[iSpace];
+        iSpace += sz;
+        assert( iSpace<=pBt->pageSize*5 );
+        /* Obscure case for non-leaf-data trees: If the cell at pCell was
+        ** previously stored on a leaf node, and its reported size was 4
+        ** bytes, then it may actually be smaller than this 
+        ** (see sqlite3BtreeParseCellPtr(), 4 bytes is the minimum size of
+        ** any cell). But it is important to pass the correct size to 
+        ** insertCell(), so reparse the cell now.
+        **
+        ** Note that this can never happen in an SQLite data file, as all
+        ** cells are at least 4 bytes. It only happens in b-trees used
+        ** to evaluate "IN (SELECT ...)" and similar clauses.
+        */
+        if( szCell[j]==4 ){
+          assert(leafCorrection==4);
+          sz = cellSizePtr(pParent, pCell);
+        }
+      }
+      rc = insertCell(pParent, nxDiv, pCell, sz, pTemp, 4);
+      if( rc!=SQLITE_OK ) goto balance_cleanup;
+      put4byte(findOverflowCell(pParent,nxDiv), pNew->pgno);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      /* If this is an auto-vacuum database, and not a leaf-data tree,
+      ** then update the pointer map with an entry for the overflow page
+      ** that the cell just inserted points to (if any).
+      */
+      if( pBt->autoVacuum && !leafData ){
+        rc = ptrmapPutOvfl(pParent, nxDiv);
+        if( rc!=SQLITE_OK ){
+          goto balance_cleanup;
+        }
+      }
+#endif
+      j++;
+      nxDiv++;
+    }
+  }
+  assert( j==nCell );
+  assert( nOld>0 );
+  assert( nNew>0 );
+  if( (pageFlags & PTF_LEAF)==0 ){
+    memcpy(&apNew[nNew-1]->aData[8], &apCopy[nOld-1]->aData[8], 4);
+  }
+  if( nxDiv==pParent->nCell+pParent->nOverflow ){
+    /* Right-most sibling is the right-most child of pParent */
+    put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew[nNew-1]);
+  }else{
+    /* Right-most sibling is the left child of the first entry in pParent
+    ** past the right-most divider entry */
+    put4byte(findOverflowCell(pParent, nxDiv), pgnoNew[nNew-1]);
+  }
+
+  /*
+  ** Reparent children of all cells.
+  */
+  for(i=0; i<nNew; i++){
+    rc = reparentChildPages(apNew[i]);
+    if( rc!=SQLITE_OK ) goto balance_cleanup;
+  }
+  rc = reparentChildPages(pParent);
+  if( rc!=SQLITE_OK ) goto balance_cleanup;
+
+  /*
+  ** Balance the parent page.  Note that the current page (pPage) might
+  ** have been added to the freelist so it might no longer be initialized.
+  ** But the parent page will always be initialized.
+  */
+  assert( pParent->isInit );
+  rc = balance(pParent, 0);
+  
+  /*
+  ** Cleanup before returning.
+  */
+balance_cleanup:
+  sqlite3_free(apCell);
+  for(i=0; i<nOld; i++){
+    releasePage(apOld[i]);
+  }
+  for(i=0; i<nNew; i++){
+    releasePage(apNew[i]);
+  }
+  releasePage(pParent);
+  TRACE(("BALANCE: finished with %d: old=%d new=%d cells=%d\n",
+          pPage->pgno, nOld, nNew, nCell));
+  return rc;
+}
+
+/*
+** This routine is called for the root page of a btree when the root
+** page contains no cells.  This is an opportunity to make the tree
+** shallower by one level.
+*/
+static int balance_shallower(MemPage *pPage){
+  MemPage *pChild;             /* The only child page of pPage */
+  Pgno pgnoChild;              /* Page number for pChild */
+  int rc = SQLITE_OK;          /* Return code from subprocedures */
+  BtShared *pBt;                  /* The main BTree structure */
+  int mxCellPerPage;           /* Maximum number of cells per page */
+  u8 **apCell;                 /* All cells from pages being balanced */
+  int *szCell;                 /* Local size of all cells */
+
+  assert( pPage->pParent==0 );
+  assert( pPage->nCell==0 );
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  pBt = pPage->pBt;
+  mxCellPerPage = MX_CELL(pBt);
+  apCell = sqlite3_malloc( mxCellPerPage*(sizeof(u8*)+sizeof(int)) );
+  if( apCell==0 ) return SQLITE_NOMEM;
+  szCell = (int*)&apCell[mxCellPerPage];
+  if( pPage->leaf ){
+    /* The table is completely empty */
+    TRACE(("BALANCE: empty table %d\n", pPage->pgno));
+  }else{
+    /* The root page is empty but has one child.  Transfer the
+    ** information from that one child into the root page if it 
+    ** will fit.  This reduces the depth of the tree by one.
+    **
+    ** If the root page is page 1, it has less space available than
+    ** its child (due to the 100 byte header that occurs at the beginning
+    ** of the database fle), so it might not be able to hold all of the 
+    ** information currently contained in the child.  If this is the 
+    ** case, then do not do the transfer.  Leave page 1 empty except
+    ** for the right-pointer to the child page.  The child page becomes
+    ** the virtual root of the tree.
+    */
+    pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]);
+    assert( pgnoChild>0 );
+    assert( pgnoChild<=sqlite3PagerPagecount(pPage->pBt->pPager) );
+    rc = sqlite3BtreeGetPage(pPage->pBt, pgnoChild, &pChild, 0);
+    if( rc ) goto end_shallow_balance;
+    if( pPage->pgno==1 ){
+      rc = sqlite3BtreeInitPage(pChild, pPage);
+      if( rc ) goto end_shallow_balance;
+      assert( pChild->nOverflow==0 );
+      if( pChild->nFree>=100 ){
+        /* The child information will fit on the root page, so do the
+        ** copy */
+        int i;
+        zeroPage(pPage, pChild->aData[0]);
+        for(i=0; i<pChild->nCell; i++){
+          apCell[i] = findCell(pChild,i);
+          szCell[i] = cellSizePtr(pChild, apCell[i]);
+        }
+        assemblePage(pPage, pChild->nCell, apCell, szCell);
+        /* Copy the right-pointer of the child to the parent. */
+        put4byte(&pPage->aData[pPage->hdrOffset+8], 
+            get4byte(&pChild->aData[pChild->hdrOffset+8]));
+        freePage(pChild);
+        TRACE(("BALANCE: child %d transfer to page 1\n", pChild->pgno));
+      }else{
+        /* The child has more information that will fit on the root.
+        ** The tree is already balanced.  Do nothing. */
+        TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno));
+      }
+    }else{
+      memcpy(pPage->aData, pChild->aData, pPage->pBt->usableSize);
+      pPage->isInit = 0;
+      pPage->pParent = 0;
+      rc = sqlite3BtreeInitPage(pPage, 0);
+      assert( rc==SQLITE_OK );
+      freePage(pChild);
+      TRACE(("BALANCE: transfer child %d into root %d\n",
+              pChild->pgno, pPage->pgno));
+    }
+    rc = reparentChildPages(pPage);
+    assert( pPage->nOverflow==0 );
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pBt->autoVacuum ){
+      int i;
+      for(i=0; i<pPage->nCell; i++){ 
+        rc = ptrmapPutOvfl(pPage, i);
+        if( rc!=SQLITE_OK ){
+          goto end_shallow_balance;
+        }
+      }
+    }
+#endif
+    releasePage(pChild);
+  }
+end_shallow_balance:
+  sqlite3_free(apCell);
+  return rc;
+}
+
+
+/*
+** The root page is overfull
+**
+** When this happens, Create a new child page and copy the
+** contents of the root into the child.  Then make the root
+** page an empty page with rightChild pointing to the new
+** child.   Finally, call balance_internal() on the new child
+** to cause it to split.
+*/
+static int balance_deeper(MemPage *pPage){
+  int rc;             /* Return value from subprocedures */
+  MemPage *pChild;    /* Pointer to a new child page */
+  Pgno pgnoChild;     /* Page number of the new child page */
+  BtShared *pBt;         /* The BTree */
+  int usableSize;     /* Total usable size of a page */
+  u8 *data;           /* Content of the parent page */
+  u8 *cdata;          /* Content of the child page */
+  int hdr;            /* Offset to page header in parent */
+  int brk;            /* Offset to content of first cell in parent */
+
+  assert( pPage->pParent==0 );
+  assert( pPage->nOverflow>0 );
+  pBt = pPage->pBt;
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  rc = allocateBtreePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0);
+  if( rc ) return rc;
+  assert( sqlite3PagerIswriteable(pChild->pDbPage) );
+  usableSize = pBt->usableSize;
+  data = pPage->aData;
+  hdr = pPage->hdrOffset;
+  brk = get2byte(&data[hdr+5]);
+  cdata = pChild->aData;
+  memcpy(cdata, &data[hdr], pPage->cellOffset+2*pPage->nCell-hdr);
+  memcpy(&cdata[brk], &data[brk], usableSize-brk);
+  assert( pChild->isInit==0 );
+  rc = sqlite3BtreeInitPage(pChild, pPage);
+  if( rc ) goto balancedeeper_out;
+  memcpy(pChild->aOvfl, pPage->aOvfl, pPage->nOverflow*sizeof(pPage->aOvfl[0]));
+  pChild->nOverflow = pPage->nOverflow;
+  if( pChild->nOverflow ){
+    pChild->nFree = 0;
+  }
+  assert( pChild->nCell==pPage->nCell );
+  zeroPage(pPage, pChild->aData[0] & ~PTF_LEAF);
+  put4byte(&pPage->aData[pPage->hdrOffset+8], pgnoChild);
+  TRACE(("BALANCE: copy root %d into %d\n", pPage->pgno, pChild->pgno));
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( pBt->autoVacuum ){
+    int i;
+    rc = ptrmapPut(pBt, pChild->pgno, PTRMAP_BTREE, pPage->pgno);
+    if( rc ) goto balancedeeper_out;
+    for(i=0; i<pChild->nCell; i++){
+      rc = ptrmapPutOvfl(pChild, i);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+    }
+  }
+#endif
+  rc = balance_nonroot(pChild);
+
+balancedeeper_out:
+  releasePage(pChild);
+  return rc;
+}
+
+/*
+** Decide if the page pPage needs to be balanced.  If balancing is
+** required, call the appropriate balancing routine.
+*/
+static int balance(MemPage *pPage, int insert){
+  int rc = SQLITE_OK;
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
+  if( pPage->pParent==0 ){
+    rc = sqlite3PagerWrite(pPage->pDbPage);
+    if( rc==SQLITE_OK && pPage->nOverflow>0 ){
+      rc = balance_deeper(pPage);
+    }
+    if( rc==SQLITE_OK && pPage->nCell==0 ){
+      rc = balance_shallower(pPage);
+    }
+  }else{
+    if( pPage->nOverflow>0 || 
+        (!insert && pPage->nFree>pPage->pBt->usableSize*2/3) ){
+      rc = balance_nonroot(pPage);
+    }
+  }
+  return rc;
+}
+
+/*
+** This routine checks all cursors that point to table pgnoRoot.
+** If any of those cursors were opened with wrFlag==0 in a different
+** database connection (a database connection that shares the pager
+** cache with the current connection) and that other connection 
+** is not in the ReadUncommmitted state, then this routine returns 
+** SQLITE_LOCKED.
+**
+** In addition to checking for read-locks (where a read-lock 
+** means a cursor opened with wrFlag==0) this routine also moves
+** all write cursors so that they are pointing to the 
+** first Cell on the root page.  This is necessary because an insert 
+** or delete might change the number of cells on a page or delete
+** a page entirely and we do not want to leave any cursors 
+** pointing to non-existant pages or cells.
+*/
+static int checkReadLocks(Btree *pBtree, Pgno pgnoRoot, BtCursor *pExclude){
+  BtCursor *p;
+  BtShared *pBt = pBtree->pBt;
+  sqlite3 *db = pBtree->db;
+  assert( sqlite3BtreeHoldsMutex(pBtree) );
+  for(p=pBt->pCursor; p; p=p->pNext){
+    if( p==pExclude ) continue;
+    if( p->eState!=CURSOR_VALID ) continue;
+    if( p->pgnoRoot!=pgnoRoot ) continue;
+    if( p->wrFlag==0 ){
+      sqlite3 *dbOther = p->pBtree->db;
+      if( dbOther==0 ||
+         (dbOther!=db && (dbOther->flags & SQLITE_ReadUncommitted)==0) ){
+        return SQLITE_LOCKED;
+      }
+    }else if( p->pPage->pgno!=p->pgnoRoot ){
+      moveToRoot(p);
+    }
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Insert a new record into the BTree.  The key is given by (pKey,nKey)
+** and the data is given by (pData,nData).  The cursor is used only to
+** define what table the record should be inserted into.  The cursor
+** is left pointing at a random location.
+**
+** For an INTKEY table, only the nKey value of the key is used.  pKey is
+** ignored.  For a ZERODATA table, the pData and nData are both ignored.
+*/
+int sqlite3BtreeInsert(
+  BtCursor *pCur,                /* Insert data into the table of this cursor */
+  const void *pKey, i64 nKey,    /* The key of the new record */
+  const void *pData, int nData,  /* The data of the new record */
+  int nZero,                     /* Number of extra 0 bytes to append to data */
+  int appendBias                 /* True if this is likely an append */
+){
+  int rc;
+  int loc;
+  int szNew;
+  MemPage *pPage;
+  Btree *p = pCur->pBtree;
+  BtShared *pBt = p->pBt;
+  unsigned char *oldCell;
+  unsigned char *newCell = 0;
+
+  assert( cursorHoldsMutex(pCur) );
+  if( pBt->inTransaction!=TRANS_WRITE ){
+    /* Must start a transaction before doing an insert */
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+    return rc;
+  }
+  assert( !pBt->readOnly );
+  if( !pCur->wrFlag ){
+    return SQLITE_PERM;   /* Cursor not open for writing */
+  }
+  if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){
+    return SQLITE_LOCKED; /* The table pCur points to has a read lock */
+  }
+  if( pCur->eState==CURSOR_FAULT ){
+    return pCur->skip;
+  }
+
+  /* Save the positions of any other cursors open on this table */
+  clearCursorPosition(pCur);
+  if( 
+    SQLITE_OK!=(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur)) ||
+    SQLITE_OK!=(rc = sqlite3BtreeMoveto(pCur, pKey, nKey, appendBias, &loc))
+  ){
+    return rc;
+  }
+
+  pPage = pCur->pPage;
+  assert( pPage->intKey || nKey>=0 );
+  assert( pPage->leaf || !pPage->leafData );
+  TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
+          pCur->pgnoRoot, nKey, nData, pPage->pgno,
+          loc==0 ? "overwrite" : "new entry"));
+  assert( pPage->isInit );
+  newCell = sqlite3_malloc( MX_CELL_SIZE(pBt) );
+  if( newCell==0 ) return SQLITE_NOMEM;
+  rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
+  if( rc ) goto end_insert;
+  assert( szNew==cellSizePtr(pPage, newCell) );
+  assert( szNew<=MX_CELL_SIZE(pBt) );
+  if( loc==0 && CURSOR_VALID==pCur->eState ){
+    int szOld;
+    assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
+    rc = sqlite3PagerWrite(pPage->pDbPage);
+    if( rc ){
+      goto end_insert;
+    }
+    oldCell = findCell(pPage, pCur->idx);
+    if( !pPage->leaf ){
+      memcpy(newCell, oldCell, 4);
+    }
+    szOld = cellSizePtr(pPage, oldCell);
+    rc = clearCell(pPage, oldCell);
+    if( rc ) goto end_insert;
+    dropCell(pPage, pCur->idx, szOld);
+  }else if( loc<0 && pPage->nCell>0 ){
+    assert( pPage->leaf );
+    pCur->idx++;
+    pCur->info.nSize = 0;
+  }else{
+    assert( pPage->leaf );
+  }
+  rc = insertCell(pPage, pCur->idx, newCell, szNew, 0, 0);
+  if( rc!=SQLITE_OK ) goto end_insert;
+  rc = balance(pPage, 1);
+  /* sqlite3BtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */
+  /* fflush(stdout); */
+  if( rc==SQLITE_OK ){
+    moveToRoot(pCur);
+  }
+end_insert:
+  sqlite3_free(newCell);
+  return rc;
+}
+
+/*
+** Delete the entry that the cursor is pointing to.  The cursor
+** is left pointing at a random location.
+*/
+int sqlite3BtreeDelete(BtCursor *pCur){
+  MemPage *pPage = pCur->pPage;
+  unsigned char *pCell;
+  int rc;
+  Pgno pgnoChild = 0;
+  Btree *p = pCur->pBtree;
+  BtShared *pBt = p->pBt;
+
+  assert( cursorHoldsMutex(pCur) );
+  assert( pPage->isInit );
+  if( pBt->inTransaction!=TRANS_WRITE ){
+    /* Must start a transaction before doing a delete */
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+    return rc;
+  }
+  assert( !pBt->readOnly );
+  if( pCur->eState==CURSOR_FAULT ){
+    return pCur->skip;
+  }
+  if( pCur->idx >= pPage->nCell ){
+    return SQLITE_ERROR;  /* The cursor is not pointing to anything */
+  }
+  if( !pCur->wrFlag ){
+    return SQLITE_PERM;   /* Did not open this cursor for writing */
+  }
+  if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){
+    return SQLITE_LOCKED; /* The table pCur points to has a read lock */
+  }
+
+  /* Restore the current cursor position (a no-op if the cursor is not in 
+  ** CURSOR_REQUIRESEEK state) and save the positions of any other cursors 
+  ** open on the same table. Then call sqlite3PagerWrite() on the page
+  ** that the entry will be deleted from.
+  */
+  if( 
+    (rc = restoreOrClearCursorPosition(pCur))!=0 ||
+    (rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 ||
+    (rc = sqlite3PagerWrite(pPage->pDbPage))!=0
+  ){
+    return rc;
+  }
+
+  /* Locate the cell within its page and leave pCell pointing to the
+  ** data. The clearCell() call frees any overflow pages associated with the
+  ** cell. The cell itself is still intact.
+  */
+  pCell = findCell(pPage, pCur->idx);
+  if( !pPage->leaf ){
+    pgnoChild = get4byte(pCell);
+  }
+  rc = clearCell(pPage, pCell);
+  if( rc ){
+    return rc;
+  }
+
+  if( !pPage->leaf ){
+    /*
+    ** The entry we are about to delete is not a leaf so if we do not
+    ** do something we will leave a hole on an internal page.
+    ** We have to fill the hole by moving in a cell from a leaf.  The
+    ** next Cell after the one to be deleted is guaranteed to exist and
+    ** to be a leaf so we can use it.
+    */
+    BtCursor leafCur;
+    unsigned char *pNext;
+    int notUsed;
+    unsigned char *tempCell = 0;
+    assert( !pPage->leafData );
+    sqlite3BtreeGetTempCursor(pCur, &leafCur);
+    rc = sqlite3BtreeNext(&leafCur, &notUsed);
+    if( rc==SQLITE_OK ){
+      rc = sqlite3PagerWrite(leafCur.pPage->pDbPage);
+    }
+    if( rc==SQLITE_OK ){
+      int szNext;
+      TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n",
+         pCur->pgnoRoot, pPage->pgno, leafCur.pPage->pgno));
+      dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell));
+      pNext = findCell(leafCur.pPage, leafCur.idx);
+      szNext = cellSizePtr(leafCur.pPage, pNext);
+      assert( MX_CELL_SIZE(pBt)>=szNext+4 );
+      tempCell = sqlite3_malloc( MX_CELL_SIZE(pBt) );
+      if( tempCell==0 ){
+        rc = SQLITE_NOMEM;
+      }
+      if( rc==SQLITE_OK ){
+        rc = insertCell(pPage, pCur->idx, pNext-4, szNext+4, tempCell, 0);
+      }
+      if( rc==SQLITE_OK ){
+        put4byte(findOverflowCell(pPage, pCur->idx), pgnoChild);
+        rc = balance(pPage, 0);
+      }
+      if( rc==SQLITE_OK ){
+        dropCell(leafCur.pPage, leafCur.idx, szNext);
+        rc = balance(leafCur.pPage, 0);
+      }
+    }
+    sqlite3_free(tempCell);
+    sqlite3BtreeReleaseTempCursor(&leafCur);
+  }else{
+    TRACE(("DELETE: table=%d delete from leaf %d\n",
+       pCur->pgnoRoot, pPage->pgno));
+    dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell));
+    rc = balance(pPage, 0);
+  }
+  if( rc==SQLITE_OK ){
+    moveToRoot(pCur);
+  }
+  return rc;
+}
+
+/*
+** Create a new BTree table.  Write into *piTable the page
+** number for the root page of the new table.
+**
+** The type of type is determined by the flags parameter.  Only the
+** following values of flags are currently in use.  Other values for
+** flags might not work:
+**
+**     BTREE_INTKEY|BTREE_LEAFDATA     Used for SQL tables with rowid keys
+**     BTREE_ZERODATA                  Used for SQL indices
+*/
+static int btreeCreateTable(Btree *p, int *piTable, int flags){
+  BtShared *pBt = p->pBt;
+  MemPage *pRoot;
+  Pgno pgnoRoot;
+  int rc;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+  if( pBt->inTransaction!=TRANS_WRITE ){
+    /* Must start a transaction first */
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+    return rc;
+  }
+  assert( !pBt->readOnly );
+
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
+  if( rc ){
+    return rc;
+  }
+#else
+  if( pBt->autoVacuum ){
+    Pgno pgnoMove;      /* Move a page here to make room for the root-page */
+    MemPage *pPageMove; /* The page to move to. */
+
+    /* Creating a new table may probably require moving an existing database
+    ** to make room for the new tables root page. In case this page turns
+    ** out to be an overflow page, delete all overflow page-map caches
+    ** held by open cursors.
+    */
+    invalidateAllOverflowCache(pBt);
+
+    /* Read the value of meta[3] from the database to determine where the
+    ** root page of the new table should go. meta[3] is the largest root-page
+    ** created so far, so the new root-page is (meta[3]+1).
+    */
+    rc = sqlite3BtreeGetMeta(p, 4, &pgnoRoot);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    pgnoRoot++;
+
+    /* The new root-page may not be allocated on a pointer-map page, or the
+    ** PENDING_BYTE page.
+    */
+    while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
+        pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
+      pgnoRoot++;
+    }
+    assert( pgnoRoot>=3 );
+
+    /* Allocate a page. The page that currently resides at pgnoRoot will
+    ** be moved to the allocated page (unless the allocated page happens
+    ** to reside at pgnoRoot).
+    */
+    rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+
+    if( pgnoMove!=pgnoRoot ){
+      /* pgnoRoot is the page that will be used for the root-page of
+      ** the new table (assuming an error did not occur). But we were
+      ** allocated pgnoMove. If required (i.e. if it was not allocated
+      ** by extending the file), the current page at position pgnoMove
+      ** is already journaled.
+      */
+      u8 eType;
+      Pgno iPtrPage;
+
+      releasePage(pPageMove);
+
+      /* Move the page currently at pgnoRoot to pgnoMove. */
+      rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
+      if( rc!=SQLITE_OK || eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
+        releasePage(pRoot);
+        return rc;
+      }
+      assert( eType!=PTRMAP_ROOTPAGE );
+      assert( eType!=PTRMAP_FREEPAGE );
+      rc = sqlite3PagerWrite(pRoot->pDbPage);
+      if( rc!=SQLITE_OK ){
+        releasePage(pRoot);
+        return rc;
+      }
+      rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove);
+      releasePage(pRoot);
+
+      /* Obtain the page at pgnoRoot */
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      rc = sqlite3PagerWrite(pRoot->pDbPage);
+      if( rc!=SQLITE_OK ){
+        releasePage(pRoot);
+        return rc;
+      }
+    }else{
+      pRoot = pPageMove;
+    } 
+
+    /* Update the pointer-map and meta-data with the new root-page number. */
+    rc = ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0);
+    if( rc ){
+      releasePage(pRoot);
+      return rc;
+    }
+    rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
+    if( rc ){
+      releasePage(pRoot);
+      return rc;
+    }
+
+  }else{
+    rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
+    if( rc ) return rc;
+  }
+#endif
+  assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
+  zeroPage(pRoot, flags | PTF_LEAF);
+  sqlite3PagerUnref(pRoot->pDbPage);
+  *piTable = (int)pgnoRoot;
+  return SQLITE_OK;
+}
+int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
+  int rc;
+  sqlite3BtreeEnter(p);
+  p->pBt->db = p->db;
+  rc = btreeCreateTable(p, piTable, flags);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Erase the given database page and all its children.  Return
+** the page to the freelist.
+*/
+static int clearDatabasePage(
+  BtShared *pBt,           /* The BTree that contains the table */
+  Pgno pgno,            /* Page number to clear */
+  MemPage *pParent,     /* Parent page.  NULL for the root */
+  int freePageFlag      /* Deallocate page if true */
+){
+  MemPage *pPage = 0;
+  int rc;
+  unsigned char *pCell;
+  int i;
+
+  assert( sqlite3_mutex_held(pBt->mutex) );
+  if( pgno>sqlite3PagerPagecount(pBt->pPager) ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+
+  rc = getAndInitPage(pBt, pgno, &pPage, pParent);
+  if( rc ) goto cleardatabasepage_out;
+  for(i=0; i<pPage->nCell; i++){
+    pCell = findCell(pPage, i);
+    if( !pPage->leaf ){
+      rc = clearDatabasePage(pBt, get4byte(pCell), pPage->pParent, 1);
+      if( rc ) goto cleardatabasepage_out;
+    }
+    rc = clearCell(pPage, pCell);
+    if( rc ) goto cleardatabasepage_out;
+  }
+  if( !pPage->leaf ){
+    rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), pPage->pParent, 1);
+    if( rc ) goto cleardatabasepage_out;
+  }
+  if( freePageFlag ){
+    rc = freePage(pPage);
+  }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
+    zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
+  }
+
+cleardatabasepage_out:
+  releasePage(pPage);
+  return rc;
+}
+
+/*
+** Delete all information from a single table in the database.  iTable is
+** the page number of the root of the table.  After this routine returns,
+** the root page is empty, but still exists.
+**
+** This routine will fail with SQLITE_LOCKED if there are any open
+** read cursors on the table.  Open write cursors are moved to the
+** root of the table.
+*/
+int sqlite3BtreeClearTable(Btree *p, int iTable){
+  int rc;
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  if( p->inTrans!=TRANS_WRITE ){
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+  }else if( (rc = checkReadLocks(p, iTable, 0))!=SQLITE_OK ){
+    /* nothing to do */
+  }else if( SQLITE_OK!=(rc = saveAllCursors(pBt, iTable, 0)) ){
+    /* nothing to do */
+  }else{
+    rc = clearDatabasePage(pBt, (Pgno)iTable, 0, 0);
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Erase all information in a table and add the root of the table to
+** the freelist.  Except, the root of the principle table (the one on
+** page 1) is never added to the freelist.
+**
+** This routine will fail with SQLITE_LOCKED if there are any open
+** cursors on the table.
+**
+** If AUTOVACUUM is enabled and the page at iTable is not the last
+** root page in the database file, then the last root page 
+** in the database file is moved into the slot formerly occupied by
+** iTable and that last slot formerly occupied by the last root page
+** is added to the freelist instead of iTable.  In this say, all
+** root pages are kept at the beginning of the database file, which
+** is necessary for AUTOVACUUM to work right.  *piMoved is set to the 
+** page number that used to be the last root page in the file before
+** the move.  If no page gets moved, *piMoved is set to 0.
+** The last root page is recorded in meta[3] and the value of
+** meta[3] is updated by this procedure.
+*/
+static int btreeDropTable(Btree *p, int iTable, int *piMoved){
+  int rc;
+  MemPage *pPage = 0;
+  BtShared *pBt = p->pBt;
+
+  assert( sqlite3BtreeHoldsMutex(p) );
+  if( p->inTrans!=TRANS_WRITE ){
+    return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+  }
+
+  /* It is illegal to drop a table if any cursors are open on the
+  ** database. This is because in auto-vacuum mode the backend may
+  ** need to move another root-page to fill a gap left by the deleted
+  ** root page. If an open cursor was using this page a problem would 
+  ** occur.
+  */
+  if( pBt->pCursor ){
+    return SQLITE_LOCKED;
+  }
+
+  rc = sqlite3BtreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
+  if( rc ) return rc;
+  rc = sqlite3BtreeClearTable(p, iTable);
+  if( rc ){
+    releasePage(pPage);
+    return rc;
+  }
+
+  *piMoved = 0;
+
+  if( iTable>1 ){
+#ifdef SQLITE_OMIT_AUTOVACUUM
+    rc = freePage(pPage);
+    releasePage(pPage);
+#else
+    if( pBt->autoVacuum ){
+      Pgno maxRootPgno;
+      rc = sqlite3BtreeGetMeta(p, 4, &maxRootPgno);
+      if( rc!=SQLITE_OK ){
+        releasePage(pPage);
+        return rc;
+      }
+
+      if( iTable==maxRootPgno ){
+        /* If the table being dropped is the table with the largest root-page
+        ** number in the database, put the root page on the free list. 
+        */
+        rc = freePage(pPage);
+        releasePage(pPage);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+      }else{
+        /* The table being dropped does not have the largest root-page
+        ** number in the database. So move the page that does into the 
+        ** gap left by the deleted root-page.
+        */
+        MemPage *pMove;
+        releasePage(pPage);
+        rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable);
+        releasePage(pMove);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        rc = freePage(pMove);
+        releasePage(pMove);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        *piMoved = maxRootPgno;
+      }
+
+      /* Set the new 'max-root-page' value in the database header. This
+      ** is the old value less one, less one more if that happens to
+      ** be a root-page number, less one again if that is the
+      ** PENDING_BYTE_PAGE.
+      */
+      maxRootPgno--;
+      if( maxRootPgno==PENDING_BYTE_PAGE(pBt) ){
+        maxRootPgno--;
+      }
+      if( maxRootPgno==PTRMAP_PAGENO(pBt, maxRootPgno) ){
+        maxRootPgno--;
+      }
+      assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
+
+      rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
+    }else{
+      rc = freePage(pPage);
+      releasePage(pPage);
+    }
+#endif
+  }else{
+    /* If sqlite3BtreeDropTable was called on page 1. */
+    zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
+    releasePage(pPage);
+  }
+  return rc;  
+}
+int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
+  int rc;
+  sqlite3BtreeEnter(p);
+  p->pBt->db = p->db;
+  rc = btreeDropTable(p, iTable, piMoved);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+
+/*
+** Read the meta-information out of a database file.  Meta[0]
+** is the number of free pages currently in the database.  Meta[1]
+** through meta[15] are available for use by higher layers.  Meta[0]
+** is read-only, the others are read/write.
+** 
+** The schema layer numbers meta values differently.  At the schema
+** layer (and the SetCookie and ReadCookie opcodes) the number of
+** free pages is not visible.  So Cookie[0] is the same as Meta[1].
+*/
+int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
+  DbPage *pDbPage;
+  int rc;
+  unsigned char *pP1;
+  BtShared *pBt = p->pBt;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+
+  /* Reading a meta-data value requires a read-lock on page 1 (and hence
+  ** the sqlite_master table. We grab this lock regardless of whether or
+  ** not the SQLITE_ReadUncommitted flag is set (the table rooted at page
+  ** 1 is treated as a special case by queryTableLock() and lockTable()).
+  */
+  rc = queryTableLock(p, 1, READ_LOCK);
+  if( rc!=SQLITE_OK ){
+    sqlite3BtreeLeave(p);
+    return rc;
+  }
+
+  assert( idx>=0 && idx<=15 );
+  rc = sqlite3PagerGet(pBt->pPager, 1, &pDbPage);
+  if( rc ){
+    sqlite3BtreeLeave(p);
+    return rc;
+  }
+  pP1 = (unsigned char *)sqlite3PagerGetData(pDbPage);
+  *pMeta = get4byte(&pP1[36 + idx*4]);
+  sqlite3PagerUnref(pDbPage);
+
+  /* If autovacuumed is disabled in this build but we are trying to 
+  ** access an autovacuumed database, then make the database readonly. 
+  */
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  if( idx==4 && *pMeta>0 ) pBt->readOnly = 1;
+#endif
+
+  /* Grab the read-lock on page 1. */
+  rc = lockTable(p, 1, READ_LOCK);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Write meta-information back into the database.  Meta[0] is
+** read-only and may not be written.
+*/
+int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
+  BtShared *pBt = p->pBt;
+  unsigned char *pP1;
+  int rc;
+  assert( idx>=1 && idx<=15 );
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  if( p->inTrans!=TRANS_WRITE ){
+    rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
+  }else{
+    assert( pBt->pPage1!=0 );
+    pP1 = pBt->pPage1->aData;
+    rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
+    if( rc==SQLITE_OK ){
+      put4byte(&pP1[36 + idx*4], iMeta);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      if( idx==7 ){
+        assert( pBt->autoVacuum || iMeta==0 );
+        assert( iMeta==0 || iMeta==1 );
+        pBt->incrVacuum = iMeta;
+      }
+#endif
+    }
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+/*
+** Return the flag byte at the beginning of the page that the cursor
+** is currently pointing to.
+*/
+int sqlite3BtreeFlags(BtCursor *pCur){
+  /* TODO: What about CURSOR_REQUIRESEEK state? Probably need to call
+  ** restoreOrClearCursorPosition() here.
+  */
+  MemPage *pPage;
+  restoreOrClearCursorPosition(pCur);
+  pPage = pCur->pPage;
+  assert( cursorHoldsMutex(pCur) );
+  assert( pPage->pBt==pCur->pBt );
+  return pPage ? pPage->aData[pPage->hdrOffset] : 0;
+}
+
+
+/*
+** Return the pager associated with a BTree.  This routine is used for
+** testing and debugging only.
+*/
+Pager *sqlite3BtreePager(Btree *p){
+  return p->pBt->pPager;
+}
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+/*
+** Append a message to the error message string.
+*/
+static void checkAppendMsg(
+  IntegrityCk *pCheck,
+  char *zMsg1,
+  const char *zFormat,
+  ...
+){
+  va_list ap;
+  char *zMsg2;
+  if( !pCheck->mxErr ) return;
+  pCheck->mxErr--;
+  pCheck->nErr++;
+  va_start(ap, zFormat);
+  zMsg2 = sqlite3VMPrintf(0, zFormat, ap);
+  va_end(ap);
+  if( zMsg1==0 ) zMsg1 = "";
+  if( pCheck->zErrMsg ){
+    char *zOld = pCheck->zErrMsg;
+    pCheck->zErrMsg = 0;
+    sqlite3SetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0);
+    sqlite3_free(zOld);
+  }else{
+    sqlite3SetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0);
+  }
+  sqlite3_free(zMsg2);
+}
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+/*
+** Add 1 to the reference count for page iPage.  If this is the second
+** reference to the page, add an error message to pCheck->zErrMsg.
+** Return 1 if there are 2 ore more references to the page and 0 if
+** if this is the first reference to the page.
+**
+** Also check that the page number is in bounds.
+*/
+static int checkRef(IntegrityCk *pCheck, int iPage, char *zContext){
+  if( iPage==0 ) return 1;
+  if( iPage>pCheck->nPage || iPage<0 ){
+    checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
+    return 1;
+  }
+  if( pCheck->anRef[iPage]==1 ){
+    checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
+    return 1;
+  }
+  return  (pCheck->anRef[iPage]++)>1;
+}
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+/*
+** Check that the entry in the pointer-map for page iChild maps to 
+** page iParent, pointer type ptrType. If not, append an error message
+** to pCheck.
+*/
+static void checkPtrmap(
+  IntegrityCk *pCheck,   /* Integrity check context */
+  Pgno iChild,           /* Child page number */
+  u8 eType,              /* Expected pointer map type */
+  Pgno iParent,          /* Expected pointer map parent page number */
+  char *zContext         /* Context description (used for error msg) */
+){
+  int rc;
+  u8 ePtrmapType;
+  Pgno iPtrmapParent;
+
+  rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
+  if( rc!=SQLITE_OK ){
+    checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
+    return;
+  }
+
+  if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
+    checkAppendMsg(pCheck, zContext, 
+      "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", 
+      iChild, eType, iParent, ePtrmapType, iPtrmapParent);
+  }
+}
+#endif
+
+/*
+** Check the integrity of the freelist or of an overflow page list.
+** Verify that the number of pages on the list is N.
+*/
+static void checkList(
+  IntegrityCk *pCheck,  /* Integrity checking context */
+  int isFreeList,       /* True for a freelist.  False for overflow page list */
+  int iPage,            /* Page number for first page in the list */
+  int N,                /* Expected number of pages in the list */
+  char *zContext        /* Context for error messages */
+){
+  int i;
+  int expected = N;
+  int iFirst = iPage;
+  while( N-- > 0 && pCheck->mxErr ){
+    DbPage *pOvflPage;
+    unsigned char *pOvflData;
+    if( iPage<1 ){
+      checkAppendMsg(pCheck, zContext,
+         "%d of %d pages missing from overflow list starting at %d",
+          N+1, expected, iFirst);
+      break;
+    }
+    if( checkRef(pCheck, iPage, zContext) ) break;
+    if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
+      checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
+      break;
+    }
+    pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
+    if( isFreeList ){
+      int n = get4byte(&pOvflData[4]);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      if( pCheck->pBt->autoVacuum ){
+        checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
+      }
+#endif
+      if( n>pCheck->pBt->usableSize/4-8 ){
+        checkAppendMsg(pCheck, zContext,
+           "freelist leaf count too big on page %d", iPage);
+        N--;
+      }else{
+        for(i=0; i<n; i++){
+          Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+          if( pCheck->pBt->autoVacuum ){
+            checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
+          }
+#endif
+          checkRef(pCheck, iFreePage, zContext);
+        }
+        N -= n;
+      }
+    }
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    else{
+      /* If this database supports auto-vacuum and iPage is not the last
+      ** page in this overflow list, check that the pointer-map entry for
+      ** the following page matches iPage.
+      */
+      if( pCheck->pBt->autoVacuum && N>0 ){
+        i = get4byte(pOvflData);
+        checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
+      }
+    }
+#endif
+    iPage = get4byte(pOvflData);
+    sqlite3PagerUnref(pOvflPage);
+  }
+}
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+/*
+** Do various sanity checks on a single page of a tree.  Return
+** the tree depth.  Root pages return 0.  Parents of root pages
+** return 1, and so forth.
+** 
+** These checks are done:
+**
+**      1.  Make sure that cells and freeblocks do not overlap
+**          but combine to completely cover the page.
+**  NO  2.  Make sure cell keys are in order.
+**  NO  3.  Make sure no key is less than or equal to zLowerBound.
+**  NO  4.  Make sure no key is greater than or equal to zUpperBound.
+**      5.  Check the integrity of overflow pages.
+**      6.  Recursively call checkTreePage on all children.
+**      7.  Verify that the depth of all children is the same.
+**      8.  Make sure this page is at least 33% full or else it is
+**          the root of the tree.
+*/
+static int checkTreePage(
+  IntegrityCk *pCheck,  /* Context for the sanity check */
+  int iPage,            /* Page number of the page to check */
+  MemPage *pParent,     /* Parent page */
+  char *zParentContext  /* Parent context */
+){
+  MemPage *pPage;
+  int i, rc, depth, d2, pgno, cnt;
+  int hdr, cellStart;
+  int nCell;
+  u8 *data;
+  BtShared *pBt;
+  int usableSize;
+  char zContext[100];
+  char *hit;
+
+  sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
+
+  /* Check that the page exists
+  */
+  pBt = pCheck->pBt;
+  usableSize = pBt->usableSize;
+  if( iPage==0 ) return 0;
+  if( checkRef(pCheck, iPage, zParentContext) ) return 0;
+  if( (rc = sqlite3BtreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
+    checkAppendMsg(pCheck, zContext,
+       "unable to get the page. error code=%d", rc);
+    return 0;
+  }
+  if( (rc = sqlite3BtreeInitPage(pPage, pParent))!=0 ){
+    checkAppendMsg(pCheck, zContext, 
+                   "sqlite3BtreeInitPage() returns error code %d", rc);
+    releasePage(pPage);
+    return 0;
+  }
+
+  /* Check out all the cells.
+  */
+  depth = 0;
+  for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
+    u8 *pCell;
+    int sz;
+    CellInfo info;
+
+    /* Check payload overflow pages
+    */
+    sqlite3_snprintf(sizeof(zContext), zContext,
+             "On tree page %d cell %d: ", iPage, i);
+    pCell = findCell(pPage,i);
+    sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+    sz = info.nData;
+    if( !pPage->intKey ) sz += info.nKey;
+    assert( sz==info.nPayload );
+    if( sz>info.nLocal ){
+      int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
+      Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      if( pBt->autoVacuum ){
+        checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
+      }
+#endif
+      checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
+    }
+
+    /* Check sanity of left child page.
+    */
+    if( !pPage->leaf ){
+      pgno = get4byte(pCell);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      if( pBt->autoVacuum ){
+        checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
+      }
+#endif
+      d2 = checkTreePage(pCheck,pgno,pPage,zContext);
+      if( i>0 && d2!=depth ){
+        checkAppendMsg(pCheck, zContext, "Child page depth differs");
+      }
+      depth = d2;
+    }
+  }
+  if( !pPage->leaf ){
+    pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
+    sqlite3_snprintf(sizeof(zContext), zContext, 
+                     "On page %d at right child: ", iPage);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pBt->autoVacuum ){
+      checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, 0);
+    }
+#endif
+    checkTreePage(pCheck, pgno, pPage, zContext);
+  }
+ 
+  /* Check for complete coverage of the page
+  */
+  data = pPage->aData;
+  hdr = pPage->hdrOffset;
+  hit = sqlite3MallocZero( usableSize );
+  if( hit ){
+    memset(hit, 1, get2byte(&data[hdr+5]));
+    nCell = get2byte(&data[hdr+3]);
+    cellStart = hdr + 12 - 4*pPage->leaf;
+    for(i=0; i<nCell; i++){
+      int pc = get2byte(&data[cellStart+i*2]);
+      int size = cellSizePtr(pPage, &data[pc]);
+      int j;
+      if( (pc+size-1)>=usableSize || pc<0 ){
+        checkAppendMsg(pCheck, 0, 
+            "Corruption detected in cell %d on page %d",i,iPage,0);
+      }else{
+        for(j=pc+size-1; j>=pc; j--) hit[j]++;
+      }
+    }
+    for(cnt=0, i=get2byte(&data[hdr+1]); i>0 && i<usableSize && cnt<10000; 
+           cnt++){
+      int size = get2byte(&data[i+2]);
+      int j;
+      if( (i+size-1)>=usableSize || i<0 ){
+        checkAppendMsg(pCheck, 0,  
+            "Corruption detected in cell %d on page %d",i,iPage,0);
+      }else{
+        for(j=i+size-1; j>=i; j--) hit[j]++;
+      }
+      i = get2byte(&data[i]);
+    }
+    for(i=cnt=0; i<usableSize; i++){
+      if( hit[i]==0 ){
+        cnt++;
+      }else if( hit[i]>1 ){
+        checkAppendMsg(pCheck, 0,
+          "Multiple uses for byte %d of page %d", i, iPage);
+        break;
+      }
+    }
+    if( cnt!=data[hdr+7] ){
+      checkAppendMsg(pCheck, 0, 
+          "Fragmented space is %d byte reported as %d on page %d",
+          cnt, data[hdr+7], iPage);
+    }
+  }
+  sqlite3_free(hit);
+
+  releasePage(pPage);
+  return depth+1;
+}
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+/*
+** This routine does a complete check of the given BTree file.  aRoot[] is
+** an array of pages numbers were each page number is the root page of
+** a table.  nRoot is the number of entries in aRoot.
+**
+** If everything checks out, this routine returns NULL.  If something is
+** amiss, an error message is written into memory obtained from malloc()
+** and a pointer to that error message is returned.  The calling function
+** is responsible for freeing the error message when it is done.
+*/
+char *sqlite3BtreeIntegrityCheck(
+  Btree *p,     /* The btree to be checked */
+  int *aRoot,   /* An array of root pages numbers for individual trees */
+  int nRoot,    /* Number of entries in aRoot[] */
+  int mxErr,    /* Stop reporting errors after this many */
+  int *pnErr    /* Write number of errors seen to this variable */
+){
+  int i;
+  int nRef;
+  IntegrityCk sCheck;
+  BtShared *pBt = p->pBt;
+
+  sqlite3BtreeEnter(p);
+  pBt->db = p->db;
+  nRef = sqlite3PagerRefcount(pBt->pPager);
+  if( lockBtreeWithRetry(p)!=SQLITE_OK ){
+    sqlite3BtreeLeave(p);
+    return sqlite3StrDup("Unable to acquire a read lock on the database");
+  }
+  sCheck.pBt = pBt;
+  sCheck.pPager = pBt->pPager;
+  sCheck.nPage = sqlite3PagerPagecount(sCheck.pPager);
+  sCheck.mxErr = mxErr;
+  sCheck.nErr = 0;
+  *pnErr = 0;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( pBt->nTrunc!=0 ){
+    sCheck.nPage = pBt->nTrunc;
+  }
+#endif
+  if( sCheck.nPage==0 ){
+    unlockBtreeIfUnused(pBt);
+    sqlite3BtreeLeave(p);
+    return 0;
+  }
+  sCheck.anRef = sqlite3_malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
+  if( !sCheck.anRef ){
+    unlockBtreeIfUnused(pBt);
+    *pnErr = 1;
+    sqlite3BtreeLeave(p);
+    return sqlite3MPrintf(p->db, "Unable to malloc %d bytes", 
+        (sCheck.nPage+1)*sizeof(sCheck.anRef[0]));
+  }
+  for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
+  i = PENDING_BYTE_PAGE(pBt);
+  if( i<=sCheck.nPage ){
+    sCheck.anRef[i] = 1;
+  }
+  sCheck.zErrMsg = 0;
+
+  /* Check the integrity of the freelist
+  */
+  checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
+            get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
+
+  /* Check all the tables.
+  */
+  for(i=0; i<nRoot && sCheck.mxErr; i++){
+    if( aRoot[i]==0 ) continue;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( pBt->autoVacuum && aRoot[i]>1 ){
+      checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
+    }
+#endif
+    checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: ");
+  }
+
+  /* Make sure every page in the file is referenced
+  */
+  for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
+#ifdef SQLITE_OMIT_AUTOVACUUM
+    if( sCheck.anRef[i]==0 ){
+      checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
+    }
+#else
+    /* If the database supports auto-vacuum, make sure no tables contain
+    ** references to pointer-map pages.
+    */
+    if( sCheck.anRef[i]==0 && 
+       (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
+      checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
+    }
+    if( sCheck.anRef[i]!=0 && 
+       (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
+      checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
+    }
+#endif
+  }
+
+  /* Make sure this analysis did not leave any unref() pages
+  */
+  unlockBtreeIfUnused(pBt);
+  if( nRef != sqlite3PagerRefcount(pBt->pPager) ){
+    checkAppendMsg(&sCheck, 0, 
+      "Outstanding page count goes from %d to %d during this analysis",
+      nRef, sqlite3PagerRefcount(pBt->pPager)
+    );
+  }
+
+  /* Clean  up and report errors.
+  */
+  sqlite3BtreeLeave(p);
+  sqlite3_free(sCheck.anRef);
+  *pnErr = sCheck.nErr;
+  return sCheck.zErrMsg;
+}
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+/*
+** Return the full pathname of the underlying database file.
+**
+** The pager filename is invariant as long as the pager is
+** open so it is safe to access without the BtShared mutex.
+*/
+const char *sqlite3BtreeGetFilename(Btree *p){
+  assert( p->pBt->pPager!=0 );
+  return sqlite3PagerFilename(p->pBt->pPager);
+}
+
+/*
+** Return the pathname of the directory that contains the database file.
+**
+** The pager directory name is invariant as long as the pager is
+** open so it is safe to access without the BtShared mutex.
+*/
+const char *sqlite3BtreeGetDirname(Btree *p){
+  assert( p->pBt->pPager!=0 );
+  return sqlite3PagerDirname(p->pBt->pPager);
+}
+
+/*
+** Return the pathname of the journal file for this database. The return
+** value of this routine is the same regardless of whether the journal file
+** has been created or not.
+**
+** The pager journal filename is invariant as long as the pager is
+** open so it is safe to access without the BtShared mutex.
+*/
+const char *sqlite3BtreeGetJournalname(Btree *p){
+  assert( p->pBt->pPager!=0 );
+  return sqlite3PagerJournalname(p->pBt->pPager);
+}
+
+#ifndef SQLITE_OMIT_VACUUM
+/*
+** Copy the complete content of pBtFrom into pBtTo.  A transaction
+** 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.
+*/
+static int btreeCopyFile(Btree *pTo, Btree *pFrom){
+  int rc = SQLITE_OK;
+  Pgno i, nPage, nToPage, iSkip;
+
+  BtShared *pBtTo = pTo->pBt;
+  BtShared *pBtFrom = pFrom->pBt;
+  pBtTo->db = pTo->db;
+  pBtFrom->db = pFrom->db;
+  
+
+  if( pTo->inTrans!=TRANS_WRITE || pFrom->inTrans!=TRANS_WRITE ){
+    return SQLITE_ERROR;
+  }
+  if( pBtTo->pCursor ) return SQLITE_BUSY;
+  nToPage = sqlite3PagerPagecount(pBtTo->pPager);
+  nPage = sqlite3PagerPagecount(pBtFrom->pPager);
+  iSkip = PENDING_BYTE_PAGE(pBtTo);
+  for(i=1; rc==SQLITE_OK && i<=nPage; i++){
+    DbPage *pDbPage;
+    if( i==iSkip ) continue;
+    rc = sqlite3PagerGet(pBtFrom->pPager, i, &pDbPage);
+    if( rc ) break;
+    rc = sqlite3PagerOverwrite(pBtTo->pPager, i, sqlite3PagerGetData(pDbPage));
+    sqlite3PagerUnref(pDbPage);
+  }
+
+  /* If the file is shrinking, journal the pages that are being truncated
+  ** so that they can be rolled back if the commit fails.
+  */
+  for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){
+    DbPage *pDbPage;
+    if( i==iSkip ) continue;
+    rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage);
+    if( rc ) break;
+    rc = sqlite3PagerWrite(pDbPage);
+    sqlite3PagerDontWrite(pDbPage);
+    /* Yeah.  It seems wierd to call DontWrite() right after Write().  But
+    ** that is because the names of those procedures do not exactly 
+    ** represent what they do.  Write() really means "put this page in the
+    ** rollback journal and mark it as dirty so that it will be written
+    ** to the database file later."  DontWrite() undoes the second part of
+    ** that and prevents the page from being written to the database.  The
+    ** page is still on the rollback journal, though.  And that is the whole
+    ** point of this loop: to put pages on the rollback journal. */
+    sqlite3PagerUnref(pDbPage);
+  }
+  if( !rc && nPage<nToPage ){
+    rc = sqlite3PagerTruncate(pBtTo->pPager, nPage);
+  }
+
+  if( rc ){
+    sqlite3BtreeRollback(pTo);
+  }
+  return rc;  
+}
+int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
+  int rc;
+  sqlite3BtreeEnter(pTo);
+  sqlite3BtreeEnter(pFrom);
+  rc = btreeCopyFile(pTo, pFrom);
+  sqlite3BtreeLeave(pFrom);
+  sqlite3BtreeLeave(pTo);
+  return rc;
+}
+
+#endif /* SQLITE_OMIT_VACUUM */
+
+/*
+** Return non-zero if a transaction is active.
+*/
+int sqlite3BtreeIsInTrans(Btree *p){
+  assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
+  return (p && (p->inTrans==TRANS_WRITE));
+}
+
+/*
+** Return non-zero if a statement transaction is active.
+*/
+int sqlite3BtreeIsInStmt(Btree *p){
+  assert( sqlite3BtreeHoldsMutex(p) );
+  return (p->pBt && p->pBt->inStmt);
+}
+
+/*
+** Return non-zero if a read (or write) transaction is active.
+*/
+int sqlite3BtreeIsInReadTrans(Btree *p){
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  return (p && (p->inTrans!=TRANS_NONE));
+}
+
+/*
+** This function returns a pointer to a blob of memory associated with
+** a single shared-btree. The memory is used by client code for its own
+** purposes (for example, to store a high-level schema associated with 
+** the shared-btree). The btree layer manages reference counting issues.
+**
+** The first time this is called on a shared-btree, nBytes bytes of memory
+** are allocated, zeroed, and returned to the caller. For each subsequent 
+** call the nBytes parameter is ignored and a pointer to the same blob
+** of memory returned. 
+**
+** Just before the shared-btree is closed, the function passed as the 
+** xFree argument when the memory allocation was made is invoked on the 
+** blob of allocated memory. This function should not call sqlite3_free()
+** on the memory, the btree layer does that.
+*/
+void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
+  BtShared *pBt = p->pBt;
+  sqlite3BtreeEnter(p);
+  if( !pBt->pSchema ){
+    pBt->pSchema = sqlite3MallocZero(nBytes);
+    pBt->xFreeSchema = xFree;
+  }
+  sqlite3BtreeLeave(p);
+  return pBt->pSchema;
+}
+
+/*
+** Return true if another user of the same shared btree as the argument
+** handle holds an exclusive lock on the sqlite_master table.
+*/
+int sqlite3BtreeSchemaLocked(Btree *p){
+  int rc;
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  sqlite3BtreeEnter(p);
+  rc = (queryTableLock(p, MASTER_ROOT, READ_LOCK)!=SQLITE_OK);
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** Obtain a lock on the table whose root page is iTab.  The
+** lock is a write lock if isWritelock is true or a read lock
+** if it is false.
+*/
+int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
+  int rc = SQLITE_OK;
+  u8 lockType = (isWriteLock?WRITE_LOCK:READ_LOCK);
+  sqlite3BtreeEnter(p);
+  rc = queryTableLock(p, iTab, lockType);
+  if( rc==SQLITE_OK ){
+    rc = lockTable(p, iTab, lockType);
+  }
+  sqlite3BtreeLeave(p);
+  return rc;
+}
+#endif
+
+#ifndef SQLITE_OMIT_INCRBLOB
+/*
+** Argument pCsr must be a cursor opened for writing on an 
+** INTKEY table currently pointing at a valid table entry. 
+** This function modifies the data stored as part of that entry.
+** Only the data content may only be modified, it is not possible
+** to change the length of the data stored.
+*/
+int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
+  assert( cursorHoldsMutex(pCsr) );
+  assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
+  assert(pCsr->isIncrblobHandle);
+  if( pCsr->eState>=CURSOR_REQUIRESEEK ){
+    if( pCsr->eState==CURSOR_FAULT ){
+      return pCsr->skip;
+    }else{
+      return SQLITE_ABORT;
+    }
+  }
+
+  /* Check some preconditions: 
+  **   (a) the cursor is open for writing,
+  **   (b) there is no read-lock on the table being modified and
+  **   (c) the cursor points at a valid row of an intKey table.
+  */
+  if( !pCsr->wrFlag ){
+    return SQLITE_READONLY;
+  }
+  assert( !pCsr->pBt->readOnly 
+          && pCsr->pBt->inTransaction==TRANS_WRITE );
+  if( checkReadLocks(pCsr->pBtree, pCsr->pgnoRoot, pCsr) ){
+    return SQLITE_LOCKED; /* The table pCur points to has a read lock */
+  }
+  if( pCsr->eState==CURSOR_INVALID || !pCsr->pPage->intKey ){
+    return SQLITE_ERROR;
+  }
+
+  return accessPayload(pCsr, offset, amt, (unsigned char *)z, 0, 1);
+}
+
+/* 
+** Set a flag on this cursor to cache the locations of pages from the 
+** overflow list for the current row. This is used by cursors opened
+** for incremental blob IO only.
+**
+** This function sets a flag only. The actual page location cache
+** (stored in BtCursor.aOverflow[]) is allocated and used by function
+** accessPayload() (the worker function for sqlite3BtreeData() and
+** sqlite3BtreePutData()).
+*/
+void sqlite3BtreeCacheOverflow(BtCursor *pCur){
+  assert( cursorHoldsMutex(pCur) );
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  assert(!pCur->isIncrblobHandle);
+  assert(!pCur->aOverflow);
+  pCur->isIncrblobHandle = 1;
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/btree.h b/client/src/thirdparty/sqlite-3.4.2/src/btree.h
new file mode 100644
index 0000000..3bfebdb
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/btree.h
@@ -0,0 +1,203 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.94 2007/12/07 18:55:28 drh Exp $
+*/
+#ifndef _BTREE_H_
+#define _BTREE_H_
+
+/* TODO: This definition is just included so other modules compile. It
+** needs to be revisited.
+*/
+#define SQLITE_N_BTREE_META 10
+
+/*
+** If defined as non-zero, auto-vacuum is enabled by default. Otherwise
+** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
+*/
+#ifndef SQLITE_DEFAULT_AUTOVACUUM
+  #define SQLITE_DEFAULT_AUTOVACUUM 0
+#endif
+
+#define BTREE_AUTOVACUUM_NONE 0        /* Do not do auto-vacuum */
+#define BTREE_AUTOVACUUM_FULL 1        /* Do full auto-vacuum */
+#define BTREE_AUTOVACUUM_INCR 2        /* Incremental vacuum */
+
+/*
+** Forward declarations of structure
+*/
+typedef struct Btree Btree;
+typedef struct BtCursor BtCursor;
+typedef struct BtShared BtShared;
+typedef struct BtreeMutexArray BtreeMutexArray;
+
+/*
+** This structure records all of the Btrees that need to hold
+** a mutex before we enter sqlite3VdbeExec().  The Btrees are
+** are placed in aBtree[] in order of aBtree[]->pBt.  That way,
+** we can always lock and unlock them all quickly.
+*/
+struct BtreeMutexArray {
+  int nMutex;
+  Btree *aBtree[SQLITE_MAX_ATTACHED+1];
+};
+
+
+int sqlite3BtreeOpen(
+  const char *zFilename,   /* Name of database file to open */
+  sqlite3 *db,             /* Associated database connection */
+  Btree **,                /* Return open Btree* here */
+  int flags,               /* Flags */
+  int vfsFlags             /* Flags passed through to VFS open */
+);
+
+/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the
+** following values.
+**
+** NOTE:  These values must match the corresponding PAGER_ values in
+** pager.h.
+*/
+#define BTREE_OMIT_JOURNAL  1  /* Do not use journal.  No argument */
+#define BTREE_NO_READLOCK   2  /* Omit readlocks on readonly files */
+#define BTREE_MEMORY        4  /* In-memory DB.  No argument */
+#define BTREE_READONLY      8  /* Open the database in read-only mode */
+#define BTREE_READWRITE    16  /* Open for both reading and writing */
+#define BTREE_CREATE       32  /* Create the database if it does not exist */
+
+/* Additional values for the 4th argument of sqlite3BtreeOpen that
+** are not associated with PAGER_ values.
+*/
+#define BTREE_PRIVATE      64  /* Never share with other connections */
+
+int sqlite3BtreeClose(Btree*);
+int sqlite3BtreeSetCacheSize(Btree*,int);
+int sqlite3BtreeSetSafetyLevel(Btree*,int,int);
+int sqlite3BtreeSyncDisabled(Btree*);
+int sqlite3BtreeSetPageSize(Btree*,int,int);
+int sqlite3BtreeGetPageSize(Btree*);
+int sqlite3BtreeMaxPageCount(Btree*,int);
+int sqlite3BtreeGetReserve(Btree*);
+int sqlite3BtreeSetAutoVacuum(Btree *, int);
+int sqlite3BtreeGetAutoVacuum(Btree *);
+int sqlite3BtreeBeginTrans(Btree*,int);
+int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);
+int sqlite3BtreeCommitPhaseTwo(Btree*);
+int sqlite3BtreeCommit(Btree*);
+int sqlite3BtreeRollback(Btree*);
+int sqlite3BtreeBeginStmt(Btree*);
+int sqlite3BtreeCommitStmt(Btree*);
+int sqlite3BtreeRollbackStmt(Btree*);
+int sqlite3BtreeCreateTable(Btree*, int*, int flags);
+int sqlite3BtreeIsInTrans(Btree*);
+int sqlite3BtreeIsInStmt(Btree*);
+int sqlite3BtreeIsInReadTrans(Btree*);
+void *sqlite3BtreeSchema(Btree *, int, void(*)(void *));
+int sqlite3BtreeSchemaLocked(Btree *);
+int sqlite3BtreeLockTable(Btree *, int, u8);
+
+const char *sqlite3BtreeGetFilename(Btree *);
+const char *sqlite3BtreeGetDirname(Btree *);
+const char *sqlite3BtreeGetJournalname(Btree *);
+int sqlite3BtreeCopyFile(Btree *, Btree *);
+
+int sqlite3BtreeIncrVacuum(Btree *);
+
+/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR
+** of the following flags:
+*/
+#define BTREE_INTKEY     1    /* Table has only 64-bit signed integer keys */
+#define BTREE_ZERODATA   2    /* Table has keys only - no data */
+#define BTREE_LEAFDATA   4    /* Data stored in leaves only.  Implies INTKEY */
+
+int sqlite3BtreeDropTable(Btree*, int, int*);
+int sqlite3BtreeClearTable(Btree*, int);
+int sqlite3BtreeGetMeta(Btree*, int idx, u32 *pValue);
+int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
+void sqlite3BtreeTripAllCursors(Btree*, int);
+
+int sqlite3BtreeCursor(
+  Btree*,                              /* BTree containing table to open */
+  int iTable,                          /* Index of root page */
+  int wrFlag,                          /* 1 for writing.  0 for read-only */
+  int(*)(void*,int,const void*,int,const void*),  /* Key comparison function */
+  void*,                               /* First argument to compare function */
+  BtCursor **ppCursor                  /* Returned cursor */
+);
+
+int sqlite3BtreeCloseCursor(BtCursor*);
+int sqlite3BtreeMoveto(BtCursor*,const void *pKey,i64 nKey,int bias,int *pRes);
+int sqlite3BtreeDelete(BtCursor*);
+int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
+                                  const void *pData, int nData,
+                                  int nZero, int bias);
+int sqlite3BtreeFirst(BtCursor*, int *pRes);
+int sqlite3BtreeLast(BtCursor*, int *pRes);
+int sqlite3BtreeNext(BtCursor*, int *pRes);
+int sqlite3BtreeEof(BtCursor*);
+int sqlite3BtreeFlags(BtCursor*);
+int sqlite3BtreePrevious(BtCursor*, int *pRes);
+int sqlite3BtreeKeySize(BtCursor*, i64 *pSize);
+int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
+sqlite3 *sqlite3BtreeCursorDb(const BtCursor*);
+const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
+const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
+int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
+int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
+
+char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*);
+struct Pager *sqlite3BtreePager(Btree*);
+
+int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
+void sqlite3BtreeCacheOverflow(BtCursor *);
+
+#ifdef SQLITE_TEST
+int sqlite3BtreeCursorInfo(BtCursor*, int*, int);
+void sqlite3BtreeCursorList(Btree*);
+int sqlite3BtreePageDump(Btree*, int, int recursive);
+#endif
+
+/*
+** If we are not using shared cache, then there is no need to
+** use mutexes to access the BtShared structures.  So make the
+** Enter and Leave procedures no-ops.
+*/
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
+  void sqlite3BtreeEnter(Btree*);
+  void sqlite3BtreeLeave(Btree*);
+  int sqlite3BtreeHoldsMutex(Btree*);
+  void sqlite3BtreeEnterCursor(BtCursor*);
+  void sqlite3BtreeLeaveCursor(BtCursor*);
+  void sqlite3BtreeEnterAll(sqlite3*);
+  void sqlite3BtreeLeaveAll(sqlite3*);
+  int sqlite3BtreeHoldsAllMutexes(sqlite3*);
+  void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*);
+  void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*);
+  void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*);
+#else
+# define sqlite3BtreeEnter(X)
+# define sqlite3BtreeLeave(X)
+# define sqlite3BtreeHoldsMutex(X) 1
+# define sqlite3BtreeEnterCursor(X)
+# define sqlite3BtreeLeaveCursor(X)
+# define sqlite3BtreeEnterAll(X)
+# define sqlite3BtreeLeaveAll(X)
+# define sqlite3BtreeHoldsAllMutexes(X) 1
+# define sqlite3BtreeMutexArrayEnter(X)
+# define sqlite3BtreeMutexArrayLeave(X)
+# define sqlite3BtreeMutexArrayInsert(X,Y)
+#endif
+
+
+#endif /* _BTREE_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/btreeInt.h b/client/src/thirdparty/sqlite-3.4.2/src/btreeInt.h
new file mode 100644
index 0000000..a1e5d42
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/btreeInt.h
@@ -0,0 +1,650 @@
+/*
+** 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: btreeInt.h,v 1.15 2007/12/21 04:47:26 danielk1977 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.
+**
+** The basic idea is that each page of the file contains N database
+** entries and N+1 pointers to subpages.
+**
+**   ----------------------------------------------------------------
+**   |  Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) |
+**   ----------------------------------------------------------------
+**
+** All of the keys on the page that Ptr(0) points to have values less
+** than Key(0).  All of the keys on page Ptr(1) and its subpages have
+** values greater than Key(0) and less than Key(1).  All of the keys
+** on Ptr(N) and its subpages have values greater than Key(N-1).  And
+** so forth.
+**
+** Finding a particular key requires reading O(log(M)) pages from the 
+** disk where M is the number of entries in the tree.
+**
+** In this implementation, a single file can hold one or more separate 
+** BTrees.  Each BTree is identified by the index of its root page.  The
+** key and data for any entry are combined to form the "payload".  A
+** fixed amount of payload can be carried directly on the database
+** page.  If the payload is larger than the preset amount then surplus
+** bytes are stored on overflow pages.  The payload for an entry
+** and the preceding pointer are combined to form a "Cell".  Each 
+** page has a small header which contains the Ptr(N) pointer and other
+** information such as the size of key and data.
+**
+** FORMAT DETAILS
+**
+** The file is divided into pages.  The first page is called page 1,
+** the second is page 2, and so forth.  A page number of zero indicates
+** "no such page".  The page size can be anything between 512 and 65536.
+** Each page can be either a btree page, a freelist page or an overflow
+** page.
+**
+** The first page is always a btree page.  The first 100 bytes of the first
+** page contain a special header (the "file header") that describes the file.
+** The format of the file header is as follows:
+**
+**   OFFSET   SIZE    DESCRIPTION
+**      0      16     Header string: "SQLite format 3\000"
+**     16       2     Page size in bytes.  
+**     18       1     File format write version
+**     19       1     File format read version
+**     20       1     Bytes of unused space at the end of each page
+**     21       1     Max embedded payload fraction
+**     22       1     Min embedded payload fraction
+**     23       1     Min leaf payload fraction
+**     24       4     File change counter
+**     28       4     Reserved for future use
+**     32       4     First freelist page
+**     36       4     Number of freelist pages in the file
+**     40      60     15 4-byte meta values passed to higher layers
+**
+** All of the integer values are big-endian (most significant byte first).
+**
+** The file change counter is incremented when the database is changed
+** This counter allows other processes to know when the file has changed
+** and thus when they need to flush their cache.
+**
+** The max embedded payload fraction is the amount of the total usable
+** space in a page that can be consumed by a single cell for standard
+** B-tree (non-LEAFDATA) tables.  A value of 255 means 100%.  The default
+** is to limit the maximum cell size so that at least 4 cells will fit
+** on one page.  Thus the default max embedded payload fraction is 64.
+**
+** If the payload for a cell is larger than the max payload, then extra
+** payload is spilled to overflow pages.  Once an overflow page is allocated,
+** as many bytes as possible are moved into the overflow pages without letting
+** the cell size drop below the min embedded payload fraction.
+**
+** The min leaf payload fraction is like the min embedded payload fraction
+** except that it applies to leaf nodes in a LEAFDATA tree.  The maximum
+** payload fraction for a LEAFDATA tree is always 100% (or 255) and it
+** not specified in the header.
+**
+** Each btree pages is divided into three sections:  The header, the
+** cell pointer array, and the cell content area.  Page 1 also has a 100-byte
+** file header that occurs before the page header.
+**
+**      |----------------|
+**      | file header    |   100 bytes.  Page 1 only.
+**      |----------------|
+**      | page header    |   8 bytes for leaves.  12 bytes for interior nodes
+**      |----------------|
+**      | cell pointer   |   |  2 bytes per cell.  Sorted order.
+**      | array          |   |  Grows downward
+**      |                |   v
+**      |----------------|
+**      | unallocated    |
+**      | space          |
+**      |----------------|   ^  Grows upwards
+**      | cell content   |   |  Arbitrary order interspersed with freeblocks.
+**      | area           |   |  and free space fragments.
+**      |----------------|
+**
+** The page headers looks like this:
+**
+**   OFFSET   SIZE     DESCRIPTION
+**      0       1      Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
+**      1       2      byte offset to the first freeblock
+**      3       2      number of cells on this page
+**      5       2      first byte of the cell content area
+**      7       1      number of fragmented free bytes
+**      8       4      Right child (the Ptr(N) value).  Omitted on leaves.
+**
+** The flags define the format of this btree page.  The leaf flag means that
+** this page has no children.  The zerodata flag means that this page carries
+** only keys and no data.  The intkey flag means that the key is a integer
+** which is stored in the key size entry of the cell header rather than in
+** the payload area.
+**
+** The cell pointer array begins on the first byte after the page header.
+** The cell pointer array contains zero or more 2-byte numbers which are
+** offsets from the beginning of the page to the cell content in the cell
+** content area.  The cell pointers occur in sorted order.  The system strives
+** to keep free space after the last cell pointer so that new cells can
+** be easily added without having to defragment the page.
+**
+** Cell content is stored at the very end of the page and grows toward the
+** beginning of the page.
+**
+** Unused space within the cell content area is collected into a linked list of
+** freeblocks.  Each freeblock is at least 4 bytes in size.  The byte offset
+** to the first freeblock is given in the header.  Freeblocks occur in
+** increasing order.  Because a freeblock must be at least 4 bytes in size,
+** any group of 3 or fewer unused bytes in the cell content area cannot
+** exist on the freeblock chain.  A group of 3 or fewer free bytes is called
+** a fragment.  The total number of bytes in all fragments is recorded.
+** in the page header at offset 7.
+**
+**    SIZE    DESCRIPTION
+**      2     Byte offset of the next freeblock
+**      2     Bytes in this freeblock
+**
+** Cells are of variable length.  Cells are stored in the cell content area at
+** the end of the page.  Pointers to the cells are in the cell pointer array
+** that immediately follows the page header.  Cells is not necessarily
+** contiguous or in order, but cell pointers are contiguous and in order.
+**
+** Cell content makes use of variable length integers.  A variable
+** length integer is 1 to 9 bytes where the lower 7 bits of each 
+** byte are used.  The integer consists of all bytes that have bit 8 set and
+** the first byte with bit 8 clear.  The most significant byte of the integer
+** appears first.  A variable-length integer may not be more than 9 bytes long.
+** As a special case, all 8 bytes of the 9th byte are used as data.  This
+** allows a 64-bit integer to be encoded in 9 bytes.
+**
+**    0x00                      becomes  0x00000000
+**    0x7f                      becomes  0x0000007f
+**    0x81 0x00                 becomes  0x00000080
+**    0x82 0x00                 becomes  0x00000100
+**    0x80 0x7f                 becomes  0x0000007f
+**    0x8a 0x91 0xd1 0xac 0x78  becomes  0x12345678
+**    0x81 0x81 0x81 0x81 0x01  becomes  0x10204081
+**
+** Variable length integers are used for rowids and to hold the number of
+** bytes of key and data in a btree cell.
+**
+** The content of a cell looks like this:
+**
+**    SIZE    DESCRIPTION
+**      4     Page number of the left child. Omitted if leaf flag is set.
+**     var    Number of bytes of data. Omitted if the zerodata flag is set.
+**     var    Number of bytes of key. Or the key itself if intkey flag is set.
+**      *     Payload
+**      4     First page of the overflow chain.  Omitted if no overflow
+**
+** Overflow pages form a linked list.  Each page except the last is completely
+** filled with data (pagesize - 4 bytes).  The last page can have as little
+** as 1 byte of data.
+**
+**    SIZE    DESCRIPTION
+**      4     Page number of next overflow page
+**      *     Data
+**
+** Freelist pages come in two subtypes: trunk pages and leaf pages.  The
+** file header points to the first in a linked list of trunk page.  Each trunk
+** page points to multiple leaf pages.  The content of a leaf page is
+** unspecified.  A trunk page looks like this:
+**
+**    SIZE    DESCRIPTION
+**      4     Page number of next trunk page
+**      4     Number of leaf pointers on this page
+**      *     zero or more pages numbers of leaves
+*/
+#include "sqliteInt.h"
+#include "pager.h"
+#include "btree.h"
+#include "os.h"
+#include <assert.h>
+
+/* Round up a number to the next larger multiple of 8.  This is used
+** to force 8-byte alignment on 64-bit architectures.
+*/
+#define ROUND8(x)   ((x+7)&~7)
+
+
+/* The following value is the maximum cell size assuming a maximum page
+** size give above.
+*/
+#define MX_CELL_SIZE(pBt)  (pBt->pageSize-8)
+
+/* The maximum number of cells on a single page of the database.  This
+** assumes a minimum cell size of 3 bytes.  Such small cells will be
+** exceedingly rare, but they are possible.
+*/
+#define MX_CELL(pBt) ((pBt->pageSize-8)/3)
+
+/* Forward declarations */
+typedef struct MemPage MemPage;
+typedef struct BtLock BtLock;
+
+/*
+** This is a magic string that appears at the beginning of every
+** SQLite database in order to identify the file as a real database.
+**
+** You can change this value at compile-time by specifying a
+** -DSQLITE_FILE_HEADER="..." on the compiler command-line.  The
+** header must be exactly 16 bytes including the zero-terminator so
+** the string itself should be 15 characters long.  If you change
+** the header, then your custom library will not be able to read 
+** databases generated by the standard tools and the standard tools
+** will not be able to read databases created by your custom library.
+*/
+#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */
+#  define SQLITE_FILE_HEADER "SQLite format 3"
+#endif
+
+/*
+** Page type flags.  An ORed combination of these flags appear as the
+** first byte of on-disk image of every BTree page.
+*/
+#define PTF_INTKEY    0x01
+#define PTF_ZERODATA  0x02
+#define PTF_LEAFDATA  0x04
+#define PTF_LEAF      0x08
+
+/*
+** As each page of the file is loaded into memory, an instance of the following
+** structure is appended and initialized to zero.  This structure stores
+** information about the page that is decoded from the raw file page.
+**
+** The pParent field points back to the parent page.  This allows us to
+** walk up the BTree from any leaf to the root.  Care must be taken to
+** unref() the parent page pointer when this page is no longer referenced.
+** The pageDestructor() routine handles that chore.
+**
+** Access to all fields of this structure is controlled by the mutex
+** stored in MemPage.pBt->mutex.
+*/
+struct MemPage {
+  u8 isInit;           /* True if previously initialized. MUST BE FIRST! */
+  u8 idxShift;         /* True if Cell indices have changed */
+  u8 nOverflow;        /* Number of overflow cell bodies in aCell[] */
+  u8 intKey;           /* True if intkey flag is set */
+  u8 leaf;             /* True if leaf flag is set */
+  u8 zeroData;         /* True if table stores keys only */
+  u8 leafData;         /* True if tables stores data on leaves only */
+  u8 hasData;          /* True if this page stores data */
+  u8 hdrOffset;        /* 100 for page 1.  0 otherwise */
+  u8 childPtrSize;     /* 0 if leaf==1.  4 if leaf==0 */
+  u16 maxLocal;        /* Copy of BtShared.maxLocal or BtShared.maxLeaf */
+  u16 minLocal;        /* Copy of BtShared.minLocal or BtShared.minLeaf */
+  u16 cellOffset;      /* Index in aData of first cell pointer */
+  u16 idxParent;       /* Index in parent of this node */
+  u16 nFree;           /* Number of free bytes on the page */
+  u16 nCell;           /* Number of cells on this page, local and ovfl */
+  struct _OvflCell {   /* Cells that will not fit on aData[] */
+    u8 *pCell;          /* Pointers to the body of the overflow cell */
+    u16 idx;            /* Insert this cell before idx-th non-overflow cell */
+  } aOvfl[5];
+  BtShared *pBt;       /* Pointer to BtShared that this page is part of */
+  u8 *aData;           /* Pointer to disk image of the page data */
+  DbPage *pDbPage;     /* Pager page handle */
+  Pgno pgno;           /* Page number for this page */
+  MemPage *pParent;    /* The parent of this page.  NULL for root */
+};
+
+/*
+** The in-memory image of a disk page has the auxiliary information appended
+** to the end.  EXTRA_SIZE is the number of bytes of space needed to hold
+** that extra information.
+*/
+#define EXTRA_SIZE sizeof(MemPage)
+
+/* A Btree handle
+**
+** A database connection contains a pointer to an instance of
+** this object for every database file that it has open.  This structure
+** is opaque to the database connection.  The database connection cannot
+** see the internals of this structure and only deals with pointers to
+** this structure.
+**
+** For some database files, the same underlying database cache might be 
+** shared between multiple connections.  In that case, each contection
+** has it own pointer to this object.  But each instance of this object
+** points to the same BtShared object.  The database cache and the
+** schema associated with the database file are all contained within
+** the BtShared object.
+**
+** All fields in this structure are accessed under sqlite3.mutex.
+** The pBt pointer itself may not be changed while there exists cursors 
+** in the referenced BtShared that point back to this Btree since those
+** cursors have to do go through this Btree to find their BtShared and
+** they often do so without holding sqlite3.mutex.
+*/
+struct Btree {
+  sqlite3 *db;       /* The database connection holding this btree */
+  BtShared *pBt;     /* Sharable content of this btree */
+  u8 inTrans;        /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
+  u8 sharable;       /* True if we can share pBt with another db */
+  u8 locked;         /* True if db currently has pBt locked */
+  int wantToLock;    /* Number of nested calls to sqlite3BtreeEnter() */
+  Btree *pNext;      /* List of other sharable Btrees from the same db */
+  Btree *pPrev;      /* Back pointer of the same list */
+};
+
+/*
+** Btree.inTrans may take one of the following values.
+**
+** If the shared-data extension is enabled, there may be multiple users
+** of the Btree structure. At most one of these may open a write transaction,
+** but any number may have active read transactions.
+*/
+#define TRANS_NONE  0
+#define TRANS_READ  1
+#define TRANS_WRITE 2
+
+/*
+** An instance of this object represents a single database file.
+** 
+** A single database file can be in use as the same time by two
+** or more database connections.  When two or more connections are
+** sharing the same database file, each connection has it own
+** private Btree object for the file and each of those Btrees points
+** to this one BtShared object.  BtShared.nRef is the number of
+** connections currently sharing this database file.
+**
+** Fields in this structure are accessed under the BtShared.mutex
+** mutex, except for nRef and pNext which are accessed under the
+** global SQLITE_MUTEX_STATIC_MASTER mutex.  The pPager field
+** may not be modified once it is initially set as long as nRef>0.
+** The pSchema field may be set once under BtShared.mutex and
+** thereafter is unchanged as long as nRef>0.
+*/
+struct BtShared {
+  Pager *pPager;        /* The page cache */
+  sqlite3 *db;          /* Database connection currently using this Btree */
+  BtCursor *pCursor;    /* A list of all open cursors */
+  MemPage *pPage1;      /* First page of the database */
+  u8 inStmt;            /* True if we are in a statement subtransaction */
+  u8 readOnly;          /* True if the underlying file is readonly */
+  u8 maxEmbedFrac;      /* Maximum payload as % of total page size */
+  u8 minEmbedFrac;      /* Minimum payload as % of total page size */
+  u8 minLeafFrac;       /* Minimum leaf payload as % of total page size */
+  u8 pageSizeFixed;     /* True if the page size can no longer be changed */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  u8 autoVacuum;        /* True if auto-vacuum is enabled */
+  u8 incrVacuum;        /* True if incr-vacuum is enabled */
+  Pgno nTrunc;          /* Non-zero if the db will be truncated (incr vacuum) */
+#endif
+  u16 pageSize;         /* Total number of bytes on a page */
+  u16 usableSize;       /* Number of usable bytes on each page */
+  int maxLocal;         /* Maximum local payload in non-LEAFDATA tables */
+  int minLocal;         /* Minimum local payload in non-LEAFDATA tables */
+  int maxLeaf;          /* Maximum local payload in a LEAFDATA table */
+  int minLeaf;          /* Minimum local payload in a LEAFDATA table */
+  u8 inTransaction;     /* Transaction state */
+  int nTransaction;     /* Number of open transactions (read + write) */
+  void *pSchema;        /* Pointer to space allocated by sqlite3BtreeSchema() */
+  void (*xFreeSchema)(void*);  /* Destructor for BtShared.pSchema */
+  sqlite3_mutex *mutex; /* Non-recursive mutex required to access this struct */
+  BusyHandler busyHdr;  /* The busy handler for this btree */
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  int nRef;             /* Number of references to this structure */
+  BtShared *pNext;      /* Next on a list of sharable BtShared structs */
+  BtLock *pLock;        /* List of locks held on this shared-btree struct */
+  Btree *pExclusive;    /* Btree with an EXCLUSIVE lock on the whole db */
+#endif
+};
+
+/*
+** An instance of the following structure is used to hold information
+** about a cell.  The parseCellPtr() function fills in this structure
+** based on information extract from the raw disk page.
+*/
+typedef struct CellInfo CellInfo;
+struct CellInfo {
+  u8 *pCell;     /* Pointer to the start of cell content */
+  i64 nKey;      /* The key for INTKEY tables, or number of bytes in key */
+  u32 nData;     /* Number of bytes of data */
+  u32 nPayload;  /* Total amount of payload */
+  u16 nHeader;   /* Size of the cell content header in bytes */
+  u16 nLocal;    /* Amount of payload held locally */
+  u16 iOverflow; /* Offset to overflow page number.  Zero if no overflow */
+  u16 nSize;     /* Size of the cell content on the main b-tree page */
+};
+
+/*
+** A cursor is a pointer to a particular entry within a particular
+** b-tree within a database file.
+**
+** The entry is identified by its MemPage and the index in
+** MemPage.aCell[] of the entry.
+**
+** When a single database file can shared by two more database connections,
+** but cursors cannot be shared.  Each cursor is associated with a
+** particular database connection identified BtCursor.pBtree.db.
+**
+** Fields in this structure are accessed under the BtShared.mutex
+** found at self->pBt->mutex. 
+*/
+struct BtCursor {
+  Btree *pBtree;            /* The Btree to which this cursor belongs */
+  BtShared *pBt;            /* The BtShared this cursor points to */
+  BtCursor *pNext, *pPrev;  /* Forms a linked list of all cursors */
+  int (*xCompare)(void*,int,const void*,int,const void*); /* Key comp func */
+  void *pArg;               /* First arg to xCompare() */
+  Pgno pgnoRoot;            /* The root page of this tree */
+  MemPage *pPage;           /* Page that contains the entry */
+  int idx;                  /* Index of the entry in pPage->aCell[] */
+  CellInfo info;            /* A parse of the cell we are pointing at */
+  u8 wrFlag;                /* True if writable */
+  u8 eState;                /* One of the CURSOR_XXX constants (see below) */
+  void *pKey;      /* Saved key that was cursor's last known position */
+  i64 nKey;        /* Size of pKey, or last integer key */
+  int skip;        /* (skip<0) -> Prev() is a no-op. (skip>0) -> Next() is */
+#ifndef SQLITE_OMIT_INCRBLOB
+  u8 isIncrblobHandle;      /* True if this cursor is an incr. io handle */
+  Pgno *aOverflow;          /* Cache of overflow page locations */
+#endif
+};
+
+/*
+** Potential values for BtCursor.eState.
+**
+** CURSOR_VALID:
+**   Cursor points to a valid entry. getPayload() etc. may be called.
+**
+** CURSOR_INVALID:
+**   Cursor does not point to a valid entry. This can happen (for example) 
+**   because the table is empty or because BtreeCursorFirst() has not been
+**   called.
+**
+** CURSOR_REQUIRESEEK:
+**   The table that this cursor was opened on still exists, but has been 
+**   modified since the cursor was last used. The cursor position is saved
+**   in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in 
+**   this state, restoreOrClearCursorPosition() can be called to attempt to
+**   seek the cursor to the saved position.
+**
+** CURSOR_FAULT:
+**   A unrecoverable error (an I/O error or a malloc failure) has occurred
+**   on a different connection that shares the BtShared cache with this
+**   cursor.  The error has left the cache in an inconsistent state.
+**   Do nothing else with this cursor.  Any attempt to use the cursor
+**   should return the error code stored in BtCursor.skip
+*/
+#define CURSOR_INVALID           0
+#define CURSOR_VALID             1
+#define CURSOR_REQUIRESEEK       2
+#define CURSOR_FAULT             3
+
+/*
+** The TRACE macro will print high-level status information about the
+** btree operation when the global variable sqlite3_btree_trace is
+** enabled.
+*/
+#if SQLITE_TEST
+# define TRACE(X)   if( sqlite3_btree_trace ){ printf X; fflush(stdout); }
+#else
+# define TRACE(X)
+#endif
+
+/*
+** Routines to read and write variable-length integers.  These used to
+** be defined locally, but now we use the varint routines in the util.c
+** file.
+*/
+#define getVarint    sqlite3GetVarint
+#define getVarint32(A,B)  ((*B=*(A))<=0x7f?1:sqlite3GetVarint32(A,B))
+#define putVarint    sqlite3PutVarint
+
+/* The database page the PENDING_BYTE occupies. This page is never used.
+** TODO: This macro is very similary to PAGER_MJ_PGNO() in pager.c. They
+** should possibly be consolidated (presumably in pager.h).
+**
+** If disk I/O is omitted (meaning that the database is stored purely
+** in memory) then there is no pending byte.
+*/
+#ifdef SQLITE_OMIT_DISKIO
+# define PENDING_BYTE_PAGE(pBt)  0x7fffffff
+#else
+# define PENDING_BYTE_PAGE(pBt) ((PENDING_BYTE/(pBt)->pageSize)+1)
+#endif
+
+/*
+** A linked list of the following structures is stored at BtShared.pLock.
+** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor 
+** is opened on the table with root page BtShared.iTable. Locks are removed
+** from this list when a transaction is committed or rolled back, or when
+** a btree handle is closed.
+*/
+struct BtLock {
+  Btree *pBtree;        /* Btree handle holding this lock */
+  Pgno iTable;          /* Root page of table */
+  u8 eLock;             /* READ_LOCK or WRITE_LOCK */
+  BtLock *pNext;        /* Next in BtShared.pLock list */
+};
+
+/* Candidate values for BtLock.eLock */
+#define READ_LOCK     1
+#define WRITE_LOCK    2
+
+/*
+** These macros define the location of the pointer-map entry for a 
+** database page. The first argument to each is the number of usable
+** bytes on each page of the database (often 1024). The second is the
+** page number to look up in the pointer map.
+**
+** PTRMAP_PAGENO returns the database page number of the pointer-map
+** page that stores the required pointer. PTRMAP_PTROFFSET returns
+** the offset of the requested map entry.
+**
+** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
+** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
+** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
+** this test.
+*/
+#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
+#define PTRMAP_PTROFFSET(pBt, pgno) (5*(pgno-ptrmapPageno(pBt, pgno)-1))
+#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
+
+/*
+** The pointer map is a lookup table that identifies the parent page for
+** each child page in the database file.  The parent page is the page that
+** contains a pointer to the child.  Every page in the database contains
+** 0 or 1 parent pages.  (In this context 'database page' refers
+** to any page that is not part of the pointer map itself.)  Each pointer map
+** entry consists of a single byte 'type' and a 4 byte parent page number.
+** The PTRMAP_XXX identifiers below are the valid types.
+**
+** The purpose of the pointer map is to facility moving pages from one
+** position in the file to another as part of autovacuum.  When a page
+** is moved, the pointer in its parent must be updated to point to the
+** new location.  The pointer map is used to locate the parent page quickly.
+**
+** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
+**                  used in this case.
+**
+** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number 
+**                  is not used in this case.
+**
+** PTRMAP_OVERFLOW1: The database page is the first page in a list of 
+**                   overflow pages. The page number identifies the page that
+**                   contains the cell with a pointer to this overflow page.
+**
+** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of
+**                   overflow pages. The page-number identifies the previous
+**                   page in the overflow page list.
+**
+** PTRMAP_BTREE: The database page is a non-root btree page. The page number
+**               identifies the parent page in the btree.
+*/
+#define PTRMAP_ROOTPAGE 1
+#define PTRMAP_FREEPAGE 2
+#define PTRMAP_OVERFLOW1 3
+#define PTRMAP_OVERFLOW2 4
+#define PTRMAP_BTREE 5
+
+/* A bunch of assert() statements to check the transaction state variables
+** of handle p (type Btree*) are internally consistent.
+*/
+#define btreeIntegrity(p) \
+  assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
+  assert( p->pBt->inTransaction>=p->inTrans ); 
+
+
+/*
+** The ISAUTOVACUUM macro is used within balance_nonroot() to determine
+** if the database supports auto-vacuum or not. Because it is used
+** within an expression that is an argument to another macro 
+** (sqliteMallocRaw), it is not possible to use conditional compilation.
+** So, this macro is defined instead.
+*/
+#ifndef SQLITE_OMIT_AUTOVACUUM
+#define ISAUTOVACUUM (pBt->autoVacuum)
+#else
+#define ISAUTOVACUUM 0
+#endif
+
+
+/*
+** This structure is passed around through all the sanity checking routines
+** in order to keep track of some global state information.
+*/
+typedef struct IntegrityCk IntegrityCk;
+struct IntegrityCk {
+  BtShared *pBt;    /* The tree being checked out */
+  Pager *pPager;    /* The associated pager.  Also accessible by pBt->pPager */
+  int nPage;        /* Number of pages in the database */
+  int *anRef;       /* Number of times each page is referenced */
+  int mxErr;        /* Stop accumulating errors when this reaches zero */
+  char *zErrMsg;    /* An error message.  NULL if no errors seen. */
+  int nErr;         /* Number of messages written to zErrMsg so far */
+};
+
+/*
+** Read or write a two- and four-byte big-endian integer values.
+*/
+#define get2byte(x)   ((x)[0]<<8 | (x)[1])
+#define put2byte(p,v) ((p)[0] = (v)>>8, (p)[1] = (v))
+#define get4byte sqlite3Get4byte
+#define put4byte sqlite3Put4byte
+
+/*
+** Internal routines that should be accessed by the btree layer only.
+*/
+int sqlite3BtreeGetPage(BtShared*, Pgno, MemPage**, int);
+int sqlite3BtreeInitPage(MemPage *pPage, MemPage *pParent);
+void sqlite3BtreeParseCellPtr(MemPage*, u8*, CellInfo*);
+void sqlite3BtreeParseCell(MemPage*, int, CellInfo*);
+#ifdef SQLITE_TEST
+u8 *sqlite3BtreeFindCell(MemPage *pPage, int iCell);
+#endif
+int sqlite3BtreeRestoreOrClearCursorPosition(BtCursor *pCur);
+void sqlite3BtreeGetTempCursor(BtCursor *pCur, BtCursor *pTempCur);
+void sqlite3BtreeReleaseTempCursor(BtCursor *pCur);
+int sqlite3BtreeIsRootPage(MemPage *pPage);
+void sqlite3BtreeMoveToParent(BtCursor *pCur);
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/build.c b/client/src/thirdparty/sqlite-3.4.2/src/build.c
new file mode 100644
index 0000000..9c7d82c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/build.c
@@ -0,0 +1,3467 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains C code routines that are called by the SQLite parser
+** when syntax rules are reduced.  The routines in this file handle the
+** following kinds of SQL syntax:
+**
+**     CREATE TABLE
+**     DROP TABLE
+**     CREATE INDEX
+**     DROP INDEX
+**     creating ID lists
+**     BEGIN TRANSACTION
+**     COMMIT
+**     ROLLBACK
+**
+** $Id: build.c,v 1.472 2008/01/31 13:35:49 drh 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.
+*/
+void sqlite3BeginParse(Parse *pParse, int explainFlag){
+  pParse->explain = explainFlag;
+  pParse->nVar = 0;
+}
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/*
+** The TableLock structure is only used by the sqlite3TableLock() and
+** codeTableLocks() functions.
+*/
+struct TableLock {
+  int iDb;             /* The database containing the table to be locked */
+  int iTab;            /* The root page of the table to be locked */
+  u8 isWriteLock;      /* True for write lock.  False for a read lock */
+  const char *zName;   /* Name of the table */
+};
+
+/*
+** Record the fact that we want to lock a table at run-time.  
+**
+** The table to be locked has root page iTab and is found in database iDb.
+** A read or a write lock can be taken depending on isWritelock.
+**
+** This routine just records the fact that the lock is desired.  The
+** code to make the lock occur is generated by a later call to
+** codeTableLocks() which occurs during sqlite3FinishCoding().
+*/
+void sqlite3TableLock(
+  Parse *pParse,     /* Parsing context */
+  int iDb,           /* Index of the database containing the table to lock */
+  int iTab,          /* Root page number of the table to be locked */
+  u8 isWriteLock,    /* True for a write lock */
+  const char *zName  /* Name of the table to be locked */
+){
+  int i;
+  int nBytes;
+  TableLock *p;
+
+  if( iDb<0 ){
+    return;
+  }
+
+  for(i=0; i<pParse->nTableLock; i++){
+    p = &pParse->aTableLock[i];
+    if( p->iDb==iDb && p->iTab==iTab ){
+      p->isWriteLock = (p->isWriteLock || isWriteLock);
+      return;
+    }
+  }
+
+  nBytes = sizeof(TableLock) * (pParse->nTableLock+1);
+  pParse->aTableLock = 
+      sqlite3DbReallocOrFree(pParse->db, pParse->aTableLock, nBytes);
+  if( pParse->aTableLock ){
+    p = &pParse->aTableLock[pParse->nTableLock++];
+    p->iDb = iDb;
+    p->iTab = iTab;
+    p->isWriteLock = isWriteLock;
+    p->zName = zName;
+  }else{
+    pParse->nTableLock = 0;
+    pParse->db->mallocFailed = 1;
+  }
+}
+
+/*
+** Code an OP_TableLock instruction for each table locked by the
+** statement (configured by calls to sqlite3TableLock()).
+*/
+static void codeTableLocks(Parse *pParse){
+  int i;
+  Vdbe *pVdbe; 
+
+  if( 0==(pVdbe = sqlite3GetVdbe(pParse)) ){
+    return;
+  }
+
+  for(i=0; i<pParse->nTableLock; i++){
+    TableLock *p = &pParse->aTableLock[i];
+    int p1 = p->iDb;
+    if( p->isWriteLock ){
+      p1 = -1*(p1+1);
+    }
+    sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, 0, p->zName, P4_STATIC);
+  }
+}
+#else
+  #define codeTableLocks(x)
+#endif
+
+/*
+** This routine is called after a single SQL statement has been
+** parsed and a VDBE program to execute that statement has been
+** prepared.  This routine puts the finishing touches on the
+** VDBE program and resets the pParse structure for the next
+** parse.
+**
+** Note that if an error occurred, it might be the case that
+** no VDBE code was generated.
+*/
+void sqlite3FinishCoding(Parse *pParse){
+  sqlite3 *db;
+  Vdbe *v;
+
+  db = pParse->db;
+  if( db->mallocFailed ) return;
+  if( pParse->nested ) return;
+  if( pParse->nErr ) return;
+  if( !pParse->pVdbe ){
+    if( pParse->rc==SQLITE_OK && pParse->nErr ){
+      pParse->rc = SQLITE_ERROR;
+      return;
+    }
+  }
+
+  /* Begin by generating some termination code at the end of the
+  ** vdbe program
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp0(v, OP_Halt);
+
+    /* The cookie mask contains one bit for each database file open.
+    ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are
+    ** 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;
+      sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
+      for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
+        if( (mask & pParse->cookieMask)==0 ) continue;
+        sqlite3VdbeUsesBtree(v, iDb);
+        sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
+        sqlite3VdbeAddOp2(v,OP_VerifyCookie, iDb, pParse->cookieValue[iDb]);
+      }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      if( pParse->pVirtualLock ){
+        char *vtab = (char *)pParse->pVirtualLock->pVtab;
+        sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
+      }
+#endif
+
+      /* Once all the cookies have been verified and transactions opened, 
+      ** obtain the required table-locks. This is a no-op unless the 
+      ** shared-cache feature is enabled.
+      */
+      codeTableLocks(pParse);
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
+    }
+
+#ifndef SQLITE_OMIT_TRACE
+    if( !db->init.busy ){
+      /* Change the P4 argument of the first opcode (which will always be
+      ** an OP_Trace) to be the complete text of the current SQL statement.
+      */
+      VdbeOp *pOp = sqlite3VdbeGetOp(v, 0);
+      if( pOp && pOp->opcode==OP_Trace ){
+        sqlite3VdbeChangeP4(v, 0, pParse->zSql, pParse->zTail-pParse->zSql);
+      }
+    }
+#endif /* SQLITE_OMIT_TRACE */
+  }
+
+
+  /* Get the VDBE program ready for execution
+  */
+  if( v && pParse->nErr==0 && !db->mallocFailed ){
+#ifdef SQLITE_DEBUG
+    FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
+    sqlite3VdbeTrace(v, trace);
+#endif
+    sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3,
+                         pParse->nTab+3, 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;
+  pParse->nSet = 0;
+  pParse->nVar = 0;
+  pParse->cookieMask = 0;
+  pParse->cookieGoto = 0;
+}
+
+/*
+** Run the parser and code generator recursively in order to generate
+** code for the SQL statement given onto the end of the pParse context
+** currently under construction.  When the parser is run recursively
+** this way, the final OP_Halt is not appended and other initialization
+** and finalization steps are omitted because those are handling by the
+** outermost parser.
+**
+** 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;
+# 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(pParse->db, zFormat, ap);
+  va_end(ap);
+  if( zSql==0 ){
+    pParse->db->mallocFailed = 1;
+    return;   /* A malloc must have failed */
+  }
+  pParse->nested++;
+  memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
+  memset(&pParse->nVar, 0, SAVE_SZ);
+  sqlite3RunParser(pParse, zSql, 0);
+  sqlite3_free(zSql);
+  memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
+  pParse->nested--;
+}
+
+/*
+** Locate the in-memory structure that describes a particular database
+** table given the name of that table and (optionally) the name of the
+** database containing the table.  Return NULL if not found.
+**
+** If zDatabase is 0, all databases are searched for the table and the
+** first matching table is returned.  (No checking for duplicate table
+** names is done.)  The search order is TEMP first, then MAIN, then any
+** auxiliary databases added using the ATTACH command.
+**
+** See also sqlite3LocateTable().
+*/
+Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
+  Table *p = 0;
+  int i;
+  assert( zName!=0 );
+  for(i=OMIT_TEMPDB; i<db->nDb; i++){
+    int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
+    if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
+    p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, strlen(zName)+1);
+    if( p ) break;
+  }
+  return p;
+}
+
+/*
+** Locate the in-memory structure that describes a particular database
+** table given the name of that table and (optionally) the name of the
+** database containing the table.  Return NULL if not found.  Also leave an
+** error message in pParse->zErrMsg.
+**
+** The difference between this routine and sqlite3FindTable() is that this
+** routine leaves an error message in pParse->zErrMsg where
+** sqlite3FindTable() does not.
+*/
+Table *sqlite3LocateTable(
+  Parse *pParse,         /* context in which to report errors */
+  int isView,            /* True if looking for a VIEW rather than a TABLE */
+  const char *zName,     /* Name of the table we are looking for */
+  const char *zDbase     /* Name of the database.  Might be NULL */
+){
+  Table *p;
+
+  /* Read the database schema. If an error occurs, leave an error message
+  ** and code in pParse and return NULL. */
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    return 0;
+  }
+
+  p = sqlite3FindTable(pParse->db, zName, zDbase);
+  if( p==0 ){
+    const char *zMsg = isView ? "no such view" : "no such table";
+    if( zDbase ){
+      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
+    }else{
+      sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
+    }
+    pParse->checkSchema = 1;
+  }
+  return p;
+}
+
+/*
+** Locate the in-memory structure that describes 
+** a particular index given the name of that index
+** and the name of the database that contains the index.
+** Return NULL if not found.
+**
+** If zDatabase is 0, all databases are searched for the
+** table and the first matching index is returned.  (No checking
+** for duplicate index names is done.)  The search order is
+** TEMP first, then MAIN, then any auxiliary databases added
+** using the ATTACH command.
+*/
+Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
+  Index *p = 0;
+  int i;
+  for(i=OMIT_TEMPDB; i<db->nDb; i++){
+    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
+    Schema *pSchema = db->aDb[j].pSchema;
+    if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
+    assert( pSchema || (j==1 && !db->aDb[1].pBt) );
+    if( pSchema ){
+      p = sqlite3HashFind(&pSchema->idxHash, zName, strlen(zName)+1);
+    }
+    if( p ) break;
+  }
+  return p;
+}
+
+/*
+** Reclaim the memory used by an index
+*/
+static void freeIndex(Index *p){
+  sqlite3_free(p->zColAff);
+  sqlite3_free(p);
+}
+
+/*
+** Remove the given index from the index hash table, and free
+** its memory structures.
+**
+** The index is removed from the database hash tables but
+** it is not unlinked from the Table that it indexes.
+** Unlinking from the Table must be done by the calling function.
+*/
+static void sqliteDeleteIndex(Index *p){
+  Index *pOld;
+  const char *zName = p->zName;
+
+  pOld = sqlite3HashInsert(&p->pSchema->idxHash, zName, strlen( zName)+1, 0);
+  assert( pOld==0 || pOld==p );
+  freeIndex(p);
+}
+
+/*
+** For the index called zIdxName which is found in the database iDb,
+** unlike that index from its Table then remove the index from
+** the index hash table and free all memory structures associated
+** with the index.
+*/
+void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
+  Index *pIndex;
+  int len;
+  Hash *pHash = &db->aDb[iDb].pSchema->idxHash;
+
+  len = strlen(zIdxName);
+  pIndex = sqlite3HashInsert(pHash, zIdxName, len+1, 0);
+  if( pIndex ){
+    if( pIndex->pTable->pIndex==pIndex ){
+      pIndex->pTable->pIndex = pIndex->pNext;
+    }else{
+      Index *p;
+      for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){}
+      if( p && p->pNext==pIndex ){
+        p->pNext = pIndex->pNext;
+      }
+    }
+    freeIndex(pIndex);
+  }
+  db->flags |= SQLITE_InternChanges;
+}
+
+/*
+** Erase all schema information from the in-memory hash tables of
+** a single database.  This routine is called to reclaim memory
+** before the database closes.  It is also called during a rollback
+** if there were schema changes during the transaction or if a
+** schema-cookie mismatch occurs.
+**
+** If iDb<=0 then reset the internal schema tables for all database
+** files.  If iDb>=2 then reset the internal schema for only the
+** single file indicated.
+*/
+void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
+  int i, j;
+  assert( iDb>=0 && iDb<db->nDb );
+
+  if( iDb==0 ){
+    sqlite3BtreeEnterAll(db);
+  }
+  for(i=iDb; i<db->nDb; i++){
+    Db *pDb = &db->aDb[i];
+    if( pDb->pSchema ){
+      assert(i==1 || (pDb->pBt && sqlite3BtreeHoldsMutex(pDb->pBt)));
+      sqlite3SchemaFree(pDb->pSchema);
+    }
+    if( iDb>0 ) return;
+  }
+  assert( iDb==0 );
+  db->flags &= ~SQLITE_InternChanges;
+  sqlite3BtreeLeaveAll(db);
+
+  /* If one or more of the auxiliary database files has been closed,
+  ** then remove them from the auxiliary database list.  We take the
+  ** opportunity to do this here since we have just deleted all of the
+  ** schema hash tables and therefore do not have to make any changes
+  ** to any of those tables.
+  */
+  for(i=0; i<db->nDb; i++){
+    struct Db *pDb = &db->aDb[i];
+    if( pDb->pBt==0 ){
+      if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux);
+      pDb->pAux = 0;
+    }
+  }
+  for(i=j=2; i<db->nDb; i++){
+    struct Db *pDb = &db->aDb[i];
+    if( pDb->pBt==0 ){
+      sqlite3_free(pDb->zName);
+      pDb->zName = 0;
+      continue;
+    }
+    if( j<i ){
+      db->aDb[j] = db->aDb[i];
+    }
+    j++;
+  }
+  memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
+  db->nDb = j;
+  if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
+    memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
+    sqlite3_free(db->aDb);
+    db->aDb = db->aDbStatic;
+  }
+}
+
+/*
+** This routine is called when a commit occurs.
+*/
+void sqlite3CommitInternalChanges(sqlite3 *db){
+  db->flags &= ~SQLITE_InternChanges;
+}
+
+/*
+** Clear the column names from a table or view.
+*/
+static void sqliteResetColumnNames(Table *pTable){
+  int i;
+  Column *pCol;
+  assert( pTable!=0 );
+  if( (pCol = pTable->aCol)!=0 ){
+    for(i=0; i<pTable->nCol; i++, pCol++){
+      sqlite3_free(pCol->zName);
+      sqlite3ExprDelete(pCol->pDflt);
+      sqlite3_free(pCol->zType);
+      sqlite3_free(pCol->zColl);
+    }
+    sqlite3_free(pTable->aCol);
+  }
+  pTable->aCol = 0;
+  pTable->nCol = 0;
+}
+
+/*
+** Remove the memory data structures associated with the given
+** Table.  No changes are made to disk by this routine.
+**
+** This routine just deletes the data structure.  It does not unlink
+** the table data structure from the hash table.  Nor does it remove
+** foreign keys from the sqlite.aFKey hash table.  But it does destroy
+** memory structures of the indices and foreign keys associated with 
+** the table.
+*/
+void sqlite3DeleteTable(Table *pTable){
+  Index *pIndex, *pNext;
+  FKey *pFKey, *pNextFKey;
+
+  if( pTable==0 ) return;
+
+  /* Do not delete the table until the reference count reaches zero. */
+  pTable->nRef--;
+  if( pTable->nRef>0 ){
+    return;
+  }
+  assert( pTable->nRef==0 );
+
+  /* Delete all indices associated with this table
+  */
+  for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
+    pNext = pIndex->pNext;
+    assert( pIndex->pSchema==pTable->pSchema );
+    sqliteDeleteIndex(pIndex);
+  }
+
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+  /* Delete all foreign keys associated with this table.  The keys
+  ** should have already been unlinked from the pSchema->aFKey hash table 
+  */
+  for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){
+    pNextFKey = pFKey->pNextFrom;
+    assert( sqlite3HashFind(&pTable->pSchema->aFKey,
+                           pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey );
+    sqlite3_free(pFKey);
+  }
+#endif
+
+  /* Delete the Table structure itself.
+  */
+  sqliteResetColumnNames(pTable);
+  sqlite3_free(pTable->zName);
+  sqlite3_free(pTable->zColAff);
+  sqlite3SelectDelete(pTable->pSelect);
+#ifndef SQLITE_OMIT_CHECK
+  sqlite3ExprDelete(pTable->pCheck);
+#endif
+  sqlite3VtabClear(pTable);
+  sqlite3_free(pTable);
+}
+
+/*
+** Unlink the given table from the hash tables and the delete the
+** table structure with all its indices and foreign keys.
+*/
+void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
+  Table *p;
+  FKey *pF1, *pF2;
+  Db *pDb;
+
+  assert( db!=0 );
+  assert( iDb>=0 && iDb<db->nDb );
+  assert( zTabName && zTabName[0] );
+  pDb = &db->aDb[iDb];
+  p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, strlen(zTabName)+1,0);
+  if( p ){
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+    for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){
+      int nTo = strlen(pF1->zTo) + 1;
+      pF2 = sqlite3HashFind(&pDb->pSchema->aFKey, pF1->zTo, nTo);
+      if( pF2==pF1 ){
+        sqlite3HashInsert(&pDb->pSchema->aFKey, pF1->zTo, nTo, pF1->pNextTo);
+      }else{
+        while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; }
+        if( pF2 ){
+          pF2->pNextTo = pF1->pNextTo;
+        }
+      }
+    }
+#endif
+    sqlite3DeleteTable(p);
+  }
+  db->flags |= SQLITE_InternChanges;
+}
+
+/*
+** Given a token, return a string that consists of the text of that
+** token with any quotations removed.  Space to hold the returned string
+** is obtained from sqliteMalloc() and must be freed by the calling
+** function.
+**
+** Tokens are often just pointers into the original SQL text and so
+** are not \000 terminated and are not persistent.  The returned string
+** is \000 terminated and is persistent.
+*/
+char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
+  char *zName;
+  if( pName ){
+    zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
+    sqlite3Dequote(zName);
+  }else{
+    zName = 0;
+  }
+  return zName;
+}
+
+/*
+** Open the sqlite_master table stored in database number iDb for
+** writing. The table is opened using cursor 0.
+*/
+void sqlite3OpenMasterTable(Parse *p, int iDb){
+  Vdbe *v = sqlite3GetVdbe(p);
+  sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
+  sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
+  sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, 5); /* sqlite_master has 5 columns */
+}
+
+/*
+** The token *pName contains the name of a database (either "main" or
+** "temp" or the name of an attached db). This routine returns the
+** index of the named database in db->aDb[], or -1 if the named db 
+** does not exist.
+*/
+int sqlite3FindDb(sqlite3 *db, Token *pName){
+  int i = -1;    /* Database number */
+  int n;         /* Number of characters in the name */
+  Db *pDb;       /* A database whose name space is being searched */
+  char *zName;   /* Name we are searching for */
+
+  zName = sqlite3NameFromToken(db, pName);
+  if( zName ){
+    n = strlen(zName);
+    for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
+      if( (!OMIT_TEMPDB || i!=1 ) && n==strlen(pDb->zName) && 
+          0==sqlite3StrICmp(pDb->zName, zName) ){
+        break;
+      }
+    }
+    sqlite3_free(zName);
+  }
+  return i;
+}
+
+/* The table or view or trigger name is passed to this routine via tokens
+** pName1 and pName2. If the table name was fully qualified, for example:
+**
+** CREATE TABLE xxx.yyy (...);
+** 
+** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
+** the table name is not fully qualified, i.e.:
+**
+** CREATE TABLE yyy(...);
+**
+** Then pName1 is set to "yyy" and pName2 is "".
+**
+** This routine sets the *ppUnqual pointer to point at the token (pName1 or
+** pName2) that stores the unqualified table name.  The index of the
+** database "xxx" is returned.
+*/
+int sqlite3TwoPartName(
+  Parse *pParse,      /* Parsing and code generating context */
+  Token *pName1,      /* The "xxx" in the name "xxx.yyy" or "xxx" */
+  Token *pName2,      /* The "yyy" in the name "xxx.yyy" */
+  Token **pUnqual     /* Write the unqualified object name here */
+){
+  int iDb;                    /* Database holding the object */
+  sqlite3 *db = pParse->db;
+
+  if( pName2 && pName2->n>0 ){
+    assert( !db->init.busy );
+    *pUnqual = pName2;
+    iDb = sqlite3FindDb(db, pName1);
+    if( iDb<0 ){
+      sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
+      pParse->nErr++;
+      return -1;
+    }
+  }else{
+    assert( db->init.iDb==0 || db->init.busy );
+    iDb = db->init.iDb;
+    *pUnqual = pName1;
+  }
+  return iDb;
+}
+
+/*
+** This routine is used to check if the UTF-8 string zName is a legal
+** unqualified name for a new schema object (table, index, view or
+** trigger). All names are legal except those that begin with the string
+** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
+** is reserved for internal use.
+*/
+int sqlite3CheckObjectName(Parse *pParse, const char *zName){
+  if( !pParse->db->init.busy && pParse->nested==0 
+          && (pParse->db->flags & SQLITE_WriteSchema)==0
+          && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
+    sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
+    return SQLITE_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Begin constructing a new table representation in memory.  This is
+** the first of several action routines that get called in response
+** to a CREATE TABLE statement.  In particular, this routine is called
+** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
+** flag is true if the table should be stored in the auxiliary database
+** file instead of in the main database file.  This is normally the case
+** when the "TEMP" or "TEMPORARY" keyword occurs in between
+** CREATE and TABLE.
+**
+** The new table record is initialized and put in pParse->pNewTable.
+** As more of the CREATE TABLE statement is parsed, additional action
+** routines will be called to add more information to this record.
+** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
+** is called to complete the construction of the new table record.
+*/
+void sqlite3StartTable(
+  Parse *pParse,   /* Parser context */
+  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 */
+  int isVirtual,   /* True if this is a VIRTUAL table */
+  int noErr        /* Do nothing if table already exists */
+){
+  Table *pTable;
+  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
+  ** pName1 and pName2. If the table name was fully qualified, for example:
+  **
+  ** CREATE TABLE xxx.yyy (...);
+  ** 
+  ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
+  ** the table name is not fully qualified, i.e.:
+  **
+  ** CREATE TABLE yyy(...);
+  **
+  ** Then pName1 is set to "yyy" and pName2 is "".
+  **
+  ** The call below sets the pName pointer to point at the token (pName1 or
+  ** pName2) that stores the unqualified table name. The variable iDb is
+  ** set to the index of the database that the table or view is to be
+  ** created in.
+  */
+  iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
+  if( iDb<0 ) return;
+  if( !OMIT_TEMPDB && isTemp && iDb>1 ){
+    /* If creating a temp table, the name may not be qualified */
+    sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
+    return;
+  }
+  if( !OMIT_TEMPDB && isTemp ) iDb = 1;
+
+  pParse->sNameToken = *pName;
+  zName = sqlite3NameFromToken(db, pName);
+  if( zName==0 ) return;
+  if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
+    goto begin_table_error;
+  }
+  if( db->init.iDb==1 ) isTemp = 1;
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  assert( (isTemp & 1)==isTemp );
+  {
+    int code;
+    char *zDb = db->aDb[iDb].zName;
+    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
+      goto begin_table_error;
+    }
+    if( isView ){
+      if( !OMIT_TEMPDB && isTemp ){
+        code = SQLITE_CREATE_TEMP_VIEW;
+      }else{
+        code = SQLITE_CREATE_VIEW;
+      }
+    }else{
+      if( !OMIT_TEMPDB && isTemp ){
+        code = SQLITE_CREATE_TEMP_TABLE;
+      }else{
+        code = SQLITE_CREATE_TABLE;
+      }
+    }
+    if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
+      goto begin_table_error;
+    }
+  }
+#endif
+
+  /* Make sure the new table name does not collide with an existing
+  ** index or table name in the same database.  Issue an error message if
+  ** it does. The exception is if the statement being parsed was passed
+  ** to an sqlite3_declare_vtab() call. In that case only the column names
+  ** and types will be used, so there is no need to test for namespace
+  ** collisions.
+  */
+  if( !IN_DECLARE_VTAB ){
+    if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+      goto begin_table_error;
+    }
+    pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName);
+    if( pTable ){
+      if( !noErr ){
+        sqlite3ErrorMsg(pParse, "table %T already exists", pName);
+      }
+      goto begin_table_error;
+    }
+    if( 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 = sqlite3DbMallocZero(db, sizeof(Table));
+  if( pTable==0 ){
+    db->mallocFailed = 1;
+    pParse->rc = SQLITE_NOMEM;
+    pParse->nErr++;
+    goto begin_table_error;
+  }
+  pTable->zName = zName;
+  pTable->iPKey = -1;
+  pTable->pSchema = db->aDb[iDb].pSchema;
+  pTable->nRef = 1;
+  if( pParse->pNewTable ) sqlite3DeleteTable(pParse->pNewTable);
+  pParse->pNewTable = pTable;
+
+  /* If this is the magic sqlite_sequence table used by autoincrement,
+  ** then record a pointer to this table in the main database structure
+  ** so that INSERT can find the table easily.
+  */
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+  if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
+    pTable->pSchema->pSeqTab = pTable;
+  }
+#endif
+
+  /* Begin generating the code that will insert the table record into
+  ** the SQLITE_MASTER table.  Note in particular that we must go ahead
+  ** and allocate the record number for the table entry now.  Before any
+  ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
+  ** indices to be created and the table record must come before the 
+  ** indices.  Hence, the record number for the table must be allocated
+  ** now.
+  */
+  if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
+    int j1;
+    int fileFormat;
+    int reg1, reg2, reg3;
+    sqlite3BeginWriteOperation(pParse, 0, iDb);
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( isVirtual ){
+      sqlite3VdbeAddOp0(v, OP_VBegin);
+    }
+#endif
+
+    /* If the file format and encoding in the database have not been set, 
+    ** set them now.
+    */
+    reg1 = pParse->regRowid = ++pParse->nMem;
+    reg2 = pParse->regRoot = ++pParse->nMem;
+    reg3 = ++pParse->nMem;
+    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, 1);   /* file_format */
+    sqlite3VdbeUsesBtree(v, iDb);
+    j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);
+    fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
+                  1 : SQLITE_MAX_FILE_FORMAT;
+    sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 1, reg3);
+    sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 4, reg3);
+    sqlite3VdbeJumpHere(v, j1);
+
+    /* This just creates a place-holder record in the sqlite_master table.
+    ** The record created does not contain anything yet.  It will be replaced
+    ** by the real entry in code generated at sqlite3EndTable().
+    **
+    ** The rowid for the new entry is left on the top of the stack.
+    ** The rowid value is needed by the code that sqlite3EndTable will
+    ** generate.
+    */
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
+    if( isView || isVirtual ){
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
+    }else
+#endif
+    {
+      sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
+    }
+    sqlite3OpenMasterTable(pParse, iDb);
+    sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
+    sqlite3VdbeAddOp2(v, OP_Null, 0, reg3);
+    sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
+    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
+    sqlite3VdbeAddOp0(v, OP_Close);
+  }
+
+  /* Normal (non-error) return. */
+  return;
+
+  /* If an error occurs, we jump here */
+begin_table_error:
+  sqlite3_free(zName);
+  return;
+}
+
+/*
+** This macro is used to compare two strings in a case-insensitive manner.
+** It is slightly faster than calling sqlite3StrICmp() directly, but
+** produces larger code.
+**
+** WARNING: This macro is not compatible with the strcmp() family. It
+** returns true if the two strings are equal, otherwise false.
+*/
+#define STRICMP(x, y) (\
+sqlite3UpperToLower[*(unsigned char *)(x)]==   \
+sqlite3UpperToLower[*(unsigned char *)(y)]     \
+&& sqlite3StrICmp((x)+1,(y)+1)==0 )
+
+/*
+** Add a new column to the table currently being constructed.
+**
+** The parser calls this routine once for each column declaration
+** in a CREATE TABLE statement.  sqlite3StartTable() gets called
+** first to get things going.  Then this routine is called for each
+** column.
+*/
+void sqlite3AddColumn(Parse *pParse, Token *pName){
+  Table *p;
+  int i;
+  char *z;
+  Column *pCol;
+  if( (p = pParse->pNewTable)==0 ) return;
+  if( p->nCol+1>SQLITE_MAX_COLUMN ){
+    sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
+    return;
+  }
+  z = sqlite3NameFromToken(pParse->db, pName);
+  if( z==0 ) return;
+  for(i=0; i<p->nCol; i++){
+    if( STRICMP(z, p->aCol[i].zName) ){
+      sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
+      sqlite3_free(z);
+      return;
+    }
+  }
+  if( (p->nCol & 0x7)==0 ){
+    Column *aNew;
+    aNew = sqlite3DbRealloc(pParse->db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
+    if( aNew==0 ){
+      sqlite3_free(z);
+      return;
+    }
+    p->aCol = aNew;
+  }
+  pCol = &p->aCol[p->nCol];
+  memset(pCol, 0, sizeof(p->aCol[0]));
+  pCol->zName = z;
+ 
+  /* If there is no type specified, columns have the default affinity
+  ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
+  ** be called next to set pCol->affinity correctly.
+  */
+  pCol->affinity = SQLITE_AFF_NONE;
+  p->nCol++;
+}
+
+/*
+** This routine is called by the parser while in the middle of
+** parsing a CREATE TABLE statement.  A "NOT NULL" constraint has
+** been seen on a column.  This routine sets the notNull flag on
+** the column currently under construction.
+*/
+void sqlite3AddNotNull(Parse *pParse, int onError){
+  Table *p;
+  int i;
+  if( (p = pParse->pNewTable)==0 ) return;
+  i = p->nCol-1;
+  if( i>=0 ) p->aCol[i].notNull = onError;
+}
+
+/*
+** Scan the column type name zType (length nType) and return the
+** associated affinity type.
+**
+** This routine does a case-independent search of zType for the 
+** substrings in the following table. If one of the substrings is
+** found, the corresponding affinity is returned. If zType contains
+** more than one of the substrings, entries toward the top of 
+** the table take priority. For example, if zType is 'BLOBINT', 
+** SQLITE_AFF_INTEGER is returned.
+**
+** Substring     | Affinity
+** --------------------------------
+** 'INT'         | SQLITE_AFF_INTEGER
+** 'CHAR'        | SQLITE_AFF_TEXT
+** 'CLOB'        | SQLITE_AFF_TEXT
+** 'TEXT'        | SQLITE_AFF_TEXT
+** 'BLOB'        | SQLITE_AFF_NONE
+** 'REAL'        | SQLITE_AFF_REAL
+** 'FLOA'        | SQLITE_AFF_REAL
+** 'DOUB'        | SQLITE_AFF_REAL
+**
+** If none of the substrings in the above table are found,
+** SQLITE_AFF_NUMERIC is returned.
+*/
+char sqlite3AffinityType(const Token *pType){
+  u32 h = 0;
+  char aff = SQLITE_AFF_NUMERIC;
+  const unsigned char *zIn = pType->z;
+  const unsigned char *zEnd = &pType->z[pType->n];
+
+  while( zIn!=zEnd ){
+    h = (h<<8) + sqlite3UpperToLower[*zIn];
+    zIn++;
+    if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
+      aff = SQLITE_AFF_TEXT; 
+    }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */
+      aff = SQLITE_AFF_TEXT;
+    }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */
+      aff = SQLITE_AFF_TEXT;
+    }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */
+        && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
+      aff = SQLITE_AFF_NONE;
+#ifndef SQLITE_OMIT_FLOATING_POINT
+    }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */
+        && aff==SQLITE_AFF_NUMERIC ){
+      aff = SQLITE_AFF_REAL;
+    }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */
+        && aff==SQLITE_AFF_NUMERIC ){
+      aff = SQLITE_AFF_REAL;
+    }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */
+        && aff==SQLITE_AFF_NUMERIC ){
+      aff = SQLITE_AFF_REAL;
+#endif
+    }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */
+      aff = SQLITE_AFF_INTEGER;
+      break;
+    }
+  }
+
+  return aff;
+}
+
+/*
+** This routine is called by the parser while in the middle of
+** parsing a CREATE TABLE statement.  The pFirst token is the first
+** token in the sequence of tokens that describe the type of the
+** column currently under construction.   pLast is the last token
+** in the sequence.  Use this information to construct a string
+** that contains the typename of the column and store that string
+** in zType.
+*/ 
+void sqlite3AddColumnType(Parse *pParse, Token *pType){
+  Table *p;
+  int i;
+  Column *pCol;
+
+  if( (p = pParse->pNewTable)==0 ) return;
+  i = p->nCol-1;
+  if( i<0 ) return;
+  pCol = &p->aCol[i];
+  sqlite3_free(pCol->zType);
+  pCol->zType = sqlite3NameFromToken(pParse->db, pType);
+  pCol->affinity = sqlite3AffinityType(pType);
+}
+
+/*
+** The expression is the default value for the most recently added column
+** of the table currently under construction.
+**
+** Default value expressions must be constant.  Raise an exception if this
+** is not the case.
+**
+** This routine is called by the parser while in the middle of
+** parsing a CREATE TABLE statement.
+*/
+void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){
+  Table *p;
+  Column *pCol;
+  if( (p = pParse->pNewTable)!=0 ){
+    pCol = &(p->aCol[p->nCol-1]);
+    if( !sqlite3ExprIsConstantOrFunction(pExpr) ){
+      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
+          pCol->zName);
+    }else{
+      Expr *pCopy;
+      sqlite3 *db = pParse->db;
+      sqlite3ExprDelete(pCol->pDflt);
+      pCol->pDflt = pCopy = sqlite3ExprDup(db, pExpr);
+      if( pCopy ){
+        sqlite3TokenCopy(db, &pCopy->span, &pExpr->span);
+      }
+    }
+  }
+  sqlite3ExprDelete(pExpr);
+}
+
+/*
+** Designate the PRIMARY KEY for the table.  pList is a list of names 
+** of columns that form the primary key.  If pList is NULL, then the
+** most recently added column of the table is the primary key.
+**
+** A table can have at most one primary key.  If the table already has
+** a primary key (and this is the second primary key) then create an
+** error.
+**
+** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
+** then we will try to use that column as the rowid.  Set the Table.iPKey
+** field of the table under construction to be the index of the
+** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
+** no INTEGER PRIMARY KEY.
+**
+** If the key is not an INTEGER PRIMARY KEY, then create a unique
+** index for the key.  No index is created for INTEGER PRIMARY KEYs.
+*/
+void sqlite3AddPrimaryKey(
+  Parse *pParse,    /* Parsing context */
+  ExprList *pList,  /* List of field names to be indexed */
+  int onError,      /* What to do with a uniqueness conflict */
+  int autoInc,      /* True if the AUTOINCREMENT keyword is present */
+  int sortOrder     /* SQLITE_SO_ASC or SQLITE_SO_DESC */
+){
+  Table *pTab = pParse->pNewTable;
+  char *zType = 0;
+  int iCol = -1, i;
+  if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
+  if( pTab->hasPrimKey ){
+    sqlite3ErrorMsg(pParse, 
+      "table \"%s\" has more than one primary key", pTab->zName);
+    goto primary_key_exit;
+  }
+  pTab->hasPrimKey = 1;
+  if( pList==0 ){
+    iCol = pTab->nCol - 1;
+    pTab->aCol[iCol].isPrimKey = 1;
+  }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
+        && sortOrder==SQLITE_SO_ASC ){
+    pTab->iPKey = iCol;
+    pTab->keyConf = onError;
+    pTab->autoInc = autoInc;
+  }else if( autoInc ){
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+    sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
+       "INTEGER PRIMARY KEY");
+#endif
+  }else{
+    sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
+    pList = 0;
+  }
+
+primary_key_exit:
+  sqlite3ExprListDelete(pList);
+  return;
+}
+
+/*
+** Add a new CHECK constraint to the table currently under construction.
+*/
+void sqlite3AddCheckConstraint(
+  Parse *pParse,    /* Parsing context */
+  Expr *pCheckExpr  /* The check expression */
+){
+#ifndef SQLITE_OMIT_CHECK
+  Table *pTab = pParse->pNewTable;
+  sqlite3 *db = pParse->db;
+  if( pTab && !IN_DECLARE_VTAB ){
+    /* The CHECK expression must be duplicated so that tokens refer
+    ** to malloced space and not the (ephemeral) text of the CREATE TABLE
+    ** statement */
+    pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, 
+                                  sqlite3ExprDup(db, pCheckExpr));
+  }
+#endif
+  sqlite3ExprDelete(pCheckExpr);
+}
+
+/*
+** Set the collation function of the most recently parsed table column
+** to the CollSeq given.
+*/
+void sqlite3AddCollateType(Parse *pParse, Token *pToken){
+  Table *p;
+  int i;
+  char *zColl;              /* Dequoted name of collation sequence */
+
+  if( (p = pParse->pNewTable)==0 ) return;
+  i = p->nCol-1;
+
+  zColl = sqlite3NameFromToken(pParse->db, pToken);
+  if( !zColl ) return;
+
+  if( sqlite3LocateCollSeq(pParse, zColl, -1) ){
+    Index *pIdx;
+    p->aCol[i].zColl = zColl;
+  
+    /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
+    ** then an index may have been created on this column before the
+    ** collation type was added. Correct this if it is the case.
+    */
+    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
+      assert( pIdx->nColumn==1 );
+      if( pIdx->aiColumn[0]==i ){
+        pIdx->azColl[0] = p->aCol[i].zColl;
+      }
+    }
+  }else{
+    sqlite3_free(zColl);
+  }
+}
+
+/*
+** This function returns the collation sequence for database native text
+** encoding identified by the string zName, length nName.
+**
+** If the requested collation sequence is not available, or not available
+** in the database native encoding, the collation factory is invoked to
+** request it. If the collation factory does not supply such a sequence,
+** and the sequence is available in another text encoding, then that is
+** returned instead.
+**
+** If no versions of the requested collations sequence are available, or
+** another error occurs, NULL is returned and an error message written into
+** pParse.
+**
+** This routine is a wrapper around sqlite3FindCollSeq().  This routine
+** invokes the collation factory if the named collation cannot be found
+** and generates an error message.
+*/
+CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName){
+  sqlite3 *db = pParse->db;
+  u8 enc = ENC(db);
+  u8 initbusy = db->init.busy;
+  CollSeq *pColl;
+
+  pColl = sqlite3FindCollSeq(db, enc, zName, nName, initbusy);
+  if( !initbusy && (!pColl || !pColl->xCmp) ){
+    pColl = sqlite3GetCollSeq(db, pColl, zName, nName);
+    if( !pColl ){
+      if( nName<0 ){
+        nName = strlen(zName);
+      }
+      sqlite3ErrorMsg(pParse, "no such collation sequence: %.*s", nName, zName);
+      pColl = 0;
+    }
+  }
+
+  return pColl;
+}
+
+
+/*
+** Generate code that will increment the schema cookie.
+**
+** The schema cookie is used to determine when the schema for the
+** database changes.  After each schema change, the cookie value
+** changes.  When a process first reads the schema it records the
+** cookie.  Thereafter, whenever it goes to access the database,
+** it checks the cookie to make sure the schema has not changed
+** since it was last read.
+**
+** This plan is not completely bullet-proof.  It is possible for
+** the schema to change multiple times and for the cookie to be
+** set back to prior value.  But schema changes are infrequent
+** and the probability of hitting the same cookie value is only
+** 1 chance in 2^32.  So we're safe enough.
+*/
+void sqlite3ChangeCookie(Parse *pParse, int iDb){
+  int r1 = sqlite3GetTempReg(pParse);
+  sqlite3 *db = pParse->db;
+  Vdbe *v = pParse->pVdbe;
+  sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
+  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 0, r1);
+  sqlite3ReleaseTempReg(pParse, r1);
+}
+
+/*
+** Measure the number of characters needed to output the given
+** identifier.  The number returned includes any quotes used
+** but does not include the null terminator.
+**
+** The estimate is conservative.  It might be larger that what is
+** really needed.
+*/
+static int identLength(const char *z){
+  int n;
+  for(n=0; *z; n++, z++){
+    if( *z=='"' ){ n++; }
+  }
+  return n + 2;
+}
+
+/*
+** Write an identifier onto the end of the given string.  Add
+** quote characters as needed.
+*/
+static void identPut(char *z, int *pIdx, char *zSignedIdent){
+  unsigned char *zIdent = (unsigned char*)zSignedIdent;
+  int i, j, needQuote;
+  i = *pIdx;
+  for(j=0; zIdent[j]; j++){
+    if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
+  }
+  needQuote =  zIdent[j]!=0 || isdigit(zIdent[0])
+                  || sqlite3KeywordCode(zIdent, j)!=TK_ID;
+  if( needQuote ) z[i++] = '"';
+  for(j=0; zIdent[j]; j++){
+    z[i++] = zIdent[j];
+    if( zIdent[j]=='"' ) z[i++] = '"';
+  }
+  if( needQuote ) z[i++] = '"';
+  z[i] = 0;
+  *pIdx = i;
+}
+
+/*
+** Generate a CREATE TABLE statement appropriate for the given
+** table.  Memory to hold the text of the statement is obtained
+** from sqliteMalloc() and must be freed by the calling function.
+*/
+static char *createTableStmt(sqlite3 *db, Table *p, int isTemp){
+  int i, k, n;
+  char *zStmt;
+  char *zSep, *zSep2, *zEnd, *z;
+  Column *pCol;
+  n = 0;
+  for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
+    n += identLength(pCol->zName);
+    z = pCol->zType;
+    if( z ){
+      n += (strlen(z) + 1);
+    }
+  }
+  n += identLength(p->zName);
+  if( n<50 ){
+    zSep = "";
+    zSep2 = ",";
+    zEnd = ")";
+  }else{
+    zSep = "\n  ";
+    zSep2 = ",\n  ";
+    zEnd = "\n)";
+  }
+  n += 35 + 6*p->nCol;
+  zStmt = sqlite3_malloc( n );
+  if( zStmt==0 ){
+    db->mallocFailed = 1;
+    return 0;
+  }
+  sqlite3_snprintf(n, zStmt,
+                  !OMIT_TEMPDB&&isTemp ? "CREATE TEMP TABLE ":"CREATE TABLE ");
+  k = strlen(zStmt);
+  identPut(zStmt, &k, p->zName);
+  zStmt[k++] = '(';
+  for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
+    sqlite3_snprintf(n-k, &zStmt[k], zSep);
+    k += strlen(&zStmt[k]);
+    zSep = zSep2;
+    identPut(zStmt, &k, pCol->zName);
+    if( (z = pCol->zType)!=0 ){
+      zStmt[k++] = ' ';
+      assert( strlen(z)+k+1<=n );
+      sqlite3_snprintf(n-k, &zStmt[k], "%s", z);
+      k += strlen(z);
+    }
+  }
+  sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
+  return zStmt;
+}
+
+/*
+** This routine is called to report the final ")" that terminates
+** a CREATE TABLE statement.
+**
+** The table structure that other action routines have been building
+** is added to the internal hash tables, assuming no errors have
+** occurred.
+**
+** An entry for the table is made in the master table on disk, unless
+** this is a temporary table or db->init.busy==1.  When db->init.busy==1
+** it means we are reading the sqlite_master table because we just
+** connected to the database or because the sqlite_master table has
+** recently changed, so the entry for this table already exists in
+** the sqlite_master table.  We do not want to create it again.
+**
+** If the pSelect argument is not NULL, it means that this routine
+** was called to create a table generated from a 
+** "CREATE TABLE ... AS SELECT ..." statement.  The column names of
+** the new table will match the result set of the SELECT.
+*/
+void sqlite3EndTable(
+  Parse *pParse,          /* Parse context */
+  Token *pCons,           /* The ',' token after the last column defn. */
+  Token *pEnd,            /* The final ')' token in the CREATE TABLE */
+  Select *pSelect         /* Select from a "CREATE ... AS SELECT" */
+){
+  Table *p;
+  sqlite3 *db = pParse->db;
+  int iDb;
+
+  if( (pEnd==0 && pSelect==0) || pParse->nErr || db->mallocFailed ) {
+    return;
+  }
+  p = pParse->pNewTable;
+  if( p==0 ) return;
+
+  assert( !db->init.busy || !pSelect );
+
+  iDb = sqlite3SchemaToIndex(db, p->pSchema);
+
+#ifndef SQLITE_OMIT_CHECK
+  /* Resolve names in all CHECK constraint expressions.
+  */
+  if( p->pCheck ){
+    SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
+    NameContext sNC;                /* Name context for pParse->pNewTable */
+
+    memset(&sNC, 0, sizeof(sNC));
+    memset(&sSrc, 0, sizeof(sSrc));
+    sSrc.nSrc = 1;
+    sSrc.a[0].zName = p->zName;
+    sSrc.a[0].pTab = p;
+    sSrc.a[0].iCursor = -1;
+    sNC.pParse = pParse;
+    sNC.pSrcList = &sSrc;
+    sNC.isCheck = 1;
+    if( sqlite3ExprResolveNames(&sNC, p->pCheck) ){
+      return;
+    }
+  }
+#endif /* !defined(SQLITE_OMIT_CHECK) */
+
+  /* If the db->init.busy is 1 it means we are reading the SQL off the
+  ** "sqlite_master" or "sqlite_temp_master" table on the disk.
+  ** So do not write to the disk again.  Extract the root page number
+  ** for the table from the db->init.newTnum field.  (The page number
+  ** should have been put there by the sqliteOpenCb routine.)
+  */
+  if( db->init.busy ){
+    p->tnum = db->init.newTnum;
+  }
+
+  /* If not initializing, then create a record for the new table
+  ** in the SQLITE_MASTER table of the database.  The record number
+  ** for the new table entry should already be on the stack.
+  **
+  ** If this is a TEMPORARY table, write the entry into the auxiliary
+  ** file instead of into the main database file.
+  */
+  if( !db->init.busy ){
+    int n;
+    Vdbe *v;
+    char *zType;    /* "view" or "table" */
+    char *zType2;   /* "VIEW" or "TABLE" */
+    char *zStmt;    /* Text of the CREATE TABLE or CREATE VIEW statement */
+
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) return;
+
+    sqlite3VdbeAddOp1(v, OP_Close, 0);
+
+    /* Create the rootpage for the new table and push it onto the stack.
+    ** A view has no rootpage, so just push a zero onto the stack for
+    ** views.  Initialize zType at the same time.
+    */
+    if( p->pSelect==0 ){
+      /* A regular table */
+      zType = "table";
+      zType2 = "TABLE";
+#ifndef SQLITE_OMIT_VIEW
+    }else{
+      /* A view */
+      zType = "view";
+      zType2 = "VIEW";
+#endif
+    }
+
+    /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
+    ** statement to populate the new table. The root-page number for the
+    ** new table is on the top of the vdbe stack.
+    **
+    ** Once the SELECT has been coded by sqlite3Select(), it is in a
+    ** suitable state to query for the column names and types to be used
+    ** by the new table.
+    **
+    ** A shared-cache write-lock is not required to write to the new table,
+    ** as a schema-lock must have already been obtained to create it. Since
+    ** a schema-lock excludes all other database users, the write-lock would
+    ** be redundant.
+    */
+    if( pSelect ){
+      SelectDest dest;
+      Table *pSelTab;
+
+      sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
+      sqlite3VdbeChangeP5(v, 1);
+      pParse->nTab = 2;
+      sqlite3SelectDestInit(&dest, SRT_Table, 1);
+      sqlite3Select(pParse, pSelect, &dest, 0, 0, 0, 0);
+      sqlite3VdbeAddOp1(v, OP_Close, 1);
+      if( pParse->nErr==0 ){
+        pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSelect);
+        if( pSelTab==0 ) return;
+        assert( p->aCol==0 );
+        p->nCol = pSelTab->nCol;
+        p->aCol = pSelTab->aCol;
+        pSelTab->nCol = 0;
+        pSelTab->aCol = 0;
+        sqlite3DeleteTable(pSelTab);
+      }
+    }
+
+    /* Compute the complete text of the CREATE statement */
+    if( pSelect ){
+      zStmt = createTableStmt(db, p, p->pSchema==db->aDb[1].pSchema);
+    }else{
+      n = pEnd->z - pParse->sNameToken.z + 1;
+      zStmt = sqlite3MPrintf(db, 
+          "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
+      );
+    }
+
+    /* A slot for the record has already been allocated in the 
+    ** SQLITE_MASTER table.  We just need to update that slot with all
+    ** the information we've collected.  The rowid for the preallocated
+    ** slot is the 2nd item on the stack.  The top of the stack is the
+    ** root page for the new table (or a 0 if this is a view).
+    */
+    sqlite3NestedParse(pParse,
+      "UPDATE %Q.%s "
+         "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
+       "WHERE rowid=#%d",
+      db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
+      zType,
+      p->zName,
+      p->zName,
+      pParse->regRoot,
+      zStmt,
+      pParse->regRowid
+    );
+    sqlite3_free(zStmt);
+    sqlite3ChangeCookie(pParse, iDb);
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+    /* Check to see if we need to create an sqlite_sequence table for
+    ** keeping track of autoincrement keys.
+    */
+    if( p->autoInc ){
+      Db *pDb = &db->aDb[iDb];
+      if( pDb->pSchema->pSeqTab==0 ){
+        sqlite3NestedParse(pParse,
+          "CREATE TABLE %Q.sqlite_sequence(name,seq)",
+          pDb->zName
+        );
+      }
+    }
+#endif
+
+    /* Reparse everything to update our internal data structures */
+    sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0,
+        sqlite3MPrintf(db, "tbl_name='%q'",p->zName), P4_DYNAMIC);
+  }
+
+
+  /* Add the table to the in-memory representation of the database.
+  */
+  if( db->init.busy && pParse->nErr==0 ){
+    Table *pOld;
+    FKey *pFKey; 
+    Schema *pSchema = p->pSchema;
+    pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, strlen(p->zName)+1,p);
+    if( pOld ){
+      assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
+      db->mallocFailed = 1;
+      return;
+    }
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+    for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){
+      void *data;
+      int nTo = strlen(pFKey->zTo) + 1;
+      pFKey->pNextTo = sqlite3HashFind(&pSchema->aFKey, pFKey->zTo, nTo);
+      data = sqlite3HashInsert(&pSchema->aFKey, pFKey->zTo, nTo, pFKey);
+      if( data==(void *)pFKey ){
+        db->mallocFailed = 1;
+      }
+    }
+#endif
+    pParse->pNewTable = 0;
+    db->nTable++;
+    db->flags |= SQLITE_InternChanges;
+
+#ifndef SQLITE_OMIT_ALTERTABLE
+    if( !p->pSelect ){
+      const char *zName = (const char *)pParse->sNameToken.z;
+      int nName;
+      assert( !pSelect && pCons && pEnd );
+      if( pCons->z==0 ){
+        pCons = pEnd;
+      }
+      nName = (const char *)pCons->z - zName;
+      p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
+    }
+#endif
+  }
+}
+
+#ifndef SQLITE_OMIT_VIEW
+/*
+** The parser calls this routine in order to create a new VIEW
+*/
+void sqlite3CreateView(
+  Parse *pParse,     /* The parsing context */
+  Token *pBegin,     /* The CREATE token that begins the statement */
+  Token *pName1,     /* The token that holds the name of the view */
+  Token *pName2,     /* The token that holds the name of the view */
+  Select *pSelect,   /* A SELECT statement that will become the new view */
+  int isTemp,        /* TRUE for a TEMPORARY view */
+  int noErr          /* Suppress error messages if VIEW already exists */
+){
+  Table *p;
+  int n;
+  const unsigned char *z;
+  Token sEnd;
+  DbFixer sFix;
+  Token *pName;
+  int iDb;
+  sqlite3 *db = pParse->db;
+
+  if( pParse->nVar>0 ){
+    sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
+    sqlite3SelectDelete(pSelect);
+    return;
+  }
+  sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
+  p = pParse->pNewTable;
+  if( p==0 || pParse->nErr ){
+    sqlite3SelectDelete(pSelect);
+    return;
+  }
+  sqlite3TwoPartName(pParse, pName1, pName2, &pName);
+  iDb = sqlite3SchemaToIndex(db, p->pSchema);
+  if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
+    && sqlite3FixSelect(&sFix, pSelect)
+  ){
+    sqlite3SelectDelete(pSelect);
+    return;
+  }
+
+  /* Make a copy of the entire SELECT statement that defines the view.
+  ** This will force all the Expr.token.z values to be dynamically
+  ** allocated rather than point to the input string - which means that
+  ** they will persist after the current sqlite3_exec() call returns.
+  */
+  p->pSelect = sqlite3SelectDup(db, pSelect);
+  sqlite3SelectDelete(pSelect);
+  if( db->mallocFailed ){
+    return;
+  }
+  if( !db->init.busy ){
+    sqlite3ViewGetColumnNames(pParse, p);
+  }
+
+  /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
+  ** the end.
+  */
+  sEnd = pParse->sLastToken;
+  if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){
+    sEnd.z += sEnd.n;
+  }
+  sEnd.n = 0;
+  n = sEnd.z - pBegin->z;
+  z = (const unsigned char*)pBegin->z;
+  while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; }
+  sEnd.z = &z[n-1];
+  sEnd.n = 1;
+
+  /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
+  sqlite3EndTable(pParse, 0, &sEnd, 0);
+  return;
+}
+#endif /* SQLITE_OMIT_VIEW */
+
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
+/*
+** The Table structure pTable is really a VIEW.  Fill in the names of
+** the columns of the view in the pTable structure.  Return the number
+** of errors.  If an error is seen leave an error message in pParse->zErrMsg.
+*/
+int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
+  Table *pSelTab;   /* A fake table from which we get the result set */
+  Select *pSel;     /* Copy of the SELECT that implements the view */
+  int nErr = 0;     /* Number of errors encountered */
+  int n;            /* Temporarily holds the number of cursors assigned */
+  sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
+
+  assert( pTable );
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( sqlite3VtabCallConnect(pParse, pTable) ){
+    return SQLITE_ERROR;
+  }
+  if( IsVirtual(pTable) ) return 0;
+#endif
+
+#ifndef SQLITE_OMIT_VIEW
+  /* A positive nCol means the columns names for this view are
+  ** already known.
+  */
+  if( pTable->nCol>0 ) return 0;
+
+  /* A negative nCol is a special marker meaning that we are currently
+  ** trying to compute the column names.  If we enter this routine with
+  ** a negative nCol, it means two or more views form a loop, like this:
+  **
+  **     CREATE VIEW one AS SELECT * FROM two;
+  **     CREATE VIEW two AS SELECT * FROM one;
+  **
+  ** Actually, this error is caught previously and so the following test
+  ** should always fail.  But we will leave it in place just to be safe.
+  */
+  if( pTable->nCol<0 ){
+    sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
+    return 1;
+  }
+  assert( pTable->nCol>=0 );
+
+  /* If we get this far, it means we need to compute the table names.
+  ** Note that the call to sqlite3ResultSetOfSelect() will expand any
+  ** "*" elements in the results set of the view and will assign cursors
+  ** to the elements of the FROM clause.  But we do not want these changes
+  ** to be permanent.  So the computation is done on a copy of the SELECT
+  ** statement that defines the view.
+  */
+  assert( pTable->pSelect );
+  pSel = sqlite3SelectDup(db, pTable->pSelect);
+  if( pSel ){
+    n = pParse->nTab;
+    sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
+    pTable->nCol = -1;
+#ifndef SQLITE_OMIT_AUTHORIZATION
+    xAuth = db->xAuth;
+    db->xAuth = 0;
+    pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel);
+    db->xAuth = xAuth;
+#else
+    pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel);
+#endif
+    pParse->nTab = n;
+    if( pSelTab ){
+      assert( pTable->aCol==0 );
+      pTable->nCol = pSelTab->nCol;
+      pTable->aCol = pSelTab->aCol;
+      pSelTab->nCol = 0;
+      pSelTab->aCol = 0;
+      sqlite3DeleteTable(pSelTab);
+      pTable->pSchema->flags |= DB_UnresetViews;
+    }else{
+      pTable->nCol = 0;
+      nErr++;
+    }
+    sqlite3SelectDelete(pSel);
+  } else {
+    nErr++;
+  }
+#endif /* SQLITE_OMIT_VIEW */
+  return nErr;  
+}
+#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
+
+#ifndef SQLITE_OMIT_VIEW
+/*
+** Clear the column names from every VIEW in database idx.
+*/
+static void sqliteViewResetAll(sqlite3 *db, int idx){
+  HashElem *i;
+  if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
+  for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
+    Table *pTab = sqliteHashData(i);
+    if( pTab->pSelect ){
+      sqliteResetColumnNames(pTab);
+    }
+  }
+  DbClearProperty(db, idx, DB_UnresetViews);
+}
+#else
+# define sqliteViewResetAll(A,B)
+#endif /* SQLITE_OMIT_VIEW */
+
+/*
+** This function is called by the VDBE to adjust the internal schema
+** used by SQLite when the btree layer moves a table root page. The
+** root-page of a table or index in database iDb has changed from iFrom
+** to iTo.
+**
+** Ticket #1728:  The symbol table might still contain information
+** on tables and/or indices that are the process of being deleted.
+** If you are unlucky, one of those deleted indices or tables might
+** have the same rootpage number as the real table or index that is
+** being moved.  So we cannot stop searching after the first match 
+** because the first match might be for one of the deleted indices
+** or tables and not the table/index that is actually being moved.
+** We must continue looping until all tables and indices with
+** rootpage==iFrom have been converted to have a rootpage of iTo
+** in order to be certain that we got the right one.
+*/
+#ifndef SQLITE_OMIT_AUTOVACUUM
+void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){
+  HashElem *pElem;
+  Hash *pHash;
+
+  pHash = &pDb->pSchema->tblHash;
+  for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
+    Table *pTab = sqliteHashData(pElem);
+    if( pTab->tnum==iFrom ){
+      pTab->tnum = iTo;
+    }
+  }
+  pHash = &pDb->pSchema->idxHash;
+  for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
+    Index *pIdx = sqliteHashData(pElem);
+    if( pIdx->tnum==iFrom ){
+      pIdx->tnum = iTo;
+    }
+  }
+}
+#endif
+
+/*
+** Write code to erase the table with root-page iTable from database iDb.
+** Also write code to modify the sqlite_master table and internal schema
+** if a root-page of another table is moved by the btree-layer whilst
+** erasing iTable (this can happen with an auto-vacuum database).
+*/ 
+static void destroyRootPage(Parse *pParse, int iTable, int iDb){
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  int r1 = sqlite3GetTempReg(pParse);
+  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  /* OP_Destroy stores an in integer r1. If this integer
+  ** is non-zero, then it is the root page number of a table moved to
+  ** location iTable. The following code modifies the sqlite_master table to
+  ** reflect this.
+  **
+  ** The "#%d" in the SQL is a special constant that means whatever value
+  ** is on the top of the stack.  See sqlite3RegisterExpr().
+  */
+  sqlite3NestedParse(pParse, 
+     "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
+     pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
+#endif
+  sqlite3ReleaseTempReg(pParse, r1);
+}
+
+/*
+** Write VDBE code to erase table pTab and all associated indices on disk.
+** Code to update the sqlite_master tables and internal schema definitions
+** in case a root-page belonging to another table is moved by the btree layer
+** is also added (this can happen with an auto-vacuum database).
+*/
+static void destroyTable(Parse *pParse, Table *pTab){
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  Index *pIdx;
+  int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  destroyRootPage(pParse, pTab->tnum, iDb);
+  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    destroyRootPage(pParse, pIdx->tnum, iDb);
+  }
+#else
+  /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
+  ** is not defined), then it is important to call OP_Destroy on the
+  ** table and index root-pages in order, starting with the numerically 
+  ** largest root-page number. This guarantees that none of the root-pages
+  ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
+  ** following were coded:
+  **
+  ** OP_Destroy 4 0
+  ** ...
+  ** OP_Destroy 5 0
+  **
+  ** and root page 5 happened to be the largest root-page number in the
+  ** database, then root page 5 would be moved to page 4 by the 
+  ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
+  ** a free-list page.
+  */
+  int iTab = pTab->tnum;
+  int iDestroyed = 0;
+
+  while( 1 ){
+    Index *pIdx;
+    int iLargest = 0;
+
+    if( iDestroyed==0 || iTab<iDestroyed ){
+      iLargest = iTab;
+    }
+    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+      int iIdx = pIdx->tnum;
+      assert( pIdx->pSchema==pTab->pSchema );
+      if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
+        iLargest = iIdx;
+      }
+    }
+    if( iLargest==0 ){
+      return;
+    }else{
+      int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+      destroyRootPage(pParse, iLargest, iDb);
+      iDestroyed = iLargest;
+    }
+  }
+#endif
+}
+
+/*
+** This routine is called to do the work of a DROP TABLE statement.
+** pName is the name of the table to be dropped.
+*/
+void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
+  Table *pTab;
+  Vdbe *v;
+  sqlite3 *db = pParse->db;
+  int iDb;
+
+  if( pParse->nErr || db->mallocFailed ){
+    goto exit_drop_table;
+  }
+  assert( pName->nSrc==1 );
+  pTab = sqlite3LocateTable(pParse, isView, 
+                            pName->a[0].zName, pName->a[0].zDatabase);
+
+  if( pTab==0 ){
+    if( noErr ){
+      sqlite3ErrorClear(pParse);
+    }
+    goto exit_drop_table;
+  }
+  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+  assert( iDb>=0 && iDb<db->nDb );
+
+  /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
+  ** it is initialized.
+  */
+  if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
+    goto exit_drop_table;
+  }
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  {
+    int code;
+    const char *zTab = SCHEMA_TABLE(iDb);
+    const char *zDb = db->aDb[iDb].zName;
+    const char *zArg2 = 0;
+    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
+      goto exit_drop_table;
+    }
+    if( isView ){
+      if( !OMIT_TEMPDB && iDb==1 ){
+        code = SQLITE_DROP_TEMP_VIEW;
+      }else{
+        code = SQLITE_DROP_VIEW;
+      }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    }else if( IsVirtual(pTab) ){
+      code = SQLITE_DROP_VTABLE;
+      zArg2 = pTab->pMod->zName;
+#endif
+    }else{
+      if( !OMIT_TEMPDB && iDb==1 ){
+        code = SQLITE_DROP_TEMP_TABLE;
+      }else{
+        code = SQLITE_DROP_TABLE;
+      }
+    }
+    if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
+      goto exit_drop_table;
+    }
+    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
+      goto exit_drop_table;
+    }
+  }
+#endif
+  if( pTab->readOnly || pTab==db->aDb[iDb].pSchema->pSeqTab ){
+    sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
+    goto exit_drop_table;
+  }
+
+#ifndef SQLITE_OMIT_VIEW
+  /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
+  ** on a table.
+  */
+  if( isView && pTab->pSelect==0 ){
+    sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
+    goto exit_drop_table;
+  }
+  if( !isView && pTab->pSelect ){
+    sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
+    goto exit_drop_table;
+  }
+#endif
+
+  /* Generate code to remove the table from the master table
+  ** on disk.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    Trigger *pTrigger;
+    Db *pDb = &db->aDb[iDb];
+    sqlite3BeginWriteOperation(pParse, 1, iDb);
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( IsVirtual(pTab) ){
+      Vdbe *v = sqlite3GetVdbe(pParse);
+      if( v ){
+        sqlite3VdbeAddOp0(v, OP_VBegin);
+      }
+    }
+#endif
+
+    /* Drop all triggers associated with the table being dropped. Code
+    ** is generated to remove entries from sqlite_master and/or
+    ** sqlite_temp_master if required.
+    */
+    pTrigger = pTab->pTrigger;
+    while( pTrigger ){
+      assert( pTrigger->pSchema==pTab->pSchema || 
+          pTrigger->pSchema==db->aDb[1].pSchema );
+      sqlite3DropTriggerPtr(pParse, pTrigger);
+      pTrigger = pTrigger->pNext;
+    }
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+    /* Remove any entries of the sqlite_sequence table associated with
+    ** the table being dropped. This is done before the table is dropped
+    ** at the btree level, in case the sqlite_sequence table needs to
+    ** move as a result of the drop (can happen in auto-vacuum mode).
+    */
+    if( pTab->autoInc ){
+      sqlite3NestedParse(pParse,
+        "DELETE FROM %s.sqlite_sequence WHERE name=%Q",
+        pDb->zName, pTab->zName
+      );
+    }
+#endif
+
+    /* Drop all SQLITE_MASTER table and index entries that refer to the
+    ** table. The program name loops through the master table and deletes
+    ** every row that refers to a table of the same name as the one being
+    ** dropped. Triggers are handled seperately because a trigger can be
+    ** created in the temp database that refers to a table in another
+    ** database.
+    */
+    sqlite3NestedParse(pParse, 
+        "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
+        pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
+    if( !isView && !IsVirtual(pTab) ){
+      destroyTable(pParse, pTab);
+    }
+
+    /* Remove the table entry from SQLite's internal schema and modify
+    ** the schema cookie.
+    */
+    if( IsVirtual(pTab) ){
+      sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
+    }
+    sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
+    sqlite3ChangeCookie(pParse, iDb);
+  }
+  sqliteViewResetAll(db, iDb);
+
+exit_drop_table:
+  sqlite3SrcListDelete(pName);
+}
+
+/*
+** This routine is called to create a new foreign key on the table
+** currently under construction.  pFromCol determines which columns
+** in the current table point to the foreign key.  If pFromCol==0 then
+** connect the key to the last column inserted.  pTo is the name of
+** the table referred to.  pToCol is a list of tables in the other
+** pTo table that the foreign key points to.  flags contains all
+** information about the conflict resolution algorithms specified
+** in the ON DELETE, ON UPDATE and ON INSERT clauses.
+**
+** An FKey structure is created and added to the table currently
+** under construction in the pParse->pNewTable field.  The new FKey
+** is not linked into db->aFKey at this point - that does not happen
+** until sqlite3EndTable().
+**
+** The foreign key is set for IMMEDIATE processing.  A subsequent call
+** to sqlite3DeferForeignKey() might change this to DEFERRED.
+*/
+void sqlite3CreateForeignKey(
+  Parse *pParse,       /* Parsing context */
+  ExprList *pFromCol,  /* Columns in this table that point to other table */
+  Token *pTo,          /* Name of the other table */
+  ExprList *pToCol,    /* Columns in the other table */
+  int flags            /* Conflict resolution algorithms. */
+){
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+  FKey *pFKey = 0;
+  Table *p = pParse->pNewTable;
+  int nByte;
+  int i;
+  int nCol;
+  char *z;
+
+  assert( pTo!=0 );
+  if( p==0 || pParse->nErr || IN_DECLARE_VTAB ) goto fk_end;
+  if( pFromCol==0 ){
+    int iCol = p->nCol-1;
+    if( iCol<0 ) goto fk_end;
+    if( pToCol && pToCol->nExpr!=1 ){
+      sqlite3ErrorMsg(pParse, "foreign key on %s"
+         " should reference only one column of table %T",
+         p->aCol[iCol].zName, pTo);
+      goto fk_end;
+    }
+    nCol = 1;
+  }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
+    sqlite3ErrorMsg(pParse,
+        "number of columns in foreign key does not match the number of "
+        "columns in the referenced table");
+    goto fk_end;
+  }else{
+    nCol = pFromCol->nExpr;
+  }
+  nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1;
+  if( pToCol ){
+    for(i=0; i<pToCol->nExpr; i++){
+      nByte += strlen(pToCol->a[i].zName) + 1;
+    }
+  }
+  pFKey = sqlite3DbMallocZero(pParse->db, nByte );
+  if( pFKey==0 ){
+    goto fk_end;
+  }
+  pFKey->pFrom = p;
+  pFKey->pNextFrom = p->pFKey;
+  z = (char*)&pFKey[1];
+  pFKey->aCol = (struct sColMap*)z;
+  z += sizeof(struct sColMap)*nCol;
+  pFKey->zTo = z;
+  memcpy(z, pTo->z, pTo->n);
+  z[pTo->n] = 0;
+  z += pTo->n+1;
+  pFKey->pNextTo = 0;
+  pFKey->nCol = nCol;
+  if( pFromCol==0 ){
+    pFKey->aCol[0].iFrom = p->nCol-1;
+  }else{
+    for(i=0; i<nCol; i++){
+      int j;
+      for(j=0; j<p->nCol; j++){
+        if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
+          pFKey->aCol[i].iFrom = j;
+          break;
+        }
+      }
+      if( j>=p->nCol ){
+        sqlite3ErrorMsg(pParse, 
+          "unknown column \"%s\" in foreign key definition", 
+          pFromCol->a[i].zName);
+        goto fk_end;
+      }
+    }
+  }
+  if( pToCol ){
+    for(i=0; i<nCol; i++){
+      int n = strlen(pToCol->a[i].zName);
+      pFKey->aCol[i].zCol = z;
+      memcpy(z, pToCol->a[i].zName, n);
+      z[n] = 0;
+      z += n+1;
+    }
+  }
+  pFKey->isDeferred = 0;
+  pFKey->deleteConf = flags & 0xff;
+  pFKey->updateConf = (flags >> 8 ) & 0xff;
+  pFKey->insertConf = (flags >> 16 ) & 0xff;
+
+  /* Link the foreign key to the table as the last step.
+  */
+  p->pFKey = pFKey;
+  pFKey = 0;
+
+fk_end:
+  sqlite3_free(pFKey);
+#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
+  sqlite3ExprListDelete(pFromCol);
+  sqlite3ExprListDelete(pToCol);
+}
+
+/*
+** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
+** clause is seen as part of a foreign key definition.  The isDeferred
+** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
+** The behavior of the most recently created foreign key is adjusted
+** accordingly.
+*/
+void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+  Table *pTab;
+  FKey *pFKey;
+  if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
+  pFKey->isDeferred = isDeferred;
+#endif
+}
+
+/*
+** Generate code that will erase and refill index *pIdx.  This is
+** used to initialize a newly created index or to recompute the
+** content of an index in response to a REINDEX command.
+**
+** if memRootPage is not negative, it means that the index is newly
+** created.  The register specified by memRootPage contains the
+** root page number of the index.  If memRootPage is negative, then
+** the index already exists and must be cleared before being refilled and
+** the root page number of the index is taken from pIndex->tnum.
+*/
+static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
+  Table *pTab = pIndex->pTable;  /* The table that is indexed */
+  int iTab = pParse->nTab;       /* Btree cursor used for pTab */
+  int iIdx = pParse->nTab+1;     /* Btree cursor used for pIndex */
+  int addr1;                     /* Address of top of loop */
+  int tnum;                      /* Root page of index */
+  Vdbe *v;                       /* Generate code into this virtual machine */
+  KeyInfo *pKey;                 /* KeyInfo for index */
+  int regIdxKey;                 /* Registers containing the index key */
+  int regRecord;                 /* Register holding assemblied index record */
+  sqlite3 *db = pParse->db;      /* The database connection */
+  int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
+      db->aDb[iDb].zName ) ){
+    return;
+  }
+#endif
+
+  /* Require a write-lock on the table to perform this operation */
+  sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
+
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ) return;
+  if( memRootPage>=0 ){
+    tnum = memRootPage;
+  }else{
+    tnum = pIndex->tnum;
+    sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
+  }
+  pKey = sqlite3IndexKeyinfo(pParse, pIndex);
+  sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb, 
+                    (char *)pKey, P4_KEYINFO_HANDOFF);
+  if( memRootPage>=0 ){
+    sqlite3VdbeChangeP5(v, 1);
+  }
+  sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
+  addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
+  regRecord = sqlite3GetTempReg(pParse);
+  regIdxKey = sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord);
+  if( pIndex->onError!=OE_None ){
+    int j1, j2;
+    int regRowid;
+
+    regRowid = regIdxKey + pIndex->nColumn;
+    j1 = sqlite3VdbeAddOp3(v, OP_IsNull, regIdxKey, 0, pIndex->nColumn);
+    j2 = sqlite3VdbeAddOp4(v, OP_IsUnique, iIdx,
+                           0, regRowid, (char*)regRecord, P4_INT32);
+    sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, OE_Abort, 0,
+                    "indexed columns are not unique", P4_STATIC);
+    sqlite3VdbeJumpHere(v, j1);
+    sqlite3VdbeJumpHere(v, j2);
+  }
+  sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
+  sqlite3ReleaseTempReg(pParse, regRecord);
+  sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
+  sqlite3VdbeJumpHere(v, addr1);
+  sqlite3VdbeAddOp1(v, OP_Close, iTab);
+  sqlite3VdbeAddOp1(v, OP_Close, iIdx);
+}
+
+/*
+** 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 
+** be NULL for a primary key or an index that is created to satisfy a
+** UNIQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
+** as the table to be indexed.  pParse->pNewTable is a table that is
+** currently being constructed by a CREATE TABLE statement.
+**
+** pList is a list of columns to be indexed.  pList will be NULL if this
+** is a primary key or unique-constraint on the most recent column added
+** to the table currently under construction.  
+*/
+void sqlite3CreateIndex(
+  Parse *pParse,     /* All information about this parse */
+  Token *pName1,     /* First part of index name. May be NULL */
+  Token *pName2,     /* Second part of index name. May be NULL */
+  SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
+  ExprList *pList,   /* A list of columns to be indexed */
+  int onError,       /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
+  Token *pStart,     /* The CREATE token that begins this statement */
+  Token *pEnd,       /* The ")" that closes the CREATE INDEX statement */
+  int sortOrder,     /* Sort order of primary key when pList==NULL */
+  int ifNotExist     /* Omit error if index already exists */
+){
+  Table *pTab = 0;     /* Table to be indexed */
+  Index *pIndex = 0;   /* The index to be created */
+  char *zName = 0;     /* Name of the index */
+  int nName;           /* Number of characters in zName */
+  int i, j;
+  Token nullId;        /* Fake token for an empty ID list */
+  DbFixer sFix;        /* For assigning database names to pTable */
+  int sortOrderMask;   /* 1 to honor DESC in index.  0 to ignore. */
+  sqlite3 *db = pParse->db;
+  Db *pDb;             /* The specific table containing the indexed database */
+  int iDb;             /* Index of the database that is being written */
+  Token *pName = 0;    /* Unqualified name of the index to create */
+  struct ExprList_item *pListItem; /* For looping over pList */
+  int nCol;
+  int nExtra = 0;
+  char *zExtra;
+
+  if( pParse->nErr || db->mallocFailed || IN_DECLARE_VTAB ){
+    goto exit_create_index;
+  }
+
+  /*
+  ** Find the table that is to be indexed.  Return early if not found.
+  */
+  if( pTblName!=0 ){
+
+    /* Use the two-part index name to determine the database 
+    ** to search for the table. 'Fix' the table name to this db
+    ** before looking up the table.
+    */
+    assert( pName1 && pName2 );
+    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
+    if( iDb<0 ) goto exit_create_index;
+
+#ifndef SQLITE_OMIT_TEMPDB
+    /* If the index name was unqualified, check if the the table
+    ** is a temp table. If so, set the database to 1. Do not do this
+    ** if initialising a database schema.
+    */
+    if( !db->init.busy ){
+      pTab = sqlite3SrcListLookup(pParse, pTblName);
+      if( pName2 && pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
+        iDb = 1;
+      }
+    }
+#endif
+
+    if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
+        sqlite3FixSrcList(&sFix, pTblName)
+    ){
+      /* Because the parser constructs pTblName from a single identifier,
+      ** sqlite3FixSrcList can never fail. */
+      assert(0);
+    }
+    pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName, 
+        pTblName->a[0].zDatabase);
+    if( !pTab ) goto exit_create_index;
+    assert( db->aDb[iDb].pSchema==pTab->pSchema );
+  }else{
+    assert( pName==0 );
+    pTab = pParse->pNewTable;
+    if( !pTab ) goto exit_create_index;
+    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+  }
+  pDb = &db->aDb[iDb];
+
+  if( pTab==0 || pParse->nErr ) goto exit_create_index;
+  if( pTab->readOnly ){
+    sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
+    goto exit_create_index;
+  }
+#ifndef SQLITE_OMIT_VIEW
+  if( pTab->pSelect ){
+    sqlite3ErrorMsg(pParse, "views may not be indexed");
+    goto exit_create_index;
+  }
+#endif
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( IsVirtual(pTab) ){
+    sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
+    goto exit_create_index;
+  }
+#endif
+
+  /*
+  ** Find the name of the index.  Make sure there is not already another
+  ** index or table with the same name.  
+  **
+  ** Exception:  If we are reading the names of permanent indices from the
+  ** sqlite_master table (because some other process changed the schema) and
+  ** one of the index names collides with the name of a temporary table or
+  ** index, then we will continue to process this index.
+  **
+  ** If pName==0 it means that we are
+  ** dealing with a primary key or UNIQUE constraint.  We have to invent our
+  ** own name.
+  */
+  if( pName ){
+    zName = sqlite3NameFromToken(db, 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 ){
+      if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index;
+      if( sqlite3FindTable(db, zName, 0)!=0 ){
+        sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
+        goto exit_create_index;
+      }
+    }
+    if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
+      if( !ifNotExist ){
+        sqlite3ErrorMsg(pParse, "index %s already exists", zName);
+      }
+      goto exit_create_index;
+    }
+  }else{
+    char zBuf[30];
+    int n;
+    Index *pLoop;
+    for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"_%d",n);
+    zName = 0;
+    sqlite3SetString(&zName, "sqlite_autoindex_", pTab->zName, zBuf, (char*)0);
+    if( zName==0 ){
+      db->mallocFailed = 1;
+      goto exit_create_index;
+    }
+  }
+
+  /* Check for authorization to create an index.
+  */
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  {
+    const char *zDb = pDb->zName;
+    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
+      goto exit_create_index;
+    }
+    i = SQLITE_CREATE_INDEX;
+    if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
+    if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
+      goto exit_create_index;
+    }
+  }
+#endif
+
+  /* If pList==0, it means this routine was called to make a primary
+  ** key out of the last column added to the table under construction.
+  ** So create a fake list to simulate this.
+  */
+  if( pList==0 ){
+    nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName;
+    nullId.n = strlen((char*)nullId.z);
+    pList = sqlite3ExprListAppend(pParse, 0, 0, &nullId);
+    if( pList==0 ) goto exit_create_index;
+    pList->a[0].sortOrder = sortOrder;
+  }
+
+  /* Figure out how many bytes of space are required to store explicitly
+  ** specified collation sequence names.
+  */
+  for(i=0; i<pList->nExpr; i++){
+    Expr *pExpr = pList->a[i].pExpr;
+    if( pExpr ){
+      nExtra += (1 + strlen(pExpr->pColl->zName));
+    }
+  }
+
+  /* 
+  ** Allocate the index structure. 
+  */
+  nName = strlen(zName);
+  nCol = pList->nExpr;
+  pIndex = sqlite3DbMallocZero(db, 
+      sizeof(Index) +              /* Index structure  */
+      sizeof(int)*nCol +           /* Index.aiColumn   */
+      sizeof(int)*(nCol+1) +       /* Index.aiRowEst   */
+      sizeof(char *)*nCol +        /* Index.azColl     */
+      sizeof(u8)*nCol +            /* Index.aSortOrder */
+      nName + 1 +                  /* Index.zName      */
+      nExtra                       /* Collation sequence names */
+  );
+  if( db->mallocFailed ){
+    goto exit_create_index;
+  }
+  pIndex->azColl = (char**)(&pIndex[1]);
+  pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
+  pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]);
+  pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]);
+  pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
+  zExtra = (char *)(&pIndex->zName[nName+1]);
+  memcpy(pIndex->zName, zName, nName+1);
+  pIndex->pTable = pTab;
+  pIndex->nColumn = pList->nExpr;
+  pIndex->onError = onError;
+  pIndex->autoIndex = pName==0;
+  pIndex->pSchema = db->aDb[iDb].pSchema;
+
+  /* Check to see if we should honor DESC requests on index columns
+  */
+  if( pDb->pSchema->file_format>=4 ){
+    sortOrderMask = -1;   /* Honor DESC */
+  }else{
+    sortOrderMask = 0;    /* Ignore DESC */
+  }
+
+  /* Scan the names of the columns of the table to be indexed and
+  ** load the column indices into the Index structure.  Report an error
+  ** if any column is not found.
+  */
+  for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
+    const char *zColName = pListItem->zName;
+    Column *pTabCol;
+    int requestedSortOrder;
+    char *zColl;                   /* Collation sequence name */
+
+    for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
+      if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
+    }
+    if( j>=pTab->nCol ){
+      sqlite3ErrorMsg(pParse, "table %s has no column named %s",
+        pTab->zName, zColName);
+      goto exit_create_index;
+    }
+    /* TODO:  Add a test to make sure that the same column is not named
+    ** more than once within the same index.  Only the first instance of
+    ** the column will ever be used by the optimizer.  Note that using the
+    ** same column more than once cannot be an error because that would 
+    ** break backwards compatibility - it needs to be a warning.
+    */
+    pIndex->aiColumn[i] = j;
+    if( pListItem->pExpr ){
+      assert( pListItem->pExpr->pColl );
+      zColl = zExtra;
+      sqlite3_snprintf(nExtra, zExtra, "%s", pListItem->pExpr->pColl->zName);
+      zExtra += (strlen(zColl) + 1);
+    }else{
+      zColl = pTab->aCol[j].zColl;
+      if( !zColl ){
+        zColl = db->pDfltColl->zName;
+      }
+    }
+    if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl, -1) ){
+      goto exit_create_index;
+    }
+    pIndex->azColl[i] = zColl;
+    requestedSortOrder = pListItem->sortOrder & sortOrderMask;
+    pIndex->aSortOrder[i] = requestedSortOrder;
+  }
+  sqlite3DefaultRowEst(pIndex);
+
+  if( pTab==pParse->pNewTable ){
+    /* This routine has been called to create an automatic index as a
+    ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
+    ** a PRIMARY KEY or UNIQUE clause following the column definitions.
+    ** i.e. one of:
+    **
+    ** CREATE TABLE t(x PRIMARY KEY, y);
+    ** CREATE TABLE t(x, y, UNIQUE(x, y));
+    **
+    ** Either way, check to see if the table already has such an index. If
+    ** so, don't bother creating this one. This only applies to
+    ** automatically created indices. Users can do as they wish with
+    ** explicit indices.
+    */
+    Index *pIdx;
+    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+      int k;
+      assert( pIdx->onError!=OE_None );
+      assert( pIdx->autoIndex );
+      assert( pIndex->onError!=OE_None );
+
+      if( pIdx->nColumn!=pIndex->nColumn ) continue;
+      for(k=0; k<pIdx->nColumn; k++){
+        const char *z1 = pIdx->azColl[k];
+        const char *z2 = pIndex->azColl[k];
+        if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
+        if( pIdx->aSortOrder[k]!=pIndex->aSortOrder[k] ) break;
+        if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break;
+      }
+      if( k==pIdx->nColumn ){
+        if( pIdx->onError!=pIndex->onError ){
+          /* This constraint creates the same index as a previous
+          ** constraint specified somewhere in the CREATE TABLE statement.
+          ** However the ON CONFLICT clauses are different. If both this 
+          ** constraint and the previous equivalent constraint have explicit
+          ** ON CONFLICT clauses this is an error. Otherwise, use the
+          ** explicitly specified behaviour for the index.
+          */
+          if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
+            sqlite3ErrorMsg(pParse, 
+                "conflicting ON CONFLICT clauses specified", 0);
+          }
+          if( pIdx->onError==OE_Default ){
+            pIdx->onError = pIndex->onError;
+          }
+        }
+        goto exit_create_index;
+      }
+    }
+  }
+
+  /* Link the new Index structure to its table and to the other
+  ** in-memory database structures. 
+  */
+  if( db->init.busy ){
+    Index *p;
+    p = sqlite3HashInsert(&pIndex->pSchema->idxHash, 
+                         pIndex->zName, strlen(pIndex->zName)+1, pIndex);
+    if( p ){
+      assert( p==pIndex );  /* Malloc must have failed */
+      db->mallocFailed = 1;
+      goto exit_create_index;
+    }
+    db->flags |= SQLITE_InternChanges;
+    if( pTblName!=0 ){
+      pIndex->tnum = db->init.newTnum;
+    }
+  }
+
+  /* If the db->init.busy is 0 then create the index on disk.  This
+  ** involves writing the index into the master table and filling in the
+  ** index with the current table contents.
+  **
+  ** The db->init.busy is 0 when the user first enters a CREATE INDEX 
+  ** command.  db->init.busy is 1 when a database is opened and 
+  ** CREATE INDEX statements are read out of the master table.  In
+  ** the latter case the index already exists on disk, which is why
+  ** we don't want to recreate it.
+  **
+  ** If pTblName==0 it means this index is generated as a primary key
+  ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
+  ** has just been created, it contains no data and the index initialization
+  ** step can be skipped.
+  */
+  else if( db->init.busy==0 ){
+    Vdbe *v;
+    char *zStmt;
+    int iMem = ++pParse->nMem;
+
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) goto exit_create_index;
+
+
+    /* Create the rootpage for the index
+    */
+    sqlite3BeginWriteOperation(pParse, 1, iDb);
+    sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
+
+    /* Gather the complete text of the CREATE INDEX statement into
+    ** the zStmt variable
+    */
+    if( pStart && pEnd ){
+      /* A named index with an explicit CREATE INDEX statement */
+      zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
+        onError==OE_None ? "" : " UNIQUE",
+        pEnd->z - pName->z + 1,
+        pName->z);
+    }else{
+      /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
+      /* zStmt = sqlite3MPrintf(""); */
+      zStmt = 0;
+    }
+
+    /* Add an entry in sqlite_master for this index
+    */
+    sqlite3NestedParse(pParse, 
+        "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
+        db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
+        pIndex->zName,
+        pTab->zName,
+        iMem,
+        zStmt
+    );
+    sqlite3_free(zStmt);
+
+    /* Fill the index with data and reparse the schema. Code an OP_Expire
+    ** to invalidate all pre-compiled statements.
+    */
+    if( pTblName ){
+      sqlite3RefillIndex(pParse, pIndex, iMem);
+      sqlite3ChangeCookie(pParse, iDb);
+      sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0,
+         sqlite3MPrintf(db, "name='%q'", pIndex->zName), P4_DYNAMIC);
+      sqlite3VdbeAddOp1(v, OP_Expire, 0);
+    }
+  }
+
+  /* When adding an index to the list of indices for a table, make
+  ** sure all indices labeled OE_Replace come after all those labeled
+  ** OE_Ignore.  This is necessary for the correct operation of UPDATE
+  ** and INSERT.
+  */
+  if( db->init.busy || pTblName==0 ){
+    if( onError!=OE_Replace || pTab->pIndex==0
+         || pTab->pIndex->onError==OE_Replace){
+      pIndex->pNext = pTab->pIndex;
+      pTab->pIndex = pIndex;
+    }else{
+      Index *pOther = pTab->pIndex;
+      while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
+        pOther = pOther->pNext;
+      }
+      pIndex->pNext = pOther->pNext;
+      pOther->pNext = pIndex;
+    }
+    pIndex = 0;
+  }
+
+  /* Clean up before exiting */
+exit_create_index:
+  if( pIndex ){
+    freeIndex(pIndex);
+  }
+  sqlite3ExprListDelete(pList);
+  sqlite3SrcListDelete(pTblName);
+  sqlite3_free(zName);
+  return;
+}
+
+/*
+** Generate code to make sure the file format number is at least minFormat.
+** The generated code will increase the file format number if necessary.
+*/
+void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
+  Vdbe *v;
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    int r1 = sqlite3GetTempReg(pParse);
+    int r2 = sqlite3GetTempReg(pParse);
+    int j1;
+    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, 1);
+    sqlite3VdbeUsesBtree(v, iDb);
+    sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
+    j1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 1, r2);
+    sqlite3VdbeJumpHere(v, j1);
+    sqlite3ReleaseTempReg(pParse, r1);
+    sqlite3ReleaseTempReg(pParse, r2);
+  }
+}
+
+/*
+** Fill the Index.aiRowEst[] array with default information - information
+** to be used when we have not run the ANALYZE command.
+**
+** aiRowEst[0] is suppose to contain the number of elements in the index.
+** Since we do not know, guess 1 million.  aiRowEst[1] is an estimate of the
+** number of rows in the table that match any particular value of the
+** first column of the index.  aiRowEst[2] is an estimate of the number
+** of rows that match any particular combiniation of the first 2 columns
+** of the index.  And so forth.  It must always be the case that
+*
+**           aiRowEst[N]<=aiRowEst[N-1]
+**           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){
+  unsigned *a = pIdx->aiRowEst;
+  int i;
+  assert( a!=0 );
+  a[0] = 1000000;
+  for(i=pIdx->nColumn; i>=5; i--){
+    a[i] = 5;
+  }
+  while( i>=1 ){
+    a[i] = 11 - i;
+    i--;
+  }
+  if( pIdx->onError!=OE_None ){
+    a[pIdx->nColumn] = 1;
+  }
+}
+
+/*
+** This routine will drop an existing named index.  This routine
+** implements the DROP INDEX statement.
+*/
+void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
+  Index *pIndex;
+  Vdbe *v;
+  sqlite3 *db = pParse->db;
+  int iDb;
+
+  if( pParse->nErr || db->mallocFailed ){
+    goto exit_drop_index;
+  }
+  assert( pName->nSrc==1 );
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    goto exit_drop_index;
+  }
+  pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
+  if( pIndex==0 ){
+    if( !ifExists ){
+      sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
+    }
+    pParse->checkSchema = 1;
+    goto exit_drop_index;
+  }
+  if( pIndex->autoIndex ){
+    sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
+      "or PRIMARY KEY constraint cannot be dropped", 0);
+    goto exit_drop_index;
+  }
+  iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  {
+    int code = SQLITE_DROP_INDEX;
+    Table *pTab = pIndex->pTable;
+    const char *zDb = db->aDb[iDb].zName;
+    const char *zTab = SCHEMA_TABLE(iDb);
+    if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
+      goto exit_drop_index;
+    }
+    if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
+    if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
+      goto exit_drop_index;
+    }
+  }
+#endif
+
+  /* Generate code to remove the index and from the master table */
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3BeginWriteOperation(pParse, 1, iDb);
+    sqlite3NestedParse(pParse,
+       "DELETE FROM %Q.%s WHERE name=%Q",
+       db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
+       pIndex->zName
+    );
+    sqlite3ChangeCookie(pParse, iDb);
+    destroyRootPage(pParse, pIndex->tnum, iDb);
+    sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
+  }
+
+exit_drop_index:
+  sqlite3SrcListDelete(pName);
+}
+
+/*
+** pArray is a pointer to an array of objects.  Each object in the
+** array is szEntry bytes in size.  This routine allocates a new
+** object on the end of the array.
+**
+** *pnEntry is the number of entries already in use.  *pnAlloc is
+** the previously allocated size of the array.  initSize is the
+** suggested initial array size allocation.
+**
+** The index of the new entry is returned in *pIdx.
+**
+** This routine returns a pointer to the array of objects.  This
+** might be the same as the pArray parameter or it might be a different
+** pointer if the array was resized.
+*/
+void *sqlite3ArrayAllocate(
+  sqlite3 *db,      /* Connection to notify of malloc failures */
+  void *pArray,     /* Array of objects.  Might be reallocated */
+  int szEntry,      /* Size of each object in the array */
+  int initSize,     /* Suggested initial allocation, in elements */
+  int *pnEntry,     /* Number of objects currently in use */
+  int *pnAlloc,     /* Current size of the allocation, in elements */
+  int *pIdx         /* Write the index of a new slot here */
+){
+  char *z;
+  if( *pnEntry >= *pnAlloc ){
+    void *pNew;
+    int newSize;
+    newSize = (*pnAlloc)*2 + initSize;
+    pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry);
+    if( pNew==0 ){
+      *pIdx = -1;
+      return pArray;
+    }
+    *pnAlloc = newSize;
+    pArray = pNew;
+  }
+  z = (char*)pArray;
+  memset(&z[*pnEntry * szEntry], 0, szEntry);
+  *pIdx = *pnEntry;
+  ++*pnEntry;
+  return pArray;
+}
+
+/*
+** 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(sqlite3 *db, IdList *pList, Token *pToken){
+  int i;
+  if( pList==0 ){
+    pList = sqlite3DbMallocZero(db, sizeof(IdList) );
+    if( pList==0 ) return 0;
+    pList->nAlloc = 0;
+  }
+  pList->a = sqlite3ArrayAllocate(
+      db,
+      pList->a,
+      sizeof(pList->a[0]),
+      5,
+      &pList->nId,
+      &pList->nAlloc,
+      &i
+  );
+  if( i<0 ){
+    sqlite3IdListDelete(pList);
+    return 0;
+  }
+  pList->a[i].zName = sqlite3NameFromToken(db, pToken);
+  return pList;
+}
+
+/*
+** Delete an IdList.
+*/
+void sqlite3IdListDelete(IdList *pList){
+  int i;
+  if( pList==0 ) return;
+  for(i=0; i<pList->nId; i++){
+    sqlite3_free(pList->a[i].zName);
+  }
+  sqlite3_free(pList->a);
+  sqlite3_free(pList);
+}
+
+/*
+** Return the index in pList of the identifier named zId.  Return -1
+** if not found.
+*/
+int sqlite3IdListIndex(IdList *pList, const char *zName){
+  int i;
+  if( pList==0 ) return -1;
+  for(i=0; i<pList->nId; i++){
+    if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
+  }
+  return -1;
+}
+
+/*
+** Append a new table name to the given SrcList.  Create a new SrcList if
+** need be.  A new entry is created in the SrcList even if pToken is NULL.
+**
+** A new SrcList is returned, or NULL if malloc() fails.
+**
+** If pDatabase is not null, it means that the table has an optional
+** database name prefix.  Like this:  "database.table".  The pDatabase
+** points to the table name and the pTable points to the database name.
+** The SrcList.a[].zName field is filled with the table name which might
+** come from pTable (if pDatabase is NULL) or from pDatabase.  
+** SrcList.a[].zDatabase is filled with the database name from pTable,
+** or with NULL if no database is specified.
+**
+** In other words, if call like this:
+**
+**         sqlite3SrcListAppend(D,A,B,0);
+**
+** Then B is a table name and the database name is unspecified.  If called
+** like this:
+**
+**         sqlite3SrcListAppend(D,A,B,C);
+**
+** Then C is the table name and B is the database name.
+*/
+SrcList *sqlite3SrcListAppend(
+  sqlite3 *db,        /* Connection to notify of malloc failures */
+  SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
+  Token *pTable,      /* Table to append */
+  Token *pDatabase    /* Database of the table */
+){
+  struct SrcList_item *pItem;
+  if( pList==0 ){
+    pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
+    if( pList==0 ) return 0;
+    pList->nAlloc = 1;
+  }
+  if( pList->nSrc>=pList->nAlloc ){
+    SrcList *pNew;
+    pList->nAlloc *= 2;
+    pNew = sqlite3DbRealloc(db, pList,
+               sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) );
+    if( pNew==0 ){
+      sqlite3SrcListDelete(pList);
+      return 0;
+    }
+    pList = pNew;
+  }
+  pItem = &pList->a[pList->nSrc];
+  memset(pItem, 0, sizeof(pList->a[0]));
+  if( pDatabase && pDatabase->z==0 ){
+    pDatabase = 0;
+  }
+  if( pDatabase && pTable ){
+    Token *pTemp = pDatabase;
+    pDatabase = pTable;
+    pTable = pTemp;
+  }
+  pItem->zName = sqlite3NameFromToken(db, pTable);
+  pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
+  pItem->iCursor = -1;
+  pItem->isPopulated = 0;
+  pList->nSrc++;
+  return pList;
+}
+
+/*
+** Assign cursors to all tables in a SrcList
+*/
+void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
+  int i;
+  struct SrcList_item *pItem;
+  assert(pList || pParse->db->mallocFailed );
+  if( pList ){
+    for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
+      if( pItem->iCursor>=0 ) break;
+      pItem->iCursor = pParse->nTab++;
+      if( pItem->pSelect ){
+        sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
+      }
+    }
+  }
+}
+
+/*
+** Delete an entire SrcList including all its substructure.
+*/
+void sqlite3SrcListDelete(SrcList *pList){
+  int i;
+  struct SrcList_item *pItem;
+  if( pList==0 ) return;
+  for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
+    sqlite3_free(pItem->zDatabase);
+    sqlite3_free(pItem->zName);
+    sqlite3_free(pItem->zAlias);
+    sqlite3DeleteTable(pItem->pTab);
+    sqlite3SelectDelete(pItem->pSelect);
+    sqlite3ExprDelete(pItem->pOn);
+    sqlite3IdListDelete(pItem->pUsing);
+  }
+  sqlite3_free(pList);
+}
+
+/*
+** This routine is called by the parser to add a new term to the
+** end of a growing FROM clause.  The "p" parameter is the part of
+** the FROM clause that has already been constructed.  "p" is NULL
+** if this is the first term of the FROM clause.  pTable and pDatabase
+** are the name of the table and database named in the FROM clause term.
+** pDatabase is NULL if the database name qualifier is missing - the
+** usual case.  If the term has a alias, then pAlias points to the
+** alias token.  If the term is a subquery, then pSubquery is the
+** SELECT statement that the subquery encodes.  The pTable and
+** pDatabase parameters are NULL for subqueries.  The pOn and pUsing
+** parameters are the content of the ON and USING clauses.
+**
+** Return a new SrcList which encodes is the FROM with the new
+** term added.
+*/
+SrcList *sqlite3SrcListAppendFromTerm(
+  Parse *pParse,          /* Parsing context */
+  SrcList *p,             /* The left part of the FROM clause already seen */
+  Token *pTable,          /* Name of the table to add to the FROM clause */
+  Token *pDatabase,       /* Name of the database containing pTable */
+  Token *pAlias,          /* The right-hand side of the AS subexpression */
+  Select *pSubquery,      /* A subquery used in place of a table name */
+  Expr *pOn,              /* The ON clause of a join */
+  IdList *pUsing          /* The USING clause of a join */
+){
+  struct SrcList_item *pItem;
+  sqlite3 *db = pParse->db;
+  p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
+  if( p==0 || p->nSrc==0 ){
+    sqlite3ExprDelete(pOn);
+    sqlite3IdListDelete(pUsing);
+    sqlite3SelectDelete(pSubquery);
+    return p;
+  }
+  pItem = &p->a[p->nSrc-1];
+  if( pAlias && pAlias->n ){
+    pItem->zAlias = sqlite3NameFromToken(db, pAlias);
+  }
+  pItem->pSelect = pSubquery;
+  pItem->pOn = pOn;
+  pItem->pUsing = pUsing;
+  return p;
+}
+
+/*
+** When building up a FROM clause in the parser, the join operator
+** is initially attached to the left operand.  But the code generator
+** expects the join operator to be on the right operand.  This routine
+** Shifts all join operators from left to right for an entire FROM
+** clause.
+**
+** Example: Suppose the join is like this:
+**
+**           A natural cross join B
+**
+** The operator is "natural cross join".  The A and B operands are stored
+** in p->a[0] and p->a[1], respectively.  The parser initially stores the
+** operator with A.  This routine shifts that operator over to B.
+*/
+void sqlite3SrcListShiftJoinType(SrcList *p){
+  if( p && p->a ){
+    int i;
+    for(i=p->nSrc-1; i>0; i--){
+      p->a[i].jointype = p->a[i-1].jointype;
+    }
+    p->a[0].jointype = 0;
+  }
+}
+
+/*
+** Begin a transaction
+*/
+void sqlite3BeginTransaction(Parse *pParse, int type){
+  sqlite3 *db;
+  Vdbe *v;
+  int i;
+
+  if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
+  if( pParse->nErr || db->mallocFailed ) return;
+  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return;
+
+  v = sqlite3GetVdbe(pParse);
+  if( !v ) return;
+  if( type!=TK_DEFERRED ){
+    for(i=0; i<db->nDb; i++){
+      sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
+      sqlite3VdbeUsesBtree(v, i);
+    }
+  }
+  sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
+}
+
+/*
+** Commit a transaction
+*/
+void sqlite3CommitTransaction(Parse *pParse){
+  sqlite3 *db;
+  Vdbe *v;
+
+  if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
+  if( pParse->nErr || db->mallocFailed ) return;
+  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return;
+
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
+  }
+}
+
+/*
+** Rollback a transaction
+*/
+void sqlite3RollbackTransaction(Parse *pParse){
+  sqlite3 *db;
+  Vdbe *v;
+
+  if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
+  if( pParse->nErr || db->mallocFailed ) return;
+  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return;
+
+  v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
+  }
+}
+
+/*
+** Make sure the TEMP database is open and available for use.  Return
+** the number of errors.  Leave any error messages in the pParse structure.
+*/
+int sqlite3OpenTempDatabase(Parse *pParse){
+  sqlite3 *db = pParse->db;
+  if( db->aDb[1].pBt==0 && !pParse->explain ){
+    int rc;
+    static const int flags = 
+          SQLITE_OPEN_READWRITE |
+          SQLITE_OPEN_CREATE |
+          SQLITE_OPEN_EXCLUSIVE |
+          SQLITE_OPEN_DELETEONCLOSE |
+          SQLITE_OPEN_TEMP_DB;
+
+    rc = sqlite3BtreeFactory(db, 0, 0, SQLITE_DEFAULT_CACHE_SIZE, flags,
+                                 &db->aDb[1].pBt);
+    if( rc!=SQLITE_OK ){
+      sqlite3ErrorMsg(pParse, "unable to open a temporary database "
+        "file for storing temporary tables");
+      pParse->rc = rc;
+      return 1;
+    }
+    assert( (db->flags & SQLITE_InTrans)==0 || db->autoCommit );
+    assert( db->aDb[1].pSchema );
+  }
+  return 0;
+}
+
+/*
+** Generate VDBE code that will verify the schema cookie and start
+** a read-transaction for all named database files.
+**
+** It is important that all schema cookies be verified and all
+** read transactions be started before anything else happens in
+** the VDBE program.  But this routine can be called after much other
+** code has been generated.  So here is what we do:
+**
+** The first time this routine is called, we code an OP_Goto that
+** will jump to a subroutine at the end of the program.  Then we
+** record every database that needs its schema verified in the
+** pParse->cookieMask field.  Later, after all other code has been
+** generated, the subroutine that does the cookie verifications and
+** starts the transactions will be coded and the OP_Goto P2 value
+** will be made to point to that subroutine.  The generation of the
+** cookie verification subroutine code happens in sqlite3FinishCoding().
+**
+** If iDb<0 then code the OP_Goto only - don't set flag to verify the
+** schema on any databases.  This can be used to position the OP_Goto
+** early in the code, before we know if any database tables will be used.
+*/
+void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
+  sqlite3 *db;
+  Vdbe *v;
+  int mask;
+
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ) return;  /* This only happens if there was a prior error */
+  db = pParse->db;
+  if( pParse->cookieGoto==0 ){
+    pParse->cookieGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
+  }
+  if( iDb>=0 ){
+    assert( iDb<db->nDb );
+    assert( db->aDb[iDb].pBt!=0 || iDb==1 );
+    assert( iDb<SQLITE_MAX_ATTACHED+2 );
+    mask = 1<<iDb;
+    if( (pParse->cookieMask & mask)==0 ){
+      pParse->cookieMask |= mask;
+      pParse->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
+      if( !OMIT_TEMPDB && iDb==1 ){
+        sqlite3OpenTempDatabase(pParse);
+      }
+    }
+  }
+}
+
+/*
+** Generate VDBE code that prepares for doing an operation that
+** might change the database.
+**
+** This routine starts a new transaction if we are not already within
+** a transaction.  If we are already within a transaction, then a checkpoint
+** is set if the setStatement parameter is true.  A checkpoint should
+** be set for operations that might fail (due to a constraint) part of
+** the way through and which will need to undo some writes without having to
+** rollback the whole transaction.  For operations where all constraints
+** can be checked before any changes are made to the database, it is never
+** necessary to undo a write and the checkpoint should not be set.
+**
+** Only database iDb and the temp database are made writable by this call.
+** If iDb==0, then the main and temp databases are made writable.   If
+** iDb==1 then only the temp database is made writable.  If iDb>1 then the
+** specified auxiliary database and the temp database are made writable.
+*/
+void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  if( v==0 ) return;
+  sqlite3CodeVerifySchema(pParse, iDb);
+  pParse->writeMask |= 1<<iDb;
+  if( setStatement && pParse->nested==0 ){
+    sqlite3VdbeAddOp1(v, OP_Statement, iDb);
+  }
+  if( (OMIT_TEMPDB || iDb!=1) && pParse->db->aDb[1].pBt!=0 ){
+    sqlite3BeginWriteOperation(pParse, setStatement, 1);
+  }
+}
+
+/*
+** Check to see if pIndex uses the collating sequence pColl.  Return
+** true if it does and false if it does not.
+*/
+#ifndef SQLITE_OMIT_REINDEX
+static int collationMatch(const char *zColl, Index *pIndex){
+  int i;
+  for(i=0; i<pIndex->nColumn; i++){
+    const char *z = pIndex->azColl[i];
+    if( z==zColl || (z && zColl && 0==sqlite3StrICmp(z, zColl)) ){
+      return 1;
+    }
+  }
+  return 0;
+}
+#endif
+
+/*
+** Recompute all indices of pTab that use the collating sequence pColl.
+** If pColl==0 then recompute all indices of pTab.
+*/
+#ifndef SQLITE_OMIT_REINDEX
+static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
+  Index *pIndex;              /* An index associated with pTab */
+
+  for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
+    if( zColl==0 || collationMatch(zColl, pIndex) ){
+      int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+      sqlite3BeginWriteOperation(pParse, 0, iDb);
+      sqlite3RefillIndex(pParse, pIndex, -1);
+    }
+  }
+}
+#endif
+
+/*
+** Recompute all indices of all tables in all databases where the
+** indices use the collating sequence pColl.  If pColl==0 then recompute
+** all indices everywhere.
+*/
+#ifndef SQLITE_OMIT_REINDEX
+static void reindexDatabases(Parse *pParse, char const *zColl){
+  Db *pDb;                    /* A single database */
+  int iDb;                    /* The database index number */
+  sqlite3 *db = pParse->db;   /* The database connection */
+  HashElem *k;                /* For looping over tables in pDb */
+  Table *pTab;                /* A table in the database */
+
+  for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
+    assert( pDb!=0 );
+    for(k=sqliteHashFirst(&pDb->pSchema->tblHash);  k; k=sqliteHashNext(k)){
+      pTab = (Table*)sqliteHashData(k);
+      reindexTable(pParse, pTab, zColl);
+    }
+  }
+}
+#endif
+
+/*
+** Generate code for the REINDEX command.
+**
+**        REINDEX                            -- 1
+**        REINDEX  <collation>               -- 2
+**        REINDEX  ?<database>.?<tablename>  -- 3
+**        REINDEX  ?<database>.?<indexname>  -- 4
+**
+** Form 1 causes all indices in all attached databases to be rebuilt.
+** Form 2 rebuilds all indices in all databases that use the named
+** collating function.  Forms 3 and 4 rebuild the named index or all
+** indices associated with the named table.
+*/
+#ifndef SQLITE_OMIT_REINDEX
+void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
+  CollSeq *pColl;             /* Collating sequence to be reindexed, or NULL */
+  char *z;                    /* Name of a table or index */
+  const char *zDb;            /* Name of the database */
+  Table *pTab;                /* A table in the database */
+  Index *pIndex;              /* An index associated with pTab */
+  int iDb;                    /* The database index number */
+  sqlite3 *db = pParse->db;   /* The database connection */
+  Token *pObjName;            /* Name of the table or index to be reindexed */
+
+  /* Read the database schema. If an error occurs, leave an error message
+  ** and code in pParse and return NULL. */
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    return;
+  }
+
+  if( pName1==0 || pName1->z==0 ){
+    reindexDatabases(pParse, 0);
+    return;
+  }else if( pName2==0 || pName2->z==0 ){
+    char *zColl;
+    assert( pName1->z );
+    zColl = sqlite3NameFromToken(pParse->db, pName1);
+    if( !zColl ) return;
+    pColl = sqlite3FindCollSeq(db, ENC(db), zColl, -1, 0);
+    if( pColl ){
+      if( zColl ){
+        reindexDatabases(pParse, zColl);
+        sqlite3_free(zColl);
+      }
+      return;
+    }
+    sqlite3_free(zColl);
+  }
+  iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
+  if( iDb<0 ) return;
+  z = sqlite3NameFromToken(db, pObjName);
+  if( z==0 ) return;
+  zDb = db->aDb[iDb].zName;
+  pTab = sqlite3FindTable(db, z, zDb);
+  if( pTab ){
+    reindexTable(pParse, pTab, 0);
+    sqlite3_free(z);
+    return;
+  }
+  pIndex = sqlite3FindIndex(db, z, zDb);
+  sqlite3_free(z);
+  if( pIndex ){
+    sqlite3BeginWriteOperation(pParse, 0, iDb);
+    sqlite3RefillIndex(pParse, pIndex, -1);
+    return;
+  }
+  sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
+}
+#endif
+
+/*
+** Return a dynamicly allocated KeyInfo structure that can be used
+** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
+**
+** If successful, a pointer to the new structure is returned. In this case
+** the caller is responsible for calling sqlite3_free() on the returned 
+** pointer. If an error occurs (out of memory or missing collation 
+** sequence), NULL is returned and the state of pParse updated to reflect
+** the error.
+*/
+KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
+  int i;
+  int nCol = pIdx->nColumn;
+  int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
+  KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(pParse->db, nBytes);
+
+  if( pKey ){
+    pKey->db = pParse->db;
+    pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
+    assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
+    for(i=0; i<nCol; i++){
+      char *zColl = pIdx->azColl[i];
+      assert( zColl );
+      pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl, -1);
+      pKey->aSortOrder[i] = pIdx->aSortOrder[i];
+    }
+    pKey->nField = nCol;
+  }
+
+  if( pParse->nErr ){
+    sqlite3_free(pKey);
+    pKey = 0;
+  }
+  return pKey;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/callback.c b/client/src/thirdparty/sqlite-3.4.2/src/callback.c
new file mode 100644
index 0000000..009cfd7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/callback.c
@@ -0,0 +1,378 @@
+/*
+** 2005 May 23 
+**
+** 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 functions used to access the internal hash tables
+** of user defined functions and collation sequences.
+**
+** $Id: callback.c,v 1.23 2007/08/29 12:31:26 danielk1977 Exp $
+*/
+
+#include "sqliteInt.h"
+
+/*
+** Invoke the 'collation needed' callback to request a collation sequence
+** in the database text encoding of name zName, length nName.
+** If the collation sequence
+*/
+static void callCollNeeded(sqlite3 *db, const char *zName, int nName){
+  assert( !db->xCollNeeded || !db->xCollNeeded16 );
+  if( nName<0 ) nName = strlen(zName);
+  if( db->xCollNeeded ){
+    char *zExternal = sqlite3DbStrNDup(db, zName, nName);
+    if( !zExternal ) return;
+    db->xCollNeeded(db->pCollNeededArg, db, (int)ENC(db), zExternal);
+    sqlite3_free(zExternal);
+  }
+#ifndef SQLITE_OMIT_UTF16
+  if( db->xCollNeeded16 ){
+    char const *zExternal;
+    sqlite3_value *pTmp = sqlite3ValueNew(db);
+    sqlite3ValueSetStr(pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC);
+    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);
+    if( zExternal ){
+      db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
+    }
+    sqlite3ValueFree(pTmp);
+  }
+#endif
+}
+
+/*
+** This routine is called if the collation factory fails to deliver a
+** collation function in the best encoding but there may be other versions
+** of this collation function (for other text encodings) available. Use one
+** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if
+** possible.
+*/
+static int synthCollSeq(sqlite3 *db, CollSeq *pColl){
+  CollSeq *pColl2;
+  char *z = pColl->zName;
+  int n = strlen(z);
+  int i;
+  static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 };
+  for(i=0; i<3; i++){
+    pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, n, 0);
+    if( pColl2->xCmp!=0 ){
+      memcpy(pColl, pColl2, sizeof(CollSeq));
+      pColl->xDel = 0;         /* Do not copy the destructor */
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_ERROR;
+}
+
+/*
+** This function is responsible for invoking the collation factory callback
+** or substituting a collation sequence of a different encoding when the
+** requested collation sequence is not available in the database native
+** encoding.
+** 
+** If it is not NULL, then pColl must point to the database native encoding 
+** collation sequence with name zName, length nName.
+**
+** The return value is either the collation sequence to be used in database
+** db for collation type name zName, length nName, or NULL, if no collation
+** sequence can be found.
+*/
+CollSeq *sqlite3GetCollSeq(
+  sqlite3* db, 
+  CollSeq *pColl, 
+  const char *zName, 
+  int nName
+){
+  CollSeq *p;
+
+  p = pColl;
+  if( !p ){
+    p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0);
+  }
+  if( !p || !p->xCmp ){
+    /* No collation sequence of this type for this encoding is registered.
+    ** Call the collation factory to see if it can supply us with one.
+    */
+    callCollNeeded(db, zName, nName);
+    p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0);
+  }
+  if( p && !p->xCmp && synthCollSeq(db, p) ){
+    p = 0;
+  }
+  assert( !p || p->xCmp );
+  return p;
+}
+
+/*
+** This routine is called on a collation sequence before it is used to
+** check that it is defined. An undefined collation sequence exists when
+** a database is loaded that contains references to collation sequences
+** that have not been defined by sqlite3_create_collation() etc.
+**
+** If required, this routine calls the 'collation needed' callback to
+** request a definition of the collating sequence. If this doesn't work, 
+** an equivalent collating sequence that uses a text encoding different
+** from the main database is substituted, if one is available.
+*/
+int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
+  if( pColl ){
+    const char *zName = pColl->zName;
+    CollSeq *p = sqlite3GetCollSeq(pParse->db, pColl, zName, -1);
+    if( !p ){
+      if( pParse->nErr==0 ){
+        sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
+      }
+      pParse->nErr++;
+      return SQLITE_ERROR;
+    }
+    assert( p==pColl );
+  }
+  return SQLITE_OK;
+}
+
+
+
+/*
+** Locate and return an entry from the db.aCollSeq hash table. If the entry
+** specified by zName and nName is not found and parameter 'create' is
+** true, then create a new entry. Otherwise return NULL.
+**
+** Each pointer stored in the sqlite3.aCollSeq hash table contains an
+** array of three CollSeq structures. The first is the collation sequence
+** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.
+**
+** Stored immediately after the three collation sequences is a copy of
+** the collation sequence name. A pointer to this string is stored in
+** each collation sequence structure.
+*/
+static CollSeq *findCollSeqEntry(
+  sqlite3 *db,
+  const char *zName,
+  int nName,
+  int create
+){
+  CollSeq *pColl;
+  if( nName<0 ) nName = strlen(zName);
+  pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
+
+  if( 0==pColl && create ){
+    pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
+    if( pColl ){
+      CollSeq *pDel = 0;
+      pColl[0].zName = (char*)&pColl[3];
+      pColl[0].enc = SQLITE_UTF8;
+      pColl[1].zName = (char*)&pColl[3];
+      pColl[1].enc = SQLITE_UTF16LE;
+      pColl[2].zName = (char*)&pColl[3];
+      pColl[2].enc = SQLITE_UTF16BE;
+      memcpy(pColl[0].zName, zName, nName);
+      pColl[0].zName[nName] = 0;
+      pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
+
+      /* If a malloc() failure occured in sqlite3HashInsert(), it will 
+      ** return the pColl pointer to be deleted (because it wasn't added
+      ** to the hash table).
+      */
+      assert( pDel==0 || pDel==pColl );
+      if( pDel!=0 ){
+        db->mallocFailed = 1;
+        sqlite3_free(pDel);
+        pColl = 0;
+      }
+    }
+  }
+  return pColl;
+}
+
+/*
+** Parameter zName points to a UTF-8 encoded string nName bytes long.
+** Return the CollSeq* pointer for the collation sequence named zName
+** for the encoding 'enc' from the database 'db'.
+**
+** If the entry specified is not found and 'create' is true, then create a
+** new entry.  Otherwise return NULL.
+**
+** A separate function sqlite3LocateCollSeq() is a wrapper around
+** this routine.  sqlite3LocateCollSeq() invokes the collation factory
+** if necessary and generates an error message if the collating sequence
+** cannot be found.
+*/
+CollSeq *sqlite3FindCollSeq(
+  sqlite3 *db,
+  u8 enc,
+  const char *zName,
+  int nName,
+  int create
+){
+  CollSeq *pColl;
+  if( zName ){
+    pColl = findCollSeqEntry(db, zName, nName, create);
+  }else{
+    pColl = db->pDfltColl;
+  }
+  assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
+  assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
+  if( pColl ) pColl += enc-1;
+  return pColl;
+}
+
+/*
+** Locate a user function given a name, a number of arguments and a flag
+** indicating whether the function prefers UTF-16 over UTF-8.  Return a
+** pointer to the FuncDef structure that defines that function, or return
+** NULL if the function does not exist.
+**
+** If the createFlag argument is true, then a new (blank) FuncDef
+** structure is created and liked into the "db" structure if a
+** no matching function previously existed.  When createFlag is true
+** and the nArg parameter is -1, then only a function that accepts
+** any number of arguments will be returned.
+**
+** If createFlag is false and nArg is -1, then the first valid
+** function found is returned.  A function is valid if either xFunc
+** or xStep is non-zero.
+**
+** If createFlag is false, then a function with the required name and
+** number of arguments may be returned even if the eTextRep flag does not
+** match that requested.
+*/
+FuncDef *sqlite3FindFunction(
+  sqlite3 *db,       /* An open database */
+  const char *zName, /* Name of the function.  Not null-terminated */
+  int nName,         /* Number of characters in the name */
+  int nArg,          /* Number of arguments.  -1 means any number */
+  u8 enc,            /* Preferred text encoding */
+  int createFlag     /* Create new entry if true and does not otherwise exist */
+){
+  FuncDef *p;         /* Iterator variable */
+  FuncDef *pFirst;    /* First function with this name */
+  FuncDef *pBest = 0; /* Best match found so far */
+  int bestmatch = 0;  
+
+
+  assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
+  if( nArg<-1 ) nArg = -1;
+
+  pFirst = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, nName);
+  for(p=pFirst; p; p=p->pNext){
+    /* During the search for the best function definition, bestmatch is set
+    ** as follows to indicate the quality of the match with the definition
+    ** pointed to by pBest:
+    **
+    ** 0: pBest is NULL. No match has been found.
+    ** 1: A variable arguments function that prefers UTF-8 when a UTF-16
+    **    encoding is requested, or vice versa.
+    ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is
+    **    requested, or vice versa.
+    ** 3: A variable arguments function using the same text encoding.
+    ** 4: A function with the exact number of arguments requested that
+    **    prefers UTF-8 when a UTF-16 encoding is requested, or vice versa.
+    ** 5: A function with the exact number of arguments requested that
+    **    prefers UTF-16LE when UTF-16BE is requested, or vice versa.
+    ** 6: An exact match.
+    **
+    ** A larger value of 'matchqual' indicates a more desirable match.
+    */
+    if( p->nArg==-1 || p->nArg==nArg || nArg==-1 ){
+      int match = 1;          /* Quality of this match */
+      if( p->nArg==nArg || nArg==-1 ){
+        match = 4;
+      }
+      if( enc==p->iPrefEnc ){
+        match += 2;
+      }
+      else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) ||
+               (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){
+        match += 1;
+      }
+
+      if( match>bestmatch ){
+        pBest = p;
+        bestmatch = match;
+      }
+    }
+  }
+
+  /* If the createFlag parameter is true, and the seach did not reveal an
+  ** exact match for the name, number of arguments and encoding, then add a
+  ** new entry to the hash table and return it.
+  */
+  if( createFlag && bestmatch<6 && 
+      (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName))!=0 ){
+    pBest->nArg = nArg;
+    pBest->pNext = pFirst;
+    pBest->iPrefEnc = enc;
+    memcpy(pBest->zName, zName, nName);
+    pBest->zName[nName] = 0;
+    if( pBest==sqlite3HashInsert(&db->aFunc,pBest->zName,nName,(void*)pBest) ){
+      db->mallocFailed = 1;
+      sqlite3_free(pBest);
+      return 0;
+    }
+  }
+
+  if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
+    return pBest;
+  }
+  return 0;
+}
+
+/*
+** Free all resources held by the schema structure. The void* argument points
+** at a Schema struct. This function does not call sqlite3_free() on the 
+** pointer itself, it just cleans up subsiduary resources (i.e. the contents
+** of the schema hash tables).
+*/
+void sqlite3SchemaFree(void *p){
+  Hash temp1;
+  Hash temp2;
+  HashElem *pElem;
+  Schema *pSchema = (Schema *)p;
+
+  temp1 = pSchema->tblHash;
+  temp2 = pSchema->trigHash;
+  sqlite3HashInit(&pSchema->trigHash, SQLITE_HASH_STRING, 0);
+  sqlite3HashClear(&pSchema->aFKey);
+  sqlite3HashClear(&pSchema->idxHash);
+  for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
+    sqlite3DeleteTrigger((Trigger*)sqliteHashData(pElem));
+  }
+  sqlite3HashClear(&temp2);
+  sqlite3HashInit(&pSchema->tblHash, SQLITE_HASH_STRING, 0);
+  for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
+    Table *pTab = sqliteHashData(pElem);
+    sqlite3DeleteTable(pTab);
+  }
+  sqlite3HashClear(&temp1);
+  pSchema->pSeqTab = 0;
+  pSchema->flags &= ~DB_SchemaLoaded;
+}
+
+/*
+** Find and return the schema associated with a BTree.  Create
+** a new one if necessary.
+*/
+Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
+  Schema * p;
+  if( pBt ){
+    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaFree);
+  }else{
+    p = (Schema *)sqlite3MallocZero(sizeof(Schema));
+  }
+  if( !p ){
+    db->mallocFailed = 1;
+  }else if ( 0==p->file_format ){
+    sqlite3HashInit(&p->tblHash, SQLITE_HASH_STRING, 0);
+    sqlite3HashInit(&p->idxHash, SQLITE_HASH_STRING, 0);
+    sqlite3HashInit(&p->trigHash, SQLITE_HASH_STRING, 0);
+    sqlite3HashInit(&p->aFKey, SQLITE_HASH_STRING, 1);
+    p->enc = SQLITE_UTF8;
+  }
+  return p;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/complete.c b/client/src/thirdparty/sqlite-3.4.2/src/complete.c
new file mode 100644
index 0000000..ae61d8a
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/complete.c
@@ -0,0 +1,271 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.6 2007/08/27 23:26:59 drh Exp $
+*/
+#include "sqliteInt.h"
+#ifndef SQLITE_OMIT_COMPLETE
+
+/*
+** This is defined in tokenize.c.  We just have to import the definition.
+*/
+#ifndef SQLITE_AMALGAMATION
+#ifdef SQLITE_ASCII
+extern const char sqlite3IsAsciiIdChar[];
+#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsAsciiIdChar[c-0x20]))
+#endif
+#ifdef SQLITE_EBCDIC
+extern const char sqlite3IsEbcdicIdChar[];
+#define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
+#endif
+#endif /* SQLITE_AMALGAMATION */
+
+
+/*
+** Token types used by the sqlite3_complete() routine.  See the header
+** comments on that procedure for additional information.
+*/
+#define tkSEMI    0
+#define tkWS      1
+#define tkOTHER   2
+#define tkEXPLAIN 3
+#define tkCREATE  4
+#define tkTEMP    5
+#define tkTRIGGER 6
+#define tkEND     7
+
+/*
+** Return TRUE if the given SQL string ends in a semicolon.
+**
+** Special handling is require for CREATE TRIGGER statements.
+** Whenever the CREATE TRIGGER keywords are seen, the statement
+** must end with ";END;".
+**
+** This implementation uses a state machine with 7 states:
+**
+**   (0) START     At the beginning or end of an SQL statement.  This routine
+**                 returns 1 if it ends in the START state and 0 if it ends
+**                 in any other state.
+**
+**   (1) NORMAL    We are in the middle of statement which ends with a single
+**                 semicolon.
+**
+**   (2) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of 
+**                 a statement.
+**
+**   (3) CREATE    The keyword CREATE has been seen at the beginning of a
+**                 statement, possibly preceeded by EXPLAIN and/or followed by
+**                 TEMP or TEMPORARY
+**
+**   (4) TRIGGER   We are in the middle of a trigger definition that must be
+**                 ended by a semicolon, the keyword END, and another semicolon.
+**
+**   (5) SEMI      We've seen the first semicolon in the ";END;" that occurs at
+**                 the end of a trigger definition.
+**
+**   (6) END       We've seen the ";END" of the ";END;" that occurs at the end
+**                 of a trigger difinition.
+**
+** Transitions between states above are determined by tokens extracted
+** from the input.  The following tokens are significant:
+**
+**   (0) tkSEMI      A semicolon.
+**   (1) tkWS        Whitespace
+**   (2) tkOTHER     Any other SQL token.
+**   (3) tkEXPLAIN   The "explain" keyword.
+**   (4) tkCREATE    The "create" keyword.
+**   (5) tkTEMP      The "temp" or "temporary" keyword.
+**   (6) tkTRIGGER   The "trigger" keyword.
+**   (7) tkEND       The "end" keyword.
+**
+** Whitespace never causes a state transition and is always ignored.
+**
+** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
+** to recognize the end of a trigger can be omitted.  All we have to do
+** is look for a semicolon that is not part of an string or comment.
+*/
+int sqlite3_complete(const char *zSql){
+  u8 state = 0;   /* Current state, using numbers defined in header comment */
+  u8 token;       /* Value of the next token */
+
+#ifndef SQLITE_OMIT_TRIGGER
+  /* A complex statement machine used to detect the end of a CREATE TRIGGER
+  ** statement.  This is the normal case.
+  */
+  static const u8 trans[7][8] = {
+                     /* Token:                                                */
+     /* State:       **  SEMI  WS  OTHER EXPLAIN  CREATE  TEMP  TRIGGER  END  */
+     /* 0   START: */ {    0,  0,     1,      2,      3,    1,       1,   1,  },
+     /* 1  NORMAL: */ {    0,  1,     1,      1,      1,    1,       1,   1,  },
+     /* 2 EXPLAIN: */ {    0,  2,     1,      1,      3,    1,       1,   1,  },
+     /* 3  CREATE: */ {    0,  3,     1,      1,      1,    3,       4,   1,  },
+     /* 4 TRIGGER: */ {    5,  4,     4,      4,      4,    4,       4,   4,  },
+     /* 5    SEMI: */ {    5,  5,     4,      4,      4,    4,       4,   6,  },
+     /* 6     END: */ {    0,  6,     4,      4,      4,    4,       4,   4,  },
+  };
+#else
+  /* If triggers are not suppored by this compile then the statement machine
+  ** used to detect the end of a statement is much simplier
+  */
+  static const u8 trans[2][3] = {
+                     /* Token:           */
+     /* State:       **  SEMI  WS  OTHER */
+     /* 0   START: */ {    0,  0,     1, },
+     /* 1  NORMAL: */ {    0,  1,     1, },
+  };
+#endif /* SQLITE_OMIT_TRIGGER */
+
+  while( *zSql ){
+    switch( *zSql ){
+      case ';': {  /* A semicolon */
+        token = tkSEMI;
+        break;
+      }
+      case ' ':
+      case '\r':
+      case '\t':
+      case '\n':
+      case '\f': {  /* White space is ignored */
+        token = tkWS;
+        break;
+      }
+      case '/': {   /* C-style comments */
+        if( zSql[1]!='*' ){
+          token = tkOTHER;
+          break;
+        }
+        zSql += 2;
+        while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
+        if( zSql[0]==0 ) return 0;
+        zSql++;
+        token = tkWS;
+        break;
+      }
+      case '-': {   /* SQL-style comments from "--" to end of line */
+        if( zSql[1]!='-' ){
+          token = tkOTHER;
+          break;
+        }
+        while( *zSql && *zSql!='\n' ){ zSql++; }
+        if( *zSql==0 ) return state==0;
+        token = tkWS;
+        break;
+      }
+      case '[': {   /* Microsoft-style identifiers in [...] */
+        zSql++;
+        while( *zSql && *zSql!=']' ){ zSql++; }
+        if( *zSql==0 ) return 0;
+        token = tkOTHER;
+        break;
+      }
+      case '`':     /* Grave-accent quoted symbols used by MySQL */
+      case '"':     /* single- and double-quoted strings */
+      case '\'': {
+        int c = *zSql;
+        zSql++;
+        while( *zSql && *zSql!=c ){ zSql++; }
+        if( *zSql==0 ) return 0;
+        token = tkOTHER;
+        break;
+      }
+      default: {
+        int c;
+        if( IdChar((u8)*zSql) ){
+          /* Keywords and unquoted identifiers */
+          int nId;
+          for(nId=1; IdChar(zSql[nId]); nId++){}
+#ifdef SQLITE_OMIT_TRIGGER
+          token = tkOTHER;
+#else
+          switch( *zSql ){
+            case 'c': case 'C': {
+              if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
+                token = tkCREATE;
+              }else{
+                token = tkOTHER;
+              }
+              break;
+            }
+            case 't': case 'T': {
+              if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
+                token = tkTRIGGER;
+              }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
+                token = tkTEMP;
+              }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
+                token = tkTEMP;
+              }else{
+                token = tkOTHER;
+              }
+              break;
+            }
+            case 'e':  case 'E': {
+              if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
+                token = tkEND;
+              }else
+#ifndef SQLITE_OMIT_EXPLAIN
+              if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
+                token = tkEXPLAIN;
+              }else
+#endif
+              {
+                token = tkOTHER;
+              }
+              break;
+            }
+            default: {
+              token = tkOTHER;
+              break;
+            }
+          }
+#endif /* SQLITE_OMIT_TRIGGER */
+          zSql += nId-1;
+        }else{
+          /* Operators and special symbols */
+          token = tkOTHER;
+        }
+        break;
+      }
+    }
+    state = trans[state][token];
+    zSql++;
+  }
+  return state==0;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** This routine is the same as the sqlite3_complete() routine described
+** above, except that the parameter is required to be UTF-16 encoded, not
+** UTF-8.
+*/
+int sqlite3_complete16(const void *zSql){
+  sqlite3_value *pVal;
+  char const *zSql8;
+  int rc = SQLITE_NOMEM;
+
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
+  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
+  if( zSql8 ){
+    rc = sqlite3_complete(zSql8);
+  }
+  sqlite3ValueFree(pVal);
+  return sqlite3ApiExit(0, rc);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+#endif /* SQLITE_OMIT_COMPLETE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/date.c b/client/src/thirdparty/sqlite-3.4.2/src/date.c
new file mode 100644
index 0000000..07ba2f2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/date.c
@@ -0,0 +1,1038 @@
+/*
+** 2003 October 31
+**
+** 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 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.75 2008/01/17 22:27:54 drh Exp $
+**
+** 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. 
+**
+** 1970-01-01 00:00:00 is JD 2440587.5
+** 2000-01-01 00:00:00 is JD 2451544.5
+**
+** This implemention requires years to be expressed as a 4-digit number
+** which means that only dates between 0000-01-01 and 9999-12-31 can
+** be represented, even though julian day numbers allow a much wider
+** range of dates.
+**
+** The Gregorian calendar system is used for all dates and times,
+** even those that predate the Gregorian calendar.  Historians usually
+** use the Julian calendar for dates prior to 1582-10-15 and for some
+** dates afterwards, depending on locale.  Beware of this difference.
+**
+** The conversion algorithms are implemented based on descriptions
+** in the following text:
+**
+**      Jean Meeus
+**      Astronomical Algorithms, 2nd Edition, 1998
+**      ISBM 0-943396-61-1
+**      Willmann-Bell, Inc
+**      Richmond, Virginia (USA)
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <time.h>
+
+#ifndef SQLITE_OMIT_DATETIME_FUNCS
+
+/*
+** A structure for holding a single date and time.
+*/
+typedef struct DateTime DateTime;
+struct DateTime {
+  double rJD;      /* The julian day number */
+  int Y, M, D;     /* Year, month, and day */
+  int h, m;        /* Hour and minutes */
+  int tz;          /* Timezone offset in minutes */
+  double s;        /* Seconds */
+  char validYMD;   /* True if Y,M,D are valid */
+  char validHMS;   /* True if h,m,s are valid */
+  char validJD;    /* True if rJD is valid */
+  char validTZ;    /* True if tz is valid */
+};
+
+
+/*
+** Convert zDate into one or more integers.  Additional arguments
+** come in groups of 5 as follows:
+**
+**       N       number of digits in the integer
+**       min     minimum allowed value of the integer
+**       max     maximum allowed value of the integer
+**       nextC   first character after the integer
+**       pVal    where to write the integers value.
+**
+** Conversions continue until one with nextC==0 is encountered.
+** The function returns the number of successful conversions.
+*/
+static int getDigits(const char *zDate, ...){
+  va_list ap;
+  int val;
+  int N;
+  int min;
+  int max;
+  int nextC;
+  int *pVal;
+  int cnt = 0;
+  va_start(ap, zDate);
+  do{
+    N = va_arg(ap, int);
+    min = va_arg(ap, int);
+    max = va_arg(ap, int);
+    nextC = va_arg(ap, int);
+    pVal = va_arg(ap, int*);
+    val = 0;
+    while( N-- ){
+      if( !isdigit(*(u8*)zDate) ){
+        goto end_getDigits;
+      }
+      val = val*10 + *zDate - '0';
+      zDate++;
+    }
+    if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
+      goto end_getDigits;
+    }
+    *pVal = val;
+    zDate++;
+    cnt++;
+  }while( nextC );
+end_getDigits:
+  va_end(ap);
+  return cnt;
+}
+
+/*
+** Read text from z[] and convert into a floating point number.  Return
+** the number of digits converted.
+*/
+#define getValue sqlite3AtoF
+
+/*
+** Parse a timezone extension on the end of a date-time.
+** The extension is of the form:
+**
+**        (+/-)HH:MM
+**
+** If the parse is successful, write the number of minutes
+** of change in *pnMin and return 0.  If a parser error occurs,
+** return 0.
+**
+** A missing specifier is not considered an error.
+*/
+static int parseTimezone(const char *zDate, DateTime *p){
+  int sgn = 0;
+  int nHr, nMn;
+  while( isspace(*(u8*)zDate) ){ zDate++; }
+  p->tz = 0;
+  if( *zDate=='-' ){
+    sgn = -1;
+  }else if( *zDate=='+' ){
+    sgn = +1;
+  }else{
+    return *zDate!=0;
+  }
+  zDate++;
+  if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
+    return 1;
+  }
+  zDate += 5;
+  p->tz = sgn*(nMn + nHr*60);
+  while( isspace(*(u8*)zDate) ){ zDate++; }
+  return *zDate!=0;
+}
+
+/*
+** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
+** The HH, MM, and SS must each be exactly 2 digits.  The
+** fractional seconds FFFF can be one or more digits.
+**
+** Return 1 if there is a parsing error and 0 on success.
+*/
+static int parseHhMmSs(const char *zDate, DateTime *p){
+  int h, m, s;
+  double ms = 0.0;
+  if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
+    return 1;
+  }
+  zDate += 5;
+  if( *zDate==':' ){
+    zDate++;
+    if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
+      return 1;
+    }
+    zDate += 2;
+    if( *zDate=='.' && isdigit((u8)zDate[1]) ){
+      double rScale = 1.0;
+      zDate++;
+      while( isdigit(*(u8*)zDate) ){
+        ms = ms*10.0 + *zDate - '0';
+        rScale *= 10.0;
+        zDate++;
+      }
+      ms /= rScale;
+    }
+  }else{
+    s = 0;
+  }
+  p->validJD = 0;
+  p->validHMS = 1;
+  p->h = h;
+  p->m = m;
+  p->s = s + ms;
+  if( parseTimezone(zDate, p) ) return 1;
+  p->validTZ = p->tz!=0;
+  return 0;
+}
+
+/*
+** Convert from YYYY-MM-DD HH:MM:SS to julian day.  We always assume
+** that the YYYY-MM-DD is according to the Gregorian calendar.
+**
+** Reference:  Meeus page 61
+*/
+static void computeJD(DateTime *p){
+  int Y, M, D, A, B, X1, X2;
+
+  if( p->validJD ) return;
+  if( p->validYMD ){
+    Y = p->Y;
+    M = p->M;
+    D = p->D;
+  }else{
+    Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
+    M = 1;
+    D = 1;
+  }
+  if( M<=2 ){
+    Y--;
+    M += 12;
+  }
+  A = Y/100;
+  B = 2 - A + (A/4);
+  X1 = 365.25*(Y+4716);
+  X2 = 30.6001*(M+1);
+  p->rJD = X1 + X2 + D + B - 1524.5;
+  p->validJD = 1;
+  if( p->validHMS ){
+    p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0;
+    if( p->validTZ ){
+      p->rJD -= p->tz*60/86400.0;
+      p->validYMD = 0;
+      p->validHMS = 0;
+      p->validTZ = 0;
+    }
+  }
+}
+
+/*
+** Parse dates of the form
+**
+**     YYYY-MM-DD HH:MM:SS.FFF
+**     YYYY-MM-DD HH:MM:SS
+**     YYYY-MM-DD HH:MM
+**     YYYY-MM-DD
+**
+** Write the result into the DateTime structure and return 0
+** on success and 1 if the input string is not a well-formed
+** date.
+*/
+static int parseYyyyMmDd(const char *zDate, DateTime *p){
+  int Y, M, D, neg;
+
+  if( zDate[0]=='-' ){
+    zDate++;
+    neg = 1;
+  }else{
+    neg = 0;
+  }
+  if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
+    return 1;
+  }
+  zDate += 10;
+  while( isspace(*(u8*)zDate) || 'T'==*(u8*)zDate ){ zDate++; }
+  if( parseHhMmSs(zDate, p)==0 ){
+    /* We got the time */
+  }else if( *zDate==0 ){
+    p->validHMS = 0;
+  }else{
+    return 1;
+  }
+  p->validJD = 0;
+  p->validYMD = 1;
+  p->Y = neg ? -Y : Y;
+  p->M = M;
+  p->D = D;
+  if( p->validTZ ){
+    computeJD(p);
+  }
+  return 0;
+}
+
+/*
+** Attempt to parse the given string into a Julian Day Number.  Return
+** the number of errors.
+**
+** The following are acceptable forms for the input string:
+**
+**      YYYY-MM-DD HH:MM:SS.FFF  +/-HH:MM
+**      DDDD.DD 
+**      now
+**
+** In the first form, the +/-HH:MM is always optional.  The fractional
+** seconds extension (the ".FFF") is optional.  The seconds portion
+** (":SS.FFF") is option.  The year and date can be omitted as long
+** as there is a time string.  The time string can be omitted as long
+** as there is a year and date.
+*/
+static int parseDateOrTime(
+  sqlite3_context *context, 
+  const char *zDate, 
+  DateTime *p
+){
+  memset(p, 0, sizeof(*p));
+  if( parseYyyyMmDd(zDate,p)==0 ){
+    return 0;
+  }else if( parseHhMmSs(zDate, p)==0 ){
+    return 0;
+  }else if( sqlite3StrICmp(zDate,"now")==0){
+    double r;
+    sqlite3OsCurrentTime((sqlite3_vfs *)sqlite3_user_data(context), &r);
+    p->rJD = r;
+    p->validJD = 1;
+    return 0;
+  }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){
+    getValue(zDate, &p->rJD);
+    p->validJD = 1;
+    return 0;
+  }
+  return 1;
+}
+
+/*
+** Compute the Year, Month, and Day from the julian day number.
+*/
+static void computeYMD(DateTime *p){
+  int Z, A, B, C, D, E, X1;
+  if( p->validYMD ) return;
+  if( !p->validJD ){
+    p->Y = 2000;
+    p->M = 1;
+    p->D = 1;
+  }else{
+    Z = p->rJD + 0.5;
+    A = (Z - 1867216.25)/36524.25;
+    A = Z + 1 + A - (A/4);
+    B = A + 1524;
+    C = (B - 122.1)/365.25;
+    D = 365.25*C;
+    E = (B-D)/30.6001;
+    X1 = 30.6001*E;
+    p->D = B - D - X1;
+    p->M = E<14 ? E-1 : E-13;
+    p->Y = p->M>2 ? C - 4716 : C - 4715;
+  }
+  p->validYMD = 1;
+}
+
+/*
+** Compute the Hour, Minute, and Seconds from the julian day number.
+*/
+static void computeHMS(DateTime *p){
+  int Z, s;
+  if( p->validHMS ) return;
+  computeJD(p);
+  Z = p->rJD + 0.5;
+  s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5;
+  p->s = 0.001*s;
+  s = p->s;
+  p->s -= s;
+  p->h = s/3600;
+  s -= p->h*3600;
+  p->m = s/60;
+  p->s += s - p->m*60;
+  p->validHMS = 1;
+}
+
+/*
+** Compute both YMD and HMS
+*/
+static void computeYMD_HMS(DateTime *p){
+  computeYMD(p);
+  computeHMS(p);
+}
+
+/*
+** Clear the YMD and HMS and the TZ
+*/
+static void clearYMD_HMS_TZ(DateTime *p){
+  p->validYMD = 0;
+  p->validHMS = 0;
+  p->validTZ = 0;
+}
+
+/*
+** Compute the difference (in days) between localtime and UTC (a.k.a. GMT)
+** for the time value p where p is in UTC.
+*/
+static double localtimeOffset(DateTime *p){
+  DateTime x, y;
+  time_t t;
+  x = *p;
+  computeYMD_HMS(&x);
+  if( x.Y<1971 || x.Y>=2038 ){
+    x.Y = 2000;
+    x.M = 1;
+    x.D = 1;
+    x.h = 0;
+    x.m = 0;
+    x.s = 0.0;
+  } else {
+    int s = x.s + 0.5;
+    x.s = s;
+  }
+  x.tz = 0;
+  x.validJD = 0;
+  computeJD(&x);
+  t = (x.rJD-2440587.5)*86400.0 + 0.5;
+#ifdef HAVE_LOCALTIME_R
+  {
+    struct tm sLocal;
+    localtime_r(&t, &sLocal);
+    y.Y = sLocal.tm_year + 1900;
+    y.M = sLocal.tm_mon + 1;
+    y.D = sLocal.tm_mday;
+    y.h = sLocal.tm_hour;
+    y.m = sLocal.tm_min;
+    y.s = sLocal.tm_sec;
+  }
+#else
+  {
+    struct tm *pTm;
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+    pTm = localtime(&t);
+    y.Y = pTm->tm_year + 1900;
+    y.M = pTm->tm_mon + 1;
+    y.D = pTm->tm_mday;
+    y.h = pTm->tm_hour;
+    y.m = pTm->tm_min;
+    y.s = pTm->tm_sec;
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+  }
+#endif
+  y.validYMD = 1;
+  y.validHMS = 1;
+  y.validJD = 0;
+  y.validTZ = 0;
+  computeJD(&y);
+  return y.rJD - x.rJD;
+}
+
+/*
+** Process a modifier to a date-time stamp.  The modifiers are
+** as follows:
+**
+**     NNN days
+**     NNN hours
+**     NNN minutes
+**     NNN.NNNN seconds
+**     NNN months
+**     NNN years
+**     start of month
+**     start of year
+**     start of week
+**     start of day
+**     weekday N
+**     unixepoch
+**     localtime
+**     utc
+**
+** Return 0 on success and 1 if there is any kind of error.
+*/
+static int parseModifier(const char *zMod, DateTime *p){
+  int rc = 1;
+  int n;
+  double r;
+  char *z, zBuf[30];
+  z = zBuf;
+  for(n=0; n<sizeof(zBuf)-1 && zMod[n]; n++){
+    z[n] = tolower(zMod[n]);
+  }
+  z[n] = 0;
+  switch( z[0] ){
+    case 'l': {
+      /*    localtime
+      **
+      ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
+      ** show local time.
+      */
+      if( strcmp(z, "localtime")==0 ){
+        computeJD(p);
+        p->rJD += localtimeOffset(p);
+        clearYMD_HMS_TZ(p);
+        rc = 0;
+      }
+      break;
+    }
+    case 'u': {
+      /*
+      **    unixepoch
+      **
+      ** Treat the current value of p->rJD as the number of
+      ** seconds since 1970.  Convert to a real julian day number.
+      */
+      if( strcmp(z, "unixepoch")==0 && p->validJD ){
+        p->rJD = p->rJD/86400.0 + 2440587.5;
+        clearYMD_HMS_TZ(p);
+        rc = 0;
+      }else if( strcmp(z, "utc")==0 ){
+        double c1;
+        computeJD(p);
+        c1 = localtimeOffset(p);
+        p->rJD -= c1;
+        clearYMD_HMS_TZ(p);
+        p->rJD += c1 - localtimeOffset(p);
+        rc = 0;
+      }
+      break;
+    }
+    case 'w': {
+      /*
+      **    weekday N
+      **
+      ** Move the date to the same time on the next occurrence of
+      ** weekday N where 0==Sunday, 1==Monday, and so forth.  If the
+      ** date is already on the appropriate weekday, this is a no-op.
+      */
+      if( strncmp(z, "weekday ", 8)==0 && getValue(&z[8],&r)>0
+                 && (n=r)==r && n>=0 && r<7 ){
+        int Z;
+        computeYMD_HMS(p);
+        p->validTZ = 0;
+        p->validJD = 0;
+        computeJD(p);
+        Z = p->rJD + 1.5;
+        Z %= 7;
+        if( Z>n ) Z -= 7;
+        p->rJD += n - Z;
+        clearYMD_HMS_TZ(p);
+        rc = 0;
+      }
+      break;
+    }
+    case 's': {
+      /*
+      **    start of TTTTT
+      **
+      ** Move the date backwards to the beginning of the current day,
+      ** or month or year.
+      */
+      if( strncmp(z, "start of ", 9)!=0 ) break;
+      z += 9;
+      computeYMD(p);
+      p->validHMS = 1;
+      p->h = p->m = 0;
+      p->s = 0.0;
+      p->validTZ = 0;
+      p->validJD = 0;
+      if( strcmp(z,"month")==0 ){
+        p->D = 1;
+        rc = 0;
+      }else if( strcmp(z,"year")==0 ){
+        computeYMD(p);
+        p->M = 1;
+        p->D = 1;
+        rc = 0;
+      }else if( strcmp(z,"day")==0 ){
+        rc = 0;
+      }
+      break;
+    }
+    case '+':
+    case '-':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9': {
+      n = getValue(z, &r);
+      assert( n>=1 );
+      if( z[n]==':' ){
+        /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
+        ** specified number of hours, minutes, seconds, and fractional seconds
+        ** to the time.  The ".FFF" may be omitted.  The ":SS.FFF" may be
+        ** omitted.
+        */
+        const char *z2 = z;
+        DateTime tx;
+        int day;
+        if( !isdigit(*(u8*)z2) ) z2++;
+        memset(&tx, 0, sizeof(tx));
+        if( parseHhMmSs(z2, &tx) ) break;
+        computeJD(&tx);
+        tx.rJD -= 0.5;
+        day = (int)tx.rJD;
+        tx.rJD -= day;
+        if( z[0]=='-' ) tx.rJD = -tx.rJD;
+        computeJD(p);
+        clearYMD_HMS_TZ(p);
+        p->rJD += tx.rJD;
+        rc = 0;
+        break;
+      }
+      z += n;
+      while( isspace(*(u8*)z) ) z++;
+      n = strlen(z);
+      if( n>10 || n<3 ) break;
+      if( z[n-1]=='s' ){ z[n-1] = 0; n--; }
+      computeJD(p);
+      rc = 0;
+      if( n==3 && strcmp(z,"day")==0 ){
+        p->rJD += r;
+      }else if( n==4 && strcmp(z,"hour")==0 ){
+        p->rJD += r/24.0;
+      }else if( n==6 && strcmp(z,"minute")==0 ){
+        p->rJD += r/(24.0*60.0);
+      }else if( n==6 && strcmp(z,"second")==0 ){
+        p->rJD += r/(24.0*60.0*60.0);
+      }else if( n==5 && strcmp(z,"month")==0 ){
+        int x, y;
+        computeYMD_HMS(p);
+        p->M += r;
+        x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
+        p->Y += x;
+        p->M -= x*12;
+        p->validJD = 0;
+        computeJD(p);
+        y = r;
+        if( y!=r ){
+          p->rJD += (r - y)*30.0;
+        }
+      }else if( n==4 && strcmp(z,"year")==0 ){
+        computeYMD_HMS(p);
+        p->Y += r;
+        p->validJD = 0;
+        computeJD(p);
+      }else{
+        rc = 1;
+      }
+      clearYMD_HMS_TZ(p);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return rc;
+}
+
+/*
+** Process time function arguments.  argv[0] is a date-time stamp.
+** argv[1] and following are modifiers.  Parse them all and write
+** the resulting time into the DateTime structure p.  Return 0
+** on success and 1 if there are any errors.
+**
+** If there are zero parameters (if even argv[0] is undefined)
+** then assume a default value of "now" for argv[0].
+*/
+static int isDate(
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv, 
+  DateTime *p
+){
+  int i;
+  const unsigned char *z;
+  static const unsigned char zDflt[] = "now";
+  if( argc==0 ){
+    z = zDflt;
+  }else{
+    z = sqlite3_value_text(argv[0]);
+  }
+  if( !z || parseDateOrTime(context, (char*)z, p) ){
+    return 1;
+  }
+  for(i=1; i<argc; i++){
+    if( (z = sqlite3_value_text(argv[i]))==0 || parseModifier((char*)z, p) ){
+      return 1;
+    }
+  }
+  return 0;
+}
+
+
+/*
+** The following routines implement the various date and time functions
+** of SQLite.
+*/
+
+/*
+**    julianday( TIMESTRING, MOD, MOD, ...)
+**
+** Return the julian day number of the date specified in the arguments
+*/
+static void juliandayFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  if( isDate(context, argc, argv, &x)==0 ){
+    computeJD(&x);
+    sqlite3_result_double(context, x.rJD);
+  }
+}
+
+/*
+**    datetime( TIMESTRING, MOD, MOD, ...)
+**
+** Return YYYY-MM-DD HH:MM:SS
+*/
+static void datetimeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  if( isDate(context, argc, argv, &x)==0 ){
+    char zBuf[100];
+    computeYMD_HMS(&x);
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
+                     x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+  }
+}
+
+/*
+**    time( TIMESTRING, MOD, MOD, ...)
+**
+** Return HH:MM:SS
+*/
+static void timeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  if( isDate(context, argc, argv, &x)==0 ){
+    char zBuf[100];
+    computeHMS(&x);
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+  }
+}
+
+/*
+**    date( TIMESTRING, MOD, MOD, ...)
+**
+** Return YYYY-MM-DD
+*/
+static void dateFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  if( isDate(context, argc, argv, &x)==0 ){
+    char zBuf[100];
+    computeYMD(&x);
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+  }
+}
+
+/*
+**    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
+**
+** Return a string described by FORMAT.  Conversions as follows:
+**
+**   %d  day of month
+**   %f  ** fractional seconds  SS.SSS
+**   %H  hour 00-24
+**   %j  day of year 000-366
+**   %J  ** Julian day number
+**   %m  month 01-12
+**   %M  minute 00-59
+**   %s  seconds since 1970-01-01
+**   %S  seconds 00-59
+**   %w  day of week 0-6  sunday==0
+**   %W  week of year 00-53
+**   %Y  year 0000-9999
+**   %%  %
+*/
+static void strftimeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  DateTime x;
+  u64 n;
+  int i, j;
+  char *z;
+  const char *zFmt = (const char*)sqlite3_value_text(argv[0]);
+  char zBuf[100];
+  if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
+  for(i=0, n=1; zFmt[i]; i++, n++){
+    if( zFmt[i]=='%' ){
+      switch( zFmt[i+1] ){
+        case 'd':
+        case 'H':
+        case 'm':
+        case 'M':
+        case 'S':
+        case 'W':
+          n++;
+          /* fall thru */
+        case 'w':
+        case '%':
+          break;
+        case 'f':
+          n += 8;
+          break;
+        case 'j':
+          n += 3;
+          break;
+        case 'Y':
+          n += 8;
+          break;
+        case 's':
+        case 'J':
+          n += 50;
+          break;
+        default:
+          return;  /* ERROR.  return a NULL */
+      }
+      i++;
+    }
+  }
+  if( n<sizeof(zBuf) ){
+    z = zBuf;
+  }else if( n>SQLITE_MAX_LENGTH ){
+    sqlite3_result_error_toobig(context);
+    return;
+  }else{
+    z = sqlite3_malloc( n );
+    if( z==0 ){
+      sqlite3_result_error_nomem(context);
+      return;
+    }
+  }
+  computeJD(&x);
+  computeYMD_HMS(&x);
+  for(i=j=0; zFmt[i]; i++){
+    if( zFmt[i]!='%' ){
+      z[j++] = zFmt[i];
+    }else{
+      i++;
+      switch( zFmt[i] ){
+        case 'd':  sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
+        case 'f': {
+          double s = x.s;
+          if( s>59.999 ) s = 59.999;
+          sqlite3_snprintf(7, &z[j],"%06.3f", s);
+          j += strlen(&z[j]);
+          break;
+        }
+        case 'H':  sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
+        case 'W': /* Fall thru */
+        case 'j': {
+          int nDay;             /* Number of days since 1st day of year */
+          DateTime y = x;
+          y.validJD = 0;
+          y.M = 1;
+          y.D = 1;
+          computeJD(&y);
+          nDay = x.rJD - y.rJD + 0.5;
+          if( zFmt[i]=='W' ){
+            int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
+            wd = ((int)(x.rJD+0.5)) % 7;
+            sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
+            j += 2;
+          }else{
+            sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
+            j += 3;
+          }
+          break;
+        }
+        case 'J': {
+          sqlite3_snprintf(20, &z[j],"%.16g",x.rJD);
+          j+=strlen(&z[j]);
+          break;
+        }
+        case 'm':  sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
+        case 'M':  sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
+        case 's': {
+          sqlite3_snprintf(30,&z[j],"%d",
+                           (int)((x.rJD-2440587.5)*86400.0 + 0.5));
+          j += strlen(&z[j]);
+          break;
+        }
+        case 'S':  sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
+        case 'w':  z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break;
+        case 'Y':  sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=strlen(&z[j]);break;
+        default:   z[j++] = '%'; break;
+      }
+    }
+  }
+  z[j] = 0;
+  sqlite3_result_text(context, z, -1,
+                      z==zBuf ? SQLITE_TRANSIENT : sqlite3_free);
+}
+
+/*
+** current_time()
+**
+** This function returns the same value as time('now').
+*/
+static void ctimeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  timeFunc(context, 0, 0);
+}
+
+/*
+** current_date()
+**
+** This function returns the same value as date('now').
+*/
+static void cdateFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  dateFunc(context, 0, 0);
+}
+
+/*
+** current_timestamp()
+**
+** This function returns the same value as datetime('now').
+*/
+static void ctimestampFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  datetimeFunc(context, 0, 0);
+}
+#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
+
+#ifdef SQLITE_OMIT_DATETIME_FUNCS
+/*
+** If the library is compiled to omit the full-scale date and time
+** handling (to get a smaller binary), the following minimal version
+** of the functions current_time(), current_date() and current_timestamp()
+** are included instead. This is to support column declarations that
+** include "DEFAULT CURRENT_TIME" etc.
+**
+** This function uses the C-library functions time(), gmtime()
+** and strftime(). The format string to pass to strftime() is supplied
+** as the user-data for the function.
+*/
+static void currentTimeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  time_t t;
+  char *zFormat = (char *)sqlite3_user_data(context);
+  char zBuf[20];
+
+  time(&t);
+#ifdef SQLITE_TEST
+  {
+    extern int sqlite3_current_time;  /* See os_XXX.c */
+    if( sqlite3_current_time ){
+      t = sqlite3_current_time;
+    }
+  }
+#endif
+
+#ifdef HAVE_GMTIME_R
+  {
+    struct tm sNow;
+    gmtime_r(&t, &sNow);
+    strftime(zBuf, 20, zFormat, &sNow);
+  }
+#else
+  {
+    struct tm *pTm;
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+    pTm = gmtime(&t);
+    strftime(zBuf, 20, zFormat, pTm);
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+  }
+#endif
+
+  sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+}
+#endif
+
+/*
+** This function registered all of the above C functions as SQL
+** functions.  This should be the only routine in this file with
+** external linkage.
+*/
+void sqlite3RegisterDateTimeFunctions(sqlite3 *db){
+#ifndef SQLITE_OMIT_DATETIME_FUNCS
+  static const struct {
+     char *zName;
+     int nArg;
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
+  } aFuncs[] = {
+    { "julianday", -1, juliandayFunc   },
+    { "date",      -1, dateFunc        },
+    { "time",      -1, timeFunc        },
+    { "datetime",  -1, datetimeFunc    },
+    { "strftime",  -1, strftimeFunc    },
+    { "current_time",       0, ctimeFunc      },
+    { "current_timestamp",  0, ctimestampFunc },
+    { "current_date",       0, cdateFunc      },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
+    sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
+        SQLITE_UTF8, (void *)(db->pVfs), aFuncs[i].xFunc, 0, 0);
+  }
+#else
+  static const struct {
+     char *zName;
+     char *zFormat;
+  } aFuncs[] = {
+    { "current_time", "%H:%M:%S" },
+    { "current_date", "%Y-%m-%d" },
+    { "current_timestamp", "%Y-%m-%d %H:%M:%S" }
+  };
+  int i;
+
+  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
+    sqlite3CreateFunc(db, aFuncs[i].zName, 0, SQLITE_UTF8, 
+        aFuncs[i].zFormat, currentTimeFunc, 0, 0);
+  }
+#endif
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/delete.c b/client/src/thirdparty/sqlite-3.4.2/src/delete.c
new file mode 100644
index 0000000..5fffc8e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/delete.c
@@ -0,0 +1,510 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.160 2008/01/25 15:04:50 drh 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.
+*/
+Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
+  Table *pTab = 0;
+  int i;
+  struct SrcList_item *pItem;
+  for(i=0, pItem=pSrc->a; i<pSrc->nSrc; i++, pItem++){
+    pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
+    sqlite3DeleteTable(pItem->pTab);
+    pItem->pTab = pTab;
+    if( pTab ){
+      pTab->nRef++;
+    }
+  }
+  return pTab;
+}
+
+/*
+** Check to make sure the given table is writable.  If it is not
+** writable, generate an error message and return 1.  If it is
+** writable return 0;
+*/
+int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
+  if( (pTab->readOnly && (pParse->db->flags & SQLITE_WriteSchema)==0
+        && pParse->nested==0) 
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      || (pTab->pMod && pTab->pMod->pModule->xUpdate==0)
+#endif
+  ){
+    sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
+    return 1;
+  }
+#ifndef SQLITE_OMIT_VIEW
+  if( !viewOk && pTab->pSelect ){
+    sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
+    return 1;
+  }
+#endif
+  return 0;
+}
+
+/*
+** Generate code that will open a table for reading.
+*/
+void sqlite3OpenTable(
+  Parse *p,       /* Generate code into this VDBE */
+  int iCur,       /* The cursor number of the table */
+  int iDb,        /* The database index in sqlite3.aDb[] */
+  Table *pTab,    /* The table to be opened */
+  int opcode      /* OP_OpenRead or OP_OpenWrite */
+){
+  Vdbe *v;
+  if( IsVirtual(pTab) ) return;
+  v = sqlite3GetVdbe(p);
+  assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
+  sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite), pTab->zName);
+  sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
+  VdbeComment((v, "%s", pTab->zName));
+  sqlite3VdbeAddOp2(v, OP_SetNumColumns, iCur, pTab->nCol);
+}
+
+
+/*
+** Generate code for a DELETE FROM statement.
+**
+**     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
+**                 \________/       \________________/
+**                  pTabList              pWhere
+*/
+void sqlite3DeleteFrom(
+  Parse *pParse,         /* The parser context */
+  SrcList *pTabList,     /* The table from which we should delete things */
+  Expr *pWhere           /* The WHERE clause.  May be null */
+){
+  Vdbe *v;               /* The virtual database engine */
+  Table *pTab;           /* The table from which records will be deleted */
+  const char *zDb;       /* Name of database holding pTab */
+  int end, addr = 0;     /* A couple addresses of generated code */
+  int i;                 /* Loop counter */
+  WhereInfo *pWInfo;     /* Information about the WHERE clause */
+  Index *pIdx;           /* For looping over indices of the table */
+  int iCur;              /* VDBE Cursor number for pTab */
+  sqlite3 *db;           /* Main database structure */
+  AuthContext sContext;  /* Authorization context */
+  int oldIdx = -1;       /* Cursor for the OLD table of AFTER triggers */
+  NameContext sNC;       /* Name context to resolve expressions in */
+  int iDb;               /* Database number */
+  int memCnt = 0;        /* Memory cell used for change counting */
+
+#ifndef SQLITE_OMIT_TRIGGER
+  int isView;                  /* True if attempting to delete from a view */
+  int triggers_exist = 0;      /* True if any triggers exist */
+#endif
+  int iBeginAfterTrigger;      /* Address of after trigger program */
+  int iEndAfterTrigger;        /* Exit of after trigger program */
+  int iBeginBeforeTrigger;     /* Address of before trigger program */
+  int iEndBeforeTrigger;       /* Exit of before trigger program */
+  u32 old_col_mask = 0;        /* Mask of OLD.* columns in use */
+
+  sContext.pParse = 0;
+  db = pParse->db;
+  if( pParse->nErr || db->mallocFailed ){
+    goto delete_from_cleanup;
+  }
+  assert( pTabList->nSrc==1 );
+
+  /* Locate the table which we want to delete.  This table has to be
+  ** put in an SrcList structure because some of the subroutines we
+  ** will be calling are designed to work with multiple tables and expect
+  ** an SrcList* parameter instead of just a Table* parameter.
+  */
+  pTab = sqlite3SrcListLookup(pParse, pTabList);
+  if( pTab==0 )  goto delete_from_cleanup;
+
+  /* Figure out if we have any triggers and if the table being
+  ** deleted from is a view
+  */
+#ifndef SQLITE_OMIT_TRIGGER
+  triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0);
+  isView = pTab->pSelect!=0;
+#else
+# define triggers_exist 0
+# define isView 0
+#endif
+#ifdef SQLITE_OMIT_VIEW
+# undef isView
+# define isView 0
+#endif
+
+  if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
+    goto delete_from_cleanup;
+  }
+  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+  assert( iDb<db->nDb );
+  zDb = db->aDb[iDb].zName;
+  if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
+    goto delete_from_cleanup;
+  }
+
+  /* If pTab is really a view, make sure it has been initialized.
+  */
+  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
+    goto delete_from_cleanup;
+  }
+
+  /* Allocate a cursor used to store the old.* data for a trigger.
+  */
+  if( triggers_exist ){ 
+    oldIdx = pParse->nTab++;
+  }
+
+  /* Resolve the column names in the WHERE clause.
+  */
+  assert( pTabList->nSrc==1 );
+  iCur = pTabList->a[0].iCursor = pParse->nTab++;
+  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    pParse->nTab++;
+  }
+  memset(&sNC, 0, sizeof(sNC));
+  sNC.pParse = pParse;
+  sNC.pSrcList = pTabList;
+  if( sqlite3ExprResolveNames(&sNC, pWhere) ){
+    goto delete_from_cleanup;
+  }
+
+  /* Start the view context
+  */
+  if( isView ){
+    sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
+  }
+
+  /* Begin generating code.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ){
+    goto delete_from_cleanup;
+  }
+  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
+  sqlite3BeginWriteOperation(pParse, triggers_exist, iDb);
+
+  if( triggers_exist ){
+    int orconf = ((pParse->trigStack)?pParse->trigStack->orconf:OE_Default);
+    int iGoto = sqlite3VdbeAddOp0(v, OP_Goto);
+    addr = sqlite3VdbeMakeLabel(v);
+
+    iBeginBeforeTrigger = sqlite3VdbeCurrentAddr(v);
+    (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_BEFORE, pTab,
+        -1, oldIdx, orconf, addr, &old_col_mask, 0);
+    iEndBeforeTrigger = sqlite3VdbeAddOp0(v, OP_Goto);
+
+    iBeginAfterTrigger = sqlite3VdbeCurrentAddr(v);
+    (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_AFTER, pTab, -1,
+        oldIdx, orconf, addr, &old_col_mask, 0);
+    iEndAfterTrigger = sqlite3VdbeAddOp0(v, OP_Goto);
+
+    sqlite3VdbeJumpHere(v, iGoto);
+  }
+
+  /* If we are trying to delete from a view, realize that view into
+  ** a ephemeral table.
+  */
+  if( isView ){
+    SelectDest dest;
+    Select *pView;
+
+    pView = sqlite3SelectDup(db, pTab->pSelect);
+    sqlite3SelectMask(pParse, pView, old_col_mask);
+    sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
+    sqlite3Select(pParse, pView, &dest, 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 ){
+    memCnt = ++pParse->nMem;
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
+  }
+
+  /* Special case: A DELETE without a WHERE clause deletes everything.
+  ** It is easier just to erase the whole table.  Note, however, that
+  ** this means that the row change count will be incorrect.
+  */
+  if( pWhere==0 && !triggers_exist && !IsVirtual(pTab) ){
+    if( db->flags & SQLITE_CountRows ){
+      /* If counting rows deleted, just count the total number of
+      ** entries in the table. */
+      int addr2;
+      if( !isView ){
+        sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
+      }
+      sqlite3VdbeAddOp2(v, OP_Rewind, iCur, sqlite3VdbeCurrentAddr(v)+2);
+      addr2 = sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
+      sqlite3VdbeAddOp2(v, OP_Next, iCur, addr2);
+      sqlite3VdbeAddOp1(v, OP_Close, iCur);
+    }
+    if( !isView ){
+      sqlite3VdbeAddOp2(v, OP_Clear, pTab->tnum, iDb);
+      if( !pParse->nested ){
+        sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
+      }
+      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+        assert( pIdx->pSchema==pTab->pSchema );
+        sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
+      }
+    }
+  } 
+  /* The usual case: There is a WHERE clause so we have to scan through
+  ** the table and pick which records to delete.
+  */
+  else{
+    int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */
+
+    /* Begin the database scan
+    */
+    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0);
+    if( pWInfo==0 ) goto delete_from_cleanup;
+
+    /* Remember the rowid of every item to be deleted.
+    */
+    sqlite3VdbeAddOp2(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid, iCur, iRowid);
+    sqlite3VdbeAddOp1(v, OP_FifoWrite, iRowid);
+    if( db->flags & SQLITE_CountRows ){
+      sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
+    }
+
+    /* End the database scan loop.
+    */
+    sqlite3WhereEnd(pWInfo);
+
+    /* Open the pseudo-table used to store OLD if there are triggers.
+    */
+    if( triggers_exist ){
+      sqlite3VdbeAddOp1(v, OP_OpenPseudo, oldIdx);
+      sqlite3VdbeAddOp2(v, OP_SetNumColumns, oldIdx, pTab->nCol);
+    }
+
+    /* Delete every item whose key was written to the list during the
+    ** database scan.  We have to delete items after the scan is complete
+    ** because deleting an item can change the scan order.
+    */
+    end = sqlite3VdbeMakeLabel(v);
+
+    if( !isView ){
+      /* Open cursors for the table we are deleting from and 
+      ** all its indices.
+      */
+      sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
+    }
+
+    /* This is the beginning of the delete loop. If a trigger encounters
+    ** an IGNORE constraint, it jumps back to here.
+    */
+    if( triggers_exist ){
+      sqlite3VdbeResolveLabel(v, addr);
+    }
+    addr = sqlite3VdbeAddOp2(v, OP_FifoRead, iRowid, end);
+
+    if( triggers_exist ){
+      int iData = ++pParse->nMem;   /* For storing row data of OLD table */
+
+      /* If the record is no longer present in the table, jump to the
+      ** next iteration of the loop through the contents of the fifo.
+      */
+      sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, iRowid);
+
+      /* Populate the OLD.* pseudo-table */
+      if( old_col_mask ){
+        sqlite3VdbeAddOp2(v, OP_RowData, iCur, iData);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Null, 0, iData);
+      }
+      sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, iData, iRowid);
+
+      /* Jump back and run the BEFORE triggers */
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginBeforeTrigger);
+      sqlite3VdbeJumpHere(v, iEndBeforeTrigger);
+    }
+
+    if( !isView ){
+      /* Delete the row */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      if( IsVirtual(pTab) ){
+        const char *pVtab = (const char *)pTab->pVtab;
+        pParse->pVirtualLock = pTab;
+        sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVtab, P4_VTAB);
+      }else
+#endif
+      {
+        sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, pParse->nested==0);
+      }
+    }
+
+    /* If there are row triggers, close all cursors then invoke
+    ** the AFTER triggers
+    */
+    if( triggers_exist ){
+      /* Jump back and run the AFTER triggers */
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger);
+      sqlite3VdbeJumpHere(v, iEndAfterTrigger);
+    }
+
+    /* End of the delete loop */
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
+    sqlite3VdbeResolveLabel(v, end);
+
+    /* Close the cursors after the loop if there are no row triggers */
+    if( !isView  && !IsVirtual(pTab) ){
+      for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
+        sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
+      }
+      sqlite3VdbeAddOp1(v, OP_Close, iCur);
+    }
+  }
+
+  /*
+  ** Return the number of rows that were deleted. If this routine is 
+  ** generating code because of a call to sqlite3NestedParse(), do not
+  ** invoke the callback function.
+  */
+  if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){
+    sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", P4_STATIC);
+  }
+
+delete_from_cleanup:
+  sqlite3AuthContextPop(&sContext);
+  sqlite3SrcListDelete(pTabList);
+  sqlite3ExprDelete(pWhere);
+  return;
+}
+
+/*
+** This routine generates VDBE code that causes a single row of a
+** single table to be deleted.
+**
+** The VDBE must be in a particular state when this routine is called.
+** These are the requirements:
+**
+**   1.  A read/write cursor pointing to pTab, the table containing the row
+**       to be deleted, must be opened as cursor number "base".
+**
+**   2.  Read/write cursors for all indices of pTab must be open as
+**       cursor number base+i for the i-th index.
+**
+**   3.  The record number of the row to be deleted must be stored in
+**       memory cell iRowid.
+**
+** This routine pops the top of the stack to remove the record number
+** and then generates code to remove both the table record and all index
+** entries that point to that record.
+*/
+void sqlite3GenerateRowDelete(
+  Parse *pParse,     /* Parsing context */
+  Table *pTab,       /* Table containing the row to be deleted */
+  int iCur,          /* Cursor number for the table */
+  int iRowid,        /* Memory cell that contains the rowid to delete */
+  int count          /* Increment the row change counter */
+){
+  int addr;
+  Vdbe *v;
+
+  v = pParse->pVdbe;
+  addr = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowid);
+  sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
+  sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
+  if( count ){
+    sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
+  }
+  sqlite3VdbeJumpHere(v, addr);
+}
+
+/*
+** 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.
+** These are the requirements:
+**
+**   1.  A read/write cursor pointing to pTab, the table containing the row
+**       to be deleted, must be opened as cursor number "iCur".
+**
+**   2.  Read/write cursors for all indices of pTab must be open as
+**       cursor number iCur+i for the i-th index.
+**
+**   3.  The "iCur" cursor must be pointing to the row that is to be
+**       deleted.
+*/
+void sqlite3GenerateRowIndexDelete(
+  Parse *pParse,     /* Parsing and code generating context */
+  Table *pTab,       /* Table containing the row to be deleted */
+  int iCur,          /* Cursor number for the table */
+  int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
+){
+  int i;
+  Index *pIdx;
+  int r1;
+
+  r1 = sqlite3GetTempReg(pParse);
+  for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
+    if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
+    sqlite3GenerateIndexKey(pParse, pIdx, iCur, r1);
+    sqlite3VdbeAddOp2(pParse->pVdbe, OP_IdxDelete, iCur+i, r1);
+  }
+  sqlite3ReleaseTempReg(pParse, r1);
+}
+
+/*
+** Generate code that will assemble an index key and put it on the top
+** of the tack.  The key with be for index pIdx which is an index on pTab.
+** iCur is the index of a cursor open on the pTab table and pointing to
+** the entry that needs indexing.
+**
+** Return a register number which is the first in a block of
+** registers that holds the elements of the index key.  The
+** block of registers has already been deallocated by the time
+** this routine returns.
+*/
+int sqlite3GenerateIndexKey(
+  Parse *pParse,     /* Parsing context */
+  Index *pIdx,       /* The index for which to generate a key */
+  int iCur,          /* Cursor number for the pIdx->pTable table */
+  int regOut         /* Write the new index key to this register */
+){
+  Vdbe *v = pParse->pVdbe;
+  int j;
+  Table *pTab = pIdx->pTable;
+  int regBase;
+  int nCol;
+
+  nCol = pIdx->nColumn;
+  regBase = sqlite3GetTempRange(pParse, nCol+1);
+  sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
+  for(j=0; j<nCol; j++){
+    int idx = pIdx->aiColumn[j];
+    if( idx==pTab->iPKey ){
+      sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
+    }else{
+      sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
+      sqlite3ColumnDefault(v, pTab, idx);
+    }
+  }
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
+  sqlite3IndexAffinityStr(v, pIdx);
+  sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
+  return regBase;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/experimental.c b/client/src/thirdparty/sqlite-3.4.2/src/experimental.c
new file mode 100644
index 0000000..052eb0b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/experimental.c
@@ -0,0 +1,37 @@
+/*
+** 2005 January 20
+**
+** 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 C code routines that are not a part of the official
+** SQLite API.  These routines are unsupported.
+**
+** $Id: experimental.c,v 1.4 2006/01/31 20:49:13 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "os.h"
+
+/*
+** Set all the parameters in the compiled SQL statement to NULL.
+*/
+int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
+  int i;
+  int rc = SQLITE_OK;
+  for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
+    rc = sqlite3_bind_null(pStmt, i);
+  }
+  return rc;
+}
+
+/*
+** Sleep for a little while.  Return the amount of time slept.
+*/
+int sqlite3_sleep(int ms){
+  return sqlite3OsSleep(ms);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/expr.c b/client/src/thirdparty/sqlite-3.4.2/src/expr.c
new file mode 100644
index 0000000..e74bdd1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/expr.c
@@ -0,0 +1,2983 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains routines used for analyzing expressions and
+** for generating VDBE code that evaluates expressions in SQLite.
+**
+** $Id: expr.c,v 1.352 2008/01/23 14:51:49 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+
+/*
+** Return the 'affinity' of the expression pExpr if any.
+**
+** If pExpr is a column, a reference to a column via an 'AS' alias,
+** or a sub-select with a column as the return value, then the 
+** affinity of that column is returned. Otherwise, 0x00 is returned,
+** indicating no affinity for the expression.
+**
+** i.e. the WHERE clause expresssions in the following statements all
+** have an affinity:
+**
+** CREATE TABLE t1(a);
+** SELECT * FROM t1 WHERE a;
+** SELECT a AS b FROM t1 WHERE b;
+** SELECT * FROM t1 WHERE (select a from t1);
+*/
+char sqlite3ExprAffinity(Expr *pExpr){
+  int op = pExpr->op;
+  if( op==TK_SELECT ){
+    return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr);
+  }
+#ifndef SQLITE_OMIT_CAST
+  if( op==TK_CAST ){
+    return sqlite3AffinityType(&pExpr->token);
+  }
+#endif
+  return pExpr->affinity;
+}
+
+/*
+** Set the collating sequence for expression pExpr to be the collating
+** sequence named by pToken.   Return a pointer to the revised expression.
+** The collating sequence is marked as "explicit" using the EP_ExpCollate
+** flag.  An explicit collating sequence will override implicit
+** collating sequences.
+*/
+Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pName){
+  char *zColl = 0;            /* Dequoted name of collation sequence */
+  CollSeq *pColl;
+  zColl = sqlite3NameFromToken(pParse->db, pName);
+  if( pExpr && zColl ){
+    pColl = sqlite3LocateCollSeq(pParse, zColl, -1);
+    if( pColl ){
+      pExpr->pColl = pColl;
+      pExpr->flags |= EP_ExpCollate;
+    }
+  }
+  sqlite3_free(zColl);
+  return pExpr;
+}
+
+/*
+** Return the default collation sequence for the expression pExpr. If
+** there is no default collation type, return 0.
+*/
+CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
+  CollSeq *pColl = 0;
+  if( pExpr ){
+    int op;
+    pColl = pExpr->pColl;
+    op = pExpr->op;
+    if( (op==TK_CAST || op==TK_UPLUS) && !pColl ){
+      return sqlite3ExprCollSeq(pParse, pExpr->pLeft);
+    }
+  }
+  if( sqlite3CheckCollSeq(pParse, pColl) ){ 
+    pColl = 0;
+  }
+  return pColl;
+}
+
+/*
+** pExpr is an operand of a comparison operator.  aff2 is the
+** type affinity of the other operand.  This routine returns the
+** type affinity that should be used for the comparison operator.
+*/
+char sqlite3CompareAffinity(Expr *pExpr, char aff2){
+  char aff1 = sqlite3ExprAffinity(pExpr);
+  if( aff1 && aff2 ){
+    /* Both sides of the comparison are columns. If one has numeric
+    ** affinity, use that. Otherwise use no affinity.
+    */
+    if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
+      return SQLITE_AFF_NUMERIC;
+    }else{
+      return SQLITE_AFF_NONE;
+    }
+  }else if( !aff1 && !aff2 ){
+    /* Neither side of the comparison is a column.  Compare the
+    ** results directly.
+    */
+    return SQLITE_AFF_NONE;
+  }else{
+    /* One side is a column, the other is not. Use the columns affinity. */
+    assert( aff1==0 || aff2==0 );
+    return (aff1 + aff2);
+  }
+}
+
+/*
+** pExpr is a comparison operator.  Return the type affinity that should
+** be applied to both operands prior to doing the comparison.
+*/
+static char comparisonAffinity(Expr *pExpr){
+  char aff;
+  assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
+          pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
+          pExpr->op==TK_NE );
+  assert( pExpr->pLeft );
+  aff = sqlite3ExprAffinity(pExpr->pLeft);
+  if( pExpr->pRight ){
+    aff = sqlite3CompareAffinity(pExpr->pRight, aff);
+  }
+  else if( pExpr->pSelect ){
+    aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff);
+  }
+  else if( !aff ){
+    aff = SQLITE_AFF_NONE;
+  }
+  return aff;
+}
+
+/*
+** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
+** idx_affinity is the affinity of an indexed column. Return true
+** if the index with affinity idx_affinity may be used to implement
+** the comparison in pExpr.
+*/
+int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
+  char aff = comparisonAffinity(pExpr);
+  switch( aff ){
+    case SQLITE_AFF_NONE:
+      return 1;
+    case SQLITE_AFF_TEXT:
+      return idx_affinity==SQLITE_AFF_TEXT;
+    default:
+      return sqlite3IsNumericAffinity(idx_affinity);
+  }
+}
+
+/*
+** Return the P5 value that should be used for a binary comparison
+** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
+*/
+static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
+  u8 aff = (char)sqlite3ExprAffinity(pExpr2);
+  aff = sqlite3CompareAffinity(pExpr1, aff) | jumpIfNull;
+  return aff;
+}
+
+/*
+** Return a pointer to the collation sequence that should be used by
+** a binary comparison operator comparing pLeft and pRight.
+**
+** If the left hand expression has a collating sequence type, then it is
+** used. Otherwise the collation sequence for the right hand expression
+** is used, or the default (BINARY) if neither expression has a collating
+** type.
+**
+** Argument pRight (but not pLeft) may be a null pointer. In this case,
+** it is not considered.
+*/
+CollSeq *sqlite3BinaryCompareCollSeq(
+  Parse *pParse, 
+  Expr *pLeft, 
+  Expr *pRight
+){
+  CollSeq *pColl;
+  assert( pLeft );
+  if( pLeft->flags & EP_ExpCollate ){
+    assert( pLeft->pColl );
+    pColl = pLeft->pColl;
+  }else if( pRight && pRight->flags & EP_ExpCollate ){
+    assert( pRight->pColl );
+    pColl = pRight->pColl;
+  }else{
+    pColl = sqlite3ExprCollSeq(pParse, pLeft);
+    if( !pColl ){
+      pColl = sqlite3ExprCollSeq(pParse, pRight);
+    }
+  }
+  return pColl;
+}
+
+/*
+** Generate code for a comparison operator.
+*/
+static int codeCompare(
+  Parse *pParse,    /* The parsing (and code generating) context */
+  Expr *pLeft,      /* The left operand */
+  Expr *pRight,     /* The right operand */
+  int opcode,       /* The comparison opcode */
+  int in1, int in2, /* Register holding operands */
+  int dest,         /* Jump here if true.  */
+  int jumpIfNull    /* If true, jump if either operand is NULL */
+){
+  int p5;
+  int addr;
+  CollSeq *p4;
+
+  p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
+  p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
+  addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
+                           (void*)p4, P4_COLLSEQ);
+  sqlite3VdbeChangeP5(pParse->pVdbe, p5);
+  return addr;
+}
+
+/*
+** Construct a new expression node and return a pointer to it.  Memory
+** for this node is obtained from sqlite3_malloc().  The calling function
+** is responsible for making sure the node eventually gets freed.
+*/
+Expr *sqlite3Expr(
+  sqlite3 *db,            /* Handle for sqlite3DbMallocZero() (may be null) */
+  int op,                 /* Expression opcode */
+  Expr *pLeft,            /* Left operand */
+  Expr *pRight,           /* Right operand */
+  const Token *pToken     /* Argument token */
+){
+  Expr *pNew;
+  pNew = sqlite3DbMallocZero(db, sizeof(Expr));
+  if( pNew==0 ){
+    /* When malloc fails, delete pLeft and pRight. Expressions passed to 
+    ** this function must always be allocated with sqlite3Expr() for this 
+    ** reason. 
+    */
+    sqlite3ExprDelete(pLeft);
+    sqlite3ExprDelete(pRight);
+    return 0;
+  }
+  pNew->op = op;
+  pNew->pLeft = pLeft;
+  pNew->pRight = pRight;
+  pNew->iAgg = -1;
+  if( pToken ){
+    assert( pToken->dyn==0 );
+    pNew->span = pNew->token = *pToken;
+  }else if( pLeft ){
+    if( pRight ){
+      sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span);
+      if( pRight->flags & EP_ExpCollate ){
+        pNew->flags |= EP_ExpCollate;
+        pNew->pColl = pRight->pColl;
+      }
+    }
+    if( pLeft->flags & EP_ExpCollate ){
+      pNew->flags |= EP_ExpCollate;
+      pNew->pColl = pLeft->pColl;
+    }
+  }
+
+  sqlite3ExprSetHeight(pNew);
+  return pNew;
+}
+
+/*
+** Works like sqlite3Expr() except that it takes an extra Parse*
+** argument and notifies the associated connection object if malloc fails.
+*/
+Expr *sqlite3PExpr(
+  Parse *pParse,          /* Parsing context */
+  int op,                 /* Expression opcode */
+  Expr *pLeft,            /* Left operand */
+  Expr *pRight,           /* Right operand */
+  const Token *pToken     /* Argument token */
+){
+  return sqlite3Expr(pParse->db, op, pLeft, pRight, pToken);
+}
+
+/*
+** When doing a nested parse, you can include terms in an expression
+** that look like this:   #1 #2 ...  These terms refer to registers
+** in the virtual machine.  #N is the N-th register.
+**
+** This routine is called by the parser to deal with on of those terms.
+** It immediately generates code to store the value in a memory location.
+** The returns an expression that will code to extract the value from
+** that memory location as needed.
+*/
+Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){
+  Vdbe *v = pParse->pVdbe;
+  Expr *p;
+  if( pParse->nested==0 ){
+    sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken);
+    return sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
+  }
+  if( v==0 ) return 0;
+  p = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, pToken);
+  if( p==0 ){
+    return 0;  /* Malloc failed */
+  }
+  p->iTable = atoi((char*)&pToken->z[1]);
+  return p;
+}
+
+/*
+** Join two expressions using an AND operator.  If either expression is
+** NULL, then just return the other expression.
+*/
+Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
+  if( pLeft==0 ){
+    return pRight;
+  }else if( pRight==0 ){
+    return pLeft;
+  }else{
+    return sqlite3Expr(db, TK_AND, pLeft, pRight, 0);
+  }
+}
+
+/*
+** Set the Expr.span field of the given expression to span all
+** text between the two given tokens.
+*/
+void sqlite3ExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){
+  assert( pRight!=0 );
+  assert( pLeft!=0 );
+  if( pExpr && pRight->z && pLeft->z ){
+    assert( pLeft->dyn==0 || pLeft->z[pLeft->n]==0 );
+    if( pLeft->dyn==0 && pRight->dyn==0 ){
+      pExpr->span.z = pLeft->z;
+      pExpr->span.n = pRight->n + (pRight->z - pLeft->z);
+    }else{
+      pExpr->span.z = 0;
+    }
+  }
+}
+
+/*
+** Construct a new expression node for a function with multiple
+** arguments.
+*/
+Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
+  Expr *pNew;
+  assert( pToken );
+  pNew = sqlite3DbMallocZero(pParse->db, sizeof(Expr) );
+  if( pNew==0 ){
+    sqlite3ExprListDelete(pList); /* Avoid leaking memory when malloc fails */
+    return 0;
+  }
+  pNew->op = TK_FUNCTION;
+  pNew->pList = pList;
+  assert( pToken->dyn==0 );
+  pNew->token = *pToken;
+  pNew->span = pNew->token;
+
+  sqlite3ExprSetHeight(pNew);
+  return pNew;
+}
+
+/*
+** Assign a variable number to an expression that encodes a wildcard
+** in the original SQL statement.  
+**
+** Wildcards consisting of a single "?" are assigned the next sequential
+** variable number.
+**
+** Wildcards of the form "?nnn" are assigned the number "nnn".  We make
+** sure "nnn" is not too be to avoid a denial of service attack when
+** the SQL statement comes from an external source.
+**
+** Wildcards of the form ":aaa" or "$aaa" are assigned the same number
+** as the previous instance of the same wildcard.  Or if this is the first
+** instance of the wildcard, the next sequenial variable number is
+** assigned.
+*/
+void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
+  Token *pToken;
+  sqlite3 *db = pParse->db;
+
+  if( pExpr==0 ) return;
+  pToken = &pExpr->token;
+  assert( pToken->n>=1 );
+  assert( pToken->z!=0 );
+  assert( pToken->z[0]!=0 );
+  if( pToken->n==1 ){
+    /* Wildcard of the form "?".  Assign the next variable number */
+    pExpr->iTable = ++pParse->nVar;
+  }else if( pToken->z[0]=='?' ){
+    /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
+    ** use it as the variable number */
+    int i;
+    pExpr->iTable = i = atoi((char*)&pToken->z[1]);
+    if( i<1 || i>SQLITE_MAX_VARIABLE_NUMBER ){
+      sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
+          SQLITE_MAX_VARIABLE_NUMBER);
+    }
+    if( i>pParse->nVar ){
+      pParse->nVar = i;
+    }
+  }else{
+    /* Wildcards of the form ":aaa" or "$aaa".  Reuse the same variable
+    ** number as the prior appearance of the same name, or if the name
+    ** has never appeared before, reuse the same variable number
+    */
+    int i, n;
+    n = pToken->n;
+    for(i=0; i<pParse->nVarExpr; i++){
+      Expr *pE;
+      if( (pE = pParse->apVarExpr[i])!=0
+          && pE->token.n==n
+          && memcmp(pE->token.z, pToken->z, n)==0 ){
+        pExpr->iTable = pE->iTable;
+        break;
+      }
+    }
+    if( i>=pParse->nVarExpr ){
+      pExpr->iTable = ++pParse->nVar;
+      if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
+        pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
+        pParse->apVarExpr =
+            sqlite3DbReallocOrFree(
+              db,
+              pParse->apVarExpr,
+              pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
+            );
+      }
+      if( !db->mallocFailed ){
+        assert( pParse->apVarExpr!=0 );
+        pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
+      }
+    }
+  } 
+  if( !pParse->nErr && pParse->nVar>SQLITE_MAX_VARIABLE_NUMBER ){
+    sqlite3ErrorMsg(pParse, "too many SQL variables");
+  }
+}
+
+/*
+** Recursively delete an expression tree.
+*/
+void sqlite3ExprDelete(Expr *p){
+  if( p==0 ) return;
+  if( p->span.dyn ) sqlite3_free((char*)p->span.z);
+  if( p->token.dyn ) sqlite3_free((char*)p->token.z);
+  sqlite3ExprDelete(p->pLeft);
+  sqlite3ExprDelete(p->pRight);
+  sqlite3ExprListDelete(p->pList);
+  sqlite3SelectDelete(p->pSelect);
+  sqlite3_free(p);
+}
+
+/*
+** The Expr.token field might be a string literal that is quoted.
+** If so, remove the quotation marks.
+*/
+void sqlite3DequoteExpr(sqlite3 *db, Expr *p){
+  if( ExprHasAnyProperty(p, EP_Dequoted) ){
+    return;
+  }
+  ExprSetProperty(p, EP_Dequoted);
+  if( p->token.dyn==0 ){
+    sqlite3TokenCopy(db, &p->token, &p->token);
+  }
+  sqlite3Dequote((char*)p->token.z);
+}
+
+
+/*
+** The following group of routines make deep copies of expressions,
+** expression lists, ID lists, and select statements.  The copies can
+** be deleted (by being passed to their respective ...Delete() routines)
+** without effecting the originals.
+**
+** The expression list, ID, and source lists return by sqlite3ExprListDup(),
+** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded 
+** by subsequent calls to sqlite*ListAppend() routines.
+**
+** Any tables that the SrcList might point to are not duplicated.
+*/
+Expr *sqlite3ExprDup(sqlite3 *db, Expr *p){
+  Expr *pNew;
+  if( p==0 ) return 0;
+  pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
+  if( pNew==0 ) return 0;
+  memcpy(pNew, p, sizeof(*pNew));
+  if( p->token.z!=0 ){
+    pNew->token.z = (u8*)sqlite3DbStrNDup(db, (char*)p->token.z, p->token.n);
+    pNew->token.dyn = 1;
+  }else{
+    assert( pNew->token.z==0 );
+  }
+  pNew->span.z = 0;
+  pNew->pLeft = sqlite3ExprDup(db, p->pLeft);
+  pNew->pRight = sqlite3ExprDup(db, p->pRight);
+  pNew->pList = sqlite3ExprListDup(db, p->pList);
+  pNew->pSelect = sqlite3SelectDup(db, p->pSelect);
+  return pNew;
+}
+void sqlite3TokenCopy(sqlite3 *db, Token *pTo, Token *pFrom){
+  if( pTo->dyn ) sqlite3_free((char*)pTo->z);
+  if( pFrom->z ){
+    pTo->n = pFrom->n;
+    pTo->z = (u8*)sqlite3DbStrNDup(db, (char*)pFrom->z, pFrom->n);
+    pTo->dyn = 1;
+  }else{
+    pTo->z = 0;
+  }
+}
+ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p){
+  ExprList *pNew;
+  struct ExprList_item *pItem, *pOldItem;
+  int i;
+  if( p==0 ) return 0;
+  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  if( pNew==0 ) return 0;
+  pNew->iECursor = 0;
+  pNew->nExpr = pNew->nAlloc = p->nExpr;
+  pNew->a = pItem = sqlite3DbMallocRaw(db,  p->nExpr*sizeof(p->a[0]) );
+  if( pItem==0 ){
+    sqlite3_free(pNew);
+    return 0;
+  } 
+  pOldItem = p->a;
+  for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
+    Expr *pNewExpr, *pOldExpr;
+    pItem->pExpr = pNewExpr = sqlite3ExprDup(db, pOldExpr = pOldItem->pExpr);
+    if( pOldExpr->span.z!=0 && pNewExpr ){
+      /* Always make a copy of the span for top-level expressions in the
+      ** expression list.  The logic in SELECT processing that determines
+      ** the names of columns in the result set needs this information */
+      sqlite3TokenCopy(db, &pNewExpr->span, &pOldExpr->span);
+    }
+    assert( pNewExpr==0 || pNewExpr->span.z!=0 
+            || pOldExpr->span.z==0
+            || db->mallocFailed );
+    pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
+    pItem->sortOrder = pOldItem->sortOrder;
+    pItem->isAgg = pOldItem->isAgg;
+    pItem->done = 0;
+  }
+  return pNew;
+}
+
+/*
+** If cursors, triggers, views and subqueries are all omitted from
+** the build, then none of the following routines, except for 
+** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
+** called with a NULL argument.
+*/
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
+ || !defined(SQLITE_OMIT_SUBQUERY)
+SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p){
+  SrcList *pNew;
+  int i;
+  int nByte;
+  if( p==0 ) return 0;
+  nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
+  pNew = sqlite3DbMallocRaw(db, nByte );
+  if( pNew==0 ) return 0;
+  pNew->nSrc = pNew->nAlloc = p->nSrc;
+  for(i=0; i<p->nSrc; i++){
+    struct SrcList_item *pNewItem = &pNew->a[i];
+    struct SrcList_item *pOldItem = &p->a[i];
+    Table *pTab;
+    pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
+    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
+    pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
+    pNewItem->jointype = pOldItem->jointype;
+    pNewItem->iCursor = pOldItem->iCursor;
+    pNewItem->isPopulated = pOldItem->isPopulated;
+    pTab = pNewItem->pTab = pOldItem->pTab;
+    if( pTab ){
+      pTab->nRef++;
+    }
+    pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect);
+    pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn);
+    pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
+    pNewItem->colUsed = pOldItem->colUsed;
+  }
+  return pNew;
+}
+IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
+  IdList *pNew;
+  int i;
+  if( p==0 ) return 0;
+  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  if( pNew==0 ) return 0;
+  pNew->nId = pNew->nAlloc = p->nId;
+  pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
+  if( pNew->a==0 ){
+    sqlite3_free(pNew);
+    return 0;
+  }
+  for(i=0; i<p->nId; i++){
+    struct IdList_item *pNewItem = &pNew->a[i];
+    struct IdList_item *pOldItem = &p->a[i];
+    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
+    pNewItem->idx = pOldItem->idx;
+  }
+  return pNew;
+}
+Select *sqlite3SelectDup(sqlite3 *db, Select *p){
+  Select *pNew;
+  if( p==0 ) return 0;
+  pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
+  if( pNew==0 ) return 0;
+  pNew->isDistinct = p->isDistinct;
+  pNew->pEList = sqlite3ExprListDup(db, p->pEList);
+  pNew->pSrc = sqlite3SrcListDup(db, p->pSrc);
+  pNew->pWhere = sqlite3ExprDup(db, p->pWhere);
+  pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy);
+  pNew->pHaving = sqlite3ExprDup(db, p->pHaving);
+  pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy);
+  pNew->op = p->op;
+  pNew->pPrior = sqlite3SelectDup(db, p->pPrior);
+  pNew->pLimit = sqlite3ExprDup(db, p->pLimit);
+  pNew->pOffset = sqlite3ExprDup(db, p->pOffset);
+  pNew->iLimit = -1;
+  pNew->iOffset = -1;
+  pNew->isResolved = p->isResolved;
+  pNew->isAgg = p->isAgg;
+  pNew->usesEphm = 0;
+  pNew->disallowOrderBy = 0;
+  pNew->pRightmost = 0;
+  pNew->addrOpenEphm[0] = -1;
+  pNew->addrOpenEphm[1] = -1;
+  pNew->addrOpenEphm[2] = -1;
+  return pNew;
+}
+#else
+Select *sqlite3SelectDup(sqlite3 *db, Select *p){
+  assert( p==0 );
+  return 0;
+}
+#endif
+
+
+/*
+** Add a new element to the end of an expression list.  If pList is
+** initially NULL, then create a new expression list.
+*/
+ExprList *sqlite3ExprListAppend(
+  Parse *pParse,          /* Parsing context */
+  ExprList *pList,        /* List to which to append. Might be NULL */
+  Expr *pExpr,            /* Expression to be appended */
+  Token *pName            /* AS keyword for the expression */
+){
+  sqlite3 *db = pParse->db;
+  if( pList==0 ){
+    pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
+    if( pList==0 ){
+      goto no_mem;
+    }
+    assert( pList->nAlloc==0 );
+  }
+  if( pList->nAlloc<=pList->nExpr ){
+    struct ExprList_item *a;
+    int n = pList->nAlloc*2 + 4;
+    a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
+    if( a==0 ){
+      goto no_mem;
+    }
+    pList->a = a;
+    pList->nAlloc = n;
+  }
+  assert( pList->a!=0 );
+  if( pExpr || pName ){
+    struct ExprList_item *pItem = &pList->a[pList->nExpr++];
+    memset(pItem, 0, sizeof(*pItem));
+    pItem->zName = sqlite3NameFromToken(db, pName);
+    pItem->pExpr = pExpr;
+  }
+  return pList;
+
+no_mem:     
+  /* Avoid leaking memory if malloc has failed. */
+  sqlite3ExprDelete(pExpr);
+  sqlite3ExprListDelete(pList);
+  return 0;
+}
+
+/*
+** If the expression list pEList contains more than iLimit elements,
+** leave an error message in pParse.
+*/
+void sqlite3ExprListCheckLength(
+  Parse *pParse,
+  ExprList *pEList,
+  int iLimit,
+  const char *zObject
+){
+  if( pEList && pEList->nExpr>iLimit ){
+    sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
+  }
+}
+
+
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+/* The following three functions, heightOfExpr(), heightOfExprList()
+** and heightOfSelect(), are used to determine the maximum height
+** of any expression tree referenced by the structure passed as the
+** first argument.
+**
+** If this maximum height is greater than the current value pointed
+** to by pnHeight, the second parameter, then set *pnHeight to that
+** value.
+*/
+static void heightOfExpr(Expr *p, int *pnHeight){
+  if( p ){
+    if( p->nHeight>*pnHeight ){
+      *pnHeight = p->nHeight;
+    }
+  }
+}
+static void heightOfExprList(ExprList *p, int *pnHeight){
+  if( p ){
+    int i;
+    for(i=0; i<p->nExpr; i++){
+      heightOfExpr(p->a[i].pExpr, pnHeight);
+    }
+  }
+}
+static void heightOfSelect(Select *p, int *pnHeight){
+  if( p ){
+    heightOfExpr(p->pWhere, pnHeight);
+    heightOfExpr(p->pHaving, pnHeight);
+    heightOfExpr(p->pLimit, pnHeight);
+    heightOfExpr(p->pOffset, pnHeight);
+    heightOfExprList(p->pEList, pnHeight);
+    heightOfExprList(p->pGroupBy, pnHeight);
+    heightOfExprList(p->pOrderBy, pnHeight);
+    heightOfSelect(p->pPrior, pnHeight);
+  }
+}
+
+/*
+** Set the Expr.nHeight variable in the structure passed as an 
+** argument. An expression with no children, Expr.pList or 
+** Expr.pSelect member has a height of 1. Any other expression
+** has a height equal to the maximum height of any other 
+** referenced Expr plus one.
+*/
+void sqlite3ExprSetHeight(Expr *p){
+  int nHeight = 0;
+  heightOfExpr(p->pLeft, &nHeight);
+  heightOfExpr(p->pRight, &nHeight);
+  heightOfExprList(p->pList, &nHeight);
+  heightOfSelect(p->pSelect, &nHeight);
+  p->nHeight = nHeight + 1;
+}
+
+/*
+** Return the maximum height of any expression tree referenced
+** by the select statement passed as an argument.
+*/
+int sqlite3SelectExprHeight(Select *p){
+  int nHeight = 0;
+  heightOfSelect(p, &nHeight);
+  return nHeight;
+}
+#endif
+
+/*
+** Delete an entire expression list.
+*/
+void sqlite3ExprListDelete(ExprList *pList){
+  int i;
+  struct ExprList_item *pItem;
+  if( pList==0 ) return;
+  assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
+  assert( pList->nExpr<=pList->nAlloc );
+  for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
+    sqlite3ExprDelete(pItem->pExpr);
+    sqlite3_free(pItem->zName);
+  }
+  sqlite3_free(pList->a);
+  sqlite3_free(pList);
+}
+
+/*
+** Walk an expression tree.  Call xFunc for each node visited.
+**
+** The return value from xFunc determines whether the tree walk continues.
+** 0 means continue walking the tree.  1 means do not walk children
+** of the current node but continue with siblings.  2 means abandon
+** the tree walk completely.
+**
+** The return value from this routine is 1 to abandon the tree walk
+** and 0 to continue.
+**
+** NOTICE:  This routine does *not* descend into subqueries.
+*/
+static int walkExprList(ExprList *, int (*)(void *, Expr*), void *);
+static int walkExprTree(Expr *pExpr, int (*xFunc)(void*,Expr*), void *pArg){
+  int rc;
+  if( pExpr==0 ) return 0;
+  rc = (*xFunc)(pArg, pExpr);
+  if( rc==0 ){
+    if( walkExprTree(pExpr->pLeft, xFunc, pArg) ) return 1;
+    if( walkExprTree(pExpr->pRight, xFunc, pArg) ) return 1;
+    if( walkExprList(pExpr->pList, xFunc, pArg) ) return 1;
+  }
+  return rc>1;
+}
+
+/*
+** Call walkExprTree() for every expression in list p.
+*/
+static int walkExprList(ExprList *p, int (*xFunc)(void *, Expr*), void *pArg){
+  int i;
+  struct ExprList_item *pItem;
+  if( !p ) return 0;
+  for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
+    if( walkExprTree(pItem->pExpr, xFunc, pArg) ) return 1;
+  }
+  return 0;
+}
+
+/*
+** Call walkExprTree() for every expression in Select p, not including
+** expressions that are part of sub-selects in any FROM clause or the LIMIT
+** or OFFSET expressions..
+*/
+static int walkSelectExpr(Select *p, int (*xFunc)(void *, Expr*), void *pArg){
+  walkExprList(p->pEList, xFunc, pArg);
+  walkExprTree(p->pWhere, xFunc, pArg);
+  walkExprList(p->pGroupBy, xFunc, pArg);
+  walkExprTree(p->pHaving, xFunc, pArg);
+  walkExprList(p->pOrderBy, xFunc, pArg);
+  if( p->pPrior ){
+    walkSelectExpr(p->pPrior, xFunc, pArg);
+  }
+  return 0;
+}
+
+
+/*
+** This routine is designed as an xFunc for walkExprTree().
+**
+** pArg is really a pointer to an integer.  If we can tell by looking
+** at pExpr that the expression that contains pExpr is not a constant
+** expression, then set *pArg to 0 and return 2 to abandon the tree walk.
+** If pExpr does does not disqualify the expression from being a constant
+** then do nothing.
+**
+** After walking the whole tree, if no nodes are found that disqualify
+** the expression as constant, then we assume the whole expression
+** is constant.  See sqlite3ExprIsConstant() for additional information.
+*/
+static int exprNodeIsConstant(void *pArg, Expr *pExpr){
+  int *pN = (int*)pArg;
+
+  /* If *pArg is 3 then any term of the expression that comes from
+  ** the ON or USING clauses of a join disqualifies the expression
+  ** from being considered constant. */
+  if( (*pN)==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
+    *pN = 0;
+    return 2;
+  }
+
+  switch( pExpr->op ){
+    /* Consider functions to be constant if all their arguments are constant
+    ** and *pArg==2 */
+    case TK_FUNCTION:
+      if( (*pN)==2 ) return 0;
+      /* Fall through */
+    case TK_ID:
+    case TK_COLUMN:
+    case TK_DOT:
+    case TK_AGG_FUNCTION:
+    case TK_AGG_COLUMN:
+#ifndef SQLITE_OMIT_SUBQUERY
+    case TK_SELECT:
+    case TK_EXISTS:
+#endif
+      *pN = 0;
+      return 2;
+    case TK_IN:
+      if( pExpr->pSelect ){
+        *pN = 0;
+        return 2;
+      }
+    default:
+      return 0;
+  }
+}
+
+/*
+** Walk an expression tree.  Return 1 if the expression is constant
+** and 0 if it involves variables or function calls.
+**
+** For the purposes of this function, a double-quoted string (ex: "abc")
+** is considered a variable but a single-quoted string (ex: 'abc') is
+** a constant.
+*/
+int sqlite3ExprIsConstant(Expr *p){
+  int isConst = 1;
+  walkExprTree(p, exprNodeIsConstant, &isConst);
+  return isConst;
+}
+
+/*
+** Walk an expression tree.  Return 1 if the expression is constant
+** that does no originate from the ON or USING clauses of a join.
+** Return 0 if it involves variables or function calls or terms from
+** an ON or USING clause.
+*/
+int sqlite3ExprIsConstantNotJoin(Expr *p){
+  int isConst = 3;
+  walkExprTree(p, exprNodeIsConstant, &isConst);
+  return isConst!=0;
+}
+
+/*
+** Walk an expression tree.  Return 1 if the expression is constant
+** or a function call with constant arguments.  Return and 0 if there
+** are any variables.
+**
+** For the purposes of this function, a double-quoted string (ex: "abc")
+** is considered a variable but a single-quoted string (ex: 'abc') is
+** a constant.
+*/
+int sqlite3ExprIsConstantOrFunction(Expr *p){
+  int isConst = 2;
+  walkExprTree(p, exprNodeIsConstant, &isConst);
+  return isConst!=0;
+}
+
+/*
+** If the expression p codes a constant integer that is small enough
+** to fit in a 32-bit integer, return 1 and put the value of the integer
+** in *pValue.  If the expression is not an integer or if it is too big
+** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
+*/
+int sqlite3ExprIsInteger(Expr *p, int *pValue){
+  switch( p->op ){
+    case TK_INTEGER: {
+      if( sqlite3GetInt32((char*)p->token.z, pValue) ){
+        return 1;
+      }
+      break;
+    }
+    case TK_UPLUS: {
+      return sqlite3ExprIsInteger(p->pLeft, pValue);
+    }
+    case TK_UMINUS: {
+      int v;
+      if( sqlite3ExprIsInteger(p->pLeft, &v) ){
+        *pValue = -v;
+        return 1;
+      }
+      break;
+    }
+    default: break;
+  }
+  return 0;
+}
+
+/*
+** Return TRUE if the given string is a row-id column name.
+*/
+int sqlite3IsRowid(const char *z){
+  if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
+  if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
+  if( sqlite3StrICmp(z, "OID")==0 ) return 1;
+  return 0;
+}
+
+/*
+** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
+** that name in the set of source tables in pSrcList and make the pExpr 
+** expression node refer back to that source column.  The following changes
+** are made to pExpr:
+**
+**    pExpr->iDb           Set the index in db->aDb[] of the database holding
+**                         the table.
+**    pExpr->iTable        Set to the cursor number for the table obtained
+**                         from pSrcList.
+**    pExpr->iColumn       Set to the column number within the table.
+**    pExpr->op            Set to TK_COLUMN.
+**    pExpr->pLeft         Any expression this points to is deleted
+**    pExpr->pRight        Any expression this points to is deleted.
+**
+** The pDbToken is the name of the database (the "X").  This value may be
+** NULL meaning that name is of the form Y.Z or Z.  Any available database
+** can be used.  The pTableToken is the name of the table (the "Y").  This
+** value can be NULL if pDbToken is also NULL.  If pTableToken is NULL it
+** means that the form of the name is Z and that columns from any table
+** can be used.
+**
+** If the name cannot be resolved unambiguously, leave an error message
+** in pParse and return non-zero.  Return zero on success.
+*/
+static int lookupName(
+  Parse *pParse,       /* The parsing context */
+  Token *pDbToken,     /* Name of the database containing table, or NULL */
+  Token *pTableToken,  /* Name of table containing column, or NULL */
+  Token *pColumnToken, /* Name of the column. */
+  NameContext *pNC,    /* The name context used to resolve the name */
+  Expr *pExpr          /* Make this EXPR node point to the selected column */
+){
+  char *zDb = 0;       /* Name of the database.  The "X" in X.Y.Z */
+  char *zTab = 0;      /* Name of the table.  The "Y" in X.Y.Z or Y.Z */
+  char *zCol = 0;      /* Name of the column.  The "Z" */
+  int i, j;            /* Loop counters */
+  int cnt = 0;         /* Number of matching column names */
+  int cntTab = 0;      /* Number of matching table names */
+  sqlite3 *db = pParse->db;  /* The database */
+  struct SrcList_item *pItem;       /* Use for looping over pSrcList items */
+  struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
+  NameContext *pTopNC = pNC;        /* First namecontext in the list */
+  Schema *pSchema = 0;              /* Schema of the expression */
+
+  assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */
+  zDb = sqlite3NameFromToken(db, pDbToken);
+  zTab = sqlite3NameFromToken(db, pTableToken);
+  zCol = sqlite3NameFromToken(db, pColumnToken);
+  if( db->mallocFailed ){
+    goto lookupname_end;
+  }
+
+  pExpr->iTable = -1;
+  while( pNC && cnt==0 ){
+    ExprList *pEList;
+    SrcList *pSrcList = pNC->pSrcList;
+
+    if( pSrcList ){
+      for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
+        Table *pTab;
+        int iDb;
+        Column *pCol;
+  
+        pTab = pItem->pTab;
+        assert( pTab!=0 );
+        iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+        assert( pTab->nCol>0 );
+        if( zTab ){
+          if( pItem->zAlias ){
+            char *zTabName = pItem->zAlias;
+            if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
+          }else{
+            char *zTabName = pTab->zName;
+            if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
+            if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
+              continue;
+            }
+          }
+        }
+        if( 0==(cntTab++) ){
+          pExpr->iTable = pItem->iCursor;
+          pSchema = pTab->pSchema;
+          pMatch = pItem;
+        }
+        for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
+          if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
+            const char *zColl = pTab->aCol[j].zColl;
+            IdList *pUsing;
+            cnt++;
+            pExpr->iTable = pItem->iCursor;
+            pMatch = pItem;
+            pSchema = pTab->pSchema;
+            /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
+            pExpr->iColumn = j==pTab->iPKey ? -1 : j;
+            pExpr->affinity = pTab->aCol[j].affinity;
+            if( (pExpr->flags & EP_ExpCollate)==0 ){
+              pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);
+            }
+            if( i<pSrcList->nSrc-1 ){
+              if( pItem[1].jointype & JT_NATURAL ){
+                /* If this match occurred in the left table of a natural join,
+                ** then skip the right table to avoid a duplicate match */
+                pItem++;
+                i++;
+              }else if( (pUsing = pItem[1].pUsing)!=0 ){
+                /* If this match occurs on a column that is in the USING clause
+                ** of a join, skip the search of the right table of the join
+                ** to avoid a duplicate match there. */
+                int k;
+                for(k=0; k<pUsing->nId; k++){
+                  if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){
+                    pItem++;
+                    i++;
+                    break;
+                  }
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+
+#ifndef SQLITE_OMIT_TRIGGER
+    /* If we have not already resolved the name, then maybe 
+    ** it is a new.* or old.* trigger argument reference
+    */
+    if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){
+      TriggerStack *pTriggerStack = pParse->trigStack;
+      Table *pTab = 0;
+      u32 *piColMask;
+      if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){
+        pExpr->iTable = pTriggerStack->newIdx;
+        assert( pTriggerStack->pTab );
+        pTab = pTriggerStack->pTab;
+        piColMask = &(pTriggerStack->newColMask);
+      }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){
+        pExpr->iTable = pTriggerStack->oldIdx;
+        assert( pTriggerStack->pTab );
+        pTab = pTriggerStack->pTab;
+        piColMask = &(pTriggerStack->oldColMask);
+      }
+
+      if( pTab ){ 
+        int iCol;
+        Column *pCol = pTab->aCol;
+
+        pSchema = pTab->pSchema;
+        cntTab++;
+        for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) {
+          if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
+            const char *zColl = pTab->aCol[iCol].zColl;
+            cnt++;
+            pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol;
+            pExpr->affinity = pTab->aCol[iCol].affinity;
+            if( (pExpr->flags & EP_ExpCollate)==0 ){
+              pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);
+            }
+            pExpr->pTab = pTab;
+            if( iCol>=0 ){
+              *piColMask |= ((u32)1<<iCol) | (iCol>=32?0xffffffff:0);
+            }
+            break;
+          }
+        }
+      }
+    }
+#endif /* !defined(SQLITE_OMIT_TRIGGER) */
+
+    /*
+    ** Perhaps the name is a reference to the ROWID
+    */
+    if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
+      cnt = 1;
+      pExpr->iColumn = -1;
+      pExpr->affinity = SQLITE_AFF_INTEGER;
+    }
+
+    /*
+    ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
+    ** might refer to an result-set alias.  This happens, for example, when
+    ** we are resolving names in the WHERE clause of the following command:
+    **
+    **     SELECT a+b AS x FROM table WHERE x<10;
+    **
+    ** In cases like this, replace pExpr with a copy of the expression that
+    ** forms the result set entry ("a+b" in the example) and return immediately.
+    ** Note that the expression in the result set should have already been
+    ** resolved by the time the WHERE clause is resolved.
+    */
+    if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
+      for(j=0; j<pEList->nExpr; j++){
+        char *zAs = pEList->a[j].zName;
+        if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
+          Expr *pDup, *pOrig;
+          assert( pExpr->pLeft==0 && pExpr->pRight==0 );
+          assert( pExpr->pList==0 );
+          assert( pExpr->pSelect==0 );
+          pOrig = pEList->a[j].pExpr;
+          if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){
+            sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
+            sqlite3_free(zCol);
+            return 2;
+          }
+          pDup = sqlite3ExprDup(db, pOrig);
+          if( pExpr->flags & EP_ExpCollate ){
+            pDup->pColl = pExpr->pColl;
+            pDup->flags |= EP_ExpCollate;
+          }
+          if( pExpr->span.dyn ) sqlite3_free((char*)pExpr->span.z);
+          if( pExpr->token.dyn ) sqlite3_free((char*)pExpr->token.z);
+          memcpy(pExpr, pDup, sizeof(*pExpr));
+          sqlite3_free(pDup);
+          cnt = 1;
+          pMatch = 0;
+          assert( zTab==0 && zDb==0 );
+          goto lookupname_end_2;
+        }
+      } 
+    }
+
+    /* Advance to the next name context.  The loop will exit when either
+    ** we have a match (cnt>0) or when we run out of name contexts.
+    */
+    if( cnt==0 ){
+      pNC = pNC->pNext;
+    }
+  }
+
+  /*
+  ** If X and Y are NULL (in other words if only the column name Z is
+  ** supplied) and the value of Z is enclosed in double-quotes, then
+  ** Z is a string literal if it doesn't match any column names.  In that
+  ** case, we need to return right away and not make any changes to
+  ** pExpr.
+  **
+  ** Because no reference was made to outer contexts, the pNC->nRef
+  ** fields are not changed in any context.
+  */
+  if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){
+    sqlite3_free(zCol);
+    return 0;
+  }
+
+  /*
+  ** cnt==0 means there was not match.  cnt>1 means there were two or
+  ** more matches.  Either way, we have an error.
+  */
+  if( cnt!=1 ){
+    const char *zErr;
+    zErr = cnt==0 ? "no such column" : "ambiguous column name";
+    if( zDb ){
+      sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
+    }else if( zTab ){
+      sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
+    }else{
+      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
+    }
+    pTopNC->nErr++;
+  }
+
+  /* If a column from a table in pSrcList is referenced, then record
+  ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes
+  ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  If the
+  ** column number is greater than the number of bits in the bitmask
+  ** then set the high-order bit of the bitmask.
+  */
+  if( pExpr->iColumn>=0 && pMatch!=0 ){
+    int n = pExpr->iColumn;
+    if( n>=sizeof(Bitmask)*8 ){
+      n = sizeof(Bitmask)*8-1;
+    }
+    assert( pMatch->iCursor==pExpr->iTable );
+    pMatch->colUsed |= ((Bitmask)1)<<n;
+  }
+
+lookupname_end:
+  /* Clean up and return
+  */
+  sqlite3_free(zDb);
+  sqlite3_free(zTab);
+  sqlite3ExprDelete(pExpr->pLeft);
+  pExpr->pLeft = 0;
+  sqlite3ExprDelete(pExpr->pRight);
+  pExpr->pRight = 0;
+  pExpr->op = TK_COLUMN;
+lookupname_end_2:
+  sqlite3_free(zCol);
+  if( cnt==1 ){
+    assert( pNC!=0 );
+    sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
+    if( pMatch && !pMatch->pSelect ){
+      pExpr->pTab = pMatch->pTab;
+    }
+    /* Increment the nRef value on all name contexts from TopNC up to
+    ** the point where the name matched. */
+    for(;;){
+      assert( pTopNC!=0 );
+      pTopNC->nRef++;
+      if( pTopNC==pNC ) break;
+      pTopNC = pTopNC->pNext;
+    }
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+/*
+** This routine is designed as an xFunc for walkExprTree().
+**
+** Resolve symbolic names into TK_COLUMN operators for the current
+** node in the expression tree.  Return 0 to continue the search down
+** the tree or 2 to abort the tree walk.
+**
+** This routine also does error checking and name resolution for
+** function names.  The operator for aggregate functions is changed
+** to TK_AGG_FUNCTION.
+*/
+static int nameResolverStep(void *pArg, Expr *pExpr){
+  NameContext *pNC = (NameContext*)pArg;
+  Parse *pParse;
+
+  if( pExpr==0 ) return 1;
+  assert( pNC!=0 );
+  pParse = pNC->pParse;
+
+  if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return 1;
+  ExprSetProperty(pExpr, EP_Resolved);
+#ifndef NDEBUG
+  if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
+    SrcList *pSrcList = pNC->pSrcList;
+    int i;
+    for(i=0; i<pNC->pSrcList->nSrc; i++){
+      assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
+    }
+  }
+#endif
+  switch( pExpr->op ){
+    /* Double-quoted strings (ex: "abc") are used as identifiers if
+    ** possible.  Otherwise they remain as strings.  Single-quoted
+    ** strings (ex: 'abc') are always string literals.
+    */
+    case TK_STRING: {
+      if( pExpr->token.z[0]=='\'' ) break;
+      /* Fall thru into the TK_ID case if this is a double-quoted string */
+    }
+    /* A lone identifier is the name of a column.
+    */
+    case TK_ID: {
+      lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr);
+      return 1;
+    }
+  
+    /* A table name and column name:     ID.ID
+    ** Or a database, table and column:  ID.ID.ID
+    */
+    case TK_DOT: {
+      Token *pColumn;
+      Token *pTable;
+      Token *pDb;
+      Expr *pRight;
+
+      /* if( pSrcList==0 ) break; */
+      pRight = pExpr->pRight;
+      if( pRight->op==TK_ID ){
+        pDb = 0;
+        pTable = &pExpr->pLeft->token;
+        pColumn = &pRight->token;
+      }else{
+        assert( pRight->op==TK_DOT );
+        pDb = &pExpr->pLeft->token;
+        pTable = &pRight->pLeft->token;
+        pColumn = &pRight->pRight->token;
+      }
+      lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr);
+      return 1;
+    }
+
+    /* Resolve function names
+    */
+    case TK_CONST_FUNC:
+    case TK_FUNCTION: {
+      ExprList *pList = pExpr->pList;    /* The argument list */
+      int n = pList ? pList->nExpr : 0;  /* Number of arguments */
+      int no_such_func = 0;       /* True if no such function exists */
+      int wrong_num_args = 0;     /* True if wrong number of arguments */
+      int is_agg = 0;             /* True if is an aggregate function */
+      int i;
+      int auth;                   /* Authorization to use the function */
+      int nId;                    /* Number of characters in function name */
+      const char *zId;            /* The function name. */
+      FuncDef *pDef;              /* Information about the function */
+      int enc = ENC(pParse->db);  /* The database encoding */
+
+      zId = (char*)pExpr->token.z;
+      nId = pExpr->token.n;
+      pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
+      if( pDef==0 ){
+        pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
+        if( pDef==0 ){
+          no_such_func = 1;
+        }else{
+          wrong_num_args = 1;
+        }
+      }else{
+        is_agg = pDef->xFunc==0;
+      }
+#ifndef SQLITE_OMIT_AUTHORIZATION
+      if( pDef ){
+        auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
+        if( auth!=SQLITE_OK ){
+          if( auth==SQLITE_DENY ){
+            sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
+                                    pDef->zName);
+            pNC->nErr++;
+          }
+          pExpr->op = TK_NULL;
+          return 1;
+        }
+      }
+#endif
+      if( is_agg && !pNC->allowAgg ){
+        sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
+        pNC->nErr++;
+        is_agg = 0;
+      }else if( no_such_func ){
+        sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
+        pNC->nErr++;
+      }else if( wrong_num_args ){
+        sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
+             nId, zId);
+        pNC->nErr++;
+      }
+      if( is_agg ){
+        pExpr->op = TK_AGG_FUNCTION;
+        pNC->hasAgg = 1;
+      }
+      if( is_agg ) pNC->allowAgg = 0;
+      for(i=0; pNC->nErr==0 && i<n; i++){
+        walkExprTree(pList->a[i].pExpr, nameResolverStep, pNC);
+      }
+      if( is_agg ) pNC->allowAgg = 1;
+      /* FIX ME:  Compute pExpr->affinity based on the expected return
+      ** type of the function 
+      */
+      return is_agg;
+    }
+#ifndef SQLITE_OMIT_SUBQUERY
+    case TK_SELECT:
+    case TK_EXISTS:
+#endif
+    case TK_IN: {
+      if( pExpr->pSelect ){
+        int nRef = pNC->nRef;
+#ifndef SQLITE_OMIT_CHECK
+        if( pNC->isCheck ){
+          sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
+        }
+#endif
+        sqlite3SelectResolve(pParse, pExpr->pSelect, pNC);
+        assert( pNC->nRef>=nRef );
+        if( nRef!=pNC->nRef ){
+          ExprSetProperty(pExpr, EP_VarSelect);
+        }
+      }
+      break;
+    }
+#ifndef SQLITE_OMIT_CHECK
+    case TK_VARIABLE: {
+      if( pNC->isCheck ){
+        sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
+      }
+      break;
+    }
+#endif
+  }
+  return 0;
+}
+
+/*
+** This routine walks an expression tree and resolves references to
+** table columns.  Nodes of the form ID.ID or ID resolve into an
+** index to the table in the table list and a column offset.  The 
+** Expr.opcode for such nodes is changed to TK_COLUMN.  The Expr.iTable
+** value is changed to the index of the referenced table in pTabList
+** plus the "base" value.  The base value will ultimately become the
+** VDBE cursor number for a cursor that is pointing into the referenced
+** table.  The Expr.iColumn value is changed to the index of the column 
+** of the referenced table.  The Expr.iColumn value for the special
+** ROWID column is -1.  Any INTEGER PRIMARY KEY column is tried as an
+** alias for ROWID.
+**
+** Also resolve function names and check the functions for proper
+** usage.  Make sure all function names are recognized and all functions
+** have the correct number of arguments.  Leave an error message
+** in pParse->zErrMsg if anything is amiss.  Return the number of errors.
+**
+** 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. */
+){
+  int savedHasAgg;
+  if( pExpr==0 ) return 0;
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+  if( (pExpr->nHeight+pNC->pParse->nHeight)>SQLITE_MAX_EXPR_DEPTH ){
+    sqlite3ErrorMsg(pNC->pParse, 
+       "Expression tree is too large (maximum depth %d)",
+       SQLITE_MAX_EXPR_DEPTH
+    );
+    return 1;
+  }
+  pNC->pParse->nHeight += pExpr->nHeight;
+#endif
+  savedHasAgg = pNC->hasAgg;
+  pNC->hasAgg = 0;
+  walkExprTree(pExpr, nameResolverStep, pNC);
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+  pNC->pParse->nHeight -= pExpr->nHeight;
+#endif
+  if( pNC->nErr>0 ){
+    ExprSetProperty(pExpr, EP_Error);
+  }
+  if( pNC->hasAgg ){
+    ExprSetProperty(pExpr, EP_Agg);
+  }else if( savedHasAgg ){
+    pNC->hasAgg = 1;
+  }
+  return ExprHasProperty(pExpr, EP_Error);
+}
+
+/*
+** A pointer instance of this structure is used to pass information
+** through walkExprTree into codeSubqueryStep().
+*/
+typedef struct QueryCoder QueryCoder;
+struct QueryCoder {
+  Parse *pParse;       /* The parsing context */
+  NameContext *pNC;    /* Namespace of first enclosing query */
+};
+
+#ifdef SQLITE_TEST
+  int sqlite3_enable_in_opt = 1;
+#else
+  #define sqlite3_enable_in_opt 1
+#endif
+
+/*
+** This function is used by the implementation of the IN (...) operator.
+** It's job is to find or create a b-tree structure that may be used
+** either to test for membership of the (...) set or to iterate through
+** its members, skipping duplicates.
+**
+** The cursor opened on the structure (database table, database index 
+** or ephermal table) is stored in pX->iTable before this function returns.
+** The returned value indicates the structure type, as follows:
+**
+**   IN_INDEX_ROWID - The cursor was opened on a database table.
+**   IN_INDEX_INDEX - The cursor was opened on a database index.
+**   IN_INDEX_EPH -   The cursor was opened on a specially created and
+**                    populated epheremal table.
+**
+** An existing structure may only be used if the SELECT is of the simple
+** form:
+**
+**     SELECT <column> FROM <table>
+**
+** If the mustBeUnique parameter is false, the structure will be used 
+** for fast set membership tests. In this case an epheremal table must 
+** be used unless <column> is an INTEGER PRIMARY KEY or an index can 
+** be found with <column> as its left-most column.
+**
+** If mustBeUnique is true, then the structure will be used to iterate
+** through the set members, skipping any duplicates. In this case an
+** epheremal table must be used unless the selected <column> is guaranteed
+** to be unique - either because it is an INTEGER PRIMARY KEY or it
+** is unique by virtue of a constraint or implicit index.
+*/
+#ifndef SQLITE_OMIT_SUBQUERY
+int sqlite3FindInIndex(Parse *pParse, Expr *pX, int mustBeUnique){
+  Select *p;
+  int eType = 0;
+  int iTab = pParse->nTab++;
+
+  /* The follwing if(...) expression is true if the SELECT is of the 
+  ** simple form:
+  **
+  **     SELECT <column> FROM <table>
+  **
+  ** If this is the case, it may be possible to use an existing table
+  ** or index instead of generating an epheremal table.
+  */
+  if( sqlite3_enable_in_opt
+   && (p=pX->pSelect) && !p->pPrior
+   && !p->isDistinct && !p->isAgg && !p->pGroupBy
+   && p->pSrc && p->pSrc->nSrc==1 && !p->pSrc->a[0].pSelect
+   && !p->pSrc->a[0].pTab->pSelect                                  
+   && p->pEList->nExpr==1 && p->pEList->a[0].pExpr->op==TK_COLUMN
+   && !p->pLimit && !p->pOffset && !p->pWhere
+  ){
+    sqlite3 *db = pParse->db;
+    Index *pIdx;
+    Expr *pExpr = p->pEList->a[0].pExpr;
+    int iCol = pExpr->iColumn;
+    Vdbe *v = sqlite3GetVdbe(pParse);
+
+    /* This function is only called from two places. In both cases the vdbe
+    ** has already been allocated. So assume sqlite3GetVdbe() is always
+    ** successful here.
+    */
+    assert(v);
+    if( iCol<0 ){
+      int iMem = ++pParse->nMem;
+      int iAddr;
+      Table *pTab = p->pSrc->a[0].pTab;
+      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+      sqlite3VdbeUsesBtree(v, iDb);
+
+      iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
+
+      sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
+      eType = IN_INDEX_ROWID;
+
+      sqlite3VdbeJumpHere(v, iAddr);
+    }else{
+      /* The collation sequence used by the comparison. If an index is to 
+      ** be used in place of a temp-table, it must be ordered according
+      ** to this collation sequence.
+      */
+      CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
+
+      /* Check that the affinity that will be used to perform the 
+      ** comparison is the same as the affinity of the column. If
+      ** it is not, it is not possible to use any index.
+      */
+      Table *pTab = p->pSrc->a[0].pTab;
+      char aff = comparisonAffinity(pX);
+      int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
+
+      for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
+        if( (pIdx->aiColumn[0]==iCol)
+         && (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
+         && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
+        ){
+          int iDb;
+          int iMem = ++pParse->nMem;
+          int iAddr;
+          char *pKey;
+  
+          pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
+          iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
+          sqlite3VdbeUsesBtree(v, iDb);
+
+          iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
+          sqlite3VdbeAddOp2(v, OP_Integer, 1, iMem);
+  
+          sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
+                               pKey,P4_KEYINFO_HANDOFF);
+          VdbeComment((v, "%s", pIdx->zName));
+          eType = IN_INDEX_INDEX;
+          sqlite3VdbeAddOp2(v, OP_SetNumColumns, iTab, pIdx->nColumn);
+
+          sqlite3VdbeJumpHere(v, iAddr);
+        }
+      }
+    }
+  }
+
+  if( eType==0 ){
+    sqlite3CodeSubselect(pParse, pX);
+    eType = IN_INDEX_EPH;
+  }else{
+    pX->iTable = iTab;
+  }
+  return eType;
+}
+#endif
+
+/*
+** Generate code for scalar subqueries used as an expression
+** and IN operators.  Examples:
+**
+**     (SELECT a FROM b)          -- subquery
+**     EXISTS (SELECT a FROM b)   -- EXISTS subquery
+**     x IN (4,5,11)              -- IN operator with list on right-hand side
+**     x IN (SELECT a FROM b)     -- IN operator with subquery on the right
+**
+** The pExpr parameter describes the expression that contains the IN
+** operator or subquery.
+*/
+#ifndef SQLITE_OMIT_SUBQUERY
+void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
+  int testAddr = 0;                       /* One-time test address */
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  if( v==0 ) return;
+
+
+  /* This code must be run in its entirety every time it is encountered
+  ** if any of the following is true:
+  **
+  **    *  The right-hand side is a correlated subquery
+  **    *  The right-hand side is an expression list containing variables
+  **    *  We are inside a trigger
+  **
+  ** 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;
+    sqlite3VdbeAddOp1(v, OP_If, mem);
+    testAddr = sqlite3VdbeAddOp2(v, OP_Integer, 1, mem);
+    assert( testAddr>0 || pParse->db->mallocFailed );
+  }
+
+  switch( pExpr->op ){
+    case TK_IN: {
+      char affinity;
+      KeyInfo keyInfo;
+      int addr;        /* Address of OP_OpenEphemeral instruction */
+
+      affinity = sqlite3ExprAffinity(pExpr->pLeft);
+
+      /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
+      ** expression it is handled the same way. A virtual table is 
+      ** filled with single-field index keys representing the results
+      ** from the SELECT or the <exprlist>.
+      **
+      ** If the 'x' expression is a column value, or the SELECT...
+      ** statement returns a column value, then the affinity of that
+      ** column is used to build the index keys. If both 'x' and the
+      ** SELECT... statement are columns, then numeric affinity is used
+      ** if either column has NUMERIC or INTEGER affinity. If neither
+      ** 'x' nor the SELECT... statement are columns, then numeric affinity
+      ** is used.
+      */
+      pExpr->iTable = pParse->nTab++;
+      addr = sqlite3VdbeAddOp1(v, OP_OpenEphemeral, pExpr->iTable);
+      memset(&keyInfo, 0, sizeof(keyInfo));
+      keyInfo.nField = 1;
+      sqlite3VdbeAddOp2(v, OP_SetNumColumns, pExpr->iTable, 1);
+
+      if( pExpr->pSelect ){
+        /* Case 1:     expr IN (SELECT ...)
+        **
+        ** Generate code to write the results of the select into the temporary
+        ** table allocated and opened above.
+        */
+        SelectDest dest;
+        ExprList *pEList;
+
+        sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
+        dest.affinity = (int)affinity;
+        assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
+        if( sqlite3Select(pParse, pExpr->pSelect, &dest, 0, 0, 0, 0) ){
+          return;
+        }
+        pEList = pExpr->pSelect->pEList;
+        if( pEList && pEList->nExpr>0 ){ 
+          keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
+              pEList->a[0].pExpr);
+        }
+      }else if( pExpr->pList ){
+        /* Case 2:     expr IN (exprlist)
+        **
+        ** For each expression, build an index key from the evaluation and
+        ** store it in the temporary table. If <expr> is a column, then use
+        ** that columns affinity when building index keys. If <expr> is not
+        ** a column, use numeric affinity.
+        */
+        int i;
+        ExprList *pList = pExpr->pList;
+        struct ExprList_item *pItem;
+        int r1, r2;
+
+        if( !affinity ){
+          affinity = SQLITE_AFF_NONE;
+        }
+        keyInfo.aColl[0] = pExpr->pLeft->pColl;
+
+        /* Loop through each expression in <exprlist>. */
+        r1 = sqlite3GetTempReg(pParse);
+        r2 = sqlite3GetTempReg(pParse);
+        for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
+          Expr *pE2 = pItem->pExpr;
+
+          /* If the expression is not constant then we will need to
+          ** 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 && !sqlite3ExprIsConstant(pE2) ){
+            sqlite3VdbeChangeToNoop(v, testAddr-1, 2);
+            testAddr = 0;
+          }
+
+          /* Evaluate the expression and insert it into the temp table */
+          sqlite3ExprCode(pParse, pE2, r1);
+          sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
+          sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
+        }
+        sqlite3ReleaseTempReg(pParse, r1);
+        sqlite3ReleaseTempReg(pParse, r2);
+      }
+      sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
+      break;
+    }
+
+    case TK_EXISTS:
+    case TK_SELECT: {
+      /* This has to be a scalar SELECT.  Generate code to put the
+      ** value of this select in a memory cell and record the number
+      ** of the memory cell in iColumn.
+      */
+      static const Token one = { (u8*)"1", 0, 1 };
+      Select *pSel;
+      SelectDest dest;
+
+      pSel = pExpr->pSelect;
+      sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
+      if( pExpr->op==TK_SELECT ){
+        dest.eDest = SRT_Mem;
+        sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
+        VdbeComment((v, "Init subquery result"));
+      }else{
+        dest.eDest = SRT_Exists;
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
+        VdbeComment((v, "Init EXISTS result"));
+      }
+      sqlite3ExprDelete(pSel->pLimit);
+      pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
+      if( sqlite3Select(pParse, pSel, &dest, 0, 0, 0, 0) ){
+        return;
+      }
+      pExpr->iColumn = dest.iParm;
+      break;
+    }
+  }
+
+  if( testAddr ){
+    sqlite3VdbeJumpHere(v, testAddr-1);
+  }
+
+  return;
+}
+#endif /* SQLITE_OMIT_SUBQUERY */
+
+/*
+** Duplicate an 8-byte value
+*/
+static char *dup8bytes(Vdbe *v, const char *in){
+  char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
+  if( out ){
+    memcpy(out, in, 8);
+  }
+  return out;
+}
+
+/*
+** Generate an instruction that will put the floating point
+** value described by z[0..n-1] into register iMem.
+**
+** The z[] string will probably not be zero-terminated.  But the 
+** z[n] character is guaranteed to be something that does not look
+** like the continuation of the number.
+*/
+static void codeReal(Vdbe *v, const char *z, int n, int negateFlag, int iMem){
+  assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
+  if( z ){
+    double value;
+    char *zV;
+    assert( !isdigit(z[n]) );
+    sqlite3AtoF(z, &value);
+    if( negateFlag ) value = -value;
+    zV = dup8bytes(v, (char*)&value);
+    sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
+  }
+}
+
+
+/*
+** Generate an instruction that will put the integer describe by
+** text z[0..n-1] into register iMem.
+**
+** The z[] string will probably not be zero-terminated.  But the 
+** z[n] character is guaranteed to be something that does not look
+** like the continuation of the number.
+*/
+static void codeInteger(Vdbe *v, const char *z, int n, int negFlag, int iMem){
+  assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );
+  if( z ){
+    int i;
+    assert( !isdigit(z[n]) );
+    if( sqlite3GetInt32(z, &i) ){
+      if( negFlag ) i = -i;
+      sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
+    }else if( sqlite3FitsIn64Bits(z, negFlag) ){
+      i64 value;
+      char *zV;
+      sqlite3Atoi64(z, &value);
+      if( negFlag ) value = -value;
+      zV = dup8bytes(v, (char*)&value);
+      sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
+    }else{
+      codeReal(v, z, n, negFlag, iMem);
+    }
+  }
+}
+
+
+/*
+** Generate code that will extract the iColumn-th column from
+** table pTab and store the column value in register iReg.
+** There is an open cursor to pTab in 
+** iTable.  If iColumn<0 then code is generated that extracts the rowid.
+*/
+void sqlite3ExprCodeGetColumn(
+  Vdbe *v,         /* The VM being created */
+  Table *pTab,     /* Description of the table we are reading from */
+  int iColumn,     /* Index of the table column */
+  int iTable,      /* The cursor pointing to the table */
+  int iReg         /* Store results here */
+){
+  if( iColumn<0 ){
+    int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;
+    sqlite3VdbeAddOp2(v, op, iTable, iReg);
+  }else if( pTab==0 ){
+    sqlite3VdbeAddOp3(v, OP_Column, iTable, iColumn, iReg);
+  }else{
+    int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
+    sqlite3VdbeAddOp3(v, op, iTable, iColumn, iReg);
+    sqlite3ColumnDefault(v, pTab, iColumn);
+#ifndef SQLITE_OMIT_FLOATING_POINT
+    if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){
+      sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
+    }
+#endif
+  }
+}
+
+/*
+** Generate code into the current Vdbe to evaluate the given
+** expression.  Attempt to store the results in register "target".
+** Return the register where results are stored.
+**
+** With this routine, there is no guaranteed that results will
+** be stored in target.  The result might be stored in some other
+** register if it is convenient to do so.  The calling function
+** must check the return code and move the results to the desired
+** register.
+*/
+static int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
+  Vdbe *v = pParse->pVdbe;  /* The VM under construction */
+  int op;                   /* The opcode being coded */
+  int inReg = target;       /* Results stored in register inReg */
+  int regFree1 = 0;         /* If non-zero free this temporary register */
+  int regFree2 = 0;         /* If non-zero free this temporary register */
+  int r1, r2, r3;           /* Various register numbers */
+
+  assert( v!=0 || pParse->db->mallocFailed );
+  assert( target>0 && target<=pParse->nMem );
+  if( v==0 ) return 0;
+
+  if( pExpr==0 ){
+    op = TK_NULL;
+  }else{
+    op = pExpr->op;
+  }
+  switch( op ){
+    case TK_AGG_COLUMN: {
+      AggInfo *pAggInfo = pExpr->pAggInfo;
+      struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
+      if( !pAggInfo->directMode ){
+        assert( pCol->iMem>0 );
+        inReg = pCol->iMem;
+        break;
+      }else if( pAggInfo->useSortingIdx ){
+        sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdx,
+                              pCol->iSorterColumn, target);
+        break;
+      }
+      /* Otherwise, fall thru into the TK_COLUMN case */
+    }
+    case TK_COLUMN: {
+      if( pExpr->iTable<0 ){
+        /* This only happens when coding check constraints */
+        assert( pParse->ckBase>0 );
+        inReg = pExpr->iColumn + pParse->ckBase;
+      }else{
+        sqlite3ExprCodeGetColumn(v, pExpr->pTab,
+                                 pExpr->iColumn, pExpr->iTable, target);
+      }
+      break;
+    }
+    case TK_INTEGER: {
+      codeInteger(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
+      break;
+    }
+    case TK_FLOAT: {
+      codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0, target);
+      break;
+    }
+    case TK_STRING: {
+      sqlite3DequoteExpr(pParse->db, pExpr);
+      sqlite3VdbeAddOp4(v,OP_String8, 0, target, 0,
+                        (char*)pExpr->token.z, pExpr->token.n);
+      break;
+    }
+    case TK_NULL: {
+      sqlite3VdbeAddOp2(v, OP_Null, 0, target);
+      break;
+    }
+#ifndef SQLITE_OMIT_BLOB_LITERAL
+    case TK_BLOB: {
+      int n;
+      const char *z;
+      char *zBlob;
+      assert( pExpr->token.n>=3 );
+      assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
+      assert( pExpr->token.z[1]=='\'' );
+      assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
+      n = pExpr->token.n - 3;
+      z = (char*)pExpr->token.z + 2;
+      zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
+      sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
+      break;
+    }
+#endif
+    case TK_VARIABLE: {
+      sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iTable, target);
+      if( pExpr->token.n>1 ){
+        sqlite3VdbeChangeP4(v, -1, (char*)pExpr->token.z, pExpr->token.n);
+      }
+      break;
+    }
+    case TK_REGISTER: {
+      inReg = pExpr->iTable;
+      break;
+    }
+#ifndef SQLITE_OMIT_CAST
+    case TK_CAST: {
+      /* Expressions of the form:   CAST(pLeft AS token) */
+      int aff, to_op;
+      inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
+      aff = sqlite3AffinityType(&pExpr->token);
+      to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
+      assert( to_op==OP_ToText    || aff!=SQLITE_AFF_TEXT    );
+      assert( to_op==OP_ToBlob    || aff!=SQLITE_AFF_NONE    );
+      assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
+      assert( to_op==OP_ToInt     || aff!=SQLITE_AFF_INTEGER );
+      assert( to_op==OP_ToReal    || aff!=SQLITE_AFF_REAL    );
+      sqlite3VdbeAddOp1(v, to_op, inReg);
+      break;
+    }
+#endif /* SQLITE_OMIT_CAST */
+    case TK_LT:
+    case TK_LE:
+    case TK_GT:
+    case TK_GE:
+    case TK_NE:
+    case TK_EQ: {
+      assert( TK_LT==OP_Lt );
+      assert( TK_LE==OP_Le );
+      assert( TK_GT==OP_Gt );
+      assert( TK_GE==OP_Ge );
+      assert( TK_EQ==OP_Eq );
+      assert( TK_NE==OP_Ne );
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
+      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
+                  r1, r2, inReg, SQLITE_STOREP2);
+      break;
+    }
+    case TK_AND:
+    case TK_OR:
+    case TK_PLUS:
+    case TK_STAR:
+    case TK_MINUS:
+    case TK_REM:
+    case TK_BITAND:
+    case TK_BITOR:
+    case TK_SLASH:
+    case TK_LSHIFT:
+    case TK_RSHIFT: 
+    case TK_CONCAT: {
+      assert( TK_AND==OP_And );
+      assert( TK_OR==OP_Or );
+      assert( TK_PLUS==OP_Add );
+      assert( TK_MINUS==OP_Subtract );
+      assert( TK_REM==OP_Remainder );
+      assert( TK_BITAND==OP_BitAnd );
+      assert( TK_BITOR==OP_BitOr );
+      assert( TK_SLASH==OP_Divide );
+      assert( TK_LSHIFT==OP_ShiftLeft );
+      assert( TK_RSHIFT==OP_ShiftRight );
+      assert( TK_CONCAT==OP_Concat );
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
+      sqlite3VdbeAddOp3(v, op, r2, r1, target);
+      break;
+    }
+    case TK_UMINUS: {
+      Expr *pLeft = pExpr->pLeft;
+      assert( pLeft );
+      if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
+        Token *p = &pLeft->token;
+        if( pLeft->op==TK_FLOAT ){
+          codeReal(v, (char*)p->z, p->n, 1, target);
+        }else{
+          codeInteger(v, (char*)p->z, p->n, 1, target);
+        }
+      }else{
+        regFree1 = r1 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
+        r2 = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
+        sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
+      }
+      inReg = target;
+      break;
+    }
+    case TK_BITNOT:
+    case TK_NOT: {
+      assert( TK_BITNOT==OP_BitNot );
+      assert( TK_NOT==OP_Not );
+      inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
+      sqlite3VdbeAddOp1(v, op, inReg);
+      break;
+    }
+    case TK_ISNULL:
+    case TK_NOTNULL: {
+      int addr;
+      assert( TK_ISNULL==OP_IsNull );
+      assert( TK_NOTNULL==OP_NotNull );
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      addr = sqlite3VdbeAddOp1(v, op, r1);
+      sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
+      sqlite3VdbeJumpHere(v, addr);
+      break;
+    }
+    case TK_AGG_FUNCTION: {
+      AggInfo *pInfo = pExpr->pAggInfo;
+      if( pInfo==0 ){
+        sqlite3ErrorMsg(pParse, "misuse of aggregate: %T",
+            &pExpr->span);
+      }else{
+        inReg = pInfo->aFunc[pExpr->iAgg].iMem;
+      }
+      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 constMask = 0;
+      int i;
+      sqlite3 *db = pParse->db;
+      u8 enc = ENC(db);
+      CollSeq *pColl = 0;
+
+      zId = (char*)pExpr->token.z;
+      nId = pExpr->token.n;
+      pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
+      assert( pDef!=0 );
+      if( pList ){
+        nExpr = pList->nExpr;
+        r1 = sqlite3GetTempRange(pParse, nExpr);
+        sqlite3ExprCodeExprList(pParse, pList, r1);
+      }else{
+        nExpr = r1 = 0;
+      }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      /* Possibly overload the function if the first argument is
+      ** a virtual table column.
+      **
+      ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
+      ** second argument, not the first, as the argument to test to
+      ** see if it is a column in a virtual table.  This is done because
+      ** the left operand of infix functions (the operand we want to
+      ** control overloading) ends up as the second argument to the
+      ** function.  The expression "A glob B" is equivalent to 
+      ** "glob(B,A).  We want to use the A in "A glob B" to test
+      ** for function overloading.  But we use the B term in "glob(B,A)".
+      */
+      if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
+        pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
+      }else if( nExpr>0 ){
+        pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
+      }
+#endif
+      for(i=0; i<nExpr && i<32; i++){
+        if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
+          constMask |= (1<<i);
+        }
+        if( pDef->needCollSeq && !pColl ){
+          pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
+        }
+      }
+      if( pDef->needCollSeq ){
+        if( !pColl ) pColl = pParse->db->pDfltColl; 
+        sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
+      }
+      sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
+                        (char*)pDef, P4_FUNCDEF);
+      sqlite3VdbeChangeP5(v, nExpr);
+      if( nExpr ){
+        sqlite3ReleaseTempRange(pParse, r1, nExpr);
+      }
+      break;
+    }
+#ifndef SQLITE_OMIT_SUBQUERY
+    case TK_EXISTS:
+    case TK_SELECT: {
+      if( pExpr->iColumn==0 ){
+        sqlite3CodeSubselect(pParse, pExpr);
+      }
+      inReg = pExpr->iColumn;
+      break;
+    }
+    case TK_IN: {
+      int j1, j2, j3, j4, j5;
+      char affinity;
+      int eType;
+
+      eType = sqlite3FindInIndex(pParse, pExpr, 0);
+
+      /* Figure out the affinity to use to create a key from the results
+      ** of the expression. affinityStr stores a static string suitable for
+      ** P4 of OP_MakeRecord.
+      */
+      affinity = comparisonAffinity(pExpr);
+
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
+
+      /* Code the <expr> from "<expr> IN (...)". The temporary table
+      ** pExpr->iTable contains the values that make up the (...) set.
+      */
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      j1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
+      sqlite3VdbeAddOp2(v, OP_Null, 0, target);
+      j2  = sqlite3VdbeAddOp0(v, OP_Goto);
+      sqlite3VdbeJumpHere(v, j1);
+      if( eType==IN_INDEX_ROWID ){
+        j3 = sqlite3VdbeAddOp3(v, OP_MustBeInt, r1, 0, 1);
+        j4 = sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, 0, r1);
+        j5 = sqlite3VdbeAddOp0(v, OP_Goto);
+        sqlite3VdbeJumpHere(v, j3);
+        sqlite3VdbeJumpHere(v, j4);
+      }else{
+        r2 = regFree2 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
+        j5 = sqlite3VdbeAddOp3(v, OP_Found, pExpr->iTable, 0, r2);
+      }
+      sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
+      sqlite3VdbeJumpHere(v, j2);
+      sqlite3VdbeJumpHere(v, j5);
+      break;
+    }
+#endif
+    /*
+    **    x BETWEEN y AND z
+    **
+    ** This is equivalent to
+    **
+    **    x>=y AND x<=z
+    **
+    ** X is stored in pExpr->pLeft.
+    ** Y is stored in pExpr->pList->a[0].pExpr.
+    ** Z is stored in pExpr->pList->a[1].pExpr.
+    */
+    case TK_BETWEEN: {
+      Expr *pLeft = pExpr->pLeft;
+      struct ExprList_item *pLItem = pExpr->pList->a;
+      Expr *pRight = pLItem->pExpr;
+
+      r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
+      r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
+      r3 = sqlite3GetTempReg(pParse);
+      codeCompare(pParse, pLeft, pRight, OP_Ge,
+                  r1, r2, r3, SQLITE_STOREP2);
+      pLItem++;
+      pRight = pLItem->pExpr;
+      sqlite3ReleaseTempReg(pParse, regFree2);
+      r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
+      codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r2, SQLITE_STOREP2);
+      sqlite3VdbeAddOp3(v, OP_And, r3, r2, target);
+      sqlite3ReleaseTempReg(pParse, r3);
+      break;
+    }
+    case TK_UPLUS: {
+      inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
+      break;
+    }
+
+    /*
+    ** Form A:
+    **   CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
+    **
+    ** Form B:
+    **   CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
+    **
+    ** Form A is can be transformed into the equivalent form B as follows:
+    **   CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
+    **        WHEN x=eN THEN rN ELSE y END
+    **
+    ** X (if it exists) is in pExpr->pLeft.
+    ** Y is in pExpr->pRight.  The Y is also optional.  If there is no
+    ** ELSE clause and no other term matches, then the result of the
+    ** exprssion is NULL.
+    ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
+    **
+    ** The result of the expression is the Ri for the first matching Ei,
+    ** or if there is no matching Ei, the ELSE term Y, or if there is
+    ** no ELSE term, NULL.
+    */
+    case TK_CASE: {
+      int endLabel;                     /* GOTO label for end of CASE stmt */
+      int nextCase;                     /* GOTO label for next WHEN clause */
+      int nExpr;                        /* 2x number of WHEN terms */
+      int i;                            /* Loop counter */
+      ExprList *pEList;                 /* List of WHEN terms */
+      struct ExprList_item *aListelem;  /* Array of WHEN terms */
+      Expr opCompare;                   /* The X==Ei expression */
+      Expr cacheX;                      /* Cached expression X */
+      Expr *pX;                         /* The X expression */
+      Expr *pTest;                      /* X==Ei (form A) or just Ei (form B) */
+
+      assert(pExpr->pList);
+      assert((pExpr->pList->nExpr % 2) == 0);
+      assert(pExpr->pList->nExpr > 0);
+      pEList = pExpr->pList;
+      aListelem = pEList->a;
+      nExpr = pEList->nExpr;
+      endLabel = sqlite3VdbeMakeLabel(v);
+      if( (pX = pExpr->pLeft)!=0 ){
+        cacheX = *pX;
+        cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, &regFree1);
+        cacheX.op = TK_REGISTER;
+        opCompare.op = TK_EQ;
+        opCompare.pLeft = &cacheX;
+        pTest = &opCompare;
+      }
+      for(i=0; i<nExpr; i=i+2){
+        if( pX ){
+          opCompare.pRight = aListelem[i].pExpr;
+        }else{
+          pTest = aListelem[i].pExpr;
+        }
+        nextCase = sqlite3VdbeMakeLabel(v);
+        sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
+        sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
+        sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
+        sqlite3VdbeResolveLabel(v, nextCase);
+      }
+      if( pExpr->pRight ){
+        sqlite3ExprCode(pParse, pExpr->pRight, target);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Null, 0, target);
+      }
+      sqlite3VdbeResolveLabel(v, endLabel);
+      break;
+    }
+#ifndef SQLITE_OMIT_TRIGGER
+    case TK_RAISE: {
+      if( !pParse->trigStack ){
+        sqlite3ErrorMsg(pParse,
+                       "RAISE() may only be used within a trigger-program");
+        return 0;
+      }
+      if( pExpr->iColumn!=OE_Ignore ){
+         assert( pExpr->iColumn==OE_Rollback ||
+                 pExpr->iColumn == OE_Abort ||
+                 pExpr->iColumn == OE_Fail );
+         sqlite3DequoteExpr(pParse->db, pExpr);
+         sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, 0,
+                        (char*)pExpr->token.z, pExpr->token.n);
+      } else {
+         assert( pExpr->iColumn == OE_Ignore );
+         sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
+         sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
+         VdbeComment((v, "raise(IGNORE)"));
+      }
+      break;
+    }
+#endif
+  }
+  sqlite3ReleaseTempReg(pParse, regFree1);
+  sqlite3ReleaseTempReg(pParse, regFree2);
+  return inReg;
+}
+
+/*
+** Generate code to evaluate an expression and store the results
+** into a register.  Return the register number where the results
+** are stored.
+**
+** If the register is a temporary register that can be deallocated,
+** then write its number into *pReg.  If the result register is no
+** a temporary, then set *pReg to zero.
+*/
+int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
+  int r1 = sqlite3GetTempReg(pParse);
+  int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
+  if( r2==r1 ){
+    *pReg = r1;
+  }else{
+    sqlite3ReleaseTempReg(pParse, r1);
+    *pReg = 0;
+  }
+  return r2;
+}
+
+/*
+** Generate code that will evaluate expression pExpr and store the
+** results in register target.  The results are guaranteed to appear
+** in register target.
+*/
+int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
+  int inReg;
+
+  assert( target>0 && target<=pParse->nMem );
+  inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
+  assert( pParse->pVdbe || pParse->db->mallocFailed );
+  if( inReg!=target && pParse->pVdbe ){
+    sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
+  }
+  return target;
+}
+
+/*
+** Generate code that evalutes the given expression and puts the result
+** in register target.
+**
+** Also make a copy of the expression results into another "cache" register
+** and modify the expression so that the next time it is evaluated,
+** the result is a copy of the cache register.
+**
+** This routine is used for expressions that are used multiple 
+** times.  They are evaluated once and the results of the expression
+** are reused.
+*/
+int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
+  Vdbe *v = pParse->pVdbe;
+  int inReg;
+  inReg = sqlite3ExprCode(pParse, pExpr, target);
+  assert( target>0 );
+  if( pExpr->op!=TK_REGISTER ){  
+    int iMem;
+    iMem = ++pParse->nMem;
+    sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
+    pExpr->iTable = iMem;
+    pExpr->op = TK_REGISTER;
+  }
+  return inReg;
+}
+
+
+/*
+** Generate code that pushes the value of every element of the given
+** expression list into a sequence of registers beginning at target.
+**
+** Return the number of elements evaluated.
+*/
+int sqlite3ExprCodeExprList(
+  Parse *pParse,     /* Parsing context */
+  ExprList *pList,   /* The expression list to be coded */
+  int target         /* Where to write results */
+){
+  struct ExprList_item *pItem;
+  int i, n;
+  assert( pList!=0 || pParse->db->mallocFailed );
+  if( pList==0 ){
+    return 0;
+  }
+  assert( target>0 );
+  n = pList->nExpr;
+  for(pItem=pList->a, i=n; i>0; i--, pItem++){
+    sqlite3ExprCode(pParse, pItem->pExpr, target);
+    target++;
+  }
+  return n;
+}
+
+/*
+** Generate code for a boolean expression such that a jump is made
+** to the label "dest" if the expression is true but execution
+** continues straight thru if the expression is false.
+**
+** If the expression evaluates to NULL (neither true nor false), then
+** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
+**
+** This code depends on the fact that certain token values (ex: TK_EQ)
+** are the same as opcode values (ex: OP_Eq) that implement the corresponding
+** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in
+** the make process cause these values to align.  Assert()s in the code
+** below verify that the numbers are aligned correctly.
+*/
+void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
+  Vdbe *v = pParse->pVdbe;
+  int op = 0;
+  int regFree1 = 0;
+  int regFree2 = 0;
+  int r1, r2;
+
+  assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
+  if( v==0 || pExpr==0 ) return;
+  op = pExpr->op;
+  switch( op ){
+    case TK_AND: {
+      int d2 = sqlite3VdbeMakeLabel(v);
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
+      sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3VdbeResolveLabel(v, d2);
+      break;
+    }
+    case TK_OR: {
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
+      break;
+    }
+    case TK_NOT: {
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
+      break;
+    }
+    case TK_LT:
+    case TK_LE:
+    case TK_GT:
+    case TK_GE:
+    case TK_NE:
+    case TK_EQ: {
+      assert( TK_LT==OP_Lt );
+      assert( TK_LE==OP_Le );
+      assert( TK_GT==OP_Gt );
+      assert( TK_GE==OP_Ge );
+      assert( TK_EQ==OP_Eq );
+      assert( TK_NE==OP_Ne );
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
+      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
+                  r1, r2, dest, jumpIfNull);
+      break;
+    }
+    case TK_ISNULL:
+    case TK_NOTNULL: {
+      assert( TK_ISNULL==OP_IsNull );
+      assert( TK_NOTNULL==OP_NotNull );
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      sqlite3VdbeAddOp2(v, op, r1, dest);
+      break;
+    }
+    case TK_BETWEEN: {
+      /*    x BETWEEN y AND z
+      **
+      ** Is equivalent to 
+      **
+      **    x>=y AND x<=z
+      **
+      ** Code it as such, taking care to do the common subexpression
+      ** elementation of x.
+      */
+      Expr exprAnd;
+      Expr compLeft;
+      Expr compRight;
+      Expr exprX;
+
+      exprX = *pExpr->pLeft;
+      exprAnd.op = TK_AND;
+      exprAnd.pLeft = &compLeft;
+      exprAnd.pRight = &compRight;
+      compLeft.op = TK_GE;
+      compLeft.pLeft = &exprX;
+      compLeft.pRight = pExpr->pList->a[0].pExpr;
+      compRight.op = TK_LE;
+      compRight.pLeft = &exprX;
+      compRight.pRight = pExpr->pList->a[1].pExpr;
+      exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
+      exprX.op = TK_REGISTER;
+      sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
+      break;
+    }
+    default: {
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
+      sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
+      break;
+    }
+  }
+  sqlite3ReleaseTempReg(pParse, regFree1);
+  sqlite3ReleaseTempReg(pParse, regFree2);  
+}
+
+/*
+** Generate code for a boolean expression such that a jump is made
+** to the label "dest" if the expression is false but execution
+** continues straight thru if the expression is true.
+**
+** If the expression evaluates to NULL (neither true nor false) then
+** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
+** is 0.
+*/
+void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
+  Vdbe *v = pParse->pVdbe;
+  int op = 0;
+  int regFree1 = 0;
+  int regFree2 = 0;
+  int r1, r2;
+
+  assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
+  if( v==0 || pExpr==0 ) return;
+
+  /* The value of pExpr->op and op are related as follows:
+  **
+  **       pExpr->op            op
+  **       ---------          ----------
+  **       TK_ISNULL          OP_NotNull
+  **       TK_NOTNULL         OP_IsNull
+  **       TK_NE              OP_Eq
+  **       TK_EQ              OP_Ne
+  **       TK_GT              OP_Le
+  **       TK_LE              OP_Gt
+  **       TK_GE              OP_Lt
+  **       TK_LT              OP_Ge
+  **
+  ** For other values of pExpr->op, op is undefined and unused.
+  ** The value of TK_ and OP_ constants are arranged such that we
+  ** can compute the mapping above using the following expression.
+  ** Assert()s verify that the computation is correct.
+  */
+  op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
+
+  /* Verify correct alignment of TK_ and OP_ constants
+  */
+  assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
+  assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
+  assert( pExpr->op!=TK_NE || op==OP_Eq );
+  assert( pExpr->op!=TK_EQ || op==OP_Ne );
+  assert( pExpr->op!=TK_LT || op==OP_Ge );
+  assert( pExpr->op!=TK_LE || op==OP_Gt );
+  assert( pExpr->op!=TK_GT || op==OP_Le );
+  assert( pExpr->op!=TK_GE || op==OP_Lt );
+
+  switch( pExpr->op ){
+    case TK_AND: {
+      sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
+      sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
+      break;
+    }
+    case TK_OR: {
+      int d2 = sqlite3VdbeMakeLabel(v);
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
+      sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
+      sqlite3VdbeResolveLabel(v, d2);
+      break;
+    }
+    case TK_NOT: {
+      sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
+      break;
+    }
+    case TK_LT:
+    case TK_LE:
+    case TK_GT:
+    case TK_GE:
+    case TK_NE:
+    case TK_EQ: {
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
+      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
+                  r1, r2, dest, jumpIfNull);
+      break;
+    }
+    case TK_ISNULL:
+    case TK_NOTNULL: {
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
+      sqlite3VdbeAddOp2(v, op, r1, dest);
+      break;
+    }
+    case TK_BETWEEN: {
+      /*    x BETWEEN y AND z
+      **
+      ** Is equivalent to 
+      **
+      **    x>=y AND x<=z
+      **
+      ** Code it as such, taking care to do the common subexpression
+      ** elementation of x.
+      */
+      Expr exprAnd;
+      Expr compLeft;
+      Expr compRight;
+      Expr exprX;
+
+      exprX = *pExpr->pLeft;
+      exprAnd.op = TK_AND;
+      exprAnd.pLeft = &compLeft;
+      exprAnd.pRight = &compRight;
+      compLeft.op = TK_GE;
+      compLeft.pLeft = &exprX;
+      compLeft.pRight = pExpr->pList->a[0].pExpr;
+      compRight.op = TK_LE;
+      compRight.pLeft = &exprX;
+      compRight.pRight = pExpr->pList->a[1].pExpr;
+      exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, &regFree1);
+      exprX.op = TK_REGISTER;
+      sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
+      break;
+    }
+    default: {
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
+      sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
+      break;
+    }
+  }
+  sqlite3ReleaseTempReg(pParse, regFree1);
+  sqlite3ReleaseTempReg(pParse, regFree2);
+}
+
+/*
+** Do a deep comparison of two expression trees.  Return TRUE (non-zero)
+** if they are identical and return FALSE if they differ in any way.
+**
+** Sometimes this routine will return FALSE even if the two expressions
+** really are equivalent.  If we cannot prove that the expressions are
+** identical, we return FALSE just to be safe.  So if this routine
+** returns false, then you do not really know for certain if the two
+** expressions are the same.  But if you get a TRUE return, then you
+** can be sure the expressions are the same.  In the places where
+** this routine is used, it does not hurt to get an extra FALSE - that
+** just might result in some slightly slower code.  But returning
+** an incorrect TRUE could lead to a malfunction.
+*/
+int sqlite3ExprCompare(Expr *pA, Expr *pB){
+  int i;
+  if( pA==0||pB==0 ){
+    return pB==pA;
+  }
+  if( pA->op!=pB->op ) return 0;
+  if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) 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) ){
+        return 0;
+      }
+    }
+  }else if( pB->pList ){
+    return 0;
+  }
+  if( pA->pSelect || pB->pSelect ) return 0;
+  if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
+  if( pA->op!=TK_COLUMN && pA->token.z ){
+    if( pB->token.z==0 ) return 0;
+    if( pB->token.n!=pA->token.n ) return 0;
+    if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){
+      return 0;
+    }
+  }
+  return 1;
+}
+
+
+/*
+** Add a new element to the pAggInfo->aCol[] array.  Return the index of
+** the new element.  Return a negative number if malloc fails.
+*/
+static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
+  int i;
+  pInfo->aCol = sqlite3ArrayAllocate(
+       db,
+       pInfo->aCol,
+       sizeof(pInfo->aCol[0]),
+       3,
+       &pInfo->nColumn,
+       &pInfo->nColumnAlloc,
+       &i
+  );
+  return i;
+}    
+
+/*
+** Add a new element to the pAggInfo->aFunc[] array.  Return the index of
+** the new element.  Return a negative number if malloc fails.
+*/
+static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
+  int i;
+  pInfo->aFunc = sqlite3ArrayAllocate(
+       db, 
+       pInfo->aFunc,
+       sizeof(pInfo->aFunc[0]),
+       3,
+       &pInfo->nFunc,
+       &pInfo->nFuncAlloc,
+       &i
+  );
+  return i;
+}    
+
+/*
+** 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;
+  NameContext *pNC = (NameContext *)pArg;
+  Parse *pParse = pNC->pParse;
+  SrcList *pSrcList = pNC->pSrcList;
+  AggInfo *pAggInfo = pNC->pAggInfo;
+
+  switch( pExpr->op ){
+    case TK_AGG_COLUMN:
+    case TK_COLUMN: {
+      /* Check to see if the column is in one of the tables in the FROM
+      ** clause of the aggregate query */
+      if( pSrcList ){
+        struct SrcList_item *pItem = pSrcList->a;
+        for(i=0; i<pSrcList->nSrc; i++, pItem++){
+          struct AggInfo_col *pCol;
+          if( pExpr->iTable==pItem->iCursor ){
+            /* If we reach this point, it means that pExpr refers to a table
+            ** that is in the FROM clause of the aggregate query.  
+            **
+            ** Make an entry for the column in pAggInfo->aCol[] if there
+            ** is not an entry there already.
+            */
+            int k;
+            pCol = pAggInfo->aCol;
+            for(k=0; k<pAggInfo->nColumn; k++, pCol++){
+              if( pCol->iTable==pExpr->iTable &&
+                  pCol->iColumn==pExpr->iColumn ){
+                break;
+              }
+            }
+            if( (k>=pAggInfo->nColumn)
+             && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 
+            ){
+              pCol = &pAggInfo->aCol[k];
+              pCol->pTab = pExpr->pTab;
+              pCol->iTable = pExpr->iTable;
+              pCol->iColumn = pExpr->iColumn;
+              pCol->iMem = ++pParse->nMem;
+              pCol->iSorterColumn = -1;
+              pCol->pExpr = pExpr;
+              if( pAggInfo->pGroupBy ){
+                int j, n;
+                ExprList *pGB = pAggInfo->pGroupBy;
+                struct ExprList_item *pTerm = pGB->a;
+                n = pGB->nExpr;
+                for(j=0; j<n; j++, pTerm++){
+                  Expr *pE = pTerm->pExpr;
+                  if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
+                      pE->iColumn==pExpr->iColumn ){
+                    pCol->iSorterColumn = j;
+                    break;
+                  }
+                }
+              }
+              if( pCol->iSorterColumn<0 ){
+                pCol->iSorterColumn = pAggInfo->nSortingColumn++;
+              }
+            }
+            /* There is now an entry for pExpr in pAggInfo->aCol[] (either
+            ** because it was there before or because we just created it).
+            ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
+            ** pAggInfo->aCol[] entry.
+            */
+            pExpr->pAggInfo = pAggInfo;
+            pExpr->op = TK_AGG_COLUMN;
+            pExpr->iAgg = k;
+            break;
+          } /* endif pExpr->iTable==pItem->iCursor */
+        } /* end loop over pSrcList */
+      }
+      return 1;
+    }
+    case TK_AGG_FUNCTION: {
+      /* The pNC->nDepth==0 test causes aggregate functions in subqueries
+      ** to be ignored */
+      if( pNC->nDepth==0 ){
+        /* Check to see if pExpr is a duplicate of another aggregate 
+        ** function that is already in the pAggInfo structure
+        */
+        struct AggInfo_func *pItem = pAggInfo->aFunc;
+        for(i=0; i<pAggInfo->nFunc; i++, pItem++){
+          if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
+            break;
+          }
+        }
+        if( i>=pAggInfo->nFunc ){
+          /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]
+          */
+          u8 enc = ENC(pParse->db);
+          i = addAggInfoFunc(pParse->db, pAggInfo);
+          if( i>=0 ){
+            pItem = &pAggInfo->aFunc[i];
+            pItem->pExpr = pExpr;
+            pItem->iMem = ++pParse->nMem;
+            pItem->pFunc = sqlite3FindFunction(pParse->db,
+                   (char*)pExpr->token.z, pExpr->token.n,
+                   pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
+            if( pExpr->flags & EP_Distinct ){
+              pItem->iDistinct = pParse->nTab++;
+            }else{
+              pItem->iDistinct = -1;
+            }
+          }
+        }
+        /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
+        */
+        pExpr->iAgg = i;
+        pExpr->pAggInfo = pAggInfo;
+        return 1;
+      }
+    }
+  }
+
+  /* Recursively walk subqueries looking for TK_COLUMN nodes that need
+  ** to be changed to TK_AGG_COLUMN.  But increment nDepth so that
+  ** TK_AGG_FUNCTION nodes in subqueries will be unchanged.
+  */
+  if( pExpr->pSelect ){
+    pNC->nDepth++;
+    walkSelectExpr(pExpr->pSelect, analyzeAggregate, pNC);
+    pNC->nDepth--;
+  }
+  return 0;
+}
+
+/*
+** Analyze the given expression looking for aggregate functions and
+** for variables that need to be added to the pParse->aAgg[] array.
+** Make additional entries to the pParse->aAgg[] array as necessary.
+**
+** This routine should only be called after the expression has been
+** analyzed by sqlite3ExprResolveNames().
+*/
+void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
+  walkExprTree(pExpr, analyzeAggregate, pNC);
+}
+
+/*
+** Call sqlite3ExprAnalyzeAggregates() for every expression in an
+** expression list.  Return the number of errors.
+**
+** If an error is found, the analysis is cut short.
+*/
+void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
+  struct ExprList_item *pItem;
+  int i;
+  if( pList ){
+    for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
+      sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
+    }
+  }
+}
+
+/*
+** Allocate or deallocate temporary use registers during code generation.
+*/
+int sqlite3GetTempReg(Parse *pParse){
+  if( pParse->nTempReg ){
+    return pParse->aTempReg[--pParse->nTempReg];
+  }else{
+    return ++pParse->nMem;
+  }
+}
+void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
+  if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
+    assert( iReg>0 );
+    pParse->aTempReg[pParse->nTempReg++] = iReg;
+  }
+}
+
+/*
+** Allocate or deallocate a block of nReg consecutive registers
+*/
+int sqlite3GetTempRange(Parse *pParse, int nReg){
+  int i;
+  if( nReg<=pParse->nRangeReg ){
+    i  = pParse->iRangeReg;
+    pParse->iRangeReg += nReg;
+    pParse->nRangeReg -= nReg;
+  }else{
+    i = pParse->nMem+1;
+    pParse->nMem += nReg;
+  }
+  return i;
+}
+void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
+  if( nReg>pParse->nRangeReg ){
+    pParse->nRangeReg = nReg;
+    pParse->iRangeReg = iReg;
+  }
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/fault.c b/client/src/thirdparty/sqlite-3.4.2/src/fault.c
new file mode 100644
index 0000000..4cc369e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/fault.c
@@ -0,0 +1,147 @@
+/*
+** 2008 Jan 22
+**
+** 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 to implement a fault-injector used for
+** testing and verification of SQLite.
+**
+** Subsystems within SQLite can call sqlite3FaultStep() to see if
+** they should simulate a fault.  sqlite3FaultStep() normally returns
+** zero but will return non-zero if a fault should be simulated.
+** Fault injectors can be used, for example, to simulate memory
+** allocation failures or I/O errors.
+**
+** The fault injector is omitted from the code if SQLite is
+** compiled with -DSQLITE_OMIT_FAULTINJECTOR=1.  There is a very
+** small performance hit for leaving the fault injector in the code.
+** Commerical products will probably want to omit the fault injector
+** from production builds.  But safety-critical systems who work
+** under the motto "fly what you test and test what you fly" may
+** choose to leave the fault injector enabled even in production.
+*/
+#include "sqliteInt.h"
+
+#ifndef SQLITE_OMIT_FAULTINJECTOR
+
+/*
+** There can be various kinds of faults.  For example, there can be
+** a memory allocation failure.  Or an I/O failure.  For each different
+** fault type, there is a separate FaultInjector structure to keep track
+** of the status of that fault.
+*/
+static struct FaultInjector {
+  int iCountdown;   /* Number of pending successes before we hit a failure */
+  int nRepeat;      /* Number of times to repeat the failure */
+  int nBenign;      /* Number of benign failures seen since last config */
+  int nFail;        /* Number of failures seen since last config */
+  u8 enable;        /* True if enabled */
+  u8 benign;        /* Ture if next failure will be benign */
+} aFault[SQLITE_FAULTINJECTOR_COUNT];
+
+/*
+** This routine configures and enables a fault injector.  After
+** calling this routine, aFaultStep() will return false (zero)
+** nDelay times, then it will return true nRepeat times,
+** then it will again begin returning false.
+*/
+void sqlite3FaultConfig(int id, int nDelay, int nRepeat){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  aFault[id].iCountdown = nDelay;
+  aFault[id].nRepeat = nRepeat;
+  aFault[id].nBenign = 0;
+  aFault[id].nFail = 0;
+  aFault[id].enable = nDelay>=0;
+  aFault[id].benign = 0;
+}
+
+/*
+** Return the number of faults (both hard and benign faults) that have
+** occurred since the injector was last configured.
+*/
+int sqlite3FaultFailures(int id){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  return aFault[id].nFail;
+}
+
+/*
+** Return the number of benign faults that have occurred since the
+** injector was last configured.
+*/
+int sqlite3FaultBenignFailures(int id){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  return aFault[id].nBenign;
+}
+
+/*
+** Return the number of successes that will occur before the next failure.
+** If no failures are scheduled, return -1.
+*/
+int sqlite3FaultPending(int id){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  if( aFault[id].enable ){
+    return aFault[id].iCountdown;
+  }else{
+    return -1;
+  }
+}
+
+/* 
+** After this routine causes subsequent faults to be either benign
+** or hard (not benign), according to the "enable" parameter.
+**
+** Most faults are hard.  In other words, most faults cause
+** an error to be propagated back up to the application interface.
+** However, sometimes a fault is easily recoverable.  For example,
+** if a malloc fails while resizing a hash table, this is completely
+** recoverable simply by not carrying out the resize.  The hash table
+** will continue to function normally.  So a malloc failure during
+** a hash table resize is a benign fault.  
+*/
+void sqlite3FaultBenign(int id, int enable){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  aFault[id].benign = enable;
+}
+
+/*
+** This routine exists as a place to set a breakpoint that will
+** fire on any simulated fault.
+*/
+static void sqlite3Fault(void){
+  static int cnt = 0;
+  cnt++;
+}
+
+
+/*
+** Check to see if a fault should be simulated.  Return true to simulate
+** the fault.  Return false if the fault should not be simulated.
+*/
+int sqlite3FaultStep(int id){
+  assert( id>=0 && id<SQLITE_FAULTINJECTOR_COUNT );
+  if( likely(!aFault[id].enable) ){
+    return 0;
+  }
+  if( aFault[id].iCountdown>0 ){
+    aFault[id].iCountdown--;
+    return 0;
+  }
+  sqlite3Fault();
+  aFault[id].nFail++;
+  if( aFault[id].benign ){
+    aFault[id].nBenign++;
+  }
+  aFault[id].nRepeat--;
+  if( aFault[id].nRepeat<=0 ){
+    aFault[id].enable = 0;
+  }
+  return 1;  
+}
+
+#endif /* SQLITE_OMIT_FAULTINJECTOR */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/func.c b/client/src/thirdparty/sqlite-3.4.2/src/func.c
new file mode 100644
index 0000000..840254b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/func.c
@@ -0,0 +1,1572 @@
+/*
+** 2002 February 23
+**
+** 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 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.183 2008/01/21 16:22:46 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "vdbeInt.h"
+
+
+/*
+** Return the collating function associated with a function.
+*/
+static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
+  return context->pColl;
+}
+
+/*
+** Implementation of the non-aggregate min() and max() functions
+*/
+static void minmaxFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int i;
+  int mask;    /* 0 for min() or 0xffffffff for max() */
+  int iBest;
+  CollSeq *pColl;
+
+  if( argc==0 ) return;
+  mask = sqlite3_user_data(context)==0 ? 0 : -1;
+  pColl = sqlite3GetFuncCollSeq(context);
+  assert( pColl );
+  assert( mask==-1 || mask==0 );
+  iBest = 0;
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  for(i=1; i<argc; i++){
+    if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
+    if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
+      iBest = i;
+    }
+  }
+  sqlite3_result_value(context, argv[iBest]);
+}
+
+/*
+** Return the type of the argument.
+*/
+static void typeofFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const char *z = 0;
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_NULL:    z = "null";    break;
+    case SQLITE_INTEGER: z = "integer"; break;
+    case SQLITE_TEXT:    z = "text";    break;
+    case SQLITE_FLOAT:   z = "real";    break;
+    case SQLITE_BLOB:    z = "blob";    break;
+  }
+  sqlite3_result_text(context, z, -1, SQLITE_STATIC);
+}
+
+
+/*
+** Implementation of the length() function
+*/
+static void lengthFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int len;
+
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_BLOB:
+    case SQLITE_INTEGER:
+    case SQLITE_FLOAT: {
+      sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
+      break;
+    }
+    case SQLITE_TEXT: {
+      const unsigned char *z = sqlite3_value_text(argv[0]);
+      if( z==0 ) return;
+      len = 0;
+      while( *z ){
+        len++;
+        SQLITE_SKIP_UTF8(z);
+      }
+      sqlite3_result_int(context, len);
+      break;
+    }
+    default: {
+      sqlite3_result_null(context);
+      break;
+    }
+  }
+}
+
+/*
+** Implementation of the abs() function
+*/
+static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+      i64 iVal = sqlite3_value_int64(argv[0]);
+      if( iVal<0 ){
+        if( (iVal<<1)==0 ){
+          sqlite3_result_error(context, "integer overflow", -1);
+          return;
+        }
+        iVal = -iVal;
+      } 
+      sqlite3_result_int64(context, iVal);
+      break;
+    }
+    case SQLITE_NULL: {
+      sqlite3_result_null(context);
+      break;
+    }
+    default: {
+      double rVal = sqlite3_value_double(argv[0]);
+      if( rVal<0 ) rVal = -rVal;
+      sqlite3_result_double(context, rVal);
+      break;
+    }
+  }
+}
+
+/*
+** Implementation of the substr() function.
+**
+** substr(x,p1,p2)  returns p2 characters of x[] beginning with p1.
+** p1 is 1-indexed.  So substr(x,1,1) returns the first character
+** of x.  If x is text, then we actually count UTF-8 characters.
+** If x is a blob, then we count bytes.
+**
+** If p1 is negative, then we begin abs(p1) from the end of x[].
+*/
+static void substrFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const unsigned char *z;
+  const unsigned char *z2;
+  int len;
+  int p0type;
+  i64 p1, p2;
+
+  assert( argc==3 || argc==2 );
+  p0type = sqlite3_value_type(argv[0]);
+  if( p0type==SQLITE_BLOB ){
+    len = sqlite3_value_bytes(argv[0]);
+    z = sqlite3_value_blob(argv[0]);
+    if( z==0 ) return;
+    assert( len==sqlite3_value_bytes(argv[0]) );
+  }else{
+    z = sqlite3_value_text(argv[0]);
+    if( z==0 ) return;
+    len = 0;
+    for(z2=z; *z2; len++){
+      SQLITE_SKIP_UTF8(z2);
+    }
+  }
+  p1 = sqlite3_value_int(argv[1]);
+  if( argc==3 ){
+    p2 = sqlite3_value_int(argv[2]);
+  }else{
+    p2 = SQLITE_MAX_LENGTH;
+  }
+  if( p1<0 ){
+    p1 += len;
+    if( p1<0 ){
+      p2 += p1;
+      p1 = 0;
+    }
+  }else if( p1>0 ){
+    p1--;
+  }
+  if( p1+p2>len ){
+    p2 = len-p1;
+  }
+  if( p0type!=SQLITE_BLOB ){
+    while( *z && p1 ){
+      SQLITE_SKIP_UTF8(z);
+      p1--;
+    }
+    for(z2=z; *z2 && p2; p2--){
+      SQLITE_SKIP_UTF8(z2);
+    }
+    sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT);
+  }else{
+    if( p2<0 ) p2 = 0;
+    sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);
+  }
+}
+
+/*
+** Implementation of the round() function
+*/
+static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  int n = 0;
+  double r;
+  char zBuf[500];  /* larger than the %f representation of the largest double */
+  assert( argc==1 || argc==2 );
+  if( argc==2 ){
+    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
+    n = sqlite3_value_int(argv[1]);
+    if( n>30 ) n = 30;
+    if( n<0 ) n = 0;
+  }
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  r = sqlite3_value_double(argv[0]);
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r);
+  sqlite3AtoF(zBuf, &r);
+  sqlite3_result_double(context, r);
+}
+
+/*
+** Allocate nByte bytes of space using sqlite3_malloc(). If the
+** allocation fails, call sqlite3_result_error_nomem() to notify
+** the database handle that malloc() has failed.
+*/
+static void *contextMalloc(sqlite3_context *context, int nByte){
+  char *z = sqlite3_malloc(nByte);
+  if( !z && nByte>0 ){
+    sqlite3_result_error_nomem(context);
+  }
+  return z;
+}
+
+/*
+** Implementation of the upper() and lower() SQL functions.
+*/
+static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  char *z1;
+  const char *z2;
+  int i, n;
+  if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
+  z2 = (char*)sqlite3_value_text(argv[0]);
+  n = sqlite3_value_bytes(argv[0]);
+  /* Verify that the call to _bytes() does not invalidate the _text() pointer */
+  assert( z2==(char*)sqlite3_value_text(argv[0]) );
+  if( z2 ){
+    z1 = contextMalloc(context, n+1);
+    if( z1 ){
+      memcpy(z1, z2, n+1);
+      for(i=0; z1[i]; i++){
+        z1[i] = toupper(z1[i]);
+      }
+      sqlite3_result_text(context, z1, -1, sqlite3_free);
+    }
+  }
+}
+static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  char *z1;
+  const char *z2;
+  int i, n;
+  if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
+  z2 = (char*)sqlite3_value_text(argv[0]);
+  n = sqlite3_value_bytes(argv[0]);
+  /* Verify that the call to _bytes() does not invalidate the _text() pointer */
+  assert( z2==(char*)sqlite3_value_text(argv[0]) );
+  if( z2 ){
+    z1 = contextMalloc(context, n+1);
+    if( z1 ){
+      memcpy(z1, z2, n+1);
+      for(i=0; z1[i]; i++){
+        z1[i] = tolower(z1[i]);
+      }
+      sqlite3_result_text(context, z1, -1, sqlite3_free);
+    }
+  }
+}
+
+/*
+** Implementation of the IFNULL(), NVL(), and COALESCE() functions.  
+** All three do the same thing.  They return the first non-NULL
+** argument.
+*/
+static void ifnullFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int i;
+  for(i=0; i<argc; i++){
+    if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
+      sqlite3_result_value(context, argv[i]);
+      break;
+    }
+  }
+}
+
+/*
+** Implementation of random().  Return a random integer.  
+*/
+static void randomFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite_int64 r;
+  sqlite3Randomness(sizeof(r), &r);
+  if( (r<<1)==0 ) r = 0;  /* Prevent 0x8000.... as the result so that we */
+                          /* can always do abs() of the result */
+  sqlite3_result_int64(context, r);
+}
+
+/*
+** Implementation of randomblob(N).  Return a random blob
+** that is N bytes long.
+*/
+static void randomBlob(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int n;
+  unsigned char *p;
+  assert( argc==1 );
+  n = sqlite3_value_int(argv[0]);
+  if( n<1 ){
+    n = 1;
+  }
+  if( n>SQLITE_MAX_LENGTH ){
+    sqlite3_result_error_toobig(context);
+    return;
+  }
+  p = contextMalloc(context, n);
+  if( p ){
+    sqlite3Randomness(n, p);
+    sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
+  }
+}
+
+/*
+** Implementation of the last_insert_rowid() SQL function.  The return
+** value is the same as the sqlite3_last_insert_rowid() API function.
+*/
+static void last_insert_rowid(
+  sqlite3_context *context, 
+  int arg, 
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_user_data(context);
+  sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
+}
+
+/*
+** Implementation of the changes() SQL function.  The return value is the
+** same as the sqlite3_changes() API function.
+*/
+static void changes(
+  sqlite3_context *context,
+  int arg,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_user_data(context);
+  sqlite3_result_int(context, sqlite3_changes(db));
+}
+
+/*
+** Implementation of the total_changes() SQL function.  The return value is
+** the same as the sqlite3_total_changes() API function.
+*/
+static void total_changes(
+  sqlite3_context *context,
+  int arg,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_user_data(context);
+  sqlite3_result_int(context, sqlite3_total_changes(db));
+}
+
+/*
+** A structure defining how to do GLOB-style comparisons.
+*/
+struct compareInfo {
+  u8 matchAll;
+  u8 matchOne;
+  u8 matchSet;
+  u8 noCase;
+};
+
+/*
+** For LIKE and GLOB matching on EBCDIC machines, assume that every
+** character is exactly one byte in size.  Also, all characters are
+** able to participate in upper-case-to-lower-case mappings in EBCDIC
+** whereas only characters less than 0x80 do in ASCII.
+*/
+#if defined(SQLITE_EBCDIC)
+# define sqlite3Utf8Read(A,B,C)  (*(A++))
+# define GlogUpperToLower(A)     A = sqlite3UpperToLower[A]
+#else
+# define GlogUpperToLower(A)     if( A<0x80 ){ A = sqlite3UpperToLower[A]; }
+#endif
+
+static const struct compareInfo globInfo = { '*', '?', '[', 0 };
+/* The correct SQL-92 behavior is for the LIKE operator to ignore
+** case.  Thus  'a' LIKE 'A' would be true. */
+static const struct compareInfo likeInfoNorm = { '%', '_',   0, 1 };
+/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
+** is case sensitive causing 'a' LIKE 'A' to be false */
+static const struct compareInfo likeInfoAlt = { '%', '_',   0, 0 };
+
+/*
+** Compare two UTF-8 strings for equality where the first string can
+** potentially be a "glob" expression.  Return true (1) if they
+** are the same and false (0) if they are different.
+**
+** Globbing rules:
+**
+**      '*'       Matches any sequence of zero or more characters.
+**
+**      '?'       Matches exactly one character.
+**
+**     [...]      Matches one character from the enclosed list of
+**                characters.
+**
+**     [^...]     Matches one character not in the enclosed list.
+**
+** With the [...] and [^...] matching, a ']' character can be included
+** in the list by making it the first character after '[' or '^'.  A
+** range of characters can be specified using '-'.  Example:
+** "[a-z]" matches any single lower-case letter.  To match a '-', make
+** it the last character in the list.
+**
+** This routine is usually quick, but can be N**2 in the worst case.
+**
+** Hints: to match '*' or '?', put them in "[]".  Like this:
+**
+**         abc[*]xyz        Matches "abc*xyz" only
+*/
+static int patternCompare(
+  const u8 *zPattern,              /* The glob pattern */
+  const u8 *zString,               /* The string to compare against the glob */
+  const struct compareInfo *pInfo, /* Information about how to do the compare */
+  const int esc                    /* The escape character */
+){
+  int c, c2;
+  int invert;
+  int seen;
+  u8 matchOne = pInfo->matchOne;
+  u8 matchAll = pInfo->matchAll;
+  u8 matchSet = pInfo->matchSet;
+  u8 noCase = pInfo->noCase; 
+  int prevEscape = 0;     /* True if the previous character was 'escape' */
+
+  while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){
+    if( !prevEscape && c==matchAll ){
+      while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll
+               || c == matchOne ){
+        if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){
+          return 0;
+        }
+      }
+      if( c==0 ){
+        return 1;
+      }else if( c==esc ){
+        c = sqlite3Utf8Read(zPattern, 0, &zPattern);
+        if( c==0 ){
+          return 0;
+        }
+      }else if( c==matchSet ){
+        assert( esc==0 );         /* This is GLOB, not LIKE */
+        assert( matchSet<0x80 );  /* '[' is a single-byte character */
+        while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
+          SQLITE_SKIP_UTF8(zString);
+        }
+        return *zString!=0;
+      }
+      while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){
+        if( noCase ){
+          GlogUpperToLower(c2);
+          GlogUpperToLower(c);
+          while( c2 != 0 && c2 != c ){
+            c2 = sqlite3Utf8Read(zString, 0, &zString);
+            GlogUpperToLower(c2);
+          }
+        }else{
+          while( c2 != 0 && c2 != c ){
+            c2 = sqlite3Utf8Read(zString, 0, &zString);
+          }
+        }
+        if( c2==0 ) return 0;
+        if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
+      }
+      return 0;
+    }else if( !prevEscape && c==matchOne ){
+      if( sqlite3Utf8Read(zString, 0, &zString)==0 ){
+        return 0;
+      }
+    }else if( c==matchSet ){
+      int prior_c = 0;
+      assert( esc==0 );    /* This only occurs for GLOB, not LIKE */
+      seen = 0;
+      invert = 0;
+      c = sqlite3Utf8Read(zString, 0, &zString);
+      if( c==0 ) return 0;
+      c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+      if( c2=='^' ){
+        invert = 1;
+        c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+      }
+      if( c2==']' ){
+        if( c==']' ) seen = 1;
+        c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+      }
+      while( c2 && c2!=']' ){
+        if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
+          c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+          if( c>=prior_c && c<=c2 ) seen = 1;
+          prior_c = 0;
+        }else{
+          if( c==c2 ){
+            seen = 1;
+          }
+          prior_c = c2;
+        }
+        c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+      }
+      if( c2==0 || (seen ^ invert)==0 ){
+        return 0;
+      }
+    }else if( esc==c && !prevEscape ){
+      prevEscape = 1;
+    }else{
+      c2 = sqlite3Utf8Read(zString, 0, &zString);
+      if( noCase ){
+        GlogUpperToLower(c);
+        GlogUpperToLower(c2);
+      }
+      if( c!=c2 ){
+        return 0;
+      }
+      prevEscape = 0;
+    }
+  }
+  return *zString==0;
+}
+
+/*
+** Count the number of times that the LIKE operator (or GLOB which is
+** just a variation of LIKE) gets called.  This is used for testing
+** only.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_like_count = 0;
+#endif
+
+
+/*
+** Implementation of the like() SQL function.  This function implements
+** the build-in LIKE operator.  The first argument to the function is the
+** pattern and the second argument is the string.  So, the SQL statements:
+**
+**       A LIKE B
+**
+** is implemented as like(B,A).
+**
+** This same function (with a different compareInfo structure) computes
+** the GLOB operator.
+*/
+static void likeFunc(
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv
+){
+  const unsigned char *zA, *zB;
+  int escape = 0;
+
+  zB = sqlite3_value_text(argv[0]);
+  zA = sqlite3_value_text(argv[1]);
+
+  /* Limit the length of the LIKE or GLOB pattern to avoid problems
+  ** of deep recursion and N*N behavior in patternCompare().
+  */
+  if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
+    sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
+    return;
+  }
+  assert( zB==sqlite3_value_text(argv[0]) );  /* Encoding did not change */
+
+  if( argc==3 ){
+    /* The escape character string must consist of a single UTF-8 character.
+    ** Otherwise, return an error.
+    */
+    const unsigned char *zEsc = sqlite3_value_text(argv[2]);
+    if( zEsc==0 ) return;
+    if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
+      sqlite3_result_error(context, 
+          "ESCAPE expression must be a single character", -1);
+      return;
+    }
+    escape = sqlite3Utf8Read(zEsc, 0, &zEsc);
+  }
+  if( zA && zB ){
+    struct compareInfo *pInfo = sqlite3_user_data(context);
+#ifdef SQLITE_TEST
+    sqlite3_like_count++;
+#endif
+    
+    sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
+  }
+}
+
+/*
+** Implementation of the NULLIF(x,y) function.  The result is the first
+** argument if the arguments are different.  The result is NULL if the
+** arguments are equal to each other.
+*/
+static void nullifFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  CollSeq *pColl = sqlite3GetFuncCollSeq(context);
+  if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
+    sqlite3_result_value(context, argv[0]);
+  }
+}
+
+/*
+** Implementation of the VERSION(*) function.  The result is the version
+** of the SQLite library that is running.
+*/
+static void versionFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC);
+}
+
+/* Array for converting from half-bytes (nybbles) into ASCII hex
+** digits. */
+static const char hexdigits[] = {
+  '0', '1', '2', '3', '4', '5', '6', '7',
+  '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 
+};
+
+/*
+** EXPERIMENTAL - This is not an official function.  The interface may
+** change.  This function may disappear.  Do not write code that depends
+** on this function.
+**
+** Implementation of the QUOTE() function.  This function takes a single
+** argument.  If the argument is numeric, the return value is the same as
+** the argument.  If the argument is NULL, the return value is the string
+** "NULL".  Otherwise, the argument is enclosed in single quotes with
+** single-quote escapes.
+*/
+static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  if( argc<1 ) return;
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_NULL: {
+      sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
+      break;
+    }
+    case SQLITE_INTEGER:
+    case SQLITE_FLOAT: {
+      sqlite3_result_value(context, argv[0]);
+      break;
+    }
+    case SQLITE_BLOB: {
+      char *zText = 0;
+      char const *zBlob = sqlite3_value_blob(argv[0]);
+      int nBlob = sqlite3_value_bytes(argv[0]);
+      assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
+
+      if( 2*nBlob+4>SQLITE_MAX_LENGTH ){
+        sqlite3_result_error_toobig(context);
+        return;
+      }
+      zText = (char *)contextMalloc(context, (2*nBlob)+4); 
+      if( zText ){
+        int i;
+        for(i=0; i<nBlob; i++){
+          zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
+          zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
+        }
+        zText[(nBlob*2)+2] = '\'';
+        zText[(nBlob*2)+3] = '\0';
+        zText[0] = 'X';
+        zText[1] = '\'';
+        sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
+        sqlite3_free(zText);
+      }
+      break;
+    }
+    case SQLITE_TEXT: {
+      int i,j;
+      u64 n;
+      const unsigned char *zArg = sqlite3_value_text(argv[0]);
+      char *z;
+
+      if( zArg==0 ) return;
+      for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
+      if( i+n+3>SQLITE_MAX_LENGTH ){
+        sqlite3_result_error_toobig(context);
+        return;
+      }
+      z = contextMalloc(context, i+n+3);
+      if( z ){
+        z[0] = '\'';
+        for(i=0, j=1; zArg[i]; i++){
+          z[j++] = zArg[i];
+          if( zArg[i]=='\'' ){
+            z[j++] = '\'';
+          }
+        }
+        z[j++] = '\'';
+        z[j] = 0;
+        sqlite3_result_text(context, z, j, sqlite3_free);
+      }
+    }
+  }
+}
+
+/*
+** The hex() function.  Interpret the argument as a blob.  Return
+** a hexadecimal rendering as text.
+*/
+static void hexFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int i, n;
+  const unsigned char *pBlob;
+  char *zHex, *z;
+  assert( argc==1 );
+  pBlob = sqlite3_value_blob(argv[0]);
+  n = sqlite3_value_bytes(argv[0]);
+  if( n*2+1>SQLITE_MAX_LENGTH ){
+    sqlite3_result_error_toobig(context);
+    return;
+  }
+  assert( pBlob==sqlite3_value_blob(argv[0]) );  /* No encoding change */
+  z = zHex = contextMalloc(context, n*2 + 1);
+  if( zHex ){
+    for(i=0; i<n; i++, pBlob++){
+      unsigned char c = *pBlob;
+      *(z++) = hexdigits[(c>>4)&0xf];
+      *(z++) = hexdigits[c&0xf];
+    }
+    *z = 0;
+    sqlite3_result_text(context, zHex, n*2, sqlite3_free);
+  }
+}
+
+/*
+** The zeroblob(N) function returns a zero-filled blob of size N bytes.
+*/
+static void zeroblobFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  i64 n;
+  assert( argc==1 );
+  n = sqlite3_value_int64(argv[0]);
+  if( n>SQLITE_MAX_LENGTH ){
+    sqlite3_result_error_toobig(context);
+  }else{
+    sqlite3_result_zeroblob(context, n);
+  }
+}
+
+/*
+** The replace() function.  Three arguments are all strings: call
+** them A, B, and C. The result is also a string which is derived
+** from A by replacing every occurance of B with C.  The match
+** must be exact.  Collating sequences are not used.
+*/
+static void replaceFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const unsigned char *zStr;        /* The input string A */
+  const unsigned char *zPattern;    /* The pattern string B */
+  const unsigned char *zRep;        /* The replacement string C */
+  unsigned char *zOut;              /* The output */
+  int nStr;                /* Size of zStr */
+  int nPattern;            /* Size of zPattern */
+  int nRep;                /* Size of zRep */
+  i64 nOut;                /* Maximum size of zOut */
+  int loopLimit;           /* Last zStr[] that might match zPattern[] */
+  int i, j;                /* Loop counters */
+
+  assert( argc==3 );
+  zStr = sqlite3_value_text(argv[0]);
+  if( zStr==0 ) return;
+  nStr = sqlite3_value_bytes(argv[0]);
+  assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
+  zPattern = sqlite3_value_text(argv[1]);
+  if( zPattern==0 || zPattern[0]==0 ) return;
+  nPattern = sqlite3_value_bytes(argv[1]);
+  assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */
+  zRep = sqlite3_value_text(argv[2]);
+  if( zRep==0 ) return;
+  nRep = sqlite3_value_bytes(argv[2]);
+  assert( zRep==sqlite3_value_text(argv[2]) );
+  nOut = nStr + 1;
+  assert( nOut<SQLITE_MAX_LENGTH );
+  zOut = contextMalloc(context, (int)nOut);
+  if( zOut==0 ){
+    return;
+  }
+  loopLimit = nStr - nPattern;  
+  for(i=j=0; i<=loopLimit; i++){
+    if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
+      zOut[j++] = zStr[i];
+    }else{
+      u8 *zOld;
+      nOut += nRep - nPattern;
+      if( nOut>=SQLITE_MAX_LENGTH ){
+        sqlite3_result_error_toobig(context);
+        sqlite3_free(zOut);
+        return;
+      }
+      zOld = zOut;
+      zOut = sqlite3_realloc(zOut, (int)nOut);
+      if( zOut==0 ){
+        sqlite3_result_error_nomem(context);
+        sqlite3_free(zOld);
+        return;
+      }
+      memcpy(&zOut[j], zRep, nRep);
+      j += nRep;
+      i += nPattern-1;
+    }
+  }
+  assert( j+nStr-i+1==nOut );
+  memcpy(&zOut[j], &zStr[i], nStr-i);
+  j += nStr - i;
+  assert( j<=nOut );
+  zOut[j] = 0;
+  sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
+}
+
+/*
+** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
+** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
+*/
+static void trimFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const unsigned char *zIn;         /* Input string */
+  const unsigned char *zCharSet;    /* Set of characters to trim */
+  int nIn;                          /* Number of bytes in input */
+  int flags;                        /* 1: trimleft  2: trimright  3: trim */
+  int i;                            /* Loop counter */
+  unsigned char *aLen;              /* Length of each character in zCharSet */
+  unsigned char **azChar;           /* Individual characters in zCharSet */
+  int nChar;                        /* Number of characters in zCharSet */
+
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
+    return;
+  }
+  zIn = sqlite3_value_text(argv[0]);
+  if( zIn==0 ) return;
+  nIn = sqlite3_value_bytes(argv[0]);
+  assert( zIn==sqlite3_value_text(argv[0]) );
+  if( argc==1 ){
+    static const unsigned char lenOne[] = { 1 };
+    static const unsigned char *azOne[] = { (u8*)" " };
+    nChar = 1;
+    aLen = (u8*)lenOne;
+    azChar = (unsigned char **)azOne;
+    zCharSet = 0;
+  }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
+    return;
+  }else{
+    const unsigned char *z;
+    for(z=zCharSet, nChar=0; *z; nChar++){
+      SQLITE_SKIP_UTF8(z);
+    }
+    if( nChar>0 ){
+      azChar = contextMalloc(context, nChar*(sizeof(char*)+1));
+      if( azChar==0 ){
+        return;
+      }
+      aLen = (unsigned char*)&azChar[nChar];
+      for(z=zCharSet, nChar=0; *z; nChar++){
+        azChar[nChar] = (unsigned char *)z;
+        SQLITE_SKIP_UTF8(z);
+        aLen[nChar] = z - azChar[nChar];
+      }
+    }
+  }
+  if( nChar>0 ){
+    flags = (int)sqlite3_user_data(context);
+    if( flags & 1 ){
+      while( nIn>0 ){
+        int len;
+        for(i=0; i<nChar; i++){
+          len = aLen[i];
+          if( memcmp(zIn, azChar[i], len)==0 ) break;
+        }
+        if( i>=nChar ) break;
+        zIn += len;
+        nIn -= len;
+      }
+    }
+    if( flags & 2 ){
+      while( nIn>0 ){
+        int len;
+        for(i=0; i<nChar; i++){
+          len = aLen[i];
+          if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
+        }
+        if( i>=nChar ) break;
+        nIn -= len;
+      }
+    }
+    if( zCharSet ){
+      sqlite3_free(azChar);
+    }
+  }
+  sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
+}
+
+#ifdef SQLITE_SOUNDEX
+/*
+** Compute the soundex encoding of a word.
+*/
+static void soundexFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  char zResult[8];
+  const u8 *zIn;
+  int i, j;
+  static const unsigned char iCode[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
+    1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
+    0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
+    1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
+  };
+  assert( argc==1 );
+  zIn = (u8*)sqlite3_value_text(argv[0]);
+  if( zIn==0 ) zIn = (u8*)"";
+  for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
+  if( zIn[i] ){
+    u8 prevcode = iCode[zIn[i]&0x7f];
+    zResult[0] = toupper(zIn[i]);
+    for(j=1; j<4 && zIn[i]; i++){
+      int code = iCode[zIn[i]&0x7f];
+      if( code>0 ){
+        if( code!=prevcode ){
+          prevcode = code;
+          zResult[j++] = code + '0';
+        }
+      }else{
+        prevcode = 0;
+      }
+    }
+    while( j<4 ){
+      zResult[j++] = '0';
+    }
+    zResult[j] = 0;
+    sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
+  }else{
+    sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
+  }
+}
+#endif
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** A function that loads a shared-library extension then returns NULL.
+*/
+static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *zFile = (const char *)sqlite3_value_text(argv[0]);
+  const char *zProc;
+  sqlite3 *db = sqlite3_user_data(context);
+  char *zErrMsg = 0;
+
+  if( argc==2 ){
+    zProc = (const char *)sqlite3_value_text(argv[1]);
+  }else{
+    zProc = 0;
+  }
+  if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
+    sqlite3_result_error(context, zErrMsg, -1);
+    sqlite3_free(zErrMsg);
+  }
+}
+#endif
+
+#ifdef SQLITE_TEST
+/*
+** This function generates a string of random characters.  Used for
+** generating test data.
+*/
+static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
+  static const unsigned char zSrc[] = 
+     "abcdefghijklmnopqrstuvwxyz"
+     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+     "0123456789"
+     ".-!,:*^+=_|?/<> ";
+  int iMin, iMax, n, r, i;
+  unsigned char zBuf[1000];
+
+  /* It used to be possible to call randstr() with any number of arguments,
+  ** but now it is registered with SQLite as requiring exactly 2.
+  */
+  assert(argc==2);
+
+  iMin = sqlite3_value_int(argv[0]);
+  if( iMin<0 ) iMin = 0;
+  if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
+  iMax = sqlite3_value_int(argv[1]);
+  if( iMax<iMin ) iMax = iMin;
+  if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
+  n = iMin;
+  if( iMax>iMin ){
+    sqlite3Randomness(sizeof(r), &r);
+    r &= 0x7fffffff;
+    n += r%(iMax + 1 - iMin);
+  }
+  assert( n<sizeof(zBuf) );
+  sqlite3Randomness(n, zBuf);
+  for(i=0; i<n; i++){
+    zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
+  }
+  zBuf[n] = 0;
+  sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
+}
+#endif /* SQLITE_TEST */
+
+#ifdef SQLITE_TEST
+/*
+** The following two SQL functions are used to test returning a text
+** result with a destructor. Function 'test_destructor' takes one argument
+** and returns the same argument interpreted as TEXT. A destructor is
+** passed with the sqlite3_result_text() call.
+**
+** SQL function 'test_destructor_count' returns the number of outstanding 
+** allocations made by 'test_destructor';
+**
+** WARNING: Not threadsafe.
+*/
+static int test_destructor_count_var = 0;
+static void destructor(void *p){
+  char *zVal = (char *)p;
+  assert(zVal);
+  zVal--;
+  sqlite3_free(zVal);
+  test_destructor_count_var--;
+}
+static void test_destructor(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  char *zVal;
+  int len;
+  sqlite3 *db = sqlite3_user_data(pCtx);
+ 
+  test_destructor_count_var++;
+  assert( nArg==1 );
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  len = sqlite3ValueBytes(argv[0], ENC(db)); 
+  zVal = contextMalloc(pCtx, len+3);
+  if( !zVal ){
+    return;
+  }
+  zVal[len+1] = 0;
+  zVal[len+2] = 0;
+  zVal++;
+  memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len);
+  if( ENC(db)==SQLITE_UTF8 ){
+    sqlite3_result_text(pCtx, zVal, -1, destructor);
+#ifndef SQLITE_OMIT_UTF16
+  }else if( ENC(db)==SQLITE_UTF16LE ){
+    sqlite3_result_text16le(pCtx, zVal, -1, destructor);
+  }else{
+    sqlite3_result_text16be(pCtx, zVal, -1, destructor);
+#endif /* SQLITE_OMIT_UTF16 */
+  }
+}
+static void test_destructor_count(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  sqlite3_result_int(pCtx, test_destructor_count_var);
+}
+#endif /* SQLITE_TEST */
+
+#ifdef SQLITE_TEST
+/*
+** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
+** interface.
+**
+** The test_auxdata() SQL function attempts to register each of its arguments
+** as auxiliary data.  If there are no prior registrations of aux data for
+** that argument (meaning the argument is not a constant or this is its first
+** call) then the result for that argument is 0.  If there is a prior
+** registration, the result for that argument is 1.  The overall result
+** is the individual argument results separated by spaces.
+*/
+static void free_test_auxdata(void *p) {sqlite3_free(p);}
+static void test_auxdata(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  int i;
+  char *zRet = contextMalloc(pCtx, nArg*2);
+  if( !zRet ) return;
+  memset(zRet, 0, nArg*2);
+  for(i=0; i<nArg; i++){
+    char const *z = (char*)sqlite3_value_text(argv[i]);
+    if( z ){
+      char *zAux = sqlite3_get_auxdata(pCtx, i);
+      if( zAux ){
+        zRet[i*2] = '1';
+        assert( strcmp(zAux,z)==0 );
+      }else {
+        zRet[i*2] = '0';
+      }
+
+      zAux = contextMalloc(pCtx, strlen(z)+1);
+      if( zAux ){
+        strcpy(zAux, z);
+        sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
+      }
+      zRet[i*2+1] = ' ';
+    }
+  }
+  sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
+}
+#endif /* SQLITE_TEST */
+
+#ifdef SQLITE_TEST
+/*
+** A function to test error reporting from user functions. This function
+** returns a copy of its first argument as an error.
+*/
+static void test_error(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), 0);
+}
+#endif /* SQLITE_TEST */
+
+/*
+** An instance of the following structure holds the context of a
+** sum() or avg() aggregate computation.
+*/
+typedef struct SumCtx SumCtx;
+struct SumCtx {
+  double rSum;      /* Floating point sum */
+  i64 iSum;         /* Integer sum */   
+  i64 cnt;          /* Number of elements summed */
+  u8 overflow;      /* True if integer overflow seen */
+  u8 approx;        /* True if non-integer value was input to the sum */
+};
+
+/*
+** Routines used to compute the sum, average, and total.
+**
+** The SUM() function follows the (broken) SQL standard which means
+** that it returns NULL if it sums over no inputs.  TOTAL returns
+** 0.0 in that case.  In addition, TOTAL always returns a float where
+** SUM might return an integer if it never encounters a floating point
+** value.  TOTAL never fails, but SUM might through an exception if
+** it overflows an integer.
+*/
+static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
+  SumCtx *p;
+  int type;
+  assert( argc==1 );
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  type = sqlite3_value_numeric_type(argv[0]);
+  if( p && type!=SQLITE_NULL ){
+    p->cnt++;
+    if( type==SQLITE_INTEGER ){
+      i64 v = sqlite3_value_int64(argv[0]);
+      p->rSum += v;
+      if( (p->approx|p->overflow)==0 ){
+        i64 iNewSum = p->iSum + v;
+        int s1 = p->iSum >> (sizeof(i64)*8-1);
+        int s2 = v       >> (sizeof(i64)*8-1);
+        int s3 = iNewSum >> (sizeof(i64)*8-1);
+        p->overflow = (s1&s2&~s3) | (~s1&~s2&s3);
+        p->iSum = iNewSum;
+      }
+    }else{
+      p->rSum += sqlite3_value_double(argv[0]);
+      p->approx = 1;
+    }
+  }
+}
+static void sumFinalize(sqlite3_context *context){
+  SumCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->cnt>0 ){
+    if( p->overflow ){
+      sqlite3_result_error(context,"integer overflow",-1);
+    }else if( p->approx ){
+      sqlite3_result_double(context, p->rSum);
+    }else{
+      sqlite3_result_int64(context, p->iSum);
+    }
+  }
+}
+static void avgFinalize(sqlite3_context *context){
+  SumCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->cnt>0 ){
+    sqlite3_result_double(context, p->rSum/(double)p->cnt);
+  }
+}
+static void totalFinalize(sqlite3_context *context){
+  SumCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  sqlite3_result_double(context, p ? p->rSum : 0.0);
+}
+
+/*
+** The following structure keeps track of state information for the
+** count() aggregate function.
+*/
+typedef struct CountCtx CountCtx;
+struct CountCtx {
+  i64 n;
+};
+
+/*
+** Routines to implement the count() aggregate function.
+*/
+static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
+  CountCtx *p;
+  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, 0);
+  sqlite3_result_int64(context, p ? p->n : 0);
+}
+
+/*
+** Routines to implement min() and max() aggregate functions.
+*/
+static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){
+  Mem *pArg  = (Mem *)argv[0];
+  Mem *pBest;
+
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
+  if( !pBest ) return;
+
+  if( pBest->flags ){
+    int max;
+    int cmp;
+    CollSeq *pColl = sqlite3GetFuncCollSeq(context);
+    /* This step function is used for both the min() and max() aggregates,
+    ** the only difference between the two being that the sense of the
+    ** comparison is inverted. For the max() aggregate, the
+    ** sqlite3_user_data() function returns (void *)-1. For min() it
+    ** returns (void *)db, where db is the sqlite3* database pointer.
+    ** Therefore the next statement sets variable 'max' to 1 for the max()
+    ** aggregate, or 0 for min().
+    */
+    max = sqlite3_user_data(context)!=0;
+    cmp = sqlite3MemCompare(pBest, pArg, pColl);
+    if( (max && cmp<0) || (!max && cmp>0) ){
+      sqlite3VdbeMemCopy(pBest, pArg);
+    }
+  }else{
+    sqlite3VdbeMemCopy(pBest, pArg);
+  }
+}
+static void minMaxFinalize(sqlite3_context *context){
+  sqlite3_value *pRes;
+  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
+  if( pRes ){
+    if( pRes->flags ){
+      sqlite3_result_value(context, pRes);
+    }
+    sqlite3VdbeMemRelease(pRes);
+  }
+}
+
+/*
+** group_concat(EXPR, ?SEPARATOR?)
+*/
+static void groupConcatStep(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  const char *zVal;
+  StrAccum *pAccum;
+  const char *zSep;
+  int nVal, nSep;
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
+
+  if( pAccum ){
+    pAccum->useMalloc = 1;
+    if( pAccum->nChar ){
+      if( argc==2 ){
+        zSep = (char*)sqlite3_value_text(argv[1]);
+        nSep = sqlite3_value_bytes(argv[1]);
+      }else{
+        zSep = ",";
+        nSep = 1;
+      }
+      sqlite3StrAccumAppend(pAccum, zSep, nSep);
+    }
+    zVal = (char*)sqlite3_value_text(argv[0]);
+    nVal = sqlite3_value_bytes(argv[0]);
+    sqlite3StrAccumAppend(pAccum, zVal, nVal);
+  }
+}
+static void groupConcatFinalize(sqlite3_context *context){
+  StrAccum *pAccum;
+  pAccum = sqlite3_aggregate_context(context, 0);
+  if( pAccum ){
+    if( pAccum->tooBig ){
+      sqlite3_result_error_toobig(context);
+    }else if( pAccum->mallocFailed ){
+      sqlite3_result_error_nomem(context);
+    }else{    
+      sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 
+                          sqlite3_free);
+    }
+  }
+}
+
+/*
+** This function registered all of the above C functions as SQL
+** functions.  This should be the only routine in this file with
+** external linkage.
+*/
+void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
+  static const struct {
+     char *zName;
+     signed char nArg;
+     u8 argType;           /* ff: db   1: 0, 2: 1, 3: 2,...  N:  N-1. */
+     u8 eTextRep;          /* 1: UTF-16.  0: UTF-8 */
+     u8 needCollSeq;
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
+  } aFuncs[] = {
+    { "min",               -1, 0, SQLITE_UTF8,    1, minmaxFunc },
+    { "min",                0, 0, SQLITE_UTF8,    1, 0          },
+    { "max",               -1, 1, SQLITE_UTF8,    1, minmaxFunc },
+    { "max",                0, 1, SQLITE_UTF8,    1, 0          },
+    { "typeof",             1, 0, SQLITE_UTF8,    0, typeofFunc },
+    { "length",             1, 0, SQLITE_UTF8,    0, lengthFunc },
+    { "substr",             2, 0, SQLITE_UTF8,    0, substrFunc },
+    { "substr",             3, 0, SQLITE_UTF8,    0, substrFunc },
+    { "abs",                1, 0, SQLITE_UTF8,    0, absFunc    },
+    { "round",              1, 0, SQLITE_UTF8,    0, roundFunc  },
+    { "round",              2, 0, SQLITE_UTF8,    0, roundFunc  },
+    { "upper",              1, 0, SQLITE_UTF8,    0, upperFunc  },
+    { "lower",              1, 0, SQLITE_UTF8,    0, lowerFunc  },
+    { "coalesce",          -1, 0, SQLITE_UTF8,    0, ifnullFunc },
+    { "coalesce",           0, 0, SQLITE_UTF8,    0, 0          },
+    { "coalesce",           1, 0, SQLITE_UTF8,    0, 0          },
+    { "hex",                1, 0, SQLITE_UTF8,    0, hexFunc    },
+    { "ifnull",             2, 0, SQLITE_UTF8,    1, ifnullFunc },
+    { "random",            -1, 0, SQLITE_UTF8,    0, randomFunc },
+    { "randomblob",         1, 0, SQLITE_UTF8,    0, randomBlob },
+    { "nullif",             2, 0, SQLITE_UTF8,    1, nullifFunc },
+    { "sqlite_version",     0, 0, SQLITE_UTF8,    0, versionFunc},
+    { "quote",              1, 0, SQLITE_UTF8,    0, quoteFunc  },
+    { "last_insert_rowid",  0, 0xff, SQLITE_UTF8, 0, last_insert_rowid },
+    { "changes",            0, 0xff, SQLITE_UTF8, 0, changes           },
+    { "total_changes",      0, 0xff, SQLITE_UTF8, 0, total_changes     },
+    { "replace",            3, 0, SQLITE_UTF8,    0, replaceFunc       },
+    { "ltrim",              1, 1, SQLITE_UTF8,    0, trimFunc          },
+    { "ltrim",              2, 1, SQLITE_UTF8,    0, trimFunc          },
+    { "rtrim",              1, 2, SQLITE_UTF8,    0, trimFunc          },
+    { "rtrim",              2, 2, SQLITE_UTF8,    0, trimFunc          },
+    { "trim",               1, 3, SQLITE_UTF8,    0, trimFunc          },
+    { "trim",               2, 3, SQLITE_UTF8,    0, trimFunc          },
+    { "zeroblob",           1, 0, SQLITE_UTF8,    0, zeroblobFunc      },
+#ifdef SQLITE_SOUNDEX
+    { "soundex",            1, 0, SQLITE_UTF8,    0, soundexFunc},
+#endif
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+    { "load_extension",     1, 0xff, SQLITE_UTF8, 0, loadExt },
+    { "load_extension",     2, 0xff, SQLITE_UTF8, 0, loadExt },
+#endif
+#ifdef SQLITE_TEST
+    { "randstr",               2, 0,    SQLITE_UTF8, 0, randStr    },
+    { "test_destructor",       1, 0xff, SQLITE_UTF8, 0, test_destructor},
+    { "test_destructor_count", 0, 0,    SQLITE_UTF8, 0, test_destructor_count},
+    { "test_auxdata",         -1, 0,    SQLITE_UTF8, 0, test_auxdata},
+    { "test_error",            1, 0,    SQLITE_UTF8, 0, test_error},
+#endif
+  };
+  static const struct {
+    char *zName;
+    signed char nArg;
+    u8 argType;
+    u8 needCollSeq;
+    void (*xStep)(sqlite3_context*,int,sqlite3_value**);
+    void (*xFinalize)(sqlite3_context*);
+  } aAggs[] = {
+    { "min",    1, 0, 1, minmaxStep,   minMaxFinalize },
+    { "max",    1, 1, 1, minmaxStep,   minMaxFinalize },
+    { "sum",    1, 0, 0, sumStep,      sumFinalize    },
+    { "total",  1, 0, 0, sumStep,      totalFinalize    },
+    { "avg",    1, 0, 0, sumStep,      avgFinalize    },
+    { "count",  0, 0, 0, countStep,    countFinalize  },
+    { "count",  1, 0, 0, countStep,    countFinalize  },
+    { "group_concat", 1, 0, 0, groupConcatStep, groupConcatFinalize },
+    { "group_concat", 2, 0, 0, groupConcatStep, groupConcatFinalize },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
+    void *pArg;
+    u8 argType = aFuncs[i].argType;
+    if( argType==0xff ){
+      pArg = db;
+    }else{
+      pArg = (void*)(int)argType;
+    }
+    sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
+        aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
+    if( aFuncs[i].needCollSeq ){
+      FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, 
+          strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0);
+      if( pFunc && aFuncs[i].needCollSeq ){
+        pFunc->needCollSeq = 1;
+      }
+    }
+  }
+#ifndef SQLITE_OMIT_ALTERTABLE
+  sqlite3AlterFunctions(db);
+#endif
+#ifndef SQLITE_OMIT_PARSER
+  sqlite3AttachFunctions(db);
+#endif
+  for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
+    void *pArg = (void*)(int)aAggs[i].argType;
+    sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, 
+        pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
+    if( aAggs[i].needCollSeq ){
+      FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName,
+          strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0);
+      if( pFunc && aAggs[i].needCollSeq ){
+        pFunc->needCollSeq = 1;
+      }
+    }
+  }
+  sqlite3RegisterDateTimeFunctions(db);
+  if( !db->mallocFailed ){
+    int rc = sqlite3_overload_function(db, "MATCH", 2);
+    assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
+    if( rc==SQLITE_NOMEM ){
+      db->mallocFailed = 1;
+    }
+  }
+#ifdef SQLITE_SSE
+  (void)sqlite3SseFunctions(db);
+#endif
+#ifdef SQLITE_CASE_SENSITIVE_LIKE
+  sqlite3RegisterLikeFunctions(db, 1);
+#else
+  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, int flagVal){
+  FuncDef *pDef;
+  pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0);
+  if( pDef ){
+    pDef->flags = flagVal;
+  }
+}
+
+/*
+** 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;
+  }
+  sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
+  sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
+  sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 
+      (struct compareInfo*)&globInfo, likeFunc, 0,0);
+  setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
+  setLikeOptFlag(db, "like", 
+      caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_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, int *pIsNocase, char *aWc){
+  FuncDef *pDef;
+  if( pExpr->op!=TK_FUNCTION || !pExpr->pList ){
+    return 0;
+  }
+  if( pExpr->pList->nExpr!=2 ){
+    return 0;
+  }
+  pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2,
+                             SQLITE_UTF8, 0);
+  if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==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 );
+  *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0;
+  return 1;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/hash.c b/client/src/thirdparty/sqlite-3.4.2/src/hash.c
new file mode 100644
index 0000000..9a91e85
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/hash.c
@@ -0,0 +1,419 @@
+/*
+** 2001 September 22
+**
+** 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 is the implementation of generic hash-tables
+** used in SQLite.
+**
+** $Id: hash.c,v 1.25 2008/01/22 21:30:53 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <assert.h>
+
+/* Turn bulk memory into a hash table object by initializing the
+** fields of the Hash structure.
+**
+** "pNew" is a pointer to the hash table that is to be initialized.
+** keyClass is one of the constants SQLITE_HASH_INT, SQLITE_HASH_POINTER,
+** SQLITE_HASH_BINARY, or SQLITE_HASH_STRING.  The value of keyClass 
+** determines what kind of key the hash table will use.  "copyKey" is
+** true if the hash table should make its own private copy of keys and
+** false if it should just use the supplied pointer.  CopyKey only makes
+** sense for SQLITE_HASH_STRING and SQLITE_HASH_BINARY and is ignored
+** for other key classes.
+*/
+void sqlite3HashInit(Hash *pNew, int keyClass, int copyKey){
+  assert( pNew!=0 );
+  assert( keyClass>=SQLITE_HASH_STRING && keyClass<=SQLITE_HASH_BINARY );
+  pNew->keyClass = keyClass;
+#if 0
+  if( keyClass==SQLITE_HASH_POINTER || keyClass==SQLITE_HASH_INT ) copyKey = 0;
+#endif
+  pNew->copyKey = copyKey;
+  pNew->first = 0;
+  pNew->count = 0;
+  pNew->htsize = 0;
+  pNew->ht = 0;
+}
+
+/* Remove all entries from a hash table.  Reclaim all memory.
+** Call this routine to delete a hash table or to reset a hash table
+** to the empty state.
+*/
+void sqlite3HashClear(Hash *pH){
+  HashElem *elem;         /* For looping over all elements of the table */
+
+  assert( pH!=0 );
+  elem = pH->first;
+  pH->first = 0;
+  if( pH->ht ) sqlite3_free(pH->ht);
+  pH->ht = 0;
+  pH->htsize = 0;
+  while( elem ){
+    HashElem *next_elem = elem->next;
+    if( pH->copyKey && elem->pKey ){
+      sqlite3_free(elem->pKey);
+    }
+    sqlite3_free(elem);
+    elem = next_elem;
+  }
+  pH->count = 0;
+}
+
+#if 0 /* NOT USED */
+/*
+** Hash and comparison functions when the mode is SQLITE_HASH_INT
+*/
+static int intHash(const void *pKey, int nKey){
+  return nKey ^ (nKey<<8) ^ (nKey>>8);
+}
+static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  return n2 - n1;
+}
+#endif
+
+#if 0 /* NOT USED */
+/*
+** Hash and comparison functions when the mode is SQLITE_HASH_POINTER
+*/
+static int ptrHash(const void *pKey, int nKey){
+  uptr x = Addr(pKey);
+  return x ^ (x<<8) ^ (x>>8);
+}
+static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( pKey1==pKey2 ) return 0;
+  if( pKey1<pKey2 ) return -1;
+  return 1;
+}
+#endif
+
+/*
+** Hash and comparison functions when the mode is SQLITE_HASH_STRING
+*/
+static int strHash(const void *pKey, int nKey){
+  const char *z = (const char *)pKey;
+  int h = 0;
+  if( nKey<=0 ) nKey = strlen(z);
+  while( nKey > 0  ){
+    h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++];
+    nKey--;
+  }
+  return h & 0x7fffffff;
+}
+static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return sqlite3StrNICmp((const char*)pKey1,(const char*)pKey2,n1);
+}
+
+/*
+** Hash and comparison functions when the mode is SQLITE_HASH_BINARY
+*/
+static int binHash(const void *pKey, int nKey){
+  int h = 0;
+  const char *z = (const char *)pKey;
+  while( nKey-- > 0 ){
+    h = (h<<3) ^ h ^ *(z++);
+  }
+  return h & 0x7fffffff;
+}
+static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){
+  if( n1!=n2 ) return 1;
+  return memcmp(pKey1,pKey2,n1);
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** The C syntax in this function definition may be unfamilar to some 
+** programmers, so we provide the following additional explanation:
+**
+** The name of the function is "hashFunction".  The function takes a
+** single parameter "keyClass".  The return value of hashFunction()
+** is a pointer to another function.  Specifically, the return value
+** of hashFunction() is a pointer to a function that takes two parameters
+** with types "const void*" and "int" and returns an "int".
+*/
+static int (*hashFunction(int keyClass))(const void*,int){
+#if 0  /* HASH_INT and HASH_POINTER are never used */
+  switch( keyClass ){
+    case SQLITE_HASH_INT:     return &intHash;
+    case SQLITE_HASH_POINTER: return &ptrHash;
+    case SQLITE_HASH_STRING:  return &strHash;
+    case SQLITE_HASH_BINARY:  return &binHash;;
+    default: break;
+  }
+  return 0;
+#else
+  if( keyClass==SQLITE_HASH_STRING ){
+    return &strHash;
+  }else{
+    assert( keyClass==SQLITE_HASH_BINARY );
+    return &binHash;
+  }
+#endif
+}
+
+/*
+** Return a pointer to the appropriate hash function given the key class.
+**
+** For help in interpreted the obscure C code in the function definition,
+** see the header comment on the previous function.
+*/
+static int (*compareFunction(int keyClass))(const void*,int,const void*,int){
+#if 0 /* HASH_INT and HASH_POINTER are never used */
+  switch( keyClass ){
+    case SQLITE_HASH_INT:     return &intCompare;
+    case SQLITE_HASH_POINTER: return &ptrCompare;
+    case SQLITE_HASH_STRING:  return &strCompare;
+    case SQLITE_HASH_BINARY:  return &binCompare;
+    default: break;
+  }
+  return 0;
+#else
+  if( keyClass==SQLITE_HASH_STRING ){
+    return &strCompare;
+  }else{
+    assert( keyClass==SQLITE_HASH_BINARY );
+    return &binCompare;
+  }
+#endif
+}
+
+/* Link an element into the hash table
+*/
+static void insertElement(
+  Hash *pH,              /* The complete hash table */
+  struct _ht *pEntry,    /* The entry into which pNew is inserted */
+  HashElem *pNew         /* The element to be inserted */
+){
+  HashElem *pHead;       /* First element already in pEntry */
+  pHead = pEntry->chain;
+  if( pHead ){
+    pNew->next = pHead;
+    pNew->prev = pHead->prev;
+    if( pHead->prev ){ pHead->prev->next = pNew; }
+    else             { pH->first = pNew; }
+    pHead->prev = pNew;
+  }else{
+    pNew->next = pH->first;
+    if( pH->first ){ pH->first->prev = pNew; }
+    pNew->prev = 0;
+    pH->first = pNew;
+  }
+  pEntry->count++;
+  pEntry->chain = pNew;
+}
+
+
+/* Resize the hash table so that it cantains "new_size" buckets.
+** "new_size" must be a power of 2.  The hash table might fail 
+** to resize if sqlite3_malloc() fails.
+*/
+static void rehash(Hash *pH, int new_size){
+  struct _ht *new_ht;            /* The new hash table */
+  HashElem *elem, *next_elem;    /* For looping over existing elements */
+  int (*xHash)(const void*,int); /* The hash function */
+
+  assert( (new_size & (new_size-1))==0 );
+
+  /* There is a call to sqlite3_malloc() inside rehash(). If there is
+  ** already an allocation at pH->ht, then if this malloc() fails it
+  ** is benign (since failing to resize a hash table is a performance
+  ** hit only, not a fatal error).
+  */
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, pH->htsize>0);
+  new_ht = (struct _ht *)sqlite3MallocZero( new_size*sizeof(struct _ht) );
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
+
+  if( new_ht==0 ) return;
+  if( pH->ht ) sqlite3_free(pH->ht);
+  pH->ht = new_ht;
+  pH->htsize = new_size;
+  xHash = hashFunction(pH->keyClass);
+  for(elem=pH->first, pH->first=0; elem; elem = next_elem){
+    int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
+    next_elem = elem->next;
+    insertElement(pH, &new_ht[h], elem);
+  }
+}
+
+/* This function (for internal use only) locates an element in an
+** hash table that matches the given key.  The hash for this key has
+** already been computed and is passed as the 4th parameter.
+*/
+static HashElem *findElementGivenHash(
+  const Hash *pH,     /* The pH to be searched */
+  const void *pKey,   /* The key we are searching for */
+  int nKey,
+  int h               /* The hash for this key. */
+){
+  HashElem *elem;                /* Used to loop thru the element list */
+  int count;                     /* Number of elements left to test */
+  int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
+
+  if( pH->ht ){
+    struct _ht *pEntry = &pH->ht[h];
+    elem = pEntry->chain;
+    count = pEntry->count;
+    xCompare = compareFunction(pH->keyClass);
+    while( count-- && elem ){
+      if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
+        return elem;
+      }
+      elem = elem->next;
+    }
+  }
+  return 0;
+}
+
+/* Remove a single entry from the hash table given a pointer to that
+** element and a hash on the element's key.
+*/
+static void removeElementGivenHash(
+  Hash *pH,         /* The pH containing "elem" */
+  HashElem* elem,   /* The element to be removed from the pH */
+  int h             /* Hash value for the element */
+){
+  struct _ht *pEntry;
+  if( elem->prev ){
+    elem->prev->next = elem->next; 
+  }else{
+    pH->first = elem->next;
+  }
+  if( elem->next ){
+    elem->next->prev = elem->prev;
+  }
+  pEntry = &pH->ht[h];
+  if( pEntry->chain==elem ){
+    pEntry->chain = elem->next;
+  }
+  pEntry->count--;
+  if( pEntry->count<=0 ){
+    pEntry->chain = 0;
+  }
+  if( pH->copyKey ){
+    sqlite3_free(elem->pKey);
+  }
+  sqlite3_free( elem );
+  pH->count--;
+  if( pH->count<=0 ){
+    assert( pH->first==0 );
+    assert( pH->count==0 );
+    sqlite3HashClear(pH);
+  }
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return a pointer to the corresponding 
+** HashElem structure for this element if it is found, or NULL
+** otherwise.
+*/
+HashElem *sqlite3HashFindElem(const Hash *pH, const void *pKey, int nKey){
+  int h;             /* A hash on key */
+  HashElem *elem;    /* The element that matches key */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  if( pH==0 || pH->ht==0 ) return 0;
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  h = (*xHash)(pKey,nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem;
+}
+
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *sqlite3HashFind(const Hash *pH, const void *pKey, int nKey){
+  HashElem *elem;    /* The element that matches key */
+  elem = sqlite3HashFindElem(pH, pKey, nKey);
+  return elem ? elem->data : 0;
+}
+
+/* Insert an element into the hash table pH.  The key is pKey,nKey
+** and the data is "data".
+**
+** If no element exists with a matching key, then a new
+** element is created.  A copy of the key is made if the copyKey
+** flag is set.  NULL is returned.
+**
+** If another element already exists with the same key, then the
+** new data replaces the old data and the old data is returned.
+** The key is not copied in this instance.  If a malloc fails, then
+** the new data is returned and the hash table is unchanged.
+**
+** If the "data" parameter to this function is NULL, then the
+** element corresponding to "key" is removed from the hash table.
+*/
+void *sqlite3HashInsert(Hash *pH, const void *pKey, int nKey, void *data){
+  int hraw;             /* Raw hash value of the key */
+  int h;                /* the hash of the key modulo hash table size */
+  HashElem *elem;       /* Used to loop thru the element list */
+  HashElem *new_elem;   /* New element added to the pH */
+  int (*xHash)(const void*,int);  /* The hash function */
+
+  assert( pH!=0 );
+  xHash = hashFunction(pH->keyClass);
+  assert( xHash!=0 );
+  hraw = (*xHash)(pKey, nKey);
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  elem = findElementGivenHash(pH,pKey,nKey,h);
+  if( elem ){
+    void *old_data = elem->data;
+    if( data==0 ){
+      removeElementGivenHash(pH,elem,h);
+    }else{
+      elem->data = data;
+      if( !pH->copyKey ){
+        elem->pKey = (void *)pKey;
+      }
+      assert(nKey==elem->nKey);
+    }
+    return old_data;
+  }
+  if( data==0 ) return 0;
+  new_elem = (HashElem*)sqlite3_malloc( sizeof(HashElem) );
+  if( new_elem==0 ) return data;
+  if( pH->copyKey && pKey!=0 ){
+    new_elem->pKey = sqlite3_malloc( nKey );
+    if( new_elem->pKey==0 ){
+      sqlite3_free(new_elem);
+      return data;
+    }
+    memcpy((void*)new_elem->pKey, pKey, nKey);
+  }else{
+    new_elem->pKey = (void*)pKey;
+  }
+  new_elem->nKey = nKey;
+  pH->count++;
+  if( pH->htsize==0 ){
+    rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      if( pH->copyKey ){
+        sqlite3_free(new_elem->pKey);
+      }
+      sqlite3_free(new_elem);
+      return data;
+    }
+  }
+  if( pH->count > pH->htsize ){
+    rehash(pH,pH->htsize*2);
+  }
+  assert( pH->htsize>0 );
+  assert( (pH->htsize & (pH->htsize-1))==0 );
+  h = hraw & (pH->htsize-1);
+  insertElement(pH, &pH->ht[h], new_elem);
+  new_elem->data = data;
+  return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/hash.h b/client/src/thirdparty/sqlite-3.4.2/src/hash.h
new file mode 100644
index 0000000..e3274e9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/hash.h
@@ -0,0 +1,110 @@
+/*
+** 2001 September 22
+**
+** 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 is the header file for the generic hash-table implemenation
+** used in SQLite.
+**
+** $Id: hash.h,v 1.11 2007/09/04 14:31:47 danielk1977 Exp $
+*/
+#ifndef _SQLITE_HASH_H_
+#define _SQLITE_HASH_H_
+
+/* Forward declarations of structures. */
+typedef struct Hash Hash;
+typedef struct HashElem HashElem;
+
+/* A complete hash table is an instance of the following structure.
+** The internals of this structure are intended to be opaque -- client
+** code should not attempt to access or modify the fields of this structure
+** directly.  Change this structure only by using the routines below.
+** However, many of the "procedures" and "functions" for modifying and
+** accessing this structure are really macros, so we can't really make
+** this structure opaque.
+*/
+struct Hash {
+  char keyClass;          /* SQLITE_HASH_INT, _POINTER, _STRING, _BINARY */
+  char copyKey;           /* True if copy of key made on insert */
+  int count;              /* Number of entries in this table */
+  int htsize;             /* Number of buckets in the hash table */
+  HashElem *first;        /* The first element of the array */
+  struct _ht {            /* the hash table */
+    int count;               /* Number of entries with this hash */
+    HashElem *chain;         /* Pointer to first entry with this hash */
+  } *ht;
+};
+
+/* Each element in the hash table is an instance of the following 
+** structure.  All elements are stored on a single doubly-linked list.
+**
+** Again, this structure is intended to be opaque, but it can't really
+** be opaque because it is used by macros.
+*/
+struct HashElem {
+  HashElem *next, *prev;   /* Next and previous elements in the table */
+  void *data;              /* Data associated with this element */
+  void *pKey; int nKey;    /* Key associated with this element */
+};
+
+/*
+** There are 4 different modes of operation for a hash table:
+**
+**   SQLITE_HASH_INT         nKey is used as the key and pKey is ignored.
+**
+**   SQLITE_HASH_POINTER     pKey is used as the key and nKey is ignored.
+**
+**   SQLITE_HASH_STRING      pKey points to a string that is nKey bytes long
+**                           (including the null-terminator, if any).  Case
+**                           is ignored in comparisons.
+**
+**   SQLITE_HASH_BINARY      pKey points to binary data nKey bytes long. 
+**                           memcmp() is used to compare keys.
+**
+** A copy of the key is made for SQLITE_HASH_STRING and SQLITE_HASH_BINARY
+** if the copyKey parameter to HashInit is 1.  
+*/
+/* #define SQLITE_HASH_INT       1 // NOT USED */
+/* #define SQLITE_HASH_POINTER   2 // NOT USED */
+#define SQLITE_HASH_STRING    3
+#define SQLITE_HASH_BINARY    4
+
+/*
+** Access routines.  To delete, insert a NULL pointer.
+*/
+void sqlite3HashInit(Hash*, int keytype, int copyKey);
+void *sqlite3HashInsert(Hash*, const void *pKey, int nKey, void *pData);
+void *sqlite3HashFind(const Hash*, const void *pKey, int nKey);
+HashElem *sqlite3HashFindElem(const Hash*, const void *pKey, int nKey);
+void sqlite3HashClear(Hash*);
+
+/*
+** Macros for looping over all elements of a hash table.  The idiom is
+** like this:
+**
+**   Hash h;
+**   HashElem *p;
+**   ...
+**   for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){
+**     SomeStructure *pData = sqliteHashData(p);
+**     // do something with pData
+**   }
+*/
+#define sqliteHashFirst(H)  ((H)->first)
+#define sqliteHashNext(E)   ((E)->next)
+#define sqliteHashData(E)   ((E)->data)
+#define sqliteHashKey(E)    ((E)->pKey)
+#define sqliteHashKeysize(E) ((E)->nKey)
+
+/*
+** Number of entries in a hash table
+*/
+#define sqliteHashCount(H)  ((H)->count)
+
+#endif /* _SQLITE_HASH_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/insert.c b/client/src/thirdparty/sqlite-3.4.2/src/insert.c
new file mode 100644
index 0000000..07b069c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/insert.c
@@ -0,0 +1,1663 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains C code routines that are called by the parser
+** to handle INSERT statements in SQLite.
+**
+** $Id: insert.c,v 1.228 2008/01/25 15:04:50 drh Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** Set P4 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:
+**
+**  Character      Column affinity
+**  ------------------------------
+**  'a'            TEXT
+**  'b'            NONE
+**  'c'            NUMERIC
+**  'd'            INTEGER
+**  'e'            REAL
+**
+** An extra 'b' is appended to the end of the string to cover the
+** rowid that appears as the last column in every index.
+*/
+void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
+  if( !pIdx->zColAff ){
+    /* The first time a column affinity string for a particular index is
+    ** required, it is allocated and populated here. It is then stored as
+    ** a member of the Index structure for subsequent use.
+    **
+    ** The column affinity string will eventually be deleted by
+    ** sqliteDeleteIndex() when the Index structure itself is cleaned
+    ** up.
+    */
+    int n;
+    Table *pTab = pIdx->pTable;
+    sqlite3 *db = sqlite3VdbeDb(v);
+    pIdx->zColAff = (char *)sqlite3DbMallocZero(db, pIdx->nColumn+2);
+    if( !pIdx->zColAff ){
+      return;
+    }
+    for(n=0; n<pIdx->nColumn; n++){
+      pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
+    }
+    pIdx->zColAff[n++] = SQLITE_AFF_NONE;
+    pIdx->zColAff[n] = 0;
+  }
+ 
+  sqlite3VdbeChangeP4(v, -1, pIdx->zColAff, 0);
+}
+
+/*
+** Set P4 of the most recently inserted opcode to a column affinity
+** string for table pTab. A column affinity string has one character
+** for each column indexed by the index, according to the affinity of the
+** column:
+**
+**  Character      Column affinity
+**  ------------------------------
+**  'a'            TEXT
+**  'b'            NONE
+**  'c'            NUMERIC
+**  'd'            INTEGER
+**  'e'            REAL
+*/
+void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
+  /* The first time a column affinity string for a particular table
+  ** is required, it is allocated and populated here. It is then 
+  ** stored as a member of the Table structure for subsequent use.
+  **
+  ** The column affinity string will eventually be deleted by
+  ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
+  */
+  if( !pTab->zColAff ){
+    char *zColAff;
+    int i;
+    sqlite3 *db = sqlite3VdbeDb(v);
+
+    zColAff = (char *)sqlite3DbMallocZero(db, pTab->nCol+1);
+    if( !zColAff ){
+      return;
+    }
+
+    for(i=0; i<pTab->nCol; i++){
+      zColAff[i] = pTab->aCol[i].affinity;
+    }
+    zColAff[pTab->nCol] = '\0';
+
+    pTab->zColAff = zColAff;
+  }
+
+  sqlite3VdbeChangeP4(v, -1, pTab->zColAff, 0);
+}
+
+/*
+** Return non-zero if the table pTab in database iDb or any of its indices
+** have been opened at any point in the VDBE program beginning at location
+** iStartAddr throught the end of the program.  This is used to see if 
+** a statement of the form  "INSERT INTO <iDb, pTab> SELECT ..." can 
+** run without using temporary table for the results of the SELECT. 
+*/
+static int readsTable(Vdbe *v, int iStartAddr, int iDb, Table *pTab){
+  int i;
+  int iEnd = sqlite3VdbeCurrentAddr(v);
+  for(i=iStartAddr; i<iEnd; i++){
+    VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
+    assert( pOp!=0 );
+    if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
+      Index *pIndex;
+      int tnum = pOp->p2;
+      if( tnum==pTab->tnum ){
+        return 1;
+      }
+      for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
+        if( tnum==pIndex->tnum ){
+          return 1;
+        }
+      }
+    }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pTab->pVtab ){
+      assert( pOp->p4.pVtab!=0 );
+      assert( pOp->p4type==P4_VTAB );
+      return 1;
+    }
+#endif
+  }
+  return 0;
+}
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+/*
+** Write out code to initialize the autoincrement logic.  This code
+** looks up the current autoincrement value in the sqlite_sequence
+** table and stores that value in a register.  Code generated by
+** autoIncStep() will keep that register holding the largest
+** rowid value.  Code generated by autoIncEnd() will write the new
+** largest value of the counter back into the sqlite_sequence table.
+**
+** This routine returns the index of the mem[] cell that contains
+** the maximum rowid counter.
+**
+** Three consecutive registers are allocated by this routine.  The
+** first two hold the name of the target table and the maximum rowid 
+** inserted into the target table, respectively.
+** The third holds the rowid in sqlite_sequence where we will
+** write back the revised maximum rowid.  This routine returns the
+** index of the second of these three registers.
+*/
+static int autoIncBegin(
+  Parse *pParse,      /* Parsing context */
+  int iDb,            /* Index of the database holding pTab */
+  Table *pTab         /* The table we are writing to */
+){
+  int memId = 0;      /* Register holding maximum rowid */
+  if( pTab->autoInc ){
+    Vdbe *v = pParse->pVdbe;
+    Db *pDb = &pParse->db->aDb[iDb];
+    int iCur = pParse->nTab;
+    int addr;               /* Address of the top of the loop */
+    assert( v );
+    pParse->nMem++;         /* Holds name of table */
+    memId = ++pParse->nMem;
+    pParse->nMem++;
+    sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
+    addr = sqlite3VdbeCurrentAddr(v);
+    sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, pTab->zName, 0);
+    sqlite3VdbeAddOp2(v, OP_Rewind, iCur, addr+8);
+    sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, memId);
+    sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
+    sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
+    sqlite3VdbeAddOp2(v, OP_Rowid, iCur, memId+1);
+    sqlite3VdbeAddOp3(v, OP_Column, iCur, 1, memId);
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+8);
+    sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+2);
+    sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
+  }
+  return memId;
+}
+
+/*
+** Update the maximum rowid for an autoincrement calculation.
+**
+** This routine should be called when the top of the stack holds a
+** new rowid that is about to be inserted.  If that new rowid is
+** larger than the maximum rowid in the memId memory cell, then the
+** memory cell is updated.  The stack is unchanged.
+*/
+static void autoIncStep(Parse *pParse, int memId, int regRowid){
+  if( memId>0 ){
+    sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
+  }
+}
+
+/*
+** After doing one or more inserts, the maximum rowid is stored
+** in reg[memId].  Generate code to write this value back into the
+** the sqlite_sequence table.
+*/
+static void autoIncEnd(
+  Parse *pParse,     /* The parsing context */
+  int iDb,           /* Index of the database holding pTab */
+  Table *pTab,       /* Table we are inserting into */
+  int memId          /* Memory cell holding the maximum rowid */
+){
+  if( pTab->autoInc ){
+    int iCur = pParse->nTab;
+    Vdbe *v = pParse->pVdbe;
+    Db *pDb = &pParse->db->aDb[iDb];
+    int j1;
+
+    assert( v );
+    sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
+    j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
+    sqlite3VdbeAddOp2(v, OP_NewRowid, iCur, memId+1);
+    sqlite3VdbeJumpHere(v, j1);
+    sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, memId-1);
+    sqlite3VdbeAddOp3(v, OP_Insert, iCur, memId-1, memId+1);
+    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
+    sqlite3VdbeAddOp1(v, OP_Close, iCur);
+  }
+}
+#else
+/*
+** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
+** above are all no-ops
+*/
+# define autoIncBegin(A,B,C) (0)
+# define autoIncStep(A,B,C)
+# define autoIncEnd(A,B,C,D)
+#endif /* SQLITE_OMIT_AUTOINCREMENT */
+
+
+/* Forward declaration */
+static int xferOptimization(
+  Parse *pParse,        /* Parser context */
+  Table *pDest,         /* The table we are inserting into */
+  Select *pSelect,      /* A SELECT statement to use as the data source */
+  int onError,          /* How to handle constraint errors */
+  int iDbDest           /* The database of pDest */
+);
+
+/*
+** This routine is call to handle SQL of the following forms:
+**
+**    insert into TABLE (IDLIST) values(EXPRLIST)
+**    insert into TABLE (IDLIST) select
+**
+** The IDLIST following the table name is always optional.  If omitted,
+** then a list of all columns for the table is substituted.  The IDLIST
+** appears in the pColumn parameter.  pColumn is NULL if IDLIST is omitted.
+**
+** The pList parameter holds EXPRLIST in the first form of the INSERT
+** statement above, and pSelect is NULL.  For the second form, pList is
+** NULL and pSelect is a pointer to the select statement used to generate
+** data for the insert.
+**
+** The code generated follows one of four templates.  For a simple
+** select with data coming from a VALUES clause, the code executes
+** once straight down through.  The template looks like this:
+**
+**         open write cursor to <table> and its indices
+**         puts VALUES clause expressions onto the stack
+**         write the resulting record into <table>
+**         cleanup
+**
+** The three remaining templates assume the statement is of the form
+**
+**   INSERT INTO <table> SELECT ...
+**
+** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
+** in other words if the SELECT pulls all columns from a single table
+** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
+** if <table2> and <table1> are distinct tables but have identical
+** schemas, including all the same indices, then a special optimization
+** is invoked that copies raw records from <table2> over to <table1>.
+** See the xferOptimization() function for the implementation of this
+** template.  This is the second template.
+**
+**         open a write cursor to <table>
+**         open read cursor on <table2>
+**         transfer all records in <table2> over to <table>
+**         close cursors
+**         foreach index on <table>
+**           open a write cursor on the <table> index
+**           open a read cursor on the corresponding <table2> index
+**           transfer all records from the read to the write cursors
+**           close cursors
+**         end foreach
+**
+** The third template is for when the second template does not apply
+** and the SELECT clause does not read from <table> at any time.
+** The generated code follows this template:
+**
+**         goto B
+**      A: setup for the SELECT
+**         loop over the rows in the SELECT
+**           gosub C
+**         end loop
+**         cleanup after the SELECT
+**         goto D
+**      B: open write cursor to <table> and its indices
+**         goto A
+**      C: insert the select result into <table>
+**         return
+**      D: cleanup
+**
+** The fourth template is used if the insert statement takes its
+** values from a SELECT but the data is being inserted into a table
+** that is also read as part of the SELECT.  In the third form,
+** we have to use a intermediate table to store the results of
+** the select.  The template is like this:
+**
+**         goto B
+**      A: setup for the SELECT
+**         loop over the tables in the SELECT
+**           gosub C
+**         end loop
+**         cleanup after the SELECT
+**         goto D
+**      C: insert the select result into the intermediate table
+**         return
+**      B: open a cursor to an intermediate table
+**         goto A
+**      D: open write cursor to <table> and its indices
+**         loop over the intermediate table
+**           transfer values form intermediate table into <table>
+**         end the loop
+**         cleanup
+*/
+void sqlite3Insert(
+  Parse *pParse,        /* Parser context */
+  SrcList *pTabList,    /* Name of table into which we are inserting */
+  ExprList *pList,      /* List of values to be inserted */
+  Select *pSelect,      /* A SELECT statement to use as the data source */
+  IdList *pColumn,      /* Column names corresponding to IDLIST. */
+  int onError           /* How to handle constraint errors */
+){
+  sqlite3 *db;          /* The main database structure */
+  Table *pTab;          /* The table to insert into.  aka TABLE */
+  char *zTab;           /* Name of the table into which we are inserting */
+  const char *zDb;      /* Name of the database holding this table */
+  int i, j, idx;        /* Loop counters */
+  Vdbe *v;              /* Generate code into this virtual machine */
+  Index *pIdx;          /* For looping over indices of the table */
+  int nColumn;          /* Number of columns in the data */
+  int nHidden = 0;      /* Number of hidden columns if TABLE is virtual */
+  int baseCur = 0;      /* VDBE Cursor number for pTab */
+  int keyColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
+  int endOfLoop;        /* Label for the end of the insertion loop */
+  int useTempTable = 0; /* Store SELECT results in intermediate table */
+  int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
+  int iCont=0,iBreak=0; /* Beginning and end of the loop over srcTab */
+  int iSelectLoop = 0;  /* Address of code that implements the SELECT */
+  int iCleanup = 0;     /* Address of the cleanup code */
+  int iInsertBlock = 0; /* Address of the subroutine used to insert data */
+  int newIdx = -1;      /* Cursor for the NEW pseudo-table */
+  int iDb;              /* Index of database holding TABLE */
+  Db *pDb;              /* The database containing table being inserted into */
+  int appendFlag = 0;   /* True if the insert is likely to be an append */
+
+  /* Register allocations */
+  int regFromSelect;    /* Base register for data coming from SELECT */
+  int regAutoinc = 0;   /* Register holding the AUTOINCREMENT counter */
+  int regRowCount = 0;  /* Memory cell used for the row counter */
+  int regIns;           /* Block of regs holding rowid+data being inserted */
+  int regRowid;         /* registers holding insert rowid */
+  int regData;          /* register holding first column to insert */
+  int regRecord;        /* Holds the assemblied row record */
+  int *aRegIdx = 0;     /* One register allocated to each index */
+
+
+#ifndef SQLITE_OMIT_TRIGGER
+  int isView;                 /* True if attempting to insert into a view */
+  int triggers_exist = 0;     /* True if there are FOR EACH ROW triggers */
+#endif
+
+  db = pParse->db;
+  if( pParse->nErr || db->mallocFailed ){
+    goto insert_cleanup;
+  }
+
+  /* Locate the table into which we will be inserting new information.
+  */
+  assert( pTabList->nSrc==1 );
+  zTab = pTabList->a[0].zName;
+  if( zTab==0 ) goto insert_cleanup;
+  pTab = sqlite3SrcListLookup(pParse, pTabList);
+  if( pTab==0 ){
+    goto insert_cleanup;
+  }
+  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+  assert( iDb<db->nDb );
+  pDb = &db->aDb[iDb];
+  zDb = pDb->zName;
+  if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
+    goto insert_cleanup;
+  }
+
+  /* Figure out if we have any triggers and if the table being
+  ** inserted into is a view
+  */
+#ifndef SQLITE_OMIT_TRIGGER
+  triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0);
+  isView = pTab->pSelect!=0;
+#else
+# define triggers_exist 0
+# define isView 0
+#endif
+#ifdef SQLITE_OMIT_VIEW
+# undef isView
+# define isView 0
+#endif
+
+  /* Ensure that:
+  *  (a) the table is not read-only, 
+  *  (b) that if it is a view then ON INSERT triggers exist
+  */
+  if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
+    goto insert_cleanup;
+  }
+  assert( pTab!=0 );
+
+  /* If pTab is really a view, make sure it has been initialized.
+  ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual 
+  ** module table).
+  */
+  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
+    goto insert_cleanup;
+  }
+
+  /* Allocate a VDBE
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ) goto insert_cleanup;
+  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
+  sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, iDb);
+
+  /* if there are row triggers, allocate a temp table for new.* references. */
+  if( triggers_exist ){
+    newIdx = pParse->nTab++;
+  }
+
+#ifndef SQLITE_OMIT_XFER_OPT
+  /* If the statement is of the form
+  **
+  **       INSERT INTO <table1> SELECT * FROM <table2>;
+  **
+  ** Then special optimizations can be applied that make the transfer
+  ** very fast and which reduce fragmentation of indices.
+  */
+  if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
+    assert( !triggers_exist );
+    assert( pList==0 );
+    goto insert_cleanup;
+  }
+#endif /* SQLITE_OMIT_XFER_OPT */
+
+  /* If this is an AUTOINCREMENT table, look up the sequence number in the
+  ** sqlite_sequence table and store it in memory cell regAutoinc.
+  */
+  regAutoinc = autoIncBegin(pParse, iDb, pTab);
+
+  /* Figure out how many columns of data are supplied.  If the data
+  ** is coming from a SELECT statement, then this step also generates
+  ** all the code to implement the SELECT statement and invoke a subroutine
+  ** to process each row of the result. (Template 2.) If the SELECT
+  ** statement uses the the table that is being inserted into, then the
+  ** subroutine is also coded here.  That subroutine stores the SELECT
+  ** results in a temporary table. (Template 3.)
+  */
+  if( pSelect ){
+    /* Data is coming from a SELECT.  Generate code to implement that SELECT
+    */
+    SelectDest dest;
+    int rc, iInitCode;
+
+    iInitCode = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
+    iSelectLoop = sqlite3VdbeCurrentAddr(v);
+    iInsertBlock = sqlite3VdbeMakeLabel(v);
+    sqlite3SelectDestInit(&dest, SRT_Subroutine, iInsertBlock);
+
+    /* Resolve the expressions in the SELECT statement and execute it. */
+    rc = sqlite3Select(pParse, pSelect, &dest, 0, 0, 0, 0);
+    if( rc || pParse->nErr || db->mallocFailed ){
+      goto insert_cleanup;
+    }
+
+    regFromSelect = dest.iMem;
+    iCleanup = sqlite3VdbeMakeLabel(v);
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, iCleanup);
+    assert( pSelect->pEList );
+    nColumn = pSelect->pEList->nExpr;
+
+    /* Set useTempTable to TRUE if the result of the SELECT statement
+    ** should be written into a temporary table.  Set to FALSE if each
+    ** row of the SELECT can be written directly into the result table.
+    **
+    ** A temp table must be used if the table being updated is also one
+    ** of the tables being read by the SELECT statement.  Also use a 
+    ** temp table in the case of row triggers.
+    */
+    if( triggers_exist || readsTable(v, iSelectLoop, iDb, pTab) ){
+      useTempTable = 1;
+    }
+
+    if( useTempTable ){
+      /* Generate the subroutine that SELECT calls to process each row of
+      ** the result.  Store the result in a temporary table
+      */
+      int regRec, regRowid;
+
+      srcTab = pParse->nTab++;
+      regRec = sqlite3GetTempReg(pParse);
+      regRowid = sqlite3GetTempReg(pParse);
+      sqlite3VdbeResolveLabel(v, iInsertBlock);
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
+      sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regRowid);
+      sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regRowid);
+      sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+      sqlite3ReleaseTempReg(pParse, regRec);
+      sqlite3ReleaseTempReg(pParse, regRowid);
+
+      /* 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.
+      */
+      sqlite3VdbeJumpHere(v, iInitCode);
+      sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, 0);
+      sqlite3VdbeAddOp2(v, OP_SetNumColumns, srcTab, nColumn);
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, iSelectLoop);
+      sqlite3VdbeResolveLabel(v, iCleanup);
+    }else{
+      sqlite3VdbeJumpHere(v, iInitCode);
+    }
+  }else{
+    /* This is the case if the data for the INSERT is coming from a VALUES
+    ** clause
+    */
+    NameContext sNC;
+    memset(&sNC, 0, sizeof(sNC));
+    sNC.pParse = pParse;
+    srcTab = -1;
+    assert( useTempTable==0 );
+    nColumn = pList ? pList->nExpr : 0;
+    for(i=0; i<nColumn; i++){
+      if( sqlite3ExprResolveNames(&sNC, pList->a[i].pExpr) ){
+        goto insert_cleanup;
+      }
+    }
+  }
+
+  /* Make sure the number of columns in the source data matches the number
+  ** of columns to be inserted into the table.
+  */
+  if( IsVirtual(pTab) ){
+    for(i=0; i<pTab->nCol; i++){
+      nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
+    }
+  }
+  if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
+    sqlite3ErrorMsg(pParse, 
+       "table %S has %d columns but %d values were supplied",
+       pTabList, 0, pTab->nCol, nColumn);
+    goto insert_cleanup;
+  }
+  if( pColumn!=0 && nColumn!=pColumn->nId ){
+    sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
+    goto insert_cleanup;
+  }
+
+  /* If the INSERT statement included an IDLIST term, then make sure
+  ** all elements of the IDLIST really are columns of the table and 
+  ** remember the column indices.
+  **
+  ** If the table has an INTEGER PRIMARY KEY column and that column
+  ** is named in the IDLIST, then record in the keyColumn variable
+  ** the index into IDLIST of the primary key column.  keyColumn is
+  ** the index of the primary key as it appears in IDLIST, not as
+  ** is appears in the original table.  (The index of the primary
+  ** key in the original table is pTab->iPKey.)
+  */
+  if( pColumn ){
+    for(i=0; i<pColumn->nId; i++){
+      pColumn->a[i].idx = -1;
+    }
+    for(i=0; i<pColumn->nId; i++){
+      for(j=0; j<pTab->nCol; j++){
+        if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
+          pColumn->a[i].idx = j;
+          if( j==pTab->iPKey ){
+            keyColumn = i;
+          }
+          break;
+        }
+      }
+      if( j>=pTab->nCol ){
+        if( sqlite3IsRowid(pColumn->a[i].zName) ){
+          keyColumn = i;
+        }else{
+          sqlite3ErrorMsg(pParse, "table %S has no column named %s",
+              pTabList, 0, pColumn->a[i].zName);
+          pParse->nErr++;
+          goto insert_cleanup;
+        }
+      }
+    }
+  }
+
+  /* If there is no IDLIST term but the table has an integer primary
+  ** key, the set the keyColumn variable to the primary key column index
+  ** in the original table definition.
+  */
+  if( pColumn==0 && nColumn>0 ){
+    keyColumn = pTab->iPKey;
+  }
+
+  /* Open the temp table for FOR EACH ROW triggers
+  */
+  if( triggers_exist ){
+    sqlite3VdbeAddOp2(v, OP_OpenPseudo, newIdx, 0);
+    sqlite3VdbeAddOp2(v, OP_SetNumColumns, newIdx, pTab->nCol);
+  }
+    
+  /* Initialize the count of rows to be inserted
+  */
+  if( db->flags & SQLITE_CountRows ){
+    regRowCount = ++pParse->nMem;
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
+  }
+
+  /* If this is not a view, open the table and and all indices */
+  if( !isView ){
+    int nIdx;
+    int i;
+
+    baseCur = pParse->nTab;
+    nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
+    aRegIdx = sqlite3DbMallocZero(db, sizeof(int)*(nIdx+1));
+    if( aRegIdx==0 ){
+      goto insert_cleanup;
+    }
+    for(i=0; i<nIdx; i++){
+      aRegIdx[i] = ++pParse->nMem;
+    }
+  }
+
+  /* If the data source is a temporary table, then we have to create
+  ** a loop because there might be multiple rows of data.  If the data
+  ** source is a subroutine call from the SELECT statement, then we need
+  ** to launch the SELECT statement processing.
+  */
+  if( useTempTable ){
+    iBreak = sqlite3VdbeMakeLabel(v);
+    sqlite3VdbeAddOp2(v, OP_Rewind, srcTab, iBreak);
+    iCont = sqlite3VdbeCurrentAddr(v);
+  }else if( pSelect ){
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, iSelectLoop);
+    sqlite3VdbeResolveLabel(v, iInsertBlock);
+  }
+
+  /* Allocate registers for holding the rowid of the new row,
+  ** the content of the new row, and the assemblied row record.
+  */
+  regRecord = ++pParse->nMem;
+  regRowid = regIns = pParse->nMem+1;
+  pParse->nMem += pTab->nCol + 1;
+  if( IsVirtual(pTab) ){
+    regRowid++;
+    pParse->nMem++;
+  }
+  regData = regRowid+1;
+
+  /* Run the BEFORE and INSTEAD OF triggers, if there are any
+  */
+  endOfLoop = sqlite3VdbeMakeLabel(v);
+  if( triggers_exist & TRIGGER_BEFORE ){
+    int regRowid;
+    int regCols;
+    int regRec;
+
+    /* build the NEW.* reference row.  Note that if there is an INTEGER
+    ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
+    ** translated into a unique ID for the row.  But on a BEFORE trigger,
+    ** we do not know what the unique ID will be (because the insert has
+    ** not happened yet) so we substitute a rowid of -1
+    */
+    regRowid = sqlite3GetTempReg(pParse);
+    if( keyColumn<0 ){
+      sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
+    }else if( useTempTable ){
+      sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
+    }else{
+      int j1;
+      assert( pSelect==0 );  /* Otherwise useTempTable is true */
+      sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
+      j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
+      sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
+      sqlite3VdbeJumpHere(v, j1);
+      sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
+    }
+
+    /* Cannot have triggers on a virtual table. If it were possible,
+    ** this block would have to account for hidden column.
+    */
+    assert(!IsVirtual(pTab));
+
+    /* Create the new column data
+    */
+    regCols = sqlite3GetTempRange(pParse, pTab->nCol);
+    for(i=0; i<pTab->nCol; i++){
+      if( pColumn==0 ){
+        j = i;
+      }else{
+        for(j=0; j<pColumn->nId; j++){
+          if( pColumn->a[j].idx==i ) break;
+        }
+      }
+      if( pColumn && j>=pColumn->nId ){
+        sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i);
+      }else if( useTempTable ){
+        sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i); 
+      }else{
+        assert( pSelect==0 ); /* Otherwise useTempTable is true */
+        sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i);
+      }
+    }
+    regRec = sqlite3GetTempReg(pParse);
+    sqlite3VdbeAddOp3(v, OP_MakeRecord, regCols, pTab->nCol, regRec);
+
+    /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
+    ** do not attempt any conversions before assembling the record.
+    ** If this is a real table, attempt conversions as required by the
+    ** table column affinities.
+    */
+    if( !isView ){
+      sqlite3TableAffinityStr(v, pTab);
+    }
+    sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRec, regRowid);
+    sqlite3ReleaseTempReg(pParse, regRec);
+    sqlite3ReleaseTempReg(pParse, regRowid);
+    sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol);
+
+    /* Fire BEFORE or INSTEAD OF triggers */
+    if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab, 
+        newIdx, -1, onError, endOfLoop, 0, 0) ){
+      goto insert_cleanup;
+    }
+  }
+
+  /* Push the record number for the new entry onto the stack.  The
+  ** record number is a randomly generate integer created by NewRowid
+  ** except when the table has an INTEGER PRIMARY KEY column, in which
+  ** case the record number is the same as that column. 
+  */
+  if( !isView ){
+    if( IsVirtual(pTab) ){
+      /* The row that the VUpdate opcode will delete: none */
+      sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
+    }
+    if( keyColumn>=0 ){
+      if( useTempTable ){
+        sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
+      }else if( pSelect ){
+        sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
+      }else{
+        VdbeOp *pOp;
+        sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
+        pOp = sqlite3VdbeGetOp(v, sqlite3VdbeCurrentAddr(v) - 1);
+        if( pOp && pOp->opcode==OP_Null ){
+          appendFlag = 1;
+          pOp->opcode = OP_NewRowid;
+          pOp->p1 = baseCur;
+          pOp->p2 = regRowid;
+          pOp->p3 = regAutoinc;
+        }
+      }
+      /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
+      ** to generate a unique primary key value.
+      */
+      if( !appendFlag ){
+        int j1;
+        j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
+        sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
+        sqlite3VdbeJumpHere(v, j1);
+        sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
+      }
+    }else if( IsVirtual(pTab) ){
+      sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
+    }else{
+      sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
+      appendFlag = 1;
+    }
+    autoIncStep(pParse, regAutoinc, regRowid);
+
+    /* Push onto the stack, data for all columns of the new entry, beginning
+    ** with the first column.
+    */
+    nHidden = 0;
+    for(i=0; i<pTab->nCol; i++){
+      int iRegStore = regRowid+1+i;
+      if( i==pTab->iPKey ){
+        /* The value of the INTEGER PRIMARY KEY column is always a NULL.
+        ** Whenever this column is read, the record number will be substituted
+        ** in its place.  So will fill this column with a NULL to avoid
+        ** taking up data space with information that will never be used. */
+        sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);
+        continue;
+      }
+      if( pColumn==0 ){
+        if( IsHiddenColumn(&pTab->aCol[i]) ){
+          assert( IsVirtual(pTab) );
+          j = -1;
+          nHidden++;
+        }else{
+          j = i - nHidden;
+        }
+      }else{
+        for(j=0; j<pColumn->nId; j++){
+          if( pColumn->a[j].idx==i ) break;
+        }
+      }
+      if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
+        sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
+      }else if( useTempTable ){
+        sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore); 
+      }else if( pSelect ){
+        sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
+      }else{
+        sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
+      }
+    }
+
+    /* Generate code to check constraints and generate index keys and
+    ** do the insertion.
+    */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( IsVirtual(pTab) ){
+      pParse->pVirtualLock = pTab;
+      sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns,
+                     (const char*)pTab->pVtab, P4_VTAB);
+    }else
+#endif
+    {
+      sqlite3GenerateConstraintChecks(
+          pParse,
+          pTab,
+          baseCur,
+          regIns,
+          aRegIdx,
+          keyColumn>=0,
+          0,
+          onError,
+          endOfLoop
+      );
+      sqlite3CompleteInsertion(
+          pParse,
+          pTab,
+          baseCur,
+          regIns,
+          aRegIdx,
+          0,
+          0,
+          (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1,
+          appendFlag
+       );
+    }
+  }
+
+  /* Update the count of rows that are inserted
+  */
+  if( (db->flags & SQLITE_CountRows)!=0 ){
+    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
+  }
+
+  if( triggers_exist ){
+    /* Code AFTER triggers */
+    if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_AFTER, pTab,
+          newIdx, -1, onError, endOfLoop, 0, 0) ){
+      goto insert_cleanup;
+    }
+  }
+
+  /* The bottom of the loop, if the data source is a SELECT statement
+  */
+  sqlite3VdbeResolveLabel(v, endOfLoop);
+  if( useTempTable ){
+    sqlite3VdbeAddOp2(v, OP_Next, srcTab, iCont);
+    sqlite3VdbeResolveLabel(v, iBreak);
+    sqlite3VdbeAddOp2(v, OP_Close, srcTab, 0);
+  }else if( pSelect ){
+    sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+    sqlite3VdbeResolveLabel(v, iCleanup);
+  }
+
+  if( !IsVirtual(pTab) && !isView ){
+    /* Close all tables opened */
+    sqlite3VdbeAddOp2(v, OP_Close, baseCur, 0);
+    for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
+      sqlite3VdbeAddOp2(v, OP_Close, idx+baseCur, 0);
+    }
+  }
+
+  /* Update the sqlite_sequence table by storing the content of the
+  ** counter value in memory regAutoinc back into the sqlite_sequence
+  ** table.
+  */
+  autoIncEnd(pParse, iDb, pTab, regAutoinc);
+
+  /*
+  ** Return the number of rows inserted. If this routine is 
+  ** generating code because of a call to sqlite3NestedParse(), do not
+  ** invoke the callback function.
+  */
+  if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){
+    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", P4_STATIC);
+  }
+
+insert_cleanup:
+  sqlite3SrcListDelete(pTabList);
+  sqlite3ExprListDelete(pList);
+  sqlite3SelectDelete(pSelect);
+  sqlite3IdListDelete(pColumn);
+  sqlite3_free(aRegIdx);
+}
+
+/*
+** Generate code to do constraint checks prior to an INSERT or an UPDATE.
+**
+** The input is a range of consecutive registers as follows:
+**
+**    1.  The rowid of the row to be updated before the update.  This
+**        value is omitted unless we are doing an UPDATE that involves a
+**        change to the record number or writing to a virtual table.
+**
+**    2.  The rowid of the row after the update.
+**
+**    3.  The data in the first column of the entry after the update.
+**
+**    i.  Data from middle columns...
+**
+**    N.  The data in the last column of the entry after the update.
+**
+** The regRowid parameter is the index of the register containing (2).
+**
+** The old rowid shown as entry (1) above is omitted unless both isUpdate
+** and rowidChng are 1.  isUpdate is true for UPDATEs and false for
+** INSERTs.  RowidChng means that the new rowid is explicitly specified by
+** the update or insert statement.  If rowidChng is false, it means that
+** the rowid is computed automatically in an insert or that the rowid value
+** is not modified by the update.
+**
+** The code generated by this routine store new index entries into
+** registers identified by aRegIdx[].  No index entry is created for
+** indices where aRegIdx[i]==0.  The order of indices in aRegIdx[] is
+** the same as the order of indices on the linked list of indices
+** attached to the table.
+**
+** This routine also generates code to check constraints.  NOT NULL,
+** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
+** then the appropriate action is performed.  There are five possible
+** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
+**
+**  Constraint type  Action       What Happens
+**  ---------------  ----------   ----------------------------------------
+**  any              ROLLBACK     The current transaction is rolled back and
+**                                sqlite3_exec() returns immediately with a
+**                                return code of SQLITE_CONSTRAINT.
+**
+**  any              ABORT        Back out changes from the current command
+**                                only (do not do a complete rollback) then
+**                                cause sqlite3_exec() to return immediately
+**                                with SQLITE_CONSTRAINT.
+**
+**  any              FAIL         Sqlite_exec() returns immediately with a
+**                                return code of SQLITE_CONSTRAINT.  The
+**                                transaction is not rolled back and any
+**                                prior changes are retained.
+**
+**  any              IGNORE       The record number and data is popped from
+**                                the stack and there is an immediate jump
+**                                to label ignoreDest.
+**
+**  NOT NULL         REPLACE      The NULL value is replace by the default
+**                                value for that column.  If the default value
+**                                is NULL, the action is the same as ABORT.
+**
+**  UNIQUE           REPLACE      The other row that conflicts with the row
+**                                being inserted is removed.
+**
+**  CHECK            REPLACE      Illegal.  The results in an exception.
+**
+** Which action to take is determined by the overrideError parameter.
+** Or if overrideError==OE_Default, then the pParse->onError parameter
+** is used.  Or if pParse->onError==OE_Default then the onError value
+** for the constraint is used.
+**
+** The calling routine must open a read/write cursor for pTab with
+** cursor number "baseCur".  All indices of pTab must also have open
+** read/write cursors with cursor number baseCur+i for the i-th cursor.
+** Except, if there is no possibility of a REPLACE action then
+** cursors do not need to be open for indices where aRegIdx[i]==0.
+*/
+void sqlite3GenerateConstraintChecks(
+  Parse *pParse,      /* The parser context */
+  Table *pTab,        /* the table into which we are inserting */
+  int baseCur,        /* Index of a read/write cursor pointing at pTab */
+  int regRowid,       /* Index of the range of input registers */
+  int *aRegIdx,       /* Register used by each index.  0 for unused indices */
+  int rowidChng,      /* True if the rowid might collide with existing entry */
+  int isUpdate,       /* True for UPDATE, False for INSERT */
+  int overrideError,  /* Override onError to this if not OE_Default */
+  int ignoreDest      /* Jump to this label on an OE_Ignore resolution */
+){
+  int i;
+  Vdbe *v;
+  int nCol;
+  int onError;
+  int j1, j2, j3;     /* Addresses of jump instructions */
+  int regData;        /* Register containing first data column */
+  int iCur;
+  Index *pIdx;
+  int seenReplace = 0;
+  int hasTwoRowids = (isUpdate && rowidChng);
+
+  v = sqlite3GetVdbe(pParse);
+  assert( v!=0 );
+  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
+  nCol = pTab->nCol;
+  regData = regRowid + 1;
+
+
+  /* Test all NOT NULL constraints.
+  */
+  for(i=0; i<nCol; i++){
+    if( i==pTab->iPKey ){
+      continue;
+    }
+    onError = pTab->aCol[i].notNull;
+    if( onError==OE_None ) continue;
+    if( overrideError!=OE_Default ){
+      onError = overrideError;
+    }else if( onError==OE_Default ){
+      onError = OE_Abort;
+    }
+    if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
+      onError = OE_Abort;
+    }
+    j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regData+i);
+    assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
+        || onError==OE_Ignore || onError==OE_Replace );
+    switch( onError ){
+      case OE_Rollback:
+      case OE_Abort:
+      case OE_Fail: {
+        char *zMsg = 0;
+        sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_CONSTRAINT, onError);
+        sqlite3SetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName,
+                        " may not be NULL", (char*)0);
+        sqlite3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
+        break;
+      }
+      case OE_Ignore: {
+        sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
+        break;
+      }
+      case OE_Replace: {
+        sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
+        break;
+      }
+    }
+    sqlite3VdbeJumpHere(v, j1);
+  }
+
+  /* Test all CHECK constraints
+  */
+#ifndef SQLITE_OMIT_CHECK
+  if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
+    int allOk = sqlite3VdbeMakeLabel(v);
+    pParse->ckBase = regData;
+    sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
+    onError = overrideError!=OE_Default ? overrideError : OE_Abort;
+    if( onError==OE_Ignore ){
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
+    }else{
+      sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_CONSTRAINT, onError);
+    }
+    sqlite3VdbeResolveLabel(v, allOk);
+  }
+#endif /* !defined(SQLITE_OMIT_CHECK) */
+
+  /* If we have an INTEGER PRIMARY KEY, make sure the primary key
+  ** of the new record does not previously exist.  Except, if this
+  ** is an UPDATE and the primary key is not changing, that is OK.
+  */
+  if( rowidChng ){
+    onError = pTab->keyConf;
+    if( overrideError!=OE_Default ){
+      onError = overrideError;
+    }else if( onError==OE_Default ){
+      onError = OE_Abort;
+    }
+    
+    if( onError!=OE_Replace || pTab->pIndex ){
+      if( isUpdate ){
+        j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, regRowid-1);
+      }
+      j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
+      switch( onError ){
+        default: {
+          onError = OE_Abort;
+          /* Fall thru into the next case */
+        }
+        case OE_Rollback:
+        case OE_Abort:
+        case OE_Fail: {
+          sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0,
+                           "PRIMARY KEY must be unique", P4_STATIC);
+          break;
+        }
+        case OE_Replace: {
+          sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
+          seenReplace = 1;
+          break;
+        }
+        case OE_Ignore: {
+          assert( seenReplace==0 );
+          sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
+          break;
+        }
+      }
+      sqlite3VdbeJumpHere(v, j3);
+      if( isUpdate ){
+        sqlite3VdbeJumpHere(v, j2);
+      }
+    }
+  }
+
+  /* Test all UNIQUE constraints by creating entries for each UNIQUE
+  ** index and making sure that duplicate entries do not already exist.
+  ** Add the new records to the indices as we go.
+  */
+  for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
+    int regIdx;
+    int regR;
+
+    if( aRegIdx[iCur]==0 ) continue;  /* Skip unused indices */
+
+    /* Create a key for accessing the index entry */
+    regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
+    for(i=0; i<pIdx->nColumn; i++){
+      int idx = pIdx->aiColumn[i];
+      if( idx==pTab->iPKey ){
+        sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
+      }
+    }
+    sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
+    sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
+    sqlite3IndexAffinityStr(v, pIdx);
+    sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
+
+    /* Find out what action to take in case there is an indexing conflict */
+    onError = pIdx->onError;
+    if( onError==OE_None ) continue;  /* pIdx is not a UNIQUE index */
+    if( overrideError!=OE_Default ){
+      onError = overrideError;
+    }else if( onError==OE_Default ){
+      onError = OE_Abort;
+    }
+    if( seenReplace ){
+      if( onError==OE_Ignore ) onError = OE_Replace;
+      else if( onError==OE_Fail ) onError = OE_Abort;
+    }
+    
+
+    /* Check to see if the new index entry will be unique */
+    j2 = sqlite3VdbeAddOp3(v, OP_IsNull, regIdx, 0, pIdx->nColumn);
+    regR = sqlite3GetTempReg(pParse);
+    sqlite3VdbeAddOp2(v, OP_SCopy, regRowid-hasTwoRowids, regR);
+    j3 = sqlite3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
+                           regR, (char*)aRegIdx[iCur], P4_INT32);
+
+    /* Generate code that executes if the new index entry is not unique */
+    assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
+        || onError==OE_Ignore || onError==OE_Replace );
+    switch( onError ){
+      case OE_Rollback:
+      case OE_Abort:
+      case OE_Fail: {
+        int j, n1, n2;
+        char zErrMsg[200];
+        sqlite3_snprintf(sizeof(zErrMsg), zErrMsg,
+                         pIdx->nColumn>1 ? "columns " : "column ");
+        n1 = strlen(zErrMsg);
+        for(j=0; j<pIdx->nColumn && n1<sizeof(zErrMsg)-30; j++){
+          char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
+          n2 = strlen(zCol);
+          if( j>0 ){
+            sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], ", ");
+            n1 += 2;
+          }
+          if( n1+n2>sizeof(zErrMsg)-30 ){
+            sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "...");
+            n1 += 3;
+            break;
+          }else{
+            sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "%s", zCol);
+            n1 += n2;
+          }
+        }
+        sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], 
+            pIdx->nColumn>1 ? " are not unique" : " is not unique");
+        sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0, zErrMsg,0);
+        break;
+      }
+      case OE_Ignore: {
+        assert( seenReplace==0 );
+        sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
+        break;
+      }
+      case OE_Replace: {
+        sqlite3GenerateRowDelete(pParse, pTab, baseCur, regR, 0);
+        seenReplace = 1;
+        break;
+      }
+    }
+    sqlite3VdbeJumpHere(v, j2);
+    sqlite3VdbeJumpHere(v, j3);
+    sqlite3ReleaseTempReg(pParse, regR);
+  }
+}
+
+/*
+** This routine generates code to finish the INSERT or UPDATE operation
+** that was started by a prior call to sqlite3GenerateConstraintChecks.
+** A consecutive range of registers starting at regRowid contains the
+** rowid and the content to be inserted.
+**
+** The arguments to this routine should be the same as the first six
+** arguments to sqlite3GenerateConstraintChecks.
+*/
+void sqlite3CompleteInsertion(
+  Parse *pParse,      /* The parser context */
+  Table *pTab,        /* the table into which we are inserting */
+  int baseCur,        /* Index of a read/write cursor pointing at pTab */
+  int regRowid,       /* Range of content */
+  int *aRegIdx,       /* Register used by each index.  0 for unused indices */
+  int rowidChng,      /* True if the record number will change */
+  int isUpdate,       /* True for UPDATE, False for INSERT */
+  int newIdx,         /* Index of NEW table for triggers.  -1 if none */
+  int appendBias      /* True if this is likely to be an append */
+){
+  int i;
+  Vdbe *v;
+  int nIdx;
+  Index *pIdx;
+  int pik_flags;
+  int regData;
+  int regRec;
+
+  v = sqlite3GetVdbe(pParse);
+  assert( v!=0 );
+  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
+  for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
+  for(i=nIdx-1; i>=0; i--){
+    if( aRegIdx[i]==0 ) continue;
+    sqlite3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
+  }
+  regData = regRowid + 1;
+  regRec = sqlite3GetTempReg(pParse);
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
+  sqlite3TableAffinityStr(v, pTab);
+#ifndef SQLITE_OMIT_TRIGGER
+  if( newIdx>=0 ){
+    sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRec, regRowid);
+  }
+#endif
+  if( pParse->nested ){
+    pik_flags = 0;
+  }else{
+    pik_flags = OPFLAG_NCHANGE;
+    pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
+  }
+  if( appendBias ){
+    pik_flags |= OPFLAG_APPEND;
+  }
+  sqlite3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
+  if( !pParse->nested ){
+    sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);
+  }
+  sqlite3VdbeChangeP5(v, pik_flags);
+}
+
+/*
+** Generate code that will open cursors for a table and for all
+** indices of that table.  The "baseCur" parameter is the cursor number used
+** for the table.  Indices are opened on subsequent cursors.
+**
+** Return the number of indices on the table.
+*/
+int sqlite3OpenTableAndIndices(
+  Parse *pParse,   /* Parsing context */
+  Table *pTab,     /* Table to be opened */
+  int baseCur,        /* Cursor number assigned to the table */
+  int op           /* OP_OpenRead or OP_OpenWrite */
+){
+  int i;
+  int iDb;
+  Index *pIdx;
+  Vdbe *v;
+
+  if( IsVirtual(pTab) ) return 0;
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+  v = sqlite3GetVdbe(pParse);
+  assert( v!=0 );
+  sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
+  for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
+    KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
+    assert( pIdx->pSchema==pTab->pSchema );
+    sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
+                      (char*)pKey, P4_KEYINFO_HANDOFF);
+    VdbeComment((v, "%s", pIdx->zName));
+  }
+  if( pParse->nTab<=baseCur+i ){
+    pParse->nTab = baseCur+i;
+  }
+  return i-1;
+}
+
+
+#ifdef SQLITE_TEST
+/*
+** The following global variable is incremented whenever the
+** transfer optimization is used.  This is used for testing
+** purposes only - to make sure the transfer optimization really
+** is happening when it is suppose to.
+*/
+int sqlite3_xferopt_count;
+#endif /* SQLITE_TEST */
+
+
+#ifndef SQLITE_OMIT_XFER_OPT
+/*
+** Check to collation names to see if they are compatible.
+*/
+static int xferCompatibleCollation(const char *z1, const char *z2){
+  if( z1==0 ){
+    return z2==0;
+  }
+  if( z2==0 ){
+    return 0;
+  }
+  return sqlite3StrICmp(z1, z2)==0;
+}
+
+
+/*
+** Check to see if index pSrc is compatible as a source of data
+** for index pDest in an insert transfer optimization.  The rules
+** for a compatible index:
+**
+**    *   The index is over the same set of columns
+**    *   The same DESC and ASC markings occurs on all columns
+**    *   The same onError processing (OE_Abort, OE_Ignore, etc)
+**    *   The same collating sequence on each column
+*/
+static int xferCompatibleIndex(Index *pDest, Index *pSrc){
+  int i;
+  assert( pDest && pSrc );
+  assert( pDest->pTable!=pSrc->pTable );
+  if( pDest->nColumn!=pSrc->nColumn ){
+    return 0;   /* Different number of columns */
+  }
+  if( pDest->onError!=pSrc->onError ){
+    return 0;   /* Different conflict resolution strategies */
+  }
+  for(i=0; i<pSrc->nColumn; i++){
+    if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
+      return 0;   /* Different columns indexed */
+    }
+    if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
+      return 0;   /* Different sort orders */
+    }
+    if( pSrc->azColl[i]!=pDest->azColl[i] ){
+      return 0;   /* Different collating sequences */
+    }
+  }
+
+  /* If no test above fails then the indices must be compatible */
+  return 1;
+}
+
+/*
+** Attempt the transfer optimization on INSERTs of the form
+**
+**     INSERT INTO tab1 SELECT * FROM tab2;
+**
+** This optimization is only attempted if
+**
+**    (1)  tab1 and tab2 have identical schemas including all the
+**         same indices and constraints
+**
+**    (2)  tab1 and tab2 are different tables
+**
+**    (3)  There must be no triggers on tab1
+**
+**    (4)  The result set of the SELECT statement is "*"
+**
+**    (5)  The SELECT statement has no WHERE, HAVING, ORDER BY, GROUP BY,
+**         or LIMIT clause.
+**
+**    (6)  The SELECT statement is a simple (not a compound) select that
+**         contains only tab2 in its FROM clause
+**
+** This method for implementing the INSERT transfers raw records from
+** tab2 over to tab1.  The columns are not decoded.  Raw records from
+** the indices of tab2 are transfered to tab1 as well.  In so doing,
+** the resulting tab1 has much less fragmentation.
+**
+** This routine returns TRUE if the optimization is attempted.  If any
+** of the conditions above fail so that the optimization should not
+** be attempted, then this routine returns FALSE.
+*/
+static int xferOptimization(
+  Parse *pParse,        /* Parser context */
+  Table *pDest,         /* The table we are inserting into */
+  Select *pSelect,      /* A SELECT statement to use as the data source */
+  int onError,          /* How to handle constraint errors */
+  int iDbDest           /* The database of pDest */
+){
+  ExprList *pEList;                /* The result set of the SELECT */
+  Table *pSrc;                     /* The table in the FROM clause of SELECT */
+  Index *pSrcIdx, *pDestIdx;       /* Source and destination indices */
+  struct SrcList_item *pItem;      /* An element of pSelect->pSrc */
+  int i;                           /* Loop counter */
+  int iDbSrc;                      /* The database of pSrc */
+  int iSrc, iDest;                 /* Cursors from source and destination */
+  int addr1, addr2;                /* Loop addresses */
+  int emptyDestTest;               /* Address of test for empty pDest */
+  int emptySrcTest;                /* Address of test for empty pSrc */
+  Vdbe *v;                         /* The VDBE we are building */
+  KeyInfo *pKey;                   /* Key information for an index */
+  int regAutoinc;                  /* Memory register used by AUTOINC */
+  int destHasUniqueIdx = 0;        /* True if pDest has a UNIQUE index */
+  int regData, regRowid;           /* Registers holding data and rowid */
+
+  if( pSelect==0 ){
+    return 0;   /* Must be of the form  INSERT INTO ... SELECT ... */
+  }
+  if( pDest->pTrigger ){
+    return 0;   /* tab1 must not have triggers */
+  }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( pDest->isVirtual ){
+    return 0;   /* tab1 must not be a virtual table */
+  }
+#endif
+  if( onError==OE_Default ){
+    onError = OE_Abort;
+  }
+  if( onError!=OE_Abort && onError!=OE_Rollback ){
+    return 0;   /* Cannot do OR REPLACE or OR IGNORE or OR FAIL */
+  }
+  assert(pSelect->pSrc);   /* allocated even if there is no FROM clause */
+  if( pSelect->pSrc->nSrc!=1 ){
+    return 0;   /* FROM clause must have exactly one term */
+  }
+  if( pSelect->pSrc->a[0].pSelect ){
+    return 0;   /* FROM clause cannot contain a subquery */
+  }
+  if( pSelect->pWhere ){
+    return 0;   /* SELECT may not have a WHERE clause */
+  }
+  if( pSelect->pOrderBy ){
+    return 0;   /* SELECT may not have an ORDER BY clause */
+  }
+  /* Do not need to test for a HAVING clause.  If HAVING is present but
+  ** there is no ORDER BY, we will get an error. */
+  if( pSelect->pGroupBy ){
+    return 0;   /* SELECT may not have a GROUP BY clause */
+  }
+  if( pSelect->pLimit ){
+    return 0;   /* SELECT may not have a LIMIT clause */
+  }
+  assert( pSelect->pOffset==0 );  /* Must be so if pLimit==0 */
+  if( pSelect->pPrior ){
+    return 0;   /* SELECT may not be a compound query */
+  }
+  if( pSelect->isDistinct ){
+    return 0;   /* SELECT may not be DISTINCT */
+  }
+  pEList = pSelect->pEList;
+  assert( pEList!=0 );
+  if( pEList->nExpr!=1 ){
+    return 0;   /* The result set must have exactly one column */
+  }
+  assert( pEList->a[0].pExpr );
+  if( pEList->a[0].pExpr->op!=TK_ALL ){
+    return 0;   /* The result set must be the special operator "*" */
+  }
+
+  /* At this point we have established that the statement is of the
+  ** correct syntactic form to participate in this optimization.  Now
+  ** we have to check the semantics.
+  */
+  pItem = pSelect->pSrc->a;
+  pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
+  if( pSrc==0 ){
+    return 0;   /* FROM clause does not contain a real table */
+  }
+  if( pSrc==pDest ){
+    return 0;   /* tab1 and tab2 may not be the same table */
+  }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( pSrc->isVirtual ){
+    return 0;   /* tab2 must not be a virtual table */
+  }
+#endif
+  if( pSrc->pSelect ){
+    return 0;   /* tab2 may not be a view */
+  }
+  if( pDest->nCol!=pSrc->nCol ){
+    return 0;   /* Number of columns must be the same in tab1 and tab2 */
+  }
+  if( pDest->iPKey!=pSrc->iPKey ){
+    return 0;   /* Both tables must have the same INTEGER PRIMARY KEY */
+  }
+  for(i=0; i<pDest->nCol; i++){
+    if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
+      return 0;    /* Affinity must be the same on all columns */
+    }
+    if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){
+      return 0;    /* Collating sequence must be the same on all columns */
+    }
+    if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){
+      return 0;    /* tab2 must be NOT NULL if tab1 is */
+    }
+  }
+  for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
+    if( pDestIdx->onError!=OE_None ){
+      destHasUniqueIdx = 1;
+    }
+    for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
+      if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
+    }
+    if( pSrcIdx==0 ){
+      return 0;    /* pDestIdx has no corresponding index in pSrc */
+    }
+  }
+#ifndef SQLITE_OMIT_CHECK
+  if( pDest->pCheck && !sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
+    return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
+  }
+#endif
+
+  /* If we get this far, it means either:
+  **
+  **    *   We can always do the transfer if the table contains an
+  **        an integer primary key
+  **
+  **    *   We can conditionally do the transfer if the destination
+  **        table is empty.
+  */
+#ifdef SQLITE_TEST
+  sqlite3_xferopt_count++;
+#endif
+  iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
+  v = sqlite3GetVdbe(pParse);
+  sqlite3CodeVerifySchema(pParse, iDbSrc);
+  iSrc = pParse->nTab++;
+  iDest = pParse->nTab++;
+  regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
+  sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
+  if( (pDest->iPKey<0 && pDest->pIndex!=0) || destHasUniqueIdx ){
+    /* If tables do not have an INTEGER PRIMARY KEY and there
+    ** are indices to be copied and the destination is not empty,
+    ** we have to disallow the transfer optimization because the
+    ** the rowids might change which will mess up indexing.
+    **
+    ** Or if the destination has a UNIQUE index and is not empty,
+    ** we also disallow the transfer optimization because we cannot
+    ** insure that all entries in the union of DEST and SRC will be
+    ** unique.
+    */
+    addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0);
+    emptyDestTest = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
+    sqlite3VdbeJumpHere(v, addr1);
+  }else{
+    emptyDestTest = 0;
+  }
+  sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
+  emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
+  regData = sqlite3GetTempReg(pParse);
+  regRowid = sqlite3GetTempReg(pParse);
+  if( pDest->iPKey>=0 ){
+    addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
+    addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
+    sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0,
+                      "PRIMARY KEY must be unique", P4_STATIC);
+    sqlite3VdbeJumpHere(v, addr2);
+    autoIncStep(pParse, regAutoinc, regRowid);
+  }else if( pDest->pIndex==0 ){
+    addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
+  }else{
+    addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
+    assert( pDest->autoInc==0 );
+  }
+  sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
+  sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
+  sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
+  sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
+  sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1);
+  autoIncEnd(pParse, iDbDest, pDest, regAutoinc);
+  for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
+    for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
+      if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
+    }
+    assert( pSrcIdx );
+    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
+    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
+    pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
+    sqlite3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
+                      (char*)pKey, P4_KEYINFO_HANDOFF);
+    VdbeComment((v, "%s", pSrcIdx->zName));
+    pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
+    sqlite3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
+                      (char*)pKey, P4_KEYINFO_HANDOFF);
+    VdbeComment((v, "%s", pDestIdx->zName));
+    addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
+    sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
+    sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
+    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
+    sqlite3VdbeJumpHere(v, addr1);
+  }
+  sqlite3VdbeJumpHere(v, emptySrcTest);
+  sqlite3ReleaseTempReg(pParse, regRowid);
+  sqlite3ReleaseTempReg(pParse, regData);
+  sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
+  sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
+  if( emptyDestTest ){
+    sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
+    sqlite3VdbeJumpHere(v, emptyDestTest);
+    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
+    return 0;
+  }else{
+    return 1;
+  }
+}
+#endif /* SQLITE_OMIT_XFER_OPT */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/journal.c b/client/src/thirdparty/sqlite-3.4.2/src/journal.c
new file mode 100644
index 0000000..7cbe5bc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/journal.c
@@ -0,0 +1,238 @@
+/*
+** 2007 August 22
+**
+** 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: journal.c,v 1.7 2007/09/06 13:49:37 drh Exp $
+*/
+
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+
+/*
+** This file implements a special kind of sqlite3_file object used
+** by SQLite to create journal files if the atomic-write optimization
+** is enabled.
+**
+** The distinctive characteristic of this sqlite3_file is that the
+** actual on disk file is created lazily. When the file is created,
+** the caller specifies a buffer size for an in-memory buffer to
+** be used to service read() and write() requests. The actual file
+** on disk is not created or populated until either:
+**
+**   1) The in-memory representation grows too large for the allocated 
+**      buffer, or
+**   2) The xSync() method is called.
+*/
+
+#include "sqliteInt.h"
+
+
+/*
+** A JournalFile object is a subclass of sqlite3_file used by
+** as an open file handle for journal files.
+*/
+struct JournalFile {
+  sqlite3_io_methods *pMethod;    /* I/O methods on journal files */
+  int nBuf;                       /* Size of zBuf[] in bytes */
+  char *zBuf;                     /* Space to buffer journal writes */
+  int iSize;                      /* Amount of zBuf[] currently used */
+  int flags;                      /* xOpen flags */
+  sqlite3_vfs *pVfs;              /* The "real" underlying VFS */
+  sqlite3_file *pReal;            /* The "real" underlying file descriptor */
+  const char *zJournal;           /* Name of the journal file */
+};
+typedef struct JournalFile JournalFile;
+
+/*
+** If it does not already exists, create and populate the on-disk file 
+** for JournalFile p.
+*/
+static int createFile(JournalFile *p){
+  int rc = SQLITE_OK;
+  if( !p->pReal ){
+    sqlite3_file *pReal = (sqlite3_file *)&p[1];
+    rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
+    if( rc==SQLITE_OK ){
+      p->pReal = pReal;
+      if( p->iSize>0 ){
+        assert(p->iSize<=p->nBuf);
+        rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
+      }
+    }
+  }
+  return rc;
+}
+
+/*
+** Close the file.
+*/
+static int jrnlClose(sqlite3_file *pJfd){
+  JournalFile *p = (JournalFile *)pJfd;
+  if( p->pReal ){
+    sqlite3OsClose(p->pReal);
+  }
+  sqlite3_free(p->zBuf);
+  return SQLITE_OK;
+}
+
+/*
+** Read data from the file.
+*/
+static int jrnlRead(
+  sqlite3_file *pJfd,    /* The journal file from which to read */
+  void *zBuf,            /* Put the results here */
+  int iAmt,              /* Number of bytes to read */
+  sqlite_int64 iOfst     /* Begin reading at this offset */
+){
+  int rc = SQLITE_OK;
+  JournalFile *p = (JournalFile *)pJfd;
+  if( p->pReal ){
+    rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
+  }else{
+    assert( iAmt+iOfst<=p->iSize );
+    memcpy(zBuf, &p->zBuf[iOfst], iAmt);
+  }
+  return rc;
+}
+
+/*
+** Write data to the file.
+*/
+static int jrnlWrite(
+  sqlite3_file *pJfd,    /* The journal file into which to write */
+  const void *zBuf,      /* Take data to be written from here */
+  int iAmt,              /* Number of bytes to write */
+  sqlite_int64 iOfst     /* Begin writing at this offset into the file */
+){
+  int rc = SQLITE_OK;
+  JournalFile *p = (JournalFile *)pJfd;
+  if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
+    rc = createFile(p);
+  }
+  if( rc==SQLITE_OK ){
+    if( p->pReal ){
+      rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
+    }else{
+      memcpy(&p->zBuf[iOfst], zBuf, iAmt);
+      if( p->iSize<(iOfst+iAmt) ){
+        p->iSize = (iOfst+iAmt);
+      }
+    }
+  }
+  return rc;
+}
+
+/*
+** Truncate the file.
+*/
+static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
+  int rc = SQLITE_OK;
+  JournalFile *p = (JournalFile *)pJfd;
+  if( p->pReal ){
+    rc = sqlite3OsTruncate(p->pReal, size);
+  }else if( size<p->iSize ){
+    p->iSize = size;
+  }
+  return rc;
+}
+
+/*
+** Sync the file.
+*/
+static int jrnlSync(sqlite3_file *pJfd, int flags){
+  int rc;
+  JournalFile *p = (JournalFile *)pJfd;
+  rc = createFile(p);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3OsSync(p->pReal, flags);
+  }
+  return rc;
+}
+
+/*
+** Query the size of the file in bytes.
+*/
+static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
+  int rc = SQLITE_OK;
+  JournalFile *p = (JournalFile *)pJfd;
+  if( p->pReal ){
+    rc = sqlite3OsFileSize(p->pReal, pSize);
+  }else{
+    *pSize = (sqlite_int64) p->iSize;
+  }
+  return rc;
+}
+
+/*
+** Table of methods for JournalFile sqlite3_file object.
+*/
+static struct sqlite3_io_methods JournalFileMethods = {
+  1,             /* iVersion */
+  jrnlClose,     /* xClose */
+  jrnlRead,      /* xRead */
+  jrnlWrite,     /* xWrite */
+  jrnlTruncate,  /* xTruncate */
+  jrnlSync,      /* xSync */
+  jrnlFileSize,  /* xFileSize */
+  0,             /* xLock */
+  0,             /* xUnlock */
+  0,             /* xCheckReservedLock */
+  0,             /* xFileControl */
+  0,             /* xSectorSize */
+  0              /* xDeviceCharacteristics */
+};
+
+/* 
+** Open a journal file.
+*/
+int sqlite3JournalOpen(
+  sqlite3_vfs *pVfs,         /* The VFS to use for actual file I/O */
+  const char *zName,         /* Name of the journal file */
+  sqlite3_file *pJfd,        /* Preallocated, blank file handle */
+  int flags,                 /* Opening flags */
+  int nBuf                   /* Bytes buffered before opening the file */
+){
+  JournalFile *p = (JournalFile *)pJfd;
+  memset(p, 0, sqlite3JournalSize(pVfs));
+  if( nBuf>0 ){
+    p->zBuf = sqlite3MallocZero(nBuf);
+    if( !p->zBuf ){
+      return SQLITE_NOMEM;
+    }
+  }else{
+    return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
+  }
+  p->pMethod = &JournalFileMethods;
+  p->nBuf = nBuf;
+  p->flags = flags;
+  p->zJournal = zName;
+  p->pVfs = pVfs;
+  return SQLITE_OK;
+}
+
+/*
+** If the argument p points to a JournalFile structure, and the underlying
+** file has not yet been created, create it now.
+*/
+int sqlite3JournalCreate(sqlite3_file *p){
+  if( p->pMethods!=&JournalFileMethods ){
+    return SQLITE_OK;
+  }
+  return createFile((JournalFile *)p);
+}
+
+/* 
+** Return the number of bytes required to store a JournalFile that uses vfs
+** pVfs to create the underlying on-disk files.
+*/
+int sqlite3JournalSize(sqlite3_vfs *pVfs){
+  return (pVfs->szOsFile+sizeof(JournalFile));
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/legacy.c b/client/src/thirdparty/sqlite-3.4.2/src/legacy.c
new file mode 100644
index 0000000..c004b89
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/legacy.c
@@ -0,0 +1,134 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.22 2007/08/29 12:31:26 danielk1977 Exp $
+*/
+
+#include "sqliteInt.h"
+#include <ctype.h>
+
+/*
+** Execute SQL code.  Return one of the SQLITE_ success/failure
+** codes.  Also write an error message into memory obtained from
+** malloc() and make *pzErrMsg point to that message.
+**
+** If the SQL is a query, then for each row in the query result
+** the xCallback() function is called.  pArg becomes the first
+** argument to xCallback().  If xCallback=NULL then no callback
+** is invoked, even for queries.
+*/
+int sqlite3_exec(
+  sqlite3 *db,                /* The database on which the SQL executes */
+  const char *zSql,           /* The SQL to be executed */
+  sqlite3_callback xCallback, /* Invoke this callback routine */
+  void *pArg,                 /* First argument to xCallback() */
+  char **pzErrMsg             /* Write error messages here */
+){
+  int rc = SQLITE_OK;
+  const char *zLeftover;
+  sqlite3_stmt *pStmt = 0;
+  char **azCols = 0;
+
+  int nRetry = 0;
+  int nCallback;
+
+  if( zSql==0 ) return SQLITE_OK;
+
+  sqlite3_mutex_enter(db->mutex);
+  while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){
+    int nCol;
+    char **azVals = 0;
+
+    pStmt = 0;
+    rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);
+    assert( rc==SQLITE_OK || pStmt==0 );
+    if( rc!=SQLITE_OK ){
+      continue;
+    }
+    if( !pStmt ){
+      /* this happens for a comment or white-space */
+      zSql = zLeftover;
+      continue;
+    }
+
+    nCallback = 0;
+
+    nCol = sqlite3_column_count(pStmt);
+    azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char *) + 1);
+    if( azCols==0 ){
+      goto exec_out;
+    }
+
+    while( 1 ){
+      int i;
+      rc = sqlite3_step(pStmt);
+
+      /* Invoke the callback function if required */
+      if( xCallback && (SQLITE_ROW==rc || 
+          (SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){
+        if( 0==nCallback ){
+          for(i=0; i<nCol; i++){
+            azCols[i] = (char *)sqlite3_column_name(pStmt, i);
+          }
+          nCallback++;
+        }
+        if( rc==SQLITE_ROW ){
+          azVals = &azCols[nCol];
+          for(i=0; i<nCol; i++){
+            azVals[i] = (char *)sqlite3_column_text(pStmt, i);
+          }
+        }
+        if( xCallback(pArg, nCol, azVals, azCols) ){
+          rc = SQLITE_ABORT;
+          goto exec_out;
+        }
+      }
+
+      if( rc!=SQLITE_ROW ){
+        rc = sqlite3_finalize(pStmt);
+        pStmt = 0;
+        if( rc!=SQLITE_SCHEMA ){
+          nRetry = 0;
+          zSql = zLeftover;
+          while( isspace((unsigned char)zSql[0]) ) zSql++;
+        }
+        break;
+      }
+    }
+
+    sqlite3_free(azCols);
+    azCols = 0;
+  }
+
+exec_out:
+  if( pStmt ) sqlite3_finalize(pStmt);
+  if( azCols ) sqlite3_free(azCols);
+
+  rc = sqlite3ApiExit(db, rc);
+  if( rc!=SQLITE_OK && rc==sqlite3_errcode(db) && pzErrMsg ){
+    int nErrMsg = 1 + strlen(sqlite3_errmsg(db));
+    *pzErrMsg = sqlite3_malloc(nErrMsg);
+    if( *pzErrMsg ){
+      memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
+    }
+  }else if( pzErrMsg ){
+    *pzErrMsg = 0;
+  }
+
+  assert( (rc&db->errMask)==rc );
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/limits.h b/client/src/thirdparty/sqlite-3.4.2/src/limits.h
new file mode 100644
index 0000000..fc31f34
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/limits.h
@@ -0,0 +1,158 @@
+/*
+** 2007 May 7
+**
+** 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 defines various limits of what SQLite can process.
+**
+** @(#) $Id: limits.h,v 1.9 2007/06/09 09:53:51 drh Exp $
+*/
+
+/*
+** The maximum length of a TEXT or BLOB in bytes.   This also
+** limits the size of a row in a table or index.
+**
+** The hard limit is the ability of a 32-bit signed integer
+** to count the size: 2^31-1 or 2147483647.
+*/
+#ifndef SQLITE_MAX_LENGTH
+# define SQLITE_MAX_LENGTH 1000000000
+#endif
+
+/*
+** This is the maximum number of
+**
+**    * Columns in a table
+**    * Columns in an index
+**    * Columns in a view
+**    * Terms in the SET clause of an UPDATE statement
+**    * Terms in the result set of a SELECT statement
+**    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
+**    * Terms in the VALUES clause of an INSERT statement
+**
+** The hard upper limit here is 32676.  Most database people will
+** tell you that in a well-normalized database, you usually should
+** not have more than a dozen or so columns in any table.  And if
+** that is the case, there is no point in having more than a few
+** dozen values in any of the other situations described above.
+*/
+#ifndef SQLITE_MAX_COLUMN
+# define SQLITE_MAX_COLUMN 2000
+#endif
+
+/*
+** The maximum length of a single SQL statement in bytes.
+** The hard limit here is the same as SQLITE_MAX_LENGTH.
+*/
+#ifndef SQLITE_MAX_SQL_LENGTH
+# define SQLITE_MAX_SQL_LENGTH 1000000
+#endif
+
+/*
+** The maximum depth of an expression tree. This is limited to 
+** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 
+** want to place more severe limits on the complexity of an 
+** expression. A value of 0 (the default) means do not enforce
+** any limitation on expression tree depth.
+*/
+#ifndef SQLITE_MAX_EXPR_DEPTH
+# define SQLITE_MAX_EXPR_DEPTH 1000
+#endif
+
+/*
+** The maximum number of terms in a compound SELECT statement.
+** The code generator for compound SELECT statements does one
+** level of recursion for each term.  A stack overflow can result
+** if the number of terms is too large.  In practice, most SQL
+** never has more than 3 or 4 terms.  Use a value of 0 to disable
+** any limit on the number of terms in a compount SELECT.
+*/
+#ifndef SQLITE_MAX_COMPOUND_SELECT
+# define SQLITE_MAX_COMPOUND_SELECT 500
+#endif
+
+/*
+** The maximum number of opcodes in a VDBE program.
+** Not currently enforced.
+*/
+#ifndef SQLITE_MAX_VDBE_OP
+# define SQLITE_MAX_VDBE_OP 25000
+#endif
+
+/*
+** The maximum number of arguments to an SQL function.
+*/
+#ifndef SQLITE_MAX_FUNCTION_ARG
+# define SQLITE_MAX_FUNCTION_ARG 100
+#endif
+
+/*
+** The maximum number of in-memory pages to use for the main database
+** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
+*/
+#ifndef SQLITE_DEFAULT_CACHE_SIZE
+# define SQLITE_DEFAULT_CACHE_SIZE  2000
+#endif
+#ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
+# define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500
+#endif
+
+/*
+** The maximum number of attached databases.  This must be at least 2
+** in order to support the main database file (0) and the file used to
+** hold temporary tables (1).  And it must be less than 32 because
+** we use a bitmask of databases with a u32 in places (for example
+** the Parse.cookieMask field).
+*/
+#ifndef SQLITE_MAX_ATTACHED
+# define SQLITE_MAX_ATTACHED 10
+#endif
+
+
+/*
+** The maximum value of a ?nnn wildcard that the parser will accept.
+*/
+#ifndef SQLITE_MAX_VARIABLE_NUMBER
+# define SQLITE_MAX_VARIABLE_NUMBER 999
+#endif
+
+/*
+** 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 the necessity of storing the value in a 2-byte unsigned integer
+** and the fact that the page size must be a power of 2.
+*/
+#ifndef SQLITE_MAX_PAGE_SIZE
+# define SQLITE_MAX_PAGE_SIZE 32768
+#endif
+
+/*
+** Maximum number of pages in one database file.
+**
+** This is really just the default value for the max_page_count pragma.
+** This value can be lowered (or raised) at run-time using that the
+** max_page_count macro.
+*/
+#ifndef SQLITE_MAX_PAGE_COUNT
+# define SQLITE_MAX_PAGE_COUNT 1073741823
+#endif
+
+/*
+** Maximum length (in bytes) of the pattern in a LIKE or GLOB
+** operator.
+*/
+#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
+# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/loadext.c b/client/src/thirdparty/sqlite-3.4.2/src/loadext.c
new file mode 100644
index 0000000..8293486
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/loadext.c
@@ -0,0 +1,518 @@
+/*
+** 2006 June 7
+**
+** 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 dynamically load extensions into
+** the SQLite library.
+*/
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+
+#ifndef SQLITE_CORE
+  #define SQLITE_CORE 1  /* Disable the API redefinition in sqlite3ext.h */
+#endif
+#include "sqlite3ext.h"
+#include "sqliteInt.h"
+#include <string.h>
+#include <ctype.h>
+
+/*
+** Some API routines are omitted when various features are
+** excluded from a build of SQLite.  Substitute a NULL pointer
+** for any missing APIs.
+*/
+#ifndef SQLITE_ENABLE_COLUMN_METADATA
+# define sqlite3_column_database_name   0
+# define sqlite3_column_database_name16 0
+# define sqlite3_column_table_name      0
+# define sqlite3_column_table_name16    0
+# define sqlite3_column_origin_name     0
+# define sqlite3_column_origin_name16   0
+# define sqlite3_table_column_metadata  0
+#endif
+
+#ifdef SQLITE_OMIT_AUTHORIZATION
+# define sqlite3_set_authorizer         0
+#endif
+
+#ifdef SQLITE_OMIT_UTF16
+# define sqlite3_bind_text16            0
+# define sqlite3_collation_needed16     0
+# define sqlite3_column_decltype16      0
+# define sqlite3_column_name16          0
+# define sqlite3_column_text16          0
+# define sqlite3_complete16             0
+# define sqlite3_create_collation16     0
+# define sqlite3_create_function16      0
+# define sqlite3_errmsg16               0
+# define sqlite3_open16                 0
+# define sqlite3_prepare16              0
+# define sqlite3_prepare16_v2           0
+# define sqlite3_result_error16         0
+# define sqlite3_result_text16          0
+# define sqlite3_result_text16be        0
+# define sqlite3_result_text16le        0
+# define sqlite3_value_text16           0
+# define sqlite3_value_text16be         0
+# define sqlite3_value_text16le         0
+# define sqlite3_column_database_name16 0
+# define sqlite3_column_table_name16    0
+# define sqlite3_column_origin_name16   0
+#endif
+
+#ifdef SQLITE_OMIT_COMPLETE
+# define sqlite3_complete 0
+# define sqlite3_complete16 0
+#endif
+
+#ifdef SQLITE_OMIT_PROGRESS_CALLBACK
+# define sqlite3_progress_handler 0
+#endif
+
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+# define sqlite3_create_module 0
+# define sqlite3_create_module_v2 0
+# define sqlite3_declare_vtab 0
+#endif
+
+#ifdef SQLITE_OMIT_SHARED_CACHE
+# define sqlite3_enable_shared_cache 0
+#endif
+
+#ifdef SQLITE_OMIT_TRACE
+# define sqlite3_profile       0
+# define sqlite3_trace         0
+#endif
+
+#ifdef SQLITE_OMIT_GET_TABLE
+# define sqlite3_free_table    0
+# define sqlite3_get_table     0
+#endif
+
+#ifdef SQLITE_OMIT_INCRBLOB
+#define sqlite3_bind_zeroblob  0
+#define sqlite3_blob_bytes     0
+#define sqlite3_blob_close     0
+#define sqlite3_blob_open      0
+#define sqlite3_blob_read      0
+#define sqlite3_blob_write     0
+#endif
+
+/*
+** The following structure contains pointers to all SQLite API routines.
+** A pointer to this structure is passed into extensions when they are
+** loaded so that the extension can make calls back into the SQLite
+** library.
+**
+** When adding new APIs, add them to the bottom of this structure
+** in order to preserve backwards compatibility.
+**
+** Extensions that use newer APIs should first call the
+** sqlite3_libversion_number() to make sure that the API they
+** intend to use is supported by the library.  Extensions should
+** also check to make sure that the pointer to the function is
+** not NULL before calling it.
+*/
+const sqlite3_api_routines sqlite3_apis = {
+  sqlite3_aggregate_context,
+  sqlite3_aggregate_count,
+  sqlite3_bind_blob,
+  sqlite3_bind_double,
+  sqlite3_bind_int,
+  sqlite3_bind_int64,
+  sqlite3_bind_null,
+  sqlite3_bind_parameter_count,
+  sqlite3_bind_parameter_index,
+  sqlite3_bind_parameter_name,
+  sqlite3_bind_text,
+  sqlite3_bind_text16,
+  sqlite3_bind_value,
+  sqlite3_busy_handler,
+  sqlite3_busy_timeout,
+  sqlite3_changes,
+  sqlite3_close,
+  sqlite3_collation_needed,
+  sqlite3_collation_needed16,
+  sqlite3_column_blob,
+  sqlite3_column_bytes,
+  sqlite3_column_bytes16,
+  sqlite3_column_count,
+  sqlite3_column_database_name,
+  sqlite3_column_database_name16,
+  sqlite3_column_decltype,
+  sqlite3_column_decltype16,
+  sqlite3_column_double,
+  sqlite3_column_int,
+  sqlite3_column_int64,
+  sqlite3_column_name,
+  sqlite3_column_name16,
+  sqlite3_column_origin_name,
+  sqlite3_column_origin_name16,
+  sqlite3_column_table_name,
+  sqlite3_column_table_name16,
+  sqlite3_column_text,
+  sqlite3_column_text16,
+  sqlite3_column_type,
+  sqlite3_column_value,
+  sqlite3_commit_hook,
+  sqlite3_complete,
+  sqlite3_complete16,
+  sqlite3_create_collation,
+  sqlite3_create_collation16,
+  sqlite3_create_function,
+  sqlite3_create_function16,
+  sqlite3_create_module,
+  sqlite3_data_count,
+  sqlite3_db_handle,
+  sqlite3_declare_vtab,
+  sqlite3_enable_shared_cache,
+  sqlite3_errcode,
+  sqlite3_errmsg,
+  sqlite3_errmsg16,
+  sqlite3_exec,
+  sqlite3_expired,
+  sqlite3_finalize,
+  sqlite3_free,
+  sqlite3_free_table,
+  sqlite3_get_autocommit,
+  sqlite3_get_auxdata,
+  sqlite3_get_table,
+  0,     /* Was sqlite3_global_recover(), but that function is deprecated */
+  sqlite3_interrupt,
+  sqlite3_last_insert_rowid,
+  sqlite3_libversion,
+  sqlite3_libversion_number,
+  sqlite3_malloc,
+  sqlite3_mprintf,
+  sqlite3_open,
+  sqlite3_open16,
+  sqlite3_prepare,
+  sqlite3_prepare16,
+  sqlite3_profile,
+  sqlite3_progress_handler,
+  sqlite3_realloc,
+  sqlite3_reset,
+  sqlite3_result_blob,
+  sqlite3_result_double,
+  sqlite3_result_error,
+  sqlite3_result_error16,
+  sqlite3_result_int,
+  sqlite3_result_int64,
+  sqlite3_result_null,
+  sqlite3_result_text,
+  sqlite3_result_text16,
+  sqlite3_result_text16be,
+  sqlite3_result_text16le,
+  sqlite3_result_value,
+  sqlite3_rollback_hook,
+  sqlite3_set_authorizer,
+  sqlite3_set_auxdata,
+  sqlite3_snprintf,
+  sqlite3_step,
+  sqlite3_table_column_metadata,
+  sqlite3_thread_cleanup,
+  sqlite3_total_changes,
+  sqlite3_trace,
+  sqlite3_transfer_bindings,
+  sqlite3_update_hook,
+  sqlite3_user_data,
+  sqlite3_value_blob,
+  sqlite3_value_bytes,
+  sqlite3_value_bytes16,
+  sqlite3_value_double,
+  sqlite3_value_int,
+  sqlite3_value_int64,
+  sqlite3_value_numeric_type,
+  sqlite3_value_text,
+  sqlite3_value_text16,
+  sqlite3_value_text16be,
+  sqlite3_value_text16le,
+  sqlite3_value_type,
+  sqlite3_vmprintf,
+  /*
+  ** The original API set ends here.  All extensions can call any
+  ** of the APIs above provided that the pointer is not NULL.  But
+  ** before calling APIs that follow, extension should check the
+  ** sqlite3_libversion_number() to make sure they are dealing with
+  ** a library that is new enough to support that API.
+  *************************************************************************
+  */
+  sqlite3_overload_function,
+
+  /*
+  ** Added after 3.3.13
+  */
+  sqlite3_prepare_v2,
+  sqlite3_prepare16_v2,
+  sqlite3_clear_bindings,
+
+  /*
+  ** Added for 3.4.1
+  */
+  sqlite3_create_module_v2,
+
+  /*
+  ** Added for 3.5.0
+  */
+  sqlite3_bind_zeroblob,
+  sqlite3_blob_bytes,
+  sqlite3_blob_close,
+  sqlite3_blob_open,
+  sqlite3_blob_read,
+  sqlite3_blob_write,
+  sqlite3_create_collation_v2,
+  sqlite3_file_control,
+  sqlite3_memory_highwater,
+  sqlite3_memory_used,
+#ifdef SQLITE_MUTEX_NOOP
+  0, 
+  0, 
+  0,
+  0,
+  0,
+#else
+  sqlite3_mutex_alloc,
+  sqlite3_mutex_enter,
+  sqlite3_mutex_free,
+  sqlite3_mutex_leave,
+  sqlite3_mutex_try,
+#endif
+  sqlite3_open_v2,
+  sqlite3_release_memory,
+  sqlite3_result_error_nomem,
+  sqlite3_result_error_toobig,
+  sqlite3_sleep,
+  sqlite3_soft_heap_limit,
+  sqlite3_vfs_find,
+  sqlite3_vfs_register,
+  sqlite3_vfs_unregister,
+};
+
+/*
+** Attempt to load an SQLite extension library contained in the file
+** zFile.  The entry point is zProc.  zProc may be 0 in which case a
+** default entry point name (sqlite3_extension_init) is used.  Use
+** of the default name is recommended.
+**
+** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
+**
+** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with 
+** error message text.  The calling function should free this memory
+** by calling sqlite3_free().
+*/
+static int sqlite3LoadExtension(
+  sqlite3 *db,          /* Load the extension into this database connection */
+  const char *zFile,    /* Name of the shared library containing extension */
+  const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */
+  char **pzErrMsg       /* Put error message here if not 0 */
+){
+  sqlite3_vfs *pVfs = db->pVfs;
+  void *handle;
+  int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
+  char *zErrmsg = 0;
+  void **aHandle;
+
+  /* Ticket #1863.  To avoid a creating security problems for older
+  ** applications that relink against newer versions of SQLite, the
+  ** ability to run load_extension is turned off by default.  One
+  ** must call sqlite3_enable_load_extension() to turn on extension
+  ** loading.  Otherwise you get the following error.
+  */
+  if( (db->flags & SQLITE_LoadExtension)==0 ){
+    if( pzErrMsg ){
+      *pzErrMsg = sqlite3_mprintf("not authorized");
+    }
+    return SQLITE_ERROR;
+  }
+
+  if( zProc==0 ){
+    zProc = "sqlite3_extension_init";
+  }
+
+  handle = sqlite3OsDlOpen(pVfs, zFile);
+  if( handle==0 ){
+    if( pzErrMsg ){
+      char zErr[256];
+      zErr[sizeof(zErr)-1] = '\0';
+      sqlite3_snprintf(sizeof(zErr)-1, zErr, 
+          "unable to open shared library [%s]", zFile);
+      sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);
+      *pzErrMsg = sqlite3DbStrDup(db, zErr);
+    }
+    return SQLITE_ERROR;
+  }
+  xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
+                   sqlite3OsDlSym(pVfs, handle, zProc);
+  if( xInit==0 ){
+    if( pzErrMsg ){
+      char zErr[256];
+      zErr[sizeof(zErr)-1] = '\0';
+      sqlite3_snprintf(sizeof(zErr)-1, zErr,
+          "no entry point [%s] in shared library [%s]", zProc,zFile);
+      sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);
+      *pzErrMsg = sqlite3DbStrDup(db, zErr);
+      sqlite3OsDlClose(pVfs, handle);
+    }
+    return SQLITE_ERROR;
+  }else if( xInit(db, &zErrmsg, &sqlite3_apis) ){
+    if( pzErrMsg ){
+      *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
+    }
+    sqlite3_free(zErrmsg);
+    sqlite3OsDlClose(pVfs, handle);
+    return SQLITE_ERROR;
+  }
+
+  /* Append the new shared library handle to the db->aExtension array. */
+  db->nExtension++;
+  aHandle = sqlite3DbMallocZero(db, sizeof(handle)*db->nExtension);
+  if( aHandle==0 ){
+    return SQLITE_NOMEM;
+  }
+  if( db->nExtension>0 ){
+    memcpy(aHandle, db->aExtension, sizeof(handle)*(db->nExtension-1));
+  }
+  sqlite3_free(db->aExtension);
+  db->aExtension = aHandle;
+
+  db->aExtension[db->nExtension-1] = handle;
+  return SQLITE_OK;
+}
+int sqlite3_load_extension(
+  sqlite3 *db,          /* Load the extension into this database connection */
+  const char *zFile,    /* Name of the shared library containing extension */
+  const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */
+  char **pzErrMsg       /* Put error message here if not 0 */
+){
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Call this routine when the database connection is closing in order
+** to clean up loaded extensions
+*/
+void sqlite3CloseExtensions(sqlite3 *db){
+  int i;
+  assert( sqlite3_mutex_held(db->mutex) );
+  for(i=0; i<db->nExtension; i++){
+    sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
+  }
+  sqlite3_free(db->aExtension);
+}
+
+/*
+** Enable or disable extension loading.  Extension loading is disabled by
+** default so as not to open security holes in older applications.
+*/
+int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
+  sqlite3_mutex_enter(db->mutex);
+  if( onoff ){
+    db->flags |= SQLITE_LoadExtension;
+  }else{
+    db->flags &= ~SQLITE_LoadExtension;
+  }
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+/*
+** The following object holds the list of automatically loaded
+** extensions.
+**
+** This list is shared across threads.  The SQLITE_MUTEX_STATIC_MASTER
+** mutex must be held while accessing this list.
+*/
+static struct {
+  int nExt;        /* Number of entries in aExt[] */          
+  void **aExt;     /* Pointers to the extension init functions */
+} autoext = { 0, 0 };
+
+
+/*
+** Register a statically linked extension that is automatically
+** loaded by every new database connection.
+*/
+int sqlite3_auto_extension(void *xInit){
+  int i;
+  int rc = SQLITE_OK;
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_mutex_enter(mutex);
+  for(i=0; i<autoext.nExt; i++){
+    if( autoext.aExt[i]==xInit ) break;
+  }
+  if( i==autoext.nExt ){
+    int nByte = (autoext.nExt+1)*sizeof(autoext.aExt[0]);
+    void **aNew;
+    aNew = sqlite3_realloc(autoext.aExt, nByte);
+    if( aNew==0 ){
+      rc = SQLITE_NOMEM;
+    }else{
+      autoext.aExt = aNew;
+      autoext.aExt[autoext.nExt] = xInit;
+      autoext.nExt++;
+    }
+  }
+  sqlite3_mutex_leave(mutex);
+  assert( (rc&0xff)==rc );
+  return rc;
+}
+
+/*
+** Reset the automatic extension loading mechanism.
+*/
+void sqlite3_reset_auto_extension(void){
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+  sqlite3_mutex_enter(mutex);
+  sqlite3_free(autoext.aExt);
+  autoext.aExt = 0;
+  autoext.nExt = 0;
+  sqlite3_mutex_leave(mutex);
+}
+
+/*
+** Load all automatic extensions.
+*/
+int sqlite3AutoLoadExtensions(sqlite3 *db){
+  int i;
+  int go = 1;
+  int rc = SQLITE_OK;
+  int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
+
+  if( autoext.nExt==0 ){
+    /* Common case: early out without every having to acquire a mutex */
+    return SQLITE_OK;
+  }
+  for(i=0; go; i++){
+    char *zErrmsg = 0;
+    sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+    sqlite3_mutex_enter(mutex);
+    if( i>=autoext.nExt ){
+      xInit = 0;
+      go = 0;
+    }else{
+      xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
+              autoext.aExt[i];
+    }
+    sqlite3_mutex_leave(mutex);
+    if( xInit && xInit(db, &zErrmsg, &sqlite3_apis) ){
+      sqlite3Error(db, SQLITE_ERROR,
+            "automatic extension loading failed: %s", zErrmsg);
+      go = 0;
+      rc = SQLITE_ERROR;
+      sqlite3_free(zErrmsg);
+    }
+  }
+  return rc;
+}
+
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/main.c b/client/src/thirdparty/sqlite-3.4.2/src/main.c
new file mode 100644
index 0000000..5f878f0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/main.c
@@ -0,0 +1,1509 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.417 2008/01/31 15:31:02 danielk1977 Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#ifdef SQLITE_ENABLE_FTS3
+# include "fts3.h"
+#endif
+
+/*
+** The version of the library
+*/
+const char sqlite3_version[] = SQLITE_VERSION;
+const char *sqlite3_libversion(void){ return sqlite3_version; }
+int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
+int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
+
+/*
+** If the following function pointer is not NULL and if
+** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
+** I/O active are written using this function.  These messages
+** are intended for debugging activity only.
+*/
+void (*sqlite3_io_trace)(const char*, ...) = 0;
+
+/*
+** If the following global variable points to a string which is the
+** name of a directory, then that directory will be used to store
+** temporary files.
+**
+** See also the "PRAGMA temp_store_directory" SQL command.
+*/
+char *sqlite3_temp_directory = 0;
+
+
+/*
+** Return true if the buffer z[0..n-1] contains all spaces.
+*/
+static int allSpaces(const char *z, int n){
+  while( n>0 && z[--n]==' ' ){}
+  return n==0;
+}
+
+/*
+** This is the default collating function named "BINARY" which is always
+** available.
+**
+** If the padFlag argument is not NULL then space padding at the end
+** of strings is ignored.  This implements the RTRIM collation.
+*/
+static int binCollFunc(
+  void *padFlag,
+  int nKey1, const void *pKey1,
+  int nKey2, const void *pKey2
+){
+  int rc, n;
+  n = nKey1<nKey2 ? nKey1 : nKey2;
+  rc = memcmp(pKey1, pKey2, n);
+  if( rc==0 ){
+    if( padFlag
+     && allSpaces(((char*)pKey1)+n, nKey1-n)
+     && allSpaces(((char*)pKey2)+n, nKey2-n)
+    ){
+      /* Leave rc unchanged at 0 */
+    }else{
+      rc = nKey1 - nKey2;
+    }
+  }
+  return rc;
+}
+
+/*
+** Another built-in collating sequence: NOCASE. 
+**
+** This collating sequence is intended to be used for "case independant
+** comparison". SQLite's knowledge of upper and lower case equivalents
+** extends only to the 26 characters used in the English language.
+**
+** At the moment there is only a UTF-8 implementation.
+*/
+static int nocaseCollatingFunc(
+  void *NotUsed,
+  int nKey1, const void *pKey1,
+  int nKey2, const void *pKey2
+){
+  int r = sqlite3StrNICmp(
+      (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
+  if( 0==r ){
+    r = nKey1-nKey2;
+  }
+  return r;
+}
+
+/*
+** Return the ROWID of the most recent insert
+*/
+sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
+  return db->lastRowid;
+}
+
+/*
+** Return the number of changes in the most recent call to sqlite3_exec().
+*/
+int sqlite3_changes(sqlite3 *db){
+  return db->nChange;
+}
+
+/*
+** Return the number of changes since the database handle was opened.
+*/
+int sqlite3_total_changes(sqlite3 *db){
+  return db->nTotalChange;
+}
+
+/*
+** Close an existing SQLite database
+*/
+int sqlite3_close(sqlite3 *db){
+  HashElem *i;
+  int j;
+
+  if( !db ){
+    return SQLITE_OK;
+  }
+  if( !sqlite3SafetyCheckSickOrOk(db) ){
+    return SQLITE_MISUSE;
+  }
+  sqlite3_mutex_enter(db->mutex);
+
+#ifdef SQLITE_SSE
+  {
+    extern void sqlite3SseCleanup(sqlite3*);
+    sqlite3SseCleanup(db);
+  }
+#endif 
+
+  sqlite3ResetInternalSchema(db, 0);
+
+  /* If a transaction is open, the ResetInternalSchema() call above
+  ** will not have called the xDisconnect() method on any virtual
+  ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
+  ** call will do so. We need to do this before the check for active
+  ** SQL statements below, as the v-table implementation may be storing
+  ** some prepared statements internally.
+  */
+  sqlite3VtabRollback(db);
+
+  /* If there are any outstanding VMs, return SQLITE_BUSY. */
+  if( db->pVdbe ){
+    sqlite3Error(db, SQLITE_BUSY, 
+        "Unable to close due to unfinalised statements");
+    sqlite3_mutex_leave(db->mutex);
+    return SQLITE_BUSY;
+  }
+  assert( sqlite3SafetyCheckSickOrOk(db) );
+
+  for(j=0; j<db->nDb; j++){
+    struct Db *pDb = &db->aDb[j];
+    if( pDb->pBt ){
+      sqlite3BtreeClose(pDb->pBt);
+      pDb->pBt = 0;
+      if( j!=1 ){
+        pDb->pSchema = 0;
+      }
+    }
+  }
+  sqlite3ResetInternalSchema(db, 0);
+  assert( db->nDb<=2 );
+  assert( db->aDb==db->aDbStatic );
+  for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
+    FuncDef *pFunc, *pNext;
+    for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
+      pNext = pFunc->pNext;
+      sqlite3_free(pFunc);
+    }
+  }
+
+  for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
+    CollSeq *pColl = (CollSeq *)sqliteHashData(i);
+    /* Invoke any destructors registered for collation sequence user data. */
+    for(j=0; j<3; j++){
+      if( pColl[j].xDel ){
+        pColl[j].xDel(pColl[j].pUser);
+      }
+    }
+    sqlite3_free(pColl);
+  }
+  sqlite3HashClear(&db->aCollSeq);
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
+    Module *pMod = (Module *)sqliteHashData(i);
+    if( pMod->xDestroy ){
+      pMod->xDestroy(pMod->pAux);
+    }
+    sqlite3_free(pMod);
+  }
+  sqlite3HashClear(&db->aModule);
+#endif
+
+  sqlite3HashClear(&db->aFunc);
+  sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
+  if( db->pErr ){
+    sqlite3ValueFree(db->pErr);
+  }
+  sqlite3CloseExtensions(db);
+
+  db->magic = SQLITE_MAGIC_ERROR;
+
+  /* The temp-database schema is allocated differently from the other schema
+  ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
+  ** So it needs to be freed here. Todo: Why not roll the temp schema into
+  ** the same sqliteMalloc() as the one that allocates the database 
+  ** structure?
+  */
+  sqlite3_free(db->aDb[1].pSchema);
+  sqlite3_mutex_leave(db->mutex);
+  db->magic = SQLITE_MAGIC_CLOSED;
+  sqlite3_mutex_free(db->mutex);
+  sqlite3_free(db);
+  return SQLITE_OK;
+}
+
+/*
+** Rollback all database files.
+*/
+void sqlite3RollbackAll(sqlite3 *db){
+  int i;
+  int inTrans = 0;
+  assert( sqlite3_mutex_held(db->mutex) );
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 1);
+  for(i=0; i<db->nDb; i++){
+    if( db->aDb[i].pBt ){
+      if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
+        inTrans = 1;
+      }
+      sqlite3BtreeRollback(db->aDb[i].pBt);
+      db->aDb[i].inTrans = 0;
+    }
+  }
+  sqlite3VtabRollback(db);
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
+
+  if( db->flags&SQLITE_InternChanges ){
+    sqlite3ExpirePreparedStatements(db);
+    sqlite3ResetInternalSchema(db, 0);
+  }
+
+  /* If one has been configured, invoke the rollback-hook callback */
+  if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
+    db->xRollbackCallback(db->pRollbackArg);
+  }
+}
+
+/*
+** Return a static string that describes the kind of error specified in the
+** argument.
+*/
+const char *sqlite3ErrStr(int rc){
+  const char *z;
+  switch( rc & 0xff ){
+    case SQLITE_ROW:
+    case SQLITE_DONE:
+    case SQLITE_OK:         z = "not an error";                          break;
+    case SQLITE_ERROR:      z = "SQL logic error or missing database";   break;
+    case SQLITE_PERM:       z = "access permission denied";              break;
+    case SQLITE_ABORT:      z = "callback requested query abort";        break;
+    case SQLITE_BUSY:       z = "database is locked";                    break;
+    case SQLITE_LOCKED:     z = "database table is locked";              break;
+    case SQLITE_NOMEM:      z = "out of memory";                         break;
+    case SQLITE_READONLY:   z = "attempt to write a readonly database";  break;
+    case SQLITE_INTERRUPT:  z = "interrupted";                           break;
+    case SQLITE_IOERR:      z = "disk I/O error";                        break;
+    case SQLITE_CORRUPT:    z = "database disk image is malformed";      break;
+    case SQLITE_FULL:       z = "database or disk is full";              break;
+    case SQLITE_CANTOPEN:   z = "unable to open database file";          break;
+    case SQLITE_EMPTY:      z = "table contains no data";                break;
+    case SQLITE_SCHEMA:     z = "database schema has changed";           break;
+    case SQLITE_TOOBIG:     z = "String or BLOB exceeded size limit";    break;
+    case SQLITE_CONSTRAINT: z = "constraint failed";                     break;
+    case SQLITE_MISMATCH:   z = "datatype mismatch";                     break;
+    case SQLITE_MISUSE:     z = "library routine called out of sequence";break;
+    case SQLITE_NOLFS:      z = "kernel lacks large file support";       break;
+    case SQLITE_AUTH:       z = "authorization denied";                  break;
+    case SQLITE_FORMAT:     z = "auxiliary database format error";       break;
+    case SQLITE_RANGE:      z = "bind or column index out of range";     break;
+    case SQLITE_NOTADB:     z = "file is encrypted or is not a database";break;
+    default:                z = "unknown error";                         break;
+  }
+  return z;
+}
+
+/*
+** This routine implements a busy callback that sleeps and tries
+** again until a timeout value is reached.  The timeout value is
+** an integer number of milliseconds passed in as the first
+** argument.
+*/
+static int sqliteDefaultBusyCallback(
+ void *ptr,               /* Database connection */
+ int count                /* Number of times table has been busy */
+){
+#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
+  static const u8 delays[] =
+     { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
+  static const u8 totals[] =
+     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
+# define NDELAY (sizeof(delays)/sizeof(delays[0]))
+  sqlite3 *db = (sqlite3 *)ptr;
+  int timeout = db->busyTimeout;
+  int delay, prior;
+
+  assert( count>=0 );
+  if( count < NDELAY ){
+    delay = delays[count];
+    prior = totals[count];
+  }else{
+    delay = delays[NDELAY-1];
+    prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
+  }
+  if( prior + delay > timeout ){
+    delay = timeout - prior;
+    if( delay<=0 ) return 0;
+  }
+  sqlite3OsSleep(db->pVfs, delay*1000);
+  return 1;
+#else
+  sqlite3 *db = (sqlite3 *)ptr;
+  int timeout = ((sqlite3 *)ptr)->busyTimeout;
+  if( (count+1)*1000 > timeout ){
+    return 0;
+  }
+  sqlite3OsSleep(db->pVfs, 1000000);
+  return 1;
+#endif
+}
+
+/*
+** Invoke the given busy handler.
+**
+** This routine is called when an operation failed with a lock.
+** If this routine returns non-zero, the lock is retried.  If it
+** returns 0, the operation aborts with an SQLITE_BUSY error.
+*/
+int sqlite3InvokeBusyHandler(BusyHandler *p){
+  int rc;
+  if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;
+  rc = p->xFunc(p->pArg, p->nBusy);
+  if( rc==0 ){
+    p->nBusy = -1;
+  }else{
+    p->nBusy++;
+  }
+  return rc; 
+}
+
+/*
+** This routine sets the busy callback for an Sqlite database to the
+** given callback function with the given argument.
+*/
+int sqlite3_busy_handler(
+  sqlite3 *db,
+  int (*xBusy)(void*,int),
+  void *pArg
+){
+  sqlite3_mutex_enter(db->mutex);
+  db->busyHandler.xFunc = xBusy;
+  db->busyHandler.pArg = pArg;
+  db->busyHandler.nBusy = 0;
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+/*
+** This routine sets the progress callback for an Sqlite database to the
+** given callback function with the given argument. The progress callback will
+** be invoked every nOps opcodes.
+*/
+void sqlite3_progress_handler(
+  sqlite3 *db, 
+  int nOps,
+  int (*xProgress)(void*), 
+  void *pArg
+){
+  if( sqlite3SafetyCheckOk(db) ){
+    sqlite3_mutex_enter(db->mutex);
+    if( nOps>0 ){
+      db->xProgress = xProgress;
+      db->nProgressOps = nOps;
+      db->pProgressArg = pArg;
+    }else{
+      db->xProgress = 0;
+      db->nProgressOps = 0;
+      db->pProgressArg = 0;
+    }
+    sqlite3_mutex_leave(db->mutex);
+  }
+}
+#endif
+
+
+/*
+** This routine installs a default busy handler that waits for the
+** specified number of milliseconds before returning 0.
+*/
+int sqlite3_busy_timeout(sqlite3 *db, int ms){
+  if( ms>0 ){
+    db->busyTimeout = ms;
+    sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
+  }else{
+    sqlite3_busy_handler(db, 0, 0);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Cause any pending operation to stop at its earliest opportunity.
+*/
+void sqlite3_interrupt(sqlite3 *db){
+  if( sqlite3SafetyCheckOk(db) ){
+    db->u1.isInterrupted = 1;
+  }
+}
+
+
+/*
+** This function is exactly the same as sqlite3_create_function(), except
+** that it is designed to be called by internal code. The difference is
+** that if a malloc() fails in sqlite3_create_function(), an error code
+** is returned and the mallocFailed flag cleared. 
+*/
+int sqlite3CreateFunc(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int enc,
+  void *pUserData,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
+  void (*xFinal)(sqlite3_context*)
+){
+  FuncDef *p;
+  int nName;
+
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( zFunctionName==0 ||
+      (xFunc && (xFinal || xStep)) || 
+      (!xFunc && (xFinal && !xStep)) ||
+      (!xFunc && (!xFinal && xStep)) ||
+      (nArg<-1 || nArg>127) ||
+      (255<(nName = strlen(zFunctionName))) ){
+    sqlite3Error(db, SQLITE_ERROR, "bad parameters");
+    return SQLITE_ERROR;
+  }
+  
+#ifndef SQLITE_OMIT_UTF16
+  /* If SQLITE_UTF16 is specified as the encoding type, transform this
+  ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
+  ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
+  **
+  ** If SQLITE_ANY is specified, add three versions of the function
+  ** to the hash table.
+  */
+  if( enc==SQLITE_UTF16 ){
+    enc = SQLITE_UTF16NATIVE;
+  }else if( enc==SQLITE_ANY ){
+    int rc;
+    rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
+         pUserData, xFunc, xStep, xFinal);
+    if( rc==SQLITE_OK ){
+      rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
+          pUserData, xFunc, xStep, xFinal);
+    }
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    enc = SQLITE_UTF16BE;
+  }
+#else
+  enc = SQLITE_UTF8;
+#endif
+  
+  /* Check if an existing function is being overridden or deleted. If so,
+  ** and there are active VMs, then return SQLITE_BUSY. If a function
+  ** is being overridden/deleted but there are no active VMs, allow the
+  ** operation to continue but invalidate all precompiled statements.
+  */
+  p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
+  if( p && p->iPrefEnc==enc && p->nArg==nArg ){
+    if( db->activeVdbeCnt ){
+      sqlite3Error(db, SQLITE_BUSY, 
+        "Unable to delete/modify user-function due to active statements");
+      assert( !db->mallocFailed );
+      return SQLITE_BUSY;
+    }else{
+      sqlite3ExpirePreparedStatements(db);
+    }
+  }
+
+  p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
+  assert(p || db->mallocFailed);
+  if( !p ){
+    return SQLITE_NOMEM;
+  }
+  p->flags = 0;
+  p->xFunc = xFunc;
+  p->xStep = xStep;
+  p->xFinalize = xFinal;
+  p->pUserData = pUserData;
+  p->nArg = nArg;
+  return SQLITE_OK;
+}
+
+/*
+** Create new user functions.
+*/
+int sqlite3_create_function(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int enc,
+  void *p,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
+  void (*xFinal)(sqlite3_context*)
+){
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+int sqlite3_create_function16(
+  sqlite3 *db,
+  const void *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *p,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+){
+  int rc;
+  char *zFunc8;
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
+  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
+  sqlite3_free(zFunc8);
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+#endif
+
+
+/*
+** Declare that a function has been overloaded by a virtual table.
+**
+** If the function already exists as a regular global function, then
+** this routine is a no-op.  If the function does not exist, then create
+** a new one that always throws a run-time error.  
+**
+** When virtual tables intend to provide an overloaded function, they
+** should call this routine to make sure the global function exists.
+** A global function must exist in order for name resolution to work
+** properly.
+*/
+int sqlite3_overload_function(
+  sqlite3 *db,
+  const char *zName,
+  int nArg
+){
+  int nName = strlen(zName);
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
+    sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
+                      0, sqlite3InvalidFunction, 0, 0);
+  }
+  rc = sqlite3ApiExit(db, SQLITE_OK);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+#ifndef SQLITE_OMIT_TRACE
+/*
+** 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
+** SQL statement.
+*/
+void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
+  void *pOld;
+  sqlite3_mutex_enter(db->mutex);
+  pOld = db->pTraceArg;
+  db->xTrace = xTrace;
+  db->pTraceArg = pArg;
+  sqlite3_mutex_leave(db->mutex);
+  return pOld;
+}
+/*
+** Register a profile function.  The pArg from the previously registered 
+** profile function is returned.  
+**
+** A NULL profile function means that no profiling is executes.  A non-NULL
+** profile is a pointer to a function that is invoked at the conclusion of
+** each SQL statement that is run.
+*/
+void *sqlite3_profile(
+  sqlite3 *db,
+  void (*xProfile)(void*,const char*,sqlite_uint64),
+  void *pArg
+){
+  void *pOld;
+  sqlite3_mutex_enter(db->mutex);
+  pOld = db->pProfileArg;
+  db->xProfile = xProfile;
+  db->pProfileArg = pArg;
+  sqlite3_mutex_leave(db->mutex);
+  return pOld;
+}
+#endif /* SQLITE_OMIT_TRACE */
+
+/*** EXPERIMENTAL ***
+**
+** Register a function to be invoked when a transaction comments.
+** If the invoked function returns non-zero, then the commit becomes a
+** rollback.
+*/
+void *sqlite3_commit_hook(
+  sqlite3 *db,              /* Attach the hook to this database */
+  int (*xCallback)(void*),  /* Function to invoke on each commit */
+  void *pArg                /* Argument to the function */
+){
+  void *pOld;
+  sqlite3_mutex_enter(db->mutex);
+  pOld = db->pCommitArg;
+  db->xCommitCallback = xCallback;
+  db->pCommitArg = pArg;
+  sqlite3_mutex_leave(db->mutex);
+  return pOld;
+}
+
+/*
+** Register a callback to be invoked each time a row is updated,
+** inserted or deleted using this database connection.
+*/
+void *sqlite3_update_hook(
+  sqlite3 *db,              /* Attach the hook to this database */
+  void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
+  void *pArg                /* Argument to the function */
+){
+  void *pRet;
+  sqlite3_mutex_enter(db->mutex);
+  pRet = db->pUpdateArg;
+  db->xUpdateCallback = xCallback;
+  db->pUpdateArg = pArg;
+  sqlite3_mutex_leave(db->mutex);
+  return pRet;
+}
+
+/*
+** Register a callback to be invoked each time a transaction is rolled
+** back by this database connection.
+*/
+void *sqlite3_rollback_hook(
+  sqlite3 *db,              /* Attach the hook to this database */
+  void (*xCallback)(void*), /* Callback function */
+  void *pArg                /* Argument to the function */
+){
+  void *pRet;
+  sqlite3_mutex_enter(db->mutex);
+  pRet = db->pRollbackArg;
+  db->xRollbackCallback = xCallback;
+  db->pRollbackArg = pArg;
+  sqlite3_mutex_leave(db->mutex);
+  return pRet;
+}
+
+/*
+** This routine is called to create a connection to a database BTree
+** driver.  If zFilename is the name of a file, then that file is
+** opened and used.  If zFilename is the magic name ":memory:" then
+** the database is stored in memory (and is thus forgotten as soon as
+** the connection is closed.)  If zFilename is NULL then the database
+** is a "virtual" database for transient use only and is deleted as
+** soon as the connection is closed.
+**
+** A virtual database can be either a disk file (that is automatically
+** deleted when the file is closed) or it an be held entirely in memory,
+** depending on the values of the TEMP_STORE compile-time macro and the
+** db->temp_store variable, according to the following chart:
+**
+**       TEMP_STORE     db->temp_store     Location of temporary database
+**       ----------     --------------     ------------------------------
+**           0               any             file
+**           1                1              file
+**           1                2              memory
+**           1                0              file
+**           2                1              file
+**           2                2              memory
+**           2                0              memory
+**           3               any             memory
+*/
+int sqlite3BtreeFactory(
+  const sqlite3 *db,        /* Main database when opening aux otherwise 0 */
+  const char *zFilename,    /* Name of the file containing the BTree database */
+  int omitJournal,          /* if TRUE then do not journal this file */
+  int nCache,               /* How many pages in the page cache */
+  int vfsFlags,             /* Flags passed through to vfsOpen */
+  Btree **ppBtree           /* Pointer to new Btree object written here */
+){
+  int btFlags = 0;
+  int rc;
+  
+  assert( sqlite3_mutex_held(db->mutex) );
+  assert( ppBtree != 0);
+  if( omitJournal ){
+    btFlags |= BTREE_OMIT_JOURNAL;
+  }
+  if( db->flags & SQLITE_NoReadlock ){
+    btFlags |= BTREE_NO_READLOCK;
+  }
+  if( zFilename==0 ){
+#if TEMP_STORE==0
+    /* Do nothing */
+#endif
+#ifndef SQLITE_OMIT_MEMORYDB
+#if TEMP_STORE==1
+    if( db->temp_store==2 ) zFilename = ":memory:";
+#endif
+#if TEMP_STORE==2
+    if( db->temp_store!=1 ) zFilename = ":memory:";
+#endif
+#if TEMP_STORE==3
+    zFilename = ":memory:";
+#endif
+#endif /* SQLITE_OMIT_MEMORYDB */
+  }
+
+  if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
+    vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
+  }
+  rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
+  if( rc==SQLITE_OK ){
+    sqlite3BtreeSetCacheSize(*ppBtree, nCache);
+  }
+  return rc;
+}
+
+/*
+** Return UTF-8 encoded English language explanation of the most recent
+** error.
+*/
+const char *sqlite3_errmsg(sqlite3 *db){
+  const char *z;
+  if( !db ){
+    return sqlite3ErrStr(SQLITE_NOMEM);
+  }
+  if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
+    return sqlite3ErrStr(SQLITE_MISUSE);
+  }
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  z = (char*)sqlite3_value_text(db->pErr);
+  if( z==0 ){
+    z = sqlite3ErrStr(db->errCode);
+  }
+  sqlite3_mutex_leave(db->mutex);
+  return z;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Return UTF-16 encoded English language explanation of the most recent
+** error.
+*/
+const void *sqlite3_errmsg16(sqlite3 *db){
+  /* Because all the characters in the string are in the unicode
+  ** range 0x00-0xFF, if we pad the big-endian string with a 
+  ** zero byte, we can obtain the little-endian string with
+  ** &big_endian[1].
+  */
+  static const char outOfMemBe[] = {
+    0, 'o', 0, 'u', 0, 't', 0, ' ', 
+    0, 'o', 0, 'f', 0, ' ', 
+    0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
+  };
+  static const char misuseBe [] = {
+    0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ', 
+    0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ', 
+    0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ', 
+    0, 'o', 0, 'u', 0, 't', 0, ' ', 
+    0, 'o', 0, 'f', 0, ' ', 
+    0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
+  };
+
+  const void *z;
+  if( !db ){
+    return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
+  }
+  if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
+    return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
+  }
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  z = sqlite3_value_text16(db->pErr);
+  if( z==0 ){
+    sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
+         SQLITE_UTF8, SQLITE_STATIC);
+    z = sqlite3_value_text16(db->pErr);
+  }
+  sqlite3ApiExit(0, 0);
+  sqlite3_mutex_leave(db->mutex);
+  return z;
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** Return the most recent error code generated by an SQLite routine. If NULL is
+** passed to this function, we assume a malloc() failed during sqlite3_open().
+*/
+int sqlite3_errcode(sqlite3 *db){
+  if( db && !sqlite3SafetyCheckSickOrOk(db) ){
+    return SQLITE_MISUSE;
+  }
+  if( !db || db->mallocFailed ){
+    return SQLITE_NOMEM;
+  }
+  return db->errCode & db->errMask;
+}
+
+/*
+** Create a new collating function for database "db".  The name is zName
+** and the encoding is enc.
+*/
+static int createCollation(
+  sqlite3* db, 
+  const char *zName, 
+  int enc, 
+  void* pCtx,
+  int(*xCompare)(void*,int,const void*,int,const void*),
+  void(*xDel)(void*)
+){
+  CollSeq *pColl;
+  int enc2;
+  
+  assert( sqlite3_mutex_held(db->mutex) );
+
+  /* If SQLITE_UTF16 is specified as the encoding type, transform this
+  ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
+  ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
+  */
+  enc2 = enc & ~SQLITE_UTF16_ALIGNED;
+  if( enc2==SQLITE_UTF16 ){
+    enc2 = SQLITE_UTF16NATIVE;
+  }
+
+  if( (enc2&~3)!=0 ){
+    sqlite3Error(db, SQLITE_ERROR, "unknown encoding");
+    return SQLITE_ERROR;
+  }
+
+  /* Check if this call is removing or replacing an existing collation 
+  ** sequence. If so, and there are active VMs, return busy. If there
+  ** are no active VMs, invalidate any pre-compiled statements.
+  */
+  pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0);
+  if( pColl && pColl->xCmp ){
+    if( db->activeVdbeCnt ){
+      sqlite3Error(db, SQLITE_BUSY, 
+        "Unable to delete/modify collation sequence due to active statements");
+      return SQLITE_BUSY;
+    }
+    sqlite3ExpirePreparedStatements(db);
+
+    /* If collation sequence pColl was created directly by a call to
+    ** sqlite3_create_collation, and not generated by synthCollSeq(),
+    ** then any copies made by synthCollSeq() need to be invalidated.
+    ** Also, collation destructor - CollSeq.xDel() - function may need
+    ** to be called.
+    */ 
+    if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
+      CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, strlen(zName));
+      int j;
+      for(j=0; j<3; j++){
+        CollSeq *p = &aColl[j];
+        if( p->enc==pColl->enc ){
+          if( p->xDel ){
+            p->xDel(p->pUser);
+          }
+          p->xCmp = 0;
+        }
+      }
+    }
+  }
+
+  pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1);
+  if( pColl ){
+    pColl->xCmp = xCompare;
+    pColl->pUser = pCtx;
+    pColl->xDel = xDel;
+    pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
+  }
+  sqlite3Error(db, SQLITE_OK, 0);
+  return SQLITE_OK;
+}
+
+
+/*
+** This routine does the work of opening a database on behalf of
+** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"  
+** is UTF-8 encoded.
+*/
+static int openDatabase(
+  const char *zFilename, /* Database filename UTF-8 encoded */
+  sqlite3 **ppDb,        /* OUT: Returned database handle */
+  unsigned flags,        /* Operational flags */
+  const char *zVfs       /* Name of the VFS to use */
+){
+  sqlite3 *db;
+  int rc;
+  CollSeq *pColl;
+
+  /* Allocate the sqlite data structure */
+  db = sqlite3MallocZero( sizeof(sqlite3) );
+  if( db==0 ) goto opendb_out;
+  db->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
+  if( db->mutex==0 ){
+    sqlite3_free(db);
+    db = 0;
+    goto opendb_out;
+  }
+  sqlite3_mutex_enter(db->mutex);
+  db->errMask = 0xff;
+  db->priorNewRowid = 0;
+  db->nDb = 2;
+  db->magic = SQLITE_MAGIC_BUSY;
+  db->aDb = db->aDbStatic;
+  db->autoCommit = 1;
+  db->nextAutovac = -1;
+  db->flags |= SQLITE_ShortColNames
+#if SQLITE_DEFAULT_FILE_FORMAT<4
+                 | SQLITE_LegacyFileFmt
+#endif
+#ifdef SQLITE_ENABLE_LOAD_EXTENSION
+                 | SQLITE_LoadExtension
+#endif
+      ;
+  sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
+  sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
+#endif
+
+  db->pVfs = sqlite3_vfs_find(zVfs);
+  if( !db->pVfs ){
+    rc = SQLITE_ERROR;
+    db->magic = SQLITE_MAGIC_SICK;
+    sqlite3Error(db, rc, "no such vfs: %s", (zVfs?zVfs:"(null)"));
+    goto opendb_out;
+  }
+
+  /* Add the default collation sequence BINARY. BINARY works for both UTF-8
+  ** and UTF-16, so add a version for each to avoid any unnecessary
+  ** conversions. The only error that can occur here is a malloc() failure.
+  */
+  if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0) ||
+      createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0) ||
+      createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0) ||
+      createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0) ||
+      (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0 
+  ){
+    assert( db->mallocFailed );
+    db->magic = SQLITE_MAGIC_SICK;
+    goto opendb_out;
+  }
+
+  /* Also add a UTF-8 case-insensitive collation sequence. */
+  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
+
+  /* Set flags on the built-in collating sequences */
+  db->pDfltColl->type = SQLITE_COLL_BINARY;
+  pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
+  if( pColl ){
+    pColl->type = SQLITE_COLL_NOCASE;
+  }
+
+  /* Open the backend database driver */
+  db->openFlags = flags;
+  rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE, 
+                           flags | SQLITE_OPEN_MAIN_DB,
+                           &db->aDb[0].pBt);
+  if( rc!=SQLITE_OK ){
+    sqlite3Error(db, rc, 0);
+    db->magic = SQLITE_MAGIC_SICK;
+    goto opendb_out;
+  }
+  db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
+  db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
+
+
+  /* The default safety_level for the main database is 'full'; for the temp
+  ** database it is 'NONE'. This matches the pager layer defaults.  
+  */
+  db->aDb[0].zName = "main";
+  db->aDb[0].safety_level = 3;
+#ifndef SQLITE_OMIT_TEMPDB
+  db->aDb[1].zName = "temp";
+  db->aDb[1].safety_level = 1;
+#endif
+
+  db->magic = SQLITE_MAGIC_OPEN;
+  if( db->mallocFailed ){
+    goto opendb_out;
+  }
+
+  /* Register all built-in functions, but do not attempt to read the
+  ** database schema yet. This is delayed until the first time the database
+  ** is accessed.
+  */
+  sqlite3Error(db, SQLITE_OK, 0);
+  sqlite3RegisterBuiltinFunctions(db);
+
+  /* Load automatic extensions - extensions that have been registered
+  ** using the sqlite3_automatic_extension() API.
+  */
+  (void)sqlite3AutoLoadExtensions(db);
+  if( sqlite3_errcode(db)!=SQLITE_OK ){
+    goto opendb_out;
+  }
+
+#ifdef SQLITE_ENABLE_FTS1
+  if( !db->mallocFailed ){
+    extern int sqlite3Fts1Init(sqlite3*);
+    rc = sqlite3Fts1Init(db);
+  }
+#endif
+
+#ifdef SQLITE_ENABLE_FTS2
+  if( !db->mallocFailed && rc==SQLITE_OK ){
+    extern int sqlite3Fts2Init(sqlite3*);
+    rc = sqlite3Fts2Init(db);
+  }
+#endif
+
+#ifdef SQLITE_ENABLE_FTS3
+  if( !db->mallocFailed && rc==SQLITE_OK ){
+    rc = sqlite3Fts3Init(db);
+  }
+#endif
+
+#ifdef SQLITE_ENABLE_ICU
+  if( !db->mallocFailed && rc==SQLITE_OK ){
+    extern int sqlite3IcuInit(sqlite3*);
+    rc = sqlite3IcuInit(db);
+  }
+#endif
+  sqlite3Error(db, rc, 0);
+
+  /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
+  ** mode.  -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
+  ** mode.  Doing nothing at all also makes NORMAL the default.
+  */
+#ifdef SQLITE_DEFAULT_LOCKING_MODE
+  db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
+  sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
+                          SQLITE_DEFAULT_LOCKING_MODE);
+#endif
+
+opendb_out:
+  if( db && db->mutex ){
+    sqlite3_mutex_leave(db->mutex);
+  }
+  if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
+    sqlite3_close(db);
+    db = 0;
+  }
+  *ppDb = db;
+  return sqlite3ApiExit(0, rc);
+}
+
+/*
+** Open a new database handle.
+*/
+int sqlite3_open(
+  const char *zFilename, 
+  sqlite3 **ppDb 
+){
+  return openDatabase(zFilename, ppDb,
+                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
+}
+int sqlite3_open_v2(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb,         /* OUT: SQLite db handle */
+  int flags,              /* Flags */
+  const char *zVfs        /* Name of VFS module to use */
+){
+  return openDatabase(filename, ppDb, flags, zVfs);
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Open a new database handle.
+*/
+int sqlite3_open16(
+  const void *zFilename, 
+  sqlite3 **ppDb
+){
+  char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
+  sqlite3_value *pVal;
+  int rc = SQLITE_NOMEM;
+
+  assert( zFilename );
+  assert( ppDb );
+  *ppDb = 0;
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
+  zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
+  if( zFilename8 ){
+    rc = openDatabase(zFilename8, ppDb,
+                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
+    if( rc==SQLITE_OK && *ppDb ){
+      rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);
+      if( rc!=SQLITE_OK ){
+        sqlite3_close(*ppDb);
+        *ppDb = 0;
+      }
+    }
+  }
+  sqlite3ValueFree(pVal);
+
+  return sqlite3ApiExit(0, rc);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** Register a new collation sequence with the database handle db.
+*/
+int sqlite3_create_collation(
+  sqlite3* db, 
+  const char *zName, 
+  int enc, 
+  void* pCtx,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+){
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Register a new collation sequence with the database handle db.
+*/
+int sqlite3_create_collation_v2(
+  sqlite3* db, 
+  const char *zName, 
+  int enc, 
+  void* pCtx,
+  int(*xCompare)(void*,int,const void*,int,const void*),
+  void(*xDel)(void*)
+){
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Register a new collation sequence with the database handle db.
+*/
+int sqlite3_create_collation16(
+  sqlite3* db, 
+  const char *zName, 
+  int enc, 
+  void* pCtx,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+){
+  int rc = SQLITE_OK;
+  char *zName8;
+  sqlite3_mutex_enter(db->mutex);
+  assert( !db->mallocFailed );
+  zName8 = sqlite3Utf16to8(db, zName, -1);
+  if( zName8 ){
+    rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
+    sqlite3_free(zName8);
+  }
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** Register a collation sequence factory callback with the database handle
+** db. Replace any previously installed collation sequence factory.
+*/
+int sqlite3_collation_needed(
+  sqlite3 *db, 
+  void *pCollNeededArg, 
+  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
+){
+  sqlite3_mutex_enter(db->mutex);
+  db->xCollNeeded = xCollNeeded;
+  db->xCollNeeded16 = 0;
+  db->pCollNeededArg = pCollNeededArg;
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Register a collation sequence factory callback with the database handle
+** db. Replace any previously installed collation sequence factory.
+*/
+int sqlite3_collation_needed16(
+  sqlite3 *db, 
+  void *pCollNeededArg, 
+  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
+){
+  sqlite3_mutex_enter(db->mutex);
+  db->xCollNeeded = 0;
+  db->xCollNeeded16 = xCollNeeded16;
+  db->pCollNeededArg = pCollNeededArg;
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+#ifndef SQLITE_OMIT_GLOBALRECOVER
+/*
+** This function is now an anachronism. It used to be used to recover from a
+** malloc() failure, but SQLite now does this automatically.
+*/
+int sqlite3_global_recover(void){
+  return SQLITE_OK;
+}
+#endif
+
+/*
+** Test to see whether or not the database connection is in autocommit
+** mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on
+** by default.  Autocommit is disabled by a BEGIN statement and reenabled
+** 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;
+}
+
+#ifdef SQLITE_DEBUG
+/*
+** The following routine is subtituted for constant SQLITE_CORRUPT in
+** debugging builds.  This provides a way to set a breakpoint for when
+** corruption is first detected.
+*/
+int sqlite3Corrupt(void){
+  return SQLITE_CORRUPT;
+}
+#endif
+
+/*
+** This is a convenience routine that makes sure that all thread-specific
+** data for this thread has been deallocated.
+**
+** SQLite no longer uses thread-specific data so this routine is now a
+** no-op.  It is retained for historical compatibility.
+*/
+void sqlite3_thread_cleanup(void){
+}
+
+/*
+** Return meta information about a specific column of a database table.
+** See comment in sqlite3.h (sqlite.h.in) for details.
+*/
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+int sqlite3_table_column_metadata(
+  sqlite3 *db,                /* Connection handle */
+  const char *zDbName,        /* Database name or NULL */
+  const char *zTableName,     /* Table name */
+  const char *zColumnName,    /* Column name */
+  char const **pzDataType,    /* OUTPUT: Declared data type */
+  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
+  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
+  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
+  int *pAutoinc               /* OUTPUT: True if colums is auto-increment */
+){
+  int rc;
+  char *zErrMsg = 0;
+  Table *pTab = 0;
+  Column *pCol = 0;
+  int iCol;
+
+  char const *zDataType = 0;
+  char const *zCollSeq = 0;
+  int notnull = 0;
+  int primarykey = 0;
+  int autoinc = 0;
+
+  /* Ensure the database schema has been loaded */
+  (void)sqlite3SafetyOn(db);
+  sqlite3_mutex_enter(db->mutex);
+  rc = sqlite3Init(db, &zErrMsg);
+  if( SQLITE_OK!=rc ){
+    goto error_out;
+  }
+
+  /* Locate the table in question */
+  pTab = sqlite3FindTable(db, zTableName, zDbName);
+  if( !pTab || pTab->pSelect ){
+    pTab = 0;
+    goto error_out;
+  }
+
+  /* Find the column for which info is requested */
+  if( sqlite3IsRowid(zColumnName) ){
+    iCol = pTab->iPKey;
+    if( iCol>=0 ){
+      pCol = &pTab->aCol[iCol];
+    }
+  }else{
+    for(iCol=0; iCol<pTab->nCol; iCol++){
+      pCol = &pTab->aCol[iCol];
+      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
+        break;
+      }
+    }
+    if( iCol==pTab->nCol ){
+      pTab = 0;
+      goto error_out;
+    }
+  }
+
+  /* The following block stores the meta information that will be returned
+  ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
+  ** and autoinc. At this point there are two possibilities:
+  ** 
+  **     1. The specified column name was rowid", "oid" or "_rowid_" 
+  **        and there is no explicitly declared IPK column. 
+  **
+  **     2. The table is not a view and the column name identified an 
+  **        explicitly declared column. Copy meta information from *pCol.
+  */ 
+  if( pCol ){
+    zDataType = pCol->zType;
+    zCollSeq = pCol->zColl;
+    notnull = (pCol->notNull?1:0);
+    primarykey  = (pCol->isPrimKey?1:0);
+    autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);
+  }else{
+    zDataType = "INTEGER";
+    primarykey = 1;
+  }
+  if( !zCollSeq ){
+    zCollSeq = "BINARY";
+  }
+
+error_out:
+  (void)sqlite3SafetyOff(db);
+
+  /* Whether the function call succeeded or failed, set the output parameters
+  ** to whatever their local counterparts contain. If an error did occur,
+  ** this has the effect of zeroing all output parameters.
+  */
+  if( pzDataType ) *pzDataType = zDataType;
+  if( pzCollSeq ) *pzCollSeq = zCollSeq;
+  if( pNotNull ) *pNotNull = notnull;
+  if( pPrimaryKey ) *pPrimaryKey = primarykey;
+  if( pAutoinc ) *pAutoinc = autoinc;
+
+  if( SQLITE_OK==rc && !pTab ){
+    sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".", 
+        zColumnName, 0);
+    rc = SQLITE_ERROR;
+  }
+  sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
+  sqlite3_free(zErrMsg);
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+#endif
+
+/*
+** Sleep for a little while.  Return the amount of time slept.
+*/
+int sqlite3_sleep(int ms){
+  sqlite3_vfs *pVfs;
+  int rc;
+  pVfs = sqlite3_vfs_find(0);
+
+  /* This function works in milliseconds, but the underlying OsSleep() 
+  ** API uses microseconds. Hence the 1000's.
+  */
+  rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
+  return rc;
+}
+
+/*
+** Enable or disable the extended result codes.
+*/
+int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
+  sqlite3_mutex_enter(db->mutex);
+  db->errMask = onoff ? 0xffffffff : 0xff;
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Invoke the xFileControl method on a particular database.
+*/
+int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
+  int rc = SQLITE_ERROR;
+  int iDb;
+  sqlite3_mutex_enter(db->mutex);
+  if( zDbName==0 ){
+    iDb = 0;
+  }else{
+    for(iDb=0; iDb<db->nDb; iDb++){
+      if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
+    }
+  }
+  if( iDb<db->nDb ){
+    Btree *pBtree = db->aDb[iDb].pBt;
+    if( pBtree ){
+      Pager *pPager;
+      sqlite3_file *fd;
+      sqlite3BtreeEnter(pBtree);
+      pPager = sqlite3BtreePager(pBtree);
+      assert( pPager!=0 );
+      fd = sqlite3PagerFile(pPager);
+      assert( fd!=0 );
+      if( fd->pMethods ){
+        rc = sqlite3OsFileControl(fd, op, pArg);
+      }
+      sqlite3BtreeLeave(pBtree);
+    }
+  }
+  sqlite3_mutex_leave(db->mutex);
+  return rc;   
+}
+
+/*
+** Interface to the testing logic.
+*/
+int sqlite3_test_control(int op, ...){
+  va_list ap;
+  int rc = 0;
+  va_start(ap, op);
+  switch( op ){
+#ifndef SQLITE_OMIT_FAULTINJECTOR
+    case SQLITE_TESTCTRL_FAULT_CONFIG: {
+      int id = va_arg(ap, int);
+      int nDelay = va_arg(ap, int);
+      int nRepeat = va_arg(ap, int);
+      sqlite3FaultConfig(id, nDelay, nRepeat);
+      break;
+    }
+    case SQLITE_TESTCTRL_FAULT_FAILURES: {
+      int id = va_arg(ap, int);
+      rc = sqlite3FaultFailures(id);
+      break;
+    }
+    case SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES: {
+      int id = va_arg(ap, int);
+      rc = sqlite3FaultBenignFailures(id);
+      break;
+    }
+    case SQLITE_TESTCTRL_FAULT_PENDING: {
+      int id = va_arg(ap, int);
+      rc = sqlite3FaultPending(id);
+      break;
+    }
+#endif /* SQLITE_OMIT_FAULTINJECTOR */
+  }
+  va_end(ap);
+  return rc;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/malloc.c b/client/src/thirdparty/sqlite-3.4.2/src/malloc.c
new file mode 100644
index 0000000..a047348
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/malloc.c
@@ -0,0 +1,239 @@
+/*
+** 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.
+**
+*************************************************************************
+** Memory allocation functions used throughout sqlite.
+**
+**
+** $Id: malloc.c,v 1.14 2007/10/20 16:36:31 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <stdarg.h>
+#include <ctype.h>
+
+/*
+** This routine runs when the memory allocator sees that the
+** total memory allocation is about to exceed the soft heap
+** limit.
+*/
+static void softHeapLimitEnforcer(
+  void *NotUsed, 
+  sqlite3_int64 inUse,
+  int allocSize
+){
+  sqlite3_release_memory(allocSize);
+}
+
+/*
+** Set the soft heap-size limit for the current thread. Passing a
+** zero or negative value indicates no limit.
+*/
+void sqlite3_soft_heap_limit(int n){
+  sqlite3_uint64 iLimit;
+  int overage;
+  if( n<0 ){
+    iLimit = 0;
+  }else{
+    iLimit = n;
+  }
+  if( iLimit>0 ){
+    sqlite3_memory_alarm(softHeapLimitEnforcer, 0, iLimit);
+  }else{
+    sqlite3_memory_alarm(0, 0, 0);
+  }
+  overage = sqlite3_memory_used() - n;
+  if( overage>0 ){
+    sqlite3_release_memory(overage);
+  }
+}
+
+/*
+** Release memory held by SQLite instances created by the current thread.
+*/
+int sqlite3_release_memory(int n){
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  return sqlite3PagerReleaseMemory(n);
+#else
+  return SQLITE_OK;
+#endif
+}
+
+
+/*
+** Allocate and zero memory.
+*/ 
+void *sqlite3MallocZero(unsigned n){
+  void *p = sqlite3_malloc(n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+
+/*
+** Allocate and zero memory.  If the allocation fails, make
+** the mallocFailed flag in the connection pointer.
+*/
+void *sqlite3DbMallocZero(sqlite3 *db, unsigned n){
+  void *p = sqlite3DbMallocRaw(db, n);
+  if( p ){
+    memset(p, 0, n);
+  }
+  return p;
+}
+
+/*
+** Allocate and zero memory.  If the allocation fails, make
+** the mallocFailed flag in the connection pointer.
+*/
+void *sqlite3DbMallocRaw(sqlite3 *db, unsigned n){
+  void *p = 0;
+  if( !db || db->mallocFailed==0 ){
+    p = sqlite3_malloc(n);
+    if( !p && db ){
+      db->mallocFailed = 1;
+    }
+  }
+  return p;
+}
+
+/*
+** Resize the block of memory pointed to by p to n bytes. If the
+** resize fails, set the mallocFailed flag inthe connection object.
+*/
+void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
+  void *pNew = 0;
+  if( db->mallocFailed==0 ){
+    pNew = sqlite3_realloc(p, n);
+    if( !pNew ){
+      db->mallocFailed = 1;
+    }
+  }
+  return pNew;
+}
+
+/*
+** Attempt to reallocate p.  If the reallocation fails, then free p
+** and set the mallocFailed flag in the database connection.
+*/
+void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
+  void *pNew;
+  pNew = sqlite3DbRealloc(db, p, n);
+  if( !pNew ){
+    sqlite3_free(p);
+  }
+  return pNew;
+}
+
+/*
+** Make a copy of a string in memory obtained from sqliteMalloc(). These 
+** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
+** is because when memory debugging is turned on, these two functions are 
+** called via macros that record the current file and line number in the
+** ThreadData structure.
+*/
+char *sqlite3StrDup(const char *z){
+  char *zNew;
+  int n;
+  if( z==0 ) return 0;
+  n = strlen(z)+1;
+  zNew = sqlite3_malloc(n);
+  if( zNew ) memcpy(zNew, z, n);
+  return zNew;
+}
+char *sqlite3StrNDup(const char *z, int n){
+  char *zNew;
+  if( z==0 ) return 0;
+  zNew = sqlite3_malloc(n+1);
+  if( zNew ){
+    memcpy(zNew, z, n);
+    zNew[n] = 0;
+  }
+  return zNew;
+}
+
+char *sqlite3DbStrDup(sqlite3 *db, const char *z){
+  char *zNew = sqlite3StrDup(z);
+  if( z && !zNew ){
+    db->mallocFailed = 1;
+  }
+  return zNew;
+}
+char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
+  char *zNew = sqlite3StrNDup(z, n);
+  if( z && !zNew ){
+    db->mallocFailed = 1;
+  }
+  return zNew;
+}
+
+/*
+** Create a string from the 2nd and subsequent arguments (up to the
+** first NULL argument), store the string in memory obtained from
+** sqliteMalloc() and make the pointer indicated by the 1st argument
+** point to that string.  The 1st argument must either be NULL or 
+** point to memory obtained from sqliteMalloc().
+*/
+void sqlite3SetString(char **pz, ...){
+  va_list ap;
+  int nByte;
+  const char *z;
+  char *zResult;
+
+  assert( pz!=0 );
+  nByte = 1;
+  va_start(ap, pz);
+  while( (z = va_arg(ap, const char*))!=0 ){
+    nByte += strlen(z);
+  }
+  va_end(ap);
+  sqlite3_free(*pz);
+  *pz = zResult = sqlite3_malloc(nByte);
+  if( zResult==0 ){
+    return;
+  }
+  *zResult = 0;
+  va_start(ap, pz);
+  while( (z = va_arg(ap, const char*))!=0 ){
+    int n = strlen(z);
+    memcpy(zResult, z, n);
+    zResult += n;
+  }
+  zResult[0] = 0;
+  va_end(ap);
+}
+
+
+/*
+** This function must be called before exiting any API function (i.e. 
+** returning control to the user) that has called sqlite3_malloc or
+** sqlite3_realloc.
+**
+** The returned value is normally a copy of the second argument to this
+** function. However, if a malloc() failure has occured since the previous
+** invocation SQLITE_NOMEM is returned instead. 
+**
+** If the first argument, db, is not NULL and a malloc() error has occured,
+** then the connection error-code (the value returned by sqlite3_errcode())
+** is set to SQLITE_NOMEM.
+*/
+int sqlite3ApiExit(sqlite3* db, int rc){
+  /* If the db handle is not NULL, then we must hold the connection handle
+  ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 
+  ** is unsafe, as is the call to sqlite3Error().
+  */
+  assert( !db || sqlite3_mutex_held(db->mutex) );
+  if( db && db->mallocFailed ){
+    sqlite3Error(db, SQLITE_NOMEM, 0);
+    db->mallocFailed = 0;
+    rc = SQLITE_NOMEM;
+  }
+  return rc & (db ? db->errMask : 0xff);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/md5.c b/client/src/thirdparty/sqlite-3.4.2/src/md5.c
new file mode 100644
index 0000000..a4c9931
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/md5.c
@@ -0,0 +1,387 @@
+/*
+** SQLite uses this code for testing only.  It is not a part of
+** the SQLite library.  This file implements two new TCL commands
+** "md5" and "md5file" that compute md5 checksums on arbitrary text
+** and on complete files.  These commands are used by the "testfixture"
+** program to help verify the correct operation of the SQLite library.
+**
+** The original use of these TCL commands was to test the ROLLBACK
+** feature of SQLite.  First compute the MD5-checksum of the database.
+** Then make some changes but rollback the changes rather than commit
+** them.  Compute a second MD5-checksum of the file and verify that the
+** two checksums are the same.  Such is the original use of this code.
+** New uses may have been added since this comment was written.
+*/
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+#include <tcl.h>
+#include <string.h>
+#include "sqlite3.h"
+
+/*
+ * If compiled on a machine that doesn't have a 32-bit integer,
+ * you just set "uint32" to the appropriate datatype for an
+ * unsigned 32-bit integer.  For example:
+ *
+ *       cc -Duint32='unsigned long' md5.c
+ *
+ */
+#ifndef uint32
+#  define uint32 unsigned int
+#endif
+
+struct Context {
+  uint32 buf[4];
+  uint32 bits[2];
+  unsigned char in[64];
+};
+typedef char MD5Context[88];
+
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+static void byteReverse (unsigned char *buf, unsigned longs){
+        uint32 t;
+        do {
+                t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
+                            ((unsigned)buf[1]<<8 | buf[0]);
+                *(uint32 *)buf = t;
+                buf += 4;
+        } while (--longs);
+}
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+static void MD5Transform(uint32 buf[4], const uint32 in[16]){
+        register uint32 a, b, c, d;
+
+        a = buf[0];
+        b = buf[1];
+        c = buf[2];
+        d = buf[3];
+
+        MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
+        MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
+        MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
+        MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
+        MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
+        MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
+        MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
+        MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
+        MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
+        MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
+        MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
+        MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
+        MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
+        MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
+        MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
+        MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
+
+        MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
+        MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
+        MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
+        MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
+        MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
+        MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
+        MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
+        MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
+        MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
+        MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
+        MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
+        MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
+        MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
+        MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
+        MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
+        MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
+
+        MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
+        MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
+        MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
+        MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
+        MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
+        MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
+        MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
+        MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
+        MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
+        MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
+        MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
+        MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
+        MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
+        MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
+        MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
+        MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
+
+        MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
+        MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
+        MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
+        MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
+        MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
+        MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
+        MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
+        MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
+        MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
+        MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
+        MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
+        MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
+        MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
+        MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
+        MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
+        MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
+
+        buf[0] += a;
+        buf[1] += b;
+        buf[2] += c;
+        buf[3] += d;
+}
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+static void MD5Init(MD5Context *pCtx){
+        struct Context *ctx = (struct Context *)pCtx;
+        ctx->buf[0] = 0x67452301;
+        ctx->buf[1] = 0xefcdab89;
+        ctx->buf[2] = 0x98badcfe;
+        ctx->buf[3] = 0x10325476;
+        ctx->bits[0] = 0;
+        ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+static 
+void MD5Update(MD5Context *pCtx, const unsigned char *buf, unsigned int len){
+        struct Context *ctx = (struct Context *)pCtx;
+        uint32 t;
+
+        /* Update bitcount */
+
+        t = ctx->bits[0];
+        if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
+                ctx->bits[1]++; /* Carry from low to high */
+        ctx->bits[1] += len >> 29;
+
+        t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
+
+        /* Handle any leading odd-sized chunks */
+
+        if ( t ) {
+                unsigned char *p = (unsigned char *)ctx->in + t;
+
+                t = 64-t;
+                if (len < t) {
+                        memcpy(p, buf, len);
+                        return;
+                }
+                memcpy(p, buf, t);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                buf += t;
+                len -= t;
+        }
+
+        /* Process data in 64-byte chunks */
+
+        while (len >= 64) {
+                memcpy(ctx->in, buf, 64);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                buf += 64;
+                len -= 64;
+        }
+
+        /* Handle any remaining bytes of data. */
+
+        memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+static void MD5Final(unsigned char digest[16], MD5Context *pCtx){
+        struct Context *ctx = (struct Context *)pCtx;
+        unsigned count;
+        unsigned char *p;
+
+        /* Compute number of bytes mod 64 */
+        count = (ctx->bits[0] >> 3) & 0x3F;
+
+        /* Set the first char of padding to 0x80.  This is safe since there is
+           always at least one byte free */
+        p = ctx->in + count;
+        *p++ = 0x80;
+
+        /* Bytes of padding needed to make 64 bytes */
+        count = 64 - 1 - count;
+
+        /* Pad out to 56 mod 64 */
+        if (count < 8) {
+                /* Two lots of padding:  Pad the first block to 64 bytes */
+                memset(p, 0, count);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+
+                /* Now fill the next block with 56 bytes */
+                memset(ctx->in, 0, 56);
+        } else {
+                /* Pad block to 56 bytes */
+                memset(p, 0, count-8);
+        }
+        byteReverse(ctx->in, 14);
+
+        /* Append length in bits and transform */
+        ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
+        ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
+
+        MD5Transform(ctx->buf, (uint32 *)ctx->in);
+        byteReverse((unsigned char *)ctx->buf, 4);
+        memcpy(digest, ctx->buf, 16);
+        memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
+}
+
+/*
+** Convert a digest into base-16.  digest should be declared as
+** "unsigned char digest[16]" in the calling function.  The MD5
+** digest is stored in the first 16 bytes.  zBuf should
+** be "char zBuf[33]".
+*/
+static void DigestToBase16(unsigned char *digest, char *zBuf){
+  static char const zEncode[] = "0123456789abcdef";
+  int i, j;
+
+  for(j=i=0; i<16; i++){
+    int a = digest[i];
+    zBuf[j++] = zEncode[(a>>4)&0xf];
+    zBuf[j++] = zEncode[a & 0xf];
+  }
+  zBuf[j] = 0;
+}
+
+/*
+** A TCL command for md5.  The argument is the text to be hashed.  The
+** Result is the hash in base64.  
+*/
+static int md5_cmd(void*cd, Tcl_Interp *interp, int argc, const char **argv){
+  MD5Context ctx;
+  unsigned char digest[16];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0], 
+        " TEXT\"", 0);
+    return TCL_ERROR;
+  }
+  MD5Init(&ctx);
+  MD5Update(&ctx, (unsigned char*)argv[1], (unsigned)strlen(argv[1]));
+  MD5Final(digest, &ctx);
+  DigestToBase16(digest, interp->result);
+  return TCL_OK;
+}
+
+/*
+** A TCL command to take the md5 hash of a file.  The argument is the
+** name of the file.
+*/
+static int md5file_cmd(void*cd, Tcl_Interp*interp, int argc, const char **argv){
+  FILE *in;
+  MD5Context ctx;
+  unsigned char digest[16];
+  char zBuf[10240];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0], 
+        " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  in = fopen(argv[1],"rb");
+  if( in==0 ){
+    Tcl_AppendResult(interp,"unable to open file \"", argv[1], 
+         "\" for reading", 0);
+    return TCL_ERROR;
+  }
+  MD5Init(&ctx);
+  for(;;){
+    int n;
+    n = fread(zBuf, 1, sizeof(zBuf), in);
+    if( n<=0 ) break;
+    MD5Update(&ctx, (unsigned char*)zBuf, (unsigned)n);
+  }
+  fclose(in);
+  MD5Final(digest, &ctx);
+  DigestToBase16(digest, interp->result);
+  return TCL_OK;
+}
+
+/*
+** Register the two TCL commands above with the TCL interpreter.
+*/
+int Md5_Init(Tcl_Interp *interp){
+  Tcl_CreateCommand(interp, "md5", (Tcl_CmdProc*)md5_cmd, 0, 0);
+  Tcl_CreateCommand(interp, "md5file", (Tcl_CmdProc*)md5file_cmd, 0, 0);
+  return TCL_OK;
+}
+
+/*
+** During testing, the special md5sum() aggregate function is available.
+** inside SQLite.  The following routines implement that function.
+*/
+static void md5step(sqlite3_context *context, int argc, sqlite3_value **argv){
+  MD5Context *p;
+  int i;
+  if( argc<1 ) return;
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  if( p==0 ) return;
+  if( sqlite3_aggregate_count(context)==1 ){
+    MD5Init(p);
+  }
+  for(i=0; i<argc; i++){
+    const char *zData = (char*)sqlite3_value_text(argv[i]);
+    if( zData ){
+      MD5Update(p, (unsigned char*)zData, strlen(zData));
+    }
+  }
+}
+static void md5finalize(sqlite3_context *context){
+  MD5Context *p;
+  unsigned char digest[16];
+  char zBuf[33];
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  MD5Final(digest,p);
+  DigestToBase16(digest, zBuf);
+  sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+}
+void Md5_Register(sqlite3 *db){
+  sqlite3_create_function(db, "md5sum", -1, SQLITE_UTF8, 0, 0, 
+      md5step, md5finalize);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mem1.c b/client/src/thirdparty/sqlite-3.4.2/src/mem1.c
new file mode 100644
index 0000000..60ffc91
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mem1.c
@@ -0,0 +1,232 @@
+/*
+** 2007 August 14
+**
+** 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 the C functions that implement a memory
+** allocation subsystem for use by SQLite.  
+**
+** $Id: mem1.c,v 1.14 2007/11/29 18:36:49 drh Exp $
+*/
+
+/*
+** This version of the memory allocator is the default.  It is
+** used when no other memory allocator is specified using compile-time
+** macros.
+*/
+#if !defined(SQLITE_MEMDEBUG) && !defined(SQLITE_MEMORY_SIZE) \
+     && !defined(SQLITE_MMAP_HEAP_SIZE)
+
+/*
+** We will eventually construct multiple memory allocation subsystems
+** suitable for use in various contexts:
+**
+**    *  Normal multi-threaded builds
+**    *  Normal single-threaded builds
+**    *  Debugging builds
+**
+** This initial version is suitable for use in normal multi-threaded
+** builds.  We envision that alternative versions will be stored in
+** separate source files.  #ifdefs will be used to select the code from
+** one of the various memN.c source files for use in any given build.
+*/
+#include "sqliteInt.h"
+
+/*
+** All of the static variables used by this module are collected
+** into a single structure named "mem".  This is to keep the
+** static variables organized and to reduce namespace pollution
+** when this module is combined with other in the amalgamation.
+*/
+static struct {
+  /*
+  ** The alarm callback and its arguments.  The mem.mutex lock will
+  ** be held while the callback is running.  Recursive calls into
+  ** the memory subsystem are allowed, but no new callbacks will be
+  ** issued.  The alarmBusy variable is set to prevent recursive
+  ** callbacks.
+  */
+  sqlite3_int64 alarmThreshold;
+  void (*alarmCallback)(void*, sqlite3_int64,int);
+  void *alarmArg;
+  int alarmBusy;
+  
+  /*
+  ** Mutex to control access to the memory allocation subsystem.
+  */
+  sqlite3_mutex *mutex;
+  
+  /*
+  ** Current allocation and high-water mark.
+  */
+  sqlite3_int64 nowUsed;
+  sqlite3_int64 mxUsed;
+  
+ 
+} mem;
+
+/*
+** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
+*/
+static void enterMem(void){
+  if( mem.mutex==0 ){
+    mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
+  }
+  sqlite3_mutex_enter(mem.mutex);
+}
+
+/*
+** Return the amount of memory currently checked out.
+*/
+sqlite3_int64 sqlite3_memory_used(void){
+  sqlite3_int64 n;
+  enterMem();
+  n = mem.nowUsed;
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Return the maximum amount of memory that has ever been
+** checked out since either the beginning of this process
+** or since the most recent reset.
+*/
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
+  sqlite3_int64 n;
+  enterMem();
+  n = mem.mxUsed;
+  if( resetFlag ){
+    mem.mxUsed = mem.nowUsed;
+  }
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Change the alarm callback
+*/
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
+  void *pArg,
+  sqlite3_int64 iThreshold
+){
+  enterMem();
+  mem.alarmCallback = xCallback;
+  mem.alarmArg = pArg;
+  mem.alarmThreshold = iThreshold;
+  sqlite3_mutex_leave(mem.mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Trigger the alarm 
+*/
+static void sqlite3MemsysAlarm(int nByte){
+  void (*xCallback)(void*,sqlite3_int64,int);
+  sqlite3_int64 nowUsed;
+  void *pArg;
+  if( mem.alarmCallback==0 || mem.alarmBusy  ) return;
+  mem.alarmBusy = 1;
+  xCallback = mem.alarmCallback;
+  nowUsed = mem.nowUsed;
+  pArg = mem.alarmArg;
+  sqlite3_mutex_leave(mem.mutex);
+  xCallback(pArg, nowUsed, nByte);
+  sqlite3_mutex_enter(mem.mutex);
+  mem.alarmBusy = 0;
+}
+
+/*
+** Allocate nBytes of memory
+*/
+void *sqlite3_malloc(int nBytes){
+  sqlite3_int64 *p = 0;
+  if( nBytes>0 ){
+    enterMem();
+    if( mem.alarmCallback!=0 && mem.nowUsed+nBytes>=mem.alarmThreshold ){
+      sqlite3MemsysAlarm(nBytes);
+    }
+    p = malloc(nBytes+8);
+    if( p==0 ){
+      sqlite3MemsysAlarm(nBytes);
+      p = malloc(nBytes+8);
+    }
+    if( p ){
+      p[0] = nBytes;
+      p++;
+      mem.nowUsed += nBytes;
+      if( mem.nowUsed>mem.mxUsed ){
+        mem.mxUsed = mem.nowUsed;
+      }
+    }
+    sqlite3_mutex_leave(mem.mutex);
+  }
+  return (void*)p; 
+}
+
+/*
+** Free memory.
+*/
+void sqlite3_free(void *pPrior){
+  sqlite3_int64 *p;
+  int nByte;
+  if( pPrior==0 ){
+    return;
+  }
+  assert( mem.mutex!=0 );
+  p = pPrior;
+  p--;
+  nByte = (int)*p;
+  sqlite3_mutex_enter(mem.mutex);
+  mem.nowUsed -= nByte;
+  free(p);
+  sqlite3_mutex_leave(mem.mutex);  
+}
+
+/*
+** Change the size of an existing memory allocation
+*/
+void *sqlite3_realloc(void *pPrior, int nBytes){
+  int nOld;
+  sqlite3_int64 *p;
+  if( pPrior==0 ){
+    return sqlite3_malloc(nBytes);
+  }
+  if( nBytes<=0 ){
+    sqlite3_free(pPrior);
+    return 0;
+  }
+  p = pPrior;
+  p--;
+  nOld = (int)p[0];
+  assert( mem.mutex!=0 );
+  sqlite3_mutex_enter(mem.mutex);
+  if( mem.nowUsed+nBytes-nOld>=mem.alarmThreshold ){
+    sqlite3MemsysAlarm(nBytes-nOld);
+  }
+  p = realloc(p, nBytes+8);
+  if( p==0 ){
+    sqlite3MemsysAlarm(nBytes);
+    p = pPrior;
+    p--;
+    p = realloc(p, nBytes+8);
+  }
+  if( p ){
+    p[0] = nBytes;
+    p++;
+    mem.nowUsed += nBytes-nOld;
+    if( mem.nowUsed>mem.mxUsed ){
+      mem.mxUsed = mem.nowUsed;
+    }
+  }
+  sqlite3_mutex_leave(mem.mutex);
+  return (void*)p;
+}
+
+#endif /* !SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mem2.c b/client/src/thirdparty/sqlite-3.4.2/src/mem2.c
new file mode 100644
index 0000000..0c99c63
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mem2.c
@@ -0,0 +1,456 @@
+/*
+** 2007 August 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.
+**
+*************************************************************************
+** This file contains the C functions that implement a memory
+** allocation subsystem for use by SQLite.  
+**
+** $Id: mem2.c,v 1.19 2008/01/22 21:30:53 drh Exp $
+*/
+
+/*
+** This version of the memory allocator is used only if the
+** SQLITE_MEMDEBUG macro is defined and SQLITE_OMIT_MEMORY_ALLOCATION
+** is not defined.
+*/
+#if defined(SQLITE_MEMDEBUG)
+
+/*
+** We will eventually construct multiple memory allocation subsystems
+** suitable for use in various contexts:
+**
+**    *  Normal multi-threaded builds
+**    *  Normal single-threaded builds
+**    *  Debugging builds
+**
+** This version is suitable for use in debugging builds.
+**
+** Features:
+**
+**    * Every allocate has guards at both ends.
+**    * New allocations are initialized with randomness
+**    * Allocations are overwritten with randomness when freed
+**    * Optional logs of malloc activity generated
+**    * Summary of outstanding allocations with backtraces to the
+**      point of allocation.
+**    * The ability to simulate memory allocation failure
+*/
+#include "sqliteInt.h"
+#include <stdio.h>
+
+/*
+** The backtrace functionality is only available with GLIBC
+*/
+#ifdef __GLIBC__
+  extern int backtrace(void**,int);
+  extern void backtrace_symbols_fd(void*const*,int,int);
+#else
+# define backtrace(A,B) 0
+# define backtrace_symbols_fd(A,B,C)
+#endif
+
+/*
+** Each memory allocation looks like this:
+**
+**  ------------------------------------------------------------------------
+**  | Title |  backtrace pointers |  MemBlockHdr |  allocation |  EndGuard |
+**  ------------------------------------------------------------------------
+**
+** The application code sees only a pointer to the allocation.  We have
+** to back up from the allocation pointer to find the MemBlockHdr.  The
+** MemBlockHdr tells us the size of the allocation and the number of
+** backtrace pointers.  There is also a guard word at the end of the
+** MemBlockHdr.
+*/
+struct MemBlockHdr {
+  struct MemBlockHdr *pNext, *pPrev;  /* Linked list of all unfreed memory */
+  int iSize;                          /* Size of this allocation */
+  char nBacktrace;                    /* Number of backtraces on this alloc */
+  char nBacktraceSlots;               /* Available backtrace slots */
+  short nTitle;                       /* Bytes of title; includes '\0' */
+  int iForeGuard;                     /* Guard word for sanity */
+};
+
+/*
+** Guard words
+*/
+#define FOREGUARD 0x80F5E153
+#define REARGUARD 0xE4676B53
+
+/*
+** Number of malloc size increments to track.
+*/
+#define NCSIZE  1000
+
+/*
+** All of the static variables used by this module are collected
+** into a single structure named "mem".  This is to keep the
+** static variables organized and to reduce namespace pollution
+** when this module is combined with other in the amalgamation.
+*/
+static struct {
+  /*
+  ** The alarm callback and its arguments.  The mem.mutex lock will
+  ** be held while the callback is running.  Recursive calls into
+  ** the memory subsystem are allowed, but no new callbacks will be
+  ** issued.  The alarmBusy variable is set to prevent recursive
+  ** callbacks.
+  */
+  sqlite3_int64 alarmThreshold;
+  void (*alarmCallback)(void*, sqlite3_int64, int);
+  void *alarmArg;
+  int alarmBusy;
+  
+  /*
+  ** Mutex to control access to the memory allocation subsystem.
+  */
+  sqlite3_mutex *mutex;
+  
+  /*
+  ** Current allocation and high-water mark.
+  */
+  sqlite3_int64 nowUsed;
+  sqlite3_int64 mxUsed;
+  
+  /*
+  ** Head and tail of a linked list of all outstanding allocations
+  */
+  struct MemBlockHdr *pFirst;
+  struct MemBlockHdr *pLast;
+  
+  /*
+  ** The number of levels of backtrace to save in new allocations.
+  */
+  int nBacktrace;
+
+  /*
+  ** Title text to insert in front of each block
+  */
+  int nTitle;        /* Bytes of zTitle to save.  Includes '\0' and padding */
+  char zTitle[100];  /* The title text */
+
+  /* 
+  ** sqlite3MallocDisallow() increments the following counter.
+  ** sqlite3MallocAllow() decrements it.
+  */
+  int disallow; /* Do not allow memory allocation */
+
+  /*
+  ** Gather statistics on the sizes of memory allocations.
+  ** sizeCnt[i] is the number of allocation attempts of i*8
+  ** bytes.  i==NCSIZE is the number of allocation attempts for
+  ** sizes more than NCSIZE*8 bytes.
+  */
+  int sizeCnt[NCSIZE];
+
+} mem;
+
+
+/*
+** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
+*/
+static void enterMem(void){
+  if( mem.mutex==0 ){
+    mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
+  }
+  sqlite3_mutex_enter(mem.mutex);
+}
+
+/*
+** Return the amount of memory currently checked out.
+*/
+sqlite3_int64 sqlite3_memory_used(void){
+  sqlite3_int64 n;
+  enterMem();
+  n = mem.nowUsed;
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Return the maximum amount of memory that has ever been
+** checked out since either the beginning of this process
+** or since the most recent reset.
+*/
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
+  sqlite3_int64 n;
+  enterMem();
+  n = mem.mxUsed;
+  if( resetFlag ){
+    mem.mxUsed = mem.nowUsed;
+  }
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Change the alarm callback
+*/
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_int64 used, int N),
+  void *pArg,
+  sqlite3_int64 iThreshold
+){
+  enterMem();
+  mem.alarmCallback = xCallback;
+  mem.alarmArg = pArg;
+  mem.alarmThreshold = iThreshold;
+  sqlite3_mutex_leave(mem.mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Trigger the alarm 
+*/
+static void sqlite3MemsysAlarm(int nByte){
+  void (*xCallback)(void*,sqlite3_int64,int);
+  sqlite3_int64 nowUsed;
+  void *pArg;
+  if( mem.alarmCallback==0 || mem.alarmBusy  ) return;
+  mem.alarmBusy = 1;
+  xCallback = mem.alarmCallback;
+  nowUsed = mem.nowUsed;
+  pArg = mem.alarmArg;
+  sqlite3_mutex_leave(mem.mutex);
+  xCallback(pArg, nowUsed, nByte);
+  sqlite3_mutex_enter(mem.mutex);
+  mem.alarmBusy = 0;
+}
+
+/*
+** Given an allocation, find the MemBlockHdr for that allocation.
+**
+** This routine checks the guards at either end of the allocation and
+** if they are incorrect it asserts.
+*/
+static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
+  struct MemBlockHdr *p;
+  int *pInt;
+
+  p = (struct MemBlockHdr*)pAllocation;
+  p--;
+  assert( p->iForeGuard==FOREGUARD );
+  assert( (p->iSize & 3)==0 );
+  pInt = (int*)pAllocation;
+  assert( pInt[p->iSize/sizeof(int)]==REARGUARD );
+  return p;
+}
+
+/*
+** Allocate nByte bytes of memory.
+*/
+void *sqlite3_malloc(int nByte){
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  char *z;
+  int *pInt;
+  void *p = 0;
+  int totalSize;
+
+  if( nByte>0 ){
+    enterMem();
+    assert( mem.disallow==0 );
+    if( mem.alarmCallback!=0 && mem.nowUsed+nByte>=mem.alarmThreshold ){
+      sqlite3MemsysAlarm(nByte);
+    }
+    nByte = (nByte+3)&~3;
+    if( nByte/8>NCSIZE-1 ){
+      mem.sizeCnt[NCSIZE-1]++;
+    }else{
+      mem.sizeCnt[nByte/8]++;
+    }
+    totalSize = nByte + sizeof(*pHdr) + sizeof(int) +
+                 mem.nBacktrace*sizeof(void*) + mem.nTitle;
+    if( sqlite3FaultStep(SQLITE_FAULTINJECTOR_MALLOC) ){
+      p = 0;
+    }else{
+      p = malloc(totalSize);
+      if( p==0 ){
+        sqlite3MemsysAlarm(nByte);
+        p = malloc(totalSize);
+      }
+    }
+    if( p ){
+      z = p;
+      pBt = (void**)&z[mem.nTitle];
+      pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
+      pHdr->pNext = 0;
+      pHdr->pPrev = mem.pLast;
+      if( mem.pLast ){
+        mem.pLast->pNext = pHdr;
+      }else{
+        mem.pFirst = pHdr;
+      }
+      mem.pLast = pHdr;
+      pHdr->iForeGuard = FOREGUARD;
+      pHdr->nBacktraceSlots = mem.nBacktrace;
+      pHdr->nTitle = mem.nTitle;
+      if( mem.nBacktrace ){
+        void *aAddr[40];
+        pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
+        memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
+      }else{
+        pHdr->nBacktrace = 0;
+      }
+      if( mem.nTitle ){
+        memcpy(z, mem.zTitle, mem.nTitle);
+      }
+      pHdr->iSize = nByte;
+      pInt = (int*)&pHdr[1];
+      pInt[nByte/sizeof(int)] = REARGUARD;
+      memset(pInt, 0x65, nByte);
+      mem.nowUsed += nByte;
+      if( mem.nowUsed>mem.mxUsed ){
+        mem.mxUsed = mem.nowUsed;
+      }
+      p = (void*)pInt;
+    }
+    sqlite3_mutex_leave(mem.mutex);
+  }
+  return p; 
+}
+
+/*
+** Free memory.
+*/
+void sqlite3_free(void *pPrior){
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  char *z;
+  if( pPrior==0 ){
+    return;
+  }
+  assert( mem.mutex!=0 );
+  pHdr = sqlite3MemsysGetHeader(pPrior);
+  pBt = (void**)pHdr;
+  pBt -= pHdr->nBacktraceSlots;
+  sqlite3_mutex_enter(mem.mutex);
+  mem.nowUsed -= pHdr->iSize;
+  if( pHdr->pPrev ){
+    assert( pHdr->pPrev->pNext==pHdr );
+    pHdr->pPrev->pNext = pHdr->pNext;
+  }else{
+    assert( mem.pFirst==pHdr );
+    mem.pFirst = pHdr->pNext;
+  }
+  if( pHdr->pNext ){
+    assert( pHdr->pNext->pPrev==pHdr );
+    pHdr->pNext->pPrev = pHdr->pPrev;
+  }else{
+    assert( mem.pLast==pHdr );
+    mem.pLast = pHdr->pPrev;
+  }
+  z = (char*)pBt;
+  z -= pHdr->nTitle;
+  memset(z, 0x2b, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
+                  pHdr->iSize + sizeof(int) + pHdr->nTitle);
+  free(z);
+  sqlite3_mutex_leave(mem.mutex);  
+}
+
+/*
+** Change the size of an existing memory allocation.
+**
+** For this debugging implementation, we *always* make a copy of the
+** allocation into a new place in memory.  In this way, if the 
+** higher level code is using pointer to the old allocation, it is 
+** much more likely to break and we are much more liking to find
+** the error.
+*/
+void *sqlite3_realloc(void *pPrior, int nByte){
+  struct MemBlockHdr *pOldHdr;
+  void *pNew;
+  if( pPrior==0 ){
+    return sqlite3_malloc(nByte);
+  }
+  if( nByte<=0 ){
+    sqlite3_free(pPrior);
+    return 0;
+  }
+  assert( mem.disallow==0 );
+  pOldHdr = sqlite3MemsysGetHeader(pPrior);
+  pNew = sqlite3_malloc(nByte);
+  if( pNew ){
+    memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
+    if( nByte>pOldHdr->iSize ){
+      memset(&((char*)pNew)[pOldHdr->iSize], 0x2b, nByte - pOldHdr->iSize);
+    }
+    sqlite3_free(pPrior);
+  }
+  return pNew;
+}
+
+/*
+** Set the number of backtrace levels kept for each allocation.
+** A value of zero turns of backtracing.  The number is always rounded
+** up to a multiple of 2.
+*/
+void sqlite3_memdebug_backtrace(int depth){
+  if( depth<0 ){ depth = 0; }
+  if( depth>20 ){ depth = 20; }
+  depth = (depth+1)&0xfe;
+  mem.nBacktrace = depth;
+}
+
+/*
+** Set the title string for subsequent allocations.
+*/
+void sqlite3_memdebug_settitle(const char *zTitle){
+  int n = strlen(zTitle) + 1;
+  enterMem();
+  if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
+  memcpy(mem.zTitle, zTitle, n);
+  mem.zTitle[n] = 0;
+  mem.nTitle = (n+3)&~3;
+  sqlite3_mutex_leave(mem.mutex);
+}
+
+/*
+** Open the file indicated and write a log of all unfreed memory 
+** allocations into that log.
+*/
+void sqlite3_memdebug_dump(const char *zFilename){
+  FILE *out;
+  struct MemBlockHdr *pHdr;
+  void **pBt;
+  int i;
+  out = fopen(zFilename, "w");
+  if( out==0 ){
+    fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
+                    zFilename);
+    return;
+  }
+  for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
+    char *z = (char*)pHdr;
+    z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
+    fprintf(out, "**** %d bytes at %p from %s ****\n", 
+            pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
+    if( pHdr->nBacktrace ){
+      fflush(out);
+      pBt = (void**)pHdr;
+      pBt -= pHdr->nBacktraceSlots;
+      backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
+      fprintf(out, "\n");
+    }
+  }
+  fprintf(out, "COUNTS:\n");
+  for(i=0; i<NCSIZE-1; i++){
+    if( mem.sizeCnt[i] ){
+      fprintf(out, "   %3d: %d\n", i*8+8, mem.sizeCnt[i]);
+    }
+  }
+  if( mem.sizeCnt[NCSIZE-1] ){
+    fprintf(out, "  >%3d: %d\n", NCSIZE*8, mem.sizeCnt[NCSIZE-1]);
+  }
+  fclose(out);
+}
+
+
+#endif /* SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mem3.c b/client/src/thirdparty/sqlite-3.4.2/src/mem3.c
new file mode 100644
index 0000000..0d98372
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mem3.c
@@ -0,0 +1,653 @@
+/*
+** 2007 October 14
+**
+** 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 the C functions that implement a memory
+** allocation subsystem for use by SQLite. 
+**
+** This version of the memory allocation subsystem omits all
+** use of malloc().  All dynamically allocatable memory is
+** contained in a static array, mem.aPool[].  The size of this
+** fixed memory pool is SQLITE_MEMORY_SIZE bytes.
+**
+** This version of the memory allocation subsystem is used if
+** and only if SQLITE_MEMORY_SIZE is defined.
+**
+** $Id: mem3.c,v 1.8 2007/12/29 13:18:22 drh Exp $
+*/
+
+/*
+** This version of the memory allocator is used only when 
+** SQLITE_MEMORY_SIZE is defined.
+*/
+#if defined(SQLITE_MEMORY_SIZE)
+#include "sqliteInt.h"
+
+#ifdef SQLITE_MEMDEBUG
+# error  cannot define both SQLITE_MEMDEBUG and SQLITE_MEMORY_SIZE
+#endif
+
+/*
+** Maximum size (in Mem3Blocks) of a "small" chunk.
+*/
+#define MX_SMALL 10
+
+
+/*
+** Number of freelist hash slots
+*/
+#define N_HASH  61
+
+/*
+** A memory allocation (also called a "chunk") consists of two or 
+** more blocks where each block is 8 bytes.  The first 8 bytes are 
+** a header that is not returned to the user.
+**
+** A chunk is two or more blocks that is either checked out or
+** free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
+** size of the allocation in blocks if the allocation is free.
+** The u.hdr.size4x&1 bit is true if the chunk is checked out and
+** false if the chunk is on the freelist.  The u.hdr.size4x&2 bit
+** is true if the previous chunk is checked out and false if the
+** previous chunk is free.  The u.hdr.prevSize field is the size of
+** the previous chunk in blocks if the previous chunk is on the
+** freelist. If the previous chunk is checked out, then
+** u.hdr.prevSize can be part of the data for that chunk and should
+** not be read or written.
+**
+** We often identify a chunk by its index in mem.aPool[].  When
+** this is done, the chunk index refers to the second block of
+** the chunk.  In this way, the first chunk has an index of 1.
+** A chunk index of 0 means "no such chunk" and is the equivalent
+** of a NULL pointer.
+**
+** The second block of free chunks is of the form u.list.  The
+** two fields form a double-linked list of chunks of related sizes.
+** Pointers to the head of the list are stored in mem.aiSmall[] 
+** for smaller chunks and mem.aiHash[] for larger chunks.
+**
+** The second block of a chunk is user data if the chunk is checked 
+** out.  If a chunk is checked out, the user data may extend into
+** the u.hdr.prevSize value of the following chunk.
+*/
+typedef struct Mem3Block Mem3Block;
+struct Mem3Block {
+  union {
+    struct {
+      u32 prevSize;   /* Size of previous chunk in Mem3Block elements */
+      u32 size4x;     /* 4x the size of current chunk in Mem3Block elements */
+    } hdr;
+    struct {
+      u32 next;       /* Index in mem.aPool[] of next free chunk */
+      u32 prev;       /* Index in mem.aPool[] of previous free chunk */
+    } list;
+  } u;
+};
+
+/*
+** All of the static variables used by this module are collected
+** into a single structure named "mem".  This is to keep the
+** static variables organized and to reduce namespace pollution
+** when this module is combined with other in the amalgamation.
+*/
+static struct {
+  /*
+  ** True if we are evaluating an out-of-memory callback.
+  */
+  int alarmBusy;
+  
+  /*
+  ** Mutex to control access to the memory allocation subsystem.
+  */
+  sqlite3_mutex *mutex;
+  
+  /*
+  ** The minimum amount of free space that we have seen.
+  */
+  u32 mnMaster;
+
+  /*
+  ** iMaster is the index of the master chunk.  Most new allocations
+  ** occur off of this chunk.  szMaster is the size (in Mem3Blocks)
+  ** of the current master.  iMaster is 0 if there is not master chunk.
+  ** The master chunk is not in either the aiHash[] or aiSmall[].
+  */
+  u32 iMaster;
+  u32 szMaster;
+
+  /*
+  ** Array of lists of free blocks according to the block size 
+  ** for smaller chunks, or a hash on the block size for larger
+  ** chunks.
+  */
+  u32 aiSmall[MX_SMALL-1];   /* For sizes 2 through MX_SMALL, inclusive */
+  u32 aiHash[N_HASH];        /* For sizes MX_SMALL+1 and larger */
+
+  /*
+  ** Memory available for allocation
+  */
+  Mem3Block aPool[SQLITE_MEMORY_SIZE/sizeof(Mem3Block)+2];
+} mem;
+
+/*
+** Unlink the chunk at mem.aPool[i] from list it is currently
+** on.  *pRoot is the list that i is a member of.
+*/
+static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
+  u32 next = mem.aPool[i].u.list.next;
+  u32 prev = mem.aPool[i].u.list.prev;
+  assert( sqlite3_mutex_held(mem.mutex) );
+  if( prev==0 ){
+    *pRoot = next;
+  }else{
+    mem.aPool[prev].u.list.next = next;
+  }
+  if( next ){
+    mem.aPool[next].u.list.prev = prev;
+  }
+  mem.aPool[i].u.list.next = 0;
+  mem.aPool[i].u.list.prev = 0;
+}
+
+/*
+** Unlink the chunk at index i from 
+** whatever list is currently a member of.
+*/
+static void memsys3Unlink(u32 i){
+  u32 size, hash;
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 );
+  assert( i>=1 );
+  size = mem.aPool[i-1].u.hdr.size4x/4;
+  assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
+  assert( size>=2 );
+  if( size <= MX_SMALL ){
+    memsys3UnlinkFromList(i, &mem.aiSmall[size-2]);
+  }else{
+    hash = size % N_HASH;
+    memsys3UnlinkFromList(i, &mem.aiHash[hash]);
+  }
+}
+
+/*
+** Link the chunk at mem.aPool[i] so that is on the list rooted
+** at *pRoot.
+*/
+static void memsys3LinkIntoList(u32 i, u32 *pRoot){
+  assert( sqlite3_mutex_held(mem.mutex) );
+  mem.aPool[i].u.list.next = *pRoot;
+  mem.aPool[i].u.list.prev = 0;
+  if( *pRoot ){
+    mem.aPool[*pRoot].u.list.prev = i;
+  }
+  *pRoot = i;
+}
+
+/*
+** Link the chunk at index i into either the appropriate
+** small chunk list, or into the large chunk hash table.
+*/
+static void memsys3Link(u32 i){
+  u32 size, hash;
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( i>=1 );
+  assert( (mem.aPool[i-1].u.hdr.size4x & 1)==0 );
+  size = mem.aPool[i-1].u.hdr.size4x/4;
+  assert( size==mem.aPool[i+size-1].u.hdr.prevSize );
+  assert( size>=2 );
+  if( size <= MX_SMALL ){
+    memsys3LinkIntoList(i, &mem.aiSmall[size-2]);
+  }else{
+    hash = size % N_HASH;
+    memsys3LinkIntoList(i, &mem.aiHash[hash]);
+  }
+}
+
+/*
+** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
+**
+** Also:  Initialize the memory allocation subsystem the first time
+** this routine is called.
+*/
+static void memsys3Enter(void){
+  if( mem.mutex==0 ){
+    mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
+    mem.aPool[0].u.hdr.size4x = SQLITE_MEMORY_SIZE/2 + 2;
+    mem.aPool[SQLITE_MEMORY_SIZE/8].u.hdr.prevSize = SQLITE_MEMORY_SIZE/8;
+    mem.aPool[SQLITE_MEMORY_SIZE/8].u.hdr.size4x = 1;
+    mem.iMaster = 1;
+    mem.szMaster = SQLITE_MEMORY_SIZE/8;
+    mem.mnMaster = mem.szMaster;
+  }
+  sqlite3_mutex_enter(mem.mutex);
+}
+
+/*
+** Return the amount of memory currently checked out.
+*/
+sqlite3_int64 sqlite3_memory_used(void){
+  sqlite3_int64 n;
+  memsys3Enter();
+  n = SQLITE_MEMORY_SIZE - mem.szMaster*8;
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Return the maximum amount of memory that has ever been
+** checked out since either the beginning of this process
+** or since the most recent reset.
+*/
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
+  sqlite3_int64 n;
+  memsys3Enter();
+  n = SQLITE_MEMORY_SIZE - mem.mnMaster*8;
+  if( resetFlag ){
+    mem.mnMaster = mem.szMaster;
+  }
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Change the alarm callback.
+**
+** This is a no-op for the static memory allocator.  The purpose
+** of the memory alarm is to support sqlite3_soft_heap_limit().
+** But with this memory allocator, the soft_heap_limit is really
+** a hard limit that is fixed at SQLITE_MEMORY_SIZE.
+*/
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
+  void *pArg,
+  sqlite3_int64 iThreshold
+){
+  return SQLITE_OK;
+}
+
+/*
+** Called when we are unable to satisfy an allocation of nBytes.
+*/
+static void memsys3OutOfMemory(int nByte){
+  if( !mem.alarmBusy ){
+    mem.alarmBusy = 1;
+    assert( sqlite3_mutex_held(mem.mutex) );
+    sqlite3_mutex_leave(mem.mutex);
+    sqlite3_release_memory(nByte);
+    sqlite3_mutex_enter(mem.mutex);
+    mem.alarmBusy = 0;
+  }
+}
+
+/*
+** Return the size of an outstanding allocation, in bytes.  The
+** size returned omits the 8-byte header overhead.  This only
+** works for chunks that are currently checked out.
+*/
+static int memsys3Size(void *p){
+  Mem3Block *pBlock = (Mem3Block*)p;
+  assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
+  return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
+}
+
+/*
+** Chunk i is a free chunk that has been unlinked.  Adjust its 
+** size parameters for check-out and return a pointer to the 
+** user portion of the chunk.
+*/
+static void *memsys3Checkout(u32 i, int nBlock){
+  u32 x;
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( i>=1 );
+  assert( mem.aPool[i-1].u.hdr.size4x/4==nBlock );
+  assert( mem.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
+  x = mem.aPool[i-1].u.hdr.size4x;
+  mem.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
+  mem.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
+  mem.aPool[i+nBlock-1].u.hdr.size4x |= 2;
+  return &mem.aPool[i];
+}
+
+/*
+** Carve a piece off of the end of the mem.iMaster free chunk.
+** Return a pointer to the new allocation.  Or, if the master chunk
+** is not large enough, return 0.
+*/
+static void *memsys3FromMaster(int nBlock){
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( mem.szMaster>=nBlock );
+  if( nBlock>=mem.szMaster-1 ){
+    /* Use the entire master */
+    void *p = memsys3Checkout(mem.iMaster, mem.szMaster);
+    mem.iMaster = 0;
+    mem.szMaster = 0;
+    mem.mnMaster = 0;
+    return p;
+  }else{
+    /* Split the master block.  Return the tail. */
+    u32 newi, x;
+    newi = mem.iMaster + mem.szMaster - nBlock;
+    assert( newi > mem.iMaster+1 );
+    mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = nBlock;
+    mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x |= 2;
+    mem.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
+    mem.szMaster -= nBlock;
+    mem.aPool[newi-1].u.hdr.prevSize = mem.szMaster;
+    x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
+    mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
+    if( mem.szMaster < mem.mnMaster ){
+      mem.mnMaster = mem.szMaster;
+    }
+    return (void*)&mem.aPool[newi];
+  }
+}
+
+/*
+** *pRoot is the head of a list of free chunks of the same size
+** or same size hash.  In other words, *pRoot is an entry in either
+** mem.aiSmall[] or mem.aiHash[].  
+**
+** This routine examines all entries on the given list and tries
+** to coalesce each entries with adjacent free chunks.  
+**
+** If it sees a chunk that is larger than mem.iMaster, it replaces 
+** the current mem.iMaster with the new larger chunk.  In order for
+** this mem.iMaster replacement to work, the master chunk must be
+** linked into the hash tables.  That is not the normal state of
+** affairs, of course.  The calling routine must link the master
+** chunk before invoking this routine, then must unlink the (possibly
+** changed) master chunk once this routine has finished.
+*/
+static void memsys3Merge(u32 *pRoot){
+  u32 iNext, prev, size, i, x;
+
+  assert( sqlite3_mutex_held(mem.mutex) );
+  for(i=*pRoot; i>0; i=iNext){
+    iNext = mem.aPool[i].u.list.next;
+    size = mem.aPool[i-1].u.hdr.size4x;
+    assert( (size&1)==0 );
+    if( (size&2)==0 ){
+      memsys3UnlinkFromList(i, pRoot);
+      assert( i > mem.aPool[i-1].u.hdr.prevSize );
+      prev = i - mem.aPool[i-1].u.hdr.prevSize;
+      if( prev==iNext ){
+        iNext = mem.aPool[prev].u.list.next;
+      }
+      memsys3Unlink(prev);
+      size = i + size/4 - prev;
+      x = mem.aPool[prev-1].u.hdr.size4x & 2;
+      mem.aPool[prev-1].u.hdr.size4x = size*4 | x;
+      mem.aPool[prev+size-1].u.hdr.prevSize = size;
+      memsys3Link(prev);
+      i = prev;
+    }else{
+      size /= 4;
+    }
+    if( size>mem.szMaster ){
+      mem.iMaster = i;
+      mem.szMaster = size;
+    }
+  }
+}
+
+/*
+** Return a block of memory of at least nBytes in size.
+** Return NULL if unable.
+*/
+static void *memsys3Malloc(int nByte){
+  u32 i;
+  int nBlock;
+  int toFree;
+
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( sizeof(Mem3Block)==8 );
+  if( nByte<=12 ){
+    nBlock = 2;
+  }else{
+    nBlock = (nByte + 11)/8;
+  }
+  assert( nBlock >= 2 );
+
+  /* STEP 1:
+  ** Look for an entry of the correct size in either the small
+  ** chunk table or in the large chunk hash table.  This is
+  ** successful most of the time (about 9 times out of 10).
+  */
+  if( nBlock <= MX_SMALL ){
+    i = mem.aiSmall[nBlock-2];
+    if( i>0 ){
+      memsys3UnlinkFromList(i, &mem.aiSmall[nBlock-2]);
+      return memsys3Checkout(i, nBlock);
+    }
+  }else{
+    int hash = nBlock % N_HASH;
+    for(i=mem.aiHash[hash]; i>0; i=mem.aPool[i].u.list.next){
+      if( mem.aPool[i-1].u.hdr.size4x/4==nBlock ){
+        memsys3UnlinkFromList(i, &mem.aiHash[hash]);
+        return memsys3Checkout(i, nBlock);
+      }
+    }
+  }
+
+  /* STEP 2:
+  ** Try to satisfy the allocation by carving a piece off of the end
+  ** of the master chunk.  This step usually works if step 1 fails.
+  */
+  if( mem.szMaster>=nBlock ){
+    return memsys3FromMaster(nBlock);
+  }
+
+
+  /* STEP 3:  
+  ** Loop through the entire memory pool.  Coalesce adjacent free
+  ** chunks.  Recompute the master chunk as the largest free chunk.
+  ** Then try again to satisfy the allocation by carving a piece off
+  ** of the end of the master chunk.  This step happens very
+  ** rarely (we hope!)
+  */
+  for(toFree=nBlock*16; toFree<SQLITE_MEMORY_SIZE*2; toFree *= 2){
+    memsys3OutOfMemory(toFree);
+    if( mem.iMaster ){
+      memsys3Link(mem.iMaster);
+      mem.iMaster = 0;
+      mem.szMaster = 0;
+    }
+    for(i=0; i<N_HASH; i++){
+      memsys3Merge(&mem.aiHash[i]);
+    }
+    for(i=0; i<MX_SMALL-1; i++){
+      memsys3Merge(&mem.aiSmall[i]);
+    }
+    if( mem.szMaster ){
+      memsys3Unlink(mem.iMaster);
+      if( mem.szMaster>=nBlock ){
+        return memsys3FromMaster(nBlock);
+      }
+    }
+  }
+
+  /* If none of the above worked, then we fail. */
+  return 0;
+}
+
+/*
+** Free an outstanding memory allocation.
+*/
+void memsys3Free(void *pOld){
+  Mem3Block *p = (Mem3Block*)pOld;
+  int i;
+  u32 size, x;
+  assert( sqlite3_mutex_held(mem.mutex) );
+  assert( p>mem.aPool && p<&mem.aPool[SQLITE_MEMORY_SIZE/8] );
+  i = p - mem.aPool;
+  assert( (mem.aPool[i-1].u.hdr.size4x&1)==1 );
+  size = mem.aPool[i-1].u.hdr.size4x/4;
+  assert( i+size<=SQLITE_MEMORY_SIZE/8+1 );
+  mem.aPool[i-1].u.hdr.size4x &= ~1;
+  mem.aPool[i+size-1].u.hdr.prevSize = size;
+  mem.aPool[i+size-1].u.hdr.size4x &= ~2;
+  memsys3Link(i);
+
+  /* Try to expand the master using the newly freed chunk */
+  if( mem.iMaster ){
+    while( (mem.aPool[mem.iMaster-1].u.hdr.size4x&2)==0 ){
+      size = mem.aPool[mem.iMaster-1].u.hdr.prevSize;
+      mem.iMaster -= size;
+      mem.szMaster += size;
+      memsys3Unlink(mem.iMaster);
+      x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
+      mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
+      mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster;
+    }
+    x = mem.aPool[mem.iMaster-1].u.hdr.size4x & 2;
+    while( (mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x&1)==0 ){
+      memsys3Unlink(mem.iMaster+mem.szMaster);
+      mem.szMaster += mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size4x/4;
+      mem.aPool[mem.iMaster-1].u.hdr.size4x = mem.szMaster*4 | x;
+      mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster;
+    }
+  }
+}
+
+/*
+** Allocate nBytes of memory
+*/
+void *sqlite3_malloc(int nBytes){
+  sqlite3_int64 *p = 0;
+  if( nBytes>0 ){
+    memsys3Enter();
+    p = memsys3Malloc(nBytes);
+    sqlite3_mutex_leave(mem.mutex);
+  }
+  return (void*)p; 
+}
+
+/*
+** Free memory.
+*/
+void sqlite3_free(void *pPrior){
+  if( pPrior==0 ){
+    return;
+  }
+  assert( mem.mutex!=0 );
+  sqlite3_mutex_enter(mem.mutex);
+  memsys3Free(pPrior);
+  sqlite3_mutex_leave(mem.mutex);  
+}
+
+/*
+** Change the size of an existing memory allocation
+*/
+void *sqlite3_realloc(void *pPrior, int nBytes){
+  int nOld;
+  void *p;
+  if( pPrior==0 ){
+    return sqlite3_malloc(nBytes);
+  }
+  if( nBytes<=0 ){
+    sqlite3_free(pPrior);
+    return 0;
+  }
+  assert( mem.mutex!=0 );
+  nOld = memsys3Size(pPrior);
+  if( nBytes<=nOld && nBytes>=nOld-128 ){
+    return pPrior;
+  }
+  sqlite3_mutex_enter(mem.mutex);
+  p = memsys3Malloc(nBytes);
+  if( p ){
+    if( nOld<nBytes ){
+      memcpy(p, pPrior, nOld);
+    }else{
+      memcpy(p, pPrior, nBytes);
+    }
+    memsys3Free(pPrior);
+  }
+  sqlite3_mutex_leave(mem.mutex);
+  return p;
+}
+
+/*
+** Open the file indicated and write a log of all unfreed memory 
+** allocations into that log.
+*/
+void sqlite3_memdebug_dump(const char *zFilename){
+#ifdef SQLITE_DEBUG
+  FILE *out;
+  int i, j;
+  u32 size;
+  if( zFilename==0 || zFilename[0]==0 ){
+    out = stdout;
+  }else{
+    out = fopen(zFilename, "w");
+    if( out==0 ){
+      fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
+                      zFilename);
+      return;
+    }
+  }
+  memsys3Enter();
+  fprintf(out, "CHUNKS:\n");
+  for(i=1; i<=SQLITE_MEMORY_SIZE/8; i+=size/4){
+    size = mem.aPool[i-1].u.hdr.size4x;
+    if( size/4<=1 ){
+      fprintf(out, "%p size error\n", &mem.aPool[i]);
+      assert( 0 );
+      break;
+    }
+    if( (size&1)==0 && mem.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
+      fprintf(out, "%p tail size does not match\n", &mem.aPool[i]);
+      assert( 0 );
+      break;
+    }
+    if( ((mem.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
+      fprintf(out, "%p tail checkout bit is incorrect\n", &mem.aPool[i]);
+      assert( 0 );
+      break;
+    }
+    if( size&1 ){
+      fprintf(out, "%p %6d bytes checked out\n", &mem.aPool[i], (size/4)*8-8);
+    }else{
+      fprintf(out, "%p %6d bytes free%s\n", &mem.aPool[i], (size/4)*8-8,
+                  i==mem.iMaster ? " **master**" : "");
+    }
+  }
+  for(i=0; i<MX_SMALL-1; i++){
+    if( mem.aiSmall[i]==0 ) continue;
+    fprintf(out, "small(%2d):", i);
+    for(j = mem.aiSmall[i]; j>0; j=mem.aPool[j].u.list.next){
+      fprintf(out, " %p(%d)", &mem.aPool[j],
+              (mem.aPool[j-1].u.hdr.size4x/4)*8-8);
+    }
+    fprintf(out, "\n"); 
+  }
+  for(i=0; i<N_HASH; i++){
+    if( mem.aiHash[i]==0 ) continue;
+    fprintf(out, "hash(%2d):", i);
+    for(j = mem.aiHash[i]; j>0; j=mem.aPool[j].u.list.next){
+      fprintf(out, " %p(%d)", &mem.aPool[j],
+              (mem.aPool[j-1].u.hdr.size4x/4)*8-8);
+    }
+    fprintf(out, "\n"); 
+  }
+  fprintf(out, "master=%d\n", mem.iMaster);
+  fprintf(out, "nowUsed=%d\n", SQLITE_MEMORY_SIZE - mem.szMaster*8);
+  fprintf(out, "mxUsed=%d\n", SQLITE_MEMORY_SIZE - mem.mnMaster*8);
+  sqlite3_mutex_leave(mem.mutex);
+  if( out==stdout ){
+    fflush(stdout);
+  }else{
+    fclose(out);
+  }
+#endif
+}
+
+
+#endif /* !SQLITE_MEMORY_SIZE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mem4.c b/client/src/thirdparty/sqlite-3.4.2/src/mem4.c
new file mode 100644
index 0000000..7d861d4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mem4.c
@@ -0,0 +1,398 @@
+/*
+** 2007 August 14
+**
+** 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 the C functions that implement a memory
+** allocation subsystem for use by SQLite.  
+**
+** $Id: mem4.c,v 1.1 2007/11/29 18:36:49 drh Exp $
+*/
+
+/*
+** This version of the memory allocator attempts to obtain memory
+** from mmap() if the size of the allocation is close to the size
+** of a virtual memory page.  If the size of the allocation is different
+** from the virtual memory page size, then ordinary malloc() is used.
+** Ordinary malloc is also used if space allocated to mmap() is
+** exhausted.
+**
+** Enable this memory allocation by compiling with -DSQLITE_MMAP_HEAP_SIZE=nnn
+** where nnn is the maximum number of bytes of mmap-ed memory you want 
+** to support.   This module may choose to use less memory than requested.
+**
+*/
+#if defined(SQLITE_MMAP_HEAP_SIZE)
+
+#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE)
+# error cannot use SQLITE_MMAP_HEAP_SIZE with either SQLITE_MEMDEBUG \
+        or SQLITE_MEMORY_SIZE
+#endif
+
+/*
+** This is a test version of the memory allocator that attempts to
+** use mmap() and madvise() for allocations and frees of approximately
+** the virtual memory page size.
+*/
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include "sqliteInt.h"
+#include <unistd.h>
+
+
+/*
+** All of the static variables used by this module are collected
+** into a single structure named "mem".  This is to keep the
+** static variables organized and to reduce namespace pollution
+** when this module is combined with other in the amalgamation.
+*/
+static struct {
+  /*
+  ** The alarm callback and its arguments.  The mem.mutex lock will
+  ** be held while the callback is running.  Recursive calls into
+  ** the memory subsystem are allowed, but no new callbacks will be
+  ** issued.  The alarmBusy variable is set to prevent recursive
+  ** callbacks.
+  */
+  sqlite3_int64 alarmThreshold;
+  void (*alarmCallback)(void*, sqlite3_int64,int);
+  void *alarmArg;
+  int alarmBusy;
+  
+  /*
+  ** Mutex to control access to the memory allocation subsystem.
+  */
+  sqlite3_mutex *mutex;
+  
+  /*
+  ** Current allocation and high-water mark.
+  */
+  sqlite3_int64 nowUsed;
+  sqlite3_int64 mxUsed;
+
+  /*
+  ** Current allocation and high-water marks for mmap allocated memory.
+  */
+  sqlite3_int64 nowUsedMMap;
+  sqlite3_int64 mxUsedMMap;
+
+  /*
+  ** Size of a single mmap page.  Obtained from sysconf().
+  */
+  int szPage;
+  int mnPage;
+
+  /*
+  ** The number of available mmap pages.
+  */
+  int nPage;
+
+  /*
+  ** Index of the first free page.  0 means no pages have been freed.
+  */
+  int firstFree;
+
+  /* First unused page on the top of the heap.
+  */
+  int firstUnused;
+
+  /*
+  ** Bulk memory obtained from from mmap().
+  */
+  char *mmapHeap;   /* first byte of the heap */ 
+
+} mem;
+
+
+/*
+** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
+** The mmap() region is initialized the first time this routine is called.
+*/
+static void memsys4Enter(void){
+  if( mem.mutex==0 ){
+    mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);
+  }
+  sqlite3_mutex_enter(mem.mutex);
+}
+
+/*
+** Attempt to free memory to the mmap heap.  This only works if
+** the pointer p is within the range of memory addresses that
+** comprise the mmap heap.  Return 1 if the memory was freed
+** successfully.  Return 0 if the pointer is out of range.
+*/
+static int mmapFree(void *p){
+  char *z;
+  int idx, *a;
+  if( mem.mmapHeap==MAP_FAILED || mem.nPage==0 ){
+    return 0;
+  }
+  z = (char*)p;
+  idx = (z - mem.mmapHeap)/mem.szPage;
+  if( idx<1 || idx>=mem.nPage ){
+    return 0;
+  }
+  a = (int*)mem.mmapHeap;
+  a[idx] = a[mem.firstFree];
+  mem.firstFree = idx;
+  mem.nowUsedMMap -= mem.szPage;
+  madvise(p, mem.szPage, MADV_DONTNEED);
+  return 1;
+}
+
+/*
+** Attempt to allocate nBytes from the mmap heap.  Return a pointer
+** to the allocated page.  Or, return NULL if the allocation fails.
+** 
+** The allocation will fail if nBytes is not the right size.
+** Or, the allocation will fail if the mmap heap has been exhausted.
+*/
+static void *mmapAlloc(int nBytes){
+  int idx = 0;
+  if( nBytes>mem.szPage || nBytes<mem.mnPage ){
+    return 0;
+  }
+  if( mem.nPage==0 ){
+    mem.szPage = sysconf(_SC_PAGE_SIZE);
+    mem.mnPage = mem.szPage - mem.szPage/10;
+    mem.nPage = SQLITE_MMAP_HEAP_SIZE/mem.szPage;
+    if( mem.nPage * sizeof(int) > mem.szPage ){
+      mem.nPage = mem.szPage/sizeof(int);
+    }
+    mem.mmapHeap =  mmap(0, mem.szPage*mem.nPage, PROT_WRITE|PROT_READ,
+                         MAP_ANONYMOUS|MAP_SHARED, -1, 0);
+    if( mem.mmapHeap==MAP_FAILED ){
+      mem.firstUnused = errno;
+    }else{
+      mem.firstUnused = 1;
+      mem.nowUsedMMap = mem.szPage;
+    }
+  }
+  if( mem.mmapHeap==MAP_FAILED ){
+    return 0;
+  }
+  if( mem.firstFree ){
+    int idx = mem.firstFree;
+    int *a = (int*)mem.mmapHeap;
+    mem.firstFree = a[idx];
+  }else if( mem.firstUnused<mem.nPage ){
+    idx = mem.firstUnused++;
+  }
+  if( idx ){
+    mem.nowUsedMMap += mem.szPage;
+    if( mem.nowUsedMMap>mem.mxUsedMMap ){
+      mem.mxUsedMMap = mem.nowUsedMMap;
+    }
+    return (void*)&mem.mmapHeap[idx*mem.szPage];
+  }else{
+    return 0;
+  }
+}
+
+/*
+** Release the mmap-ed memory region if it is currently allocated and
+** is not in use.
+*/
+static void mmapUnmap(void){
+  if( mem.mmapHeap==MAP_FAILED ) return;
+  if( mem.nPage==0 ) return;
+  if( mem.nowUsedMMap>mem.szPage ) return;
+  munmap(mem.mmapHeap, mem.nPage*mem.szPage);
+  mem.nowUsedMMap = 0;
+  mem.nPage = 0;
+}
+    
+
+/*
+** Return the amount of memory currently checked out.
+*/
+sqlite3_int64 sqlite3_memory_used(void){
+  sqlite3_int64 n;
+  memsys4Enter();
+  n = mem.nowUsed + mem.nowUsedMMap;
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Return the maximum amount of memory that has ever been
+** checked out since either the beginning of this process
+** or since the most recent reset.
+*/
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
+  sqlite3_int64 n;
+  memsys4Enter();
+  n = mem.mxUsed + mem.mxUsedMMap;
+  if( resetFlag ){
+    mem.mxUsed = mem.nowUsed;
+    mem.mxUsedMMap = mem.nowUsedMMap;
+  }
+  sqlite3_mutex_leave(mem.mutex);  
+  return n;
+}
+
+/*
+** Change the alarm callback
+*/
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
+  void *pArg,
+  sqlite3_int64 iThreshold
+){
+  memsys4Enter();
+  mem.alarmCallback = xCallback;
+  mem.alarmArg = pArg;
+  mem.alarmThreshold = iThreshold;
+  sqlite3_mutex_leave(mem.mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Trigger the alarm 
+*/
+static void sqlite3MemsysAlarm(int nByte){
+  void (*xCallback)(void*,sqlite3_int64,int);
+  sqlite3_int64 nowUsed;
+  void *pArg;
+  if( mem.alarmCallback==0 || mem.alarmBusy  ) return;
+  mem.alarmBusy = 1;
+  xCallback = mem.alarmCallback;
+  nowUsed = mem.nowUsed;
+  pArg = mem.alarmArg;
+  sqlite3_mutex_leave(mem.mutex);
+  xCallback(pArg, nowUsed, nByte);
+  sqlite3_mutex_enter(mem.mutex);
+  mem.alarmBusy = 0;
+}
+
+/*
+** Allocate nBytes of memory
+*/
+static void *memsys4Malloc(int nBytes){
+  sqlite3_int64 *p = 0;
+  if( mem.alarmCallback!=0
+         && mem.nowUsed+mem.nowUsedMMap+nBytes>=mem.alarmThreshold ){
+    sqlite3MemsysAlarm(nBytes);
+  }
+  if( (p = mmapAlloc(nBytes))==0 ){
+    p = malloc(nBytes+8);
+    if( p==0 ){
+      sqlite3MemsysAlarm(nBytes);
+      p = malloc(nBytes+8);
+    }
+    if( p ){
+      p[0] = nBytes;
+      p++;
+      mem.nowUsed += nBytes;
+      if( mem.nowUsed>mem.mxUsed ){
+        mem.mxUsed = mem.nowUsed;
+      }
+    }
+  }
+  return (void*)p; 
+}
+
+/*
+** Return the size of a memory allocation
+*/
+static int memsys4Size(void *pPrior){
+  char *z = (char*)pPrior;
+  int idx = mem.nPage ? (z - mem.mmapHeap)/mem.szPage : 0;
+  int nByte;
+  if( idx>=1 && idx<mem.nPage ){
+    nByte = mem.szPage;
+  }else{
+    sqlite3_int64 *p = pPrior;
+    p--;
+    nByte = (int)*p;
+  }
+  return nByte;
+}
+
+/*
+** Free memory.
+*/
+static void memsys4Free(void *pPrior){
+  sqlite3_int64 *p;
+  int nByte;
+  if( mmapFree(pPrior)==0 ){
+    p = pPrior;
+    p--;
+    nByte = (int)*p;
+    mem.nowUsed -= nByte;
+    free(p);
+    if( mem.nowUsed==0 ){
+      mmapUnmap();
+    }      
+  }
+}
+
+/*
+** Allocate nBytes of memory
+*/
+void *sqlite3_malloc(int nBytes){
+  sqlite3_int64 *p = 0;
+  if( nBytes>0 ){
+    memsys4Enter();
+    p = memsys4Malloc(nBytes);
+    sqlite3_mutex_leave(mem.mutex);
+  }
+  return (void*)p; 
+}
+
+/*
+** Free memory.
+*/
+void sqlite3_free(void *pPrior){
+  if( pPrior==0 ){
+    return;
+  }
+  assert( mem.mutex!=0 );
+  sqlite3_mutex_enter(mem.mutex);
+  memsys4Free(pPrior);
+  sqlite3_mutex_leave(mem.mutex);  
+}
+
+
+
+/*
+** Change the size of an existing memory allocation
+*/
+void *sqlite3_realloc(void *pPrior, int nBytes){
+  int nOld;
+  sqlite3_int64 *p;
+  if( pPrior==0 ){
+    return sqlite3_malloc(nBytes);
+  }
+  if( nBytes<=0 ){
+    sqlite3_free(pPrior);
+    return 0;
+  }
+  nOld = memsys4Size(pPrior);
+  if( nBytes<=nOld && nBytes>=nOld-128 ){
+    return pPrior;
+  }
+  assert( mem.mutex!=0 );
+  sqlite3_mutex_enter(mem.mutex);
+  p = memsys4Malloc(nBytes);
+  if( p ){
+    if( nOld<nBytes ){
+      memcpy(p, pPrior, nOld);
+    }else{
+      memcpy(p, pPrior, nBytes);
+    }
+    memsys4Free(pPrior);
+  }
+  assert( mem.mutex!=0 );
+  sqlite3_mutex_leave(mem.mutex);
+  return (void*)p;
+}
+
+#endif /* !SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mutex.c b/client/src/thirdparty/sqlite-3.4.2/src/mutex.c
new file mode 100644
index 0000000..5815ff2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mutex.c
@@ -0,0 +1,126 @@
+/*
+** 2007 August 14
+**
+** 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 the C functions that implement mutexes.
+**
+** The implementation in this file does not provide any mutual
+** exclusion and is thus suitable for use only in applications
+** that use SQLite in a single thread.  But this implementation
+** does do a lot of error checking on mutexes to make sure they
+** are called correctly and at appropriate times.  Hence, this
+** implementation is suitable for testing.
+** debugging purposes
+**
+** $Id: mutex.c,v 1.16 2007/09/10 16:13:00 danielk1977 Exp $
+*/
+#include "sqliteInt.h"
+
+#ifdef SQLITE_MUTEX_NOOP_DEBUG
+/*
+** In this implementation, mutexes do not provide any mutual exclusion.
+** But the error checking is provided.  This implementation is useful
+** for test purposes.
+*/
+
+/*
+** The mutex object
+*/
+struct sqlite3_mutex {
+  int id;     /* The mutex type */
+  int cnt;    /* Number of entries without a matching leave */
+};
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated. 
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int id){
+  static sqlite3_mutex aStatic[5];
+  sqlite3_mutex *pNew = 0;
+  switch( id ){
+    case SQLITE_MUTEX_FAST:
+    case SQLITE_MUTEX_RECURSIVE: {
+      pNew = sqlite3_malloc(sizeof(*pNew));
+      if( pNew ){
+        pNew->id = id;
+        pNew->cnt = 0;
+      }
+      break;
+    }
+    default: {
+      assert( id-2 >= 0 );
+      assert( id-2 < sizeof(aStatic)/sizeof(aStatic[0]) );
+      pNew = &aStatic[id-2];
+      pNew->id = id;
+      break;
+    }
+  }
+  return pNew;
+}
+
+/*
+** This routine deallocates a previously allocated mutex.
+*/
+void sqlite3_mutex_free(sqlite3_mutex *p){
+  assert( p );
+  assert( p->cnt==0 );
+  assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
+  sqlite3_free(p);
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+void sqlite3_mutex_enter(sqlite3_mutex *p){
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  p->cnt++;
+}
+int sqlite3_mutex_try(sqlite3_mutex *p){
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  p->cnt++;
+  return SQLITE_OK;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+void sqlite3_mutex_leave(sqlite3_mutex *p){
+  assert( p );
+  assert( sqlite3_mutex_held(p) );
+  p->cnt--;
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+}
+
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use inside assert() statements.
+*/
+int sqlite3_mutex_held(sqlite3_mutex *p){
+  return p==0 || p->cnt>0;
+}
+int sqlite3_mutex_notheld(sqlite3_mutex *p){
+  return p==0 || p->cnt==0;
+}
+#endif /* SQLITE_MUTEX_NOOP_DEBUG */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mutex.h b/client/src/thirdparty/sqlite-3.4.2/src/mutex.h
new file mode 100644
index 0000000..e7ec9d2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mutex.h
@@ -0,0 +1,82 @@
+/*
+** 2007 August 28
+**
+** 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 the common header for all mutex implementations.
+** The sqliteInt.h header #includes this file so that it is available
+** to all source files.  We break it out in an effort to keep the code
+** better organized.
+**
+** NOTE:  source files should *not* #include this header file directly.
+** Source files should #include the sqliteInt.h file and let that file
+** include this one indirectly.
+**
+** $Id: mutex.h,v 1.2 2007/08/30 14:10:30 drh Exp $
+*/
+
+
+#ifdef SQLITE_MUTEX_APPDEF
+/*
+** If SQLITE_MUTEX_APPDEF is defined, then this whole module is
+** omitted and equivalent functionality must be provided by the
+** application that links against the SQLite library.
+*/
+#else
+/*
+** Figure out what version of the code to use.  The choices are
+**
+**   SQLITE_MUTEX_NOOP         For single-threaded applications that
+**                             do not desire error checking.
+**
+**   SQLITE_MUTEX_NOOP_DEBUG   For single-threaded applications with
+**                             error checking to help verify that mutexes
+**                             are being used correctly even though they
+**                             are not needed.  Used when SQLITE_DEBUG is
+**                             defined on single-threaded builds.
+**
+**   SQLITE_MUTEX_PTHREADS     For multi-threaded applications on Unix.
+**
+**   SQLITE_MUTEX_W32          For multi-threaded applications on Win32.
+**
+**   SQLITE_MUTEX_OS2          For multi-threaded applications on OS/2.
+*/
+#define SQLITE_MUTEX_NOOP 1   /* The default */
+#if defined(SQLITE_DEBUG) && !SQLITE_THREADSAFE
+# undef SQLITE_MUTEX_NOOP
+# define SQLITE_MUTEX_NOOP_DEBUG
+#endif
+#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_UNIX
+# undef SQLITE_MUTEX_NOOP
+# define SQLITE_MUTEX_PTHREADS
+#endif
+#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_WIN
+# undef SQLITE_MUTEX_NOOP
+# define SQLITE_MUTEX_W32
+#endif
+#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_OS2
+# undef SQLITE_MUTEX_NOOP
+# define SQLITE_MUTEX_OS2
+#endif
+
+#ifdef SQLITE_MUTEX_NOOP
+/*
+** If this is a no-op implementation, implement everything as macros.
+*/
+#define sqlite3_mutex_alloc(X)    ((sqlite3_mutex*)8)
+#define sqlite3_mutex_free(X)
+#define sqlite3_mutex_enter(X)
+#define sqlite3_mutex_try(X)      SQLITE_OK
+#define sqlite3_mutex_leave(X)
+#define sqlite3_mutex_held(X)     1
+#define sqlite3_mutex_notheld(X)  1
+#endif
+
+#endif /* SQLITE_MUTEX_APPDEF */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mutex_os2.c b/client/src/thirdparty/sqlite-3.4.2/src/mutex_os2.c
new file mode 100644
index 0000000..cbffeee
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mutex_os2.c
@@ -0,0 +1,245 @@
+/*
+** 2007 August 28
+**
+** 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 the C functions that implement mutexes for OS/2
+**
+** $Id: mutex_os2.c,v 1.5 2008/02/01 19:42:38 pweilbacher Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** The code in this file is only used if SQLITE_MUTEX_OS2 is defined.
+** See the mutex.h file for details.
+*/
+#ifdef SQLITE_MUTEX_OS2
+
+/********************** OS/2 Mutex Implementation **********************
+**
+** This implementation of mutexes is built using the OS/2 API.
+*/
+
+/*
+** The mutex object
+** Each recursive mutex is an instance of the following structure.
+*/
+struct sqlite3_mutex {
+  HMTX mutex;       /* Mutex controlling the lock */
+  int  id;          /* Mutex type */
+  int  nRef;        /* Number of references */
+  TID  owner;       /* Thread holding this mutex */
+};
+
+#define OS2_MUTEX_INITIALIZER   0,0,0,0
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated. 
+** SQLite will unwind its stack and return an error.  The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST               0
+** <li>  SQLITE_MUTEX_RECURSIVE          1
+** <li>  SQLITE_MUTEX_STATIC_MASTER      2
+** <li>  SQLITE_MUTEX_STATIC_MEM         3
+** <li>  SQLITE_MUTEX_STATIC_PRNG        4
+** </ul>
+**
+** The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  But SQLite will only request a recursive mutex in
+** cases where it really needs one.  If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex.  Three static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  But for the static
+** mutex types, the same mutex is returned on every call that has
+** the same type number.
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int iType){
+  sqlite3_mutex *p = NULL;
+  switch( iType ){
+    case SQLITE_MUTEX_FAST:
+    case SQLITE_MUTEX_RECURSIVE: {
+      p = sqlite3MallocZero( sizeof(*p) );
+      if( p ){
+        p->id = iType;
+        if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){
+          sqlite3_free( p );
+          p = NULL;
+        }
+      }
+      break;
+    }
+    default: {
+      static volatile int isInit = 0;
+      static sqlite3_mutex staticMutexes[] = {
+        { OS2_MUTEX_INITIALIZER, },
+        { OS2_MUTEX_INITIALIZER, },
+        { OS2_MUTEX_INITIALIZER, },
+        { OS2_MUTEX_INITIALIZER, },
+        { OS2_MUTEX_INITIALIZER, },
+      };
+      if ( !isInit ){
+        APIRET rc;
+        PTIB ptib;
+        PPIB ppib;
+        HMTX mutex;
+        char name[32];
+        DosGetInfoBlocks( &ptib, &ppib );
+        sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",
+                          ppib->pib_ulpid );
+        while( !isInit ){
+          mutex = 0;
+          rc = DosCreateMutexSem( name, &mutex, 0, FALSE);
+          if( rc == NO_ERROR ){
+            int i;
+            if( !isInit ){
+              for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
+                DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );
+              }
+              isInit = 1;
+            }
+            DosCloseMutexSem( mutex );
+          }else if( rc == ERROR_DUPLICATE_NAME ){
+            DosSleep( 1 );
+          }else{
+            return p;
+          }
+        }
+      }
+      assert( iType-2 >= 0 );
+      assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
+      p = &staticMutexes[iType-2];
+      p->id = iType;
+      break;
+    }
+  }
+  return p;
+}
+
+
+/*
+** This routine deallocates a previously allocated mutex.
+** SQLite is careful to deallocate every mutex that it allocates.
+*/
+void sqlite3_mutex_free(sqlite3_mutex *p){
+  assert( p );
+  assert( p->nRef==0 );
+  assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
+  DosCloseMutexSem( p->mutex );
+  sqlite3_free( p );
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+void sqlite3_mutex_enter(sqlite3_mutex *p){
+  TID tid;
+  PID holder1;
+  ULONG holder2;
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);
+  DosQueryMutexSem(p->mutex, &holder1, &tid, &holder2);
+  p->owner = tid;
+  p->nRef++;
+}
+int sqlite3_mutex_try(sqlite3_mutex *p){
+  int rc;
+  TID tid;
+  PID holder1;
+  ULONG holder2;
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR) {
+    DosQueryMutexSem(p->mutex, &holder1, &tid, &holder2);
+    p->owner = tid;
+    p->nRef++;
+    rc = SQLITE_OK;
+  } else {
+    rc = SQLITE_BUSY;
+  }
+
+  return rc;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+void sqlite3_mutex_leave(sqlite3_mutex *p){
+  TID tid;
+  PID holder1;
+  ULONG holder2;
+  assert( p->nRef>0 );
+  DosQueryMutexSem(p->mutex, &holder1, &tid, &holder2);
+  assert( p->owner==tid );
+  p->nRef--;
+  assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
+  DosReleaseMutexSem(p->mutex);
+}
+
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use inside assert() statements.
+*/
+int sqlite3_mutex_held(sqlite3_mutex *p){
+  TID tid;
+  PID pid;
+  ULONG ulCount;
+  PTIB ptib;
+  if( p!=0 ) {
+    DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
+  } else {
+    DosGetInfoBlocks(&ptib, NULL);
+    tid = ptib->tib_ptib2->tib2_ultid;
+  }
+  return p==0 || (p->nRef!=0 && p->owner==tid);
+}
+int sqlite3_mutex_notheld(sqlite3_mutex *p){
+  TID tid;
+  PID pid;
+  ULONG ulCount;
+  PTIB ptib;
+  if( p!= 0 ) {
+    DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
+  } else {
+    DosGetInfoBlocks(&ptib, NULL);
+    tid = ptib->tib_ptib2->tib2_ultid;
+  }
+  return p==0 || p->nRef==0 || p->owner!=tid;
+}
+#endif /* SQLITE_MUTEX_OS2 */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mutex_unix.c b/client/src/thirdparty/sqlite-3.4.2/src/mutex_unix.c
new file mode 100644
index 0000000..93e7e9a
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mutex_unix.c
@@ -0,0 +1,298 @@
+/*
+** 2007 August 28
+**
+** 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 the C functions that implement mutexes for pthreads
+**
+** $Id: mutex_unix.c,v 1.5 2007/11/28 14:04:57 drh Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** The code in this file is only used if we are compiling threadsafe
+** under unix with pthreads.
+**
+** Note that this implementation requires a version of pthreads that
+** supports recursive mutexes.
+*/
+#ifdef SQLITE_MUTEX_PTHREADS
+
+#include <pthread.h>
+
+
+/*
+** Each recursive mutex is an instance of the following structure.
+*/
+struct sqlite3_mutex {
+  pthread_mutex_t mutex;     /* Mutex controlling the lock */
+  int id;                    /* Mutex type */
+  int nRef;                  /* Number of entrances */
+  pthread_t owner;           /* Thread that is within this mutex */
+#ifdef SQLITE_DEBUG
+  int trace;                 /* True to trace changes */
+#endif
+};
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated.  SQLite
+** will unwind its stack and return an error.  The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST
+** <li>  SQLITE_MUTEX_RECURSIVE
+** <li>  SQLITE_MUTEX_STATIC_MASTER
+** <li>  SQLITE_MUTEX_STATIC_MEM
+** <li>  SQLITE_MUTEX_STATIC_MEM2
+** <li>  SQLITE_MUTEX_STATIC_PRNG
+** <li>  SQLITE_MUTEX_STATIC_LRU
+** </ul>
+**
+** The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  But SQLite will only request a recursive mutex in
+** cases where it really needs one.  If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex.  Three static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  But for the static 
+** mutex types, the same mutex is returned on every call that has
+** the same type number.
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int iType){
+  static sqlite3_mutex staticMutexes[] = {
+    { PTHREAD_MUTEX_INITIALIZER, },
+    { PTHREAD_MUTEX_INITIALIZER, },
+    { PTHREAD_MUTEX_INITIALIZER, },
+    { PTHREAD_MUTEX_INITIALIZER, },
+    { PTHREAD_MUTEX_INITIALIZER, },
+  };
+  sqlite3_mutex *p;
+  switch( iType ){
+    case SQLITE_MUTEX_RECURSIVE: {
+      p = sqlite3MallocZero( sizeof(*p) );
+      if( p ){
+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
+        /* If recursive mutexes are not available, we will have to
+        ** build our own.  See below. */
+        pthread_mutex_init(&p->mutex, 0);
+#else
+        /* Use a recursive mutex if it is available */
+        pthread_mutexattr_t recursiveAttr;
+        pthread_mutexattr_init(&recursiveAttr);
+        pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
+        pthread_mutex_init(&p->mutex, &recursiveAttr);
+        pthread_mutexattr_destroy(&recursiveAttr);
+#endif
+        p->id = iType;
+      }
+      break;
+    }
+    case SQLITE_MUTEX_FAST: {
+      p = sqlite3MallocZero( sizeof(*p) );
+      if( p ){
+        p->id = iType;
+        pthread_mutex_init(&p->mutex, 0);
+      }
+      break;
+    }
+    default: {
+      assert( iType-2 >= 0 );
+      assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
+      p = &staticMutexes[iType-2];
+      p->id = iType;
+      break;
+    }
+  }
+  return p;
+}
+
+
+/*
+** This routine deallocates a previously
+** allocated mutex.  SQLite is careful to deallocate every
+** mutex that it allocates.
+*/
+void sqlite3_mutex_free(sqlite3_mutex *p){
+  assert( p );
+  assert( p->nRef==0 );
+  assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
+  pthread_mutex_destroy(&p->mutex);
+  sqlite3_free(p);
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+void sqlite3_mutex_enter(sqlite3_mutex *p){
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+
+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
+  /* If recursive mutexes are not available, then we have to grow
+  ** our own.  This implementation assumes that pthread_equal()
+  ** is atomic - that it cannot be deceived into thinking self
+  ** and p->owner are equal if p->owner changes between two values
+  ** that are not equal to self while the comparison is taking place.
+  ** This implementation also assumes a coherent cache - that 
+  ** separate processes cannot read different values from the same
+  ** address at the same time.  If either of these two conditions
+  ** are not met, then the mutexes will fail and problems will result.
+  */
+  {
+    pthread_t self = pthread_self();
+    if( p->nRef>0 && pthread_equal(p->owner, self) ){
+      p->nRef++;
+    }else{
+      pthread_mutex_lock(&p->mutex);
+      assert( p->nRef==0 );
+      p->owner = self;
+      p->nRef = 1;
+    }
+  }
+#else
+  /* Use the built-in recursive mutexes if they are available.
+  */
+  pthread_mutex_lock(&p->mutex);
+  p->owner = pthread_self();
+  p->nRef++;
+#endif
+
+#ifdef SQLITE_DEBUG
+  if( p->trace ){
+    printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+}
+int sqlite3_mutex_try(sqlite3_mutex *p){
+  int rc;
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+
+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
+  /* If recursive mutexes are not available, then we have to grow
+  ** our own.  This implementation assumes that pthread_equal()
+  ** is atomic - that it cannot be deceived into thinking self
+  ** and p->owner are equal if p->owner changes between two values
+  ** that are not equal to self while the comparison is taking place.
+  ** This implementation also assumes a coherent cache - that 
+  ** separate processes cannot read different values from the same
+  ** address at the same time.  If either of these two conditions
+  ** are not met, then the mutexes will fail and problems will result.
+  */
+  {
+    pthread_t self = pthread_self();
+    if( p->nRef>0 && pthread_equal(p->owner, self) ){
+      p->nRef++;
+      rc = SQLITE_OK;
+    }else if( pthread_mutex_lock(&p->mutex)==0 ){
+      assert( p->nRef==0 );
+      p->owner = self;
+      p->nRef = 1;
+      rc = SQLITE_OK;
+    }else{
+      rc = SQLITE_BUSY;
+    }
+  }
+#else
+  /* Use the built-in recursive mutexes if they are available.
+  */
+  if( pthread_mutex_trylock(&p->mutex)==0 ){
+    p->owner = pthread_self();
+    p->nRef++;
+    rc = SQLITE_OK;
+  }else{
+    rc = SQLITE_BUSY;
+  }
+#endif
+
+#ifdef SQLITE_DEBUG
+  if( rc==SQLITE_OK && p->trace ){
+    printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+  return rc;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+void sqlite3_mutex_leave(sqlite3_mutex *p){
+  assert( p );
+  assert( sqlite3_mutex_held(p) );
+  p->nRef--;
+  assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
+
+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
+  if( p->nRef==0 ){
+    pthread_mutex_unlock(&p->mutex);
+  }
+#else
+  pthread_mutex_unlock(&p->mutex);
+#endif
+
+#ifdef SQLITE_DEBUG
+  if( p->trace ){
+    printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
+  }
+#endif
+}
+
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use only inside assert() statements.  On some platforms,
+** there might be race conditions that can cause these routines to
+** deliver incorrect results.  In particular, if pthread_equal() is
+** not an atomic operation, then these routines might delivery
+** incorrect results.  On most platforms, pthread_equal() is a 
+** comparison of two integers and is therefore atomic.  But we are
+** told that HPUX is not such a platform.  If so, then these routines
+** will not always work correctly on HPUX.
+**
+** On those platforms where pthread_equal() is not atomic, SQLite
+** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
+** make sure no assert() statements are evaluated and hence these
+** routines are never called.
+*/
+#ifndef NDEBUG
+int sqlite3_mutex_held(sqlite3_mutex *p){
+  return p==0 || (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
+}
+int sqlite3_mutex_notheld(sqlite3_mutex *p){
+  return p==0 || p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
+}
+#endif
+#endif /* SQLITE_MUTEX_PTHREAD */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/mutex_w32.c b/client/src/thirdparty/sqlite-3.4.2/src/mutex_w32.c
new file mode 100644
index 0000000..1944ccc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/mutex_w32.c
@@ -0,0 +1,219 @@
+/*
+** 2007 August 14
+**
+** 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 the C functions that implement mutexes for win32
+**
+** $Id: mutex_w32.c,v 1.5 2007/10/05 15:08:01 drh Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** The code in this file is only used if we are compiling multithreaded
+** on a win32 system.
+*/
+#ifdef SQLITE_MUTEX_W32
+
+/*
+** Each recursive mutex is an instance of the following structure.
+*/
+struct sqlite3_mutex {
+  CRITICAL_SECTION mutex;    /* Mutex controlling the lock */
+  int id;                    /* Mutex type */
+  int nRef;                  /* Number of enterances */
+  DWORD owner;               /* Thread holding this mutex */
+};
+
+/*
+** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
+** or WinCE.  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.
+*/
+#if OS_WINCE
+# define mutexIsNT()  (1)
+#else
+  static int mutexIsNT(void){
+    static int osType = 0;
+    if( osType==0 ){
+      OSVERSIONINFO sInfo;
+      sInfo.dwOSVersionInfoSize = sizeof(sInfo);
+      GetVersionEx(&sInfo);
+      osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
+    }
+    return osType==2;
+  }
+#endif /* OS_WINCE */
+
+
+/*
+** The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it.  If it returns NULL
+** that means that a mutex could not be allocated.  SQLite
+** will unwind its stack and return an error.  The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST               0
+** <li>  SQLITE_MUTEX_RECURSIVE          1
+** <li>  SQLITE_MUTEX_STATIC_MASTER      2
+** <li>  SQLITE_MUTEX_STATIC_MEM         3
+** <li>  SQLITE_MUTEX_STATIC_PRNG        4
+** </ul>
+**
+** The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  But SQLite will only request a recursive mutex in
+** cases where it really needs one.  If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex.  Three static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  But for the static 
+** mutex types, the same mutex is returned on every call that has
+** the same type number.
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int iType){
+  sqlite3_mutex *p;
+
+  switch( iType ){
+    case SQLITE_MUTEX_FAST:
+    case SQLITE_MUTEX_RECURSIVE: {
+      p = sqlite3MallocZero( sizeof(*p) );
+      if( p ){
+        p->id = iType;
+        InitializeCriticalSection(&p->mutex);
+      }
+      break;
+    }
+    default: {
+      static sqlite3_mutex staticMutexes[5];
+      static int isInit = 0;
+      while( !isInit ){
+        static long lock = 0;
+        if( InterlockedIncrement(&lock)==1 ){
+          int i;
+          for(i=0; i<sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++){
+            InitializeCriticalSection(&staticMutexes[i].mutex);
+          }
+          isInit = 1;
+        }else{
+          Sleep(1);
+        }
+      }
+      assert( iType-2 >= 0 );
+      assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
+      p = &staticMutexes[iType-2];
+      p->id = iType;
+      break;
+    }
+  }
+  return p;
+}
+
+
+/*
+** This routine deallocates a previously
+** allocated mutex.  SQLite is careful to deallocate every
+** mutex that it allocates.
+*/
+void sqlite3_mutex_free(sqlite3_mutex *p){
+  assert( p );
+  assert( p->nRef==0 );
+  assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
+  DeleteCriticalSection(&p->mutex);
+  sqlite3_free(p);
+}
+
+/*
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex.  If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
+** be entered multiple times by the same thread.  In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  If the same thread tries to enter any other kind of mutex
+** more than once, the behavior is undefined.
+*/
+void sqlite3_mutex_enter(sqlite3_mutex *p){
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  EnterCriticalSection(&p->mutex);
+  p->owner = GetCurrentThreadId(); 
+  p->nRef++;
+}
+int sqlite3_mutex_try(sqlite3_mutex *p){
+  int rc = SQLITE_BUSY;
+  assert( p );
+  assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
+  /*
+  ** The sqlite3_mutex_try() routine is very rarely used, and when it
+  ** is used it is merely an optimization.  So it is OK for it to always
+  ** fail.  
+  **
+  ** The TryEnterCriticalSection() interface is only available on WinNT.
+  ** And some windows compilers complain if you try to use it without
+  ** first doing some #defines that prevent SQLite from building on Win98.
+  ** For that reason, we will omit this optimization for now.  See
+  ** ticket #2685.
+  */
+#if 0
+  if( mutexIsNT() && TryEnterCriticalSection(&p->mutex) ){
+    p->owner = GetCurrentThreadId();
+    p->nRef++;
+    rc = SQLITE_OK;
+  }
+#endif
+  return rc;
+}
+
+/*
+** The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  The behavior
+** is undefined if the mutex is not currently entered or
+** is not currently allocated.  SQLite will never do either.
+*/
+void sqlite3_mutex_leave(sqlite3_mutex *p){
+  assert( p->nRef>0 );
+  assert( p->owner==GetCurrentThreadId() );
+  p->nRef--;
+  assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
+  LeaveCriticalSection(&p->mutex);
+}
+
+/*
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
+** intended for use only inside assert() statements.
+*/
+int sqlite3_mutex_held(sqlite3_mutex *p){
+  return p==0 || (p->nRef!=0 && p->owner==GetCurrentThreadId());
+}
+int sqlite3_mutex_notheld(sqlite3_mutex *p){
+  return p==0 || p->nRef==0 || p->owner!=GetCurrentThreadId();
+}
+#endif /* SQLITE_MUTEX_W32 */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os.c b/client/src/thirdparty/sqlite-3.4.2/src/os.c
new file mode 100644
index 0000000..57e2d0f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os.c
@@ -0,0 +1,267 @@
+ /*
+** 2005 November 29
+**
+** 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 OS interface code that is common to all
+** architectures.
+*/
+#define _SQLITE_OS_C_ 1
+#include "sqliteInt.h"
+#undef _SQLITE_OS_C_
+
+/*
+** The default SQLite sqlite3_vfs implementations do not allocate
+** memory (actually, os_unix.c allocates a small amount of memory
+** from within OsOpen()), but some third-party implementations may.
+** So we test the effects of a malloc() failing and the sqlite3OsXXX()
+** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
+**
+** The following functions are instrumented for malloc() failure 
+** testing:
+**
+**     sqlite3OsOpen()
+**     sqlite3OsRead()
+**     sqlite3OsWrite()
+**     sqlite3OsSync()
+**     sqlite3OsLock()
+**
+*/
+#ifdef SQLITE_TEST
+  #define DO_OS_MALLOC_TEST if (1) {            \
+    void *pTstAlloc = sqlite3_malloc(10);       \
+    if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \
+    sqlite3_free(pTstAlloc);                    \
+  }
+#else
+  #define DO_OS_MALLOC_TEST
+#endif
+
+/*
+** The following routines are convenience wrappers around methods
+** of the sqlite3_file object.  This is mostly just syntactic sugar. All
+** of this would be completely automatic if SQLite were coded using
+** C++ instead of plain old C.
+*/
+int sqlite3OsClose(sqlite3_file *pId){
+  int rc = SQLITE_OK;
+  if( pId->pMethods ){
+    rc = pId->pMethods->xClose(pId);
+    pId->pMethods = 0;
+  }
+  return rc;
+}
+int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xRead(id, pBuf, amt, offset);
+}
+int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xWrite(id, pBuf, amt, offset);
+}
+int sqlite3OsTruncate(sqlite3_file *id, i64 size){
+  return id->pMethods->xTruncate(id, size);
+}
+int sqlite3OsSync(sqlite3_file *id, int flags){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xSync(id, flags);
+}
+int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
+  return id->pMethods->xFileSize(id, pSize);
+}
+int sqlite3OsLock(sqlite3_file *id, int lockType){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xLock(id, lockType);
+}
+int sqlite3OsUnlock(sqlite3_file *id, int lockType){
+  return id->pMethods->xUnlock(id, lockType);
+}
+int sqlite3OsCheckReservedLock(sqlite3_file *id){
+  return id->pMethods->xCheckReservedLock(id);
+}
+int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
+  return id->pMethods->xFileControl(id,op,pArg);
+}
+int sqlite3OsSectorSize(sqlite3_file *id){
+  int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
+  return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
+}
+int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
+  return id->pMethods->xDeviceCharacteristics(id);
+}
+
+/*
+** The next group of routines are convenience wrappers around the
+** VFS methods.
+*/
+int sqlite3OsOpen(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  sqlite3_file *pFile, 
+  int flags, 
+  int *pFlagsOut
+){
+  DO_OS_MALLOC_TEST;
+  return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
+}
+int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  return pVfs->xDelete(pVfs, zPath, dirSync);
+}
+int sqlite3OsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+  return pVfs->xAccess(pVfs, zPath, flags);
+}
+int sqlite3OsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){
+  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);
+}
+int sqlite3OsFullPathname(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int nPathOut, 
+  char *zPathOut
+){
+  return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
+}
+void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  return pVfs->xDlOpen(pVfs, zPath);
+}
+void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  pVfs->xDlError(pVfs, nByte, zBufOut);
+}
+void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  return pVfs->xDlSym(pVfs, pHandle, zSymbol);
+}
+void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  pVfs->xDlClose(pVfs, pHandle);
+}
+int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  return pVfs->xRandomness(pVfs, nByte, zBufOut);
+}
+int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
+  return pVfs->xSleep(pVfs, nMicro);
+}
+int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  return pVfs->xCurrentTime(pVfs, pTimeOut);
+}
+
+int sqlite3OsOpenMalloc(
+  sqlite3_vfs *pVfs, 
+  const char *zFile, 
+  sqlite3_file **ppFile, 
+  int flags,
+  int *pOutFlags
+){
+  int rc = SQLITE_NOMEM;
+  sqlite3_file *pFile;
+  pFile = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);
+  if( pFile ){
+    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(pFile);
+    }else{
+      *ppFile = pFile;
+    }
+  }
+  return rc;
+}
+int sqlite3OsCloseFree(sqlite3_file *pFile){
+  int rc = SQLITE_OK;
+  if( pFile ){
+    rc = sqlite3OsClose(pFile);
+    sqlite3_free(pFile);
+  }
+  return rc;
+}
+
+/*
+** The list of all registered VFS implementations.  This list is
+** initialized to the single VFS returned by sqlite3OsDefaultVfs()
+** upon the first call to sqlite3_vfs_find().
+*/
+static sqlite3_vfs *vfsList = 0;
+
+/*
+** Locate a VFS by name.  If no name is given, simply return the
+** first VFS on the list.
+*/
+sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+#endif
+  sqlite3_vfs *pVfs = 0;
+  static int isInit = 0;
+  sqlite3_mutex_enter(mutex);
+  if( !isInit ){
+    vfsList = sqlite3OsDefaultVfs();
+    isInit = 1;
+  }
+  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
+    if( zVfs==0 ) break;
+    if( strcmp(zVfs, pVfs->zName)==0 ) break;
+  }
+  sqlite3_mutex_leave(mutex);
+  return pVfs;
+}
+
+/*
+** Unlink a VFS from the linked list
+*/
+static void vfsUnlink(sqlite3_vfs *pVfs){
+  assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) );
+  if( pVfs==0 ){
+    /* No-op */
+  }else if( vfsList==pVfs ){
+    vfsList = pVfs->pNext;
+  }else if( vfsList ){
+    sqlite3_vfs *p = vfsList;
+    while( p->pNext && p->pNext!=pVfs ){
+      p = p->pNext;
+    }
+    if( p->pNext==pVfs ){
+      p->pNext = pVfs->pNext;
+    }
+  }
+}
+
+/*
+** Register a VFS with the system.  It is harmless to register the same
+** VFS multiple times.  The new VFS becomes the default if makeDflt is
+** true.
+*/
+int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+#endif
+  sqlite3_vfs_find(0);  /* Make sure we are initialized */
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  if( makeDflt || vfsList==0 ){
+    pVfs->pNext = vfsList;
+    vfsList = pVfs;
+  }else{
+    pVfs->pNext = vfsList->pNext;
+    vfsList->pNext = pVfs;
+  }
+  assert(vfsList);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Unregister a VFS so that it is no longer accessible.
+*/
+int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+#endif
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os.h b/client/src/thirdparty/sqlite-3.4.2/src/os.h
new file mode 100644
index 0000000..026e2c4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os.h
@@ -0,0 +1,275 @@
+/*
+** 2001 September 16
+**
+** 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 header file (together with is companion C source-code file
+** "os.c") attempt to abstract the underlying operating system so that
+** the SQLite library will work on both POSIX and windows systems.
+**
+** This header file is #include-ed by sqliteInt.h and thus ends up
+** being included by every source file.
+*/
+#ifndef _SQLITE_OS_H_
+#define _SQLITE_OS_H_
+
+/*
+** Figure out if we are dealing with Unix, Windows, or some other
+** operating system.  After the following block of preprocess macros,
+** all of OS_UNIX, OS_WIN, OS_OS2, and OS_OTHER will defined to either
+** 1 or 0.  One of the four will be 1.  The other three will be 0.
+*/
+#if defined(OS_OTHER)
+# if OS_OTHER==1
+#   undef OS_UNIX
+#   define OS_UNIX 0
+#   undef OS_WIN
+#   define OS_WIN 0
+#   undef OS_OS2
+#   define OS_OS2 0
+# else
+#   undef OS_OTHER
+# endif
+#endif
+#if !defined(OS_UNIX) && !defined(OS_OTHER)
+# define OS_OTHER 0
+# ifndef OS_WIN
+#   if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
+#     define OS_WIN 1
+#     define OS_UNIX 0
+#     define OS_OS2 0
+#   elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__)
+#     define OS_WIN 0
+#     define OS_UNIX 0
+#     define OS_OS2 1
+#   else
+#     define OS_WIN 0
+#     define OS_UNIX 1
+#     define OS_OS2 0
+#  endif
+# else
+#  define OS_UNIX 0
+#  define OS_OS2 0
+# endif
+#else
+# ifndef OS_WIN
+#  define OS_WIN 0
+# endif
+#endif
+
+
+
+/*
+** Define the maximum size of a temporary filename
+*/
+#if OS_WIN
+# include <windows.h>
+# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
+#elif OS_OS2
+# if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)
+#  include <os2safe.h> /* has to be included before os2.h for linking to work */
+# endif
+# define INCL_DOSDATETIME
+# define INCL_DOSFILEMGR
+# define INCL_DOSERRORS
+# define INCL_DOSMISC
+# define INCL_DOSPROCESS
+# define INCL_DOSMODULEMGR
+# define INCL_DOSSEMAPHORES
+# include <os2.h>
+# define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP)
+#else
+# define SQLITE_TEMPNAME_SIZE 200
+#endif
+
+/* If the SET_FULLSYNC macro is not defined above, then make it
+** a no-op
+*/
+#ifndef SET_FULLSYNC
+# define SET_FULLSYNC(x,y)
+#endif
+
+/*
+** The default size of a disk sector
+*/
+#ifndef SQLITE_DEFAULT_SECTOR_SIZE
+# define SQLITE_DEFAULT_SECTOR_SIZE 512
+#endif
+
+/*
+** Temporary files are named starting with this prefix followed by 16 random
+** alphanumeric characters, and no file extension. They are stored in the
+** OS's standard temporary file directory, and are deleted prior to exit.
+** If sqlite is being embedded in another program, you may wish to change the
+** prefix to reflect your program's name, so that if your program exits
+** prematurely, old temporary files can be easily identified. This can be done
+** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
+**
+** 2006-10-31:  The default prefix used to be "sqlite_".  But then
+** Mcafee started using SQLite in their anti-virus product and it
+** started putting files with the "sqlite" name in the c:/temp folder.
+** This annoyed many windows users.  Those users would then do a 
+** Google search for "sqlite", find the telephone numbers of the
+** developers and call to wake them up at night and complain.
+** For this reason, the default name prefix is changed to be "sqlite" 
+** spelled backwards.  So the temp files are still identified, but
+** anybody smart enough to figure out the code is also likely smart
+** enough to know that calling the developer will not help get rid
+** of the file.
+*/
+#ifndef SQLITE_TEMP_FILE_PREFIX
+# define SQLITE_TEMP_FILE_PREFIX "etilqs_"
+#endif
+
+/*
+** The following values may be passed as the second argument to
+** sqlite3OsLock(). The various locks exhibit the following semantics:
+**
+** SHARED:    Any number of processes may hold a SHARED lock simultaneously.
+** RESERVED:  A single process may hold a RESERVED lock on a file at
+**            any time. Other processes may hold and obtain new SHARED locks.
+** PENDING:   A single process may hold a PENDING lock on a file at
+**            any one time. Existing SHARED locks may persist, but no new
+**            SHARED locks may be obtained by other processes.
+** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
+**
+** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
+** process that requests an EXCLUSIVE lock may actually obtain a PENDING
+** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
+** sqlite3OsLock().
+*/
+#define NO_LOCK         0
+#define SHARED_LOCK     1
+#define RESERVED_LOCK   2
+#define PENDING_LOCK    3
+#define EXCLUSIVE_LOCK  4
+
+/*
+** File Locking Notes:  (Mostly about windows but also some info for Unix)
+**
+** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
+** those functions are not available.  So we use only LockFile() and
+** UnlockFile().
+**
+** LockFile() prevents not just writing but also reading by other processes.
+** A SHARED_LOCK is obtained by locking a single randomly-chosen 
+** byte out of a specific range of bytes. The lock byte is obtained at 
+** random so two separate readers can probably access the file at the 
+** same time, unless they are unlucky and choose the same lock byte.
+** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
+** There can only be one writer.  A RESERVED_LOCK is obtained by locking
+** a single byte of the file that is designated as the reserved lock byte.
+** A PENDING_LOCK is obtained by locking a designated byte different from
+** the RESERVED_LOCK byte.
+**
+** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available,
+** which means we can use reader/writer locks.  When reader/writer locks
+** are used, the lock is placed on the same range of bytes that is used
+** for probabilistic locking in Win95/98/ME.  Hence, the locking scheme
+** will support two or more Win95 readers or two or more WinNT readers.
+** But a single Win95 reader will lock out all WinNT readers and a single
+** WinNT reader will lock out all other Win95 readers.
+**
+** The following #defines specify the range of bytes used for locking.
+** SHARED_SIZE is the number of bytes available in the pool from which
+** a random byte is selected for a shared lock.  The pool of bytes for
+** shared locks begins at SHARED_FIRST. 
+**
+** These #defines are available in sqlite_aux.h so that adaptors for
+** connecting SQLite to other operating systems can use the same byte
+** ranges for locking.  In particular, the same locking strategy and
+** byte ranges are used for Unix.  This leaves open the possiblity of having
+** clients on win95, winNT, and unix all talking to the same shared file
+** and all locking correctly.  To do so would require that samba (or whatever
+** tool is being used for file sharing) implements locks correctly between
+** windows and unix.  I'm guessing that isn't likely to happen, but by
+** using the same locking range we are at least open to the possibility.
+**
+** Locking in windows is manditory.  For this reason, we cannot store
+** actual data in the bytes used for locking.  The pager never allocates
+** the pages involved in locking therefore.  SHARED_SIZE is selected so
+** that all locks will fit on a single page even at the minimum page size.
+** PENDING_BYTE defines the beginning of the locks.  By default PENDING_BYTE
+** is set high so that we don't have to allocate an unused page except
+** for very large databases.  But one should test the page skipping logic 
+** by setting PENDING_BYTE low and running the entire regression suite.
+**
+** 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.
+**
+*/
+#ifndef SQLITE_TEST
+#define PENDING_BYTE      0x40000000  /* First byte past the 1GB boundary */
+#else
+extern unsigned int sqlite3_pending_byte;
+#define PENDING_BYTE sqlite3_pending_byte
+#endif
+
+#define RESERVED_BYTE     (PENDING_BYTE+1)
+#define SHARED_FIRST      (PENDING_BYTE+2)
+#define SHARED_SIZE       510
+
+/* 
+** Functions for accessing sqlite3_file methods 
+*/
+int sqlite3OsClose(sqlite3_file*);
+int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
+int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
+int sqlite3OsTruncate(sqlite3_file*, i64 size);
+int sqlite3OsSync(sqlite3_file*, int);
+int sqlite3OsFileSize(sqlite3_file*, i64 *pSize);
+int sqlite3OsLock(sqlite3_file*, int);
+int sqlite3OsUnlock(sqlite3_file*, int);
+int sqlite3OsCheckReservedLock(sqlite3_file *id);
+int sqlite3OsFileControl(sqlite3_file*,int,void*);
+int sqlite3OsSectorSize(sqlite3_file *id);
+int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
+
+/* 
+** Functions for accessing sqlite3_vfs methods 
+*/
+int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *);
+int sqlite3OsDelete(sqlite3_vfs *, const char *, int);
+int sqlite3OsAccess(sqlite3_vfs *, const char *, int);
+int sqlite3OsGetTempname(sqlite3_vfs *, int, char *);
+int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *);
+void *sqlite3OsDlOpen(sqlite3_vfs *, const char *);
+void sqlite3OsDlError(sqlite3_vfs *, int, char *);
+void *sqlite3OsDlSym(sqlite3_vfs *, void *, const char *);
+void sqlite3OsDlClose(sqlite3_vfs *, void *);
+int sqlite3OsRandomness(sqlite3_vfs *, int, char *);
+int sqlite3OsSleep(sqlite3_vfs *, int);
+int sqlite3OsCurrentTime(sqlite3_vfs *, double*);
+
+/*
+** Convenience functions for opening and closing files using 
+** sqlite3_malloc() to obtain space for the file-handle structure.
+*/
+int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*);
+int sqlite3OsCloseFree(sqlite3_file *);
+
+/*
+** Each OS-specific backend defines an instance of the following
+** structure for returning a pointer to its sqlite3_vfs.  If OS_OTHER
+** is defined (meaning that the application-defined OS interface layer
+** is used) then there is no default VFS.   The application must
+** register one or more VFS structures using sqlite3_vfs_register()
+** before attempting to use SQLite.
+*/
+#if OS_UNIX || OS_WIN || OS_OS2
+sqlite3_vfs *sqlite3OsDefaultVfs(void);
+#else
+# define sqlite3OsDefaultVfs(X) 0
+#endif
+
+#endif /* _SQLITE_OS_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_common.h b/client/src/thirdparty/sqlite-3.4.2/src/os_common.h
new file mode 100644
index 0000000..8de4be9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_common.h
@@ -0,0 +1,127 @@
+/*
+** 2004 May 22
+**
+** 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 macros and a little bit of code that is common to
+** all of the platform-specific files (os_*.c) and is #included into those
+** files.
+**
+** This file should be #included by the os_*.c files only.  It is not a
+** general purpose header file.
+*/
+
+/*
+** At least two bugs have slipped in because we changed the MEMORY_DEBUG
+** macro to SQLITE_DEBUG and some older makefiles have not yet made the
+** 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
+
+
+/*
+ * When testing, this global variable stores the location of the
+ * pending-byte in the database file.
+ */
+#ifdef SQLITE_TEST
+unsigned int sqlite3_pending_byte = 0x40000000;
+#endif
+
+#ifdef SQLITE_DEBUG
+int sqlite3_os_trace = 0;
+#define OSTRACE1(X)         if( sqlite3_os_trace ) sqlite3DebugPrintf(X)
+#define OSTRACE2(X,Y)       if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y)
+#define OSTRACE3(X,Y,Z)     if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z)
+#define OSTRACE4(X,Y,Z,A)   if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A)
+#define OSTRACE5(X,Y,Z,A,B) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A,B)
+#define OSTRACE6(X,Y,Z,A,B,C) \
+    if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C)
+#define OSTRACE7(X,Y,Z,A,B,C,D) \
+    if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C,D)
+#else
+#define OSTRACE1(X)
+#define OSTRACE2(X,Y)
+#define OSTRACE3(X,Y,Z)
+#define OSTRACE4(X,Y,Z,A)
+#define OSTRACE5(X,Y,Z,A,B)
+#define OSTRACE6(X,Y,Z,A,B,C)
+#define OSTRACE7(X,Y,Z,A,B,C,D)
+#endif
+
+/*
+** Macros for performance tracing.  Normally turned off.  Only works
+** on i486 hardware.
+*/
+#ifdef SQLITE_PERFORMANCE_TRACE
+__inline__ unsigned long long int hwtime(void){
+  unsigned long long int x;
+  __asm__("rdtsc\n\t"
+          "mov %%edx, %%ecx\n\t"
+          :"=A" (x));
+  return x;
+}
+static unsigned long long int g_start;
+static unsigned int elapse;
+#define TIMER_START       g_start=hwtime()
+#define TIMER_END         elapse=hwtime()-g_start
+#define TIMER_ELAPSED     elapse
+#else
+#define TIMER_START
+#define TIMER_END
+#define TIMER_ELAPSED     0
+#endif
+
+/*
+** 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_hit = 0;
+int sqlite3_io_error_pending = 0;
+int sqlite3_io_error_persist = 0;
+int sqlite3_diskfull_pending = 0;
+int sqlite3_diskfull = 0;
+#define SimulateIOError(CODE)  \
+  if( sqlite3_io_error_pending || sqlite3_io_error_hit ) \
+     if( sqlite3_io_error_pending-- == 1 \
+         || (sqlite3_io_error_persist && sqlite3_io_error_hit) ) \
+                { local_ioerr(); CODE; }
+static void local_ioerr(){
+  IOTRACE(("IOERR\n"));
+  sqlite3_io_error_hit = 1;
+}
+#define SimulateDiskfullError(CODE) \
+   if( sqlite3_diskfull_pending ){ \
+     if( sqlite3_diskfull_pending == 1 ){ \
+       local_ioerr(); \
+       sqlite3_diskfull = 1; \
+       sqlite3_io_error_hit = 1; \
+       CODE; \
+     }else{ \
+       sqlite3_diskfull_pending--; \
+     } \
+   }
+#else
+#define SimulateIOError(A)
+#define SimulateDiskfullError(A)
+#endif
+
+/*
+** When testing, keep a count of the number of open files.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_open_file_count = 0;
+#define OpenCounter(X)  sqlite3_open_file_count+=(X)
+#else
+#define OpenCounter(X)
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_os2.c b/client/src/thirdparty/sqlite-3.4.2/src/os_os2.c
new file mode 100644
index 0000000..d5e3382
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_os2.c
@@ -0,0 +1,989 @@
+/*
+** 2006 Feb 14
+**
+** 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 that is specific to OS/2.
+*/
+
+#include "sqliteInt.h"
+
+#if OS_OS2
+
+/*
+** A Note About Memory Allocation:
+**
+** This driver uses malloc()/free() directly rather than going through
+** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers
+** are designed for use on embedded systems where memory is scarce and
+** malloc failures happen frequently.  OS/2 does not typically run on
+** embedded systems, and when it does the developers normally have bigger
+** problems to worry about than running out of memory.  So there is not
+** a compelling need to use the wrappers.
+**
+** But there is a good reason to not use the wrappers.  If we use the
+** wrappers then we will get simulated malloc() failures within this
+** driver.  And that causes all kinds of problems for our tests.  We
+** could enhance SQLite to deal with simulated malloc failures within
+** the OS driver, but the code to deal with those failure would not
+** be exercised on Linux (which does not need to malloc() in the driver)
+** and so we would have difficulty writing coverage tests for that
+** code.  Better to leave the code out, we think.
+**
+** The point of this discussion is as follows:  When creating a new
+** OS layer for an embedded system, if you use this file as an example,
+** avoid the use of malloc()/free().  Those routines work ok on OS/2
+** desktops but not so well in embedded systems.
+*/
+
+/*
+** Macros used to determine whether or not to use threads.
+*/
+#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE
+# define SQLITE_OS2_THREADS 1
+#endif
+
+/*
+** Include code that is common to all os_*.c files
+*/
+#include "os_common.h"
+
+/*
+** The os2File structure is subclass of sqlite3_file specific for the OS/2
+** protability layer.
+*/
+typedef struct os2File os2File;
+struct os2File {
+  const sqlite3_io_methods *pMethod;  /* Always the first entry */
+  HFILE h;                  /* Handle for accessing the file */
+  int delOnClose;           /* True if file is to be deleted on close */
+  char* pathToDel;          /* Name of file to delete on close */
+  unsigned char locktype;   /* Type of lock currently held on this file */
+};
+
+/*****************************************************************************
+** The next group of routines implement the I/O methods specified
+** by the sqlite3_io_methods object.
+******************************************************************************/
+
+/*
+** Close a file.
+*/
+int os2Close( sqlite3_file *id ){
+  APIRET rc = NO_ERROR;
+  os2File *pFile;
+  if( id && (pFile = (os2File*)id) != 0 ){
+    OSTRACE2( "CLOSE %d\n", pFile->h );
+    rc = DosClose( pFile->h );
+    pFile->locktype = NO_LOCK;
+    if( pFile->delOnClose != 0 ){
+      rc = DosForceDelete( (PSZ)pFile->pathToDel );
+    }
+    if( pFile->pathToDel ){
+      free( pFile->pathToDel );
+    }
+    id = 0;
+    OpenCounter( -1 );
+  }
+
+  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
+}
+
+/*
+** 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 os2Read(
+  sqlite3_file *id,               /* File to read from */
+  void *pBuf,                     /* Write content into this buffer */
+  int amt,                        /* Number of bytes to read */
+  sqlite3_int64 offset            /* Begin reading at this offset */
+){
+  ULONG fileLocation = 0L;
+  ULONG got;
+  os2File *pFile = (os2File*)id;
+  assert( id!=0 );
+  SimulateIOError( return SQLITE_IOERR_READ );
+  OSTRACE3( "READ %d lock=%d\n", pFile->h, pFile->locktype );
+  if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
+    return SQLITE_IOERR;
+  }
+  if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
+    return SQLITE_IOERR_READ;
+  }
+  if( got == (ULONG)amt )
+    return SQLITE_OK;
+  else {
+    memset(&((char*)pBuf)[got], 0, amt-got);
+    return SQLITE_IOERR_SHORT_READ;
+  }
+}
+
+/*
+** Write data from a buffer into a file.  Return SQLITE_OK on success
+** or some other error code on failure.
+*/
+int os2Write(
+  sqlite3_file *id,               /* File to write into */
+  const void *pBuf,               /* The bytes to be written */
+  int amt,                        /* Number of bytes to write */
+  sqlite3_int64 offset            /* Offset into the file to begin writing at */
+){
+  ULONG fileLocation = 0L;
+  APIRET rc = NO_ERROR;
+  ULONG wrote;
+  os2File *pFile = (os2File*)id;
+  assert( id!=0 );
+  SimulateIOError( return SQLITE_IOERR_WRITE );
+  SimulateDiskfullError( return SQLITE_FULL );
+  OSTRACE3( "WRITE %d lock=%d\n", pFile->h, pFile->locktype );
+  if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
+    return SQLITE_IOERR;
+  }
+  assert( amt>0 );
+  while( amt > 0 &&
+         (rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote )) &&
+         wrote > 0
+  ){
+    amt -= wrote;
+    pBuf = &((char*)pBuf)[wrote];
+  }
+
+  return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;
+}
+
+/*
+** Truncate an open file to a specified size
+*/
+int os2Truncate( sqlite3_file *id, i64 nByte ){
+  APIRET rc = NO_ERROR;
+  os2File *pFile = (os2File*)id;
+  OSTRACE3( "TRUNCATE %d %lld\n", pFile->h, nByte );
+  SimulateIOError( return SQLITE_IOERR_TRUNCATE );
+  rc = DosSetFileSize( pFile->h, nByte );
+  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
+}
+
+#ifdef SQLITE_TEST
+/*
+** Count the number of fullsyncs and normal syncs.  This is used to test
+** that syncs and fullsyncs are occuring at the right times.
+*/
+int sqlite3_sync_count = 0;
+int sqlite3_fullsync_count = 0;
+#endif
+
+/*
+** Make sure all writes to a particular file are committed to disk.
+*/
+int os2Sync( sqlite3_file *id, int flags ){
+  os2File *pFile = (os2File*)id;
+  OSTRACE3( "SYNC %d lock=%d\n", pFile->h, pFile->locktype );
+#ifdef SQLITE_TEST
+  if( flags & SQLITE_SYNC_FULL){
+    sqlite3_fullsync_count++;
+  }
+  sqlite3_sync_count++;
+#endif
+  return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
+}
+
+/*
+** Determine the current size of a file in bytes
+*/
+int os2FileSize( sqlite3_file *id, sqlite3_int64 *pSize ){
+  APIRET rc = NO_ERROR;
+  FILESTATUS3 fsts3FileInfo;
+  memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
+  assert( id!=0 );
+  SimulateIOError( return SQLITE_IOERR );
+  rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
+  if( rc == NO_ERROR ){
+    *pSize = fsts3FileInfo.cbFile;
+    return SQLITE_OK;
+  }else{
+    return SQLITE_IOERR;
+  }
+}
+
+/*
+** Acquire a reader lock.
+*/
+static int getReadLock( os2File *pFile ){
+  FILELOCK  LockArea,
+            UnlockArea;
+  APIRET res;
+  memset(&LockArea, 0, sizeof(LockArea));
+  memset(&UnlockArea, 0, sizeof(UnlockArea));
+  LockArea.lOffset = SHARED_FIRST;
+  LockArea.lRange = SHARED_SIZE;
+  UnlockArea.lOffset = 0L;
+  UnlockArea.lRange = 0L;
+  res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+  OSTRACE3( "GETREADLOCK %d res=%d\n", pFile->h, res );
+  return res;
+}
+
+/*
+** Undo a readlock
+*/
+static int unlockReadLock( os2File *id ){
+  FILELOCK  LockArea,
+            UnlockArea;
+  APIRET res;
+  memset(&LockArea, 0, sizeof(LockArea));
+  memset(&UnlockArea, 0, sizeof(UnlockArea));
+  LockArea.lOffset = 0L;
+  LockArea.lRange = 0L;
+  UnlockArea.lOffset = SHARED_FIRST;
+  UnlockArea.lRange = SHARED_SIZE;
+  res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, 2000L, 1L );
+  OSTRACE3( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res );
+  return res;
+}
+
+/*
+** Lock the file with the lock specified by parameter locktype - one
+** of the following:
+**
+**     (1) SHARED_LOCK
+**     (2) RESERVED_LOCK
+**     (3) PENDING_LOCK
+**     (4) EXCLUSIVE_LOCK
+**
+** Sometimes when requesting one lock state, additional lock states
+** are inserted in between.  The locking might fail on one of the later
+** transitions leaving the lock state different from what it started but
+** still short of its goal.  The following chart shows the allowed
+** transitions and the inserted intermediate states:
+**
+**    UNLOCKED -> SHARED
+**    SHARED -> RESERVED
+**    SHARED -> (PENDING) -> EXCLUSIVE
+**    RESERVED -> (PENDING) -> EXCLUSIVE
+**    PENDING -> EXCLUSIVE
+**
+** This routine will only increase a lock.  The os2Unlock() routine
+** erases all locks at once and returns us immediately to locking level 0.
+** It is not possible to lower the locking level one step at a time.  You
+** must go straight to locking level 0.
+*/
+int os2Lock( sqlite3_file *id, int locktype ){
+  int rc = SQLITE_OK;       /* Return code from subroutines */
+  APIRET res = NO_ERROR;    /* Result of an OS/2 lock call */
+  int newLocktype;       /* Set pFile->locktype to this value before exiting */
+  int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
+  FILELOCK  LockArea,
+            UnlockArea;
+  os2File *pFile = (os2File*)id;
+  memset(&LockArea, 0, sizeof(LockArea));
+  memset(&UnlockArea, 0, sizeof(UnlockArea));
+  assert( pFile!=0 );
+  OSTRACE4( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype );
+
+  /* If there is already a lock of this type or more restrictive on the
+  ** os2File, do nothing. Don't use the end_lock: exit path, as
+  ** sqlite3OsEnterMutex() hasn't been called yet.
+  */
+  if( pFile->locktype>=locktype ){
+    OSTRACE3( "LOCK %d %d ok (already held)\n", pFile->h, locktype );
+    return SQLITE_OK;
+  }
+
+  /* Make sure the locking sequence is correct
+  */
+  assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+  assert( locktype!=PENDING_LOCK );
+  assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
+
+  /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
+  ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
+  ** the PENDING_LOCK byte is temporary.
+  */
+  newLocktype = pFile->locktype;
+  if( pFile->locktype==NO_LOCK
+      || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
+  ){
+    int cnt = 3;
+
+    LockArea.lOffset = PENDING_BYTE;
+    LockArea.lRange = 1L;
+    UnlockArea.lOffset = 0L;
+    UnlockArea.lRange = 0L;
+
+    while( cnt-->0 && ( res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L) )
+                      != NO_ERROR
+    ){
+      /* Try 3 times to get the pending lock.  The pending lock might be
+      ** held by another reader process who will release it momentarily.
+      */
+      OSTRACE2( "LOCK could not get a PENDING lock. cnt=%d\n", cnt );
+      DosSleep(1);
+    }
+    if( res == NO_ERROR){
+      gotPendingLock = 1;
+      OSTRACE3( "LOCK %d pending lock boolean set.  res=%d\n", pFile->h, res );
+    }
+  }
+
+  /* Acquire a shared lock
+  */
+  if( locktype==SHARED_LOCK && res == NO_ERROR ){
+    assert( pFile->locktype==NO_LOCK );
+    res = getReadLock(pFile);
+    if( res == NO_ERROR ){
+      newLocktype = SHARED_LOCK;
+    }
+    OSTRACE3( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res );
+  }
+
+  /* Acquire a RESERVED lock
+  */
+  if( locktype==RESERVED_LOCK && res == NO_ERROR ){
+    assert( pFile->locktype==SHARED_LOCK );
+    LockArea.lOffset = RESERVED_BYTE;
+    LockArea.lRange = 1L;
+    UnlockArea.lOffset = 0L;
+    UnlockArea.lRange = 0L;
+    res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    if( res == NO_ERROR ){
+      newLocktype = RESERVED_LOCK;
+    }
+    OSTRACE3( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res );
+  }
+
+  /* Acquire a PENDING lock
+  */
+  if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
+    newLocktype = PENDING_LOCK;
+    gotPendingLock = 0;
+    OSTRACE2( "LOCK %d acquire pending lock. pending lock boolean unset.\n", pFile->h );
+  }
+
+  /* Acquire an EXCLUSIVE lock
+  */
+  if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
+    assert( pFile->locktype>=SHARED_LOCK );
+    res = unlockReadLock(pFile);
+    OSTRACE2( "unreadlock = %d\n", res );
+    LockArea.lOffset = SHARED_FIRST;
+    LockArea.lRange = SHARED_SIZE;
+    UnlockArea.lOffset = 0L;
+    UnlockArea.lRange = 0L;
+    res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    if( res == NO_ERROR ){
+      newLocktype = EXCLUSIVE_LOCK;
+    }else{
+      OSTRACE2( "OS/2 error-code = %d\n", res );
+      getReadLock(pFile);
+    }
+    OSTRACE3( "LOCK %d acquire exclusive lock.  res=%d\n", pFile->h, res );
+  }
+
+  /* If we are holding a PENDING lock that ought to be released, then
+  ** release it now.
+  */
+  if( gotPendingLock && locktype==SHARED_LOCK ){
+    int r;
+    LockArea.lOffset = 0L;
+    LockArea.lRange = 0L;
+    UnlockArea.lOffset = PENDING_BYTE;
+    UnlockArea.lRange = 1L;
+    r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    OSTRACE3( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r );
+  }
+
+  /* Update the state of the lock has held in the file descriptor then
+  ** return the appropriate result code.
+  */
+  if( res == NO_ERROR ){
+    rc = SQLITE_OK;
+  }else{
+    OSTRACE4( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
+              locktype, newLocktype );
+    rc = SQLITE_BUSY;
+  }
+  pFile->locktype = newLocktype;
+  OSTRACE3( "LOCK %d now %d\n", pFile->h, pFile->locktype );
+  return rc;
+}
+
+/*
+** This routine checks if there is a RESERVED lock held on the specified
+** file by this or any other process. If such a lock is held, return
+** non-zero, otherwise zero.
+*/
+int os2CheckReservedLock( sqlite3_file *id ){
+  APIRET rc = NO_ERROR;
+  os2File *pFile = (os2File*)id;
+  assert( pFile!=0 );
+  if( pFile->locktype>=RESERVED_LOCK ){
+    rc = 1;
+    OSTRACE3( "TEST WR-LOCK %d %d (local)\n", pFile->h, rc );
+  }else{
+    FILELOCK  LockArea,
+              UnlockArea;
+    memset(&LockArea, 0, sizeof(LockArea));
+    memset(&UnlockArea, 0, sizeof(UnlockArea));
+    LockArea.lOffset = RESERVED_BYTE;
+    LockArea.lRange = 1L;
+    UnlockArea.lOffset = 0L;
+    UnlockArea.lRange = 0L;
+    rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    OSTRACE3( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc );
+    if( rc == NO_ERROR ){
+      int r;
+      LockArea.lOffset = 0L;
+      LockArea.lRange = 0L;
+      UnlockArea.lOffset = RESERVED_BYTE;
+      UnlockArea.lRange = 1L;
+      r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+      OSTRACE3( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, r );
+    }
+    OSTRACE3( "TEST WR-LOCK %d %d (remote)\n", pFile->h, rc );
+  }
+  return rc;
+}
+
+/*
+** Lower the locking level on file descriptor id to locktype.  locktype
+** must be either NO_LOCK or SHARED_LOCK.
+**
+** If the locking level of the file descriptor is already at or below
+** the requested locking level, this routine is a no-op.
+**
+** It is not possible for this routine to fail if the second argument
+** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
+** might return SQLITE_IOERR;
+*/
+int os2Unlock( sqlite3_file *id, int locktype ){
+  int type;
+  os2File *pFile = (os2File*)id;
+  APIRET rc = SQLITE_OK;
+  APIRET res = NO_ERROR;
+  FILELOCK  LockArea,
+            UnlockArea;
+  memset(&LockArea, 0, sizeof(LockArea));
+  memset(&UnlockArea, 0, sizeof(UnlockArea));
+  assert( pFile!=0 );
+  assert( locktype<=SHARED_LOCK );
+  OSTRACE4( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype );
+  type = pFile->locktype;
+  if( type>=EXCLUSIVE_LOCK ){
+    LockArea.lOffset = 0L;
+    LockArea.lRange = 0L;
+    UnlockArea.lOffset = SHARED_FIRST;
+    UnlockArea.lRange = SHARED_SIZE;
+    res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    OSTRACE3( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res );
+    if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
+      /* This should never happen.  We should always be able to
+      ** reacquire the read lock */
+      OSTRACE3( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype );
+      rc = SQLITE_IOERR_UNLOCK;
+    }
+  }
+  if( type>=RESERVED_LOCK ){
+    LockArea.lOffset = 0L;
+    LockArea.lRange = 0L;
+    UnlockArea.lOffset = RESERVED_BYTE;
+    UnlockArea.lRange = 1L;
+    res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    OSTRACE3( "UNLOCK %d reserved res=%d\n", pFile->h, res );
+  }
+  if( locktype==NO_LOCK && type>=SHARED_LOCK ){
+    res = unlockReadLock(pFile);
+    OSTRACE5( "UNLOCK %d is %d want %d res=%d\n", pFile->h, type, locktype, res );
+  }
+  if( type>=PENDING_LOCK ){
+    LockArea.lOffset = 0L;
+    LockArea.lRange = 0L;
+    UnlockArea.lOffset = PENDING_BYTE;
+    UnlockArea.lRange = 1L;
+    res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 2000L, 1L );
+    OSTRACE3( "UNLOCK %d pending res=%d\n", pFile->h, res );
+  }
+  pFile->locktype = locktype;
+  OSTRACE3( "UNLOCK %d now %d\n", pFile->h, pFile->locktype );
+  return rc;
+}
+
+/*
+** Control and query of the open file handle.
+*/
+static int os2FileControl(sqlite3_file *id, int op, void *pArg){
+  switch( op ){
+    case SQLITE_FCNTL_LOCKSTATE: {
+      *(int*)pArg = ((os2File*)id)->locktype;
+      OSTRACE3( "FCNTL_LOCKSTATE %d lock=%d\n", ((os2File*)id)->h, ((os2File*)id)->locktype );
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_ERROR;
+}
+
+/*
+** Return the sector size in bytes of the underlying block device for
+** the specified file. This is almost always 512 bytes, but may be
+** larger for some devices.
+**
+** SQLite code assumes this function cannot fail. It also assumes that
+** if two files are created in the same file-system directory (i.e.
+** a database and its journal file) that the sector size will be the
+** same for both.
+*/
+static int os2SectorSize(sqlite3_file *id){
+  return SQLITE_DEFAULT_SECTOR_SIZE;
+}
+
+/*
+** Return a vector of device characteristics.
+*/
+static int os2DeviceCharacteristics(sqlite3_file *id){
+  return 0;
+}
+
+/*
+** This vector defines all the methods that can operate on an
+** sqlite3_file for os2.
+*/
+static const sqlite3_io_methods os2IoMethod = {
+  1,                        /* iVersion */
+  os2Close,
+  os2Read,
+  os2Write,
+  os2Truncate,
+  os2Sync,
+  os2FileSize,
+  os2Lock,
+  os2Unlock,
+  os2CheckReservedLock,
+  os2FileControl,
+  os2SectorSize,
+  os2DeviceCharacteristics
+};
+
+/***************************************************************************
+** Here ends the I/O methods that form the sqlite3_io_methods object.
+**
+** The next block of code implements the VFS methods.
+****************************************************************************/
+
+/*
+** Open a file.
+*/
+static int os2Open(
+  sqlite3_vfs *pVfs,            /* Not used */
+  const char *zName,            /* Name of the file */
+  sqlite3_file *id,             /* Write the SQLite file handle here */
+  int flags,                    /* Open mode flags */
+  int *pOutFlags                /* Status return flags */
+){
+  HFILE h;
+  ULONG ulFileAttribute = 0;
+  ULONG ulOpenFlags = 0;
+  ULONG ulOpenMode = 0;
+  os2File *pFile = (os2File*)id;
+  APIRET rc = NO_ERROR;
+  ULONG ulAction;
+
+  memset(pFile, 0, sizeof(*pFile));
+
+  OSTRACE2( "OPEN want %d\n", flags );
+
+  //ulOpenMode = flags & SQLITE_OPEN_READWRITE ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY;
+  if( flags & SQLITE_OPEN_READWRITE ){
+    ulOpenMode |= OPEN_ACCESS_READWRITE;
+    OSTRACE1( "OPEN read/write\n" );
+  }else{
+    ulOpenMode |= OPEN_ACCESS_READONLY;
+    OSTRACE1( "OPEN read only\n" );
+  }
+
+  //ulOpenFlags = flags & SQLITE_OPEN_CREATE ? OPEN_ACTION_CREATE_IF_NEW : OPEN_ACTION_FAIL_IF_NEW;
+  if( flags & SQLITE_OPEN_CREATE ){
+    ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
+    OSTRACE1( "OPEN open new/create\n" );
+  }else{
+    ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
+    OSTRACE1( "OPEN open existing\n" );
+  }
+
+  //ulOpenMode |= flags & SQLITE_OPEN_MAIN_DB ? OPEN_SHARE_DENYNONE : OPEN_SHARE_DENYWRITE;
+  if( flags & SQLITE_OPEN_MAIN_DB ){
+    ulOpenMode |= OPEN_SHARE_DENYNONE;
+    OSTRACE1( "OPEN share read/write\n" );
+  }else{
+    ulOpenMode |= OPEN_SHARE_DENYWRITE;
+    OSTRACE1( "OPEN share read only\n" );
+  }
+
+  if( flags & (SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_TEMP_JOURNAL
+               | SQLITE_OPEN_SUBJOURNAL) ){
+    //ulFileAttribute = FILE_HIDDEN;  //for debugging, we want to make sure it is deleted
+    ulFileAttribute = FILE_NORMAL;
+    pFile->delOnClose = 1;
+    pFile->pathToDel = (char*)malloc(sizeof(char) * pVfs->mxPathname);
+    sqlite3OsFullPathname(pVfs, zName, pVfs->mxPathname, pFile->pathToDel);
+    OSTRACE1( "OPEN hidden/delete on close file attributes\n" );
+  }else{
+    ulFileAttribute = FILE_ARCHIVED | FILE_NORMAL;
+    pFile->delOnClose = 0;
+    pFile->pathToDel = NULL;
+    OSTRACE1( "OPEN normal file attribute\n" );
+  }
+
+  //ulOpenMode |= flags & (SQLITE_OPEN_MAIN_DB | SQLITE_OPEN_TEMP_DB) ?
+  //                  OPEN_FLAGS_RANDOM : OPEN_FLAGS_SEQUENTIAL;
+  if( flags & (SQLITE_OPEN_MAIN_DB | SQLITE_OPEN_TEMP_DB) ){
+    ulOpenMode |= OPEN_FLAGS_RANDOM;
+    OSTRACE1( "OPEN random access\n" );
+  }else{
+    ulOpenMode |= OPEN_FLAGS_SEQUENTIAL;
+    OSTRACE1( "OPEN sequential access\n" );
+  }
+  ulOpenMode |= OPEN_FLAGS_FAIL_ON_ERROR;
+
+  rc = DosOpen( (PSZ)zName,
+                &h,
+                &ulAction,
+                0L,
+                ulFileAttribute,
+                ulOpenFlags,
+                ulOpenMode,
+                (PEAOP2)NULL );
+  if( rc != NO_ERROR ){
+    OSTRACE7( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulAttr=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
+              rc, zName, ulAction, ulFileAttribute, ulOpenFlags, ulOpenMode );
+    if( flags & SQLITE_OPEN_READWRITE ){
+      OSTRACE2( "OPEN %d Invalid handle\n", ((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE) );
+      return os2Open( 0, zName, id,
+                      ((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE),
+                      pOutFlags );
+    }else{
+      return SQLITE_CANTOPEN;
+    }
+  }
+
+  if( pOutFlags ){
+    *pOutFlags = flags & SQLITE_OPEN_READWRITE ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
+  }
+
+  pFile->pMethod = &os2IoMethod;
+  pFile->h = h;
+  OpenCounter(+1);
+  OSTRACE3( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags );
+  return SQLITE_OK;
+}
+
+/*
+** Delete the named file.
+*/
+int os2Delete(
+  sqlite3_vfs *pVfs,                     /* Not used on os2 */
+  const char *zFilename,                 /* Name of file to delete */
+  int syncDir                            /* Not used on os2 */
+){
+  APIRET rc = NO_ERROR;
+  SimulateIOError(return SQLITE_IOERR_DELETE);
+  rc = DosDelete( (PSZ)zFilename );
+  OSTRACE2( "DELETE \"%s\"\n", zFilename );
+  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
+}
+
+/*
+** Check the existance and status of a file.
+*/
+static int os2Access(
+  sqlite3_vfs *pVfs,        /* Not used on os2 */
+  const char *zFilename,    /* Name of file to check */
+  int flags                 /* Type of test to make on this file */
+){
+  FILESTATUS3 fsts3ConfigInfo;
+  APIRET rc = NO_ERROR;
+
+  memset(&fsts3ConfigInfo, 0, sizeof(fsts3ConfigInfo));
+  rc = DosQueryPathInfo( (PSZ)zFilename, FIL_STANDARD,
+                         &fsts3ConfigInfo, sizeof(FILESTATUS3) );
+  OSTRACE4( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
+            fsts3ConfigInfo.attrFile, flags, rc );
+  switch( flags ){
+    case SQLITE_ACCESS_READ:
+    case SQLITE_ACCESS_EXISTS:
+      rc = (rc == NO_ERROR);
+      OSTRACE3( "ACCESS %s access of read and exists  rc=%d\n", zFilename, rc );
+      break;
+    case SQLITE_ACCESS_READWRITE:
+      rc = (fsts3ConfigInfo.attrFile & FILE_READONLY) == 0;
+      OSTRACE3( "ACCESS %s access of read/write  rc=%d\n", zFilename, rc );
+      break;
+    default:
+      assert( !"Invalid flags argument" );
+  }
+  return rc;
+}
+
+
+/*
+** Create a temporary file name in zBuf.  zBuf must be big enough to
+** hold at pVfs->mxPathname characters.
+*/
+static int os2GetTempname( sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
+  static const unsigned char zChars[] =
+    "abcdefghijklmnopqrstuvwxyz"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "0123456789";
+  int i, j;
+  char zTempPathBuf[3];
+  PSZ zTempPath = (PSZ)&zTempPathBuf;
+  if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){
+    if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){
+      if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){
+           ULONG ulDriveNum = 0, ulDriveMap = 0;
+           DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap );
+           sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) );
+      }
+    }
+  }
+  /* strip off a trailing slashes or backslashes, otherwise we would get *
+   * multiple (back)slashes which causes DosOpen() to fail               */
+  j = strlen(zTempPath);
+  while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ) ){
+    j--;
+  }
+  zTempPath[j] = '\0';
+  sqlite3_snprintf( nBuf-30, zBuf,
+                    "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath );
+  j = strlen( zBuf );
+  sqlite3Randomness( 20, &zBuf[j] );
+  for( i = 0; i < 20; i++, j++ ){
+    zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
+  }
+  zBuf[j] = 0;
+  OSTRACE2( "TEMP FILENAME: %s\n", zBuf );
+  return SQLITE_OK;
+}
+
+
+/*
+** Turn a relative pathname into a full pathname.  Write the full
+** pathname into zFull[].  zFull[] will be at least pVfs->mxPathname
+** bytes in size.
+*/
+static int os2FullPathname(
+  sqlite3_vfs *pVfs,          /* Pointer to vfs object */
+  const char *zRelative,      /* Possibly relative input path */
+  int nFull,                  /* Size of output buffer in bytes */
+  char *zFull                 /* Output buffer */
+){
+  APIRET rc = DosQueryPathInfo( zRelative, FIL_QUERYFULLNAME, zFull, nFull );
+  return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
+}
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** Interfaces for opening a shared library, finding entry points
+** within the shared library, and closing the shared library.
+*/
+/*
+** Interfaces for opening a shared library, finding entry points
+** within the shared library, and closing the shared library.
+*/
+static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
+  UCHAR loadErr[256];
+  HMODULE hmod;
+  APIRET rc;
+  rc = DosLoadModule((PSZ)loadErr, sizeof(loadErr), zFilename, &hmod);
+  return rc != NO_ERROR ? 0 : (void*)hmod;
+}
+/*
+** A no-op since the error code is returned on the DosLoadModule call.
+** os2Dlopen returns zero if DosLoadModule is not successful.
+*/
+static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
+/* no-op */
+}
+void *os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  PFN pfn;
+  APIRET rc;
+  rc = DosQueryProcAddr((HMODULE)pHandle, 0L, zSymbol, &pfn);
+  if( rc != NO_ERROR ){
+    /* if the symbol itself was not found, search again for the same
+     * symbol with an extra underscore, that might be needed depending
+     * on the calling convention */
+    char _zSymbol[256] = "_";
+    strncat(_zSymbol, zSymbol, 255);
+    rc = DosQueryProcAddr((HMODULE)pHandle, 0L, _zSymbol, &pfn);
+  }
+  return rc != NO_ERROR ? 0 : (void*)pfn;
+}
+void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
+  DosFreeModule((HMODULE)pHandle);
+}
+#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
+  #define os2DlOpen 0
+  #define os2DlError 0
+  #define os2DlSym 0
+  #define os2DlClose 0
+#endif
+
+
+/*
+** Write up to nBuf bytes of randomness into zBuf.
+*/
+static int os2Randomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
+  ULONG sizeofULong = sizeof(ULONG);
+  int n = 0;
+  if( sizeof(DATETIME) <= nBuf - n ){
+    DATETIME x;
+    DosGetDateTime(&x);
+    memcpy(&zBuf[n], &x, sizeof(x));
+    n += sizeof(x);
+  }
+
+  if( sizeofULong <= nBuf - n ){
+    PPIB ppib;
+    DosGetInfoBlocks(NULL, &ppib);
+    memcpy(&zBuf[n], &ppib->pib_ulpid, sizeofULong);
+    n += sizeofULong;
+  }
+
+  if( sizeofULong <= nBuf - n ){
+    PTIB ptib;
+    DosGetInfoBlocks(&ptib, NULL);
+    memcpy(&zBuf[n], &ptib->tib_ptib2->tib2_ultid, sizeofULong);
+    n += sizeofULong;
+  }
+
+  /* if we still haven't filled the buffer yet the following will */
+  /* grab everything once instead of making several calls for a single item */
+  if( sizeofULong <= nBuf - n ){
+    ULONG ulSysInfo[QSV_MAX];
+    DosQuerySysInfo(1L, QSV_MAX, ulSysInfo, sizeofULong * QSV_MAX);
+
+    memcpy(&zBuf[n], &ulSysInfo[QSV_MS_COUNT - 1], sizeofULong);
+    n += sizeofULong;
+
+    if( sizeofULong <= nBuf - n ){
+      memcpy(&zBuf[n], &ulSysInfo[QSV_TIMER_INTERVAL - 1], sizeofULong);
+      n += sizeofULong;
+    }
+    if( sizeofULong <= nBuf - n ){
+      memcpy(&zBuf[n], &ulSysInfo[QSV_TIME_LOW - 1], sizeofULong);
+      n += sizeofULong;
+    }
+    if( sizeofULong <= nBuf - n ){
+      memcpy(&zBuf[n], &ulSysInfo[QSV_TIME_HIGH - 1], sizeofULong);
+      n += sizeofULong;
+    }
+    if( sizeofULong <= nBuf - n ){
+      memcpy(&zBuf[n], &ulSysInfo[QSV_TOTAVAILMEM - 1], sizeofULong);
+      n += sizeofULong;
+    }
+  }
+
+  return n;
+}
+
+/*
+** Sleep for a little while.  Return the amount of time slept.
+** The argument is the number of microseconds we want to sleep.
+** The return value is the number of microseconds of sleep actually
+** requested from the underlying operating system, a number which
+** might be greater than or equal to the argument, but not less
+** than the argument.
+*/
+static int os2Sleep( sqlite3_vfs *pVfs, int microsec ){
+  DosSleep( (microsec/1000) );
+  return microsec;
+}
+
+/*
+** The following variable, if set to a non-zero value, becomes the result
+** returned from sqlite3OsCurrentTime().  This is used for testing.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_current_time = 0;
+#endif
+
+/*
+** 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 os2CurrentTime( sqlite3_vfs *pVfs, double *prNow ){
+  double now;
+  SHORT minute; /* needs to be able to cope with negative timezone offset */
+  USHORT second, hour,
+         day, month, year;
+  DATETIME dt;
+  DosGetDateTime( &dt );
+  second = (USHORT)dt.seconds;
+  minute = (SHORT)dt.minutes + dt.timezone;
+  hour = (USHORT)dt.hours;
+  day = (USHORT)dt.day;
+  month = (USHORT)dt.month;
+  year = (USHORT)dt.year;
+
+  /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
+     http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c */
+  /* Calculate the Julian days */
+  now = day - 32076 +
+    1461*(year + 4800 + (month - 14)/12)/4 +
+    367*(month - 2 - (month - 14)/12*12)/12 -
+    3*((year + 4900 + (month - 14)/12)/100)/4;
+
+  /* Add the fractional hours, mins and seconds */
+  now += (hour + 12.0)/24.0;
+  now += minute/1440.0;
+  now += second/86400.0;
+  *prNow = now;
+#ifdef SQLITE_TEST
+  if( sqlite3_current_time ){
+    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
+  }
+#endif
+  return 0;
+}
+
+/*
+** Return a pointer to the sqlite3DefaultVfs structure.   We use
+** a function rather than give the structure global scope because
+** some compilers (MSVC) do not allow forward declarations of
+** initialized structures.
+*/
+sqlite3_vfs *sqlite3OsDefaultVfs(void){
+  static sqlite3_vfs os2Vfs = {
+    1,                 /* iVersion */
+    sizeof(os2File),   /* szOsFile */
+    CCHMAXPATH,        /* mxPathname */
+    0,                 /* pNext */
+    "os2",             /* zName */
+    0,                 /* pAppData */
+
+    os2Open,           /* xOpen */
+    os2Delete,         /* xDelete */
+    os2Access,         /* xAccess */
+    os2GetTempname,    /* xGetTempname */
+    os2FullPathname,   /* xFullPathname */
+    os2DlOpen,         /* xDlOpen */
+    os2DlError,        /* xDlError */
+    os2DlSym,          /* xDlSym */
+    os2DlClose,        /* xDlClose */
+    os2Randomness,     /* xRandomness */
+    os2Sleep,          /* xSleep */
+    os2CurrentTime     /* xCurrentTime */
+  };
+
+  return &os2Vfs;
+}
+
+#endif /* OS_OS2 */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_os2.h b/client/src/thirdparty/sqlite-3.4.2/src/os_os2.h
new file mode 100644
index 0000000..de7f385
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_os2.h
@@ -0,0 +1,73 @@
+/*
+** 2004 May 22
+**
+** 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 header file defined OS-specific features for OS/2.
+*/
+#ifndef _SQLITE_OS_OS2_H_
+#define _SQLITE_OS_OS2_H_
+
+/*
+** standard include files.
+*/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/*
+** Macros used to determine whether or not to use threads.  The
+** SQLITE_OS2_THREADS macro is defined if we are synchronizing for
+** Posix threads and SQLITE_W32_THREADS is defined if we are
+** synchronizing using Win32 threads.
+*/
+/* this mutex implementation only available with EMX */
+#if SQLITE_THREADSAFE
+# include <sys/builtin.h>
+# include <sys/smutex.h>
+# define SQLITE_OS2_THREADS 1
+#endif
+
+/*
+** The OsFile structure is a operating-system independing representation
+** of an open file handle.  It is defined differently for each architecture.
+**
+** This is the definition for Unix.
+**
+** OsFile.locktype takes one of the values SHARED_LOCK, RESERVED_LOCK,
+** PENDING_LOCK or EXCLUSIVE_LOCK.
+*/
+typedef struct OsFile OsFile;
+struct OsFile {
+     int h;        /* The file descriptor (LHANDLE) */
+     int locked;              /* True if this user holds the lock */
+     int delOnClose;          /* True if file is to be deleted on close */
+     char *pathToDel;         /* Name of file to delete on close */
+     unsigned char locktype;   /* The type of lock held on this fd */
+     unsigned char isOpen;   /* True if needs to be closed */
+     unsigned char fullSync;
+};
+
+/*
+** Maximum number of characters in a temporary file name
+*/
+#define SQLITE_TEMPNAME_SIZE 200
+
+/*
+** Minimum interval supported by sqlite3OsSleep().
+*/
+#define SQLITE_MIN_SLEEP_MS 1
+
+#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
+# define SQLITE_DEFAULT_FILE_PERMISSIONS 0600
+#endif
+
+#endif /* _SQLITE_OS_OS2_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_test.c b/client/src/thirdparty/sqlite-3.4.2/src/os_test.c
new file mode 100644
index 0000000..9b1c0e2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_test.c
@@ -0,0 +1,463 @@
+/*
+** 2004 May 22
+**
+** 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 that is specific to Unix systems. It is used
+** for testing SQLite only.
+*/
+#if OS_TEST              /* This file is used for the test backend only */
+#include "sqliteInt.h"
+#include "os.h"          /* Must be first to enable large file support */
+
+#define sqlite3OsOpenReadWrite     sqlite3RealOpenReadWrite
+#define sqlite3OsOpenExclusive     sqlite3RealOpenExclusive
+#define sqlite3OsOpenReadOnly      sqlite3RealOpenReadOnly
+#define sqlite3OsOpenDirectory     sqlite3RealOpenDirectory
+#define sqlite3OsClose             sqlite3RealClose
+#define sqlite3OsRead              sqlite3RealRead
+#define sqlite3OsWrite             sqlite3RealWrite
+#define sqlite3OsSeek              sqlite3RealSeek
+#define sqlite3OsSync              sqlite3RealSync
+#define sqlite3OsTruncate          sqlite3RealTruncate
+#define sqlite3OsFileSize          sqlite3RealFileSize
+#define sqlite3OsLock              sqlite3RealLock
+#define sqlite3OsUnlock            sqlite3RealUnlock
+#define sqlite3OsCheckReservedLock sqlite3RealCheckReservedLock
+
+#define OsFile OsRealFile
+#define OS_UNIX 1
+#include "os_unix.c"
+#undef OS_UNIX
+#undef OsFile
+
+#undef sqlite3OsOpenReadWrite     
+#undef sqlite3OsOpenExclusive     
+#undef sqlite3OsOpenReadOnly      
+#undef sqlite3OsOpenDirectory     
+#undef sqlite3OsClose             
+#undef sqlite3OsRead              
+#undef sqlite3OsWrite             
+#undef sqlite3OsSeek              
+#undef sqlite3OsSync              
+#undef sqlite3OsTruncate          
+#undef sqlite3OsFileSize          
+#undef sqlite3OsLock              
+#undef sqlite3OsUnlock            
+#undef sqlite3OsCheckReservedLock 
+
+#define BLOCKSIZE 512
+#define BLOCK_OFFSET(x) ((x) * BLOCKSIZE)
+
+
+/*
+** The following variables control when a simulated crash occurs.
+**
+** If iCrashDelay is non-zero, then zCrashFile contains (full path) name of
+** a file that SQLite will call sqlite3OsSync() on. Each time this happens
+** iCrashDelay is decremented. If iCrashDelay is zero after being
+** decremented, a "crash" occurs during the sync() operation.
+**
+** In other words, a crash occurs the iCrashDelay'th time zCrashFile is
+** synced.
+*/
+static int iCrashDelay = 0;
+char zCrashFile[256];
+
+/*
+** Set the value of the two crash parameters.
+*/
+void sqlite3SetCrashParams(int iDelay, char const *zFile){
+  sqlite3OsEnterMutex();
+  assert( strlen(zFile)<256 );
+  strcpy(zCrashFile, zFile);
+  iCrashDelay = iDelay;
+  sqlite3OsLeaveMutex();
+}
+
+/*
+** File zPath is being sync()ed. Return non-zero if this should
+** cause a crash.
+*/
+static int crashRequired(char const *zPath){
+  int r;
+  int n;
+  sqlite3OsEnterMutex();
+  n = strlen(zCrashFile);
+  if( zCrashFile[n-1]=='*' ){
+    n--;
+  }else if( strlen(zPath)>n ){
+    n = strlen(zPath);
+  }
+  r = 0;
+  if( iCrashDelay>0 && strncmp(zPath, zCrashFile, n)==0 ){
+    iCrashDelay--;
+    if( iCrashDelay<=0 ){
+      r = 1;
+    }
+  }
+  sqlite3OsLeaveMutex();
+  return r;
+}
+
+
+static OsTestFile *pAllFiles = 0;
+
+/*
+** Initialise the os_test.c specific fields of pFile.
+*/
+static void initFile(OsFile *id, char const *zName){
+  OsTestFile *pFile = (OsTestFile *)
+      sqliteMalloc(sizeof(OsTestFile) + strlen(zName)+1);
+  pFile->nMaxWrite = 0; 
+  pFile->nBlk = 0; 
+  pFile->apBlk = 0; 
+  pFile->zName = (char *)(&pFile[1]);
+  strcpy(pFile->zName, zName);
+  *id = pFile;
+  pFile->pNext = pAllFiles;
+  pAllFiles = pFile;
+}
+
+/*
+** Undo the work done by initFile. Delete the OsTestFile structure
+** and unlink the structure from the pAllFiles list.
+*/
+static void closeFile(OsFile *id){
+  OsTestFile *pFile = *id;
+  if( pFile==pAllFiles ){
+    pAllFiles = pFile->pNext;
+  }else{
+    OsTestFile *p;
+    for(p=pAllFiles; p->pNext!=pFile; p=p->pNext ){
+      assert( p );
+    }
+    p->pNext = pFile->pNext;
+  }
+  sqliteFree(pFile);
+  *id = 0;
+}
+
+/*
+** Return the current seek offset from the start of the file. This
+** is unix-only code.
+*/
+static i64 osTell(OsTestFile *pFile){
+  return lseek(pFile->fd.h, 0, SEEK_CUR);
+}
+
+/*
+** Load block 'blk' into the cache of pFile.
+*/
+static int cacheBlock(OsTestFile *pFile, int blk){
+  if( blk>=pFile->nBlk ){
+    int n = ((pFile->nBlk * 2) + 100 + blk);
+    /* if( pFile->nBlk==0 ){ printf("DIRTY %s\n", pFile->zName); } */
+    pFile->apBlk = (u8 **)sqliteRealloc(pFile->apBlk, n * sizeof(u8*));
+    if( !pFile->apBlk ) return SQLITE_NOMEM;
+    memset(&pFile->apBlk[pFile->nBlk], 0, (n - pFile->nBlk)*sizeof(u8*));
+    pFile->nBlk = n;
+  }
+
+  if( !pFile->apBlk[blk] ){
+    i64 filesize;
+    int rc;
+
+    u8 *p = sqliteMalloc(BLOCKSIZE);
+    if( !p ) return SQLITE_NOMEM;
+    pFile->apBlk[blk] = p;
+
+    rc = sqlite3RealFileSize(&pFile->fd, &filesize);
+    if( rc!=SQLITE_OK ) return rc;
+
+    if( BLOCK_OFFSET(blk)<filesize ){
+      int len = BLOCKSIZE;
+      rc = sqlite3RealSeek(&pFile->fd, blk*BLOCKSIZE);
+      if( BLOCK_OFFSET(blk+1)>filesize ){
+        len = filesize - BLOCK_OFFSET(blk);
+      }
+      if( rc!=SQLITE_OK ) return rc;
+      rc = sqlite3RealRead(&pFile->fd, p, len);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+/* #define TRACE_WRITECACHE */
+
+/*
+** Write the cache of pFile to disk. If crash is non-zero, randomly
+** skip blocks when writing. The cache is deleted before returning.
+*/
+static int writeCache2(OsTestFile *pFile, int crash){
+  int i;
+  int nMax = pFile->nMaxWrite;
+  i64 offset;
+  int rc = SQLITE_OK;
+
+  offset = osTell(pFile);
+  for(i=0; i<pFile->nBlk; i++){
+    u8 *p = pFile->apBlk[i];
+    if( p ){
+      int skip = 0;
+      int trash = 0;
+      if( crash ){
+        char random;
+        sqlite3Randomness(1, &random);
+        if( random & 0x01 ){
+          if( random & 0x02 ){
+            trash = 1;
+#ifdef TRACE_WRITECACHE
+printf("Trashing block %d of %s\n", i, pFile->zName); 
+#endif
+          }else{
+            skip = 1;
+#ifdef TRACE_WRITECACHE
+printf("Skiping block %d of %s\n", i, pFile->zName); 
+#endif
+          }
+        }else{
+#ifdef TRACE_WRITECACHE
+printf("Writing block %d of %s\n", i, pFile->zName); 
+#endif
+        }
+      }
+      if( rc==SQLITE_OK ){
+        rc = sqlite3RealSeek(&pFile->fd, BLOCK_OFFSET(i));
+      }
+      if( rc==SQLITE_OK && !skip ){
+        int len = BLOCKSIZE;
+        if( BLOCK_OFFSET(i+1)>nMax ){
+          len = nMax-BLOCK_OFFSET(i);
+        }
+        if( len>0 ){
+          if( trash ){
+            sqlite3Randomness(len, p);
+          }
+          rc = sqlite3RealWrite(&pFile->fd, p, len);
+        }
+      }
+      sqliteFree(p);
+    }
+  }
+  sqliteFree(pFile->apBlk);
+  pFile->nBlk = 0;
+  pFile->apBlk = 0;
+  pFile->nMaxWrite = 0;
+
+  if( rc==SQLITE_OK ){
+    rc = sqlite3RealSeek(&pFile->fd, offset);
+  }
+  return rc;
+}
+
+/*
+** Write the cache to disk.
+*/
+static int writeCache(OsTestFile *pFile){
+  if( pFile->apBlk ){
+    int c = crashRequired(pFile->zName);
+    if( c ){
+      OsTestFile *p;
+#ifdef TRACE_WRITECACHE
+      printf("\nCrash during sync of %s\n", pFile->zName);
+#endif
+      for(p=pAllFiles; p; p=p->pNext){
+        writeCache2(p, 1);
+      }
+      exit(-1);
+    }else{
+      return writeCache2(pFile, 0);
+    }
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Close the file.
+*/
+int sqlite3OsClose(OsFile *id){
+  if( !(*id) ) return SQLITE_OK;
+  if( (*id)->fd.isOpen ){
+    /* printf("CLOSE %s (%d blocks)\n", (*id)->zName, (*id)->nBlk); */
+    writeCache(*id);
+    sqlite3RealClose(&(*id)->fd);
+  }
+  closeFile(id);
+  return SQLITE_OK;
+}
+
+int sqlite3OsRead(OsFile *id, void *pBuf, int amt){
+  i64 offset;       /* The current offset from the start of the file */
+  i64 end;          /* The byte just past the last byte read */
+  int blk;            /* Block number the read starts on */
+  int i;
+  u8 *zCsr;
+  int rc = SQLITE_OK;
+  OsTestFile *pFile = *id;
+
+  offset = osTell(pFile);
+  end = offset+amt;
+  blk = (offset/BLOCKSIZE);
+
+  zCsr = (u8 *)pBuf;
+  for(i=blk; i*BLOCKSIZE<end; i++){
+    int off = 0;
+    int len = 0;
+
+
+    if( BLOCK_OFFSET(i) < offset ){
+      off = offset-BLOCK_OFFSET(i);
+    }
+    len = BLOCKSIZE - off;
+    if( BLOCK_OFFSET(i+1) > end ){
+      len = len - (BLOCK_OFFSET(i+1)-end);
+    }
+
+    if( i<pFile->nBlk && pFile->apBlk[i]){
+      u8 *pBlk = pFile->apBlk[i];
+      memcpy(zCsr, &pBlk[off], len);
+    }else{
+      rc = sqlite3RealSeek(&pFile->fd, BLOCK_OFFSET(i) + off);
+      if( rc!=SQLITE_OK ) return rc;
+      rc = sqlite3RealRead(&pFile->fd, zCsr, len);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+
+    zCsr += len;
+  }
+  assert( zCsr==&((u8 *)pBuf)[amt] );
+
+  rc = sqlite3RealSeek(&pFile->fd, end);
+  return rc;
+}
+
+int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){
+  i64 offset;       /* The current offset from the start of the file */
+  i64 end;          /* The byte just past the last byte written */
+  int blk;            /* Block number the write starts on */
+  int i;
+  const u8 *zCsr;
+  int rc = SQLITE_OK;
+  OsTestFile *pFile = *id;
+
+  offset = osTell(pFile);
+  end = offset+amt;
+  blk = (offset/BLOCKSIZE);
+
+  zCsr = (u8 *)pBuf;
+  for(i=blk; i*BLOCKSIZE<end; i++){
+    u8 *pBlk;
+    int off = 0;
+    int len = 0;
+
+    /* Make sure the block is in the cache */
+    rc = cacheBlock(pFile, i);
+    if( rc!=SQLITE_OK ) return rc;
+
+    /* Write into the cache */
+    pBlk = pFile->apBlk[i];
+    assert( pBlk );
+
+    if( BLOCK_OFFSET(i) < offset ){
+      off = offset-BLOCK_OFFSET(i);
+    }
+    len = BLOCKSIZE - off;
+    if( BLOCK_OFFSET(i+1) > end ){
+      len = len - (BLOCK_OFFSET(i+1)-end);
+    }
+    memcpy(&pBlk[off], zCsr, len);
+    zCsr += len;
+  }
+  if( pFile->nMaxWrite<end ){
+    pFile->nMaxWrite = end;
+  }
+  assert( zCsr==&((u8 *)pBuf)[amt] );
+
+  rc = sqlite3RealSeek(&pFile->fd, end);
+  return rc;
+}
+
+/*
+** Sync the file. First flush the write-cache to disk, then call the
+** real sync() function.
+*/
+int sqlite3OsSync(OsFile *id, int dataOnly){
+  int rc;
+  /* printf("SYNC %s (%d blocks)\n", (*id)->zName, (*id)->nBlk); */
+  rc = writeCache(*id);
+  if( rc!=SQLITE_OK ) return rc;
+  rc = sqlite3RealSync(&(*id)->fd, dataOnly);
+  return rc;
+}
+
+/*
+** Truncate the file. Set the internal OsFile.nMaxWrite variable to the new
+** file size to ensure that nothing in the write-cache past this point
+** is written to disk.
+*/
+int sqlite3OsTruncate(OsFile *id, i64 nByte){
+  (*id)->nMaxWrite = nByte;
+  return sqlite3RealTruncate(&(*id)->fd, nByte);
+}
+
+/*
+** Return the size of the file. If the cache contains a write that extended
+** the file, then return this size instead of the on-disk size.
+*/
+int sqlite3OsFileSize(OsFile *id, i64 *pSize){
+  int rc = sqlite3RealFileSize(&(*id)->fd, pSize);
+  if( rc==SQLITE_OK && pSize && *pSize<(*id)->nMaxWrite ){
+    *pSize = (*id)->nMaxWrite;
+  }
+  return rc;
+}
+
+/*
+** The three functions used to open files. All that is required is to
+** initialise the os_test.c specific fields and then call the corresponding
+** os_unix.c function to really open the file.
+*/
+int sqlite3OsOpenReadWrite(const char *zFilename, OsFile *id, int *pReadonly){
+  initFile(id, zFilename);
+  return sqlite3RealOpenReadWrite(zFilename, &(*id)->fd, pReadonly);
+}
+int sqlite3OsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
+  initFile(id, zFilename);
+  return sqlite3RealOpenExclusive(zFilename, &(*id)->fd, delFlag);
+}
+int sqlite3OsOpenReadOnly(const char *zFilename, OsFile *id){
+  initFile(id, zFilename);
+  return sqlite3RealOpenReadOnly(zFilename, &(*id)->fd);
+}
+
+/*
+** These six function calls are passed straight through to the os_unix.c
+** backend.
+*/
+int sqlite3OsSeek(OsFile *id, i64 offset){
+  return sqlite3RealSeek(&(*id)->fd, offset);
+}
+int sqlite3OsCheckReservedLock(OsFile *id){
+  return sqlite3RealCheckReservedLock(&(*id)->fd);
+}
+int sqlite3OsLock(OsFile *id, int locktype){
+  return sqlite3RealLock(&(*id)->fd, locktype);
+}
+int sqlite3OsUnlock(OsFile *id, int locktype){
+  return sqlite3RealUnlock(&(*id)->fd, locktype);
+}
+int sqlite3OsOpenDirectory(const char *zDirname, OsFile *id){
+  return sqlite3RealOpenDirectory(zDirname, &(*id)->fd);
+}
+
+#endif /* OS_TEST */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_test.h b/client/src/thirdparty/sqlite-3.4.2/src/os_test.h
new file mode 100644
index 0000000..dc0a04a
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_test.h
@@ -0,0 +1,40 @@
+/*
+** 2004 May 22
+**
+** 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.
+**
+******************************************************************************
+**
+*/
+#ifndef _SQLITE_OS_TEST_H_
+#define _SQLITE_OS_TEST_H_
+
+#define OsFile OsRealFile
+#define OS_UNIX 1
+#include "os_unix.h"
+#undef OS_UNIX
+#undef OsFile
+#undef SET_FULLSYNC
+
+/* Include sqliteInt.h now to get the type u8. */
+#include "sqliteInt.h"
+
+typedef struct OsTestFile* OsFile;
+typedef struct OsTestFile OsTestFile;
+struct OsTestFile {
+  u8 **apBlk;       /* Array of blocks that have been written to. */
+  int nBlk;         /* Size of apBlock. */
+  int nMaxWrite;    /* Largest offset written to. */
+  char *zName;      /* File name */
+  OsRealFile fd;
+  OsTestFile *pNext;
+};
+
+void sqlite3SetCrashParams(int iDelay, char const *zFile);
+
+#endif /* _SQLITE_OS_UNIX_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_unix.c b/client/src/thirdparty/sqlite-3.4.2/src/os_unix.c
new file mode 100644
index 0000000..6f9b3c0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_unix.c
@@ -0,0 +1,2758 @@
+/*
+** 2004 May 22
+**
+** 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 that is specific to Unix systems.
+*/
+#include "sqliteInt.h"
+#if OS_UNIX              /* This file is used on unix only */
+
+/* #define SQLITE_ENABLE_LOCKING_STYLE 0 */
+
+/*
+** These #defines should enable >2GB file support on Posix if the
+** underlying operating system supports it.  If the OS lacks
+** large file support, these should be no-ops.
+**
+** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
+** on the compiler command line.  This is necessary if you are compiling
+** on a recent machine (ex: RedHat 7.2) but you want your code to work
+** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
+** without this option, LFS is enable.  But LFS does not exist in the kernel
+** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
+** portability you should omit LFS.
+*/
+#ifndef SQLITE_DISABLE_LFS
+# define _LARGE_FILE       1
+# ifndef _FILE_OFFSET_BITS
+#   define _FILE_OFFSET_BITS 64
+# endif
+# define _LARGEFILE_SOURCE 1
+#endif
+
+/*
+** standard include files.
+*/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <sys/mount.h>
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+/*
+** If we are to be thread-safe, include the pthreads header and define
+** the SQLITE_UNIX_THREADS macro.
+*/
+#if SQLITE_THREADSAFE
+# include <pthread.h>
+# define SQLITE_UNIX_THREADS 1
+#endif
+
+/*
+** Default permissions when creating a new file
+*/
+#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
+# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
+#endif
+
+/*
+** Maximum supported path-length.
+*/
+#define MAX_PATHNAME 512
+
+
+/*
+** The unixFile structure is subclass of sqlite3_file specific for the unix
+** protability layer.
+*/
+typedef struct unixFile unixFile;
+struct unixFile {
+  sqlite3_io_methods const *pMethod;  /* Always the first entry */
+#ifdef SQLITE_TEST
+  /* In test mode, increase the size of this structure a bit so that 
+  ** it is larger than the struct CrashFile defined in test6.c.
+  */
+  char aPadding[32];
+#endif
+  struct openCnt *pOpen;    /* Info about all open fd's on this inode */
+  struct lockInfo *pLock;   /* Info about locks on this inode */
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+  void *lockingContext;     /* Locking style specific state */
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+  int h;                    /* The file descriptor */
+  unsigned char locktype;   /* The type of lock held on this fd */
+  int dirfd;                /* File descriptor for the directory */
+#if SQLITE_THREADSAFE
+  pthread_t tid;            /* The thread that "owns" this unixFile */
+#endif
+};
+
+/*
+** Include code that is common to all os_*.c files
+*/
+#include "os_common.h"
+
+/*
+** Define various macros that are missing from some systems.
+*/
+#ifndef O_LARGEFILE
+# define O_LARGEFILE 0
+#endif
+#ifdef SQLITE_DISABLE_LFS
+# undef O_LARGEFILE
+# define O_LARGEFILE 0
+#endif
+#ifndef O_NOFOLLOW
+# define O_NOFOLLOW 0
+#endif
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif
+
+/*
+** The DJGPP compiler environment looks mostly like Unix, but it
+** lacks the fcntl() system call.  So redefine fcntl() to be something
+** that always succeeds.  This means that locking does not occur under
+** DJGPP.  But it is DOS - what did you expect?
+*/
+#ifdef __DJGPP__
+# define fcntl(A,B,C) 0
+#endif
+
+/*
+** The threadid macro resolves to the thread-id or to 0.  Used for
+** testing and debugging only.
+*/
+#if SQLITE_THREADSAFE
+#define threadid pthread_self()
+#else
+#define threadid 0
+#endif
+
+/*
+** Set or check the unixFile.tid field.  This field is set when an unixFile
+** is first opened.  All subsequent uses of the unixFile verify that the
+** same thread is operating on the unixFile.  Some operating systems do
+** not allow locks to be overridden by other threads and that restriction
+** means that sqlite3* database handles cannot be moved from one thread
+** to another.  This logic makes sure a user does not try to do that
+** by mistake.
+**
+** Version 3.3.1 (2006-01-15):  unixFile can be moved from one thread to
+** another as long as we are running on a system that supports threads
+** overriding each others locks (which now the most common behavior)
+** or if no locks are held.  But the unixFile.pLock field needs to be
+** recomputed because its key includes the thread-id.  See the 
+** transferOwnership() function below for additional information
+*/
+#if SQLITE_THREADSAFE
+# define SET_THREADID(X)   (X)->tid = pthread_self()
+# define CHECK_THREADID(X) (threadsOverrideEachOthersLocks==0 && \
+                            !pthread_equal((X)->tid, pthread_self()))
+#else
+# define SET_THREADID(X)
+# define CHECK_THREADID(X) 0
+#endif
+
+/*
+** Here is the dirt on POSIX advisory locks:  ANSI STD 1003.1 (1996)
+** section 6.5.2.2 lines 483 through 490 specify that when a process
+** sets or clears a lock, that operation overrides any prior locks set
+** by the same process.  It does not explicitly say so, but this implies
+** that it overrides locks set by the same process using a different
+** file descriptor.  Consider this test case:
+**
+**       int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
+**       int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
+**
+** Suppose ./file1 and ./file2 are really the same file (because
+** one is a hard or symbolic link to the other) then if you set
+** an exclusive lock on fd1, then try to get an exclusive lock
+** on fd2, it works.  I would have expected the second lock to
+** fail since there was already a lock on the file due to fd1.
+** But not so.  Since both locks came from the same process, the
+** second overrides the first, even though they were on different
+** file descriptors opened on different file names.
+**
+** Bummer.  If you ask me, this is broken.  Badly broken.  It means
+** that we cannot use POSIX locks to synchronize file access among
+** competing threads of the same process.  POSIX locks will work fine
+** to synchronize access for threads in separate processes, but not
+** threads within the same process.
+**
+** To work around the problem, SQLite has to manage file locks internally
+** on its own.  Whenever a new database is opened, we have to find the
+** specific inode of the database file (the inode is determined by the
+** st_dev and st_ino fields of the stat structure that fstat() fills in)
+** and check for locks already existing on that inode.  When locks are
+** created or removed, we have to look at our own internal record of the
+** locks to see if another thread has previously set a lock on that same
+** inode.
+**
+** The sqlite3_file structure for POSIX is no longer just an integer file
+** descriptor.  It is now a structure that holds the integer file
+** descriptor and a pointer to a structure that describes the internal
+** locks on the corresponding inode.  There is one locking structure
+** per inode, so if the same inode is opened twice, both unixFile structures
+** point to the same locking structure.  The locking structure keeps
+** a reference count (so we will know when to delete it) and a "cnt"
+** field that tells us its internal lock status.  cnt==0 means the
+** file is unlocked.  cnt==-1 means the file has an exclusive lock.
+** cnt>0 means there are cnt shared locks on the file.
+**
+** Any attempt to lock or unlock a file first checks the locking
+** structure.  The fcntl() system call is only invoked to set a 
+** POSIX lock if the internal lock structure transitions between
+** a locked and an unlocked state.
+**
+** 2004-Jan-11:
+** More recent discoveries about POSIX advisory locks.  (The more
+** I discover, the more I realize the a POSIX advisory locks are
+** an abomination.)
+**
+** If you close a file descriptor that points to a file that has locks,
+** all locks on that file that are owned by the current process are
+** released.  To work around this problem, each unixFile structure contains
+** a pointer to an openCnt structure.  There is one openCnt structure
+** per open inode, which means that multiple unixFile can point to a single
+** openCnt.  When an attempt is made to close an unixFile, if there are
+** other unixFile open on the same inode that are holding locks, the call
+** to close() the file descriptor is deferred until all of the locks clear.
+** The openCnt structure keeps a list of file descriptors that need to
+** be closed and that list is walked (and cleared) when the last lock
+** clears.
+**
+** First, under Linux threads, because each thread has a separate
+** process ID, lock operations in one thread do not override locks
+** to the same file in other threads.  Linux threads behave like
+** separate processes in this respect.  But, if you close a file
+** descriptor in linux threads, all locks are cleared, even locks
+** on other threads and even though the other threads have different
+** process IDs.  Linux threads is inconsistent in this respect.
+** (I'm beginning to think that linux threads is an abomination too.)
+** The consequence of this all is that the hash table for the lockInfo
+** structure has to include the process id as part of its key because
+** locks in different threads are treated as distinct.  But the 
+** openCnt structure should not include the process id in its
+** key because close() clears lock on all threads, not just the current
+** thread.  Were it not for this goofiness in linux threads, we could
+** combine the lockInfo and openCnt structures into a single structure.
+**
+** 2004-Jun-28:
+** On some versions of linux, threads can override each others locks.
+** On others not.  Sometimes you can change the behavior on the same
+** system by setting the LD_ASSUME_KERNEL environment variable.  The
+** POSIX standard is silent as to which behavior is correct, as far
+** as I can tell, so other versions of unix might show the same
+** inconsistency.  There is no little doubt in my mind that posix
+** advisory locks and linux threads are profoundly broken.
+**
+** To work around the inconsistencies, we have to test at runtime 
+** whether or not threads can override each others locks.  This test
+** is run once, the first time any lock is attempted.  A static 
+** variable is set to record the results of this test for future
+** use.
+*/
+
+/*
+** An instance of the following structure serves as the key used
+** to locate a particular lockInfo structure given its inode.
+**
+** If threads cannot override each others locks, then we set the
+** lockKey.tid field to the thread ID.  If threads can override
+** each others locks then tid is always set to zero.  tid is omitted
+** if we compile without threading support.
+*/
+struct lockKey {
+  dev_t dev;       /* Device number */
+  ino_t ino;       /* Inode number */
+#if SQLITE_THREADSAFE
+  pthread_t tid;   /* Thread ID or zero if threads can override each other */
+#endif
+};
+
+/*
+** An instance of the following structure is allocated for each open
+** inode on each thread with a different process ID.  (Threads have
+** different process IDs on linux, but not on most other unixes.)
+**
+** A single inode can have multiple file descriptors, so each unixFile
+** structure contains a pointer to an instance of this object and this
+** object keeps a count of the number of unixFile pointing to it.
+*/
+struct lockInfo {
+  struct lockKey key;  /* The lookup key */
+  int cnt;             /* Number of SHARED locks held */
+  int locktype;        /* One of SHARED_LOCK, RESERVED_LOCK etc. */
+  int nRef;            /* Number of pointers to this structure */
+};
+
+/*
+** An instance of the following structure serves as the key used
+** to locate a particular openCnt structure given its inode.  This
+** is the same as the lockKey except that the thread ID is omitted.
+*/
+struct openKey {
+  dev_t dev;   /* Device number */
+  ino_t ino;   /* Inode number */
+};
+
+/*
+** An instance of the following structure is allocated for each open
+** inode.  This structure keeps track of the number of locks on that
+** inode.  If a close is attempted against an inode that is holding
+** locks, the close is deferred until all locks clear by adding the
+** file descriptor to be closed to the pending list.
+*/
+struct openCnt {
+  struct openKey key;   /* The lookup key */
+  int nRef;             /* Number of pointers to this structure */
+  int nLock;            /* Number of outstanding locks */
+  int nPending;         /* Number of pending close() operations */
+  int *aPending;        /* Malloced space holding fd's awaiting a close() */
+};
+
+/* 
+** These hash tables map inodes and file descriptors (really, lockKey and
+** openKey structures) into lockInfo and openCnt structures.  Access to 
+** these hash tables must be protected by a mutex.
+*/
+static Hash lockHash = {SQLITE_HASH_BINARY, 0, 0, 0, 0, 0};
+static Hash openHash = {SQLITE_HASH_BINARY, 0, 0, 0, 0, 0};
+
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+/*
+** The locking styles are associated with the different file locking
+** capabilities supported by different file systems.  
+**
+** POSIX locking style fully supports shared and exclusive byte-range locks 
+** ADP locking only supports exclusive byte-range locks
+** FLOCK only supports a single file-global exclusive lock
+** DOTLOCK isn't a true locking style, it refers to the use of a special
+**   file named the same as the database file with a '.lock' extension, this
+**   can be used on file systems that do not offer any reliable file locking
+** NO locking means that no locking will be attempted, this is only used for
+**   read-only file systems currently
+** UNSUPPORTED means that no locking will be attempted, this is only used for
+**   file systems that are known to be unsupported
+*/
+typedef enum {
+        posixLockingStyle = 0,       /* standard posix-advisory locks */
+        afpLockingStyle,             /* use afp locks */
+        flockLockingStyle,           /* use flock() */
+        dotlockLockingStyle,         /* use <file>.lock files */
+        noLockingStyle,              /* useful for read-only file system */
+        unsupportedLockingStyle      /* indicates unsupported file system */
+} sqlite3LockingStyle;
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+/*
+** Helper functions to obtain and relinquish the global mutex.
+*/
+static void enterMutex(){
+  sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+}
+static void leaveMutex(){
+  sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
+}
+
+#if SQLITE_THREADSAFE
+/*
+** This variable records whether or not threads can override each others
+** locks.
+**
+**    0:  No.  Threads cannot override each others locks.
+**    1:  Yes.  Threads can override each others locks.
+**   -1:  We don't know yet.
+**
+** On some systems, we know at compile-time if threads can override each
+** others locks.  On those systems, the SQLITE_THREAD_OVERRIDE_LOCK macro
+** will be set appropriately.  On other systems, we have to check at
+** runtime.  On these latter systems, SQLTIE_THREAD_OVERRIDE_LOCK is
+** undefined.
+**
+** This variable normally has file scope only.  But during testing, we make
+** it a global so that the test code can change its value in order to verify
+** that the right stuff happens in either case.
+*/
+#ifndef SQLITE_THREAD_OVERRIDE_LOCK
+# define SQLITE_THREAD_OVERRIDE_LOCK -1
+#endif
+#ifdef SQLITE_TEST
+int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK;
+#else
+static int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK;
+#endif
+
+/*
+** This structure holds information passed into individual test
+** threads by the testThreadLockingBehavior() routine.
+*/
+struct threadTestData {
+  int fd;                /* File to be locked */
+  struct flock lock;     /* The locking operation */
+  int result;            /* Result of the locking operation */
+};
+
+#ifdef SQLITE_LOCK_TRACE
+/*
+** Print out information about all locking operations.
+**
+** This routine is used for troubleshooting locks on multithreaded
+** platforms.  Enable by compiling with the -DSQLITE_LOCK_TRACE
+** command-line option on the compiler.  This code is normally
+** turned off.
+*/
+static int lockTrace(int fd, int op, struct flock *p){
+  char *zOpName, *zType;
+  int s;
+  int savedErrno;
+  if( op==F_GETLK ){
+    zOpName = "GETLK";
+  }else if( op==F_SETLK ){
+    zOpName = "SETLK";
+  }else{
+    s = fcntl(fd, op, p);
+    sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
+    return s;
+  }
+  if( p->l_type==F_RDLCK ){
+    zType = "RDLCK";
+  }else if( p->l_type==F_WRLCK ){
+    zType = "WRLCK";
+  }else if( p->l_type==F_UNLCK ){
+    zType = "UNLCK";
+  }else{
+    assert( 0 );
+  }
+  assert( p->l_whence==SEEK_SET );
+  s = fcntl(fd, op, p);
+  savedErrno = errno;
+  sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
+     threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
+     (int)p->l_pid, s);
+  if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
+    struct flock l2;
+    l2 = *p;
+    fcntl(fd, F_GETLK, &l2);
+    if( l2.l_type==F_RDLCK ){
+      zType = "RDLCK";
+    }else if( l2.l_type==F_WRLCK ){
+      zType = "WRLCK";
+    }else if( l2.l_type==F_UNLCK ){
+      zType = "UNLCK";
+    }else{
+      assert( 0 );
+    }
+    sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
+       zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
+  }
+  errno = savedErrno;
+  return s;
+}
+#define fcntl lockTrace
+#endif /* SQLITE_LOCK_TRACE */
+
+/*
+** The testThreadLockingBehavior() routine launches two separate
+** threads on this routine.  This routine attempts to lock a file
+** descriptor then returns.  The success or failure of that attempt
+** allows the testThreadLockingBehavior() procedure to determine
+** whether or not threads can override each others locks.
+*/
+static void *threadLockingTest(void *pArg){
+  struct threadTestData *pData = (struct threadTestData*)pArg;
+  pData->result = fcntl(pData->fd, F_SETLK, &pData->lock);
+  return pArg;
+}
+
+/*
+** This procedure attempts to determine whether or not threads
+** can override each others locks then sets the 
+** threadsOverrideEachOthersLocks variable appropriately.
+*/
+static void testThreadLockingBehavior(int fd_orig){
+  int fd;
+  struct threadTestData d[2];
+  pthread_t t[2];
+
+  fd = dup(fd_orig);
+  if( fd<0 ) return;
+  memset(d, 0, sizeof(d));
+  d[0].fd = fd;
+  d[0].lock.l_type = F_RDLCK;
+  d[0].lock.l_len = 1;
+  d[0].lock.l_start = 0;
+  d[0].lock.l_whence = SEEK_SET;
+  d[1] = d[0];
+  d[1].lock.l_type = F_WRLCK;
+  pthread_create(&t[0], 0, threadLockingTest, &d[0]);
+  pthread_create(&t[1], 0, threadLockingTest, &d[1]);
+  pthread_join(t[0], 0);
+  pthread_join(t[1], 0);
+  close(fd);
+  threadsOverrideEachOthersLocks =  d[0].result==0 && d[1].result==0;
+}
+#endif /* SQLITE_THREADSAFE */
+
+/*
+** Release a lockInfo structure previously allocated by findLockInfo().
+*/
+static void releaseLockInfo(struct lockInfo *pLock){
+  if (pLock == NULL)
+    return;
+  pLock->nRef--;
+  if( pLock->nRef==0 ){
+    sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0);
+    sqlite3_free(pLock);
+  }
+}
+
+/*
+** Release a openCnt structure previously allocated by findLockInfo().
+*/
+static void releaseOpenCnt(struct openCnt *pOpen){
+  if (pOpen == NULL)
+    return;
+  pOpen->nRef--;
+  if( pOpen->nRef==0 ){
+    sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
+    free(pOpen->aPending);
+    sqlite3_free(pOpen);
+  }
+}
+
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+/*
+** Tests a byte-range locking query to see if byte range locks are 
+** supported, if not we fall back to dotlockLockingStyle.
+*/
+static sqlite3LockingStyle sqlite3TestLockingStyle(
+  const char *filePath, 
+  int fd
+){
+  /* test byte-range lock using fcntl */
+  struct flock lockInfo;
+  
+  lockInfo.l_len = 1;
+  lockInfo.l_start = 0;
+  lockInfo.l_whence = SEEK_SET;
+  lockInfo.l_type = F_RDLCK;
+  
+  if( fcntl(fd, F_GETLK, &lockInfo)!=-1 ) {
+    return posixLockingStyle;
+  } 
+  
+  /* testing for flock can give false positives.  So if if the above test
+  ** fails, then we fall back to using dot-lock style locking.
+  */  
+  return dotlockLockingStyle;
+}
+
+/* 
+** Examines the f_fstypename entry in the statfs structure as returned by 
+** stat() for the file system hosting the database file, assigns the 
+** appropriate locking style based on its value.  These values and 
+** assignments are based on Darwin/OSX behavior and have not been tested on 
+** other systems.
+*/
+static sqlite3LockingStyle sqlite3DetectLockingStyle(
+  const char *filePath, 
+  int fd
+){
+
+#ifdef SQLITE_FIXED_LOCKING_STYLE
+  return (sqlite3LockingStyle)SQLITE_FIXED_LOCKING_STYLE;
+#else
+  struct statfs fsInfo;
+
+  if (statfs(filePath, &fsInfo) == -1)
+    return sqlite3TestLockingStyle(filePath, fd);
+  
+  if (fsInfo.f_flags & MNT_RDONLY)
+    return noLockingStyle;
+  
+  if( (!strcmp(fsInfo.f_fstypename, "hfs")) ||
+    (!strcmp(fsInfo.f_fstypename, "ufs")) )
+                return posixLockingStyle;
+  
+  if(!strcmp(fsInfo.f_fstypename, "afpfs"))
+    return afpLockingStyle;
+  
+  if(!strcmp(fsInfo.f_fstypename, "nfs")) 
+    return sqlite3TestLockingStyle(filePath, fd);
+  
+  if(!strcmp(fsInfo.f_fstypename, "smbfs"))
+    return flockLockingStyle;
+  
+  if(!strcmp(fsInfo.f_fstypename, "msdos"))
+    return dotlockLockingStyle;
+  
+  if(!strcmp(fsInfo.f_fstypename, "webdav"))
+    return unsupportedLockingStyle;
+  
+  return sqlite3TestLockingStyle(filePath, fd);  
+#endif /* SQLITE_FIXED_LOCKING_STYLE */
+}
+
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+/*
+** Given a file descriptor, locate lockInfo and openCnt structures that
+** describes that file descriptor.  Create new ones if necessary.  The
+** return values might be uninitialized if an error occurs.
+**
+** Return the number of errors.
+*/
+static int findLockInfo(
+  int fd,                      /* The file descriptor used in the key */
+  struct lockInfo **ppLock,    /* Return the lockInfo structure here */
+  struct openCnt **ppOpen      /* Return the openCnt structure here */
+){
+  int rc;
+  struct lockKey key1;
+  struct openKey key2;
+  struct stat statbuf;
+  struct lockInfo *pLock;
+  struct openCnt *pOpen;
+  rc = fstat(fd, &statbuf);
+  if( rc!=0 ) return 1;
+
+  memset(&key1, 0, sizeof(key1));
+  key1.dev = statbuf.st_dev;
+  key1.ino = statbuf.st_ino;
+#if SQLITE_THREADSAFE
+  if( threadsOverrideEachOthersLocks<0 ){
+    testThreadLockingBehavior(fd);
+  }
+  key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self();
+#endif
+  memset(&key2, 0, sizeof(key2));
+  key2.dev = statbuf.st_dev;
+  key2.ino = statbuf.st_ino;
+  pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1));
+  if( pLock==0 ){
+    struct lockInfo *pOld;
+    pLock = sqlite3_malloc( sizeof(*pLock) );
+    if( pLock==0 ){
+      rc = 1;
+      goto exit_findlockinfo;
+    }
+    pLock->key = key1;
+    pLock->nRef = 1;
+    pLock->cnt = 0;
+    pLock->locktype = 0;
+    pOld = sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock);
+    if( pOld!=0 ){
+      assert( pOld==pLock );
+      sqlite3_free(pLock);
+      rc = 1;
+      goto exit_findlockinfo;
+    }
+  }else{
+    pLock->nRef++;
+  }
+  *ppLock = pLock;
+  if( ppOpen!=0 ){
+    pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
+    if( pOpen==0 ){
+      struct openCnt *pOld;
+      pOpen = sqlite3_malloc( sizeof(*pOpen) );
+      if( pOpen==0 ){
+        releaseLockInfo(pLock);
+        rc = 1;
+        goto exit_findlockinfo;
+      }
+      pOpen->key = key2;
+      pOpen->nRef = 1;
+      pOpen->nLock = 0;
+      pOpen->nPending = 0;
+      pOpen->aPending = 0;
+      pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
+      if( pOld!=0 ){
+        assert( pOld==pOpen );
+        sqlite3_free(pOpen);
+        releaseLockInfo(pLock);
+        rc = 1;
+        goto exit_findlockinfo;
+      }
+    }else{
+      pOpen->nRef++;
+    }
+    *ppOpen = pOpen;
+  }
+
+exit_findlockinfo:
+  return rc;
+}
+
+#ifdef SQLITE_DEBUG
+/*
+** Helper function for printing out trace information from debugging
+** binaries. This returns the string represetation of the supplied
+** integer lock-type.
+*/
+static const char *locktypeName(int locktype){
+  switch( locktype ){
+  case NO_LOCK: return "NONE";
+  case SHARED_LOCK: return "SHARED";
+  case RESERVED_LOCK: return "RESERVED";
+  case PENDING_LOCK: return "PENDING";
+  case EXCLUSIVE_LOCK: return "EXCLUSIVE";
+  }
+  return "ERROR";
+}
+#endif
+
+/*
+** If we are currently in a different thread than the thread that the
+** unixFile argument belongs to, then transfer ownership of the unixFile
+** over to the current thread.
+**
+** A unixFile is only owned by a thread on systems where one thread is
+** unable to override locks created by a different thread.  RedHat9 is
+** an example of such a system.
+**
+** Ownership transfer is only allowed if the unixFile is currently unlocked.
+** If the unixFile is locked and an ownership is wrong, then return
+** SQLITE_MISUSE.  SQLITE_OK is returned if everything works.
+*/
+#if SQLITE_THREADSAFE
+static int transferOwnership(unixFile *pFile){
+  int rc;
+  pthread_t hSelf;
+  if( threadsOverrideEachOthersLocks ){
+    /* Ownership transfers not needed on this system */
+    return SQLITE_OK;
+  }
+  hSelf = pthread_self();
+  if( pthread_equal(pFile->tid, hSelf) ){
+    /* We are still in the same thread */
+    OSTRACE1("No-transfer, same thread\n");
+    return SQLITE_OK;
+  }
+  if( pFile->locktype!=NO_LOCK ){
+    /* We cannot change ownership while we are holding a lock! */
+    return SQLITE_MISUSE;
+  }
+  OSTRACE4("Transfer ownership of %d from %d to %d\n",
+            pFile->h, pFile->tid, hSelf);
+  pFile->tid = hSelf;
+  if (pFile->pLock != NULL) {
+    releaseLockInfo(pFile->pLock);
+    rc = findLockInfo(pFile->h, &pFile->pLock, 0);
+    OSTRACE5("LOCK    %d is now %s(%s,%d)\n", pFile->h,
+           locktypeName(pFile->locktype),
+           locktypeName(pFile->pLock->locktype), pFile->pLock->cnt);
+    return rc;
+  } else {
+    return SQLITE_OK;
+  }
+}
+#else
+  /* On single-threaded builds, ownership transfer is a no-op */
+# define transferOwnership(X) SQLITE_OK
+#endif
+
+/*
+** Seek to the offset passed as the second argument, then read cnt 
+** bytes into pBuf. Return the number of bytes actually read.
+**
+** NB:  If you define USE_PREAD or USE_PREAD64, then it might also
+** be necessary to define _XOPEN_SOURCE to be 500.  This varies from
+** one system to another.  Since SQLite does not define USE_PREAD
+** any any form by default, we will not attempt to define _XOPEN_SOURCE.
+** See tickets #2741 and #2681.
+*/
+static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
+  int got;
+  i64 newOffset;
+  TIMER_START;
+#if defined(USE_PREAD)
+  got = pread(id->h, pBuf, cnt, offset);
+  SimulateIOError( got = -1 );
+#elif defined(USE_PREAD64)
+  got = pread64(id->h, pBuf, cnt, offset);
+  SimulateIOError( got = -1 );
+#else
+  newOffset = lseek(id->h, offset, SEEK_SET);
+  SimulateIOError( newOffset-- );
+  if( newOffset!=offset ){
+    return -1;
+  }
+  got = read(id->h, pBuf, cnt);
+#endif
+  TIMER_END;
+  OSTRACE5("READ    %-3d %5d %7lld %d\n", id->h, got, offset, TIMER_ELAPSED);
+  return got;
+}
+
+/*
+** Read data from a file into a buffer.  Return SQLITE_OK if all
+** bytes were read successfully and SQLITE_IOERR if anything goes
+** wrong.
+*/
+static int unixRead(
+  sqlite3_file *id, 
+  void *pBuf, 
+  int amt,
+  sqlite3_int64 offset
+){
+  int got;
+  assert( id );
+  got = seekAndRead((unixFile*)id, offset, pBuf, amt);
+  if( got==amt ){
+    return SQLITE_OK;
+  }else if( got<0 ){
+    return SQLITE_IOERR_READ;
+  }else{
+    memset(&((char*)pBuf)[got], 0, amt-got);
+    return SQLITE_IOERR_SHORT_READ;
+  }
+}
+
+/*
+** Seek to the offset in id->offset then read cnt bytes into pBuf.
+** Return the number of bytes actually read.  Update the offset.
+*/
+static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
+  int got;
+  i64 newOffset;
+  TIMER_START;
+#if defined(USE_PREAD)
+  got = pwrite(id->h, pBuf, cnt, offset);
+#elif defined(USE_PREAD64)
+  got = pwrite64(id->h, pBuf, cnt, offset);
+#else
+  newOffset = lseek(id->h, offset, SEEK_SET);
+  if( newOffset!=offset ){
+    return -1;
+  }
+  got = write(id->h, pBuf, cnt);
+#endif
+  TIMER_END;
+  OSTRACE5("WRITE   %-3d %5d %7lld %d\n", id->h, got, offset, TIMER_ELAPSED);
+  return got;
+}
+
+
+/*
+** Write data from a buffer into a file.  Return SQLITE_OK on success
+** or some other error code on failure.
+*/
+static int unixWrite(
+  sqlite3_file *id, 
+  const void *pBuf, 
+  int amt,
+  sqlite3_int64 offset 
+){
+  int wrote = 0;
+  assert( id );
+  assert( amt>0 );
+  while( amt>0 && (wrote = seekAndWrite((unixFile*)id, offset, pBuf, amt))>0 ){
+    amt -= wrote;
+    offset += wrote;
+    pBuf = &((char*)pBuf)[wrote];
+  }
+  SimulateIOError(( wrote=(-1), amt=1 ));
+  SimulateDiskfullError(( wrote=0, amt=1 ));
+  if( amt>0 ){
+    if( wrote<0 ){
+      return SQLITE_IOERR_WRITE;
+    }else{
+      return SQLITE_FULL;
+    }
+  }
+  return SQLITE_OK;
+}
+
+#ifdef SQLITE_TEST
+/*
+** Count the number of fullsyncs and normal syncs.  This is used to test
+** that syncs and fullsyncs are occuring at the right times.
+*/
+int sqlite3_sync_count = 0;
+int sqlite3_fullsync_count = 0;
+#endif
+
+/*
+** Use the fdatasync() API only if the HAVE_FDATASYNC macro is defined.
+** Otherwise use fsync() in its place.
+*/
+#ifndef HAVE_FDATASYNC
+# define fdatasync fsync
+#endif
+
+/*
+** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
+** the F_FULLFSYNC macro is defined.  F_FULLFSYNC is currently
+** only available on Mac OS X.  But that could change.
+*/
+#ifdef F_FULLFSYNC
+# define HAVE_FULLFSYNC 1
+#else
+# define HAVE_FULLFSYNC 0
+#endif
+
+
+/*
+** The fsync() system call does not work as advertised on many
+** unix systems.  The following procedure is an attempt to make
+** it work better.
+**
+** 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 dataOnly){
+  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
+  if( fullSync ) sqlite3_fullsync_count++;
+  sqlite3_sync_count++;
+#endif
+
+  /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
+  ** no-op
+  */
+#ifdef SQLITE_NO_SYNC
+  rc = SQLITE_OK;
+#else
+
+#if HAVE_FULLFSYNC
+  if( fullSync ){
+    rc = fcntl(fd, F_FULLFSYNC, 0);
+  }else{
+    rc = 1;
+  }
+  /* If the FULLFSYNC failed, fall back to attempting an fsync().
+   * It shouldn't be possible for fullfsync to fail on the local 
+   * file system (on OSX), so failure indicates that FULLFSYNC
+   * isn't supported for this file system. So, attempt an fsync 
+   * and (for now) ignore the overhead of a superfluous fcntl call.  
+   * It'd be better to detect fullfsync support once and avoid 
+   * the fcntl call every time sync is called.
+   */
+  if( rc ) rc = fsync(fd);
+
+#else 
+  if( dataOnly ){
+    rc = fdatasync(fd);
+  }else{
+    rc = fsync(fd);
+  }
+#endif /* HAVE_FULLFSYNC */
+#endif /* defined(SQLITE_NO_SYNC) */
+
+  return rc;
+}
+
+/*
+** Make sure all writes to a particular file are committed to disk.
+**
+** If dataOnly==0 then both the file itself and its metadata (file
+** size, access time, etc) are synced.  If dataOnly!=0 then only the
+** file data is synced.
+**
+** 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.
+*/
+static int unixSync(sqlite3_file *id, int flags){
+  int rc;
+  unixFile *pFile = (unixFile*)id;
+
+  int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
+  int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
+
+  /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
+  assert((flags&0x0F)==SQLITE_SYNC_NORMAL
+      || (flags&0x0F)==SQLITE_SYNC_FULL
+  );
+
+  assert( pFile );
+  OSTRACE2("SYNC    %-3d\n", pFile->h);
+  rc = full_fsync(pFile->h, isFullsync, isDataOnly);
+  SimulateIOError( rc=1 );
+  if( rc ){
+    return SQLITE_IOERR_FSYNC;
+  }
+  if( pFile->dirfd>=0 ){
+    OSTRACE4("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd,
+            HAVE_FULLFSYNC, isFullsync);
+#ifndef SQLITE_DISABLE_DIRSYNC
+    /* The directory sync is only attempted if full_fsync is
+    ** turned off or unavailable.  If a full_fsync occurred above,
+    ** then the directory sync is superfluous.
+    */
+    if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){
+       /*
+       ** We have received multiple reports of fsync() returning
+       ** errors when applied to directories on certain file systems.
+       ** A failed directory sync is not a big deal.  So it seems
+       ** better to ignore the error.  Ticket #1657
+       */
+       /* return SQLITE_IOERR; */
+    }
+#endif
+    close(pFile->dirfd);  /* Only need to sync once, so close the directory */
+    pFile->dirfd = -1;    /* when we are done. */
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Truncate an open file to a specified size
+*/
+static int unixTruncate(sqlite3_file *id, i64 nByte){
+  int rc;
+  assert( id );
+  SimulateIOError( return SQLITE_IOERR_TRUNCATE );
+  rc = ftruncate(((unixFile*)id)->h, (off_t)nByte);
+  if( rc ){
+    return SQLITE_IOERR_TRUNCATE;
+  }else{
+    return SQLITE_OK;
+  }
+}
+
+/*
+** Determine the current size of a file in bytes
+*/
+static int unixFileSize(sqlite3_file *id, i64 *pSize){
+  int rc;
+  struct stat buf;
+  assert( id );
+  rc = fstat(((unixFile*)id)->h, &buf);
+  SimulateIOError( rc=1 );
+  if( rc!=0 ){
+    return SQLITE_IOERR_FSTAT;
+  }
+  *pSize = buf.st_size;
+  return SQLITE_OK;
+}
+
+/*
+** This routine checks if there is a RESERVED lock held on the specified
+** file by this or any other process. If such a lock is held, return
+** non-zero.  If the file is unlocked or holds only SHARED locks, then
+** return zero.
+*/
+static int unixCheckReservedLock(sqlite3_file *id){
+  int r = 0;
+  unixFile *pFile = (unixFile*)id;
+
+  assert( pFile );
+  enterMutex(); /* Because pFile->pLock is shared across threads */
+
+  /* Check if a thread in this process holds such a lock */
+  if( pFile->pLock->locktype>SHARED_LOCK ){
+    r = 1;
+  }
+
+  /* Otherwise see if some other process holds it.
+  */
+  if( !r ){
+    struct flock lock;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = RESERVED_BYTE;
+    lock.l_len = 1;
+    lock.l_type = F_WRLCK;
+    fcntl(pFile->h, F_GETLK, &lock);
+    if( lock.l_type!=F_UNLCK ){
+      r = 1;
+    }
+  }
+  
+  leaveMutex();
+  OSTRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
+
+  return r;
+}
+
+/*
+** Lock the file with the lock specified by parameter locktype - one
+** of the following:
+**
+**     (1) SHARED_LOCK
+**     (2) RESERVED_LOCK
+**     (3) PENDING_LOCK
+**     (4) EXCLUSIVE_LOCK
+**
+** Sometimes when requesting one lock state, additional lock states
+** are inserted in between.  The locking might fail on one of the later
+** transitions leaving the lock state different from what it started but
+** still short of its goal.  The following chart shows the allowed
+** transitions and the inserted intermediate states:
+**
+**    UNLOCKED -> SHARED
+**    SHARED -> RESERVED
+**    SHARED -> (PENDING) -> EXCLUSIVE
+**    RESERVED -> (PENDING) -> EXCLUSIVE
+**    PENDING -> EXCLUSIVE
+**
+** This routine will only increase a lock.  Use the sqlite3OsUnlock()
+** routine to lower a locking level.
+*/
+static int unixLock(sqlite3_file *id, int locktype){
+  /* The following describes the implementation of the various locks and
+  ** lock transitions in terms of the POSIX advisory shared and exclusive
+  ** lock primitives (called read-locks and write-locks below, to avoid
+  ** confusion with SQLite lock names). The algorithms are complicated
+  ** slightly in order to be compatible with windows systems simultaneously
+  ** accessing the same database file, in case that is ever required.
+  **
+  ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
+  ** byte', each single bytes at well known offsets, and the 'shared byte
+  ** range', a range of 510 bytes at a well known offset.
+  **
+  ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
+  ** byte'.  If this is successful, a random byte from the 'shared byte
+  ** range' is read-locked and the lock on the 'pending byte' released.
+  **
+  ** A process may only obtain a RESERVED lock after it has a SHARED lock.
+  ** A RESERVED lock is implemented by grabbing a write-lock on the
+  ** 'reserved byte'. 
+  **
+  ** A process may only obtain a PENDING lock after it has obtained a
+  ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
+  ** on the 'pending byte'. This ensures that no new SHARED locks can be
+  ** obtained, but existing SHARED locks are allowed to persist. A process
+  ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
+  ** This property is used by the algorithm for rolling back a journal file
+  ** after a crash.
+  **
+  ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
+  ** implemented by obtaining a write-lock on the entire 'shared byte
+  ** range'. Since all other locks require a read-lock on one of the bytes
+  ** within this range, this ensures that no other locks are held on the
+  ** database. 
+  **
+  ** The reason a single byte cannot be used instead of the 'shared byte
+  ** range' is that some versions of windows do not support read-locks. By
+  ** locking a random byte from a range, concurrent SHARED locks may exist
+  ** even if the locking primitive used is always a write-lock.
+  */
+  int rc = SQLITE_OK;
+  unixFile *pFile = (unixFile*)id;
+  struct lockInfo *pLock = pFile->pLock;
+  struct flock lock;
+  int s;
+
+  assert( pFile );
+  OSTRACE7("LOCK    %d %s was %s(%s,%d) pid=%d\n", pFile->h,
+      locktypeName(locktype), locktypeName(pFile->locktype),
+      locktypeName(pLock->locktype), pLock->cnt , getpid());
+
+  /* If there is already a lock of this type or more restrictive on the
+  ** unixFile, do nothing. Don't use the end_lock: exit path, as
+  ** enterMutex() hasn't been called yet.
+  */
+  if( pFile->locktype>=locktype ){
+    OSTRACE3("LOCK    %d %s ok (already held)\n", pFile->h,
+            locktypeName(locktype));
+    return SQLITE_OK;
+  }
+
+  /* Make sure the locking sequence is correct
+  */
+  assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+  assert( locktype!=PENDING_LOCK );
+  assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
+
+  /* This mutex is needed because pFile->pLock is shared across threads
+  */
+  enterMutex();
+
+  /* Make sure the current thread owns the pFile.
+  */
+  rc = transferOwnership(pFile);
+  if( rc!=SQLITE_OK ){
+    leaveMutex();
+    return rc;
+  }
+  pLock = pFile->pLock;
+
+  /* If some thread using this PID has a lock via a different unixFile*
+  ** handle that precludes the requested lock, return BUSY.
+  */
+  if( (pFile->locktype!=pLock->locktype && 
+          (pLock->locktype>=PENDING_LOCK || locktype>SHARED_LOCK))
+  ){
+    rc = SQLITE_BUSY;
+    goto end_lock;
+  }
+
+  /* If a SHARED lock is requested, and some thread using this PID already
+  ** has a SHARED or RESERVED lock, then increment reference counts and
+  ** return SQLITE_OK.
+  */
+  if( locktype==SHARED_LOCK && 
+      (pLock->locktype==SHARED_LOCK || pLock->locktype==RESERVED_LOCK) ){
+    assert( locktype==SHARED_LOCK );
+    assert( pFile->locktype==0 );
+    assert( pLock->cnt>0 );
+    pFile->locktype = SHARED_LOCK;
+    pLock->cnt++;
+    pFile->pOpen->nLock++;
+    goto end_lock;
+  }
+
+  lock.l_len = 1L;
+
+  lock.l_whence = SEEK_SET;
+
+  /* A PENDING lock is needed before acquiring a SHARED lock and before
+  ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
+  ** be released.
+  */
+  if( locktype==SHARED_LOCK 
+      || (locktype==EXCLUSIVE_LOCK && pFile->locktype<PENDING_LOCK)
+  ){
+    lock.l_type = (locktype==SHARED_LOCK?F_RDLCK:F_WRLCK);
+    lock.l_start = PENDING_BYTE;
+    s = fcntl(pFile->h, F_SETLK, &lock);
+    if( s==(-1) ){
+      rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
+      goto end_lock;
+    }
+  }
+
+
+  /* If control gets to this point, then actually go ahead and make
+  ** operating system calls for the specified lock.
+  */
+  if( locktype==SHARED_LOCK ){
+    assert( pLock->cnt==0 );
+    assert( pLock->locktype==0 );
+
+    /* Now get the read-lock */
+    lock.l_start = SHARED_FIRST;
+    lock.l_len = SHARED_SIZE;
+    s = fcntl(pFile->h, F_SETLK, &lock);
+
+    /* Drop the temporary PENDING lock */
+    lock.l_start = PENDING_BYTE;
+    lock.l_len = 1L;
+    lock.l_type = F_UNLCK;
+    if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){
+      rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+      goto end_lock;
+    }
+    if( s==(-1) ){
+      rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
+    }else{
+      pFile->locktype = SHARED_LOCK;
+      pFile->pOpen->nLock++;
+      pLock->cnt = 1;
+    }
+  }else if( locktype==EXCLUSIVE_LOCK && pLock->cnt>1 ){
+    /* We are trying for an exclusive lock but another thread in this
+    ** same process is still holding a shared lock. */
+    rc = SQLITE_BUSY;
+  }else{
+    /* The request was for a RESERVED or EXCLUSIVE lock.  It is
+    ** assumed that there is a SHARED or greater lock on the file
+    ** already.
+    */
+    assert( 0!=pFile->locktype );
+    lock.l_type = F_WRLCK;
+    switch( locktype ){
+      case RESERVED_LOCK:
+        lock.l_start = RESERVED_BYTE;
+        break;
+      case EXCLUSIVE_LOCK:
+        lock.l_start = SHARED_FIRST;
+        lock.l_len = SHARED_SIZE;
+        break;
+      default:
+        assert(0);
+    }
+    s = fcntl(pFile->h, F_SETLK, &lock);
+    if( s==(-1) ){
+      rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
+    }
+  }
+  
+  if( rc==SQLITE_OK ){
+    pFile->locktype = locktype;
+    pLock->locktype = locktype;
+  }else if( locktype==EXCLUSIVE_LOCK ){
+    pFile->locktype = PENDING_LOCK;
+    pLock->locktype = PENDING_LOCK;
+  }
+
+end_lock:
+  leaveMutex();
+  OSTRACE4("LOCK    %d %s %s\n", pFile->h, locktypeName(locktype), 
+      rc==SQLITE_OK ? "ok" : "failed");
+  return rc;
+}
+
+/*
+** Lower the locking level on file descriptor pFile to locktype.  locktype
+** must be either NO_LOCK or SHARED_LOCK.
+**
+** If the locking level of the file descriptor is already at or below
+** the requested locking level, this routine is a no-op.
+*/
+static int unixUnlock(sqlite3_file *id, int locktype){
+  struct lockInfo *pLock;
+  struct flock lock;
+  int rc = SQLITE_OK;
+  unixFile *pFile = (unixFile*)id;
+
+  assert( pFile );
+  OSTRACE7("UNLOCK  %d %d was %d(%d,%d) pid=%d\n", pFile->h, locktype,
+      pFile->locktype, pFile->pLock->locktype, pFile->pLock->cnt, getpid());
+
+  assert( locktype<=SHARED_LOCK );
+  if( pFile->locktype<=locktype ){
+    return SQLITE_OK;
+  }
+  if( CHECK_THREADID(pFile) ){
+    return SQLITE_MISUSE;
+  }
+  enterMutex();
+  pLock = pFile->pLock;
+  assert( pLock->cnt!=0 );
+  if( pFile->locktype>SHARED_LOCK ){
+    assert( pLock->locktype==pFile->locktype );
+    if( locktype==SHARED_LOCK ){
+      lock.l_type = F_RDLCK;
+      lock.l_whence = SEEK_SET;
+      lock.l_start = SHARED_FIRST;
+      lock.l_len = SHARED_SIZE;
+      if( fcntl(pFile->h, F_SETLK, &lock)==(-1) ){
+        /* This should never happen */
+        rc = SQLITE_IOERR_RDLOCK;
+      }
+    }
+    lock.l_type = F_UNLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = PENDING_BYTE;
+    lock.l_len = 2L;  assert( PENDING_BYTE+1==RESERVED_BYTE );
+    if( fcntl(pFile->h, F_SETLK, &lock)!=(-1) ){
+      pLock->locktype = SHARED_LOCK;
+    }else{
+      rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+    }
+  }
+  if( locktype==NO_LOCK ){
+    struct openCnt *pOpen;
+
+    /* Decrement the shared lock counter.  Release the lock using an
+    ** OS call only when all threads in this same process have released
+    ** the lock.
+    */
+    pLock->cnt--;
+    if( pLock->cnt==0 ){
+      lock.l_type = F_UNLCK;
+      lock.l_whence = SEEK_SET;
+      lock.l_start = lock.l_len = 0L;
+      if( fcntl(pFile->h, F_SETLK, &lock)!=(-1) ){
+        pLock->locktype = NO_LOCK;
+      }else{
+        rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+      }
+    }
+
+    /* Decrement the count of locks against this same file.  When the
+    ** count reaches zero, close any other file descriptors whose close
+    ** was deferred because of outstanding locks.
+    */
+    pOpen = pFile->pOpen;
+    pOpen->nLock--;
+    assert( pOpen->nLock>=0 );
+    if( pOpen->nLock==0 && pOpen->nPending>0 ){
+      int i;
+      for(i=0; i<pOpen->nPending; i++){
+        close(pOpen->aPending[i]);
+      }
+      free(pOpen->aPending);
+      pOpen->nPending = 0;
+      pOpen->aPending = 0;
+    }
+  }
+  leaveMutex();
+  pFile->locktype = locktype;
+  return rc;
+}
+
+/*
+** Close a file.
+*/
+static int unixClose(sqlite3_file *id){
+  unixFile *pFile = (unixFile *)id;
+  if( !pFile ) return SQLITE_OK;
+  unixUnlock(id, NO_LOCK);
+  if( pFile->dirfd>=0 ) close(pFile->dirfd);
+  pFile->dirfd = -1;
+  enterMutex();
+
+  if( pFile->pOpen->nLock ){
+    /* If there are outstanding locks, do not actually close the file just
+    ** yet because that would clear those locks.  Instead, add the file
+    ** descriptor to pOpen->aPending.  It will be automatically closed when
+    ** the last lock is cleared.
+    */
+    int *aNew;
+    struct openCnt *pOpen = pFile->pOpen;
+    aNew = realloc( pOpen->aPending, (pOpen->nPending+1)*sizeof(int) );
+    if( aNew==0 ){
+      /* If a malloc fails, just leak the file descriptor */
+    }else{
+      pOpen->aPending = aNew;
+      pOpen->aPending[pOpen->nPending] = pFile->h;
+      pOpen->nPending++;
+    }
+  }else{
+    /* There are no outstanding locks so we can close the file immediately */
+    close(pFile->h);
+  }
+  releaseLockInfo(pFile->pLock);
+  releaseOpenCnt(pFile->pOpen);
+
+  leaveMutex();
+  OSTRACE2("CLOSE   %-3d\n", pFile->h);
+  OpenCounter(-1);
+  memset(pFile, 0, sizeof(unixFile));
+  return SQLITE_OK;
+}
+
+
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+#pragma mark AFP Support
+
+/*
+ ** The afpLockingContext structure contains all afp lock specific state
+ */
+typedef struct afpLockingContext afpLockingContext;
+struct afpLockingContext {
+  unsigned long long sharedLockByte;
+  char *filePath;
+};
+
+struct ByteRangeLockPB2
+{
+  unsigned long long offset;        /* offset to first byte to lock */
+  unsigned long long length;        /* nbr of bytes to lock */
+  unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
+  unsigned char unLockFlag;         /* 1 = unlock, 0 = lock */
+  unsigned char startEndFlag;       /* 1=rel to end of fork, 0=rel to start */
+  int fd;                           /* file desc to assoc this lock with */
+};
+
+#define afpfsByteRangeLock2FSCTL        _IOWR('z', 23, struct ByteRangeLockPB2)
+
+/* 
+** Return 0 on success, 1 on failure.  To match the behavior of the 
+** normal posix file locking (used in unixLock for example), we should 
+** provide 'richer' return codes - specifically to differentiate between
+** 'file busy' and 'file system error' results.
+*/
+static int _AFPFSSetLock(
+  const char *path, 
+  int fd, 
+  unsigned long long offset, 
+  unsigned long long length, 
+  int setLockFlag
+){
+  struct ByteRangeLockPB2       pb;
+  int                     err;
+  
+  pb.unLockFlag = setLockFlag ? 0 : 1;
+  pb.startEndFlag = 0;
+  pb.offset = offset;
+  pb.length = length; 
+  pb.fd = fd;
+  OSTRACE5("AFPLOCK setting lock %s for %d in range %llx:%llx\n", 
+    (setLockFlag?"ON":"OFF"), fd, offset, length);
+  err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
+  if ( err==-1 ) {
+    OSTRACE4("AFPLOCK failed to fsctl() '%s' %d %s\n", path, errno, 
+      strerror(errno));
+    return 1; /* error */
+  } else {
+    return 0;
+  }
+}
+
+/*
+ ** This routine checks if there is a RESERVED lock held on the specified
+ ** file by this or any other process. If such a lock is held, return
+ ** non-zero.  If the file is unlocked or holds only SHARED locks, then
+ ** return zero.
+ */
+static int afpUnixCheckReservedLock(sqlite3_file *id){
+  int r = 0;
+  unixFile *pFile = (unixFile*)id;
+  
+  assert( pFile ); 
+  afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
+  
+  /* Check if a thread in this process holds such a lock */
+  if( pFile->locktype>SHARED_LOCK ){
+    r = 1;
+  }
+  
+  /* Otherwise see if some other process holds it.
+   */
+  if ( !r ) {
+    /* lock the byte */
+    int failed = _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1,1);  
+    if (failed) {
+      /* if we failed to get the lock then someone else must have it */
+      r = 1;
+    } else {
+      /* if we succeeded in taking the reserved lock, unlock it to restore
+      ** the original state */
+      _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1, 0);
+    }
+  }
+  OSTRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
+  
+  return r;
+}
+
+/* AFP-style locking following the behavior of unixLock, see the unixLock 
+** function comments for details of lock management. */
+static int afpUnixLock(sqlite3_file *id, int locktype)
+{
+  int rc = SQLITE_OK;
+  unixFile *pFile = (unixFile*)id;
+  afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
+  int gotPendingLock = 0;
+  
+  assert( pFile );
+  OSTRACE5("LOCK    %d %s was %s pid=%d\n", pFile->h,
+         locktypeName(locktype), locktypeName(pFile->locktype), getpid());  
+  /* If there is already a lock of this type or more restrictive on the
+    ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
+    ** enterMutex() hasn't been called yet.
+    */
+  if( pFile->locktype>=locktype ){
+    OSTRACE3("LOCK    %d %s ok (already held)\n", pFile->h,
+           locktypeName(locktype));
+    return SQLITE_OK;
+  }
+
+  /* Make sure the locking sequence is correct
+    */
+  assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+  assert( locktype!=PENDING_LOCK );
+  assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
+  
+  /* This mutex is needed because pFile->pLock is shared across threads
+    */
+  enterMutex();
+
+  /* Make sure the current thread owns the pFile.
+    */
+  rc = transferOwnership(pFile);
+  if( rc!=SQLITE_OK ){
+    leaveMutex();
+    return rc;
+  }
+    
+  /* A PENDING lock is needed before acquiring a SHARED lock and before
+    ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
+    ** be released.
+    */
+  if( locktype==SHARED_LOCK 
+      || (locktype==EXCLUSIVE_LOCK && pFile->locktype<PENDING_LOCK)
+      ){
+    int failed = _AFPFSSetLock(context->filePath, pFile->h, 
+      PENDING_BYTE, 1, 1);
+    if (failed) {
+      rc = SQLITE_BUSY;
+      goto afp_end_lock;
+    }
+  }
+  
+  /* If control gets to this point, then actually go ahead and make
+    ** operating system calls for the specified lock.
+    */
+  if( locktype==SHARED_LOCK ){
+    int lk, failed;
+    int tries = 0;
+    
+    /* Now get the read-lock */
+    /* note that the quality of the randomness doesn't matter that much */
+    lk = random(); 
+    context->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
+    failed = _AFPFSSetLock(context->filePath, pFile->h, 
+      SHARED_FIRST+context->sharedLockByte, 1, 1);
+    
+    /* Drop the temporary PENDING lock */
+    if (_AFPFSSetLock(context->filePath, pFile->h, PENDING_BYTE, 1, 0)) {
+      rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+      goto afp_end_lock;
+    }
+    
+    if( failed ){
+      rc = SQLITE_BUSY;
+    } else {
+      pFile->locktype = SHARED_LOCK;
+    }
+  }else{
+    /* The request was for a RESERVED or EXCLUSIVE lock.  It is
+    ** assumed that there is a SHARED or greater lock on the file
+    ** already.
+    */
+    int failed = 0;
+    assert( 0!=pFile->locktype );
+    if (locktype >= RESERVED_LOCK && pFile->locktype < RESERVED_LOCK) {
+        /* Acquire a RESERVED lock */
+        failed = _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1,1);
+    }
+    if (!failed && locktype == EXCLUSIVE_LOCK) {
+      /* Acquire an EXCLUSIVE lock */
+        
+      /* Remove the shared lock before trying the range.  we'll need to 
+      ** reestablish the shared lock if we can't get the  afpUnixUnlock
+      */
+      if (!_AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST +
+                         context->sharedLockByte, 1, 0)) {
+        /* now attemmpt to get the exclusive lock range */
+        failed = _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST, 
+                               SHARED_SIZE, 1);
+        if (failed && _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST +
+                                    context->sharedLockByte, 1, 1)) {
+          rc = SQLITE_IOERR_RDLOCK; /* this should never happen */
+        }
+      } else {
+        /* */
+        rc = SQLITE_IOERR_UNLOCK; /* this should never happen */
+      }
+    }
+    if( failed && rc == SQLITE_OK){
+      rc = SQLITE_BUSY;
+    }
+  }
+  
+  if( rc==SQLITE_OK ){
+    pFile->locktype = locktype;
+  }else if( locktype==EXCLUSIVE_LOCK ){
+    pFile->locktype = PENDING_LOCK;
+  }
+  
+afp_end_lock:
+    leaveMutex();
+  OSTRACE4("LOCK    %d %s %s\n", pFile->h, locktypeName(locktype), 
+         rc==SQLITE_OK ? "ok" : "failed");
+  return rc;
+}
+
+/*
+ ** Lower the locking level on file descriptor pFile to locktype.  locktype
+ ** must be either NO_LOCK or SHARED_LOCK.
+ **
+ ** If the locking level of the file descriptor is already at or below
+ ** the requested locking level, this routine is a no-op.
+ */
+static int afpUnixUnlock(sqlite3_file *id, int locktype) {
+  struct flock lock;
+  int rc = SQLITE_OK;
+  unixFile *pFile = (unixFile*)id;
+  afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
+
+  assert( pFile );
+  OSTRACE5("UNLOCK  %d %d was %d pid=%d\n", pFile->h, locktype,
+         pFile->locktype, getpid());
+  
+  assert( locktype<=SHARED_LOCK );
+  if( pFile->locktype<=locktype ){
+    return SQLITE_OK;
+  }
+  if( CHECK_THREADID(pFile) ){
+    return SQLITE_MISUSE;
+  }
+  enterMutex();
+  if( pFile->locktype>SHARED_LOCK ){
+    if( locktype==SHARED_LOCK ){
+      int failed = 0;
+
+      /* unlock the exclusive range - then re-establish the shared lock */
+      if (pFile->locktype==EXCLUSIVE_LOCK) {
+        failed = _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST, 
+                                 SHARED_SIZE, 0);
+        if (!failed) {
+          /* successfully removed the exclusive lock */
+          if (_AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST+
+                            context->sharedLockByte, 1, 1)) {
+            /* failed to re-establish our shared lock */
+            rc = SQLITE_IOERR_RDLOCK; /* This should never happen */
+          }
+        } else {
+          /* This should never happen - failed to unlock the exclusive range */
+          rc = SQLITE_IOERR_UNLOCK;
+        } 
+      }
+    }
+    if (rc == SQLITE_OK && pFile->locktype>=PENDING_LOCK) {
+      if (_AFPFSSetLock(context->filePath, pFile->h, PENDING_BYTE, 1, 0)){
+        /* failed to release the pending lock */
+        rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
+      }
+    } 
+    if (rc == SQLITE_OK && pFile->locktype>=RESERVED_LOCK) {
+      if (_AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1, 0)) {
+        /* failed to release the reserved lock */
+        rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+      }
+    } 
+  }
+  if( locktype==NO_LOCK ){
+    int failed = _AFPFSSetLock(context->filePath, pFile->h, 
+                               SHARED_FIRST + context->sharedLockByte, 1, 0);
+    if (failed) {
+      rc = SQLITE_IOERR_UNLOCK;  /* This should never happen */
+    }
+  }
+  if (rc == SQLITE_OK)
+    pFile->locktype = locktype;
+  leaveMutex();
+  return rc;
+}
+
+/*
+ ** Close a file & cleanup AFP specific locking context 
+ */
+static int afpUnixClose(sqlite3_file *id) {
+  unixFile *pFile = (unixFile*)pId;
+
+  if( !pFile ) return SQLITE_OK;
+  afpUnixUnlock(*pId, NO_LOCK);
+  /* free the AFP locking structure */
+  if (pFile->lockingContext != NULL) {
+    if (((afpLockingContext *)pFile->lockingContext)->filePath != NULL)
+      sqlite3_free(((afpLockingContext*)pFile->lockingContext)->filePath);
+    sqlite3_free(pFile->lockingContext);
+  }
+
+  if( pFile->dirfd>=0 ) close(pFile->dirfd);
+  pFile->dirfd = -1;
+  close(pFile->h);
+  OSTRACE2("CLOSE   %-3d\n", pFile->h);
+  OpenCounter(-1);
+  return SQLITE_OK;
+}
+
+
+#pragma mark flock() style locking
+
+/*
+ ** The flockLockingContext is not used
+ */
+typedef void flockLockingContext;
+
+static int flockUnixCheckReservedLock(sqlite3_file *id) {
+  unixFile *pFile = (unixFile*)id;
+  
+  if (pFile->locktype == RESERVED_LOCK) {
+    return 1; /* already have a reserved lock */
+  } else {
+    /* attempt to get the lock */
+    int rc = flock(pFile->h, LOCK_EX | LOCK_NB);
+    if (!rc) {
+      /* got the lock, unlock it */
+      flock(pFile->h, LOCK_UN);
+      return 0;  /* no one has it reserved */
+    }
+    return 1; /* someone else might have it reserved */
+  }
+}
+
+static int flockUnixLock(sqlite3_file *id, int locktype) {
+  unixFile *pFile = (unixFile*)id;
+  
+  /* if we already have a lock, it is exclusive.  
+  ** Just adjust level and punt on outta here. */
+  if (pFile->locktype > NO_LOCK) {
+    pFile->locktype = locktype;
+    return SQLITE_OK;
+  }
+  
+  /* grab an exclusive lock */
+  int rc = flock(pFile->h, LOCK_EX | LOCK_NB);
+  if (rc) {
+    /* didn't get, must be busy */
+    return SQLITE_BUSY;
+  } else {
+    /* got it, set the type and return ok */
+    pFile->locktype = locktype;
+    return SQLITE_OK;
+  }
+}
+
+static int flockUnixUnlock(sqlite3_file *id, int locktype) {
+  unixFile *pFile = (unixFile*)id;
+  
+  assert( locktype<=SHARED_LOCK );
+  
+  /* no-op if possible */
+  if( pFile->locktype==locktype ){
+    return SQLITE_OK;
+  }
+  
+  /* shared can just be set because we always have an exclusive */
+  if (locktype==SHARED_LOCK) {
+    pFile->locktype = locktype;
+    return SQLITE_OK;
+  }
+  
+  /* no, really, unlock. */
+  int rc = flock(pFile->h, LOCK_UN);
+  if (rc)
+    return SQLITE_IOERR_UNLOCK;
+  else {
+    pFile->locktype = NO_LOCK;
+    return SQLITE_OK;
+  }
+}
+
+/*
+ ** Close a file.
+ */
+static int flockUnixClose(sqlite3_file *pId) {
+  unixFile *pFile = (unixFile*)*pId;
+  
+  if( !pFile ) return SQLITE_OK;
+  flockUnixUnlock(*pId, NO_LOCK);
+  
+  if( pFile->dirfd>=0 ) close(pFile->dirfd);
+  pFile->dirfd = -1;
+  enterMutex();
+  
+  close(pFile->h);  
+  leaveMutex();
+  OSTRACE2("CLOSE   %-3d\n", pFile->h);
+  OpenCounter(-1);
+  return SQLITE_OK;
+}
+
+#pragma mark Old-School .lock file based locking
+
+/*
+ ** The dotlockLockingContext structure contains all dotlock (.lock) lock
+ ** specific state
+ */
+typedef struct dotlockLockingContext dotlockLockingContext;
+struct dotlockLockingContext {
+  char *lockPath;
+};
+
+
+static int dotlockUnixCheckReservedLock(sqlite3_file *id) {
+  unixFile *pFile = (unixFile*)id;
+  dotlockLockingContext *context = 
+    (dotlockLockingContext *) pFile->lockingContext;
+  
+  if (pFile->locktype == RESERVED_LOCK) {
+    return 1; /* already have a reserved lock */
+  } else {
+    struct stat statBuf;
+    if (lstat(context->lockPath,&statBuf) == 0)
+      /* file exists, someone else has the lock */
+      return 1;
+    else
+      /* file does not exist, we could have it if we want it */
+      return 0;
+  }
+}
+
+static int dotlockUnixLock(sqlite3_file *id, int locktype) {
+  unixFile *pFile = (unixFile*)id;
+  dotlockLockingContext *context = 
+    (dotlockLockingContext *) pFile->lockingContext;
+  
+  /* if we already have a lock, it is exclusive.  
+  ** Just adjust level and punt on outta here. */
+  if (pFile->locktype > NO_LOCK) {
+    pFile->locktype = locktype;
+    
+    /* Always update the timestamp on the old file */
+    utimes(context->lockPath,NULL);
+    return SQLITE_OK;
+  }
+  
+  /* check to see if lock file already exists */
+  struct stat statBuf;
+  if (lstat(context->lockPath,&statBuf) == 0){
+    return SQLITE_BUSY; /* it does, busy */
+  }
+  
+  /* grab an exclusive lock */
+  int fd = open(context->lockPath,O_RDONLY|O_CREAT|O_EXCL,0600);
+  if (fd < 0) {
+    /* failed to open/create the file, someone else may have stolen the lock */
+    return SQLITE_BUSY; 
+  }
+  close(fd);
+  
+  /* got it, set the type and return ok */
+  pFile->locktype = locktype;
+  return SQLITE_OK;
+}
+
+static int dotlockUnixUnlock(sqlite3_file *id, int locktype) {
+  unixFile *pFile = (unixFile*)id;
+  dotlockLockingContext *context = 
+    (dotlockLockingContext *) pFile->lockingContext;
+  
+  assert( locktype<=SHARED_LOCK );
+  
+  /* no-op if possible */
+  if( pFile->locktype==locktype ){
+    return SQLITE_OK;
+  }
+  
+  /* shared can just be set because we always have an exclusive */
+  if (locktype==SHARED_LOCK) {
+    pFile->locktype = locktype;
+    return SQLITE_OK;
+  }
+  
+  /* no, really, unlock. */
+  unlink(context->lockPath);
+  pFile->locktype = NO_LOCK;
+  return SQLITE_OK;
+}
+
+/*
+ ** Close a file.
+ */
+static int dotlockUnixClose(sqlite3_file *id) {
+  unixFile *pFile = (unixFile*)id;
+  
+  if( !pFile ) return SQLITE_OK;
+  dotlockUnixUnlock(*pId, NO_LOCK);
+  /* free the dotlock locking structure */
+  if (pFile->lockingContext != NULL) {
+    if (((dotlockLockingContext *)pFile->lockingContext)->lockPath != NULL)
+      sqlite3_free( ( (dotlockLockingContext *)
+        pFile->lockingContext)->lockPath);
+    sqlite3_free(pFile->lockingContext);
+  }
+  
+  if( pFile->dirfd>=0 ) close(pFile->dirfd);
+  pFile->dirfd = -1;
+  enterMutex();
+  
+  close(pFile->h);
+  
+  leaveMutex();
+  OSTRACE2("CLOSE   %-3d\n", pFile->h);
+  OpenCounter(-1);
+  return SQLITE_OK;
+}
+
+
+#pragma mark No locking
+
+/*
+ ** The nolockLockingContext is void
+ */
+typedef void nolockLockingContext;
+
+static int nolockUnixCheckReservedLock(sqlite3_file *id) {
+  return 0;
+}
+
+static int nolockUnixLock(sqlite3_file *id, int locktype) {
+  return SQLITE_OK;
+}
+
+static int nolockUnixUnlock(sqlite3_file *id, int locktype) {
+  return SQLITE_OK;
+}
+
+/*
+ ** Close a file.
+ */
+static int nolockUnixClose(sqlite3_file *id) {
+  unixFile *pFile = (unixFile*)id;
+  
+  if( !pFile ) return SQLITE_OK;
+  if( pFile->dirfd>=0 ) close(pFile->dirfd);
+  pFile->dirfd = -1;
+  enterMutex();
+  
+  close(pFile->h);
+  
+  leaveMutex();
+  OSTRACE2("CLOSE   %-3d\n", pFile->h);
+  OpenCounter(-1);
+  return SQLITE_OK;
+}
+
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+
+/*
+** Information and control of an open file handle.
+*/
+static int unixFileControl(sqlite3_file *id, int op, void *pArg){
+  switch( op ){
+    case SQLITE_FCNTL_LOCKSTATE: {
+      *(int*)pArg = ((unixFile*)id)->locktype;
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_ERROR;
+}
+
+/*
+** Return the sector size in bytes of the underlying block device for
+** the specified file. This is almost always 512 bytes, but may be
+** larger for some devices.
+**
+** SQLite code assumes this function cannot fail. It also assumes that
+** if two files are created in the same file-system directory (i.e.
+** a database and its journal file) that the sector size will be the
+** same for both.
+*/
+static int unixSectorSize(sqlite3_file *id){
+  return SQLITE_DEFAULT_SECTOR_SIZE;
+}
+
+/*
+** Return the device characteristics for the file. This is always 0.
+*/
+static int unixDeviceCharacteristics(sqlite3_file *id){
+  return 0;
+}
+
+/*
+** This vector defines all the methods that can operate on an sqlite3_file
+** for unix.
+*/
+static const sqlite3_io_methods sqlite3UnixIoMethod = {
+  1,                        /* iVersion */
+  unixClose,
+  unixRead,
+  unixWrite,
+  unixTruncate,
+  unixSync,
+  unixFileSize,
+  unixLock,
+  unixUnlock,
+  unixCheckReservedLock,
+  unixFileControl,
+  unixSectorSize,
+  unixDeviceCharacteristics
+};
+
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+/*
+** This vector defines all the methods that can operate on an sqlite3_file
+** for unix with AFP style file locking.
+*/
+static const sqlite3_io_methods sqlite3AFPLockingUnixIoMethod = {
+  1,                        /* iVersion */
+  unixClose,
+  unixRead,
+  unixWrite,
+  unixTruncate,
+  unixSync,
+  unixFileSize,
+  afpUnixLock,
+  afpUnixUnlock,
+  afpUnixCheckReservedLock,
+  unixFileControl,
+  unixSectorSize,
+  unixDeviceCharacteristics
+};
+
+/*
+** This vector defines all the methods that can operate on an sqlite3_file
+** for unix with flock() style file locking.
+*/
+static const sqlite3_io_methods sqlite3FlockLockingUnixIoMethod = {
+  1,                        /* iVersion */
+  flockUnixClose,
+  unixRead,
+  unixWrite,
+  unixTruncate,
+  unixSync,
+  unixFileSize,
+  flockUnixLock,
+  flockUnixUnlock,
+  flockUnixCheckReservedLock,
+  unixFileControl,
+  unixSectorSize,
+  unixDeviceCharacteristics
+};
+
+/*
+** This vector defines all the methods that can operate on an sqlite3_file
+** for unix with dotlock style file locking.
+*/
+static const sqlite3_io_methods sqlite3DotlockLockingUnixIoMethod = {
+  1,                        /* iVersion */
+  dotlockUnixClose,
+  unixRead,
+  unixWrite,
+  unixTruncate,
+  unixSync,
+  unixFileSize,
+  dotlockUnixLock,
+  dotlockUnixUnlock,
+  dotlockUnixCheckReservedLock,
+  unixFileControl,
+  unixSectorSize,
+  unixDeviceCharacteristics
+};
+
+/*
+** This vector defines all the methods that can operate on an sqlite3_file
+** for unix with dotlock style file locking.
+*/
+static const sqlite3_io_methods sqlite3NolockLockingUnixIoMethod = {
+  1,                        /* iVersion */
+  nolockUnixClose,
+  unixRead,
+  unixWrite,
+  unixTruncate,
+  unixSync,
+  unixFileSize,
+  nolockUnixLock,
+  nolockUnixUnlock,
+  nolockUnixCheckReservedLock,
+  unixFileControl,
+  unixSectorSize,
+  unixDeviceCharacteristics
+};
+
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+/*
+** Allocate memory for a new unixFile and initialize that unixFile.
+** Write a pointer to the new unixFile into *pId.
+** If we run out of memory, close the file and return an error.
+*/
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+/* 
+** When locking extensions are enabled, the filepath and locking style 
+** are needed to determine the unixFile pMethod to use for locking operations.
+** The locking-style specific lockingContext data structure is created 
+** and assigned here also.
+*/
+static int fillInUnixFile(
+  int h,                  /* Open file descriptor of file being opened */
+  int dirfd,              /* Directory file descriptor */
+  sqlite3_file *pId,      /* Write completed initialization here */
+  const char *zFilename,  /* Name of the file being opened */
+){
+  sqlite3LockingStyle lockingStyle;
+  unixFile *pNew = (unixFile *)pId;
+  int rc;
+
+  memset(pNew, 0, sizeof(unixFile));
+  lockingStyle = sqlite3DetectLockingStyle(zFilename, h);
+  if ( lockingStyle == posixLockingStyle ) {
+    enterMutex();
+    rc = findLockInfo(h, &pNew->pLock, &pNew->pOpen);
+    leaveMutex();
+    if( rc ){
+      close(h);
+      unlink(zFilename);
+      return SQLITE_NOMEM;
+    }
+  } else {
+    /*  pLock and pOpen are only used for posix advisory locking */
+    pNew->pLock = NULL;
+    pNew->pOpen = NULL;
+  }
+  pNew->dirfd = -1;
+  pNew->h = h;
+  SET_THREADID(pNew);
+  pNew = sqlite3_malloc( sizeof(unixFile) );
+  if( pNew==0 ){
+    close(h);
+    enterMutex();
+    releaseLockInfo(pNew->pLock);
+    releaseOpenCnt(pNew->pOpen);
+    leaveMutex();
+    return SQLITE_NOMEM;
+  }else{
+    switch(lockingStyle) {
+      case afpLockingStyle: {
+        /* afp locking uses the file path so it needs to be included in
+        ** the afpLockingContext */
+        int nFilename;
+        pNew->pMethod = &sqlite3AFPLockingUnixIoMethod;
+        pNew->lockingContext = 
+          sqlite3_malloc(sizeof(afpLockingContext));
+        nFilename = strlen(zFilename)+1;
+        ((afpLockingContext *)pNew->lockingContext)->filePath = 
+          sqlite3_malloc(nFilename);
+        memcpy(((afpLockingContext *)pNew->lockingContext)->filePath, 
+               zFilename, nFilename);
+        srandomdev();
+        break;
+      }
+      case flockLockingStyle:
+        /* flock locking doesn't need additional lockingContext information */
+        pNew->pMethod = &sqlite3FlockLockingUnixIoMethod;
+        break;
+      case dotlockLockingStyle: {
+        /* dotlock locking uses the file path so it needs to be included in
+         ** the dotlockLockingContext */
+        int nFilename;
+        pNew->pMethod = &sqlite3DotlockLockingUnixIoMethod;
+        pNew->lockingContext = sqlite3_malloc(
+          sizeof(dotlockLockingContext));
+        nFilename = strlen(zFilename) + 6;
+        ((dotlockLockingContext *)pNew->lockingContext)->lockPath = 
+            sqlite3_malloc( nFilename );
+        sqlite3_snprintf(nFilename, 
+                ((dotlockLockingContext *)pNew->lockingContext)->lockPath, 
+                "%s.lock", zFilename);
+        break;
+      }
+      case posixLockingStyle:
+        /* posix locking doesn't need additional lockingContext information */
+        pNew->pMethod = &sqlite3UnixIoMethod;
+        break;
+      case noLockingStyle:
+      case unsupportedLockingStyle:
+      default: 
+        pNew->pMethod = &sqlite3NolockLockingUnixIoMethod;
+    }
+    OpenCounter(+1);
+    return SQLITE_OK;
+  }
+}
+#else /* SQLITE_ENABLE_LOCKING_STYLE */
+static int fillInUnixFile(
+  int h,                 /* Open file descriptor on file being opened */
+  int dirfd,
+  sqlite3_file *pId,     /* Write to the unixFile structure here */
+  const char *zFilename  /* Name of the file being opened */
+){
+  unixFile *pNew = (unixFile *)pId;
+  int rc;
+
+#ifdef FD_CLOEXEC
+  fcntl(h, F_SETFD, fcntl(h, F_GETFD, 0) | FD_CLOEXEC);
+#endif
+
+  enterMutex();
+  rc = findLockInfo(h, &pNew->pLock, &pNew->pOpen);
+  leaveMutex();
+  if( rc ){
+    if( dirfd>=0 ) close(dirfd);
+    close(h);
+    return SQLITE_NOMEM;
+  }
+
+  OSTRACE3("OPEN    %-3d %s\n", h, zFilename);
+  pNew->dirfd = -1;
+  pNew->h = h;
+  pNew->dirfd = dirfd;
+  SET_THREADID(pNew);
+
+  pNew->pMethod = &sqlite3UnixIoMethod;
+  OpenCounter(+1);
+  return SQLITE_OK;
+}
+#endif /* SQLITE_ENABLE_LOCKING_STYLE */
+
+/*
+** Open a file descriptor to the directory containing file zFilename.
+** If successful, *pFd is set to the opened file descriptor and
+** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
+** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
+** value.
+**
+** If SQLITE_OK is returned, the caller is responsible for closing
+** the file descriptor *pFd using close().
+*/
+static int openDirectory(const char *zFilename, int *pFd){
+  int ii;
+  int fd = -1;
+  char zDirname[MAX_PATHNAME+1];
+
+  sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
+  for(ii=strlen(zDirname); ii>=0 && zDirname[ii]!='/'; ii--);
+  if( ii>0 ){
+    zDirname[ii] = '\0';
+    fd = open(zDirname, O_RDONLY|O_BINARY, 0);
+    if( fd>=0 ){
+#ifdef FD_CLOEXEC
+      fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
+#endif
+      OSTRACE3("OPENDIR %-3d %s\n", fd, zDirname);
+    }
+  }
+  *pFd = fd;
+  return (fd>=0?SQLITE_OK:SQLITE_CANTOPEN);
+}
+
+/*
+** Open the file zPath.
+** 
+** Previously, the SQLite OS layer used three functions in place of this
+** one:
+**
+**     sqlite3OsOpenReadWrite();
+**     sqlite3OsOpenReadOnly();
+**     sqlite3OsOpenExclusive();
+**
+** These calls correspond to the following combinations of flags:
+**
+**     ReadWrite() ->     (READWRITE | CREATE)
+**     ReadOnly()  ->     (READONLY) 
+**     OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
+**
+** The old OpenExclusive() accepted a boolean argument - "delFlag". If
+** true, the file was configured to be automatically deleted when the
+** file handle closed. To achieve the same effect using this new 
+** interface, add the DELETEONCLOSE flag to those specified above for 
+** OpenExclusive().
+*/
+static int unixOpen(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  int fd = 0;                    /* File descriptor returned by open() */
+  int dirfd = -1;                /* Directory file descriptor */
+  int oflags = 0;                /* Flags to pass to open() */
+  int eType = flags&0xFFFFFF00;  /* Type of file to open */
+
+  int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
+  int isDelete     = (flags & SQLITE_OPEN_DELETEONCLOSE);
+  int isCreate     = (flags & SQLITE_OPEN_CREATE);
+  int isReadonly   = (flags & SQLITE_OPEN_READONLY);
+  int isReadWrite  = (flags & SQLITE_OPEN_READWRITE);
+
+  /* If creating a master or main-file journal, this function will open
+  ** a file-descriptor on the directory too. The first time unixSync()
+  ** is called the directory file descriptor will be fsync()ed and close()d.
+  */
+  int isOpenDirectory = (isCreate && 
+      (eType==SQLITE_OPEN_MASTER_JOURNAL || eType==SQLITE_OPEN_MAIN_JOURNAL)
+  );
+
+  /* Check the following statements are true: 
+  **
+  **   (a) Exactly one of the READWRITE and READONLY flags must be set, and 
+  **   (b) if CREATE is set, then READWRITE must also be set, and
+  **   (c) if EXCLUSIVE is set, then CREATE must also be set.
+  **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
+  */
+  assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
+  assert(isCreate==0 || isReadWrite);
+  assert(isExclusive==0 || isCreate);
+  assert(isDelete==0 || isCreate);
+
+
+  /* The main DB, main journal, and master journal are never automatically
+  ** deleted
+  */
+  assert( eType!=SQLITE_OPEN_MAIN_DB || !isDelete );
+  assert( eType!=SQLITE_OPEN_MAIN_JOURNAL || !isDelete );
+  assert( eType!=SQLITE_OPEN_MASTER_JOURNAL || !isDelete );
+
+  /* Assert that the upper layer has set one of the "file-type" flags. */
+  assert( eType==SQLITE_OPEN_MAIN_DB      || eType==SQLITE_OPEN_TEMP_DB 
+       || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL 
+       || eType==SQLITE_OPEN_SUBJOURNAL   || eType==SQLITE_OPEN_MASTER_JOURNAL 
+       || eType==SQLITE_OPEN_TRANSIENT_DB
+  );
+
+  if( isReadonly )  oflags |= O_RDONLY;
+  if( isReadWrite ) oflags |= O_RDWR;
+  if( isCreate )    oflags |= O_CREAT;
+  if( isExclusive ) oflags |= (O_EXCL|O_NOFOLLOW);
+  oflags |= (O_LARGEFILE|O_BINARY);
+
+  memset(pFile, 0, sizeof(unixFile));
+  fd = open(zPath, oflags, isDelete?0600:SQLITE_DEFAULT_FILE_PERMISSIONS);
+  if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
+    /* Failed to open the file for read/write access. Try read-only. */
+    flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
+    flags |= SQLITE_OPEN_READONLY;
+    return unixOpen(pVfs, zPath, pFile, flags, pOutFlags);
+  }
+  if( fd<0 ){
+    return SQLITE_CANTOPEN;
+  }
+  if( isDelete ){
+    unlink(zPath);
+  }
+  if( pOutFlags ){
+    *pOutFlags = flags;
+  }
+
+  assert(fd!=0);
+  if( isOpenDirectory ){
+    int rc = openDirectory(zPath, &dirfd);
+    if( rc!=SQLITE_OK ){
+      close(fd);
+      return rc;
+    }
+  }
+  return fillInUnixFile(fd, dirfd, pFile, zPath);
+}
+
+/*
+** Delete the file at zPath. If the dirSync argument is true, fsync()
+** the directory after deleting the file.
+*/
+static int unixDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  int rc = SQLITE_OK;
+  SimulateIOError(return SQLITE_IOERR_DELETE);
+  unlink(zPath);
+  if( dirSync ){
+    int fd;
+    rc = openDirectory(zPath, &fd);
+    if( rc==SQLITE_OK ){
+      if( fsync(fd) ){
+        rc = SQLITE_IOERR_DIR_FSYNC;
+      }
+      close(fd);
+    }
+  }
+  return rc;
+}
+
+/*
+** Test the existance of or access permissions of file zPath. The
+** test performed depends on the value of flags:
+**
+**     SQLITE_ACCESS_EXISTS: Return 1 if the file exists
+**     SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
+**     SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
+**
+** Otherwise return 0.
+*/
+static int unixAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+  int amode = 0;
+  switch( flags ){
+    case SQLITE_ACCESS_EXISTS:
+      amode = F_OK;
+      break;
+    case SQLITE_ACCESS_READWRITE:
+      amode = W_OK|R_OK;
+      break;
+    case SQLITE_ACCESS_READ:
+      amode = R_OK;
+      break;
+
+    default:
+      assert(!"Invalid flags argument");
+  }
+  return (access(zPath, amode)==0);
+}
+
+/*
+** Create a temporary file name in zBuf.  zBuf must be allocated
+** by the calling process and must be big enough to hold at least
+** pVfs->mxPathname bytes.
+*/
+static int unixGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
+  static const char *azDirs[] = {
+     0,
+     "/var/tmp",
+     "/usr/tmp",
+     "/tmp",
+     ".",
+  };
+  static const unsigned char zChars[] =
+    "abcdefghijklmnopqrstuvwxyz"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "0123456789";
+  int i, j;
+  struct stat buf;
+  const char *zDir = ".";
+
+  /* It's odd to simulate an io-error here, but really this is just
+  ** using the io-error infrastructure to test that SQLite handles this
+  ** function failing. 
+  */
+  SimulateIOError( return SQLITE_ERROR );
+
+  azDirs[0] = sqlite3_temp_directory;
+  for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
+    if( azDirs[i]==0 ) continue;
+    if( stat(azDirs[i], &buf) ) continue;
+    if( !S_ISDIR(buf.st_mode) ) continue;
+    if( access(azDirs[i], 07) ) continue;
+    zDir = azDirs[i];
+    break;
+  }
+  if( strlen(zDir) - sizeof(SQLITE_TEMP_FILE_PREFIX) - 17 <=0 ){
+    return SQLITE_ERROR;
+  }
+  do{
+    assert( pVfs->mxPathname==MAX_PATHNAME );
+    sqlite3_snprintf(nBuf-17, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
+    j = strlen(zBuf);
+    sqlite3Randomness(15, &zBuf[j]);
+    for(i=0; i<15; i++, j++){
+      zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
+    }
+    zBuf[j] = 0;
+  }while( access(zBuf,0)==0 );
+  return SQLITE_OK;
+}
+
+
+/*
+** Turn a relative pathname into a full pathname. The relative path
+** is stored as a nul-terminated string in the buffer pointed to by
+** zPath. 
+**
+** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes 
+** (in this case, MAX_PATHNAME bytes). The full-path is written to
+** this buffer before returning.
+*/
+static int unixFullPathname(
+  sqlite3_vfs *pVfs,            /* Pointer to vfs object */
+  const char *zPath,            /* Possibly relative input path */
+  int nOut,                     /* Size of output buffer in bytes */
+  char *zOut                    /* Output buffer */
+){
+
+  /* It's odd to simulate an io-error here, but really this is just
+  ** using the io-error infrastructure to test that SQLite handles this
+  ** function failing. This function could fail if, for example, the
+  ** current working directly has been unlinked.
+  */
+  SimulateIOError( return SQLITE_ERROR );
+
+  assert( pVfs->mxPathname==MAX_PATHNAME );
+  zOut[nOut-1] = '\0';
+  if( zPath[0]=='/' ){
+    sqlite3_snprintf(nOut, zOut, "%s", zPath);
+  }else{
+    int nCwd;
+    if( getcwd(zOut, nOut-1)==0 ){
+      return SQLITE_CANTOPEN;
+    }
+    nCwd = strlen(zOut);
+    sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
+  }
+  return SQLITE_OK;
+
+#if 0
+  /*
+  ** Remove "/./" path elements and convert "/A/./" path elements
+  ** to just "/".
+  */
+  if( zFull ){
+    int i, j;
+    for(i=j=0; zFull[i]; i++){
+      if( zFull[i]=='/' ){
+        if( zFull[i+1]=='/' ) continue;
+        if( zFull[i+1]=='.' && zFull[i+2]=='/' ){
+          i += 1;
+          continue;
+        }
+        if( zFull[i+1]=='.' && zFull[i+2]=='.' && zFull[i+3]=='/' ){
+          while( j>0 && zFull[j-1]!='/' ){ j--; }
+          i += 3;
+          continue;
+        }
+      }
+      zFull[j++] = zFull[i];
+    }
+    zFull[j] = 0;
+  }
+#endif
+}
+
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** Interfaces for opening a shared library, finding entry points
+** within the shared library, and closing the shared library.
+*/
+#include <dlfcn.h>
+static void *unixDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
+  return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
+}
+
+/*
+** SQLite calls this function immediately after a call to unixDlSym() or
+** unixDlOpen() fails (returns a null pointer). If a more detailed error
+** message is available, it is written to zBufOut. If no error message
+** is available, zBufOut is left unmodified and SQLite uses a default
+** error message.
+*/
+static void unixDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
+  char *zErr;
+  enterMutex();
+  zErr = dlerror();
+  if( zErr ){
+    sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
+  }
+  leaveMutex();
+}
+static void *unixDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  return dlsym(pHandle, zSymbol);
+}
+static void unixDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  dlclose(pHandle);
+}
+#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
+  #define unixDlOpen  0
+  #define unixDlError 0
+  #define unixDlSym   0
+  #define unixDlClose 0
+#endif
+
+/*
+** Write nBuf bytes of random data to the supplied buffer zBuf.
+*/
+static int unixRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
+
+  assert(nBuf>=(sizeof(time_t)+sizeof(int)));
+
+  /* We have to initialize zBuf to prevent valgrind from reporting
+  ** errors.  The reports issued by valgrind are incorrect - we would
+  ** prefer that the randomness be increased by making use of the
+  ** uninitialized space in zBuf - but valgrind errors tend to worry
+  ** some users.  Rather than argue, it seems easier just to initialize
+  ** the whole array and silence valgrind, even if that means less randomness
+  ** in the random seed.
+  **
+  ** When testing, initializing zBuf[] to zero is all we do.  That means
+  ** that we always use the same random number sequence.  This makes the
+  ** tests repeatable.
+  */
+  memset(zBuf, 0, nBuf);
+#if !defined(SQLITE_TEST)
+  {
+    int pid, fd;
+    fd = open("/dev/urandom", O_RDONLY);
+    if( fd<0 ){
+      time_t t;
+      time(&t);
+      memcpy(zBuf, &t, sizeof(t));
+      pid = getpid();
+      memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
+    }else{
+      read(fd, zBuf, nBuf);
+      close(fd);
+    }
+  }
+#endif
+  return SQLITE_OK;
+}
+
+
+/*
+** Sleep for a little while.  Return the amount of time slept.
+** The argument is the number of microseconds we want to sleep.
+** The return value is the number of microseconds of sleep actually
+** requested from the underlying operating system, a number which
+** might be greater than or equal to the argument, but not less
+** than the argument.
+*/
+static int unixSleep(sqlite3_vfs *pVfs, int microseconds){
+#if defined(HAVE_USLEEP) && HAVE_USLEEP
+  usleep(microseconds);
+  return microseconds;
+#else
+  int seconds = (microseconds+999999)/1000000;
+  sleep(seconds);
+  return seconds*1000000;
+#endif
+}
+
+/*
+** The following variable, if set to a non-zero value, becomes the result
+** returned from sqlite3OsCurrentTime().  This is used for testing.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_current_time = 0;
+#endif
+
+/*
+** 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.
+*/
+static int unixCurrentTime(sqlite3_vfs *pVfs, double *prNow){
+#ifdef NO_GETTOD
+  time_t t;
+  time(&t);
+  *prNow = t/86400.0 + 2440587.5;
+#else
+  struct timeval sNow;
+  gettimeofday(&sNow, 0);
+  *prNow = 2440587.5 + sNow.tv_sec/86400.0 + sNow.tv_usec/86400000000.0;
+#endif
+#ifdef SQLITE_TEST
+  if( sqlite3_current_time ){
+    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
+  }
+#endif
+  return 0;
+}
+
+/*
+** Return a pointer to the sqlite3DefaultVfs structure.   We use
+** a function rather than give the structure global scope because
+** some compilers (MSVC) do not allow forward declarations of
+** initialized structures.
+*/
+sqlite3_vfs *sqlite3OsDefaultVfs(void){
+  static sqlite3_vfs unixVfs = {
+    1,                  /* iVersion */
+    sizeof(unixFile),   /* szOsFile */
+    MAX_PATHNAME,       /* mxPathname */
+    0,                  /* pNext */
+    "unix",             /* zName */
+    0,                  /* pAppData */
+  
+    unixOpen,           /* xOpen */
+    unixDelete,         /* xDelete */
+    unixAccess,         /* xAccess */
+    unixGetTempname,    /* xGetTempName */
+    unixFullPathname,   /* xFullPathname */
+    unixDlOpen,         /* xDlOpen */
+    unixDlError,        /* xDlError */
+    unixDlSym,          /* xDlSym */
+    unixDlClose,        /* xDlClose */
+    unixRandomness,     /* xRandomness */
+    unixSleep,          /* xSleep */
+    unixCurrentTime     /* xCurrentTime */
+  };
+  
+  return &unixVfs;
+}
+ 
+#endif /* OS_UNIX */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_unix.h b/client/src/thirdparty/sqlite-3.4.2/src/os_unix.h
new file mode 100644
index 0000000..5fdfc2f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_unix.h
@@ -0,0 +1,116 @@
+/*
+** 2004 May 22
+**
+** 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 header file defined OS-specific features for Unix.
+*/
+#ifndef _SQLITE_OS_UNIX_H_
+#define _SQLITE_OS_UNIX_H_
+
+/*
+** Helpful hint:  To get this to compile on HP/UX, add -D_INCLUDE_POSIX_SOURCE
+** to the compiler command line.
+*/
+
+/*
+** These #defines should enable >2GB file support on Posix if the
+** underlying operating system supports it.  If the OS lacks
+** large file support, or if the OS is windows, these should be no-ops.
+**
+** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
+** on the compiler command line.  This is necessary if you are compiling
+** on a recent machine (ex: RedHat 7.2) but you want your code to work
+** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
+** without this option, LFS is enable.  But LFS does not exist in the kernel
+** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
+** portability you should omit LFS.
+**
+** Similar is true for MacOS.  LFS is only supported on MacOS 9 and later.
+*/
+#ifndef SQLITE_DISABLE_LFS
+# define _LARGE_FILE       1
+# ifndef _FILE_OFFSET_BITS
+#   define _FILE_OFFSET_BITS 64
+# endif
+# define _LARGEFILE_SOURCE 1
+#endif
+
+/*
+** standard include files.
+*/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/*
+** Macros used to determine whether or not to use threads.  The
+** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for
+** Posix threads and SQLITE_W32_THREADS is defined if we are
+** synchronizing using Win32 threads.
+*/
+#if defined(THREADSAFE) && THREADSAFE
+# include <pthread.h>
+# define SQLITE_UNIX_THREADS 1
+#endif
+
+/*
+** The OsFile structure is a operating-system independing representation
+** of an open file handle.  It is defined differently for each architecture.
+**
+** This is the definition for Unix.
+**
+** OsFile.locktype takes one of the values SHARED_LOCK, RESERVED_LOCK,
+** PENDING_LOCK or EXCLUSIVE_LOCK.
+*/
+typedef struct OsFile OsFile;
+struct OsFile {
+  struct Pager *pPager;     /* The pager that owns this OsFile.  Might be 0 */
+  struct openCnt *pOpen;    /* Info about all open fd's on this inode */
+  struct lockInfo *pLock;   /* Info about locks on this inode */
+  int h;                    /* The file descriptor */
+  unsigned char locktype;   /* The type of lock held on this fd */
+  unsigned char isOpen;     /* True if needs to be closed */
+  unsigned char fullSync;   /* Use F_FULLSYNC if available */
+  int dirfd;                /* File descriptor for the directory */
+#ifdef SQLITE_UNIX_THREADS
+  pthread_t tid;            /* The thread authorized to use this OsFile */
+#endif
+};
+
+/*
+** A macro to set the OsFile.fullSync flag, if it exists.
+*/
+#define SET_FULLSYNC(x,y)  ((x).fullSync = (y))
+
+/*
+** Maximum number of characters in a temporary file name
+*/
+#define SQLITE_TEMPNAME_SIZE 200
+
+/*
+** Minimum interval supported by sqlite3OsSleep().
+*/
+#if defined(HAVE_USLEEP) && HAVE_USLEEP
+# define SQLITE_MIN_SLEEP_MS 1
+#else
+# define SQLITE_MIN_SLEEP_MS 1000
+#endif
+
+/*
+** Default permissions when creating a new file
+*/
+#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
+# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
+#endif
+
+
+#endif /* _SQLITE_OS_UNIX_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_win.c b/client/src/thirdparty/sqlite-3.4.2/src/os_win.c
new file mode 100644
index 0000000..e5555f1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_win.c
@@ -0,0 +1,1557 @@
+/*
+** 2004 May 22
+**
+** 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 that is specific to windows.
+*/
+#include "sqliteInt.h"
+#if OS_WIN               /* This file is used for windows only */
+
+
+/*
+** A Note About Memory Allocation:
+**
+** This driver uses malloc()/free() directly rather than going through
+** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers
+** are designed for use on embedded systems where memory is scarce and
+** malloc failures happen frequently.  Win32 does not typically run on
+** embedded systems, and when it does the developers normally have bigger
+** problems to worry about than running out of memory.  So there is not
+** a compelling need to use the wrappers.
+**
+** But there is a good reason to not use the wrappers.  If we use the
+** wrappers then we will get simulated malloc() failures within this
+** driver.  And that causes all kinds of problems for our tests.  We
+** could enhance SQLite to deal with simulated malloc failures within
+** the OS driver, but the code to deal with those failure would not
+** be exercised on Linux (which does not need to malloc() in the driver)
+** and so we would have difficulty writing coverage tests for that
+** code.  Better to leave the code out, we think.
+**
+** The point of this discussion is as follows:  When creating a new
+** OS layer for an embedded system, if you use this file as an example,
+** avoid the use of malloc()/free().  Those routines work ok on windows
+** desktops but not so well in embedded systems.
+*/
+
+#include <winbase.h>
+
+#ifdef __CYGWIN__
+# include <sys/cygwin.h>
+#endif
+
+/*
+** Macros used to determine whether or not to use threads.
+*/
+#if defined(THREADSAFE) && THREADSAFE
+# define SQLITE_W32_THREADS 1
+#endif
+
+/*
+** Include code that is common to all os_*.c files
+*/
+#include "os_common.h"
+
+/*
+** Determine if we are dealing with WindowsCE - which has a much
+** reduced API.
+*/
+#if defined(_WIN32_WCE)
+# define OS_WINCE 1
+# define AreFileApisANSI() 1
+#else
+# define OS_WINCE 0
+#endif
+
+/*
+** WinCE lacks native support for file locking so we have to fake it
+** with some code of our own.
+*/
+#if OS_WINCE
+typedef struct winceLock {
+  int nReaders;       /* Number of reader locks obtained */
+  BOOL bPending;      /* Indicates a pending lock has been obtained */
+  BOOL bReserved;     /* Indicates a reserved lock has been obtained */
+  BOOL bExclusive;    /* Indicates an exclusive lock has been obtained */
+} winceLock;
+#endif
+
+/*
+** The winFile structure is a subclass of sqlite3_file* specific to the win32
+** portability layer.
+*/
+typedef struct winFile winFile;
+struct winFile {
+  const sqlite3_io_methods *pMethod;/* Must be first */
+  HANDLE h;               /* Handle for accessing the file */
+  unsigned char locktype; /* Type of lock currently held on this file */
+  short sharedLockByte;   /* Randomly chosen byte used as a shared lock */
+#if OS_WINCE
+  WCHAR *zDeleteOnClose;  /* Name of file to delete when closing */
+  HANDLE hMutex;          /* Mutex used to control access to shared lock */  
+  HANDLE hShared;         /* Shared memory segment used for locking */
+  winceLock local;        /* Locks obtained by this instance of winFile */
+  winceLock *shared;      /* Global shared lock memory for the file  */
+#endif
+};
+
+
+/*
+** The following variable is (normally) set once and never changes
+** thereafter.  It records whether the operating system is Win95
+** or WinNT.
+**
+** 0:   Operating system unknown.
+** 1:   Operating system is Win95.
+** 2:   Operating system is WinNT.
+**
+** In order to facilitate testing on a WinNT system, the test fixture
+** can manually set this value to 1 to emulate Win98 behavior.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_os_type = 0;
+#else
+static int sqlite3_os_type = 0;
+#endif
+
+/*
+** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
+** or WinCE.  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.
+*/
+#if OS_WINCE
+# define isNT()  (1)
+#else
+  static int isNT(void){
+    if( sqlite3_os_type==0 ){
+      OSVERSIONINFO sInfo;
+      sInfo.dwOSVersionInfoSize = sizeof(sInfo);
+      GetVersionEx(&sInfo);
+      sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
+    }
+    return sqlite3_os_type==2;
+  }
+#endif /* OS_WINCE */
+
+/*
+** Convert a UTF-8 string to microsoft unicode (UTF-16?). 
+**
+** Space to hold the returned string is obtained from malloc.
+*/
+static WCHAR *utf8ToUnicode(const char *zFilename){
+  int nChar;
+  WCHAR *zWideFilename;
+
+  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
+  zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
+  if( zWideFilename==0 ){
+    return 0;
+  }
+  nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
+  if( nChar==0 ){
+    free(zWideFilename);
+    zWideFilename = 0;
+  }
+  return zWideFilename;
+}
+
+/*
+** Convert microsoft unicode to UTF-8.  Space to hold the returned string is
+** obtained from malloc().
+*/
+static char *unicodeToUtf8(const WCHAR *zWideFilename){
+  int nByte;
+  char *zFilename;
+
+  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
+  zFilename = malloc( nByte );
+  if( zFilename==0 ){
+    return 0;
+  }
+  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
+                              0, 0);
+  if( nByte == 0 ){
+    free(zFilename);
+    zFilename = 0;
+  }
+  return zFilename;
+}
+
+/*
+** Convert an ansi string to microsoft unicode, based on the
+** current codepage settings for file apis.
+** 
+** Space to hold the returned string is obtained
+** from malloc.
+*/
+static WCHAR *mbcsToUnicode(const char *zFilename){
+  int nByte;
+  WCHAR *zMbcsFilename;
+  int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+
+  nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
+  zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
+  if( zMbcsFilename==0 ){
+    return 0;
+  }
+  nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
+  if( nByte==0 ){
+    free(zMbcsFilename);
+    zMbcsFilename = 0;
+  }
+  return zMbcsFilename;
+}
+
+/*
+** Convert microsoft unicode to multibyte character string, based on the
+** user's Ansi codepage.
+**
+** Space to hold the returned string is obtained from
+** malloc().
+*/
+static char *unicodeToMbcs(const WCHAR *zWideFilename){
+  int nByte;
+  char *zFilename;
+  int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+
+  nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
+  zFilename = malloc( nByte );
+  if( zFilename==0 ){
+    return 0;
+  }
+  nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
+                              0, 0);
+  if( nByte == 0 ){
+    free(zFilename);
+    zFilename = 0;
+  }
+  return zFilename;
+}
+
+/*
+** Convert multibyte character string to UTF-8.  Space to hold the
+** returned string is obtained from malloc().
+*/
+static char *mbcsToUtf8(const char *zFilename){
+  char *zFilenameUtf8;
+  WCHAR *zTmpWide;
+
+  zTmpWide = mbcsToUnicode(zFilename);
+  if( zTmpWide==0 ){
+    return 0;
+  }
+  zFilenameUtf8 = unicodeToUtf8(zTmpWide);
+  free(zTmpWide);
+  return zFilenameUtf8;
+}
+
+/*
+** Convert UTF-8 to multibyte character string.  Space to hold the 
+** returned string is obtained from malloc().
+*/
+static char *utf8ToMbcs(const char *zFilename){
+  char *zFilenameMbcs;
+  WCHAR *zTmpWide;
+
+  zTmpWide = utf8ToUnicode(zFilename);
+  if( zTmpWide==0 ){
+    return 0;
+  }
+  zFilenameMbcs = unicodeToMbcs(zTmpWide);
+  free(zTmpWide);
+  return zFilenameMbcs;
+}
+
+#if OS_WINCE
+/*************************************************************************
+** This section contains code for WinCE only.
+*/
+/*
+** WindowsCE does not have a localtime() function.  So create a
+** substitute.
+*/
+#include <time.h>
+struct tm *__cdecl localtime(const time_t *t)
+{
+  static struct tm y;
+  FILETIME uTm, lTm;
+  SYSTEMTIME pTm;
+  sqlite3_int64 t64;
+  t64 = *t;
+  t64 = (t64 + 11644473600)*10000000;
+  uTm.dwLowDateTime = t64 & 0xFFFFFFFF;
+  uTm.dwHighDateTime= t64 >> 32;
+  FileTimeToLocalFileTime(&uTm,&lTm);
+  FileTimeToSystemTime(&lTm,&pTm);
+  y.tm_year = pTm.wYear - 1900;
+  y.tm_mon = pTm.wMonth - 1;
+  y.tm_wday = pTm.wDayOfWeek;
+  y.tm_mday = pTm.wDay;
+  y.tm_hour = pTm.wHour;
+  y.tm_min = pTm.wMinute;
+  y.tm_sec = pTm.wSecond;
+  return &y;
+}
+
+/* This will never be called, but defined to make the code compile */
+#define GetTempPathA(a,b)
+
+#define LockFile(a,b,c,d,e)       winceLockFile(&a, b, c, d, e)
+#define UnlockFile(a,b,c,d,e)     winceUnlockFile(&a, b, c, d, e)
+#define LockFileEx(a,b,c,d,e,f)   winceLockFileEx(&a, b, c, d, e, f)
+
+#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-offsetof(winFile,h)]
+
+/*
+** Acquire a lock on the handle h
+*/
+static void winceMutexAcquire(HANDLE h){
+   DWORD dwErr;
+   do {
+     dwErr = WaitForSingleObject(h, INFINITE);
+   } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
+}
+/*
+** Release a lock acquired by winceMutexAcquire()
+*/
+#define winceMutexRelease(h) ReleaseMutex(h)
+
+/*
+** Create the mutex and shared memory used for locking in the file
+** descriptor pFile
+*/
+static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
+  WCHAR *zTok;
+  WCHAR *zName = utf8ToUnicode(zFilename);
+  BOOL bInit = TRUE;
+
+  /* Initialize the local lockdata */
+  ZeroMemory(&pFile->local, sizeof(pFile->local));
+
+  /* Replace the backslashes from the filename and lowercase it
+  ** to derive a mutex name. */
+  zTok = CharLowerW(zName);
+  for (;*zTok;zTok++){
+    if (*zTok == '\\') *zTok = '_';
+  }
+
+  /* Create/open the named mutex */
+  pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
+  if (!pFile->hMutex){
+    free(zName);
+    return FALSE;
+  }
+
+  /* Acquire the mutex before continuing */
+  winceMutexAcquire(pFile->hMutex);
+  
+  /* Since the names of named mutexes, semaphores, file mappings etc are 
+  ** case-sensitive, take advantage of that by uppercasing the mutex name
+  ** and using that as the shared filemapping name.
+  */
+  CharUpperW(zName);
+  pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
+                                       PAGE_READWRITE, 0, sizeof(winceLock),
+                                       zName);  
+
+  /* Set a flag that indicates we're the first to create the memory so it 
+  ** must be zero-initialized */
+  if (GetLastError() == ERROR_ALREADY_EXISTS){
+    bInit = FALSE;
+  }
+
+  free(zName);
+
+  /* If we succeeded in making the shared memory handle, map it. */
+  if (pFile->hShared){
+    pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, 
+             FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
+    /* If mapping failed, close the shared memory handle and erase it */
+    if (!pFile->shared){
+      CloseHandle(pFile->hShared);
+      pFile->hShared = NULL;
+    }
+  }
+
+  /* If shared memory could not be created, then close the mutex and fail */
+  if (pFile->hShared == NULL){
+    winceMutexRelease(pFile->hMutex);
+    CloseHandle(pFile->hMutex);
+    pFile->hMutex = NULL;
+    return FALSE;
+  }
+  
+  /* Initialize the shared memory if we're supposed to */
+  if (bInit) {
+    ZeroMemory(pFile->shared, sizeof(winceLock));
+  }
+
+  winceMutexRelease(pFile->hMutex);
+  return TRUE;
+}
+
+/*
+** Destroy the part of winFile that deals with wince locks
+*/
+static void winceDestroyLock(winFile *pFile){
+  if (pFile->hMutex){
+    /* Acquire the mutex */
+    winceMutexAcquire(pFile->hMutex);
+
+    /* The following blocks should probably assert in debug mode, but they
+       are to cleanup in case any locks remained open */
+    if (pFile->local.nReaders){
+      pFile->shared->nReaders --;
+    }
+    if (pFile->local.bReserved){
+      pFile->shared->bReserved = FALSE;
+    }
+    if (pFile->local.bPending){
+      pFile->shared->bPending = FALSE;
+    }
+    if (pFile->local.bExclusive){
+      pFile->shared->bExclusive = FALSE;
+    }
+
+    /* De-reference and close our copy of the shared memory handle */
+    UnmapViewOfFile(pFile->shared);
+    CloseHandle(pFile->hShared);
+
+    /* Done with the mutex */
+    winceMutexRelease(pFile->hMutex);    
+    CloseHandle(pFile->hMutex);
+    pFile->hMutex = NULL;
+  }
+}
+
+/* 
+** An implementation of the LockFile() API of windows for wince
+*/
+static BOOL winceLockFile(
+  HANDLE *phFile,
+  DWORD dwFileOffsetLow,
+  DWORD dwFileOffsetHigh,
+  DWORD nNumberOfBytesToLockLow,
+  DWORD nNumberOfBytesToLockHigh
+){
+  winFile *pFile = HANDLE_TO_WINFILE(phFile);
+  BOOL bReturn = FALSE;
+
+  if (!pFile->hMutex) return TRUE;
+  winceMutexAcquire(pFile->hMutex);
+
+  /* Wanting an exclusive lock? */
+  if (dwFileOffsetLow == SHARED_FIRST
+       && nNumberOfBytesToLockLow == SHARED_SIZE){
+    if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
+       pFile->shared->bExclusive = TRUE;
+       pFile->local.bExclusive = TRUE;
+       bReturn = TRUE;
+    }
+  }
+
+  /* Want a read-only lock? */
+  else if ((dwFileOffsetLow >= SHARED_FIRST &&
+            dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&
+            nNumberOfBytesToLockLow == 1){
+    if (pFile->shared->bExclusive == 0){
+      pFile->local.nReaders ++;
+      if (pFile->local.nReaders == 1){
+        pFile->shared->nReaders ++;
+      }
+      bReturn = TRUE;
+    }
+  }
+
+  /* Want a pending lock? */
+  else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){
+    /* If no pending lock has been acquired, then acquire it */
+    if (pFile->shared->bPending == 0) {
+      pFile->shared->bPending = TRUE;
+      pFile->local.bPending = TRUE;
+      bReturn = TRUE;
+    }
+  }
+  /* Want a reserved lock? */
+  else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
+    if (pFile->shared->bReserved == 0) {
+      pFile->shared->bReserved = TRUE;
+      pFile->local.bReserved = TRUE;
+      bReturn = TRUE;
+    }
+  }
+
+  winceMutexRelease(pFile->hMutex);
+  return bReturn;
+}
+
+/*
+** An implementation of the UnlockFile API of windows for wince
+*/
+static BOOL winceUnlockFile(
+  HANDLE *phFile,
+  DWORD dwFileOffsetLow,
+  DWORD dwFileOffsetHigh,
+  DWORD nNumberOfBytesToUnlockLow,
+  DWORD nNumberOfBytesToUnlockHigh
+){
+  winFile *pFile = HANDLE_TO_WINFILE(phFile);
+  BOOL bReturn = FALSE;
+
+  if (!pFile->hMutex) return TRUE;
+  winceMutexAcquire(pFile->hMutex);
+
+  /* Releasing a reader lock or an exclusive lock */
+  if (dwFileOffsetLow >= SHARED_FIRST &&
+       dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){
+    /* Did we have an exclusive lock? */
+    if (pFile->local.bExclusive){
+      pFile->local.bExclusive = FALSE;
+      pFile->shared->bExclusive = FALSE;
+      bReturn = TRUE;
+    }
+
+    /* Did we just have a reader lock? */
+    else if (pFile->local.nReaders){
+      pFile->local.nReaders --;
+      if (pFile->local.nReaders == 0)
+      {
+        pFile->shared->nReaders --;
+      }
+      bReturn = TRUE;
+    }
+  }
+
+  /* Releasing a pending lock */
+  else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
+    if (pFile->local.bPending){
+      pFile->local.bPending = FALSE;
+      pFile->shared->bPending = FALSE;
+      bReturn = TRUE;
+    }
+  }
+  /* Releasing a reserved lock */
+  else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
+    if (pFile->local.bReserved) {
+      pFile->local.bReserved = FALSE;
+      pFile->shared->bReserved = FALSE;
+      bReturn = TRUE;
+    }
+  }
+
+  winceMutexRelease(pFile->hMutex);
+  return bReturn;
+}
+
+/*
+** An implementation of the LockFileEx() API of windows for wince
+*/
+static BOOL winceLockFileEx(
+  HANDLE *phFile,
+  DWORD dwFlags,
+  DWORD dwReserved,
+  DWORD nNumberOfBytesToLockLow,
+  DWORD nNumberOfBytesToLockHigh,
+  LPOVERLAPPED lpOverlapped
+){
+  /* If the caller wants a shared read lock, forward this call
+  ** to winceLockFile */
+  if (lpOverlapped->Offset == SHARED_FIRST &&
+      dwFlags == 1 &&
+      nNumberOfBytesToLockLow == SHARED_SIZE){
+    return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
+  }
+  return FALSE;
+}
+/*
+** End of the special code for wince
+*****************************************************************************/
+#endif /* OS_WINCE */
+
+/*****************************************************************************
+** The next group of routines implement the I/O methods specified
+** by the sqlite3_io_methods object.
+******************************************************************************/
+
+/*
+** Close a file.
+**
+** It is reported that an attempt to close a handle might sometimes
+** fail.  This is a very unreasonable result, but windows is notorious
+** for being unreasonable so I do not doubt that it might happen.  If
+** the close fails, we pause for 100 milliseconds and try again.  As
+** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
+** giving up and returning an error.
+*/
+#define MX_CLOSE_ATTEMPT 3
+static int winClose(sqlite3_file *id){
+  int rc, cnt = 0;
+  winFile *pFile = (winFile*)id;
+  OSTRACE2("CLOSE %d\n", pFile->h);
+  do{
+    rc = CloseHandle(pFile->h);
+  }while( rc==0 && cnt++ < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
+#if OS_WINCE
+  winceDestroyLock(pFile);
+  if( pFile->zDeleteOnClose ){
+    DeleteFileW(pFile->zDeleteOnClose);
+    free(pFile->zDeleteOnClose);
+  }
+#endif
+  OpenCounter(-1);
+  return rc ? SQLITE_OK : SQLITE_IOERR;
+}
+
+/*
+** Some microsoft compilers lack this definition.
+*/
+#ifndef INVALID_SET_FILE_POINTER
+# define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#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.
+*/
+static int winRead(
+  sqlite3_file *id,          /* File to read from */
+  void *pBuf,                /* Write content into this buffer */
+  int amt,                   /* Number of bytes to read */
+  sqlite3_int64 offset       /* Begin reading at this offset */
+){
+  LONG upperBits = (offset>>32) & 0x7fffffff;
+  LONG lowerBits = offset & 0xffffffff;
+  DWORD rc;
+  DWORD got;
+  winFile *pFile = (winFile*)id;
+  assert( id!=0 );
+  SimulateIOError(return SQLITE_IOERR_READ);
+  OSTRACE3("READ %d lock=%d\n", pFile->h, pFile->locktype);
+  rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
+  if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
+    return SQLITE_FULL;
+  }
+  if( !ReadFile(pFile->h, pBuf, amt, &got, 0) ){
+    return SQLITE_IOERR_READ;
+  }
+  if( got==(DWORD)amt ){
+    return SQLITE_OK;
+  }else{
+    memset(&((char*)pBuf)[got], 0, amt-got);
+    return SQLITE_IOERR_SHORT_READ;
+  }
+}
+
+/*
+** Write data from a buffer into a file.  Return SQLITE_OK on success
+** or some other error code on failure.
+*/
+static int winWrite(
+  sqlite3_file *id,         /* File to write into */
+  const void *pBuf,         /* The bytes to be written */
+  int amt,                  /* Number of bytes to write */
+  sqlite3_int64 offset      /* Offset into the file to begin writing at */
+){
+  LONG upperBits = (offset>>32) & 0x7fffffff;
+  LONG lowerBits = offset & 0xffffffff;
+  DWORD rc;
+  DWORD wrote;
+  winFile *pFile = (winFile*)id;
+  assert( id!=0 );
+  SimulateIOError(return SQLITE_IOERR_WRITE);
+  SimulateDiskfullError(return SQLITE_FULL);
+  OSTRACE3("WRITE %d lock=%d\n", pFile->h, pFile->locktype);
+  rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
+  if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
+    return SQLITE_FULL;
+  }
+  assert( amt>0 );
+  while(
+     amt>0
+     && (rc = WriteFile(pFile->h, pBuf, amt, &wrote, 0))!=0
+     && wrote>0
+  ){
+    amt -= wrote;
+    pBuf = &((char*)pBuf)[wrote];
+  }
+  if( !rc || amt>(int)wrote ){
+    return SQLITE_FULL;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Truncate an open file to a specified size
+*/
+static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
+  LONG upperBits = (nByte>>32) & 0x7fffffff;
+  LONG lowerBits = nByte & 0xffffffff;
+  winFile *pFile = (winFile*)id;
+  OSTRACE3("TRUNCATE %d %lld\n", pFile->h, nByte);
+  SimulateIOError(return SQLITE_IOERR_TRUNCATE);
+  SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
+  SetEndOfFile(pFile->h);
+  return SQLITE_OK;
+}
+
+#ifdef SQLITE_TEST
+/*
+** Count the number of fullsyncs and normal syncs.  This is used to test
+** that syncs and fullsyncs are occuring at the right times.
+*/
+int sqlite3_sync_count = 0;
+int sqlite3_fullsync_count = 0;
+#endif
+
+/*
+** Make sure all writes to a particular file are committed to disk.
+*/
+static int winSync(sqlite3_file *id, int flags){
+  winFile *pFile = (winFile*)id;
+  OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);
+#ifdef SQLITE_TEST
+  if( flags & SQLITE_SYNC_FULL ){
+    sqlite3_fullsync_count++;
+  }
+  sqlite3_sync_count++;
+#endif
+  if( FlushFileBuffers(pFile->h) ){
+    return SQLITE_OK;
+  }else{
+    return SQLITE_IOERR;
+  }
+}
+
+/*
+** Determine the current size of a file in bytes
+*/
+static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
+  winFile *pFile = (winFile*)id;
+  DWORD upperBits, lowerBits;
+  SimulateIOError(return SQLITE_IOERR_FSTAT);
+  lowerBits = GetFileSize(pFile->h, &upperBits);
+  *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
+  return SQLITE_OK;
+}
+
+/*
+** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
+*/
+#ifndef LOCKFILE_FAIL_IMMEDIATELY
+# define LOCKFILE_FAIL_IMMEDIATELY 1
+#endif
+
+/*
+** Acquire a reader lock.
+** Different API routines are called depending on whether or not this
+** is Win95 or WinNT.
+*/
+static int getReadLock(winFile *pFile){
+  int res;
+  if( isNT() ){
+    OVERLAPPED ovlp;
+    ovlp.Offset = SHARED_FIRST;
+    ovlp.OffsetHigh = 0;
+    ovlp.hEvent = 0;
+    res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
+                     0, SHARED_SIZE, 0, &ovlp);
+  }else{
+    int lk;
+    sqlite3Randomness(sizeof(lk), &lk);
+    pFile->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
+    res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
+  }
+  return res;
+}
+
+/*
+** Undo a readlock
+*/
+static int unlockReadLock(winFile *pFile){
+  int res;
+  if( isNT() ){
+    res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+  }else{
+    res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
+  }
+  return res;
+}
+
+/*
+** Lock the file with the lock specified by parameter locktype - one
+** of the following:
+**
+**     (1) SHARED_LOCK
+**     (2) RESERVED_LOCK
+**     (3) PENDING_LOCK
+**     (4) EXCLUSIVE_LOCK
+**
+** Sometimes when requesting one lock state, additional lock states
+** are inserted in between.  The locking might fail on one of the later
+** transitions leaving the lock state different from what it started but
+** still short of its goal.  The following chart shows the allowed
+** transitions and the inserted intermediate states:
+**
+**    UNLOCKED -> SHARED
+**    SHARED -> RESERVED
+**    SHARED -> (PENDING) -> EXCLUSIVE
+**    RESERVED -> (PENDING) -> EXCLUSIVE
+**    PENDING -> EXCLUSIVE
+**
+** This routine will only increase a lock.  The winUnlock() routine
+** erases all locks at once and returns us immediately to locking level 0.
+** It is not possible to lower the locking level one step at a time.  You
+** must go straight to locking level 0.
+*/
+static int winLock(sqlite3_file *id, int locktype){
+  int rc = SQLITE_OK;    /* Return code from subroutines */
+  int res = 1;           /* Result of a windows lock call */
+  int newLocktype;       /* Set pFile->locktype to this value before exiting */
+  int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
+  winFile *pFile = (winFile*)id;
+
+  assert( pFile!=0 );
+  OSTRACE5("LOCK %d %d was %d(%d)\n",
+          pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
+
+  /* If there is already a lock of this type or more restrictive on the
+  ** OsFile, do nothing. Don't use the end_lock: exit path, as
+  ** sqlite3OsEnterMutex() hasn't been called yet.
+  */
+  if( pFile->locktype>=locktype ){
+    return SQLITE_OK;
+  }
+
+  /* Make sure the locking sequence is correct
+  */
+  assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+  assert( locktype!=PENDING_LOCK );
+  assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
+
+  /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
+  ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
+  ** the PENDING_LOCK byte is temporary.
+  */
+  newLocktype = pFile->locktype;
+  if( pFile->locktype==NO_LOCK
+   || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
+  ){
+    int cnt = 3;
+    while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
+      /* Try 3 times to get the pending lock.  The pending lock might be
+      ** held by another reader process who will release it momentarily.
+      */
+      OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);
+      Sleep(1);
+    }
+    gotPendingLock = res;
+  }
+
+  /* Acquire a shared lock
+  */
+  if( locktype==SHARED_LOCK && res ){
+    assert( pFile->locktype==NO_LOCK );
+    res = getReadLock(pFile);
+    if( res ){
+      newLocktype = SHARED_LOCK;
+    }
+  }
+
+  /* Acquire a RESERVED lock
+  */
+  if( locktype==RESERVED_LOCK && res ){
+    assert( pFile->locktype==SHARED_LOCK );
+    res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
+    if( res ){
+      newLocktype = RESERVED_LOCK;
+    }
+  }
+
+  /* Acquire a PENDING lock
+  */
+  if( locktype==EXCLUSIVE_LOCK && res ){
+    newLocktype = PENDING_LOCK;
+    gotPendingLock = 0;
+  }
+
+  /* Acquire an EXCLUSIVE lock
+  */
+  if( locktype==EXCLUSIVE_LOCK && res ){
+    assert( pFile->locktype>=SHARED_LOCK );
+    res = unlockReadLock(pFile);
+    OSTRACE2("unreadlock = %d\n", res);
+    res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+    if( res ){
+      newLocktype = EXCLUSIVE_LOCK;
+    }else{
+      OSTRACE2("error-code = %d\n", GetLastError());
+      getReadLock(pFile);
+    }
+  }
+
+  /* If we are holding a PENDING lock that ought to be released, then
+  ** release it now.
+  */
+  if( gotPendingLock && locktype==SHARED_LOCK ){
+    UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
+  }
+
+  /* Update the state of the lock has held in the file descriptor then
+  ** return the appropriate result code.
+  */
+  if( res ){
+    rc = SQLITE_OK;
+  }else{
+    OSTRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
+           locktype, newLocktype);
+    rc = SQLITE_BUSY;
+  }
+  pFile->locktype = newLocktype;
+  return rc;
+}
+
+/*
+** This routine checks if there is a RESERVED lock held on the specified
+** file by this or any other process. If such a lock is held, return
+** non-zero, otherwise zero.
+*/
+static int winCheckReservedLock(sqlite3_file *id){
+  int rc;
+  winFile *pFile = (winFile*)id;
+  assert( pFile!=0 );
+  if( pFile->locktype>=RESERVED_LOCK ){
+    rc = 1;
+    OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
+  }else{
+    rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
+    if( rc ){
+      UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
+    }
+    rc = !rc;
+    OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
+  }
+  return rc;
+}
+
+/*
+** Lower the locking level on file descriptor id to locktype.  locktype
+** must be either NO_LOCK or SHARED_LOCK.
+**
+** If the locking level of the file descriptor is already at or below
+** the requested locking level, this routine is a no-op.
+**
+** It is not possible for this routine to fail if the second argument
+** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
+** might return SQLITE_IOERR;
+*/
+static int winUnlock(sqlite3_file *id, int locktype){
+  int type;
+  winFile *pFile = (winFile*)id;
+  int rc = SQLITE_OK;
+  assert( pFile!=0 );
+  assert( locktype<=SHARED_LOCK );
+  OSTRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
+          pFile->locktype, pFile->sharedLockByte);
+  type = pFile->locktype;
+  if( type>=EXCLUSIVE_LOCK ){
+    UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+    if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
+      /* This should never happen.  We should always be able to
+      ** reacquire the read lock */
+      rc = SQLITE_IOERR_UNLOCK;
+    }
+  }
+  if( type>=RESERVED_LOCK ){
+    UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
+  }
+  if( locktype==NO_LOCK && type>=SHARED_LOCK ){
+    unlockReadLock(pFile);
+  }
+  if( type>=PENDING_LOCK ){
+    UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
+  }
+  pFile->locktype = locktype;
+  return rc;
+}
+
+/*
+** Control and query of the open file handle.
+*/
+static int winFileControl(sqlite3_file *id, int op, void *pArg){
+  switch( op ){
+    case SQLITE_FCNTL_LOCKSTATE: {
+      *(int*)pArg = ((winFile*)id)->locktype;
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_ERROR;
+}
+
+/*
+** Return the sector size in bytes of the underlying block device for
+** the specified file. This is almost always 512 bytes, but may be
+** larger for some devices.
+**
+** SQLite code assumes this function cannot fail. It also assumes that
+** if two files are created in the same file-system directory (i.e.
+** a database and its journal file) that the sector size will be the
+** same for both.
+*/
+static int winSectorSize(sqlite3_file *id){
+  return SQLITE_DEFAULT_SECTOR_SIZE;
+}
+
+/*
+** Return a vector of device characteristics.
+*/
+static int winDeviceCharacteristics(sqlite3_file *id){
+  return 0;
+}
+
+/*
+** This vector defines all the methods that can operate on an
+** sqlite3_file for win32.
+*/
+static const sqlite3_io_methods winIoMethod = {
+  1,                        /* iVersion */
+  winClose,
+  winRead,
+  winWrite,
+  winTruncate,
+  winSync,
+  winFileSize,
+  winLock,
+  winUnlock,
+  winCheckReservedLock,
+  winFileControl,
+  winSectorSize,
+  winDeviceCharacteristics
+};
+
+/***************************************************************************
+** Here ends the I/O methods that form the sqlite3_io_methods object.
+**
+** The next block of code implements the VFS methods.
+****************************************************************************/
+
+/*
+** Convert a UTF-8 filename into whatever form the underlying
+** operating system wants filenames in.  Space to hold the result
+** is obtained from malloc and must be freed by the calling
+** function.
+*/
+static void *convertUtf8Filename(const char *zFilename){
+  void *zConverted = 0;
+  if( isNT() ){
+    zConverted = utf8ToUnicode(zFilename);
+  }else{
+    zConverted = utf8ToMbcs(zFilename);
+  }
+  /* caller will handle out of memory */
+  return zConverted;
+}
+
+/*
+** Open a file.
+*/
+static int winOpen(
+  sqlite3_vfs *pVfs,        /* Not used */
+  const char *zName,        /* Name of the file (UTF-8) */
+  sqlite3_file *id,         /* Write the SQLite file handle here */
+  int flags,                /* Open mode flags */
+  int *pOutFlags            /* Status return flags */
+){
+  HANDLE h;
+  DWORD dwDesiredAccess;
+  DWORD dwShareMode;
+  DWORD dwCreationDisposition;
+  DWORD dwFlagsAndAttributes = 0;
+  int isTemp;
+  winFile *pFile = (winFile*)id;
+  void *zConverted = convertUtf8Filename(zName);
+  if( zConverted==0 ){
+    return SQLITE_NOMEM;
+  }
+
+  if( flags & SQLITE_OPEN_READWRITE ){
+    dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+  }else{
+    dwDesiredAccess = GENERIC_READ;
+  }
+  if( flags & SQLITE_OPEN_CREATE ){
+    dwCreationDisposition = OPEN_ALWAYS;
+  }else{
+    dwCreationDisposition = OPEN_EXISTING;
+  }
+  if( flags & SQLITE_OPEN_MAIN_DB ){
+    dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+  }else{
+    dwShareMode = 0;
+  }
+  if( flags & SQLITE_OPEN_DELETEONCLOSE ){
+#if OS_WINCE
+    dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
+#else
+    dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
+                               | FILE_ATTRIBUTE_HIDDEN
+                               | FILE_FLAG_DELETE_ON_CLOSE;
+#endif
+    isTemp = 1;
+  }else{
+    dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
+    isTemp = 0;
+  }
+  /* Reports from the internet are that performance is always
+  ** better if FILE_FLAG_RANDOM_ACCESS is used.  Ticket #2699. */
+  dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
+  if( isNT() ){
+    h = CreateFileW((WCHAR*)zConverted,
+       dwDesiredAccess,
+       dwShareMode,
+       NULL,
+       dwCreationDisposition,
+       dwFlagsAndAttributes,
+       NULL
+    );
+  }else{
+#if OS_WINCE
+    return SQLITE_NOMEM;
+#else
+    h = CreateFileA((char*)zConverted,
+       dwDesiredAccess,
+       dwShareMode,
+       NULL,
+       dwCreationDisposition,
+       dwFlagsAndAttributes,
+       NULL
+    );
+#endif
+  }
+  if( h==INVALID_HANDLE_VALUE ){
+    free(zConverted);
+    if( flags & SQLITE_OPEN_READWRITE ){
+      return winOpen(0, zName, id, 
+             ((flags|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
+    }else{
+      return SQLITE_CANTOPEN;
+    }
+  }
+  if( pOutFlags ){
+    if( flags & SQLITE_OPEN_READWRITE ){
+      *pOutFlags = SQLITE_OPEN_READWRITE;
+    }else{
+      *pOutFlags = SQLITE_OPEN_READONLY;
+    }
+  }
+  memset(pFile, 0, sizeof(*pFile));
+  pFile->pMethod = &winIoMethod;
+  pFile->h = h;
+#if OS_WINCE
+  if( (flags & (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)) ==
+               (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)
+       && !winceCreateLock(zName, pFile)
+  ){
+    CloseHandle(h);
+    free(zConverted);
+    return SQLITE_CANTOPEN;
+  }
+  if( isTemp ){
+    pFile->zDeleteOnClose = zConverted;
+  }else
+#endif
+  {
+    free(zConverted);
+  }
+  OpenCounter(+1);
+  return SQLITE_OK;
+}
+
+/*
+** Delete the named file.
+**
+** Note that windows does not allow a file to be deleted if some other
+** process has it open.  Sometimes a virus scanner or indexing program
+** will open a journal file shortly after it is created in order to do
+** whatever does.  While this other process is holding the
+** file open, we will be unable to delete it.  To work around this
+** problem, we delay 100 milliseconds and try to delete again.  Up
+** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
+** up and returning an error.
+*/
+#define MX_DELETION_ATTEMPTS 5
+static int winDelete(
+  sqlite3_vfs *pVfs,          /* Not used on win32 */
+  const char *zFilename,      /* Name of file to delete */
+  int syncDir                 /* Not used on win32 */
+){
+  int cnt = 0;
+  int rc;
+  void *zConverted = convertUtf8Filename(zFilename);
+  if( zConverted==0 ){
+    return SQLITE_NOMEM;
+  }
+  SimulateIOError(return SQLITE_IOERR_DELETE);
+  if( isNT() ){
+    do{
+      DeleteFileW(zConverted);
+    }while( (rc = GetFileAttributesW(zConverted))!=0xffffffff 
+            && cnt++ < MX_DELETION_ATTEMPTS && (Sleep(100), 1) );
+  }else{
+#if OS_WINCE
+    return SQLITE_NOMEM;
+#else
+    do{
+      DeleteFileA(zConverted);
+    }while( (rc = GetFileAttributesA(zConverted))!=0xffffffff
+            && cnt++ < MX_DELETION_ATTEMPTS && (Sleep(100), 1) );
+#endif
+  }
+  free(zConverted);
+  OSTRACE2("DELETE \"%s\"\n", zFilename);
+  return rc==0xffffffff ? SQLITE_OK : SQLITE_IOERR_DELETE;
+}
+
+/*
+** Check the existance and status of a file.
+*/
+static int winAccess(
+  sqlite3_vfs *pVfs,         /* Not used on win32 */
+  const char *zFilename,     /* Name of file to check */
+  int flags                  /* Type of test to make on this file */
+){
+  DWORD attr;
+  int rc;
+  void *zConverted = convertUtf8Filename(zFilename);
+  if( zConverted==0 ){
+    return SQLITE_NOMEM;
+  }
+  if( isNT() ){
+    attr = GetFileAttributesW((WCHAR*)zConverted);
+  }else{
+#if OS_WINCE
+    return SQLITE_NOMEM;
+#else
+    attr = GetFileAttributesA((char*)zConverted);
+#endif
+  }
+  free(zConverted);
+  switch( flags ){
+    case SQLITE_ACCESS_READ:
+    case SQLITE_ACCESS_EXISTS:
+      rc = attr!=0xffffffff;
+      break;
+    case SQLITE_ACCESS_READWRITE:
+      rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
+      break;
+    default:
+      assert(!"Invalid flags argument");
+  }
+  return rc;
+}
+
+
+/*
+** Create a temporary file name in zBuf.  zBuf must be big enough to
+** hold at pVfs->mxPathname characters.
+*/
+static int winGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
+  static char zChars[] =
+    "abcdefghijklmnopqrstuvwxyz"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "0123456789";
+  int i, j;
+  char zTempPath[MAX_PATH+1];
+  if( sqlite3_temp_directory ){
+    sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
+  }else if( isNT() ){
+    char *zMulti;
+    WCHAR zWidePath[MAX_PATH];
+    GetTempPathW(MAX_PATH-30, zWidePath);
+    zMulti = unicodeToUtf8(zWidePath);
+    if( zMulti ){
+      sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
+      free(zMulti);
+    }else{
+      return SQLITE_NOMEM;
+    }
+  }else{
+    char *zUtf8;
+    char zMbcsPath[MAX_PATH];
+    GetTempPathA(MAX_PATH-30, zMbcsPath);
+    zUtf8 = mbcsToUtf8(zMbcsPath);
+    if( zUtf8 ){
+      sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
+      free(zUtf8);
+    }else{
+      return SQLITE_NOMEM;
+    }
+  }
+  for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
+  zTempPath[i] = 0;
+  sqlite3_snprintf(nBuf-30, zBuf,
+                   "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
+  j = strlen(zBuf);
+  sqlite3Randomness(20, &zBuf[j]);
+  for(i=0; i<20; i++, j++){
+    zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
+  }
+  zBuf[j] = 0;
+  OSTRACE2("TEMP FILENAME: %s\n", zBuf);
+  return SQLITE_OK; 
+}
+
+/*
+** Turn a relative pathname into a full pathname.  Write the full
+** pathname into zOut[].  zOut[] will be at least pVfs->mxPathname
+** bytes in size.
+*/
+static int winFullPathname(
+  sqlite3_vfs *pVfs,            /* Pointer to vfs object */
+  const char *zRelative,        /* Possibly relative input path */
+  int nFull,                    /* Size of output buffer in bytes */
+  char *zFull                   /* Output buffer */
+){
+
+#if defined(__CYGWIN__)
+  cygwin_conv_to_full_win32_path(zRelative, zFull);
+  return SQLITE_OK;
+#endif
+
+#if OS_WINCE
+  /* WinCE has no concept of a relative pathname, or so I am told. */
+  sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
+  return SQLITE_OK;
+#endif
+
+#if !OS_WINCE && !defined(__CYGWIN__)
+  int nByte;
+  void *zConverted;
+  char *zOut;
+  zConverted = convertUtf8Filename(zRelative);
+  if( isNT() ){
+    WCHAR *zTemp;
+    nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
+    zTemp = malloc( nByte*sizeof(zTemp[0]) );
+    if( zTemp==0 ){
+      free(zConverted);
+      return SQLITE_NOMEM;
+    }
+    GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
+    free(zConverted);
+    zOut = unicodeToUtf8(zTemp);
+    free(zTemp);
+  }else{
+    char *zTemp;
+    nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
+    zTemp = malloc( nByte*sizeof(zTemp[0]) );
+    if( zTemp==0 ){
+      free(zConverted);
+      return SQLITE_NOMEM;
+    }
+    GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
+    free(zConverted);
+    zOut = mbcsToUtf8(zTemp);
+    free(zTemp);
+  }
+  if( zOut ){
+    sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
+    free(zOut);
+    return SQLITE_OK;
+  }else{
+    return SQLITE_NOMEM;
+  }
+#endif
+}
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+/*
+** Interfaces for opening a shared library, finding entry points
+** within the shared library, and closing the shared library.
+*/
+/*
+** Interfaces for opening a shared library, finding entry points
+** within the shared library, and closing the shared library.
+*/
+static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
+  HANDLE h;
+  void *zConverted = convertUtf8Filename(zFilename);
+  if( zConverted==0 ){
+    return 0;
+  }
+  if( isNT() ){
+    h = LoadLibraryW((WCHAR*)zConverted);
+  }else{
+#if OS_WINCE
+    return 0;
+#else
+    h = LoadLibraryA((char*)zConverted);
+#endif
+  }
+  free(zConverted);
+  return (void*)h;
+}
+static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
+#if OS_WINCE
+  int error = GetLastError();
+  if( error>0x7FFFFFF ){
+    sqlite3_snprintf(nBuf, zBufOut, "OsError 0x%x", error);
+  }else{
+    sqlite3_snprintf(nBuf, zBufOut, "OsError %d", error);
+  }
+#else
+  FormatMessageA(
+    FORMAT_MESSAGE_FROM_SYSTEM,
+    NULL,
+    GetLastError(),
+    0,
+    zBufOut,
+    nBuf-1,
+    0
+  );
+#endif
+}
+void *winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+#if OS_WINCE
+  /* The GetProcAddressA() routine is only available on wince. */
+  return GetProcAddressA((HANDLE)pHandle, zSymbol);
+#else
+  /* All other windows platforms expect GetProcAddress() to take
+  ** an Ansi string regardless of the _UNICODE setting */
+  return GetProcAddress((HANDLE)pHandle, zSymbol);
+#endif
+}
+void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  FreeLibrary((HANDLE)pHandle);
+}
+#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
+  #define winDlOpen  0
+  #define winDlError 0
+  #define winDlSym   0
+  #define winDlClose 0
+#endif
+
+
+/*
+** Write up to nBuf bytes of randomness into zBuf.
+*/
+static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
+  int n = 0;
+  if( sizeof(SYSTEMTIME)<=nBuf-n ){
+    SYSTEMTIME x;
+    GetSystemTime(&x);
+    memcpy(&zBuf[n], &x, sizeof(x));
+    n += sizeof(x);
+  }
+  if( sizeof(DWORD)<=nBuf-n ){
+    DWORD pid = GetCurrentProcessId();
+    memcpy(&zBuf[n], &pid, sizeof(pid));
+    n += sizeof(pid);
+  }
+  if( sizeof(DWORD)<=nBuf-n ){
+    DWORD cnt = GetTickCount();
+    memcpy(&zBuf[n], &cnt, sizeof(cnt));
+    n += sizeof(cnt);
+  }
+  if( sizeof(LARGE_INTEGER)<=nBuf-n ){
+    LARGE_INTEGER i;
+    QueryPerformanceCounter(&i);
+    memcpy(&zBuf[n], &i, sizeof(i));
+    n += sizeof(i);
+  }
+  return n;
+}
+
+
+/*
+** Sleep for a little while.  Return the amount of time slept.
+*/
+static int winSleep(sqlite3_vfs *pVfs, int microsec){
+  Sleep((microsec+999)/1000);
+  return ((microsec+999)/1000)*1000;
+}
+
+/*
+** The following variable, if set to a non-zero value, becomes the result
+** returned from sqlite3OsCurrentTime().  This is used for testing.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_current_time = 0;
+#endif
+
+/*
+** 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 winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
+  FILETIME ft;
+  /* FILETIME structure is a 64-bit value representing the number of 
+     100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). 
+  */
+  double now;
+#if OS_WINCE
+  SYSTEMTIME time;
+  GetSystemTime(&time);
+  SystemTimeToFileTime(&time,&ft);
+#else
+  GetSystemTimeAsFileTime( &ft );
+#endif
+  now = ((double)ft.dwHighDateTime) * 4294967296.0; 
+  *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
+#ifdef SQLITE_TEST
+  if( sqlite3_current_time ){
+    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
+  }
+#endif
+  return 0;
+}
+
+
+/*
+** Return a pointer to the sqlite3DefaultVfs structure.   We use
+** a function rather than give the structure global scope because
+** some compilers (MSVC) do not allow forward declarations of
+** initialized structures.
+*/
+sqlite3_vfs *sqlite3OsDefaultVfs(void){
+  static sqlite3_vfs winVfs = {
+    1,                 /* iVersion */
+    sizeof(winFile),   /* szOsFile */
+    MAX_PATH,          /* mxPathname */
+    0,                 /* pNext */
+    "win32",           /* zName */
+    0,                 /* pAppData */
+  
+    winOpen,           /* xOpen */
+    winDelete,         /* xDelete */
+    winAccess,         /* xAccess */
+    winGetTempname,    /* xGetTempName */
+    winFullPathname,   /* xFullPathname */
+    winDlOpen,         /* xDlOpen */
+    winDlError,        /* xDlError */
+    winDlSym,          /* xDlSym */
+    winDlClose,        /* xDlClose */
+    winRandomness,     /* xRandomness */
+    winSleep,          /* xSleep */
+    winCurrentTime     /* xCurrentTime */
+  };
+  
+  return &winVfs;
+}
+
+#endif /* OS_WIN */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/os_win.h b/client/src/thirdparty/sqlite-3.4.2/src/os_win.h
new file mode 100644
index 0000000..baf937b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/os_win.h
@@ -0,0 +1,40 @@
+/*
+** 2004 May 22
+**
+** 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 header file defines OS-specific features for Win32
+*/
+#ifndef _SQLITE_OS_WIN_H_
+#define _SQLITE_OS_WIN_H_
+
+#include <windows.h>
+#include <winbase.h>
+
+/*
+** The OsFile structure is a operating-system independing representation
+** of an open file handle.  It is defined differently for each architecture.
+**
+** This is the definition for Win32.
+*/
+typedef struct OsFile OsFile;
+struct OsFile {
+  HANDLE h;               /* Handle for accessing the file */
+  unsigned char locktype; /* Type of lock currently held on this file */
+  unsigned char isOpen;   /* True if needs to be closed */
+  short sharedLockByte;   /* Randomly chosen byte used as a shared lock */
+};
+
+
+#define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
+#define SQLITE_MIN_SLEEP_MS 1
+
+
+#endif /* _SQLITE_OS_WIN_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/pager.c b/client/src/thirdparty/sqlite-3.4.2/src/pager.c
new file mode 100644
index 0000000..5677761
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/pager.c
@@ -0,0 +1,5133 @@
+/*
+** 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.
+**
+*************************************************************************
+** This is the implementation of the page cache subsystem or "pager".
+** 
+** 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.405 2008/02/02 20:47:38 drh Exp $
+*/
+#ifndef SQLITE_OMIT_DISKIO
+#include "sqliteInt.h"
+#include <assert.h>
+#include <string.h>
+
+/*
+** Macros for troubleshooting.  Normally turned off
+*/
+#if 0
+#define sqlite3DebugPrintf printf
+#define PAGERTRACE1(X)       sqlite3DebugPrintf(X)
+#define PAGERTRACE2(X,Y)     sqlite3DebugPrintf(X,Y)
+#define PAGERTRACE3(X,Y,Z)   sqlite3DebugPrintf(X,Y,Z)
+#define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W)
+#define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V)
+#else
+#define PAGERTRACE1(X)
+#define PAGERTRACE2(X,Y)
+#define PAGERTRACE3(X,Y,Z)
+#define PAGERTRACE4(X,Y,Z,W)
+#define PAGERTRACE5(X,Y,Z,W,V)
+#endif
+
+/*
+** The following two macros are used within the PAGERTRACEX() macros above
+** to print out file-descriptors. 
+**
+** PAGERID() takes a pointer to a Pager struct as its argument. The
+** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
+** struct as its argument.
+*/
+#define PAGERID(p) ((int)(p->fd))
+#define FILEHANDLEID(fd) ((int)fd)
+
+/*
+** The page cache as a whole is always in one of the following
+** states:
+**
+**   PAGER_UNLOCK        The page cache is not currently reading or 
+**                       writing the database file.  There is no
+**                       data held in memory.  This is the initial
+**                       state.
+**
+**   PAGER_SHARED        The page cache is reading the database.
+**                       Writing is not permitted.  There can be
+**                       multiple readers accessing the same database
+**                       file at the same time.
+**
+**   PAGER_RESERVED      This process has reserved the database for writing
+**                       but has not yet made any changes.  Only one process
+**                       at a time can reserve the database.  The original
+**                       database file has not been modified so other
+**                       processes may still be reading the on-disk
+**                       database file.
+**
+**   PAGER_EXCLUSIVE     The page cache is writing the database.
+**                       Access is exclusive.  No other processes or
+**                       threads can be reading or writing while one
+**                       process is writing.
+**
+**   PAGER_SYNCED        The pager moves to this state from PAGER_EXCLUSIVE
+**                       after all dirty pages have been written to the
+**                       database file and the file has been synced to
+**                       disk. All that remains to do is to remove or
+**                       truncate the journal file and the transaction 
+**                       will be committed.
+**
+** The page cache comes up in PAGER_UNLOCK.  The first time a
+** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.
+** After all pages have been released using sqlite_page_unref(),
+** the state transitions back to PAGER_UNLOCK.  The first time
+** that sqlite3PagerWrite() is called, the state transitions to
+** PAGER_RESERVED.  (Note that sqlite3PagerWrite() can only be
+** called on an outstanding page which means that the pager must
+** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)
+** PAGER_RESERVED means that there is an open rollback journal.
+** The transition to PAGER_EXCLUSIVE occurs before any changes
+** are made to the database file, though writes to the rollback
+** journal occurs with just PAGER_RESERVED.  After an sqlite3PagerRollback()
+** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,
+** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.
+*/
+#define PAGER_UNLOCK      0
+#define PAGER_SHARED      1   /* same as SHARED_LOCK */
+#define PAGER_RESERVED    2   /* same as RESERVED_LOCK */
+#define PAGER_EXCLUSIVE   4   /* same as EXCLUSIVE_LOCK */
+#define PAGER_SYNCED      5
+
+/*
+** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time,
+** then failed attempts to get a reserved lock will invoke the busy callback.
+** This is off by default.  To see why, consider the following scenario:
+** 
+** Suppose thread A already has a shared lock and wants a reserved lock.
+** Thread B already has a reserved lock and wants an exclusive lock.  If
+** both threads are using their busy callbacks, it might be a long time
+** be for one of the threads give up and allows the other to proceed.
+** But if the thread trying to get the reserved lock gives up quickly
+** (if it never invokes its busy callback) then the contention will be
+** resolved quickly.
+*/
+#ifndef SQLITE_BUSY_RESERVED_LOCK
+# define SQLITE_BUSY_RESERVED_LOCK 0
+#endif
+
+/*
+** This macro rounds values up so that if the value is an address it
+** is guaranteed to be an address that is aligned to an 8-byte boundary.
+*/
+#define FORCE_ALIGNMENT(X)   (((X)+7)&~7)
+
+typedef struct PgHdr PgHdr;
+
+/*
+** Each pager stores all currently unreferenced pages in a list sorted
+** in least-recently-used (LRU) order (i.e. the first item on the list has 
+** not been referenced in a long time, the last item has been recently
+** used). An instance of this structure is included as part of each
+** pager structure for this purpose (variable Pager.lru).
+**
+** Additionally, if memory-management is enabled, all unreferenced pages 
+** are stored in a global LRU list (global variable sqlite3LruPageList).
+**
+** In both cases, the PagerLruList.pFirstSynced variable points to
+** the first page in the corresponding list that does not require an
+** fsync() operation before its memory can be reclaimed. If no such
+** page exists, PagerLruList.pFirstSynced is set to NULL.
+*/
+typedef struct PagerLruList PagerLruList;
+struct PagerLruList {
+  PgHdr *pFirst;         /* First page in LRU list */
+  PgHdr *pLast;          /* Last page in LRU list (the most recently used) */
+  PgHdr *pFirstSynced;   /* First page in list with PgHdr.needSync==0 */
+};
+
+/*
+** The following structure contains the next and previous pointers used
+** to link a PgHdr structure into a PagerLruList linked list. 
+*/
+typedef struct PagerLruLink PagerLruLink;
+struct PagerLruLink {
+  PgHdr *pNext;
+  PgHdr *pPrev;
+};
+
+/*
+** Each in-memory image of a page begins with the following header.
+** This header is only visible to this pager module.  The client
+** code that calls pager sees only the data that follows the header.
+**
+** Client code should call sqlite3PagerWrite() on a page prior to making
+** any modifications to that page.  The first time sqlite3PagerWrite()
+** is called, the original page contents are written into the rollback
+** journal and PgHdr.inJournal and PgHdr.needSync are set.  Later, once
+** the journal page has made it onto the disk surface, PgHdr.needSync
+** is cleared.  The modified page cannot be written back into the original
+** database file until the journal pages has been synced to disk and the
+** PgHdr.needSync has been cleared.
+**
+** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and
+** is cleared again when the page content is written back to the original
+** database file.
+**
+** Details of important structure elements:
+**
+** needSync
+**
+**     If this is true, this means that it is not safe to write the page
+**     content to the database because the original content needed
+**     for rollback has not by synced to the main rollback journal.
+**     The original content may have been written to the rollback journal
+**     but it has not yet been synced.  So we cannot write to the database
+**     file because power failure might cause the page in the journal file
+**     to never reach the disk.  It is as if the write to the journal file
+**     does not occur until the journal file is synced.
+**     
+**     This flag is false if the page content exactly matches what
+**     currently exists in the database file.  The needSync flag is also
+**     false if the original content has been written to the main rollback
+**     journal and synced.  If the page represents a new page that has
+**     been added onto the end of the database during the current
+**     transaction, the needSync flag is true until the original database
+**     size in the journal header has been synced to disk.
+**
+** inJournal
+**
+**     This is true if the original page has been written into the main
+**     rollback journal.  This is always false for new pages added to
+**     the end of the database file during the current transaction.
+**     And this flag says nothing about whether or not the journal
+**     has been synced to disk.  For pages that are in the original
+**     database file, the following expression should always be true:
+**
+**       inJournal = (pPager->aInJournal[(pgno-1)/8] & (1<<((pgno-1)%8))!=0
+**
+**     The pPager->aInJournal[] array is only valid for the original
+**     pages of the database, not new pages that are added to the end
+**     of the database, so obviously the above expression cannot be
+**     valid for new pages.  For new pages inJournal is always 0.
+**
+** dirty
+**
+**     When true, this means that the content of the page has been
+**     modified and needs to be written back to the database file.
+**     If false, it means that either the content of the page is
+**     unchanged or else the content is unimportant and we do not
+**     care whether or not it is preserved.
+**
+** alwaysRollback
+**
+**     This means that the sqlite3PagerDontRollback() API should be
+**     ignored for this page.  The DontRollback() API attempts to say
+**     that the content of the page on disk is unimportant (it is an
+**     unused page on the freelist) so that it is unnecessary to 
+**     rollback changes to this page because the content of the page
+**     can change without changing the meaning of the database.  This
+**     flag overrides any DontRollback() attempt.  This flag is set
+**     when a page that originally contained valid data is added to
+**     the freelist.  Later in the same transaction, this page might
+**     be pulled from the freelist and reused for something different
+**     and at that point the DontRollback() API will be called because
+**     pages taken from the freelist do not need to be protected by
+**     the rollback journal.  But this flag says that the page was
+**     not originally part of the freelist so that it still needs to
+**     be rolled back in spite of any subsequent DontRollback() calls.
+**
+** needRead 
+**
+**     This flag means (when true) that the content of the page has
+**     not yet been loaded from disk.  The in-memory content is just
+**     garbage.  (Actually, we zero the content, but you should not
+**     make any assumptions about the content nevertheless.)  If the
+**     content is needed in the future, it should be read from the
+**     original database file.
+*/
+struct PgHdr {
+  Pager *pPager;                 /* The pager to which this page belongs */
+  Pgno pgno;                     /* The page number for this page */
+  PgHdr *pNextHash, *pPrevHash;  /* Hash collision chain for PgHdr.pgno */
+  PagerLruLink free;             /* Next and previous free pages */
+  PgHdr *pNextAll;               /* A list of all pages */
+  u8 inJournal;                  /* TRUE if has been written to journal */
+  u8 dirty;                      /* TRUE if we need to write back changes */
+  u8 needSync;                   /* Sync journal before writing this page */
+  u8 alwaysRollback;             /* Disable DontRollback() for this page */
+  u8 needRead;                   /* Read content if PagerWrite() is called */
+  short int nRef;                /* Number of users of this page */
+  PgHdr *pDirty, *pPrevDirty;    /* Dirty pages */
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  PagerLruLink gfree;            /* Global list of nRef==0 pages */
+#endif
+#ifdef SQLITE_CHECK_PAGES
+  u32 pageHash;
+#endif
+  void *pData;                   /* Page data */
+  /* Pager.nExtra bytes of local data appended to this header */
+};
+
+/*
+** For an in-memory only database, some extra information is recorded about
+** each page so that changes can be rolled back.  (Journal files are not
+** used for in-memory databases.)  The following information is added to
+** the end of every EXTRA block for in-memory databases.
+**
+** This information could have been added directly to the PgHdr structure.
+** But then it would take up an extra 8 bytes of storage on every PgHdr
+** even for disk-based databases.  Splitting it out saves 8 bytes.  This
+** is only a savings of 0.8% but those percentages add up.
+*/
+typedef struct PgHistory PgHistory;
+struct PgHistory {
+  u8 *pOrig;     /* Original page text.  Restore to this on a full rollback */
+  u8 *pStmt;     /* Text as it was at the beginning of the current statement */
+  PgHdr *pNextStmt, *pPrevStmt;  /* List of pages in the statement journal */
+  u8 inStmt;                     /* TRUE if in the statement subjournal */
+};
+
+/*
+** A macro used for invoking the codec if there is one
+*/
+#ifdef SQLITE_HAS_CODEC
+# define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); }
+# define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D))
+#else
+# define CODEC1(P,D,N,X) /* NO-OP */
+# define CODEC2(P,D,N,X) ((char*)D)
+#endif
+
+/*
+** Convert a pointer to a PgHdr into a pointer to its data
+** and back again.
+*/
+#define PGHDR_TO_DATA(P)    ((P)->pData)
+#define PGHDR_TO_EXTRA(G,P) ((void*)&((G)[1]))
+#define PGHDR_TO_HIST(P,PGR)  \
+            ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->nExtra])
+
+/*
+** A open page cache is an instance of the following structure.
+**
+** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
+** or SQLITE_FULL. Once one of the first three errors occurs, it persists
+** and is returned as the result of every major pager API call.  The
+** SQLITE_FULL return code is slightly different. It persists only until the
+** next successful rollback is performed on the pager cache. Also,
+** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
+** APIs, they may still be used successfully.
+*/
+struct Pager {
+  sqlite3_vfs *pVfs;          /* OS functions to use for IO */
+  u8 journalOpen;             /* True if journal file descriptors is valid */
+  u8 journalStarted;          /* True if header of journal is synced */
+  u8 useJournal;              /* Use a rollback journal on this file */
+  u8 noReadlock;              /* Do not bother to obtain readlocks */
+  u8 stmtOpen;                /* True if the statement subjournal is open */
+  u8 stmtInUse;               /* True we are in a statement subtransaction */
+  u8 stmtAutoopen;            /* Open stmt journal when main journal is opened*/
+  u8 noSync;                  /* Do not sync the journal if true */
+  u8 fullSync;                /* Do extra syncs of the journal for robustness */
+  u8 sync_flags;              /* One of SYNC_NORMAL or SYNC_FULL */
+  u8 state;                   /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */
+  u8 tempFile;                /* zFilename is a temporary file */
+  u8 readOnly;                /* True for a read-only database */
+  u8 needSync;                /* True if an fsync() is needed on the journal */
+  u8 dirtyCache;              /* True if cached pages have changed */
+  u8 alwaysRollback;          /* Disable DontRollback() for all pages */
+  u8 memDb;                   /* True to inhibit all file I/O */
+  u8 setMaster;               /* True if a m-j name has been written to jrnl */
+  u8 doNotSync;               /* Boolean. While true, do not spill the cache */
+  u8 exclusiveMode;           /* Boolean. True if locking_mode==EXCLUSIVE */
+  u8 changeCountDone;         /* Set after incrementing the change-counter */
+  u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */
+  int errCode;                /* One of several kinds of errors */
+  int dbSize;                 /* Number of pages in the file */
+  int origDbSize;             /* dbSize before the current change */
+  int stmtSize;               /* Size of database (in pages) at stmt_begin() */
+  int nRec;                   /* Number of pages written to the journal */
+  u32 cksumInit;              /* Quasi-random value added to every checksum */
+  int stmtNRec;               /* Number of records in stmt subjournal */
+  int nExtra;                 /* Add this many bytes to each in-memory page */
+  int pageSize;               /* Number of bytes in a page */
+  int nPage;                  /* Total number of in-memory pages */
+  int nRef;                   /* Number of in-memory pages with PgHdr.nRef>0 */
+  int mxPage;                 /* Maximum number of pages to hold in cache */
+  Pgno mxPgno;                /* Maximum allowed size of the database */
+  u8 *aInJournal;             /* One bit for each page in the database file */
+  u8 *aInStmt;                /* One bit for each page in the database */
+  char *zFilename;            /* Name of the database file */
+  char *zJournal;             /* Name of the journal file */
+  char *zDirectory;           /* Directory hold database and journal files */
+  char *zStmtJrnl;            /* Name of the statement journal file */
+  sqlite3_file *fd, *jfd;     /* File descriptors for database and journal */
+  sqlite3_file *stfd;         /* File descriptor for the statement subjournal*/
+  BusyHandler *pBusyHandler;  /* Pointer to sqlite.busyHandler */
+  PagerLruList lru;           /* LRU list of free pages */
+  PgHdr *pAll;                /* List of all pages */
+  PgHdr *pStmt;               /* List of pages in the statement subjournal */
+  PgHdr *pDirty;              /* List of all dirty pages */
+  i64 journalOff;             /* Current byte offset in the journal file */
+  i64 journalHdr;             /* Byte offset to previous journal header */
+  i64 stmtHdrOff;             /* First journal header written this statement */
+  i64 stmtCksum;              /* cksumInit when statement was started */
+  i64 stmtJSize;              /* Size of journal at stmt_begin() */
+  int sectorSize;             /* Assumed sector size during rollback */
+#ifdef SQLITE_TEST
+  int nHit, nMiss;            /* Cache hits and missing */
+  int nRead, nWrite;          /* Database pages read/written */
+#endif
+  void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */
+  void (*xReiniter)(DbPage*,int);   /* Call this routine when reloading pages */
+#ifdef SQLITE_HAS_CODEC
+  void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
+  void *pCodecArg;            /* First argument to xCodec() */
+#endif
+  int nHash;                  /* Size of the pager hash table */
+  PgHdr **aHash;              /* Hash table to map page number to PgHdr */
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  Pager *pNext;               /* Doubly linked list of pagers on which */
+  Pager *pPrev;               /* sqlite3_release_memory() will work */
+  int iInUseMM;               /* Non-zero if unavailable to MM */
+  int iInUseDB;               /* Non-zero if in sqlite3_release_memory() */
+#endif
+  char *pTmpSpace;            /* Pager.pageSize bytes of space for tmp use */
+  char dbFileVers[16];        /* Changes whenever database file changes */
+};
+
+/*
+** The following global variables hold counters used for
+** testing purposes only.  These variables do not exist in
+** a non-testing build.  These variables are not thread-safe.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_pager_readdb_count = 0;    /* Number of full pages read from DB */
+int sqlite3_pager_writedb_count = 0;   /* Number of full pages written to DB */
+int sqlite3_pager_writej_count = 0;    /* Number of pages written to journal */
+int sqlite3_pager_pgfree_count = 0;    /* Number of cache pages freed */
+# define PAGER_INCR(v)  v++
+#else
+# define PAGER_INCR(v)
+#endif
+
+/*
+** The following variable points to the head of a double-linked list
+** of all pagers that are eligible for page stealing by the
+** sqlite3_release_memory() interface.  Access to this list is
+** protected by the SQLITE_MUTEX_STATIC_MEM2 mutex.
+*/
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+static Pager *sqlite3PagerList = 0;
+static PagerLruList sqlite3LruPageList = {0, 0, 0};
+#endif
+
+
+/*
+** Journal files begin with the following magic string.  The data
+** was obtained from /dev/random.  It is used only as a sanity check.
+**
+** Since version 2.8.0, the journal format contains additional sanity
+** checking information.  If the power fails while the journal is begin
+** written, semi-random garbage data might appear in the journal
+** file after power is restored.  If an attempt is then made
+** to roll the journal back, the database could be corrupted.  The additional
+** sanity checking data is an attempt to discover the garbage in the
+** journal and ignore it.
+**
+** The sanity checking information for the new journal format consists
+** of a 32-bit checksum on each page of data.  The checksum covers both
+** the page number and the pPager->pageSize bytes of data for the page.
+** This cksum is initialized to a 32-bit random value that appears in the
+** journal file right after the header.  The random initializer is important,
+** because garbage data that appears at the end of a journal is likely
+** data that was once in other files that have now been deleted.  If the
+** garbage data came from an obsolete journal file, the checksums might
+** be correct.  But by initializing the checksum to random value which
+** is different for every journal, we minimize that risk.
+*/
+static const unsigned char aJournalMagic[] = {
+  0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
+};
+
+/*
+** The size of the header and of each page in the journal is determined
+** by the following macros.
+*/
+#define JOURNAL_PG_SZ(pPager)  ((pPager->pageSize) + 8)
+
+/*
+** The journal header size for this pager. In the future, this could be
+** set to some value read from the disk controller. The important
+** characteristic is that it is the same size as a disk sector.
+*/
+#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
+
+/*
+** The macro MEMDB is true if we are dealing with an in-memory database.
+** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
+** the value of MEMDB will be a constant and the compiler will optimize
+** out code that would never execute.
+*/
+#ifdef SQLITE_OMIT_MEMORYDB
+# define MEMDB 0
+#else
+# define MEMDB pPager->memDb
+#endif
+
+/*
+** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
+** reserved for working around a windows/posix incompatibility). It is
+** used in the journal to signify that the remainder of the journal file 
+** is devoted to storing a master journal name - there are no more pages to
+** roll back. See comments for function writeMasterJournal() for details.
+*/
+/* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */
+#define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1)
+
+/*
+** The maximum legal page number is (2^31 - 1).
+*/
+#define PAGER_MAX_PGNO 2147483647
+
+/*
+** The pagerEnter() and pagerLeave() routines acquire and release
+** a mutex on each pager.  The mutex is recursive.
+**
+** This is a special-purpose mutex.  It only provides mutual exclusion
+** between the Btree and the Memory Management sqlite3_release_memory()
+** function.  It does not prevent, for example, two Btrees from accessing
+** the same pager at the same time.  Other general-purpose mutexes in
+** the btree layer handle that chore.
+*/
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  static void pagerEnter(Pager *p){
+    p->iInUseDB++;
+    if( p->iInUseMM && p->iInUseDB==1 ){
+      sqlite3_mutex *mutex;
+      mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
+      p->iInUseDB = 0;
+      sqlite3_mutex_enter(mutex);
+      p->iInUseDB = 1;
+      sqlite3_mutex_leave(mutex);
+    }
+    assert( p->iInUseMM==0 );
+  }
+  static void pagerLeave(Pager *p){
+    p->iInUseDB--;
+    assert( p->iInUseDB>=0 );
+  }
+#else
+# define pagerEnter(X)
+# define pagerLeave(X)
+#endif
+
+/*
+** Add page pPg to the end of the linked list managed by structure
+** pList (pPg becomes the last entry in the list - the most recently 
+** used). Argument pLink should point to either pPg->free or pPg->gfree,
+** depending on whether pPg is being added to the pager-specific or
+** global LRU list.
+*/
+static void listAdd(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
+  pLink->pNext = 0;
+  pLink->pPrev = pList->pLast;
+
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  assert(pLink==&pPg->free || pLink==&pPg->gfree);
+  assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
+#endif
+
+  if( pList->pLast ){
+    int iOff = (char *)pLink - (char *)pPg;
+    PagerLruLink *pLastLink = (PagerLruLink *)(&((u8 *)pList->pLast)[iOff]);
+    pLastLink->pNext = pPg;
+  }else{
+    assert(!pList->pFirst);
+    pList->pFirst = pPg;
+  }
+
+  pList->pLast = pPg;
+  if( !pList->pFirstSynced && pPg->needSync==0 ){
+    pList->pFirstSynced = pPg;
+  }
+}
+
+/*
+** Remove pPg from the list managed by the structure pointed to by pList.
+**
+** Argument pLink should point to either pPg->free or pPg->gfree, depending 
+** on whether pPg is being added to the pager-specific or global LRU list.
+*/
+static void listRemove(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){
+  int iOff = (char *)pLink - (char *)pPg;
+
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  assert(pLink==&pPg->free || pLink==&pPg->gfree);
+  assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList);
+#endif
+
+  if( pPg==pList->pFirst ){
+    pList->pFirst = pLink->pNext;
+  }
+  if( pPg==pList->pLast ){
+    pList->pLast = pLink->pPrev;
+  }
+  if( pLink->pPrev ){
+    PagerLruLink *pPrevLink = (PagerLruLink *)(&((u8 *)pLink->pPrev)[iOff]);
+    pPrevLink->pNext = pLink->pNext;
+  }
+  if( pLink->pNext ){
+    PagerLruLink *pNextLink = (PagerLruLink *)(&((u8 *)pLink->pNext)[iOff]);
+    pNextLink->pPrev = pLink->pPrev;
+  }
+  if( pPg==pList->pFirstSynced ){
+    PgHdr *p = pLink->pNext;
+    while( p && p->needSync ){
+      PagerLruLink *pL = (PagerLruLink *)(&((u8 *)p)[iOff]);
+      p = pL->pNext;
+    }
+    pList->pFirstSynced = p;
+  }
+
+  pLink->pNext = pLink->pPrev = 0;
+}
+
+/* 
+** Add page pPg to the list of free pages for the pager. If 
+** memory-management is enabled, also add the page to the global 
+** list of free pages.
+*/
+static void lruListAdd(PgHdr *pPg){
+  listAdd(&pPg->pPager->lru, &pPg->free, pPg);
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  if( !pPg->pPager->memDb ){
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+    listAdd(&sqlite3LruPageList, &pPg->gfree, pPg);
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+  }
+#endif
+}
+
+/* 
+** Remove page pPg from the list of free pages for the associated pager.
+** If memory-management is enabled, also remove pPg from the global list
+** of free pages.
+*/
+static void lruListRemove(PgHdr *pPg){
+  listRemove(&pPg->pPager->lru, &pPg->free, pPg);
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  if( !pPg->pPager->memDb ){
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+    listRemove(&sqlite3LruPageList, &pPg->gfree, pPg);
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+  }
+#endif
+}
+
+/* 
+** This function is called just after the needSync flag has been cleared
+** from all pages managed by pPager (usually because the journal file
+** has just been synced). It updates the pPager->lru.pFirstSynced variable
+** and, if memory-management is enabled, the sqlite3LruPageList.pFirstSynced
+** variable also.
+*/
+static void lruListSetFirstSynced(Pager *pPager){
+  pPager->lru.pFirstSynced = pPager->lru.pFirst;
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  if( !pPager->memDb ){
+    PgHdr *p;
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+    for(p=sqlite3LruPageList.pFirst; p && p->needSync; p=p->gfree.pNext);
+    assert(p==pPager->lru.pFirstSynced || p==sqlite3LruPageList.pFirstSynced);
+    sqlite3LruPageList.pFirstSynced = p;
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+  }
+#endif
+}
+
+/*
+** Return true if page *pPg has already been written to the statement
+** journal (or statement snapshot has been created, if *pPg is part
+** of an in-memory database).
+*/
+static int pageInStatement(PgHdr *pPg){
+  Pager *pPager = pPg->pPager;
+  if( MEMDB ){
+    return PGHDR_TO_HIST(pPg, pPager)->inStmt;
+  }else{
+    Pgno pgno = pPg->pgno;
+    u8 *a = pPager->aInStmt;
+    return (a && (int)pgno<=pPager->stmtSize && (a[pgno/8] & (1<<(pgno&7))));
+  }
+}
+
+/*
+** Change the size of the pager hash table to N.  N must be a power
+** of two.
+*/
+static void pager_resize_hash_table(Pager *pPager, int N){
+  PgHdr **aHash, *pPg;
+  assert( N>0 && (N&(N-1))==0 );
+  pagerLeave(pPager);
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, pPager->aHash!=0);
+  aHash = sqlite3MallocZero( sizeof(aHash[0])*N );
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
+  pagerEnter(pPager);
+  if( aHash==0 ){
+    /* Failure to rehash is not an error.  It is only a performance hit. */
+    return;
+  }
+  sqlite3_free(pPager->aHash);
+  pPager->nHash = N;
+  pPager->aHash = aHash;
+  for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+    int h;
+    if( pPg->pgno==0 ){
+      assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
+      continue;
+    }
+    h = pPg->pgno & (N-1);
+    pPg->pNextHash = aHash[h];
+    if( aHash[h] ){
+      aHash[h]->pPrevHash = pPg;
+    }
+    aHash[h] = pPg;
+    pPg->pPrevHash = 0;
+  }
+}
+
+/*
+** Read a 32-bit integer from the given file descriptor.  Store the integer
+** that is read in *pRes.  Return SQLITE_OK if everything worked, or an
+** error code is something goes wrong.
+**
+** All values are stored on disk as big-endian.
+*/
+static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
+  unsigned char ac[4];
+  int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
+  if( rc==SQLITE_OK ){
+    *pRes = sqlite3Get4byte(ac);
+  }
+  return rc;
+}
+
+/*
+** Write a 32-bit integer into a string buffer in big-endian byte order.
+*/
+#define put32bits(A,B)  sqlite3Put4byte((u8*)A,B)
+
+/*
+** Write a 32-bit integer into the given file descriptor.  Return SQLITE_OK
+** on success or an error code is something goes wrong.
+*/
+static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
+  char ac[4];
+  put32bits(ac, val);
+  return sqlite3OsWrite(fd, ac, 4, offset);
+}
+
+/*
+** If file pFd is open, call sqlite3OsUnlock() on it.
+*/
+static int osUnlock(sqlite3_file *pFd, int eLock){
+  if( !pFd->pMethods ){
+    return SQLITE_OK;
+  }
+  return sqlite3OsUnlock(pFd, eLock);
+}
+
+/*
+** This function determines whether or not the atomic-write optimization
+** can be used with this pager. The optimization can be used if:
+**
+**  (a) the value returned by OsDeviceCharacteristics() indicates that
+**      a database page may be written atomically, and
+**  (b) the value returned by OsSectorSize() is less than or equal
+**      to the page size.
+**
+** If the optimization cannot be used, 0 is returned. If it can be used,
+** then the value returned is the size of the journal file when it
+** contains rollback data for exactly one page.
+*/
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+static int jrnlBufferSize(Pager *pPager){
+  int dc;           /* Device characteristics */
+  int nSector;      /* Sector size */
+  int nPage;        /* Page size */
+  sqlite3_file *fd = pPager->fd;
+
+  if( fd->pMethods ){
+    dc = sqlite3OsDeviceCharacteristics(fd);
+    nSector = sqlite3OsSectorSize(fd);
+    nPage = pPager->pageSize;
+  }
+
+  assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
+  assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
+
+  if( !fd->pMethods || (dc&(SQLITE_IOCAP_ATOMIC|(nPage>>8))&&nSector<=nPage) ){
+    return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
+  }
+  return 0;
+}
+#endif
+
+/*
+** This function should be called when an error occurs within the pager
+** code. The first argument is a pointer to the pager structure, the
+** second the error-code about to be returned by a pager API function. 
+** The value returned is a copy of the second argument to this function. 
+**
+** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL
+** the error becomes persistent. Until the persisten error is cleared,
+** subsequent API calls on this Pager will immediately return the same 
+** error code.
+**
+** A persistent error indicates that the contents of the pager-cache 
+** cannot be trusted. This state can be cleared by completely discarding 
+** the contents of the pager-cache. If a transaction was active when
+** the persistent error occured, then the rollback journal may need
+** to be replayed.
+*/
+static void pager_unlock(Pager *pPager);
+static int pager_error(Pager *pPager, int rc){
+  int rc2 = rc & 0xff;
+  assert(
+       pPager->errCode==SQLITE_FULL ||
+       pPager->errCode==SQLITE_OK ||
+       (pPager->errCode & 0xff)==SQLITE_IOERR
+  );
+  if(
+    rc2==SQLITE_FULL ||
+    rc2==SQLITE_IOERR ||
+    rc2==SQLITE_CORRUPT
+  ){
+    pPager->errCode = rc;
+    if( pPager->state==PAGER_UNLOCK && pPager->nRef==0 ){
+      /* If the pager is already unlocked, call pager_unlock() now to
+      ** clear the error state and ensure that the pager-cache is 
+      ** completely empty.
+      */
+      pager_unlock(pPager);
+    }
+  }
+  return rc;
+}
+
+/*
+** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
+** on the cache using a hash function.  This is used for testing
+** and debugging only.
+*/
+#ifdef SQLITE_CHECK_PAGES
+/*
+** Return a 32-bit hash of the page data for pPage.
+*/
+static u32 pager_datahash(int nByte, unsigned char *pData){
+  u32 hash = 0;
+  int i;
+  for(i=0; i<nByte; i++){
+    hash = (hash*1039) + pData[i];
+  }
+  return hash;
+}
+static u32 pager_pagehash(PgHdr *pPage){
+  return pager_datahash(pPage->pPager->pageSize, 
+                        (unsigned char *)PGHDR_TO_DATA(pPage));
+}
+
+/*
+** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
+** is defined, and NDEBUG is not defined, an assert() statement checks
+** that the page is either dirty or still matches the calculated page-hash.
+*/
+#define CHECK_PAGE(x) checkPage(x)
+static void checkPage(PgHdr *pPg){
+  Pager *pPager = pPg->pPager;
+  assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty || 
+      pPg->pageHash==pager_pagehash(pPg) );
+}
+
+#else
+#define pager_datahash(X,Y)  0
+#define pager_pagehash(X)  0
+#define CHECK_PAGE(x)
+#endif
+
+/*
+** When this is called the journal file for pager pPager must be open.
+** The master journal file name is read from the end of the file and 
+** written into memory supplied by the caller. 
+**
+** zMaster must point to a buffer of at least nMaster bytes allocated by
+** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
+** enough space to write the master journal name). If the master journal
+** name in the journal is longer than nMaster bytes (including a
+** nul-terminator), then this is handled as if no master journal name
+** were present in the journal.
+**
+** If no master journal file name is present zMaster[0] is set to 0 and
+** SQLITE_OK returned.
+*/
+static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){
+  int rc;
+  u32 len;
+  i64 szJ;
+  u32 cksum;
+  int i;
+  unsigned char aMagic[8]; /* A buffer to hold the magic header */
+
+  zMaster[0] = '\0';
+
+  rc = sqlite3OsFileSize(pJrnl, &szJ);
+  if( rc!=SQLITE_OK || szJ<16 ) return rc;
+
+  rc = read32bits(pJrnl, szJ-16, &len);
+  if( rc!=SQLITE_OK ) return rc;
+
+  if( len>=nMaster ){
+    return SQLITE_OK;
+  }
+
+  rc = read32bits(pJrnl, szJ-12, &cksum);
+  if( rc!=SQLITE_OK ) return rc;
+
+  rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8);
+  if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc;
+
+  rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  zMaster[len] = '\0';
+
+  /* See if the checksum matches the master journal name */
+  for(i=0; i<len; i++){
+    cksum -= zMaster[i];
+   }
+  if( cksum ){
+    /* If the checksum doesn't add up, then one or more of the disk sectors
+    ** containing the master journal filename is corrupted. This means
+    ** definitely roll back, so just return SQLITE_OK and report a (nul)
+    ** master-journal filename.
+    */
+    zMaster[0] = '\0';
+  }
+   
+  return SQLITE_OK;
+}
+
+/*
+** Seek the journal file descriptor to the next sector boundary where a
+** journal header may be read or written. Pager.journalOff is updated with
+** the new seek offset.
+**
+** i.e for a sector size of 512:
+**
+** Input Offset              Output Offset
+** ---------------------------------------
+** 0                         0
+** 512                       512
+** 100                       512
+** 2000                      2048
+** 
+*/
+static void seekJournalHdr(Pager *pPager){
+  i64 offset = 0;
+  i64 c = pPager->journalOff;
+  if( c ){
+    offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
+  }
+  assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
+  assert( offset>=c );
+  assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
+  pPager->journalOff = offset;
+}
+
+/*
+** The journal file must be open when this routine is called. A journal
+** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
+** current location.
+**
+** The format for the journal header is as follows:
+** - 8 bytes: Magic identifying journal format.
+** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
+** - 4 bytes: Random number used for page hash.
+** - 4 bytes: Initial database page count.
+** - 4 bytes: Sector size used by the process that wrote this journal.
+** 
+** Followed by (JOURNAL_HDR_SZ - 24) bytes of unused space.
+*/
+static int writeJournalHdr(Pager *pPager){
+  char zHeader[sizeof(aJournalMagic)+16];
+  int rc;
+
+  if( pPager->stmtHdrOff==0 ){
+    pPager->stmtHdrOff = pPager->journalOff;
+  }
+
+  seekJournalHdr(pPager);
+  pPager->journalHdr = pPager->journalOff;
+
+  memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
+
+  /* 
+  ** Write the nRec Field - the number of page records that follow this
+  ** journal header. Normally, zero is written to this value at this time.
+  ** After the records are added to the journal (and the journal synced, 
+  ** if in full-sync mode), the zero is overwritten with the true number
+  ** of records (see syncJournal()).
+  **
+  ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
+  ** reading the journal this value tells SQLite to assume that the
+  ** rest of the journal file contains valid page records. This assumption
+  ** is dangerous, as if a failure occured whilst writing to the journal
+  ** file it may contain some garbage data. There are two scenarios
+  ** where this risk can be ignored:
+  **
+  **   * When the pager is in no-sync mode. Corruption can follow a
+  **     power failure in this case anyway.
+  **
+  **   * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
+  **     that garbage data is never appended to the journal file.
+  */
+  assert(pPager->fd->pMethods||pPager->noSync);
+  if( (pPager->noSync) 
+   || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) 
+  ){
+    put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
+  }else{
+    put32bits(&zHeader[sizeof(aJournalMagic)], 0);
+  }
+
+  /* The random check-hash initialiser */ 
+  sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
+  put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
+  /* The initial database size */
+  put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize);
+  /* The assumed sector size for this process */
+  put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
+  IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, sizeof(zHeader)))
+  rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader),pPager->journalOff);
+  pPager->journalOff += JOURNAL_HDR_SZ(pPager);
+
+  /* The journal header has been written successfully. Seek the journal
+  ** file descriptor to the end of the journal header sector.
+  */
+  if( rc==SQLITE_OK ){
+    IOTRACE(("JTAIL %p %lld\n", pPager, pPager->journalOff-1))
+    rc = sqlite3OsWrite(pPager->jfd, "\000", 1, pPager->journalOff-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
+** file. See comments above function writeJournalHdr() for a description of
+** the journal header format.
+**
+** If the header is read successfully, *nRec is set to the number of
+** page records following this header and *dbSize is set to the size of the
+** database before the transaction began, in pages. Also, pPager->cksumInit
+** is set to the value read from the journal header. SQLITE_OK is returned
+** in this case.
+**
+** If the journal header file appears to be corrupted, SQLITE_DONE is
+** returned and *nRec and *dbSize are not set.  If JOURNAL_HDR_SZ bytes
+** cannot be read from the journal file an error code is returned.
+*/
+static int readJournalHdr(
+  Pager *pPager, 
+  i64 journalSize,
+  u32 *pNRec, 
+  u32 *pDbSize
+){
+  int rc;
+  unsigned char aMagic[8]; /* A buffer to hold the magic header */
+  i64 jrnlOff;
+
+  seekJournalHdr(pPager);
+  if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
+    return SQLITE_DONE;
+  }
+  jrnlOff = pPager->journalOff;
+
+  rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff);
+  if( rc ) return rc;
+  jrnlOff += sizeof(aMagic);
+
+  if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
+    return SQLITE_DONE;
+  }
+
+  rc = read32bits(pPager->jfd, jrnlOff, pNRec);
+  if( rc ) return rc;
+
+  rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit);
+  if( rc ) return rc;
+
+  rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize);
+  if( rc ) return rc;
+
+  /* Update the assumed sector-size to match the value used by 
+  ** the process that created this journal. If this journal was
+  ** created by a process other than this one, then this routine
+  ** is being called from within pager_playback(). The local value
+  ** of Pager.sectorSize is restored at the end of that routine.
+  */
+  rc = read32bits(pPager->jfd, jrnlOff+12, (u32 *)&pPager->sectorSize);
+  if( rc ) return rc;
+
+  pPager->journalOff += JOURNAL_HDR_SZ(pPager);
+  return SQLITE_OK;
+}
+
+
+/*
+** Write the supplied master journal name into the journal file for pager
+** pPager at the current location. The master journal name must be the last
+** thing written to a journal file. If the pager is in full-sync mode, the
+** journal file descriptor is advanced to the next sector boundary before
+** anything is written. The format is:
+**
+** + 4 bytes: PAGER_MJ_PGNO.
+** + N bytes: length of master journal name.
+** + 4 bytes: N
+** + 4 bytes: Master journal name checksum.
+** + 8 bytes: aJournalMagic[].
+**
+** The master journal page checksum is the sum of the bytes in the master
+** journal name.
+**
+** If zMaster is a NULL pointer (occurs for a single database transaction), 
+** this call is a no-op.
+*/
+static int writeMasterJournal(Pager *pPager, const char *zMaster){
+  int rc;
+  int len; 
+  int i; 
+  i64 jrnlOff;
+  u32 cksum = 0;
+  char zBuf[sizeof(aJournalMagic)+2*4];
+
+  if( !zMaster || pPager->setMaster) return SQLITE_OK;
+  pPager->setMaster = 1;
+
+  len = strlen(zMaster);
+  for(i=0; i<len; i++){
+    cksum += zMaster[i];
+  }
+
+  /* If in full-sync mode, advance to the next disk sector before writing
+  ** the master journal name. This is in case the previous page written to
+  ** the journal has already been synced.
+  */
+  if( pPager->fullSync ){
+    seekJournalHdr(pPager);
+  }
+  jrnlOff = pPager->journalOff;
+  pPager->journalOff += (len+20);
+
+  rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager));
+  if( rc!=SQLITE_OK ) return rc;
+  jrnlOff += 4;
+
+  rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff);
+  if( rc!=SQLITE_OK ) return rc;
+  jrnlOff += len;
+
+  put32bits(zBuf, len);
+  put32bits(&zBuf[4], cksum);
+  memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic));
+  rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff);
+  pPager->needSync = !pPager->noSync;
+  return rc;
+}
+
+/*
+** Add or remove a page from the list of all pages that are in the
+** statement journal.
+**
+** The Pager keeps a separate list of pages that are currently in
+** the statement journal.  This helps the sqlite3PagerStmtCommit()
+** routine run MUCH faster for the common case where there are many
+** pages in memory but only a few are in the statement journal.
+*/
+static void page_add_to_stmt_list(PgHdr *pPg){
+  Pager *pPager = pPg->pPager;
+  PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+  assert( MEMDB );
+  if( !pHist->inStmt ){
+    assert( pHist->pPrevStmt==0 && pHist->pNextStmt==0 );
+    if( pPager->pStmt ){
+      PGHDR_TO_HIST(pPager->pStmt, pPager)->pPrevStmt = pPg;
+    }
+    pHist->pNextStmt = pPager->pStmt;
+    pPager->pStmt = pPg;
+    pHist->inStmt = 1;
+  }
+}
+
+/*
+** Find a page in the hash table given its page number.  Return
+** a pointer to the page or NULL if not found.
+*/
+static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
+  PgHdr *p;
+  if( pPager->aHash==0 ) return 0;
+  p = pPager->aHash[pgno & (pPager->nHash-1)];
+  while( p && p->pgno!=pgno ){
+    p = p->pNextHash;
+  }
+  return p;
+}
+
+/*
+** Clear the in-memory cache.  This routine
+** sets the state of the pager back to what it was when it was first
+** opened.  Any outstanding pages are invalidated and subsequent attempts
+** to access those pages will likely result in a coredump.
+*/
+static void pager_reset(Pager *pPager){
+  PgHdr *pPg, *pNext;
+  if( pPager->errCode ) return;
+  for(pPg=pPager->pAll; pPg; pPg=pNext){
+    IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno));
+    PAGER_INCR(sqlite3_pager_pgfree_count);
+    pNext = pPg->pNextAll;
+    lruListRemove(pPg);
+    sqlite3_free(pPg);
+  }
+  assert(pPager->lru.pFirst==0);
+  assert(pPager->lru.pFirstSynced==0);
+  assert(pPager->lru.pLast==0);
+  pPager->pStmt = 0;
+  pPager->pAll = 0;
+  pPager->pDirty = 0;
+  pPager->nHash = 0;
+  sqlite3_free(pPager->aHash);
+  pPager->nPage = 0;
+  pPager->aHash = 0;
+  pPager->nRef = 0;
+}
+
+/*
+** Unlock the database file. 
+**
+** If the pager is currently in error state, discard the contents of 
+** the cache and reset the Pager structure internal state. If there is
+** an open journal-file, then the next time a shared-lock is obtained
+** on the pager file (by this or any other process), it will be
+** treated as a hot-journal and rolled back.
+*/
+static void pager_unlock(Pager *pPager){
+  if( !pPager->exclusiveMode ){
+    if( !MEMDB ){
+      if( pPager->fd->pMethods ){
+        osUnlock(pPager->fd, NO_LOCK);
+      }
+      pPager->dbSize = -1;
+      IOTRACE(("UNLOCK %p\n", pPager))
+
+      /* If Pager.errCode is set, the contents of the pager cache cannot be
+      ** trusted. Now that the pager file is unlocked, the contents of the
+      ** cache can be discarded and the error code safely cleared.
+      */
+      if( pPager->errCode ){
+        pPager->errCode = SQLITE_OK;
+        pager_reset(pPager);
+        if( pPager->stmtOpen ){
+          sqlite3OsClose(pPager->stfd);
+          sqlite3_free(pPager->aInStmt);
+          pPager->aInStmt = 0;
+        }
+        if( pPager->journalOpen ){
+          sqlite3OsClose(pPager->jfd);
+          pPager->journalOpen = 0;
+          sqlite3_free(pPager->aInJournal);
+          pPager->aInJournal = 0;
+        }
+        pPager->stmtOpen = 0;
+        pPager->stmtInUse = 0;
+        pPager->journalOff = 0;
+        pPager->journalStarted = 0;
+        pPager->stmtAutoopen = 0;
+        pPager->origDbSize = 0;
+      }
+    }
+
+    if( !MEMDB || pPager->errCode==SQLITE_OK ){
+      pPager->state = PAGER_UNLOCK;
+      pPager->changeCountDone = 0;
+    }
+  }
+}
+
+/*
+** Execute a rollback if a transaction is active and unlock the 
+** database file. If the pager has already entered the error state, 
+** do not attempt the rollback.
+*/
+static void pagerUnlockAndRollback(Pager *p){
+  assert( p->state>=PAGER_RESERVED || p->journalOpen==0 );
+  if( p->errCode==SQLITE_OK && p->state>=PAGER_RESERVED ){
+    sqlite3PagerRollback(p);
+  }
+  pager_unlock(p);
+  assert( p->errCode || !p->journalOpen || (p->exclusiveMode&&!p->journalOff) );
+  assert( p->errCode || !p->stmtOpen || p->exclusiveMode );
+}
+
+/*
+** This routine ends a transaction.  A transaction is ended by either
+** a COMMIT or a ROLLBACK.
+**
+** When this routine is called, the pager has the journal file open and
+** a RESERVED or EXCLUSIVE lock on the database.  This routine will release
+** the database lock and acquires a SHARED lock in its place if that is
+** the appropriate thing to do.  Release locks usually is appropriate,
+** unless we are in exclusive access mode or unless this is a 
+** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation.
+**
+** The journal file is either deleted or truncated.
+**
+** TODO: Consider keeping the journal file open for temporary databases.
+** This might give a performance improvement on windows where opening
+** a file is an expensive operation.
+*/
+static int pager_end_transaction(Pager *pPager){
+  PgHdr *pPg;
+  int rc = SQLITE_OK;
+  int rc2 = SQLITE_OK;
+  assert( !MEMDB );
+  if( pPager->state<PAGER_RESERVED ){
+    return SQLITE_OK;
+  }
+  sqlite3PagerStmtCommit(pPager);
+  if( pPager->stmtOpen && !pPager->exclusiveMode ){
+    sqlite3OsClose(pPager->stfd);
+    pPager->stmtOpen = 0;
+  }
+  if( pPager->journalOpen ){
+    if( pPager->exclusiveMode 
+          && (rc = sqlite3OsTruncate(pPager->jfd, 0))==SQLITE_OK ){;
+      pPager->journalOff = 0;
+      pPager->journalStarted = 0;
+    }else{
+      sqlite3OsClose(pPager->jfd);
+      pPager->journalOpen = 0;
+      if( rc==SQLITE_OK ){
+        rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
+      }
+    }
+    sqlite3_free( pPager->aInJournal );
+    pPager->aInJournal = 0;
+    for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+      pPg->inJournal = 0;
+      pPg->dirty = 0;
+      pPg->needSync = 0;
+      pPg->alwaysRollback = 0;
+#ifdef SQLITE_CHECK_PAGES
+      pPg->pageHash = pager_pagehash(pPg);
+#endif
+    }
+    pPager->pDirty = 0;
+    pPager->dirtyCache = 0;
+    pPager->nRec = 0;
+  }else{
+    assert( pPager->aInJournal==0 );
+    assert( pPager->dirtyCache==0 || pPager->useJournal==0 );
+  }
+
+  if( !pPager->exclusiveMode ){
+    rc2 = osUnlock(pPager->fd, SHARED_LOCK);
+    pPager->state = PAGER_SHARED;
+  }else if( pPager->state==PAGER_SYNCED ){
+    pPager->state = PAGER_EXCLUSIVE;
+  }
+  pPager->origDbSize = 0;
+  pPager->setMaster = 0;
+  pPager->needSync = 0;
+  lruListSetFirstSynced(pPager);
+  pPager->dbSize = -1;
+
+  return (rc==SQLITE_OK?rc2:rc);
+}
+
+/*
+** Compute and return a checksum for the page of data.
+**
+** This is not a real checksum.  It is really just the sum of the 
+** random initial value and the page number.  We experimented with
+** a checksum of the entire data, but that was found to be too slow.
+**
+** Note that the page number is stored at the beginning of data and
+** the checksum is stored at the end.  This is important.  If journal
+** corruption occurs due to a power failure, the most likely scenario
+** is that one end or the other of the record will be changed.  It is
+** much less likely that the two ends of the journal record will be
+** correct and the middle be corrupt.  Thus, this "checksum" scheme,
+** though fast and simple, catches the mostly likely kind of corruption.
+**
+** FIX ME:  Consider adding every 200th (or so) byte of the data to the
+** checksum.  That way if a single page spans 3 or more disk sectors and
+** only the middle sector is corrupt, we will still have a reasonable
+** chance of failing the checksum and thus detecting the problem.
+*/
+static u32 pager_cksum(Pager *pPager, const u8 *aData){
+  u32 cksum = pPager->cksumInit;
+  int i = pPager->pageSize-200;
+  while( i>0 ){
+    cksum += aData[i];
+    i -= 200;
+  }
+  return cksum;
+}
+
+/* Forward declaration */
+static void makeClean(PgHdr*);
+
+/*
+** Read a single page from the journal file opened on file descriptor
+** jfd.  Playback this one page.
+**
+** If useCksum==0 it means this journal does not use checksums.  Checksums
+** are not used in statement journals because statement journals do not
+** need to survive power failures.
+*/
+static int pager_playback_one_page(
+  Pager *pPager, 
+  sqlite3_file *jfd,
+  i64 offset,
+  int useCksum
+){
+  int rc;
+  PgHdr *pPg;                   /* An existing page in the cache */
+  Pgno pgno;                    /* The page number of a page in journal */
+  u32 cksum;                    /* Checksum used for sanity checking */
+  u8 *aData = (u8 *)pPager->pTmpSpace;   /* Temp storage for a page */
+
+  /* useCksum should be true for the main journal and false for
+  ** statement journals.  Verify that this is always the case
+  */
+  assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) );
+  assert( aData );
+
+  rc = read32bits(jfd, offset, &pgno);
+  if( rc!=SQLITE_OK ) return rc;
+  rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4);
+  if( rc!=SQLITE_OK ) return rc;
+  pPager->journalOff += pPager->pageSize + 4;
+
+  /* Sanity checking on the page.  This is more important that I originally
+  ** thought.  If a power failure occurs while the journal is being written,
+  ** it could cause invalid data to be written into the journal.  We need to
+  ** detect this invalid data (with high probability) and ignore it.
+  */
+  if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
+    return SQLITE_DONE;
+  }
+  if( pgno>(unsigned)pPager->dbSize ){
+    return SQLITE_OK;
+  }
+  if( useCksum ){
+    rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum);
+    if( rc ) return rc;
+    pPager->journalOff += 4;
+    if( pager_cksum(pPager, aData)!=cksum ){
+      return SQLITE_DONE;
+    }
+  }
+
+  assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );
+
+  /* If the pager is in RESERVED state, then there must be a copy of this
+  ** page in the pager cache. In this case just update the pager cache,
+  ** not the database file. The page is left marked dirty in this case.
+  **
+  ** An exception to the above rule: If the database is in no-sync mode
+  ** and a page is moved during an incremental vacuum then the page may
+  ** not be in the pager cache. Later: if a malloc() or IO error occurs
+  ** during a Movepage() call, then the page may not be in the cache
+  ** either. So the condition described in the above paragraph is not
+  ** assert()able.
+  **
+  ** If in EXCLUSIVE state, then we update the pager cache if it exists
+  ** and the main file. The page is then marked not dirty.
+  **
+  ** Ticket #1171:  The statement journal might contain page content that is
+  ** different from the page content at the start of the transaction.
+  ** This occurs when a page is changed prior to the start of a statement
+  ** then changed again within the statement.  When rolling back such a
+  ** statement we must not write to the original database unless we know
+  ** for certain that original page contents are synced into the main rollback
+  ** journal.  Otherwise, a power loss might leave modified data in the
+  ** database file without an entry in the rollback journal that can
+  ** restore the database to its original form.  Two conditions must be
+  ** met before writing to the database files. (1) the database must be
+  ** locked.  (2) we know that the original page content is fully synced
+  ** in the main journal either because the page is not in cache or else
+  ** the page is marked as needSync==0.
+  */
+  pPg = pager_lookup(pPager, pgno);
+  PAGERTRACE4("PLAYBACK %d page %d hash(%08x)\n",
+               PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData));
+  if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){
+    i64 offset = (pgno-1)*(i64)pPager->pageSize;
+    rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, offset);
+    if( pPg ){
+      makeClean(pPg);
+    }
+  }
+  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
+    ** sqlite3PagerRollback().
+    */
+    void *pData;
+    /* assert( pPg->nRef==0 || pPg->pgno==1 ); */
+    pData = PGHDR_TO_DATA(pPg);
+    memcpy(pData, aData, pPager->pageSize);
+    if( pPager->xReiniter ){
+      pPager->xReiniter(pPg, pPager->pageSize);
+    }
+#ifdef SQLITE_CHECK_PAGES
+    pPg->pageHash = pager_pagehash(pPg);
+#endif
+    /* If this was page 1, then restore the value of Pager.dbFileVers.
+    ** Do this before any decoding. */
+    if( pgno==1 ){
+      memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
+    }
+
+    /* Decode the page just read from disk */
+    CODEC1(pPager, pData, pPg->pgno, 3);
+  }
+  return rc;
+}
+
+/*
+** Parameter zMaster is the name of a master journal file. A single journal
+** file that referred to the master journal file has just been rolled back.
+** This routine checks if it is possible to delete the master journal file,
+** and does so if it is.
+**
+** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not 
+** available for use within this function.
+**
+**
+** The master journal file contains the names of all child journals.
+** To tell if a master journal can be deleted, check to each of the
+** children.  If all children are either missing or do not refer to
+** a different master journal, then this master journal can be deleted.
+*/
+static int pager_delmaster(Pager *pPager, const char *zMaster){
+  sqlite3_vfs *pVfs = pPager->pVfs;
+  int rc;
+  int master_open = 0;
+  sqlite3_file *pMaster;
+  sqlite3_file *pJournal;
+  char *zMasterJournal = 0; /* Contents of master journal file */
+  i64 nMasterJournal;       /* Size of master journal file */
+
+  /* Open the master journal file exclusively in case some other process
+  ** is running this routine also. Not that it makes too much difference.
+  */
+  pMaster = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile * 2);
+  pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
+  if( !pMaster ){
+    rc = SQLITE_NOMEM;
+  }else{
+    int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
+    rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
+  }
+  if( rc!=SQLITE_OK ) goto delmaster_out;
+  master_open = 1;
+
+  rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
+  if( rc!=SQLITE_OK ) goto delmaster_out;
+
+  if( nMasterJournal>0 ){
+    char *zJournal;
+    char *zMasterPtr = 0;
+    int nMasterPtr = pPager->pVfs->mxPathname+1;
+
+    /* Load the entire master journal file into space obtained from
+    ** sqlite3_malloc() and pointed to by zMasterJournal. 
+    */
+    zMasterJournal = (char *)sqlite3_malloc(nMasterJournal + nMasterPtr);
+    if( !zMasterJournal ){
+      rc = SQLITE_NOMEM;
+      goto delmaster_out;
+    }
+    zMasterPtr = &zMasterJournal[nMasterJournal];
+    rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0);
+    if( rc!=SQLITE_OK ) goto delmaster_out;
+
+    zJournal = zMasterJournal;
+    while( (zJournal-zMasterJournal)<nMasterJournal ){
+      if( sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS) ){
+        /* One of the journals pointed to by the master journal exists.
+        ** Open it and check if it points at the master journal. If
+        ** so, return without deleting the master journal file.
+        */
+        int c;
+        int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
+        rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
+        if( rc!=SQLITE_OK ){
+          goto delmaster_out;
+        }
+
+        rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
+        sqlite3OsClose(pJournal);
+        if( rc!=SQLITE_OK ){
+          goto delmaster_out;
+        }
+
+        c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
+        if( c ){
+          /* We have a match. Do not delete the master journal file. */
+          goto delmaster_out;
+        }
+      }
+      zJournal += (strlen(zJournal)+1);
+    }
+  }
+  
+  rc = sqlite3OsDelete(pVfs, zMaster, 0);
+
+delmaster_out:
+  if( zMasterJournal ){
+    sqlite3_free(zMasterJournal);
+  }  
+  if( master_open ){
+    sqlite3OsClose(pMaster);
+  }
+  sqlite3_free(pMaster);
+  return rc;
+}
+
+
+static void pager_truncate_cache(Pager *pPager);
+
+/*
+** Truncate the main file of the given pager to the number of pages
+** indicated. Also truncate the cached representation of the file.
+**
+** Might might be the case that the file on disk is smaller than nPage.
+** This can happen, for example, if we are in the middle of a transaction
+** which has extended the file size and the new pages are still all held
+** in cache, then an INSERT or UPDATE does a statement rollback.  Some
+** operating system implementations can get confused if you try to
+** truncate a file to some size that is larger than it currently is,
+** so detect this case and do not do the truncation.
+*/
+static int pager_truncate(Pager *pPager, int nPage){
+  int rc = SQLITE_OK;
+  if( pPager->state>=PAGER_EXCLUSIVE && pPager->fd->pMethods ){
+    i64 currentSize, newSize;
+    rc = sqlite3OsFileSize(pPager->fd, &currentSize);
+    newSize = pPager->pageSize*(i64)nPage;
+    if( rc==SQLITE_OK && currentSize>newSize ){
+      rc = sqlite3OsTruncate(pPager->fd, newSize);
+    }
+  }
+  if( rc==SQLITE_OK ){
+    pPager->dbSize = nPage;
+    pager_truncate_cache(pPager);
+  }
+  return rc;
+}
+
+/*
+** Set the sectorSize for the given pager.
+**
+** The sector size is the larger of the sector size reported
+** by sqlite3OsSectorSize() and the pageSize.
+*/
+static void setSectorSize(Pager *pPager){
+  assert(pPager->fd->pMethods||pPager->tempFile);
+  if( !pPager->tempFile ){
+    /* Sector size doesn't matter for temporary files. Also, the file
+    ** may not have been opened yet, in whcih case the OsSectorSize()
+    ** call will segfault.
+    */
+    pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
+  }
+  if( pPager->sectorSize<pPager->pageSize ){
+    pPager->sectorSize = pPager->pageSize;
+  }
+}
+
+/*
+** Playback the journal and thus restore the database file to
+** the state it was in before we started making changes.  
+**
+** The journal file format is as follows: 
+**
+**  (1)  8 byte prefix.  A copy of aJournalMagic[].
+**  (2)  4 byte big-endian integer which is the number of valid page records
+**       in the journal.  If this value is 0xffffffff, then compute the
+**       number of page records from the journal size.
+**  (3)  4 byte big-endian integer which is the initial value for the 
+**       sanity checksum.
+**  (4)  4 byte integer which is the number of pages to truncate the
+**       database to during a rollback.
+**  (5)  4 byte integer which is the number of bytes in the master journal
+**       name.  The value may be zero (indicate that there is no master
+**       journal.)
+**  (6)  N bytes of the master journal name.  The name will be nul-terminated
+**       and might be shorter than the value read from (5).  If the first byte
+**       of the name is \000 then there is no master journal.  The master
+**       journal name is stored in UTF-8.
+**  (7)  Zero or more pages instances, each as follows:
+**        +  4 byte page number.
+**        +  pPager->pageSize bytes of data.
+**        +  4 byte checksum
+**
+** When we speak of the journal header, we mean the first 6 items above.
+** Each entry in the journal is an instance of the 7th item.
+**
+** Call the value from the second bullet "nRec".  nRec is the number of
+** valid page entries in the journal.  In most cases, you can compute the
+** value of nRec from the size of the journal file.  But if a power
+** failure occurred while the journal was being written, it could be the
+** case that the size of the journal file had already been increased but
+** the extra entries had not yet made it safely to disk.  In such a case,
+** the value of nRec computed from the file size would be too large.  For
+** that reason, we always use the nRec value in the header.
+**
+** If the nRec value is 0xffffffff it means that nRec should be computed
+** from the file size.  This value is used when the user selects the
+** no-sync option for the journal.  A power failure could lead to corruption
+** in this case.  But for things like temporary table (which will be
+** deleted when the power is restored) we don't care.  
+**
+** If the file opened as the journal file is not a well-formed
+** journal file then all pages up to the first corrupted page are rolled
+** back (or no pages if the journal header is corrupted). The journal file
+** is then deleted and SQLITE_OK returned, just as if no corruption had
+** been encountered.
+**
+** If an I/O or malloc() error occurs, the journal-file is not deleted
+** and an error code is returned.
+*/
+static int pager_playback(Pager *pPager, int isHot){
+  sqlite3_vfs *pVfs = pPager->pVfs;
+  i64 szJ;                 /* Size of the journal file in bytes */
+  u32 nRec;                /* Number of Records in the journal */
+  int i;                   /* Loop counter */
+  Pgno mxPg = 0;           /* Size of the original file in pages */
+  int rc;                  /* Result code of a subroutine */
+  char *zMaster = 0;       /* Name of master journal file if any */
+
+  /* Figure out how many records are in the journal.  Abort early if
+  ** the journal is empty.
+  */
+  assert( pPager->journalOpen );
+  rc = sqlite3OsFileSize(pPager->jfd, &szJ);
+  if( rc!=SQLITE_OK || szJ==0 ){
+    goto end_playback;
+  }
+
+  /* Read the master journal name from the journal, if it is present.
+  ** If a master journal file name is specified, but the file is not
+  ** present on disk, then the journal is not hot and does not need to be
+  ** played back.
+  */
+  zMaster = pPager->pTmpSpace;
+  rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
+  assert( rc!=SQLITE_DONE );
+  if( rc!=SQLITE_OK 
+   || (zMaster[0] && !sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS)) 
+  ){
+    zMaster = 0;
+    if( rc==SQLITE_DONE ) rc = SQLITE_OK;
+    goto end_playback;
+  }
+  pPager->journalOff = 0;
+  zMaster = 0;
+
+  /* This loop terminates either when the readJournalHdr() call returns
+  ** SQLITE_DONE or an IO error occurs. */
+  while( 1 ){
+
+    /* Read the next journal header from the journal file.  If there are
+    ** not enough bytes left in the journal file for a complete header, or
+    ** it is corrupted, then a process must of failed while writing it.
+    ** This indicates nothing more needs to be rolled back.
+    */
+    rc = readJournalHdr(pPager, szJ, &nRec, &mxPg);
+    if( rc!=SQLITE_OK ){ 
+      if( rc==SQLITE_DONE ){
+        rc = SQLITE_OK;
+      }
+      goto end_playback;
+    }
+
+    /* If nRec is 0xffffffff, then this journal was created by a process
+    ** working in no-sync mode. This means that the rest of the journal
+    ** file consists of pages, there are no more journal headers. Compute
+    ** the value of nRec based on this assumption.
+    */
+    if( nRec==0xffffffff ){
+      assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
+      nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager);
+    }
+
+    /* If nRec is 0 and this rollback is of a transaction created by this
+    ** process and if this is the final header in the journal, then it means
+    ** that this part of the journal was being filled but has not yet been
+    ** synced to disk.  Compute the number of pages based on the remaining
+    ** size of the file.
+    **
+    ** The third term of the test was added to fix ticket #2565.
+    */
+    if( nRec==0 && !isHot &&
+        pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
+      nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager);
+    }
+
+    /* If this is the first header read from the journal, truncate the
+    ** database file back to its original size.
+    */
+    if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
+      rc = pager_truncate(pPager, mxPg);
+      if( rc!=SQLITE_OK ){
+        goto end_playback;
+      }
+    }
+
+    /* Copy original pages out of the journal and back into the database file.
+    */
+    for(i=0; i<nRec; i++){
+      rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
+      if( rc!=SQLITE_OK ){
+        if( rc==SQLITE_DONE ){
+          rc = SQLITE_OK;
+          pPager->journalOff = szJ;
+          break;
+        }else{
+          goto end_playback;
+        }
+      }
+    }
+  }
+  /*NOTREACHED*/
+  assert( 0 );
+
+end_playback:
+  if( rc==SQLITE_OK ){
+    zMaster = pPager->pTmpSpace;
+    rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
+  }
+  if( rc==SQLITE_OK ){
+    rc = pager_end_transaction(pPager);
+  }
+  if( rc==SQLITE_OK && zMaster[0] ){
+    /* If there was a master journal and this routine will return success,
+    ** see if it is possible to delete the master journal.
+    */
+    rc = pager_delmaster(pPager, zMaster);
+  }
+
+  /* The Pager.sectorSize variable may have been updated while rolling
+  ** back a journal created by a process with a different sector size
+  ** value. Reset it to the correct value for this process.
+  */
+  setSectorSize(pPager);
+  return rc;
+}
+
+/*
+** Playback the statement journal.
+**
+** This is similar to playing back the transaction journal but with
+** a few extra twists.
+**
+**    (1)  The number of pages in the database file at the start of
+**         the statement is stored in pPager->stmtSize, not in the
+**         journal file itself.
+**
+**    (2)  In addition to playing back the statement journal, also
+**         playback all pages of the transaction journal beginning
+**         at offset pPager->stmtJSize.
+*/
+static int pager_stmt_playback(Pager *pPager){
+  i64 szJ;                 /* Size of the full journal */
+  i64 hdrOff;
+  int nRec;                /* Number of Records */
+  int i;                   /* Loop counter */
+  int rc;
+
+  szJ = pPager->journalOff;
+#ifndef NDEBUG 
+  {
+    i64 os_szJ;
+    rc = sqlite3OsFileSize(pPager->jfd, &os_szJ);
+    if( rc!=SQLITE_OK ) return rc;
+    assert( szJ==os_szJ );
+  }
+#endif
+
+  /* Set hdrOff to be the offset just after the end of the last journal
+  ** page written before the first journal-header for this statement
+  ** transaction was written, or the end of the file if no journal
+  ** header was written.
+  */
+  hdrOff = pPager->stmtHdrOff;
+  assert( pPager->fullSync || !hdrOff );
+  if( !hdrOff ){
+    hdrOff = szJ;
+  }
+  
+  /* Truncate the database back to its original size.
+  */
+  rc = pager_truncate(pPager, pPager->stmtSize);
+  assert( pPager->state>=PAGER_SHARED );
+
+  /* Figure out how many records are in the statement journal.
+  */
+  assert( pPager->stmtInUse && pPager->journalOpen );
+  nRec = pPager->stmtNRec;
+  
+  /* Copy original pages out of the statement journal and back into the
+  ** database file.  Note that the statement journal omits checksums from
+  ** each record since power-failure recovery is not important to statement
+  ** journals.
+  */
+  for(i=0; i<nRec; i++){
+    i64 offset = i*(4+pPager->pageSize);
+    rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0);
+    assert( rc!=SQLITE_DONE );
+    if( rc!=SQLITE_OK ) goto end_stmt_playback;
+  }
+
+  /* Now roll some pages back from the transaction journal. Pager.stmtJSize
+  ** was the size of the journal file when this statement was started, so
+  ** everything after that needs to be rolled back, either into the
+  ** database, the memory cache, or both.
+  **
+  ** If it is not zero, then Pager.stmtHdrOff is the offset to the start
+  ** of the first journal header written during this statement transaction.
+  */
+  pPager->journalOff = pPager->stmtJSize;
+  pPager->cksumInit = pPager->stmtCksum;
+  while( pPager->journalOff < hdrOff ){
+    rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
+    assert( rc!=SQLITE_DONE );
+    if( rc!=SQLITE_OK ) goto end_stmt_playback;
+  }
+
+  while( pPager->journalOff < szJ ){
+    u32 nJRec;         /* Number of Journal Records */
+    u32 dummy;
+    rc = readJournalHdr(pPager, szJ, &nJRec, &dummy);
+    if( rc!=SQLITE_OK ){
+      assert( rc!=SQLITE_DONE );
+      goto end_stmt_playback;
+    }
+    if( nJRec==0 ){
+      nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8);
+    }
+    for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){
+      rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1);
+      assert( rc!=SQLITE_DONE );
+      if( rc!=SQLITE_OK ) goto end_stmt_playback;
+    }
+  }
+
+  pPager->journalOff = szJ;
+  
+end_stmt_playback:
+  if( rc==SQLITE_OK) {
+    pPager->journalOff = szJ;
+    /* pager_reload_cache(pPager); */
+  }
+  return rc;
+}
+
+/*
+** Change the maximum number of in-memory pages that are allowed.
+*/
+void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
+  if( mxPage>10 ){
+    pPager->mxPage = mxPage;
+  }else{
+    pPager->mxPage = 10;
+  }
+}
+
+/*
+** Adjust the robustness of the database to damage due to OS crashes
+** or power failures by changing the number of syncs()s when writing
+** the rollback journal.  There are three levels:
+**
+**    OFF       sqlite3OsSync() is never called.  This is the default
+**              for temporary and transient files.
+**
+**    NORMAL    The journal is synced once before writes begin on the
+**              database.  This is normally adequate protection, but
+**              it is theoretically possible, though very unlikely,
+**              that an inopertune power failure could leave the journal
+**              in a state which would cause damage to the database
+**              when it is rolled back.
+**
+**    FULL      The journal is synced twice before writes begin on the
+**              database (with some additional information - the nRec field
+**              of the journal header - being written in between the two
+**              syncs).  If we assume that writing a
+**              single disk sector is atomic, then this mode provides
+**              assurance that the journal will not be corrupted to the
+**              point of causing damage to the database during rollback.
+**
+** Numeric values associated with these states are OFF==1, NORMAL=2,
+** and FULL=3.
+*/
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){
+  pPager->noSync =  level==1 || pPager->tempFile;
+  pPager->fullSync = level==3 && !pPager->tempFile;
+  pPager->sync_flags = (full_fsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
+  if( pPager->noSync ) pPager->needSync = 0;
+}
+#endif
+
+/*
+** The following global variable is incremented whenever the library
+** attempts to open a temporary file.  This information is used for
+** testing and analysis only.  
+*/
+#ifdef SQLITE_TEST
+int sqlite3_opentemp_count = 0;
+#endif
+
+/*
+** Open a temporary file. 
+**
+** Write the file descriptor into *fd.  Return SQLITE_OK on success or some
+** other error code if we fail. The OS will automatically delete the temporary
+** file when it is closed.
+*/
+static int sqlite3PagerOpentemp(
+  sqlite3_vfs *pVfs,    /* The virtual file system layer */
+  sqlite3_file *pFile,  /* Write the file descriptor here */
+  char *zFilename,      /* Name of the file.  Might be NULL */
+  int vfsFlags          /* Flags passed through to the VFS */
+){
+  int rc;
+  assert( zFilename!=0 );
+
+#ifdef SQLITE_TEST
+  sqlite3_opentemp_count++;  /* Used for testing and analysis only */
+#endif
+
+  vfsFlags |=  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
+            SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
+  rc = sqlite3OsOpen(pVfs, zFilename, pFile, vfsFlags, 0);
+  assert( rc!=SQLITE_OK || pFile->pMethods );
+  return rc;
+}
+
+/*
+** Create a new page cache and put a pointer to the page cache in *ppPager.
+** The file to be cached need not exist.  The file is not locked until
+** the first call to sqlite3PagerGet() and is only held open until the
+** last page is released using sqlite3PagerUnref().
+**
+** If zFilename is NULL then a randomly-named temporary file is created
+** and used as the file to be cached.  The file will be deleted
+** automatically when it is closed.
+**
+** If zFilename is ":memory:" then all information is held in cache.
+** It is never written to disk.  This can be used to implement an
+** in-memory database.
+*/
+int sqlite3PagerOpen(
+  sqlite3_vfs *pVfs,       /* The virtual file system to use */
+  Pager **ppPager,         /* Return the Pager structure here */
+  const char *zFilename,   /* Name of the database file to open */
+  int nExtra,              /* Extra bytes append to each in-memory page */
+  int flags,               /* flags controlling this file */
+  int vfsFlags             /* flags passed through to sqlite3_vfs.xOpen() */
+){
+  u8 *pPtr;
+  Pager *pPager = 0;
+  int rc = SQLITE_OK;
+  int i;
+  int tempFile = 0;
+  int memDb = 0;
+  int readOnly = 0;
+  int useJournal = (flags & PAGER_OMIT_JOURNAL)==0;
+  int noReadlock = (flags & PAGER_NO_READLOCK)!=0;
+  int journalFileSize = sqlite3JournalSize(pVfs);
+  int nDefaultPage = SQLITE_DEFAULT_PAGE_SIZE;
+  char *zPathname;
+  int nPathname;
+
+  /* The default return is a NULL pointer */
+  *ppPager = 0;
+
+  /* Compute the full pathname */
+  nPathname = pVfs->mxPathname+1;
+  zPathname = sqlite3_malloc(nPathname);
+  if( zPathname==0 ){
+    return SQLITE_NOMEM;
+  }
+  if( zFilename && zFilename[0] ){
+#ifndef SQLITE_OMIT_MEMORYDB
+    if( strcmp(zFilename,":memory:")==0 ){
+      memDb = 1;
+      zPathname[0] = 0;
+    }else
+#endif
+    {
+      rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
+    }
+  }else{
+    rc = sqlite3OsGetTempname(pVfs, nPathname, zPathname);
+  }
+  if( rc!=SQLITE_OK ){
+    sqlite3_free(zPathname);
+    return rc;
+  }
+  nPathname = strlen(zPathname);
+
+  /* Allocate memory for the pager structure */
+  pPager = sqlite3MallocZero(
+    sizeof(*pPager) +           /* Pager structure */
+    journalFileSize +           /* The journal file structure */ 
+    pVfs->szOsFile * 2 +        /* The db and stmt journal files */ 
+    4*nPathname + 40            /* zFilename, zDirectory, zJournal, zStmtJrnl */
+  );
+  if( !pPager ){
+    sqlite3_free(zPathname);
+    return SQLITE_NOMEM;
+  }
+  pPtr = (u8 *)&pPager[1];
+  pPager->vfsFlags = vfsFlags;
+  pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0];
+  pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1];
+  pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2];
+  pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize];
+  pPager->zDirectory = &pPager->zFilename[nPathname+1];
+  pPager->zJournal = &pPager->zDirectory[nPathname+1];
+  pPager->zStmtJrnl = &pPager->zJournal[nPathname+10];
+  pPager->pVfs = pVfs;
+  memcpy(pPager->zFilename, zPathname, nPathname+1);
+  sqlite3_free(zPathname);
+
+  /* Open the pager file.
+  */
+  if( zFilename && zFilename[0] && !memDb ){
+    if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){
+      rc = SQLITE_CANTOPEN;
+    }else{
+      int fout = 0;
+      rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd,
+                         pPager->vfsFlags, &fout);
+      readOnly = (fout&SQLITE_OPEN_READONLY);
+
+      /* If the file was successfully opened for read/write access,
+      ** choose a default page size in case we have to create the
+      ** database file. The default page size is the maximum of:
+      **
+      **    + SQLITE_DEFAULT_PAGE_SIZE,
+      **    + The value returned by sqlite3OsSectorSize()
+      **    + The largest page size that can be written atomically.
+      */
+      if( rc==SQLITE_OK && !readOnly ){
+        int iSectorSize = sqlite3OsSectorSize(pPager->fd);
+        if( nDefaultPage<iSectorSize ){
+          nDefaultPage = iSectorSize;
+        }
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+        {
+          int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
+          int ii;
+          assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
+          assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
+          assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
+          for(ii=nDefaultPage; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
+            if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) nDefaultPage = ii;
+          }
+        }
+#endif
+        if( nDefaultPage>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
+          nDefaultPage = SQLITE_MAX_DEFAULT_PAGE_SIZE;
+        }
+      }
+    }
+  }else if( !memDb ){
+    /* If a temporary file is requested, it is not opened immediately.
+    ** In this case we accept the default page size and delay actually
+    ** opening the file until the first call to OsWrite().
+    */ 
+    tempFile = 1;
+    pPager->state = PAGER_EXCLUSIVE;
+  }
+
+  if( pPager && rc==SQLITE_OK ){
+    pPager->pTmpSpace = (char *)sqlite3_malloc(nDefaultPage);
+  }
+
+  /* If an error occured in either of the blocks above.
+  ** Free the Pager structure and close the file.
+  ** Since the pager is not allocated there is no need to set 
+  ** any Pager.errMask variables.
+  */
+  if( !pPager || !pPager->pTmpSpace ){
+    sqlite3OsClose(pPager->fd);
+    sqlite3_free(pPager);
+    return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc);
+  }
+
+  PAGERTRACE3("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename);
+  IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
+
+  /* Fill in Pager.zDirectory[] */
+  memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1);
+  for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){}
+  if( i>0 ) pPager->zDirectory[i-1] = 0;
+
+  /* Fill in Pager.zJournal[] and Pager.zStmtJrnl[] */
+  memcpy(pPager->zJournal, pPager->zFilename, nPathname);
+  memcpy(&pPager->zJournal[nPathname], "-journal", 9);
+  memcpy(pPager->zStmtJrnl, pPager->zFilename, nPathname);
+  memcpy(&pPager->zStmtJrnl[nPathname], "-stmtjrnl", 10);
+
+  /* pPager->journalOpen = 0; */
+  pPager->useJournal = useJournal && !memDb;
+  pPager->noReadlock = noReadlock && readOnly;
+  /* pPager->stmtOpen = 0; */
+  /* pPager->stmtInUse = 0; */
+  /* pPager->nRef = 0; */
+  pPager->dbSize = memDb-1;
+  pPager->pageSize = nDefaultPage;
+  /* pPager->stmtSize = 0; */
+  /* pPager->stmtJSize = 0; */
+  /* pPager->nPage = 0; */
+  pPager->mxPage = 100;
+  pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
+  /* pPager->state = PAGER_UNLOCK; */
+  assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
+  /* pPager->errMask = 0; */
+  pPager->tempFile = tempFile;
+  assert( tempFile==PAGER_LOCKINGMODE_NORMAL 
+          || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
+  assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
+  pPager->exclusiveMode = tempFile; 
+  pPager->memDb = memDb;
+  pPager->readOnly = readOnly;
+  /* pPager->needSync = 0; */
+  pPager->noSync = pPager->tempFile || !useJournal;
+  pPager->fullSync = (pPager->noSync?0:1);
+  pPager->sync_flags = SQLITE_SYNC_NORMAL;
+  /* pPager->pFirst = 0; */
+  /* pPager->pFirstSynced = 0; */
+  /* pPager->pLast = 0; */
+  pPager->nExtra = FORCE_ALIGNMENT(nExtra);
+  assert(pPager->fd->pMethods||memDb||tempFile);
+  if( !memDb ){
+    setSectorSize(pPager);
+  }
+  /* pPager->pBusyHandler = 0; */
+  /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
+  *ppPager = pPager;
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  pPager->iInUseMM = 0;
+  pPager->iInUseDB = 0;
+  if( !memDb ){
+    sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
+    sqlite3_mutex_enter(mutex);
+    pPager->pNext = sqlite3PagerList;
+    if( sqlite3PagerList ){
+      assert( sqlite3PagerList->pPrev==0 );
+      sqlite3PagerList->pPrev = pPager;
+    }
+    pPager->pPrev = 0;
+    sqlite3PagerList = pPager;
+    sqlite3_mutex_leave(mutex);
+  }
+#endif
+  return SQLITE_OK;
+}
+
+/*
+** Set the busy handler function.
+*/
+void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){
+  pPager->pBusyHandler = pBusyHandler;
+}
+
+/*
+** Set the destructor for this pager.  If not NULL, the destructor is called
+** when the reference count on each page reaches zero.  The destructor can
+** be used to clean up information in the extra segment appended to each page.
+**
+** The destructor is not called as a result sqlite3PagerClose().  
+** Destructors are only called by sqlite3PagerUnref().
+*/
+void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){
+  pPager->xDestructor = xDesc;
+}
+
+/*
+** Set the reinitializer for this pager.  If not NULL, the reinitializer
+** is called when the content of a page in cache is restored to its original
+** value as a result of a rollback.  The callback gives higher-level code
+** an opportunity to restore the EXTRA section to agree with the restored
+** page data.
+*/
+void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){
+  pPager->xReiniter = xReinit;
+}
+
+/*
+** Set the page size to *pPageSize. If the suggest new page size is
+** inappropriate, then an alternative page size is set to that
+** value before returning.
+*/
+int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){
+  int rc = SQLITE_OK;
+  u16 pageSize = *pPageSize;
+  assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
+  if( pageSize && pageSize!=pPager->pageSize 
+   && !pPager->memDb && pPager->nRef==0 
+  ){
+    char *pNew = (char *)sqlite3_malloc(pageSize);
+    if( !pNew ){
+      rc = SQLITE_NOMEM;
+    }else{
+      pagerEnter(pPager);
+      pager_reset(pPager);
+      pPager->pageSize = pageSize;
+      setSectorSize(pPager);
+      sqlite3_free(pPager->pTmpSpace);
+      pPager->pTmpSpace = pNew;
+      pagerLeave(pPager);
+    }
+  }
+  *pPageSize = pPager->pageSize;
+  return rc;
+}
+
+/*
+** Return a pointer to the "temporary page" buffer held internally
+** by the pager.  This is a buffer that is big enough to hold the
+** entire content of a database page.  This buffer is used internally
+** during rollback and will be overwritten whenever a rollback
+** occurs.  But other modules are free to use it too, as long as
+** no rollbacks are happening.
+*/
+void *sqlite3PagerTempSpace(Pager *pPager){
+  return pPager->pTmpSpace;
+}
+
+/*
+** Attempt to set the maximum database page count if mxPage is positive. 
+** Make no changes if mxPage is zero or negative.  And never reduce the
+** maximum page count below the current size of the database.
+**
+** Regardless of mxPage, return the current maximum page count.
+*/
+int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
+  if( mxPage>0 ){
+    pPager->mxPgno = mxPage;
+  }
+  sqlite3PagerPagecount(pPager);
+  return pPager->mxPgno;
+}
+
+/*
+** The following set of routines are used to disable the simulated
+** I/O error mechanism.  These routines are used to avoid simulated
+** errors in places where we do not care about errors.
+**
+** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
+** and generate no code.
+*/
+#ifdef SQLITE_TEST
+extern int sqlite3_io_error_pending;
+extern int sqlite3_io_error_hit;
+static int saved_cnt;
+void disable_simulated_io_errors(void){
+  saved_cnt = sqlite3_io_error_pending;
+  sqlite3_io_error_pending = -1;
+}
+void enable_simulated_io_errors(void){
+  sqlite3_io_error_pending = saved_cnt;
+}
+#else
+# define disable_simulated_io_errors()
+# define enable_simulated_io_errors()
+#endif
+
+/*
+** Read the first N bytes from the beginning of the file into memory
+** that pDest points to. 
+**
+** No error checking is done. The rational for this is that this function 
+** may be called even if the file does not exist or contain a header. In 
+** these cases sqlite3OsRead() will return an error, to which the correct 
+** response is to zero the memory at pDest and continue.  A real IO error 
+** will presumably recur and be picked up later (Todo: Think about this).
+*/
+int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
+  int rc = SQLITE_OK;
+  memset(pDest, 0, N);
+  assert(MEMDB||pPager->fd->pMethods||pPager->tempFile);
+  if( pPager->fd->pMethods ){
+    IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
+    rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
+    if( rc==SQLITE_IOERR_SHORT_READ ){
+      rc = SQLITE_OK;
+    }
+  }
+  return rc;
+}
+
+/*
+** Return the total number of pages in the disk file associated with
+** pPager. 
+**
+** If the PENDING_BYTE lies on the page directly after the end of the
+** file, then consider this page part of the file too. For example, if
+** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the
+** file is 4096 bytes, 5 is returned instead of 4.
+*/
+int sqlite3PagerPagecount(Pager *pPager){
+  i64 n = 0;
+  int rc;
+  assert( pPager!=0 );
+  if( pPager->errCode ){
+    return 0;
+  }
+  if( pPager->dbSize>=0 ){
+    n = pPager->dbSize;
+  } else {
+    assert(pPager->fd->pMethods||pPager->tempFile);
+    if( (pPager->fd->pMethods)
+     && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){
+      pPager->nRef++;
+      pager_error(pPager, rc);
+      pPager->nRef--;
+      return 0;
+    }
+    if( n>0 && n<pPager->pageSize ){
+      n = 1;
+    }else{
+      n /= pPager->pageSize;
+    }
+    if( pPager->state!=PAGER_UNLOCK ){
+      pPager->dbSize = n;
+    }
+  }
+  if( n==(PENDING_BYTE/pPager->pageSize) ){
+    n++;
+  }
+  if( n>pPager->mxPgno ){
+    pPager->mxPgno = n;
+  }
+  return n;
+}
+
+
+#ifndef SQLITE_OMIT_MEMORYDB
+/*
+** Clear a PgHistory block
+*/
+static void clearHistory(PgHistory *pHist){
+  sqlite3_free(pHist->pOrig);
+  sqlite3_free(pHist->pStmt);
+  pHist->pOrig = 0;
+  pHist->pStmt = 0;
+}
+#else
+#define clearHistory(x)
+#endif
+
+/*
+** Forward declaration
+*/
+static int syncJournal(Pager*);
+
+/*
+** Unlink pPg from its hash chain. Also set the page number to 0 to indicate
+** that the page is not part of any hash chain. This is required because the
+** sqlite3PagerMovepage() routine can leave a page in the 
+** pNextFree/pPrevFree list that is not a part of any hash-chain.
+*/
+static void unlinkHashChain(Pager *pPager, PgHdr *pPg){
+  if( pPg->pgno==0 ){
+    assert( pPg->pNextHash==0 && pPg->pPrevHash==0 );
+    return;
+  }
+  if( pPg->pNextHash ){
+    pPg->pNextHash->pPrevHash = pPg->pPrevHash;
+  }
+  if( pPg->pPrevHash ){
+    assert( pPager->aHash[pPg->pgno & (pPager->nHash-1)]!=pPg );
+    pPg->pPrevHash->pNextHash = pPg->pNextHash;
+  }else{
+    int h = pPg->pgno & (pPager->nHash-1);
+    pPager->aHash[h] = pPg->pNextHash;
+  }
+  if( MEMDB ){
+    clearHistory(PGHDR_TO_HIST(pPg, pPager));
+  }
+  pPg->pgno = 0;
+  pPg->pNextHash = pPg->pPrevHash = 0;
+}
+
+/*
+** Unlink a page from the free list (the list of all pages where nRef==0)
+** and from its hash collision chain.
+*/
+static void unlinkPage(PgHdr *pPg){
+  Pager *pPager = pPg->pPager;
+
+  /* Unlink from free page list */
+  lruListRemove(pPg);
+
+  /* Unlink from the pgno hash table */
+  unlinkHashChain(pPager, pPg);
+}
+
+/*
+** This routine is used to truncate the cache when a database
+** is truncated.  Drop from the cache all pages whose pgno is
+** larger than pPager->dbSize and is unreferenced.
+**
+** Referenced pages larger than pPager->dbSize are zeroed.
+**
+** Actually, at the point this routine is called, it would be
+** an error to have a referenced page.  But rather than delete
+** that page and guarantee a subsequent segfault, it seems better
+** to zero it and hope that we error out sanely.
+*/
+static void pager_truncate_cache(Pager *pPager){
+  PgHdr *pPg;
+  PgHdr **ppPg;
+  int dbSize = pPager->dbSize;
+
+  ppPg = &pPager->pAll;
+  while( (pPg = *ppPg)!=0 ){
+    if( pPg->pgno<=dbSize ){
+      ppPg = &pPg->pNextAll;
+    }else if( pPg->nRef>0 ){
+      memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
+      ppPg = &pPg->pNextAll;
+    }else{
+      *ppPg = pPg->pNextAll;
+      IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno));
+      PAGER_INCR(sqlite3_pager_pgfree_count);
+      unlinkPage(pPg);
+      makeClean(pPg);
+      sqlite3_free(pPg);
+      pPager->nPage--;
+    }
+  }
+}
+
+/*
+** Try to obtain a lock on a file.  Invoke the busy callback if the lock
+** is currently not available.  Repeat until the busy callback returns
+** false or until the lock succeeds.
+**
+** Return SQLITE_OK on success and an error code if we cannot obtain
+** the lock.
+*/
+static int pager_wait_on_lock(Pager *pPager, int locktype){
+  int rc;
+
+  /* The OS lock values must be the same as the Pager lock values */
+  assert( PAGER_SHARED==SHARED_LOCK );
+  assert( PAGER_RESERVED==RESERVED_LOCK );
+  assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
+
+  /* If the file is currently unlocked then the size must be unknown */
+  assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB );
+
+  if( pPager->state>=locktype ){
+    rc = SQLITE_OK;
+  }else{
+    do {
+      rc = sqlite3OsLock(pPager->fd, locktype);
+    }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) );
+    if( rc==SQLITE_OK ){
+      pPager->state = locktype;
+      IOTRACE(("LOCK %p %d\n", pPager, locktype))
+    }
+  }
+  return rc;
+}
+
+/*
+** Truncate the file to the number of pages specified.
+*/
+int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){
+  int rc;
+  assert( pPager->state>=PAGER_SHARED || MEMDB );
+  sqlite3PagerPagecount(pPager);
+  if( pPager->errCode ){
+    rc = pPager->errCode;
+    return rc;
+  }
+  if( nPage>=(unsigned)pPager->dbSize ){
+    return SQLITE_OK;
+  }
+  if( MEMDB ){
+    pPager->dbSize = nPage;
+    pager_truncate_cache(pPager);
+    return SQLITE_OK;
+  }
+  pagerEnter(pPager);
+  rc = syncJournal(pPager);
+  pagerLeave(pPager);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  /* Get an exclusive lock on the database before truncating. */
+  pagerEnter(pPager);
+  rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
+  pagerLeave(pPager);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  rc = pager_truncate(pPager, nPage);
+  return rc;
+}
+
+/*
+** Shutdown the page cache.  Free all memory and close all files.
+**
+** If a transaction was in progress when this routine is called, that
+** transaction is rolled back.  All outstanding pages are invalidated
+** and their memory is freed.  Any attempt to use a page associated
+** with this page cache after this function returns will likely
+** result in a coredump.
+**
+** This function always succeeds. If a transaction is active an attempt
+** is made to roll it back. If an error occurs during the rollback 
+** a hot journal may be left in the filesystem but no error is returned
+** to the caller.
+*/
+int sqlite3PagerClose(Pager *pPager){
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  if( !MEMDB ){
+    sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
+    sqlite3_mutex_enter(mutex);
+    if( pPager->pPrev ){
+      pPager->pPrev->pNext = pPager->pNext;
+    }else{
+      sqlite3PagerList = pPager->pNext;
+    }
+    if( pPager->pNext ){
+      pPager->pNext->pPrev = pPager->pPrev;
+    }
+    sqlite3_mutex_leave(mutex);
+  }
+#endif
+
+  disable_simulated_io_errors();
+  pPager->errCode = 0;
+  pPager->exclusiveMode = 0;
+  pager_reset(pPager);
+  pagerUnlockAndRollback(pPager);
+  enable_simulated_io_errors();
+  PAGERTRACE2("CLOSE %d\n", PAGERID(pPager));
+  IOTRACE(("CLOSE %p\n", pPager))
+  assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
+  if( pPager->journalOpen ){
+    sqlite3OsClose(pPager->jfd);
+  }
+  sqlite3_free(pPager->aInJournal);
+  if( pPager->stmtOpen ){
+    sqlite3OsClose(pPager->stfd);
+  }
+  sqlite3OsClose(pPager->fd);
+  /* Temp files are automatically deleted by the OS
+  ** if( pPager->tempFile ){
+  **   sqlite3OsDelete(pPager->zFilename);
+  ** }
+  */
+
+  sqlite3_free(pPager->aHash);
+  sqlite3_free(pPager->pTmpSpace);
+  sqlite3_free(pPager);
+  return SQLITE_OK;
+}
+
+#if !defined(NDEBUG) || defined(SQLITE_TEST)
+/*
+** Return the page number for the given page data.
+*/
+Pgno sqlite3PagerPagenumber(DbPage *p){
+  return p->pgno;
+}
+#endif
+
+/*
+** The page_ref() function increments the reference count for a page.
+** If the page is currently on the freelist (the reference count is zero) then
+** remove it from the freelist.
+**
+** For non-test systems, page_ref() is a macro that calls _page_ref()
+** online of the reference count is zero.  For test systems, page_ref()
+** is a real function so that we can set breakpoints and trace it.
+*/
+static void _page_ref(PgHdr *pPg){
+  if( pPg->nRef==0 ){
+    /* The page is currently on the freelist.  Remove it. */
+    lruListRemove(pPg);
+    pPg->pPager->nRef++;
+  }
+  pPg->nRef++;
+}
+#ifdef SQLITE_DEBUG
+  static void page_ref(PgHdr *pPg){
+    if( pPg->nRef==0 ){
+      _page_ref(pPg);
+    }else{
+      pPg->nRef++;
+    }
+  }
+#else
+# define page_ref(P)   ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++)
+#endif
+
+/*
+** Increment the reference count for a page.  The input pointer is
+** a reference to the page data.
+*/
+int sqlite3PagerRef(DbPage *pPg){
+  pagerEnter(pPg->pPager);
+  page_ref(pPg);
+  pagerLeave(pPg->pPager);
+  return SQLITE_OK;
+}
+
+/*
+** Sync the journal.  In other words, make sure all the pages that have
+** been written to the journal have actually reached the surface of the
+** disk.  It is not safe to modify the original database file until after
+** the journal has been synced.  If the original database is modified before
+** the journal is synced and a power failure occurs, the unsynced journal
+** data would be lost and we would be unable to completely rollback the
+** database changes.  Database corruption would occur.
+** 
+** This routine also updates the nRec field in the header of the journal.
+** (See comments on the pager_playback() routine for additional information.)
+** If the sync mode is FULL, two syncs will occur.  First the whole journal
+** is synced, then the nRec field is updated, then a second sync occurs.
+**
+** For temporary databases, we do not care if we are able to rollback
+** after a power failure, so no sync occurs.
+**
+** If the IOCAP_SEQUENTIAL flag is set for the persistent media on which
+** the database is stored, then OsSync() is never called on the journal
+** file. In this case all that is required is to update the nRec field in
+** the journal header.
+**
+** This routine clears the needSync field of every page current held in
+** memory.
+*/
+static int syncJournal(Pager *pPager){
+  PgHdr *pPg;
+  int rc = SQLITE_OK;
+
+
+  /* Sync the journal before modifying the main database
+  ** (assuming there is a journal and it needs to be synced.)
+  */
+  if( pPager->needSync ){
+    if( !pPager->tempFile ){
+      int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
+      assert( pPager->journalOpen );
+
+      /* assert( !pPager->noSync ); // noSync might be set if synchronous
+      ** was turned off after the transaction was started.  Ticket #615 */
+#ifndef NDEBUG
+      {
+        /* Make sure the pPager->nRec counter we are keeping agrees
+        ** with the nRec computed from the size of the journal file.
+        */
+        i64 jSz;
+        rc = sqlite3OsFileSize(pPager->jfd, &jSz);
+        if( rc!=0 ) return rc;
+        assert( pPager->journalOff==jSz );
+      }
+#endif
+      if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
+        /* 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.
+        **
+        ** This is not required if the persistent media supports the
+        ** SAFE_APPEND property. Because in this case it is not possible 
+        ** for garbage data to be appended to the file, the nRec field
+        ** is populated with 0xFFFFFFFF when the journal header is written
+        ** and never needs to be updated.
+        */
+        i64 jrnlOff;
+        if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
+          PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager));
+          IOTRACE(("JSYNC %p\n", pPager))
+          rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
+          if( rc!=0 ) return rc;
+        }
+
+        jrnlOff = pPager->journalHdr + sizeof(aJournalMagic);
+        IOTRACE(("JHDR %p %lld %d\n", pPager, jrnlOff, 4));
+        rc = write32bits(pPager->jfd, jrnlOff, pPager->nRec);
+        if( rc ) return rc;
+      }
+      if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
+        PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager));
+        IOTRACE(("JSYNC %p\n", pPager))
+        rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags| 
+          (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
+        );
+        if( rc!=0 ) return rc;
+      }
+      pPager->journalStarted = 1;
+    }
+    pPager->needSync = 0;
+
+    /* Erase the needSync flag from every page.
+    */
+    for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+      pPg->needSync = 0;
+    }
+    lruListSetFirstSynced(pPager);
+  }
+
+#ifndef NDEBUG
+  /* If the Pager.needSync flag is clear then the PgHdr.needSync
+  ** flag must also be clear for all pages.  Verify that this
+  ** invariant is true.
+  */
+  else{
+    for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+      assert( pPg->needSync==0 );
+    }
+    assert( pPager->lru.pFirstSynced==pPager->lru.pFirst );
+  }
+#endif
+
+  return rc;
+}
+
+/*
+** Merge two lists of pages connected by pDirty and in pgno order.
+** Do not both fixing the pPrevDirty pointers.
+*/
+static PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB){
+  PgHdr result, *pTail;
+  pTail = &result;
+  while( pA && pB ){
+    if( pA->pgno<pB->pgno ){
+      pTail->pDirty = pA;
+      pTail = pA;
+      pA = pA->pDirty;
+    }else{
+      pTail->pDirty = pB;
+      pTail = pB;
+      pB = pB->pDirty;
+    }
+  }
+  if( pA ){
+    pTail->pDirty = pA;
+  }else if( pB ){
+    pTail->pDirty = pB;
+  }else{
+    pTail->pDirty = 0;
+  }
+  return result.pDirty;
+}
+
+/*
+** Sort the list of pages in accending order by pgno.  Pages are
+** connected by pDirty pointers.  The pPrevDirty pointers are
+** corrupted by this sort.
+*/
+#define N_SORT_BUCKET_ALLOC 25
+#define N_SORT_BUCKET       25
+#ifdef SQLITE_TEST
+  int sqlite3_pager_n_sort_bucket = 0;
+  #undef N_SORT_BUCKET
+  #define N_SORT_BUCKET \
+   (sqlite3_pager_n_sort_bucket?sqlite3_pager_n_sort_bucket:N_SORT_BUCKET_ALLOC)
+#endif
+static PgHdr *sort_pagelist(PgHdr *pIn){
+  PgHdr *a[N_SORT_BUCKET_ALLOC], *p;
+  int i;
+  memset(a, 0, sizeof(a));
+  while( pIn ){
+    p = pIn;
+    pIn = p->pDirty;
+    p->pDirty = 0;
+    for(i=0; i<N_SORT_BUCKET-1; i++){
+      if( a[i]==0 ){
+        a[i] = p;
+        break;
+      }else{
+        p = merge_pagelist(a[i], p);
+        a[i] = 0;
+      }
+    }
+    if( i==N_SORT_BUCKET-1 ){
+      /* Coverage: To get here, there need to be 2^(N_SORT_BUCKET) 
+      ** elements in the input list. This is possible, but impractical.
+      ** Testing this line is the point of global variable
+      ** sqlite3_pager_n_sort_bucket.
+      */
+      a[i] = merge_pagelist(a[i], p);
+    }
+  }
+  p = a[0];
+  for(i=1; i<N_SORT_BUCKET; i++){
+    p = merge_pagelist(p, a[i]);
+  }
+  return p;
+}
+
+/*
+** Given a list of pages (connected by the PgHdr.pDirty pointer) write
+** every one of those pages out to the database file and mark them all
+** as clean.
+*/
+static int pager_write_pagelist(PgHdr *pList){
+  Pager *pPager;
+  PgHdr *p;
+  int rc;
+
+  if( pList==0 ) return SQLITE_OK;
+  pPager = pList->pPager;
+
+  /* At this point there may be either a RESERVED or EXCLUSIVE lock on the
+  ** database file. If there is already an EXCLUSIVE lock, the following
+  ** calls to sqlite3OsLock() are no-ops.
+  **
+  ** Moving the lock from RESERVED to EXCLUSIVE actually involves going
+  ** through an intermediate state PENDING.   A PENDING lock prevents new
+  ** readers from attaching to the database but is unsufficient for us to
+  ** write.  The idea of a PENDING lock is to prevent new readers from
+  ** coming in while we wait for existing readers to clear.
+  **
+  ** While the pager is in the RESERVED state, the original database file
+  ** is unchanged and we can rollback without having to playback the
+  ** journal into the original database file.  Once we transition to
+  ** EXCLUSIVE, it means the database file has been changed and any rollback
+  ** will require a journal playback.
+  */
+  rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  pList = sort_pagelist(pList);
+  for(p=pList; p; p=p->pDirty){
+    assert( p->dirty );
+    p->dirty = 0;
+  }
+  while( pList ){
+
+    /* If the file has not yet been opened, open it now. */
+    if( !pPager->fd->pMethods ){
+      assert(pPager->tempFile);
+      rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->fd, pPager->zFilename,
+                                pPager->vfsFlags);
+      if( rc ) return rc;
+    }
+
+    /* If there are dirty pages in the page cache with page numbers greater
+    ** than Pager.dbSize, this means sqlite3PagerTruncate() 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 ){
+      i64 offset = (pList->pgno-1)*(i64)pPager->pageSize;
+      char *pData = CODEC2(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
+      PAGERTRACE4("STORE %d page %d hash(%08x)\n",
+                   PAGERID(pPager), pList->pgno, pager_pagehash(pList));
+      IOTRACE(("PGOUT %p %d\n", pPager, pList->pgno));
+      rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
+      PAGER_INCR(sqlite3_pager_writedb_count);
+      PAGER_INCR(pPager->nWrite);
+      if( pList->pgno==1 ){
+        memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
+      }
+    }
+#ifndef NDEBUG
+    else{
+      PAGERTRACE3("NOSTORE %d page %d\n", PAGERID(pPager), pList->pgno);
+    }
+#endif
+    if( rc ) return rc;
+#ifdef SQLITE_CHECK_PAGES
+    pList->pageHash = pager_pagehash(pList);
+#endif
+    pList = pList->pDirty;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Collect every dirty page into a dirty list and
+** return a pointer to the head of that list.  All pages are
+** collected even if they are still in use.
+*/
+static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
+  return pPager->pDirty;
+}
+
+/*
+** Return TRUE if there is a hot journal on the given pager.
+** A hot journal is one that needs to be played back.
+**
+** If the current size of the database file is 0 but a journal file
+** exists, that is probably an old journal left over from a prior
+** database with the same name.  Just delete the journal.
+*/
+static int hasHotJournal(Pager *pPager){
+  sqlite3_vfs *pVfs = pPager->pVfs;
+  if( !pPager->useJournal ) return 0;
+  if( !pPager->fd->pMethods ) return 0;
+  if( !sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){
+    return 0;
+  }
+  if( sqlite3OsCheckReservedLock(pPager->fd) ){
+    return 0;
+  }
+  if( sqlite3PagerPagecount(pPager)==0 ){
+    sqlite3OsDelete(pVfs, pPager->zJournal, 0);
+    return 0;
+  }else{
+    return 1;
+  }
+}
+
+/*
+** Try to find a page in the cache that can be recycled. 
+**
+** This routine may return SQLITE_IOERR, SQLITE_FULL or SQLITE_OK. It 
+** does not set the pPager->errCode variable.
+*/
+static int pager_recycle(Pager *pPager, PgHdr **ppPg){
+  PgHdr *pPg;
+  *ppPg = 0;
+
+  /* It is illegal to call this function unless the pager object
+  ** pointed to by pPager has at least one free page (page with nRef==0).
+  */ 
+  assert(!MEMDB);
+  assert(pPager->lru.pFirst);
+
+  /* Find a page to recycle.  Try to locate a page that does not
+  ** require us to do an fsync() on the journal.
+  */
+  pPg = pPager->lru.pFirstSynced;
+
+  /* If we could not find a page that does not require an fsync()
+  ** on the journal file then fsync the journal file.  This is a
+  ** very slow operation, so we work hard to avoid it.  But sometimes
+  ** it can't be helped.
+  */
+  if( pPg==0 && pPager->lru.pFirst){
+    int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
+    int rc = syncJournal(pPager);
+    if( rc!=0 ){
+      return rc;
+    }
+    if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
+      /* If in full-sync mode, write a new journal header into the
+      ** journal file. This is done to avoid ever modifying a journal
+      ** header that is involved in the rollback of pages that have
+      ** already been written to the database (in case the header is
+      ** trashed when the nRec field is updated).
+      */
+      pPager->nRec = 0;
+      assert( pPager->journalOff > 0 );
+      assert( pPager->doNotSync==0 );
+      rc = writeJournalHdr(pPager);
+      if( rc!=0 ){
+        return rc;
+      }
+    }
+    pPg = pPager->lru.pFirst;
+  }
+
+  assert( pPg->nRef==0 );
+
+  /* Write the page to the database file if it is dirty.
+  */
+  if( pPg->dirty ){
+    int rc;
+    assert( pPg->needSync==0 );
+    makeClean(pPg);
+    pPg->dirty = 1;
+    pPg->pDirty = 0;
+    rc = pager_write_pagelist( pPg );
+    pPg->dirty = 0;
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+  }
+  assert( pPg->dirty==0 );
+
+  /* If the page we are recycling is marked as alwaysRollback, then
+  ** set the global alwaysRollback flag, thus disabling the
+  ** sqlite3PagerDontRollback() optimization for the rest of this transaction.
+  ** It is necessary to do this because the page marked alwaysRollback
+  ** might be reloaded at a later time but at that point we won't remember
+  ** that is was marked alwaysRollback.  This means that all pages must
+  ** be marked as alwaysRollback from here on out.
+  */
+  if( pPg->alwaysRollback ){
+    IOTRACE(("ALWAYS_ROLLBACK %p\n", pPager))
+    pPager->alwaysRollback = 1;
+  }
+
+  /* Unlink the old page from the free list and the hash table
+  */
+  unlinkPage(pPg);
+  assert( pPg->pgno==0 );
+
+  *ppPg = pPg;
+  return SQLITE_OK;
+}
+
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+/*
+** This function is called to free superfluous dynamically allocated memory
+** held by the pager system. Memory in use by any SQLite pager allocated
+** by the current thread may be sqlite3_free()ed.
+**
+** nReq is the number of bytes of memory required. Once this much has
+** been released, the function returns. The return value is the total number 
+** of bytes of memory released.
+*/
+int sqlite3PagerReleaseMemory(int nReq){
+  int nReleased = 0;          /* Bytes of memory released so far */
+  sqlite3_mutex *mutex;       /* The MEM2 mutex */
+  Pager *pPager;              /* For looping over pagers */
+  BusyHandler *savedBusy;     /* Saved copy of the busy handler */
+  int rc = SQLITE_OK;
+
+  /* Acquire the memory-management mutex
+  */
+  mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2);
+  sqlite3_mutex_enter(mutex);
+
+  /* Signal all database connections that memory management wants
+  ** to have access to the pagers.
+  */
+  for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
+     pPager->iInUseMM = 1;
+  }
+
+  while( rc==SQLITE_OK && (nReq<0 || nReleased<nReq) ){
+    PgHdr *pPg;
+    PgHdr *pRecycled;
+ 
+    /* Try to find a page to recycle that does not require a sync(). If
+    ** this is not possible, find one that does require a sync().
+    */
+    sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+    pPg = sqlite3LruPageList.pFirstSynced;
+    while( pPg && (pPg->needSync || pPg->pPager->iInUseDB) ){
+      pPg = pPg->gfree.pNext;
+    }
+    if( !pPg ){
+      pPg = sqlite3LruPageList.pFirst;
+      while( pPg && pPg->pPager->iInUseDB ){
+        pPg = pPg->gfree.pNext;
+      }
+    }
+    sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU));
+
+    /* If pPg==0, then the block above has failed to find a page to
+    ** recycle. In this case return early - no further memory will
+    ** be released.
+    */
+    if( !pPg ) break;
+
+    pPager = pPg->pPager;
+    assert(!pPg->needSync || pPg==pPager->lru.pFirst);
+    assert(pPg->needSync || pPg==pPager->lru.pFirstSynced);
+  
+    savedBusy = pPager->pBusyHandler;
+    pPager->pBusyHandler = 0;
+    rc = pager_recycle(pPager, &pRecycled);
+    pPager->pBusyHandler = savedBusy;
+    assert(pRecycled==pPg || rc!=SQLITE_OK);
+    if( rc==SQLITE_OK ){
+      /* We've found a page to free. At this point the page has been 
+      ** removed from the page hash-table, free-list and synced-list 
+      ** (pFirstSynced). It is still in the all pages (pAll) list. 
+      ** Remove it from this list before freeing.
+      **
+      ** Todo: Check the Pager.pStmt list to make sure this is Ok. It 
+      ** probably is though.
+      */
+      PgHdr *pTmp;
+      assert( pPg );
+      if( pPg==pPager->pAll ){
+         pPager->pAll = pPg->pNextAll;
+      }else{
+        for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){}
+        pTmp->pNextAll = pPg->pNextAll;
+      }
+      nReleased += (
+          sizeof(*pPg) + pPager->pageSize
+          + sizeof(u32) + pPager->nExtra
+          + MEMDB*sizeof(PgHistory) 
+      );
+      IOTRACE(("PGFREE %p %d *\n", pPager, pPg->pgno));
+      PAGER_INCR(sqlite3_pager_pgfree_count);
+      sqlite3_free(pPg);
+      pPager->nPage--;
+    }else{
+      /* An error occured whilst writing to the database file or 
+      ** journal in pager_recycle(). The error is not returned to the 
+      ** caller of this function. Instead, set the Pager.errCode variable.
+      ** The error will be returned to the user (or users, in the case 
+      ** of a shared pager cache) of the pager for which the error occured.
+      */
+      assert(
+          (rc&0xff)==SQLITE_IOERR ||
+          rc==SQLITE_FULL ||
+          rc==SQLITE_BUSY
+      );
+      assert( pPager->state>=PAGER_RESERVED );
+      pager_error(pPager, rc);
+    }
+  }
+
+  /* Clear the memory management flags and release the mutex
+  */
+  for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){
+     pPager->iInUseMM = 0;
+  }
+  sqlite3_mutex_leave(mutex);
+
+  /* Return the number of bytes released
+  */
+  return nReleased;
+}
+#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
+
+/*
+** Read the content of page pPg out of the database file.
+*/
+static int readDbPage(Pager *pPager, PgHdr *pPg, Pgno pgno){
+  int rc;
+  i64 offset;
+  assert( MEMDB==0 );
+  assert(pPager->fd->pMethods||pPager->tempFile);
+  if( !pPager->fd->pMethods ){
+    return SQLITE_IOERR_SHORT_READ;
+  }
+  offset = (pgno-1)*(i64)pPager->pageSize;
+  rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize, offset);
+  PAGER_INCR(sqlite3_pager_readdb_count);
+  PAGER_INCR(pPager->nRead);
+  IOTRACE(("PGIN %p %d\n", pPager, pgno));
+  if( pgno==1 ){
+    memcpy(&pPager->dbFileVers, &((u8*)PGHDR_TO_DATA(pPg))[24],
+                                              sizeof(pPager->dbFileVers));
+  }
+  CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
+  PAGERTRACE4("FETCH %d page %d hash(%08x)\n",
+               PAGERID(pPager), pPg->pgno, pager_pagehash(pPg));
+  return rc;
+}
+
+
+/*
+** This function is called to obtain the shared lock required before
+** data may be read from the pager cache. If the shared lock has already
+** been obtained, this function is a no-op.
+**
+** Immediately after obtaining the shared lock (if required), this function
+** checks for a hot-journal file. If one is found, an emergency rollback
+** is performed immediately.
+*/
+static int pagerSharedLock(Pager *pPager){
+  int rc = SQLITE_OK;
+  int isHot = 0;
+
+  /* If this database is opened for exclusive access, has no outstanding 
+  ** page references and is in an error-state, now is the chance to clear
+  ** the error. Discard the contents of the pager-cache and treat any
+  ** open journal file as a hot-journal.
+  */
+  if( !MEMDB && pPager->exclusiveMode && pPager->nRef==0 && pPager->errCode ){
+    if( pPager->journalOpen ){
+      isHot = 1;
+    }
+    pager_reset(pPager);
+    pPager->errCode = SQLITE_OK;
+  }
+
+  /* If the pager is still in an error state, do not proceed. The error 
+  ** state will be cleared at some point in the future when all page 
+  ** references are dropped and the cache can be discarded.
+  */
+  if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
+    return pPager->errCode;
+  }
+
+  if( pPager->state==PAGER_UNLOCK || isHot ){
+    sqlite3_vfs *pVfs = pPager->pVfs;
+    if( !MEMDB ){
+      assert( pPager->nRef==0 );
+      if( !pPager->noReadlock ){
+        rc = pager_wait_on_lock(pPager, SHARED_LOCK);
+        if( rc!=SQLITE_OK ){
+          return pager_error(pPager, rc);
+        }
+        assert( pPager->state>=SHARED_LOCK );
+      }
+  
+      /* If a journal file exists, and there is no RESERVED lock on the
+      ** database file, then it either needs to be played back or deleted.
+      */
+      if( hasHotJournal(pPager) || isHot ){
+        /* Get an EXCLUSIVE lock on the database file. At this point it is
+        ** important that a RESERVED lock is not obtained on the way to the
+        ** EXCLUSIVE lock. If it were, another process might open the
+        ** database file, detect the RESERVED lock, and conclude that the
+        ** database is safe to read while this process is still rolling it 
+        ** back.
+        ** 
+        ** Because the intermediate RESERVED lock is not requested, the
+        ** second process will get to this point in the code and fail to
+        ** obtain its own EXCLUSIVE lock on the database file.
+        */
+        if( pPager->state<EXCLUSIVE_LOCK ){
+          rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
+          if( rc!=SQLITE_OK ){
+            pager_unlock(pPager);
+            return pager_error(pPager, rc);
+          }
+          pPager->state = PAGER_EXCLUSIVE;
+        }
+ 
+        /* Open the journal for reading only.  Return SQLITE_BUSY if
+        ** we are unable to open the journal file. 
+        **
+        ** The journal file does not need to be locked itself.  The
+        ** journal file is never open unless the main database file holds
+        ** a write lock, so there is never any chance of two or more
+        ** processes opening the journal at the same time.
+        **
+        ** Open the journal for read/write access. This is because in 
+        ** exclusive-access mode the file descriptor will be kept open and
+        ** possibly used for a transaction later on. On some systems, the
+        ** OsTruncate() call used in exclusive-access mode also requires
+        ** a read/write file handle.
+        */
+        if( !isHot ){
+          rc = SQLITE_BUSY;
+          if( sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){
+            int fout = 0;
+            int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
+            assert( !pPager->tempFile );
+            rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
+            assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
+            if( fout&SQLITE_OPEN_READONLY ){
+              rc = SQLITE_BUSY;
+              sqlite3OsClose(pPager->jfd);
+            }
+          }
+        }
+        if( rc!=SQLITE_OK ){
+          pager_unlock(pPager);
+          return ((rc==SQLITE_NOMEM||rc==SQLITE_IOERR_NOMEM)?rc:SQLITE_BUSY);
+        }
+        pPager->journalOpen = 1;
+        pPager->journalStarted = 0;
+        pPager->journalOff = 0;
+        pPager->setMaster = 0;
+        pPager->journalHdr = 0;
+ 
+        /* Playback and delete the journal.  Drop the database write
+        ** lock and reacquire the read lock.
+        */
+        rc = pager_playback(pPager, 1);
+        if( rc!=SQLITE_OK ){
+          return pager_error(pPager, rc);
+        }
+        assert(pPager->state==PAGER_SHARED || 
+            (pPager->exclusiveMode && pPager->state>PAGER_SHARED)
+        );
+      }
+
+      if( pPager->pAll ){
+        /* The shared-lock has just been acquired on the database file
+        ** and there are already pages in the cache (from a previous
+        ** read or write transaction).  Check to see if the database
+        ** has been modified.  If the database has changed, flush the
+        ** cache.
+        **
+        ** Database changes is detected by looking at 15 bytes beginning
+        ** at offset 24 into the file.  The first 4 of these 16 bytes are
+        ** a 32-bit counter that is incremented with each change.  The
+        ** other bytes change randomly with each file change when
+        ** a codec is in use.
+        ** 
+        ** There is a vanishingly small chance that a change will not be 
+        ** detected.  The chance of an undetected change is so small that
+        ** it can be neglected.
+        */
+        char dbFileVers[sizeof(pPager->dbFileVers)];
+        sqlite3PagerPagecount(pPager);
+
+        if( pPager->errCode ){
+          return pPager->errCode;
+        }
+
+        if( pPager->dbSize>0 ){
+          IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
+          rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
+          if( rc!=SQLITE_OK ){
+            return rc;
+          }
+        }else{
+          memset(dbFileVers, 0, sizeof(dbFileVers));
+        }
+
+        if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
+          pager_reset(pPager);
+        }
+      }
+    }
+    assert( pPager->exclusiveMode || pPager->state<=PAGER_SHARED );
+    if( pPager->state==PAGER_UNLOCK ){
+      pPager->state = PAGER_SHARED;
+    }
+  }
+
+  return rc;
+}
+
+/*
+** Allocate a PgHdr object.   Either create a new one or reuse
+** an existing one that is not otherwise in use.
+**
+** A new PgHdr structure is created if any of the following are
+** true:
+**
+**     (1)  We have not exceeded our maximum allocated cache size
+**          as set by the "PRAGMA cache_size" command.
+**
+**     (2)  There are no unused PgHdr objects available at this time.
+**
+**     (3)  This is an in-memory database.
+**
+**     (4)  There are no PgHdr objects that do not require a journal
+**          file sync and a sync of the journal file is currently
+**          prohibited.
+**
+** Otherwise, reuse an existing PgHdr.  In other words, reuse an
+** existing PgHdr if all of the following are true:
+**
+**     (1)  We have reached or exceeded the maximum cache size
+**          allowed by "PRAGMA cache_size".
+**
+**     (2)  There is a PgHdr available with PgHdr->nRef==0
+**
+**     (3)  We are not in an in-memory database
+**
+**     (4)  Either there is an available PgHdr that does not need
+**          to be synced to disk or else disk syncing is currently
+**          allowed.
+*/
+static int pagerAllocatePage(Pager *pPager, PgHdr **ppPg){
+  int rc = SQLITE_OK;
+  PgHdr *pPg;
+  int nByteHdr;
+
+  /* Create a new PgHdr if any of the four conditions defined 
+  ** above are met: */
+  if( pPager->nPage<pPager->mxPage
+   || pPager->lru.pFirst==0 
+   || MEMDB
+   || (pPager->lru.pFirstSynced==0 && pPager->doNotSync)
+  ){
+    if( pPager->nPage>=pPager->nHash ){
+      pager_resize_hash_table(pPager,
+         pPager->nHash<256 ? 256 : pPager->nHash*2);
+      if( pPager->nHash==0 ){
+        rc = SQLITE_NOMEM;
+        goto pager_allocate_out;
+      }
+    }
+    pagerLeave(pPager);
+    nByteHdr = sizeof(*pPg) + sizeof(u32) + pPager->nExtra
+              + MEMDB*sizeof(PgHistory);
+    pPg = sqlite3_malloc( nByteHdr + pPager->pageSize );
+    pagerEnter(pPager);
+    if( pPg==0 ){
+      rc = SQLITE_NOMEM;
+      goto pager_allocate_out;
+    }
+    memset(pPg, 0, nByteHdr);
+    pPg->pData = (void*)(nByteHdr + (char*)pPg);
+    pPg->pPager = pPager;
+    pPg->pNextAll = pPager->pAll;
+    pPager->pAll = pPg;
+    pPager->nPage++;
+  }else{
+    /* Recycle an existing page with a zero ref-count. */
+    rc = pager_recycle(pPager, &pPg);
+    if( rc==SQLITE_BUSY ){
+      rc = SQLITE_IOERR_BLOCKED;
+    }
+    if( rc!=SQLITE_OK ){
+      goto pager_allocate_out;
+    }
+    assert( pPager->state>=SHARED_LOCK );
+    assert(pPg);
+  }
+  *ppPg = pPg;
+
+pager_allocate_out:
+  return rc;
+}
+
+/*
+** Make sure we have the content for a page.  If the page was
+** previously acquired with noContent==1, then the content was
+** just initialized to zeros instead of being read from disk.
+** But now we need the real data off of disk.  So make sure we
+** have it.  Read it in if we do not have it already.
+*/
+static int pager_get_content(PgHdr *pPg){
+  if( pPg->needRead ){
+    int rc = readDbPage(pPg->pPager, pPg, pPg->pgno);
+    if( rc==SQLITE_OK ){
+      pPg->needRead = 0;
+    }else{
+      return rc;
+    }
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Acquire a page.
+**
+** A read lock on the disk file is obtained when the first page is acquired. 
+** This read lock is dropped when the last page is released.
+**
+** This routine works for any page number greater than 0.  If the database
+** file is smaller than the requested page, then no actual disk
+** read occurs and the memory image of the page is initialized to
+** all zeros.  The extra data appended to a page is always initialized
+** to zeros the first time a page is loaded into memory.
+**
+** The acquisition might fail for several reasons.  In all cases,
+** an appropriate error code is returned and *ppPage is set to NULL.
+**
+** See also sqlite3PagerLookup().  Both this routine and Lookup() attempt
+** to find a page in the in-memory cache first.  If the page is not already
+** in memory, this routine goes to disk to read it in whereas Lookup()
+** just returns 0.  This routine acquires a read-lock the first time it
+** has to go to disk, and could also playback an old journal if necessary.
+** Since Lookup() never goes to disk, it never has to deal with locks
+** or journal files.
+**
+** If noContent is false, the page contents are actually read from disk.
+** If noContent is true, it means that we do not care about the contents
+** of the page at this time, so do not do a disk read.  Just fill in the
+** page content with zeros.  But mark the fact that we have not read the
+** content by setting the PgHdr.needRead flag.  Later on, if 
+** sqlite3PagerWrite() is called on this page or if this routine is
+** called again with noContent==0, that means that the content is needed
+** and the disk read should occur at that point.
+*/
+static int pagerAcquire(
+  Pager *pPager,      /* The pager open on the database file */
+  Pgno pgno,          /* Page number to fetch */
+  DbPage **ppPage,    /* Write a pointer to the page here */
+  int noContent       /* Do not bother reading content from disk if true */
+){
+  PgHdr *pPg;
+  int rc;
+
+  assert( pPager->state==PAGER_UNLOCK || pPager->nRef>0 || pgno==1 );
+
+  /* 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 || pgno==PAGER_MJ_PGNO(pPager) ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+
+  /* Make sure we have not hit any critical errors.
+  */ 
+  assert( pPager!=0 );
+  *ppPage = 0;
+
+  /* If this is the first page accessed, then get a SHARED lock
+  ** on the database file. pagerSharedLock() is a no-op if 
+  ** a database lock is already held.
+  */
+  rc = pagerSharedLock(pPager);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  assert( pPager->state!=PAGER_UNLOCK );
+
+  pPg = pager_lookup(pPager, pgno);
+  if( pPg==0 ){
+    /* The requested page is not in the page cache. */
+    int nMax;
+    int h;
+    PAGER_INCR(pPager->nMiss);
+    rc = pagerAllocatePage(pPager, &pPg);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+
+    pPg->pgno = pgno;
+    assert( !MEMDB || pgno>pPager->stmtSize );
+    if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
+#if 0
+      sqlite3CheckMemory(pPager->aInJournal, pgno/8);
+#endif
+      assert( pPager->journalOpen );
+      pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
+      pPg->needSync = 0;
+    }else{
+      pPg->inJournal = 0;
+      pPg->needSync = 0;
+    }
+
+    makeClean(pPg);
+    pPg->nRef = 1;
+
+    pPager->nRef++;
+    if( pPager->nExtra>0 ){
+      memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra);
+    }
+    nMax = sqlite3PagerPagecount(pPager);
+    if( pPager->errCode ){
+      rc = pPager->errCode;
+      sqlite3PagerUnref(pPg);
+      return rc;
+    }
+
+    /* Populate the page with data, either by reading from the database
+    ** file, or by setting the entire page to zero.
+    */
+    if( nMax<(int)pgno || MEMDB || (noContent && !pPager->alwaysRollback) ){
+      if( pgno>pPager->mxPgno ){
+        sqlite3PagerUnref(pPg);
+        return SQLITE_FULL;
+      }
+      memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
+      pPg->needRead = noContent && !pPager->alwaysRollback;
+      IOTRACE(("ZERO %p %d\n", pPager, pgno));
+    }else{
+      rc = readDbPage(pPager, pPg, pgno);
+      if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
+        pPg->pgno = 0;
+        sqlite3PagerUnref(pPg);
+        return rc;
+      }
+      pPg->needRead = 0;
+    }
+
+    /* Link the page into the page hash table */
+    h = pgno & (pPager->nHash-1);
+    assert( pgno!=0 );
+    pPg->pNextHash = pPager->aHash[h];
+    pPager->aHash[h] = pPg;
+    if( pPg->pNextHash ){
+      assert( pPg->pNextHash->pPrevHash==0 );
+      pPg->pNextHash->pPrevHash = pPg;
+    }
+
+#ifdef SQLITE_CHECK_PAGES
+    pPg->pageHash = pager_pagehash(pPg);
+#endif
+  }else{
+    /* The requested page is in the page cache. */
+    assert(pPager->nRef>0 || pgno==1);
+    PAGER_INCR(pPager->nHit);
+    if( !noContent ){
+      rc = pager_get_content(pPg);
+      if( rc ){
+        return rc;
+      }
+    }
+    page_ref(pPg);
+  }
+  *ppPage = pPg;
+  return SQLITE_OK;
+}
+int sqlite3PagerAcquire(
+  Pager *pPager,      /* The pager open on the database file */
+  Pgno pgno,          /* Page number to fetch */
+  DbPage **ppPage,    /* Write a pointer to the page here */
+  int noContent       /* Do not bother reading content from disk if true */
+){
+  int rc;
+  pagerEnter(pPager);
+  rc = pagerAcquire(pPager, pgno, ppPage, noContent);
+  pagerLeave(pPager);
+  return rc;
+}
+
+
+/*
+** Acquire a page if it is already in the in-memory cache.  Do
+** not read the page from disk.  Return a pointer to the page,
+** or 0 if the page is not in cache.
+**
+** See also sqlite3PagerGet().  The difference between this routine
+** and sqlite3PagerGet() is that _get() will go to the disk and read
+** in the page if the page is not already in cache.  This routine
+** returns NULL if the page is not in cache or if a disk I/O error 
+** has ever happened.
+*/
+DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
+  PgHdr *pPg = 0;
+
+  assert( pPager!=0 );
+  assert( pgno!=0 );
+
+  pagerEnter(pPager);
+  if( pPager->state==PAGER_UNLOCK ){
+    assert( !pPager->pAll || pPager->exclusiveMode );
+  }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
+    /* Do nothing */
+  }else if( (pPg = pager_lookup(pPager, pgno))!=0 ){
+    page_ref(pPg);
+  }
+  pagerLeave(pPager);
+  return pPg;
+}
+
+/*
+** Release a page.
+**
+** If the number of references to the page drop to zero, then the
+** page is added to the LRU list.  When all references to all pages
+** are released, a rollback occurs and the lock on the database is
+** removed.
+*/
+int sqlite3PagerUnref(DbPage *pPg){
+  Pager *pPager = pPg->pPager;
+
+  /* Decrement the reference count for this page
+  */
+  assert( pPg->nRef>0 );
+  pagerEnter(pPg->pPager);
+  pPg->nRef--;
+
+  CHECK_PAGE(pPg);
+
+  /* When the number of references to a page reach 0, call the
+  ** destructor and add the page to the freelist.
+  */
+  if( pPg->nRef==0 ){
+
+    lruListAdd(pPg);
+    if( pPager->xDestructor ){
+      pPager->xDestructor(pPg, pPager->pageSize);
+    }
+  
+    /* When all pages reach the freelist, drop the read lock from
+    ** the database file.
+    */
+    pPager->nRef--;
+    assert( pPager->nRef>=0 );
+    if( pPager->nRef==0 && (!pPager->exclusiveMode || pPager->journalOff>0) ){
+      pagerUnlockAndRollback(pPager);
+    }
+  }
+  pagerLeave(pPager);
+  return SQLITE_OK;
+}
+
+/*
+** Create a journal file for pPager.  There should already be a RESERVED
+** or EXCLUSIVE lock on the database file when this routine is called.
+**
+** Return SQLITE_OK if everything.  Return an error code and release the
+** write lock if anything goes wrong.
+*/
+static int pager_open_journal(Pager *pPager){
+  sqlite3_vfs *pVfs = pPager->pVfs;
+  int flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_CREATE);
+
+  int rc;
+  assert( !MEMDB );
+  assert( pPager->state>=PAGER_RESERVED );
+  assert( pPager->journalOpen==0 );
+  assert( pPager->useJournal );
+  assert( pPager->aInJournal==0 );
+  sqlite3PagerPagecount(pPager);
+  pagerLeave(pPager);
+  pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+  pagerEnter(pPager);
+  if( pPager->aInJournal==0 ){
+    rc = SQLITE_NOMEM;
+    goto failed_to_open_journal;
+  }
+
+  if( pPager->tempFile ){
+    flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
+  }else{
+    flags |= (SQLITE_OPEN_MAIN_JOURNAL);
+  }
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+  rc = sqlite3JournalOpen(
+      pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
+  );
+#else
+  rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
+#endif
+  assert( rc!=SQLITE_OK || pPager->jfd->pMethods );
+  pPager->journalOff = 0;
+  pPager->setMaster = 0;
+  pPager->journalHdr = 0;
+  if( rc!=SQLITE_OK ){
+    if( rc==SQLITE_NOMEM ){
+      sqlite3OsDelete(pVfs, pPager->zJournal, 0);
+    }
+    goto failed_to_open_journal;
+  }
+  pPager->journalOpen = 1;
+  pPager->journalStarted = 0;
+  pPager->needSync = 0;
+  pPager->alwaysRollback = 0;
+  pPager->nRec = 0;
+  if( pPager->errCode ){
+    rc = pPager->errCode;
+    goto failed_to_open_journal;
+  }
+  pPager->origDbSize = pPager->dbSize;
+
+  rc = writeJournalHdr(pPager);
+
+  if( pPager->stmtAutoopen && rc==SQLITE_OK ){
+    rc = sqlite3PagerStmtBegin(pPager);
+  }
+  if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && rc!=SQLITE_IOERR_NOMEM ){
+    rc = pager_end_transaction(pPager);
+    if( rc==SQLITE_OK ){
+      rc = SQLITE_FULL;
+    }
+  }
+  return rc;
+
+failed_to_open_journal:
+  sqlite3_free(pPager->aInJournal);
+  pPager->aInJournal = 0;
+  return rc;
+}
+
+/*
+** Acquire a write-lock on the database.  The lock is removed when
+** the any of the following happen:
+**
+**   *  sqlite3PagerCommitPhaseTwo() is called.
+**   *  sqlite3PagerRollback() is called.
+**   *  sqlite3PagerClose() is called.
+**   *  sqlite3PagerUnref() is called to on every outstanding page.
+**
+** The first parameter to this routine is a pointer to any open page of the
+** database file.  Nothing changes about the page - it is used merely to
+** acquire a pointer to the Pager structure and as proof that there is
+** already a read-lock on the database.
+**
+** The second parameter indicates how much space in bytes to reserve for a
+** master journal file-name at the start of the journal when it is created.
+**
+** A journal file is opened if this is not a temporary file.  For temporary
+** files, the opening of the journal file is deferred until there is an
+** actual need to write to the journal.
+**
+** If the database is already reserved for writing, this routine is a no-op.
+**
+** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file
+** immediately instead of waiting until we try to flush the cache.  The
+** exFlag is ignored if a transaction is already active.
+*/
+int sqlite3PagerBegin(DbPage *pPg, int exFlag){
+  Pager *pPager = pPg->pPager;
+  int rc = SQLITE_OK;
+  pagerEnter(pPager);
+  assert( pPg->nRef>0 );
+  assert( pPager->state!=PAGER_UNLOCK );
+  if( pPager->state==PAGER_SHARED ){
+    assert( pPager->aInJournal==0 );
+    if( MEMDB ){
+      pPager->state = PAGER_EXCLUSIVE;
+      pPager->origDbSize = pPager->dbSize;
+    }else{
+      rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
+      if( rc==SQLITE_OK ){
+        pPager->state = PAGER_RESERVED;
+        if( exFlag ){
+          rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
+        }
+      }
+      if( rc!=SQLITE_OK ){
+        pagerLeave(pPager);
+        return rc;
+      }
+      pPager->dirtyCache = 0;
+      PAGERTRACE2("TRANSACTION %d\n", PAGERID(pPager));
+      if( pPager->useJournal && !pPager->tempFile ){
+        rc = pager_open_journal(pPager);
+      }
+    }
+  }else if( pPager->journalOpen && pPager->journalOff==0 ){
+    /* This happens when the pager was in exclusive-access mode last
+    ** time a (read or write) transaction was successfully concluded
+    ** by this connection. Instead of deleting the journal file it was 
+    ** kept open and truncated to 0 bytes.
+    */
+    assert( pPager->nRec==0 );
+    assert( pPager->origDbSize==0 );
+    assert( pPager->aInJournal==0 );
+    sqlite3PagerPagecount(pPager);
+    pagerLeave(pPager);
+    pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+    pagerEnter(pPager);
+    if( !pPager->aInJournal ){
+      rc = SQLITE_NOMEM;
+    }else{
+      pPager->origDbSize = pPager->dbSize;
+      rc = writeJournalHdr(pPager);
+    }
+  }
+  assert( !pPager->journalOpen || pPager->journalOff>0 || rc!=SQLITE_OK );
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Make a page dirty.  Set its dirty flag and add it to the dirty
+** page list.
+*/
+static void makeDirty(PgHdr *pPg){
+  if( pPg->dirty==0 ){
+    Pager *pPager = pPg->pPager;
+    pPg->dirty = 1;
+    pPg->pDirty = pPager->pDirty;
+    if( pPager->pDirty ){
+      pPager->pDirty->pPrevDirty = pPg;
+    }
+    pPg->pPrevDirty = 0;
+    pPager->pDirty = pPg;
+  }
+}
+
+/*
+** Make a page clean.  Clear its dirty bit and remove it from the
+** dirty page list.
+*/
+static void makeClean(PgHdr *pPg){
+  if( pPg->dirty ){
+    pPg->dirty = 0;
+    if( pPg->pDirty ){
+      assert( pPg->pDirty->pPrevDirty==pPg );
+      pPg->pDirty->pPrevDirty = pPg->pPrevDirty;
+    }
+    if( pPg->pPrevDirty ){
+      assert( pPg->pPrevDirty->pDirty==pPg );
+      pPg->pPrevDirty->pDirty = pPg->pDirty;
+    }else{
+      assert( pPg->pPager->pDirty==pPg );
+      pPg->pPager->pDirty = pPg->pDirty;
+    }
+  }
+}
+
+
+/*
+** Mark a data page as writeable.  The page is written into the journal 
+** if it is not there already.  This routine must be called before making
+** changes to a page.
+**
+** The first time this routine is called, the pager creates a new
+** journal and acquires a RESERVED lock on the database.  If the RESERVED
+** lock could not be acquired, this routine returns SQLITE_BUSY.  The
+** calling routine must check for that return value and be careful not to
+** change any page data until this routine returns SQLITE_OK.
+**
+** If the journal file could not be written because the disk is full,
+** then this routine returns SQLITE_FULL and does an immediate rollback.
+** All subsequent write attempts also return SQLITE_FULL until there
+** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to
+** reset.
+*/
+static int pager_write(PgHdr *pPg){
+  void *pData = PGHDR_TO_DATA(pPg);
+  Pager *pPager = pPg->pPager;
+  int rc = SQLITE_OK;
+
+  /* Check for errors
+  */
+  if( pPager->errCode ){ 
+    return pPager->errCode;
+  }
+  if( pPager->readOnly ){
+    return SQLITE_PERM;
+  }
+
+  assert( !pPager->setMaster );
+
+  CHECK_PAGE(pPg);
+
+  /* If this page was previously acquired with noContent==1, that means
+  ** we didn't really read in the content of the page.  This can happen
+  ** (for example) when the page is being moved to the freelist.  But
+  ** now we are (perhaps) moving the page off of the freelist for
+  ** reuse and we need to know its original content so that content
+  ** can be stored in the rollback journal.  So do the read at this
+  ** time.
+  */
+  rc = pager_get_content(pPg);
+  if( rc ){
+    return rc;
+  }
+
+  /* Mark the page as dirty.  If the page has already been written
+  ** to the journal then we can return right away.
+  */
+  makeDirty(pPg);
+  if( pPg->inJournal && (pageInStatement(pPg) || pPager->stmtInUse==0) ){
+    pPager->dirtyCache = 1;
+  }else{
+
+    /* If we get this far, it means that the page needs to be
+    ** written to the transaction journal or the ckeckpoint journal
+    ** or both.
+    **
+    ** First check to see that the transaction journal exists and
+    ** create it if it does not.
+    */
+    assert( pPager->state!=PAGER_UNLOCK );
+    rc = sqlite3PagerBegin(pPg, 0);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    assert( pPager->state>=PAGER_RESERVED );
+    if( !pPager->journalOpen && pPager->useJournal ){
+      rc = pager_open_journal(pPager);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+    assert( pPager->journalOpen || !pPager->useJournal );
+    pPager->dirtyCache = 1;
+  
+    /* The transaction journal now exists and we have a RESERVED or an
+    ** EXCLUSIVE lock on the main database file.  Write the current page to
+    ** the transaction journal if it is not there already.
+    */
+    if( !pPg->inJournal && (pPager->useJournal || MEMDB) ){
+      if( (int)pPg->pgno <= pPager->origDbSize ){
+        if( MEMDB ){
+          PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+          PAGERTRACE3("JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
+          assert( pHist->pOrig==0 );
+          pHist->pOrig = sqlite3_malloc( pPager->pageSize );
+          if( !pHist->pOrig ){
+            return SQLITE_NOMEM;
+          }
+          memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize);
+        }else{
+          u32 cksum;
+          char *pData2;
+
+          /* We should never write to the journal file the page that
+          ** contains the database locks.  The following assert verifies
+          ** that we do not. */
+          assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
+          pData2 = CODEC2(pPager, pData, pPg->pgno, 7);
+          cksum = pager_cksum(pPager, (u8*)pData2);
+          rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno);
+          if( rc==SQLITE_OK ){
+            rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize,
+                                pPager->journalOff + 4);
+            pPager->journalOff += pPager->pageSize+4;
+          }
+          if( rc==SQLITE_OK ){
+            rc = write32bits(pPager->jfd, pPager->journalOff, cksum);
+            pPager->journalOff += 4;
+          }
+          IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, 
+                   pPager->journalOff, pPager->pageSize));
+          PAGER_INCR(sqlite3_pager_writej_count);
+          PAGERTRACE5("JOURNAL %d page %d needSync=%d hash(%08x)\n",
+               PAGERID(pPager), pPg->pgno, pPg->needSync, pager_pagehash(pPg));
+
+          /* An error has occured writing to the journal file. The 
+          ** transaction will be rolled back by the layer above.
+          */
+          if( rc!=SQLITE_OK ){
+            return rc;
+          }
+
+          pPager->nRec++;
+          assert( pPager->aInJournal!=0 );
+          pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
+          pPg->needSync = !pPager->noSync;
+          if( pPager->stmtInUse ){
+            pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
+          }
+        }
+      }else{
+        pPg->needSync = !pPager->journalStarted && !pPager->noSync;
+        PAGERTRACE4("APPEND %d page %d needSync=%d\n",
+                PAGERID(pPager), pPg->pgno, pPg->needSync);
+      }
+      if( pPg->needSync ){
+        pPager->needSync = 1;
+      }
+      pPg->inJournal = 1;
+    }
+  
+    /* If the statement journal is open and the page is not in it,
+    ** then write the current page to the statement journal.  Note that
+    ** the statement journal format differs from the standard journal format
+    ** in that it omits the checksums and the header.
+    */
+    if( pPager->stmtInUse 
+     && !pageInStatement(pPg) 
+     && (int)pPg->pgno<=pPager->stmtSize 
+    ){
+      assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize );
+      if( MEMDB ){
+        PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+        assert( pHist->pStmt==0 );
+        pHist->pStmt = sqlite3_malloc( pPager->pageSize );
+        if( pHist->pStmt ){
+          memcpy(pHist->pStmt, PGHDR_TO_DATA(pPg), pPager->pageSize);
+        }
+        PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
+        page_add_to_stmt_list(pPg);
+      }else{
+        i64 offset = pPager->stmtNRec*(4+pPager->pageSize);
+        char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7);
+        rc = write32bits(pPager->stfd, offset, pPg->pgno);
+        if( rc==SQLITE_OK ){
+          rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize, offset+4);
+        }
+        PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        pPager->stmtNRec++;
+        assert( pPager->aInStmt!=0 );
+        pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
+      }
+    }
+  }
+
+  /* Update the database size and return.
+  */
+  assert( pPager->state>=PAGER_SHARED );
+  if( pPager->dbSize<(int)pPg->pgno ){
+    pPager->dbSize = pPg->pgno;
+    if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){
+      pPager->dbSize++;
+    }
+  }
+  return rc;
+}
+
+/*
+** This function is used to mark a data-page as writable. It uses 
+** pager_write() to open a journal file (if it is not already open)
+** and write the page *pData to the journal.
+**
+** The difference between this function and pager_write() is that this
+** function also deals with the special case where 2 or more pages
+** fit on a single disk sector. In this case all co-resident pages
+** must have been written to the journal file before returning.
+*/
+int sqlite3PagerWrite(DbPage *pDbPage){
+  int rc = SQLITE_OK;
+
+  PgHdr *pPg = pDbPage;
+  Pager *pPager = pPg->pPager;
+  Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
+
+  pagerEnter(pPager);
+  if( !MEMDB && nPagePerSector>1 ){
+    Pgno nPageCount;          /* Total number of pages in database file */
+    Pgno pg1;                 /* First page of the sector pPg is located on. */
+    int nPage;                /* Number of pages starting at pg1 to journal */
+    int ii;
+    int needSync = 0;
+
+    /* Set the doNotSync flag to 1. This is because we cannot allow a journal
+    ** header to be written between the pages journaled by this function.
+    */
+    assert( pPager->doNotSync==0 );
+    pPager->doNotSync = 1;
+
+    /* This trick assumes that both the page-size and sector-size are
+    ** an integer power of 2. It sets variable pg1 to the identifier
+    ** of the first page of the sector pPg is located on.
+    */
+    pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
+
+    nPageCount = sqlite3PagerPagecount(pPager);
+    if( pPg->pgno>nPageCount ){
+      nPage = (pPg->pgno - pg1)+1;
+    }else if( (pg1+nPagePerSector-1)>nPageCount ){
+      nPage = nPageCount+1-pg1;
+    }else{
+      nPage = nPagePerSector;
+    }
+    assert(nPage>0);
+    assert(pg1<=pPg->pgno);
+    assert((pg1+nPage)>pPg->pgno);
+
+    for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
+      Pgno pg = pg1+ii;
+      PgHdr *pPage;
+      if( !pPager->aInJournal || pg==pPg->pgno || 
+          pg>pPager->origDbSize || !(pPager->aInJournal[pg/8]&(1<<(pg&7)))
+      ) {
+        if( pg!=PAGER_MJ_PGNO(pPager) ){
+          rc = sqlite3PagerGet(pPager, pg, &pPage);
+          if( rc==SQLITE_OK ){
+            rc = pager_write(pPage);
+            if( pPage->needSync ){
+              needSync = 1;
+            }
+            sqlite3PagerUnref(pPage);
+          }
+        }
+      }else if( (pPage = pager_lookup(pPager, pg)) ){
+        if( pPage->needSync ){
+          needSync = 1;
+        }
+      }
+    }
+
+    /* If the PgHdr.needSync flag is set for any of the nPage pages 
+    ** starting at pg1, then it needs to be set for all of them. Because
+    ** writing to any of these nPage pages may damage the others, the
+    ** journal file must contain sync()ed copies of all of them
+    ** before any of them can be written out to the database file.
+    */
+    if( needSync ){
+      for(ii=0; ii<nPage && needSync; ii++){
+        PgHdr *pPage = pager_lookup(pPager, pg1+ii);
+        if( pPage ) pPage->needSync = 1;
+      }
+      assert(pPager->needSync);
+    }
+
+    assert( pPager->doNotSync==1 );
+    pPager->doNotSync = 0;
+  }else{
+    rc = pager_write(pDbPage);
+  }
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Return TRUE if the page given in the argument was previously passed
+** to sqlite3PagerWrite().  In other words, return TRUE if it is ok
+** to change the content of the page.
+*/
+#ifndef NDEBUG
+int sqlite3PagerIswriteable(DbPage *pPg){
+  return pPg->dirty;
+}
+#endif
+
+#ifndef SQLITE_OMIT_VACUUM
+/*
+** Replace the content of a single page with the information in the third
+** argument.
+*/
+int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void *pData){
+  PgHdr *pPg;
+  int rc;
+
+  pagerEnter(pPager);
+  rc = sqlite3PagerGet(pPager, pgno, &pPg);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3PagerWrite(pPg);
+    if( rc==SQLITE_OK ){
+      memcpy(sqlite3PagerGetData(pPg), pData, pPager->pageSize);
+    }
+    sqlite3PagerUnref(pPg);
+  }
+  pagerLeave(pPager);
+  return rc;
+}
+#endif
+
+/*
+** A call to this routine tells the pager that it is not necessary to
+** write the information on page pPg back to the disk, even though
+** that page might be marked as dirty.
+**
+** The overlying software layer calls this routine when all of the data
+** on the given page is unused.  The pager marks the page as clean so
+** that it does not get written to disk.
+**
+** Tests show that this optimization, together with the
+** sqlite3PagerDontRollback() below, more than double the speed
+** of large INSERT operations and quadruple the speed of large DELETEs.
+**
+** When this routine is called, set the alwaysRollback flag to true.
+** Subsequent calls to sqlite3PagerDontRollback() for the same page
+** will thereafter be ignored.  This is necessary to avoid a problem
+** where a page with data is added to the freelist during one part of
+** a transaction then removed from the freelist during a later part
+** of the same transaction and reused for some other purpose.  When it
+** is first added to the freelist, this routine is called.  When reused,
+** the sqlite3PagerDontRollback() routine is called.  But because the
+** page contains critical data, we still need to be sure it gets
+** rolled back in spite of the sqlite3PagerDontRollback() call.
+*/
+void sqlite3PagerDontWrite(DbPage *pDbPage){
+  PgHdr *pPg = pDbPage;
+  Pager *pPager = pPg->pPager;
+
+  if( MEMDB ) return;
+  pagerEnter(pPager);
+  pPg->alwaysRollback = 1;
+  if( pPg->dirty && !pPager->stmtInUse ){
+    assert( pPager->state>=PAGER_SHARED );
+    if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){
+      /* If this pages is the last page in the file and the file has grown
+      ** during the current transaction, then do NOT mark the page as clean.
+      ** When the database file grows, we must make sure that the last page
+      ** gets written at least once so that the disk file will be the correct
+      ** size. If you do not write this page and the size of the file
+      ** on the disk ends up being too small, that can lead to database
+      ** corruption during the next transaction.
+      */
+    }else{
+      PAGERTRACE3("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager));
+      IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
+      makeClean(pPg);
+#ifdef SQLITE_CHECK_PAGES
+      pPg->pageHash = pager_pagehash(pPg);
+#endif
+    }
+  }
+  pagerLeave(pPager);
+}
+
+/*
+** A call to this routine tells the pager that if a rollback occurs,
+** it is not necessary to restore the data on the given page.  This
+** means that the pager does not have to record the given page in the
+** rollback journal.
+**
+** If we have not yet actually read the content of this page (if
+** the PgHdr.needRead flag is set) then this routine acts as a promise
+** that we will never need to read the page content in the future.
+** so the needRead flag can be cleared at this point.
+**
+** This routine is only called from a single place in the sqlite btree
+** code (when a leaf is removed from the free-list). This allows the
+** following assumptions to be made about pPg:
+**
+**   1. PagerDontWrite() has been called on the page, OR 
+**      PagerWrite() has not yet been called on the page.
+**
+**   2. The page existed when the transaction was started.
+**
+** Details: DontRollback() (this routine) is only called when a leaf is
+** removed from the free list. DontWrite() is called whenever a page 
+** becomes a free-list leaf.
+*/
+void sqlite3PagerDontRollback(DbPage *pPg){
+  Pager *pPager = pPg->pPager;
+
+  pagerEnter(pPager);
+  assert( pPager->state>=PAGER_RESERVED );
+
+  /* If the journal file is not open, or DontWrite() has been called on
+  ** this page (DontWrite() sets the alwaysRollback flag), then this
+  ** function is a no-op.
+  */
+  if( pPager->journalOpen==0 || pPg->alwaysRollback || pPager->alwaysRollback ){
+    pagerLeave(pPager);
+    return;
+  }
+  assert( !MEMDB );    /* For a memdb, pPager->journalOpen is always 0 */
+
+  /* Check that PagerWrite() has not yet been called on this page, and
+  ** that the page existed when the transaction started.
+  */
+  assert( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize );
+
+  assert( pPager->aInJournal!=0 );
+  pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7);
+  pPg->inJournal = 1;
+  pPg->needRead = 0;
+  if( pPager->stmtInUse ){
+    assert( pPager->stmtSize <= pPager->origDbSize );
+    pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7);
+  }
+  PAGERTRACE3("DONT_ROLLBACK page %d of %d\n", pPg->pgno, PAGERID(pPager));
+  IOTRACE(("GARBAGE %p %d\n", pPager, pPg->pgno))
+  pagerLeave(pPager);
+}
+
+
+/*
+** This routine is called to increment the database file change-counter,
+** stored at byte 24 of the pager file.
+*/
+static int pager_incr_changecounter(Pager *pPager, int isDirect){
+  PgHdr *pPgHdr;
+  u32 change_counter;
+  int rc = SQLITE_OK;
+
+  if( !pPager->changeCountDone ){
+    /* Open page 1 of the file for writing. */
+    rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
+    if( rc!=SQLITE_OK ) return rc;
+
+    if( !isDirect ){
+      rc = sqlite3PagerWrite(pPgHdr);
+      if( rc!=SQLITE_OK ){
+        sqlite3PagerUnref(pPgHdr);
+        return rc;
+      }
+    }
+
+    /* Increment the value just read and write it back to byte 24. */
+    change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
+    change_counter++;
+    put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter);
+
+    if( isDirect && pPager->fd->pMethods ){
+      const void *zBuf = PGHDR_TO_DATA(pPgHdr);
+      rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
+    }
+
+    /* Release the page reference. */
+    sqlite3PagerUnref(pPgHdr);
+    pPager->changeCountDone = 1;
+  }
+  return rc;
+}
+
+/*
+** Sync the database file for the pager pPager. zMaster points to the name
+** of a master journal file that should be written into the individual
+** journal file. zMaster may be NULL, which is interpreted as no master
+** journal (a single database transaction).
+**
+** This routine ensures that the journal is synced, all dirty pages written
+** to the database file and the database file synced. The only thing that
+** remains to commit the transaction is to delete the journal file (or
+** master journal file if specified).
+**
+** Note that if zMaster==NULL, this does not overwrite a previous value
+** passed to an sqlite3PagerCommitPhaseOne() call.
+**
+** If parameter nTrunc is non-zero, then the pager file is truncated to
+** nTrunc pages (this is used by auto-vacuum databases).
+*/
+int sqlite3PagerCommitPhaseOne(Pager *pPager, const char *zMaster, Pgno nTrunc){
+  int rc = SQLITE_OK;
+
+  PAGERTRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n", 
+      pPager->zFilename, zMaster, nTrunc);
+  pagerEnter(pPager);
+
+  /* If this is an in-memory db, or no pages have been written to, or this
+  ** function has already been called, it is a no-op.
+  */
+  if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){
+    PgHdr *pPg;
+
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+    /* The atomic-write optimization can be used if all of the
+    ** following are true:
+    **
+    **    + The file-system supports the atomic-write property for
+    **      blocks of size page-size, and
+    **    + This commit is not part of a multi-file transaction, and
+    **    + Exactly one page has been modified and store in the journal file.
+    **
+    ** If the optimization can be used, then the journal file will never
+    ** be created for this transaction.
+    */
+    int useAtomicWrite = (
+        !zMaster && 
+        pPager->journalOff==jrnlBufferSize(pPager) && 
+        nTrunc==0 && 
+        (0==pPager->pDirty || 0==pPager->pDirty->pDirty)
+    );
+    if( useAtomicWrite ){
+      /* Update the nRec field in the journal file. */
+      int offset = pPager->journalHdr + sizeof(aJournalMagic);
+      assert(pPager->nRec==1);
+      rc = write32bits(pPager->jfd, offset, pPager->nRec);
+
+      /* Update the db file change counter. The following call will modify
+      ** the in-memory representation of page 1 to include the updated
+      ** change counter and then write page 1 directly to the database
+      ** file. Because of the atomic-write property of the host file-system, 
+      ** this is safe.
+      */
+      if( rc==SQLITE_OK ){
+        rc = pager_incr_changecounter(pPager, 1);
+      }
+    }else{
+      rc = sqlite3JournalCreate(pPager->jfd);
+    }
+
+    if( !useAtomicWrite && rc==SQLITE_OK )
+#endif
+
+    /* If a master journal file name has already been written to the
+    ** journal file, then no sync is required. This happens when it is
+    ** written, then the process fails to upgrade from a RESERVED to an
+    ** EXCLUSIVE lock. The next time the process tries to commit the
+    ** transaction the m-j name will have already been written.
+    */
+    if( !pPager->setMaster ){
+      assert( pPager->journalOpen );
+      rc = pager_incr_changecounter(pPager, 0);
+      if( rc!=SQLITE_OK ) goto sync_exit;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+      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;
+        int iSkip = PAGER_MJ_PGNO(pPager);
+        for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){
+          if( !(pPager->aInJournal[i/8] & (1<<(i&7))) && i!=iSkip ){
+            rc = sqlite3PagerGet(pPager, i, &pPg);
+            if( rc!=SQLITE_OK ) goto sync_exit;
+            rc = sqlite3PagerWrite(pPg);
+            sqlite3PagerUnref(pPg);
+            if( rc!=SQLITE_OK ) goto sync_exit;
+          }
+        } 
+      }
+#endif
+      rc = writeMasterJournal(pPager, zMaster);
+      if( rc!=SQLITE_OK ) goto sync_exit;
+      rc = syncJournal(pPager);
+    }
+    if( rc!=SQLITE_OK ) goto sync_exit;
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( nTrunc!=0 ){
+      rc = sqlite3PagerTruncate(pPager, nTrunc);
+      if( rc!=SQLITE_OK ) goto sync_exit;
+    }
+#endif
+
+    /* Write all dirty pages to the database file */
+    pPg = pager_get_all_dirty_pages(pPager);
+    rc = pager_write_pagelist(pPg);
+    if( rc!=SQLITE_OK ){
+      while( pPg && !pPg->dirty ){ pPg = pPg->pDirty; }
+      pPager->pDirty = pPg;
+      goto sync_exit;
+    }
+    pPager->pDirty = 0;
+
+    /* Sync the database file. */
+    if( !pPager->noSync ){
+      rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
+    }
+    IOTRACE(("DBSYNC %p\n", pPager))
+
+    pPager->state = PAGER_SYNCED;
+  }else if( MEMDB && nTrunc!=0 ){
+    rc = sqlite3PagerTruncate(pPager, nTrunc);
+  }
+
+sync_exit:
+  if( rc==SQLITE_IOERR_BLOCKED ){
+    /* pager_incr_changecounter() may attempt to obtain an exclusive
+     * lock to spill the cache and return IOERR_BLOCKED. But since 
+     * there is no chance the cache is inconsistent, it is
+     * better to return SQLITE_BUSY.
+     */
+    rc = SQLITE_BUSY;
+  }
+  pagerLeave(pPager);
+  return rc;
+}
+
+
+/*
+** Commit all changes to the database and release the write lock.
+**
+** If the commit fails for any reason, a rollback attempt is made
+** and an error code is returned.  If the commit worked, SQLITE_OK
+** is returned.
+*/
+int sqlite3PagerCommitPhaseTwo(Pager *pPager){
+  int rc;
+  PgHdr *pPg;
+
+  if( pPager->errCode ){
+    return pPager->errCode;
+  }
+  if( pPager->state<PAGER_RESERVED ){
+    return SQLITE_ERROR;
+  }
+  pagerEnter(pPager);
+  PAGERTRACE2("COMMIT %d\n", PAGERID(pPager));
+  if( MEMDB ){
+    pPg = pager_get_all_dirty_pages(pPager);
+    while( pPg ){
+      PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+      clearHistory(pHist);
+      pPg->dirty = 0;
+      pPg->inJournal = 0;
+      pHist->inStmt = 0;
+      pPg->needSync = 0;
+      pHist->pPrevStmt = pHist->pNextStmt = 0;
+      pPg = pPg->pDirty;
+    }
+    pPager->pDirty = 0;
+#ifndef NDEBUG
+    for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+      PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+      assert( !pPg->alwaysRollback );
+      assert( !pHist->pOrig );
+      assert( !pHist->pStmt );
+    }
+#endif
+    pPager->pStmt = 0;
+    pPager->state = PAGER_SHARED;
+    pagerLeave(pPager);
+    return SQLITE_OK;
+  }
+  assert( pPager->journalOpen || !pPager->dirtyCache );
+  assert( pPager->state==PAGER_SYNCED || !pPager->dirtyCache );
+  rc = pager_end_transaction(pPager);
+  rc = pager_error(pPager, rc);
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Rollback all changes.  The database falls back to PAGER_SHARED mode.
+** All in-memory cache pages revert to their original data contents.
+** The journal is deleted.
+**
+** This routine cannot fail unless some other process is not following
+** the correct locking protocol or unless some other
+** process is writing trash into the journal file (SQLITE_CORRUPT) or
+** unless a prior malloc() failed (SQLITE_NOMEM).  Appropriate error
+** codes are returned for all these occasions.  Otherwise,
+** SQLITE_OK is returned.
+*/
+int sqlite3PagerRollback(Pager *pPager){
+  int rc;
+  PAGERTRACE2("ROLLBACK %d\n", PAGERID(pPager));
+  if( MEMDB ){
+    PgHdr *p;
+    for(p=pPager->pAll; p; p=p->pNextAll){
+      PgHistory *pHist;
+      assert( !p->alwaysRollback );
+      if( !p->dirty ){
+        assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pOrig );
+        assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pStmt );
+        continue;
+      }
+
+      pHist = PGHDR_TO_HIST(p, pPager);
+      if( pHist->pOrig ){
+        memcpy(PGHDR_TO_DATA(p), pHist->pOrig, pPager->pageSize);
+        PAGERTRACE3("ROLLBACK-PAGE %d of %d\n", p->pgno, PAGERID(pPager));
+      }else{
+        PAGERTRACE3("PAGE %d is clean on %d\n", p->pgno, PAGERID(pPager));
+      }
+      clearHistory(pHist);
+      p->dirty = 0;
+      p->inJournal = 0;
+      pHist->inStmt = 0;
+      pHist->pPrevStmt = pHist->pNextStmt = 0;
+      if( pPager->xReiniter ){
+        pPager->xReiniter(p, pPager->pageSize);
+      }
+    }
+    pPager->pDirty = 0;
+    pPager->pStmt = 0;
+    pPager->dbSize = pPager->origDbSize;
+    pager_truncate_cache(pPager);
+    pPager->stmtInUse = 0;
+    pPager->state = PAGER_SHARED;
+    return SQLITE_OK;
+  }
+
+  pagerEnter(pPager);
+  if( !pPager->dirtyCache || !pPager->journalOpen ){
+    rc = pager_end_transaction(pPager);
+    pagerLeave(pPager);
+    return rc;
+  }
+
+  if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
+    if( pPager->state>=PAGER_EXCLUSIVE ){
+      pager_playback(pPager, 0);
+    }
+    pagerLeave(pPager);
+    return pPager->errCode;
+  }
+  if( pPager->state==PAGER_RESERVED ){
+    int rc2;
+    rc = pager_playback(pPager, 0);
+    rc2 = pager_end_transaction(pPager);
+    if( rc==SQLITE_OK ){
+      rc = rc2;
+    }
+  }else{
+    rc = pager_playback(pPager, 0);
+  }
+  /* pager_reset(pPager); */
+  pPager->dbSize = -1;
+
+  /* If an error occurs during a ROLLBACK, we can no longer trust the pager
+  ** cache. So call pager_error() on the way out to make any error 
+  ** persistent.
+  */
+  rc = pager_error(pPager, rc);
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Return TRUE if the database file is opened read-only.  Return FALSE
+** if the database is (in theory) writable.
+*/
+int sqlite3PagerIsreadonly(Pager *pPager){
+  return pPager->readOnly;
+}
+
+/*
+** Return the number of references to the pager.
+*/
+int sqlite3PagerRefcount(Pager *pPager){
+  return pPager->nRef;
+}
+
+#ifdef SQLITE_TEST
+/*
+** This routine is used for testing and analysis only.
+*/
+int *sqlite3PagerStats(Pager *pPager){
+  static int a[11];
+  a[0] = pPager->nRef;
+  a[1] = pPager->nPage;
+  a[2] = pPager->mxPage;
+  a[3] = pPager->dbSize;
+  a[4] = pPager->state;
+  a[5] = pPager->errCode;
+  a[6] = pPager->nHit;
+  a[7] = pPager->nMiss;
+  a[8] = 0;  /* Used to be pPager->nOvfl */
+  a[9] = pPager->nRead;
+  a[10] = pPager->nWrite;
+  return a;
+}
+#endif
+
+/*
+** Set the statement rollback point.
+**
+** This routine should be called with the transaction journal already
+** open.  A new statement journal is created that can be used to rollback
+** changes of a single SQL command within a larger transaction.
+*/
+static int pagerStmtBegin(Pager *pPager){
+  int rc;
+  assert( !pPager->stmtInUse );
+  assert( pPager->state>=PAGER_SHARED );
+  assert( pPager->dbSize>=0 );
+  PAGERTRACE2("STMT-BEGIN %d\n", PAGERID(pPager));
+  if( MEMDB ){
+    pPager->stmtInUse = 1;
+    pPager->stmtSize = pPager->dbSize;
+    return SQLITE_OK;
+  }
+  if( !pPager->journalOpen ){
+    pPager->stmtAutoopen = 1;
+    return SQLITE_OK;
+  }
+  assert( pPager->journalOpen );
+  pagerLeave(pPager);
+  assert( pPager->aInStmt==0 );
+  pPager->aInStmt = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+  pagerEnter(pPager);
+  if( pPager->aInStmt==0 ){
+    /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */
+    return SQLITE_NOMEM;
+  }
+#ifndef NDEBUG
+  rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize);
+  if( rc ) goto stmt_begin_failed;
+  assert( pPager->stmtJSize == pPager->journalOff );
+#endif
+  pPager->stmtJSize = pPager->journalOff;
+  pPager->stmtSize = pPager->dbSize;
+  pPager->stmtHdrOff = 0;
+  pPager->stmtCksum = pPager->cksumInit;
+  if( !pPager->stmtOpen ){
+    rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->stfd, pPager->zStmtJrnl,
+                              SQLITE_OPEN_SUBJOURNAL);
+    if( rc ){
+      goto stmt_begin_failed;
+    }
+    pPager->stmtOpen = 1;
+    pPager->stmtNRec = 0;
+  }
+  pPager->stmtInUse = 1;
+  return SQLITE_OK;
+ 
+stmt_begin_failed:
+  if( pPager->aInStmt ){
+    sqlite3_free(pPager->aInStmt);
+    pPager->aInStmt = 0;
+  }
+  return rc;
+}
+int sqlite3PagerStmtBegin(Pager *pPager){
+  int rc;
+  pagerEnter(pPager);
+  rc = pagerStmtBegin(pPager);
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Commit a statement.
+*/
+int sqlite3PagerStmtCommit(Pager *pPager){
+  pagerEnter(pPager);
+  if( pPager->stmtInUse ){
+    PgHdr *pPg, *pNext;
+    PAGERTRACE2("STMT-COMMIT %d\n", PAGERID(pPager));
+    if( !MEMDB ){
+      /* sqlite3OsTruncate(pPager->stfd, 0); */
+      sqlite3_free( pPager->aInStmt );
+      pPager->aInStmt = 0;
+    }else{
+      for(pPg=pPager->pStmt; pPg; pPg=pNext){
+        PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager);
+        pNext = pHist->pNextStmt;
+        assert( pHist->inStmt );
+        pHist->inStmt = 0;
+        pHist->pPrevStmt = pHist->pNextStmt = 0;
+        sqlite3_free(pHist->pStmt);
+        pHist->pStmt = 0;
+      }
+    }
+    pPager->stmtNRec = 0;
+    pPager->stmtInUse = 0;
+    pPager->pStmt = 0;
+  }
+  pPager->stmtAutoopen = 0;
+  pagerLeave(pPager);
+  return SQLITE_OK;
+}
+
+/*
+** Rollback a statement.
+*/
+int sqlite3PagerStmtRollback(Pager *pPager){
+  int rc;
+  pagerEnter(pPager);
+  if( pPager->stmtInUse ){
+    PAGERTRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager));
+    if( MEMDB ){
+      PgHdr *pPg;
+      PgHistory *pHist;
+      for(pPg=pPager->pStmt; pPg; pPg=pHist->pNextStmt){
+        pHist = PGHDR_TO_HIST(pPg, pPager);
+        if( pHist->pStmt ){
+          memcpy(PGHDR_TO_DATA(pPg), pHist->pStmt, pPager->pageSize);
+          sqlite3_free(pHist->pStmt);
+          pHist->pStmt = 0;
+        }
+      }
+      pPager->dbSize = pPager->stmtSize;
+      pager_truncate_cache(pPager);
+      rc = SQLITE_OK;
+    }else{
+      rc = pager_stmt_playback(pPager);
+    }
+    sqlite3PagerStmtCommit(pPager);
+  }else{
+    rc = SQLITE_OK;
+  }
+  pPager->stmtAutoopen = 0;
+  pagerLeave(pPager);
+  return rc;
+}
+
+/*
+** Return the full pathname of the database file.
+*/
+const char *sqlite3PagerFilename(Pager *pPager){
+  return pPager->zFilename;
+}
+
+/*
+** Return the VFS structure for the pager.
+*/
+const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
+  return pPager->pVfs;
+}
+
+/*
+** Return the file handle for the database file associated
+** with the pager.  This might return NULL if the file has
+** not yet been opened.
+*/
+sqlite3_file *sqlite3PagerFile(Pager *pPager){
+  return pPager->fd;
+}
+
+/*
+** Return the directory of the database file.
+*/
+const char *sqlite3PagerDirname(Pager *pPager){
+  return pPager->zDirectory;
+}
+
+/*
+** Return the full pathname of the journal file.
+*/
+const char *sqlite3PagerJournalname(Pager *pPager){
+  return pPager->zJournal;
+}
+
+/*
+** Return true if fsync() calls are disabled for this pager.  Return FALSE
+** if fsync()s are executed normally.
+*/
+int sqlite3PagerNosync(Pager *pPager){
+  return pPager->noSync;
+}
+
+#ifdef SQLITE_HAS_CODEC
+/*
+** Set the codec for this pager
+*/
+void sqlite3PagerSetCodec(
+  Pager *pPager,
+  void *(*xCodec)(void*,void*,Pgno,int),
+  void *pCodecArg
+){
+  pPager->xCodec = xCodec;
+  pPager->pCodecArg = pCodecArg;
+}
+#endif
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+/*
+** Move the page pPg to location pgno in the file.
+**
+** There must be no references to the page previously located at
+** pgno (which we call pPgOld) though that page is allowed to be
+** in cache.  If the page previous located at pgno is not already
+** in the rollback journal, it is not put there by by this routine.
+**
+** References to the page pPg remain valid. Updating any
+** meta-data associated with pPg (i.e. data stored in the nExtra bytes
+** allocated along with the page) is the responsibility of the caller.
+**
+** A transaction must be active when this routine is called. It used to be
+** required that a statement transaction was not active, but this restriction
+** has been removed (CREATE INDEX needs to move a page when a statement
+** transaction is active).
+*/
+int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno){
+  PgHdr *pPgOld;  /* The page being overwritten. */
+  int h;
+  Pgno needSyncPgno = 0;
+
+  pagerEnter(pPager);
+  assert( pPg->nRef>0 );
+
+  PAGERTRACE5("MOVE %d page %d (needSync=%d) moves to %d\n", 
+      PAGERID(pPager), pPg->pgno, pPg->needSync, pgno);
+  IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
+
+  pager_get_content(pPg);
+  if( pPg->needSync ){
+    needSyncPgno = pPg->pgno;
+    assert( pPg->inJournal || (int)pgno>pPager->origDbSize );
+    assert( pPg->dirty );
+    assert( pPager->needSync );
+  }
+
+  /* Unlink pPg from its hash-chain */
+  unlinkHashChain(pPager, pPg);
+
+  /* If the cache contains a page with page-number pgno, remove it
+  ** from its hash chain. Also, if the PgHdr.needSync was set for 
+  ** page pgno before the 'move' operation, it needs to be retained 
+  ** for the page moved there.
+  */
+  pPg->needSync = 0;
+  pPgOld = pager_lookup(pPager, pgno);
+  if( pPgOld ){
+    assert( pPgOld->nRef==0 );
+    unlinkHashChain(pPager, pPgOld);
+    makeClean(pPgOld);
+    pPg->needSync = pPgOld->needSync;
+  }else{
+    pPg->needSync = 0;
+  }
+  if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
+    pPg->inJournal =  (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
+  }else{
+    pPg->inJournal = 0;
+    assert( pPg->needSync==0 || (int)pgno>pPager->origDbSize );
+  }
+
+  /* Change the page number for pPg and insert it into the new hash-chain. */
+  assert( pgno!=0 );
+  pPg->pgno = pgno;
+  h = pgno & (pPager->nHash-1);
+  if( pPager->aHash[h] ){
+    assert( pPager->aHash[h]->pPrevHash==0 );
+    pPager->aHash[h]->pPrevHash = pPg;
+  }
+  pPg->pNextHash = pPager->aHash[h];
+  pPager->aHash[h] = pPg;
+  pPg->pPrevHash = 0;
+
+  makeDirty(pPg);
+  pPager->dirtyCache = 1;
+
+  if( needSyncPgno ){
+    /* If needSyncPgno is non-zero, then the journal file needs to be 
+    ** sync()ed before any data is written to database file page needSyncPgno.
+    ** Currently, no such page exists in the page-cache and the 
+    ** Pager.aInJournal bit has been set. This needs to be remedied by loading
+    ** the page into the pager-cache and setting the PgHdr.needSync flag.
+    **
+    ** If the attempt to load the page into the page-cache fails, (due
+    ** to a malloc() or IO failure), clear the bit in the aInJournal[]
+    ** array. Otherwise, if the page is loaded and written again in
+    ** this transaction, it may be written to the database file before
+    ** it is synced into the journal file. This way, it may end up in
+    ** the journal file twice, but that is not a problem.
+    **
+    ** The sqlite3PagerGet() call may cause the journal to sync. So make
+    ** sure the Pager.needSync flag is set too.
+    */
+    int rc;
+    PgHdr *pPgHdr;
+    assert( pPager->needSync );
+    rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
+    if( rc!=SQLITE_OK ){
+      if( pPager->aInJournal && (int)needSyncPgno<=pPager->origDbSize ){
+        pPager->aInJournal[needSyncPgno/8] &= ~(1<<(needSyncPgno&7));
+      }
+      pagerLeave(pPager);
+      return rc;
+    }
+    pPager->needSync = 1;
+    pPgHdr->needSync = 1;
+    pPgHdr->inJournal = 1;
+    makeDirty(pPgHdr);
+    sqlite3PagerUnref(pPgHdr);
+  }
+
+  pagerLeave(pPager);
+  return SQLITE_OK;
+}
+#endif
+
+/*
+** Return a pointer to the data for the specified page.
+*/
+void *sqlite3PagerGetData(DbPage *pPg){
+  return PGHDR_TO_DATA(pPg);
+}
+
+/*
+** Return a pointer to the Pager.nExtra bytes of "extra" space 
+** allocated along with the specified page.
+*/
+void *sqlite3PagerGetExtra(DbPage *pPg){
+  Pager *pPager = pPg->pPager;
+  return (pPager?PGHDR_TO_EXTRA(pPg, pPager):0);
+}
+
+/*
+** Get/set the locking-mode for this pager. Parameter eMode must be one
+** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or 
+** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
+** the locking-mode is set to the value specified.
+**
+** The returned value is either PAGER_LOCKINGMODE_NORMAL or
+** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
+** locking-mode.
+*/
+int sqlite3PagerLockingMode(Pager *pPager, int eMode){
+  assert( eMode==PAGER_LOCKINGMODE_QUERY
+            || eMode==PAGER_LOCKINGMODE_NORMAL
+            || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
+  assert( PAGER_LOCKINGMODE_QUERY<0 );
+  assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
+  if( eMode>=0 && !pPager->tempFile ){
+    pPager->exclusiveMode = eMode;
+  }
+  return (int)pPager->exclusiveMode;
+}
+
+#ifdef SQLITE_TEST
+/*
+** Print a listing of all referenced pages and their ref count.
+*/
+void sqlite3PagerRefdump(Pager *pPager){
+  PgHdr *pPg;
+  for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
+    if( pPg->nRef<=0 ) continue;
+    sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%d\n", 
+       pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef);
+  }
+}
+#endif
+
+#endif /* SQLITE_OMIT_DISKIO */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/pager.h b/client/src/thirdparty/sqlite-3.4.2/src/pager.h
new file mode 100644
index 0000000..c864a15
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/pager.h
@@ -0,0 +1,125 @@
+/*
+** 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.
+**
+*************************************************************************
+** 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.69 2008/02/02 20:47:38 drh Exp $
+*/
+
+#ifndef _PAGER_H_
+#define _PAGER_H_
+
+/*
+** The type used to represent a page number.  The first page in a file
+** is called page 1.  0 is used to represent "not a page".
+*/
+typedef unsigned int Pgno;
+
+/*
+** Each open file is managed by a separate instance of the "Pager" structure.
+*/
+typedef struct Pager Pager;
+
+/*
+** Handle type for pages.
+*/
+typedef struct PgHdr DbPage;
+
+/*
+** Allowed values for the flags parameter to sqlite3PagerOpen().
+**
+** NOTE: This values must match the corresponding BTREE_ values in btree.h.
+*/
+#define PAGER_OMIT_JOURNAL  0x0001    /* Do not use a rollback journal */
+#define PAGER_NO_READLOCK   0x0002    /* Omit readlocks on readonly files */
+
+/*
+** Valid values for the second argument to sqlite3PagerLockingMode().
+*/
+#define PAGER_LOCKINGMODE_QUERY      -1
+#define PAGER_LOCKINGMODE_NORMAL      0
+#define PAGER_LOCKINGMODE_EXCLUSIVE   1
+
+/*
+** See source code comments for a detailed description of the following
+** routines:
+*/
+int sqlite3PagerOpen(sqlite3_vfs *, Pager **ppPager, const char*, int,int,int);
+void sqlite3PagerSetBusyhandler(Pager*, BusyHandler *pBusyHandler);
+void sqlite3PagerSetDestructor(Pager*, void(*)(DbPage*,int));
+void sqlite3PagerSetReiniter(Pager*, void(*)(DbPage*,int));
+int sqlite3PagerSetPagesize(Pager*, u16*);
+int sqlite3PagerMaxPageCount(Pager*, int);
+int sqlite3PagerReadFileheader(Pager*, int, unsigned char*);
+void sqlite3PagerSetCachesize(Pager*, int);
+int sqlite3PagerClose(Pager *pPager);
+int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
+#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0)
+DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
+int sqlite3PagerRef(DbPage*);
+int sqlite3PagerUnref(DbPage*);
+int sqlite3PagerWrite(DbPage*);
+int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void*);
+int sqlite3PagerPagecount(Pager*);
+int sqlite3PagerTruncate(Pager*,Pgno);
+int sqlite3PagerBegin(DbPage*, int exFlag);
+int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, Pgno);
+int sqlite3PagerCommitPhaseTwo(Pager*);
+int sqlite3PagerRollback(Pager*);
+int sqlite3PagerIsreadonly(Pager*);
+int sqlite3PagerStmtBegin(Pager*);
+int sqlite3PagerStmtCommit(Pager*);
+int sqlite3PagerStmtRollback(Pager*);
+void sqlite3PagerDontRollback(DbPage*);
+void sqlite3PagerDontWrite(DbPage*);
+int sqlite3PagerRefcount(Pager*);
+void sqlite3PagerSetSafetyLevel(Pager*,int,int);
+const char *sqlite3PagerFilename(Pager*);
+const sqlite3_vfs *sqlite3PagerVfs(Pager*);
+sqlite3_file *sqlite3PagerFile(Pager*);
+const char *sqlite3PagerDirname(Pager*);
+const char *sqlite3PagerJournalname(Pager*);
+int sqlite3PagerNosync(Pager*);
+int sqlite3PagerMovepage(Pager*,DbPage*,Pgno);
+void *sqlite3PagerGetData(DbPage *); 
+void *sqlite3PagerGetExtra(DbPage *); 
+int sqlite3PagerLockingMode(Pager *, int);
+void *sqlite3PagerTempSpace(Pager*);
+
+#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
+  int sqlite3PagerReleaseMemory(int);
+#endif
+
+#ifdef SQLITE_HAS_CODEC
+  void sqlite3PagerSetCodec(Pager*,void*(*)(void*,void*,Pgno,int),void*);
+#endif
+
+#if !defined(NDEBUG) || defined(SQLITE_TEST)
+  Pgno sqlite3PagerPagenumber(DbPage*);
+  int sqlite3PagerIswriteable(DbPage*);
+#endif
+
+#ifdef SQLITE_TEST
+  int *sqlite3PagerStats(Pager*);
+  void sqlite3PagerRefdump(Pager*);
+#endif
+
+#ifdef SQLITE_TEST
+void disable_simulated_io_errors(void);
+void enable_simulated_io_errors(void);
+#else
+# define disable_simulated_io_errors()
+# define enable_simulated_io_errors()
+#endif
+
+#endif /* _PAGER_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/parse.y b/client/src/thirdparty/sqlite-3.4.2/src/parse.y
new file mode 100644
index 0000000..7766341
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/parse.y
@@ -0,0 +1,1114 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains SQLite's grammar for SQL.  Process this file
+** using the lemon parser generator to generate C code that runs
+** the parser.  Lemon will also generate a header file containing
+** numeric codes for all of the tokens.
+**
+** @(#) $Id: parse.y,v 1.240 2008/01/22 23:37:10 drh Exp $
+*/
+
+// All token codes are small integers with #defines that begin with "TK_"
+%token_prefix TK_
+
+// The type of the data attached to each token is Token.  This is also the
+// default type for non-terminals.
+//
+%token_type {Token}
+%default_type {Token}
+
+// The generated parser function takes a 4th argument as follows:
+%extra_argument {Parse *pParse}
+
+// This code runs whenever there is a syntax error
+//
+%syntax_error {
+  assert( TOKEN.z[0] );  /* The tokenizer always gives us a token */
+  sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
+  pParse->parseError = 1;
+}
+%stack_overflow {
+  sqlite3ErrorMsg(pParse, "parser stack overflow");
+  pParse->parseError = 1;
+}
+
+// The name of the generated procedure that implements the parser
+// is as follows:
+%name sqlite3Parser
+
+// The following text is included near the beginning of the C source
+// code file that implements the parser.
+//
+%include {
+#include "sqliteInt.h"
+
+/*
+** An instance of this structure holds information about the
+** LIMIT clause of a SELECT statement.
+*/
+struct LimitVal {
+  Expr *pLimit;    /* The LIMIT expression.  NULL if there is no limit */
+  Expr *pOffset;   /* The OFFSET expression.  NULL if there is none */
+};
+
+/*
+** An instance of this structure is used to store the LIKE,
+** GLOB, NOT LIKE, and NOT GLOB operators.
+*/
+struct LikeOp {
+  Token eOperator;  /* "like" or "glob" or "regexp" */
+  int not;         /* True if the NOT keyword is present */
+};
+
+/*
+** An instance of the following structure describes the event of a
+** TRIGGER.  "a" is the event type, one of TK_UPDATE, TK_INSERT,
+** TK_DELETE, or TK_INSTEAD.  If the event is of the form
+**
+**      UPDATE ON (a,b,c)
+**
+** Then the "b" IdList records the list "a,b,c".
+*/
+struct TrigEvent { int a; IdList * b; };
+
+/*
+** An instance of this structure holds the ATTACH key and the key type.
+*/
+struct AttachKey { int type;  Token key; };
+
+} // end %include
+
+// Input is a single SQL command
+input ::= cmdlist.
+cmdlist ::= cmdlist ecmd.
+cmdlist ::= ecmd.
+cmdx ::= cmd.           { sqlite3FinishCoding(pParse); }
+ecmd ::= SEMI.
+ecmd ::= explain cmdx SEMI.
+explain ::= .           { sqlite3BeginParse(pParse, 0); }
+%ifndef SQLITE_OMIT_EXPLAIN
+explain ::= EXPLAIN.              { sqlite3BeginParse(pParse, 1); }
+explain ::= EXPLAIN QUERY PLAN.   { sqlite3BeginParse(pParse, 2); }
+%endif  SQLITE_OMIT_EXPLAIN
+
+///////////////////// Begin and end transactions. ////////////////////////////
+//
+
+cmd ::= BEGIN transtype(Y) trans_opt.  {sqlite3BeginTransaction(pParse, Y);}
+trans_opt ::= .
+trans_opt ::= TRANSACTION.
+trans_opt ::= TRANSACTION nm.
+%type transtype {int}
+transtype(A) ::= .             {A = TK_DEFERRED;}
+transtype(A) ::= DEFERRED(X).  {A = @X;}
+transtype(A) ::= IMMEDIATE(X). {A = @X;}
+transtype(A) ::= EXCLUSIVE(X). {A = @X;}
+cmd ::= COMMIT trans_opt.      {sqlite3CommitTransaction(pParse);}
+cmd ::= END trans_opt.         {sqlite3CommitTransaction(pParse);}
+cmd ::= ROLLBACK trans_opt.    {sqlite3RollbackTransaction(pParse);}
+
+///////////////////// The CREATE TABLE statement ////////////////////////////
+//
+cmd ::= create_table create_table_args.
+create_table ::= CREATE temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {
+   sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);
+}
+%type ifnotexists {int}
+ifnotexists(A) ::= .              {A = 0;}
+ifnotexists(A) ::= IF NOT EXISTS. {A = 1;}
+%type temp {int}
+%ifndef SQLITE_OMIT_TEMPDB
+temp(A) ::= TEMP.  {A = 1;}
+%endif  SQLITE_OMIT_TEMPDB
+temp(A) ::= .      {A = 0;}
+create_table_args ::= LP columnlist conslist_opt(X) RP(Y). {
+  sqlite3EndTable(pParse,&X,&Y,0);
+}
+create_table_args ::= AS select(S). {
+  sqlite3EndTable(pParse,0,0,S);
+  sqlite3SelectDelete(S);
+}
+columnlist ::= columnlist COMMA column.
+columnlist ::= column.
+
+// A "column" is a complete description of a single column in a
+// CREATE TABLE statement.  This includes the column name, its
+// datatype, and other keywords such as PRIMARY KEY, UNIQUE, REFERENCES,
+// NOT NULL and so forth.
+//
+column(A) ::= columnid(X) type carglist. {
+  A.z = X.z;
+  A.n = (pParse->sLastToken.z-X.z) + pParse->sLastToken.n;
+}
+columnid(A) ::= nm(X). {
+  sqlite3AddColumn(pParse,&X);
+  A = X;
+}
+
+
+// An IDENTIFIER can be a generic identifier, or one of several
+// keywords.  Any non-standard keyword can also be an identifier.
+//
+%type id {Token}
+id(A) ::= ID(X).         {A = X;}
+
+// The following directive causes tokens ABORT, AFTER, ASC, etc. to
+// fallback to ID if they will not parse as their original value.
+// This obviates the need for the "id" nonterminal.
+//
+%fallback ID
+  ABORT AFTER ANALYZE ASC ATTACH BEFORE BEGIN CASCADE CAST CONFLICT
+  DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR
+  IGNORE IMMEDIATE INITIALLY INSTEAD LIKE_KW MATCH PLAN
+  QUERY KEY OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW
+  TEMP TRIGGER VACUUM VIEW VIRTUAL
+%ifdef SQLITE_OMIT_COMPOUND_SELECT
+  EXCEPT INTERSECT UNION
+%endif SQLITE_OMIT_COMPOUND_SELECT
+  REINDEX RENAME CTIME_KW IF
+  .
+%wildcard ANY.
+
+// Define operator precedence early so that this is the first occurance
+// of the operator tokens in the grammer.  Keeping the operators together
+// causes them to be assigned integer values that are close together,
+// which keeps parser tables smaller.
+//
+// The token values assigned to these symbols is determined by the order
+// in which lemon first sees them.  It must be the case that ISNULL/NOTNULL,
+// NE/EQ, GT/LE, and GE/LT are separated by only a single value.  See
+// the sqlite3ExprIfFalse() routine for additional information on this
+// constraint.
+//
+%left OR.
+%left AND.
+%right NOT.
+%left IS MATCH LIKE_KW BETWEEN IN ISNULL NOTNULL NE EQ.
+%left GT LE LT GE.
+%right ESCAPE.
+%left BITAND BITOR LSHIFT RSHIFT.
+%left PLUS MINUS.
+%left STAR SLASH REM.
+%left CONCAT.
+%left COLLATE.
+%right UMINUS UPLUS BITNOT.
+
+// And "ids" is an identifer-or-string.
+//
+%type ids {Token}
+ids(A) ::= ID|STRING(X).   {A = X;}
+
+// The name of a column or table can be any of the following:
+//
+%type nm {Token}
+nm(A) ::= ID(X).         {A = X;}
+nm(A) ::= STRING(X).     {A = X;}
+nm(A) ::= JOIN_KW(X).    {A = X;}
+
+// A typetoken is really one or more tokens that form a type name such
+// as can be found after the column name in a CREATE TABLE statement.
+// Multiple tokens are concatenated to form the value of the typetoken.
+//
+%type typetoken {Token}
+type ::= .
+type ::= typetoken(X).                   {sqlite3AddColumnType(pParse,&X);}
+typetoken(A) ::= typename(X).   {A = X;}
+typetoken(A) ::= typename(X) LP signed RP(Y). {
+  A.z = X.z;
+  A.n = &Y.z[Y.n] - X.z;
+}
+typetoken(A) ::= typename(X) LP signed COMMA signed RP(Y). {
+  A.z = X.z;
+  A.n = &Y.z[Y.n] - X.z;
+}
+%type typename {Token}
+typename(A) ::= ids(X).             {A = X;}
+typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(Y.z-X.z);}
+signed ::= plus_num.
+signed ::= minus_num.
+
+// "carglist" is a list of additional constraints that come after the
+// column name and column type in a CREATE TABLE statement.
+//
+carglist ::= carglist carg.
+carglist ::= .
+carg ::= CONSTRAINT nm ccons.
+carg ::= ccons.
+ccons ::= DEFAULT term(X).            {sqlite3AddDefaultValue(pParse,X);}
+ccons ::= DEFAULT LP expr(X) RP.      {sqlite3AddDefaultValue(pParse,X);}
+ccons ::= DEFAULT PLUS term(X).       {sqlite3AddDefaultValue(pParse,X);}
+ccons ::= DEFAULT MINUS term(X).      {
+  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);
+  sqlite3AddDefaultValue(pParse,p);
+}
+ccons ::= DEFAULT id(X).              {
+  Expr *p = sqlite3PExpr(pParse, TK_STRING, 0, 0, &X);
+  sqlite3AddDefaultValue(pParse,p);
+}
+
+// In addition to the type name, we also care about the primary key and
+// UNIQUE constraints.
+//
+ccons ::= NULL onconf.
+ccons ::= NOT NULL onconf(R).               {sqlite3AddNotNull(pParse, R);}
+ccons ::= PRIMARY KEY sortorder(Z) onconf(R) autoinc(I).
+                                     {sqlite3AddPrimaryKey(pParse,0,R,I,Z);}
+ccons ::= UNIQUE onconf(R).    {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0,0,0);}
+ccons ::= CHECK LP expr(X) RP.       {sqlite3AddCheckConstraint(pParse,X);}
+ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
+                                {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
+ccons ::= defer_subclause(D).   {sqlite3DeferForeignKey(pParse,D);}
+ccons ::= COLLATE ids(C).  {sqlite3AddCollateType(pParse, &C);}
+
+// The optional AUTOINCREMENT keyword
+%type autoinc {int}
+autoinc(X) ::= .          {X = 0;}
+autoinc(X) ::= AUTOINCR.  {X = 1;}
+
+// The next group of rules parses the arguments to a REFERENCES clause
+// that determine if the referential integrity checking is deferred or
+// or immediate and which determine what action to take if a ref-integ
+// check fails.
+//
+%type refargs {int}
+refargs(A) ::= .                     { A = OE_Restrict * 0x010101; }
+refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; }
+%type refarg {struct {int value; int mask;}}
+refarg(A) ::= MATCH nm.              { A.value = 0;     A.mask = 0x000000; }
+refarg(A) ::= ON DELETE refact(X).   { A.value = X;     A.mask = 0x0000ff; }
+refarg(A) ::= ON UPDATE refact(X).   { A.value = X<<8;  A.mask = 0x00ff00; }
+refarg(A) ::= ON INSERT refact(X).   { A.value = X<<16; A.mask = 0xff0000; }
+%type refact {int}
+refact(A) ::= SET NULL.              { A = OE_SetNull; }
+refact(A) ::= SET DEFAULT.           { A = OE_SetDflt; }
+refact(A) ::= CASCADE.               { A = OE_Cascade; }
+refact(A) ::= RESTRICT.              { A = OE_Restrict; }
+%type defer_subclause {int}
+defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X).  {A = X;}
+defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X).      {A = X;}
+%type init_deferred_pred_opt {int}
+init_deferred_pred_opt(A) ::= .                       {A = 0;}
+init_deferred_pred_opt(A) ::= INITIALLY DEFERRED.     {A = 1;}
+init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE.    {A = 0;}
+
+// For the time being, the only constraint we care about is the primary
+// key and UNIQUE.  Both create indices.
+//
+conslist_opt(A) ::= .                   {A.n = 0; A.z = 0;}
+conslist_opt(A) ::= COMMA(X) conslist.  {A = X;}
+conslist ::= conslist COMMA tcons.
+conslist ::= conslist tcons.
+conslist ::= tcons.
+tcons ::= CONSTRAINT nm.
+tcons ::= PRIMARY KEY LP idxlist(X) autoinc(I) RP onconf(R).
+                                         {sqlite3AddPrimaryKey(pParse,X,R,I,0);}
+tcons ::= UNIQUE LP idxlist(X) RP onconf(R).
+                                 {sqlite3CreateIndex(pParse,0,0,0,X,R,0,0,0,0);}
+tcons ::= CHECK LP expr(E) RP onconf. {sqlite3AddCheckConstraint(pParse,E);}
+tcons ::= FOREIGN KEY LP idxlist(FA) RP
+          REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). {
+    sqlite3CreateForeignKey(pParse, FA, &T, TA, R);
+    sqlite3DeferForeignKey(pParse, D);
+}
+%type defer_subclause_opt {int}
+defer_subclause_opt(A) ::= .                    {A = 0;}
+defer_subclause_opt(A) ::= defer_subclause(X).  {A = X;}
+
+// The following is a non-standard extension that allows us to declare the
+// default behavior when there is a constraint conflict.
+//
+%type onconf {int}
+%type orconf {int}
+%type resolvetype {int}
+onconf(A) ::= .                              {A = OE_Default;}
+onconf(A) ::= ON CONFLICT resolvetype(X).    {A = X;}
+orconf(A) ::= .                              {A = OE_Default;}
+orconf(A) ::= OR resolvetype(X).             {A = X;}
+resolvetype(A) ::= raisetype(X).             {A = X;}
+resolvetype(A) ::= IGNORE.                   {A = OE_Ignore;}
+resolvetype(A) ::= REPLACE.                  {A = OE_Replace;}
+
+////////////////////////// The DROP TABLE /////////////////////////////////////
+//
+cmd ::= DROP TABLE ifexists(E) fullname(X). {
+  sqlite3DropTable(pParse, X, 0, E);
+}
+%type ifexists {int}
+ifexists(A) ::= IF EXISTS.   {A = 1;}
+ifexists(A) ::= .            {A = 0;}
+
+///////////////////// The CREATE VIEW statement /////////////////////////////
+//
+%ifndef SQLITE_OMIT_VIEW
+cmd ::= CREATE(X) temp(T) VIEW ifnotexists(E) nm(Y) dbnm(Z) AS select(S). {
+  sqlite3CreateView(pParse, &X, &Y, &Z, S, T, E);
+}
+cmd ::= DROP VIEW ifexists(E) fullname(X). {
+  sqlite3DropTable(pParse, X, 1, E);
+}
+%endif  SQLITE_OMIT_VIEW
+
+//////////////////////// The SELECT statement /////////////////////////////////
+//
+cmd ::= select(X).  {
+  SelectDest dest = {SRT_Callback, 0, 0};
+  sqlite3Select(pParse, X, &dest, 0, 0, 0, 0);
+  sqlite3SelectDelete(X);
+}
+
+%type select {Select*}
+%destructor select {sqlite3SelectDelete($$);}
+%type oneselect {Select*}
+%destructor oneselect {sqlite3SelectDelete($$);}
+
+select(A) ::= oneselect(X).                      {A = X;}
+%ifndef SQLITE_OMIT_COMPOUND_SELECT
+select(A) ::= select(X) multiselect_op(Y) oneselect(Z).  {
+  if( Z ){
+    Z->op = Y;
+    Z->pPrior = X;
+  }else{
+    sqlite3SelectDelete(X);
+  }
+  A = Z;
+}
+%type multiselect_op {int}
+multiselect_op(A) ::= UNION(OP).             {A = @OP;}
+multiselect_op(A) ::= UNION ALL.             {A = TK_ALL;}
+multiselect_op(A) ::= EXCEPT|INTERSECT(OP).  {A = @OP;}
+%endif SQLITE_OMIT_COMPOUND_SELECT
+oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y)
+                 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
+  A = sqlite3SelectNew(pParse,W,X,Y,P,Q,Z,D,L.pLimit,L.pOffset);
+}
+
+// The "distinct" nonterminal is true (1) if the DISTINCT keyword is
+// present and false (0) if it is not.
+//
+%type distinct {int}
+distinct(A) ::= DISTINCT.   {A = 1;}
+distinct(A) ::= ALL.        {A = 0;}
+distinct(A) ::= .           {A = 0;}
+
+// selcollist is a list of expressions that are to become the return
+// values of the SELECT statement.  The "*" in statements like
+// "SELECT * FROM ..." is encoded as a special expression with an
+// opcode of TK_ALL.
+//
+%type selcollist {ExprList*}
+%destructor selcollist {sqlite3ExprListDelete($$);}
+%type sclp {ExprList*}
+%destructor sclp {sqlite3ExprListDelete($$);}
+sclp(A) ::= selcollist(X) COMMA.             {A = X;}
+sclp(A) ::= .                                {A = 0;}
+selcollist(A) ::= sclp(P) expr(X) as(Y).     {
+   A = sqlite3ExprListAppend(pParse,P,X,Y.n?&Y:0);
+}
+selcollist(A) ::= sclp(P) STAR. {
+  Expr *p = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);
+  A = sqlite3ExprListAppend(pParse, P, p, 0);
+}
+selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
+  Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);
+  Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
+  Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
+  A = sqlite3ExprListAppend(pParse,P, pDot, 0);
+}
+
+// An option "AS <id>" phrase that can follow one of the expressions that
+// define the result set, or one of the tables in the FROM clause.
+//
+%type as {Token}
+as(X) ::= AS nm(Y).    {X = Y;}
+as(X) ::= ids(Y).      {X = Y;}
+as(X) ::= .            {X.n = 0;}
+
+
+%type seltablist {SrcList*}
+%destructor seltablist {sqlite3SrcListDelete($$);}
+%type stl_prefix {SrcList*}
+%destructor stl_prefix {sqlite3SrcListDelete($$);}
+%type from {SrcList*}
+%destructor from {sqlite3SrcListDelete($$);}
+
+// A complete FROM clause.
+//
+from(A) ::= .                {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
+from(A) ::= FROM seltablist(X).  {
+  A = X;
+  sqlite3SrcListShiftJoinType(A);
+}
+
+// "seltablist" is a "Select Table List" - the content of the FROM clause
+// in a SELECT statement.  "stl_prefix" is a prefix of this list.
+//
+stl_prefix(A) ::= seltablist(X) joinop(Y).    {
+   A = X;
+   if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y;
+}
+stl_prefix(A) ::= .                           {A = 0;}
+seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). {
+  A = sqlite3SrcListAppendFromTerm(pParse,X,&Y,&D,&Z,0,N,U);
+}
+%ifndef SQLITE_OMIT_SUBQUERY
+  seltablist(A) ::= stl_prefix(X) LP seltablist_paren(S) RP
+                    as(Z) on_opt(N) using_opt(U). {
+    A = sqlite3SrcListAppendFromTerm(pParse,X,0,0,&Z,S,N,U);
+  }
+  
+  // A seltablist_paren nonterminal represents anything in a FROM that
+  // is contained inside parentheses.  This can be either a subquery or
+  // a grouping of table and subqueries.
+  //
+  %type seltablist_paren {Select*}
+  %destructor seltablist_paren {sqlite3SelectDelete($$);}
+  seltablist_paren(A) ::= select(S).      {A = S;}
+  seltablist_paren(A) ::= seltablist(F).  {
+     sqlite3SrcListShiftJoinType(F);
+     A = sqlite3SelectNew(pParse,0,F,0,0,0,0,0,0,0);
+  }
+%endif  SQLITE_OMIT_SUBQUERY
+
+%type dbnm {Token}
+dbnm(A) ::= .          {A.z=0; A.n=0;}
+dbnm(A) ::= DOT nm(X). {A = X;}
+
+%type fullname {SrcList*}
+%destructor fullname {sqlite3SrcListDelete($$);}
+fullname(A) ::= nm(X) dbnm(Y).  {A = sqlite3SrcListAppend(pParse->db,0,&X,&Y);}
+
+%type joinop {int}
+%type joinop2 {int}
+joinop(X) ::= COMMA|JOIN.              { X = JT_INNER; }
+joinop(X) ::= JOIN_KW(A) JOIN.         { X = sqlite3JoinType(pParse,&A,0,0); }
+joinop(X) ::= JOIN_KW(A) nm(B) JOIN.   { X = sqlite3JoinType(pParse,&A,&B,0); }
+joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN.
+                                       { X = sqlite3JoinType(pParse,&A,&B,&C); }
+
+%type on_opt {Expr*}
+%destructor on_opt {sqlite3ExprDelete($$);}
+on_opt(N) ::= ON expr(E).   {N = E;}
+on_opt(N) ::= .             {N = 0;}
+
+%type using_opt {IdList*}
+%destructor using_opt {sqlite3IdListDelete($$);}
+using_opt(U) ::= USING LP inscollist(L) RP.  {U = L;}
+using_opt(U) ::= .                        {U = 0;}
+
+
+%type orderby_opt {ExprList*}
+%destructor orderby_opt {sqlite3ExprListDelete($$);}
+%type sortlist {ExprList*}
+%destructor sortlist {sqlite3ExprListDelete($$);}
+%type sortitem {Expr*}
+%destructor sortitem {sqlite3ExprDelete($$);}
+
+orderby_opt(A) ::= .                          {A = 0;}
+orderby_opt(A) ::= ORDER BY sortlist(X).      {A = X;}
+sortlist(A) ::= sortlist(X) COMMA sortitem(Y) sortorder(Z). {
+  A = sqlite3ExprListAppend(pParse,X,Y,0);
+  if( A ) A->a[A->nExpr-1].sortOrder = Z;
+}
+sortlist(A) ::= sortitem(Y) sortorder(Z). {
+  A = sqlite3ExprListAppend(pParse,0,Y,0);
+  if( A && A->a ) A->a[0].sortOrder = Z;
+}
+sortitem(A) ::= expr(X).   {A = X;}
+
+%type sortorder {int}
+
+sortorder(A) ::= ASC.           {A = SQLITE_SO_ASC;}
+sortorder(A) ::= DESC.          {A = SQLITE_SO_DESC;}
+sortorder(A) ::= .              {A = SQLITE_SO_ASC;}
+
+%type groupby_opt {ExprList*}
+%destructor groupby_opt {sqlite3ExprListDelete($$);}
+groupby_opt(A) ::= .                      {A = 0;}
+groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;}
+
+%type having_opt {Expr*}
+%destructor having_opt {sqlite3ExprDelete($$);}
+having_opt(A) ::= .                {A = 0;}
+having_opt(A) ::= HAVING expr(X).  {A = X;}
+
+%type limit_opt {struct LimitVal}
+
+// The destructor for limit_opt will never fire in the current grammar.
+// The limit_opt non-terminal only occurs at the end of a single production
+// rule for SELECT statements.  As soon as the rule that create the 
+// limit_opt non-terminal reduces, the SELECT statement rule will also
+// reduce.  So there is never a limit_opt non-terminal on the stack 
+// except as a transient.  So there is never anything to destroy.
+//
+//%destructor limit_opt {
+//  sqlite3ExprDelete($$.pLimit);
+//  sqlite3ExprDelete($$.pOffset);
+//}
+limit_opt(A) ::= .                     {A.pLimit = 0; A.pOffset = 0;}
+limit_opt(A) ::= LIMIT expr(X).        {A.pLimit = X; A.pOffset = 0;}
+limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y). 
+                                       {A.pLimit = X; A.pOffset = Y;}
+limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y). 
+                                       {A.pOffset = X; A.pLimit = Y;}
+
+/////////////////////////// The DELETE statement /////////////////////////////
+//
+cmd ::= DELETE FROM fullname(X) where_opt(Y). {sqlite3DeleteFrom(pParse,X,Y);}
+
+%type where_opt {Expr*}
+%destructor where_opt {sqlite3ExprDelete($$);}
+
+where_opt(A) ::= .                    {A = 0;}
+where_opt(A) ::= WHERE expr(X).       {A = X;}
+
+////////////////////////// The UPDATE command ////////////////////////////////
+//
+cmd ::= UPDATE orconf(R) fullname(X) SET setlist(Y) where_opt(Z).  {
+  sqlite3ExprListCheckLength(pParse,Y,SQLITE_MAX_COLUMN,"set list"); 
+  sqlite3Update(pParse,X,Y,Z,R);
+}
+
+%type setlist {ExprList*}
+%destructor setlist {sqlite3ExprListDelete($$);}
+
+setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y).
+    {A = sqlite3ExprListAppend(pParse,Z,Y,&X);}
+setlist(A) ::= nm(X) EQ expr(Y).
+    {A = sqlite3ExprListAppend(pParse,0,Y,&X);}
+
+////////////////////////// The INSERT command /////////////////////////////////
+//
+cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) 
+        VALUES LP itemlist(Y) RP.
+            {sqlite3Insert(pParse, X, Y, 0, F, R);}
+cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) select(S).
+            {sqlite3Insert(pParse, X, 0, S, F, R);}
+cmd ::= insert_cmd(R) INTO fullname(X) inscollist_opt(F) DEFAULT VALUES.
+            {sqlite3Insert(pParse, X, 0, 0, F, R);}
+
+%type insert_cmd {int}
+insert_cmd(A) ::= INSERT orconf(R).   {A = R;}
+insert_cmd(A) ::= REPLACE.            {A = OE_Replace;}
+
+
+%type itemlist {ExprList*}
+%destructor itemlist {sqlite3ExprListDelete($$);}
+
+itemlist(A) ::= itemlist(X) COMMA expr(Y).
+    {A = sqlite3ExprListAppend(pParse,X,Y,0);}
+itemlist(A) ::= expr(X).
+    {A = sqlite3ExprListAppend(pParse,0,X,0);}
+
+%type inscollist_opt {IdList*}
+%destructor inscollist_opt {sqlite3IdListDelete($$);}
+%type inscollist {IdList*}
+%destructor inscollist {sqlite3IdListDelete($$);}
+
+inscollist_opt(A) ::= .                       {A = 0;}
+inscollist_opt(A) ::= LP inscollist(X) RP.    {A = X;}
+inscollist(A) ::= inscollist(X) COMMA nm(Y).
+    {A = sqlite3IdListAppend(pParse->db,X,&Y);}
+inscollist(A) ::= nm(Y).
+    {A = sqlite3IdListAppend(pParse->db,0,&Y);}
+
+/////////////////////////// Expression Processing /////////////////////////////
+//
+
+%type expr {Expr*}
+%destructor expr {sqlite3ExprDelete($$);}
+%type term {Expr*}
+%destructor term {sqlite3ExprDelete($$);}
+
+expr(A) ::= term(X).             {A = X;}
+expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqlite3ExprSpan(A,&B,&E); }
+term(A) ::= NULL(X).             {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
+expr(A) ::= ID(X).               {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}
+expr(A) ::= JOIN_KW(X).          {A = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);}
+expr(A) ::= nm(X) DOT nm(Y). {
+  Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
+  Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
+  A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
+}
+expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
+  Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
+  Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Y);
+  Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &Z);
+  Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
+  A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
+}
+term(A) ::= INTEGER|FLOAT|BLOB(X).  {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
+term(A) ::= STRING(X).       {A = sqlite3PExpr(pParse, @X, 0, 0, &X);}
+expr(A) ::= REGISTER(X).     {A = sqlite3RegisterExpr(pParse, &X);}
+expr(A) ::= VARIABLE(X).     {
+  Token *pToken = &X;
+  Expr *pExpr = A = sqlite3PExpr(pParse, TK_VARIABLE, 0, 0, pToken);
+  sqlite3ExprAssignVarNumber(pParse, pExpr);
+}
+expr(A) ::= expr(E) COLLATE ids(C). {
+  A = sqlite3ExprSetColl(pParse, E, &C);
+}
+%ifndef SQLITE_OMIT_CAST
+expr(A) ::= CAST(X) LP expr(E) AS typetoken(T) RP(Y). {
+  A = sqlite3PExpr(pParse, TK_CAST, E, 0, &T);
+  sqlite3ExprSpan(A,&X,&Y);
+}
+%endif  SQLITE_OMIT_CAST
+expr(A) ::= ID(X) LP distinct(D) exprlist(Y) RP(E). {
+  if( Y && Y->nExpr>SQLITE_MAX_FUNCTION_ARG ){
+    sqlite3ErrorMsg(pParse, "too many arguments on function %T", &X);
+  }
+  A = sqlite3ExprFunction(pParse, Y, &X);
+  sqlite3ExprSpan(A,&X,&E);
+  if( D && A ){
+    A->flags |= EP_Distinct;
+  }
+}
+expr(A) ::= ID(X) LP STAR RP(E). {
+  A = sqlite3ExprFunction(pParse, 0, &X);
+  sqlite3ExprSpan(A,&X,&E);
+}
+term(A) ::= CTIME_KW(OP). {
+  /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
+  ** treated as functions that return constants */
+  A = sqlite3ExprFunction(pParse, 0,&OP);
+  if( A ){
+    A->op = TK_CONST_FUNC;  
+    A->span = OP;
+  }
+}
+expr(A) ::= expr(X) AND(OP) expr(Y).       {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) OR(OP) expr(Y).        {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) LT|GT|GE|LE(OP) expr(Y).
+                                           {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) EQ|NE(OP) expr(Y).     {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) BITAND|BITOR|LSHIFT|RSHIFT(OP) expr(Y).
+                                           {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) PLUS|MINUS(OP) expr(Y).{A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) STAR|SLASH|REM(OP) expr(Y).
+                                           {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+expr(A) ::= expr(X) CONCAT(OP) expr(Y).    {A = sqlite3PExpr(pParse,@OP,X,Y,0);}
+%type likeop {struct LikeOp}
+likeop(A) ::= LIKE_KW(X).     {A.eOperator = X; A.not = 0;}
+likeop(A) ::= NOT LIKE_KW(X). {A.eOperator = X; A.not = 1;}
+likeop(A) ::= MATCH(X).       {A.eOperator = X; A.not = 0;}
+likeop(A) ::= NOT MATCH(X).   {A.eOperator = X; A.not = 1;}
+%type escape {Expr*}
+%destructor escape {sqlite3ExprDelete($$);}
+escape(X) ::= ESCAPE expr(A). [ESCAPE] {X = A;}
+escape(X) ::= .               [ESCAPE] {X = 0;}
+expr(A) ::= expr(X) likeop(OP) expr(Y) escape(E).  [LIKE_KW]  {
+  ExprList *pList;
+  pList = sqlite3ExprListAppend(pParse,0, Y, 0);
+  pList = sqlite3ExprListAppend(pParse,pList, X, 0);
+  if( E ){
+    pList = sqlite3ExprListAppend(pParse,pList, E, 0);
+  }
+  A = sqlite3ExprFunction(pParse, pList, &OP.eOperator);
+  if( OP.not ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
+  sqlite3ExprSpan(A, &X->span, &Y->span);
+  if( A ) A->flags |= EP_InfixFunc;
+}
+
+expr(A) ::= expr(X) ISNULL|NOTNULL(E). {
+  A = sqlite3PExpr(pParse, @E, X, 0, 0);
+  sqlite3ExprSpan(A,&X->span,&E);
+}
+expr(A) ::= expr(X) IS NULL(E). {
+  A = sqlite3PExpr(pParse, TK_ISNULL, X, 0, 0);
+  sqlite3ExprSpan(A,&X->span,&E);
+}
+expr(A) ::= expr(X) NOT NULL(E). {
+  A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);
+  sqlite3ExprSpan(A,&X->span,&E);
+}
+expr(A) ::= expr(X) IS NOT NULL(E). {
+  A = sqlite3PExpr(pParse, TK_NOTNULL, X, 0, 0);
+  sqlite3ExprSpan(A,&X->span,&E);
+}
+expr(A) ::= NOT(B) expr(X). {
+  A = sqlite3PExpr(pParse, @B, X, 0, 0);
+  sqlite3ExprSpan(A,&B,&X->span);
+}
+expr(A) ::= BITNOT(B) expr(X). {
+  A = sqlite3PExpr(pParse, @B, X, 0, 0);
+  sqlite3ExprSpan(A,&B,&X->span);
+}
+expr(A) ::= MINUS(B) expr(X). [UMINUS] {
+  A = sqlite3PExpr(pParse, TK_UMINUS, X, 0, 0);
+  sqlite3ExprSpan(A,&B,&X->span);
+}
+expr(A) ::= PLUS(B) expr(X). [UPLUS] {
+  A = sqlite3PExpr(pParse, TK_UPLUS, X, 0, 0);
+  sqlite3ExprSpan(A,&B,&X->span);
+}
+%type between_op {int}
+between_op(A) ::= BETWEEN.     {A = 0;}
+between_op(A) ::= NOT BETWEEN. {A = 1;}
+expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
+  ExprList *pList = sqlite3ExprListAppend(pParse,0, X, 0);
+  pList = sqlite3ExprListAppend(pParse,pList, Y, 0);
+  A = sqlite3PExpr(pParse, TK_BETWEEN, W, 0, 0);
+  if( A ){
+    A->pList = pList;
+  }else{
+    sqlite3ExprListDelete(pList);
+  } 
+  if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
+  sqlite3ExprSpan(A,&W->span,&Y->span);
+}
+%ifndef SQLITE_OMIT_SUBQUERY
+  %type in_op {int}
+  in_op(A) ::= IN.      {A = 0;}
+  in_op(A) ::= NOT IN.  {A = 1;}
+  expr(A) ::= expr(X) in_op(N) LP exprlist(Y) RP(E). [IN] {
+    A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
+    if( A ){
+      A->pList = Y;
+      sqlite3ExprSetHeight(A);
+    }else{
+      sqlite3ExprListDelete(Y);
+    }
+    if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
+    sqlite3ExprSpan(A,&X->span,&E);
+  }
+  expr(A) ::= LP(B) select(X) RP(E). {
+    A = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
+    if( A ){
+      A->pSelect = X;
+      sqlite3ExprSetHeight(A);
+    }else{
+      sqlite3SelectDelete(X);
+    }
+    sqlite3ExprSpan(A,&B,&E);
+  }
+  expr(A) ::= expr(X) in_op(N) LP select(Y) RP(E).  [IN] {
+    A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
+    if( A ){
+      A->pSelect = Y;
+      sqlite3ExprSetHeight(A);
+    }else{
+      sqlite3SelectDelete(Y);
+    }
+    if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
+    sqlite3ExprSpan(A,&X->span,&E);
+  }
+  expr(A) ::= expr(X) in_op(N) nm(Y) dbnm(Z). [IN] {
+    SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
+    A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
+    if( A ){
+      A->pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
+      sqlite3ExprSetHeight(A);
+    }else{
+      sqlite3SrcListDelete(pSrc);
+    }
+    if( N ) A = sqlite3PExpr(pParse, TK_NOT, A, 0, 0);
+    sqlite3ExprSpan(A,&X->span,Z.z?&Z:&Y);
+  }
+  expr(A) ::= EXISTS(B) LP select(Y) RP(E). {
+    Expr *p = A = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
+    if( p ){
+      p->pSelect = Y;
+      sqlite3ExprSpan(p,&B,&E);
+      sqlite3ExprSetHeight(A);
+    }else{
+      sqlite3SelectDelete(Y);
+    }
+  }
+%endif SQLITE_OMIT_SUBQUERY
+
+/* CASE expressions */
+expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). {
+  A = sqlite3PExpr(pParse, TK_CASE, X, Z, 0);
+  if( A ){
+    A->pList = Y;
+    sqlite3ExprSetHeight(A);
+  }else{
+    sqlite3ExprListDelete(Y);
+  }
+  sqlite3ExprSpan(A, &C, &E);
+}
+%type case_exprlist {ExprList*}
+%destructor case_exprlist {sqlite3ExprListDelete($$);}
+case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
+  A = sqlite3ExprListAppend(pParse,X, Y, 0);
+  A = sqlite3ExprListAppend(pParse,A, Z, 0);
+}
+case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
+  A = sqlite3ExprListAppend(pParse,0, Y, 0);
+  A = sqlite3ExprListAppend(pParse,A, Z, 0);
+}
+%type case_else {Expr*}
+%destructor case_else {sqlite3ExprDelete($$);}
+case_else(A) ::=  ELSE expr(X).         {A = X;}
+case_else(A) ::=  .                     {A = 0;} 
+%type case_operand {Expr*}
+%destructor case_operand {sqlite3ExprDelete($$);}
+case_operand(A) ::= expr(X).            {A = X;} 
+case_operand(A) ::= .                   {A = 0;} 
+
+%type exprlist {ExprList*}
+%destructor exprlist {sqlite3ExprListDelete($$);}
+%type nexprlist {ExprList*}
+%destructor nexprlist {sqlite3ExprListDelete($$);}
+
+exprlist(A) ::= nexprlist(X).                {A = X;}
+exprlist(A) ::= .                            {A = 0;}
+nexprlist(A) ::= nexprlist(X) COMMA expr(Y).
+    {A = sqlite3ExprListAppend(pParse,X,Y,0);}
+nexprlist(A) ::= expr(Y).
+    {A = sqlite3ExprListAppend(pParse,0,Y,0);}
+
+
+///////////////////////////// The CREATE INDEX command ///////////////////////
+//
+cmd ::= CREATE(S) uniqueflag(U) INDEX ifnotexists(NE) nm(X) dbnm(D)
+        ON nm(Y) LP idxlist(Z) RP(E). {
+  sqlite3CreateIndex(pParse, &X, &D, 
+                     sqlite3SrcListAppend(pParse->db,0,&Y,0), Z, U,
+                      &S, &E, SQLITE_SO_ASC, NE);
+}
+
+%type uniqueflag {int}
+uniqueflag(A) ::= UNIQUE.  {A = OE_Abort;}
+uniqueflag(A) ::= .        {A = OE_None;}
+
+%type idxlist {ExprList*}
+%destructor idxlist {sqlite3ExprListDelete($$);}
+%type idxlist_opt {ExprList*}
+%destructor idxlist_opt {sqlite3ExprListDelete($$);}
+%type idxitem {Token}
+
+idxlist_opt(A) ::= .                         {A = 0;}
+idxlist_opt(A) ::= LP idxlist(X) RP.         {A = X;}
+idxlist(A) ::= idxlist(X) COMMA idxitem(Y) collate(C) sortorder(Z).  {
+  Expr *p = 0;
+  if( C.n>0 ){
+    p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
+    sqlite3ExprSetColl(pParse, p, &C);
+  }
+  A = sqlite3ExprListAppend(pParse,X, p, &Y);
+  sqlite3ExprListCheckLength(pParse, A, SQLITE_MAX_COLUMN, "index");
+  if( A ) A->a[A->nExpr-1].sortOrder = Z;
+}
+idxlist(A) ::= idxitem(Y) collate(C) sortorder(Z). {
+  Expr *p = 0;
+  if( C.n>0 ){
+    p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
+    sqlite3ExprSetColl(pParse, p, &C);
+  }
+  A = sqlite3ExprListAppend(pParse,0, p, &Y);
+  sqlite3ExprListCheckLength(pParse, A, SQLITE_MAX_COLUMN, "index");
+  if( A ) A->a[A->nExpr-1].sortOrder = Z;
+}
+idxitem(A) ::= nm(X).              {A = X;}
+
+%type collate {Token}
+collate(C) ::= .                {C.z = 0; C.n = 0;}
+collate(C) ::= COLLATE ids(X).   {C = X;}
+
+
+///////////////////////////// The DROP INDEX command /////////////////////////
+//
+cmd ::= DROP INDEX ifexists(E) fullname(X).   {sqlite3DropIndex(pParse, X, E);}
+
+///////////////////////////// The VACUUM command /////////////////////////////
+//
+%ifndef SQLITE_OMIT_VACUUM
+%ifndef SQLITE_OMIT_ATTACH
+cmd ::= VACUUM.                {sqlite3Vacuum(pParse);}
+cmd ::= VACUUM nm.             {sqlite3Vacuum(pParse);}
+%endif  SQLITE_OMIT_ATTACH
+%endif  SQLITE_OMIT_VACUUM
+
+///////////////////////////// The PRAGMA command /////////////////////////////
+//
+%ifndef SQLITE_OMIT_PRAGMA
+cmd ::= PRAGMA nm(X) dbnm(Z) EQ nmnum(Y).  {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
+cmd ::= PRAGMA nm(X) dbnm(Z) EQ ON(Y).  {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
+cmd ::= PRAGMA nm(X) dbnm(Z) EQ minus_num(Y). {
+  sqlite3Pragma(pParse,&X,&Z,&Y,1);
+}
+cmd ::= PRAGMA nm(X) dbnm(Z) LP nmnum(Y) RP. {sqlite3Pragma(pParse,&X,&Z,&Y,0);}
+cmd ::= PRAGMA nm(X) dbnm(Z).             {sqlite3Pragma(pParse,&X,&Z,0,0);}
+nmnum(A) ::= plus_num(X).             {A = X;}
+nmnum(A) ::= nm(X).                   {A = X;}
+%endif SQLITE_OMIT_PRAGMA
+plus_num(A) ::= plus_opt number(X).   {A = X;}
+minus_num(A) ::= MINUS number(X).     {A = X;}
+number(A) ::= INTEGER|FLOAT(X).       {A = X;}
+plus_opt ::= PLUS.
+plus_opt ::= .
+
+//////////////////////////// The CREATE TRIGGER command /////////////////////
+
+%ifndef SQLITE_OMIT_TRIGGER
+
+cmd ::= CREATE trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
+  Token all;
+  all.z = A.z;
+  all.n = (Z.z - A.z) + Z.n;
+  sqlite3FinishTrigger(pParse, S, &all);
+}
+
+trigger_decl(A) ::= temp(T) TRIGGER ifnotexists(NOERR) nm(B) dbnm(Z) 
+                    trigger_time(C) trigger_event(D)
+                    ON fullname(E) foreach_clause when_clause(G). {
+  sqlite3BeginTrigger(pParse, &B, &Z, C, D.a, D.b, E, G, T, NOERR);
+  A = (Z.n==0?B:Z);
+}
+
+%type trigger_time {int}
+trigger_time(A) ::= BEFORE.      { A = TK_BEFORE; }
+trigger_time(A) ::= AFTER.       { A = TK_AFTER;  }
+trigger_time(A) ::= INSTEAD OF.  { A = TK_INSTEAD;}
+trigger_time(A) ::= .            { A = TK_BEFORE; }
+
+%type trigger_event {struct TrigEvent}
+%destructor trigger_event {sqlite3IdListDelete($$.b);}
+trigger_event(A) ::= DELETE|INSERT(OP).       {A.a = @OP; A.b = 0;}
+trigger_event(A) ::= UPDATE(OP).              {A.a = @OP; A.b = 0;}
+trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X;}
+
+foreach_clause ::= .
+foreach_clause ::= FOR EACH ROW.
+
+%type when_clause {Expr*}
+%destructor when_clause {sqlite3ExprDelete($$);}
+when_clause(A) ::= .             { A = 0; }
+when_clause(A) ::= WHEN expr(X). { A = X; }
+
+%type trigger_cmd_list {TriggerStep*}
+%destructor trigger_cmd_list {sqlite3DeleteTriggerStep($$);}
+trigger_cmd_list(A) ::= trigger_cmd_list(Y) trigger_cmd(X) SEMI. {
+  if( Y ){
+    Y->pLast->pNext = X;
+  }else{
+    Y = X;
+  }
+  Y->pLast = X;
+  A = Y;
+}
+trigger_cmd_list(A) ::= . { A = 0; }
+
+%type trigger_cmd {TriggerStep*}
+%destructor trigger_cmd {sqlite3DeleteTriggerStep($$);}
+// UPDATE 
+trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z).  
+               { A = sqlite3TriggerUpdateStep(pParse->db, &X, Y, Z, R); }
+
+// INSERT
+trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) 
+                   VALUES LP itemlist(Y) RP.  
+               {A = sqlite3TriggerInsertStep(pParse->db, &X, F, Y, 0, R);}
+
+trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S).
+               {A = sqlite3TriggerInsertStep(pParse->db, &X, F, 0, S, R);}
+
+// DELETE
+trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y).
+               {A = sqlite3TriggerDeleteStep(pParse->db, &X, Y);}
+
+// SELECT
+trigger_cmd(A) ::= select(X).  {A = sqlite3TriggerSelectStep(pParse->db, X); }
+
+// The special RAISE expression that may occur in trigger programs
+expr(A) ::= RAISE(X) LP IGNORE RP(Y).  {
+  A = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0); 
+  if( A ){
+    A->iColumn = OE_Ignore;
+    sqlite3ExprSpan(A, &X, &Y);
+  }
+}
+expr(A) ::= RAISE(X) LP raisetype(T) COMMA nm(Z) RP(Y).  {
+  A = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &Z); 
+  if( A ) {
+    A->iColumn = T;
+    sqlite3ExprSpan(A, &X, &Y);
+  }
+}
+%endif  !SQLITE_OMIT_TRIGGER
+
+%type raisetype {int}
+raisetype(A) ::= ROLLBACK.  {A = OE_Rollback;}
+raisetype(A) ::= ABORT.     {A = OE_Abort;}
+raisetype(A) ::= FAIL.      {A = OE_Fail;}
+
+
+////////////////////////  DROP TRIGGER statement //////////////////////////////
+%ifndef SQLITE_OMIT_TRIGGER
+cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
+  sqlite3DropTrigger(pParse,X,NOERR);
+}
+%endif  !SQLITE_OMIT_TRIGGER
+
+//////////////////////// ATTACH DATABASE file AS name /////////////////////////
+%ifndef SQLITE_OMIT_ATTACH
+cmd ::= ATTACH database_kw_opt expr(F) AS expr(D) key_opt(K). {
+  sqlite3Attach(pParse, F, D, K);
+}
+cmd ::= DETACH database_kw_opt expr(D). {
+  sqlite3Detach(pParse, D);
+}
+
+%type key_opt {Expr*}
+%destructor key_opt {sqlite3ExprDelete($$);}
+key_opt(A) ::= .                     { A = 0; }
+key_opt(A) ::= KEY expr(X).          { A = X; }
+
+database_kw_opt ::= DATABASE.
+database_kw_opt ::= .
+%endif SQLITE_OMIT_ATTACH
+
+////////////////////////// REINDEX collation //////////////////////////////////
+%ifndef SQLITE_OMIT_REINDEX
+cmd ::= REINDEX.                {sqlite3Reindex(pParse, 0, 0);}
+cmd ::= REINDEX nm(X) dbnm(Y).  {sqlite3Reindex(pParse, &X, &Y);}
+%endif  SQLITE_OMIT_REINDEX
+
+/////////////////////////////////// ANALYZE ///////////////////////////////////
+%ifndef SQLITE_OMIT_ANALYZE
+cmd ::= ANALYZE.                {sqlite3Analyze(pParse, 0, 0);}
+cmd ::= ANALYZE nm(X) dbnm(Y).  {sqlite3Analyze(pParse, &X, &Y);}
+%endif
+
+//////////////////////// ALTER TABLE table ... ////////////////////////////////
+%ifndef SQLITE_OMIT_ALTERTABLE
+cmd ::= ALTER TABLE fullname(X) RENAME TO nm(Z). {
+  sqlite3AlterRenameTable(pParse,X,&Z);
+}
+cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column(Y). {
+  sqlite3AlterFinishAddColumn(pParse, &Y);
+}
+add_column_fullname ::= fullname(X). {
+  sqlite3AlterBeginAddColumn(pParse, X);
+}
+kwcolumn_opt ::= .
+kwcolumn_opt ::= COLUMNKW.
+%endif  SQLITE_OMIT_ALTERTABLE
+
+//////////////////////// CREATE VIRTUAL TABLE ... /////////////////////////////
+%ifndef SQLITE_OMIT_VIRTUALTABLE
+cmd ::= create_vtab.                       {sqlite3VtabFinishParse(pParse,0);}
+cmd ::= create_vtab LP vtabarglist RP(X).  {sqlite3VtabFinishParse(pParse,&X);}
+create_vtab ::= CREATE VIRTUAL TABLE nm(X) dbnm(Y) USING nm(Z). {
+    sqlite3VtabBeginParse(pParse, &X, &Y, &Z);
+}
+vtabarglist ::= vtabarg.
+vtabarglist ::= vtabarglist COMMA vtabarg.
+vtabarg ::= .                       {sqlite3VtabArgInit(pParse);}
+vtabarg ::= vtabarg vtabargtoken.
+vtabargtoken ::= ANY(X).            {sqlite3VtabArgExtend(pParse,&X);}
+vtabargtoken ::= lp anylist RP(X).  {sqlite3VtabArgExtend(pParse,&X);}
+lp ::= LP(X).                       {sqlite3VtabArgExtend(pParse,&X);}
+anylist ::= .
+anylist ::= anylist ANY(X).         {sqlite3VtabArgExtend(pParse,&X);}
+%endif  SQLITE_OMIT_VIRTUALTABLE
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/pragma.c b/client/src/thirdparty/sqlite-3.4.2/src/pragma.c
new file mode 100644
index 0000000..dc7db61
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/pragma.c
@@ -0,0 +1,1227 @@
+/*
+** 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 PRAGMA command.
+**
+** $Id: pragma.c,v 1.169 2008/01/22 01:48:09 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+
+/* Ignore this whole file if pragmas are disabled
+*/
+#if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER)
+
+/*
+** Interpret the given string as a safety level.  Return 0 for OFF,
+** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 
+** unrecognized string argument.
+**
+** Note that the values returned are one less that the values that
+** should be passed into sqlite3BtreeSetSafetyLevel().  The is done
+** to support legacy SQL code.  The safety level used to be boolean
+** and older scripts may have used numbers 0 for OFF and 1 for ON.
+*/
+static int getSafetyLevel(const char *z){
+                             /* 123456789 123456789 */
+  static const char zText[] = "onoffalseyestruefull";
+  static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
+  static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
+  static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
+  int i, n;
+  if( isdigit(*z) ){
+    return atoi(z);
+  }
+  n = strlen(z);
+  for(i=0; i<sizeof(iLength); i++){
+    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
+      return iValue[i];
+    }
+  }
+  return 1;
+}
+
+/*
+** Interpret the given string as a boolean value.
+*/
+static int getBoolean(const char *z){
+  return getSafetyLevel(z)&1;
+}
+
+/*
+** Interpret the given string as a locking mode value.
+*/
+static int getLockingMode(const char *z){
+  if( z ){
+    if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
+    if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
+  }
+  return PAGER_LOCKINGMODE_QUERY;
+}
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+/*
+** Interpret the given string as an auto-vacuum mode value.
+**
+** The following strings, "none", "full" and "incremental" are 
+** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
+*/
+static int getAutoVacuum(const char *z){
+  int i;
+  if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
+  if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
+  if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
+  i = atoi(z);
+  return ((i>=0&&i<=2)?i:0);
+}
+#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
+
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+/*
+** Interpret the given string as a temp db location. Return 1 for file
+** backed temporary databases, 2 for the Red-Black tree in memory database
+** and 0 to use the compile-time default.
+*/
+static int getTempStore(const char *z){
+  if( z[0]>='0' && z[0]<='2' ){
+    return z[0] - '0';
+  }else if( sqlite3StrICmp(z, "file")==0 ){
+    return 1;
+  }else if( sqlite3StrICmp(z, "memory")==0 ){
+    return 2;
+  }else{
+    return 0;
+  }
+}
+#endif /* SQLITE_PAGER_PRAGMAS */
+
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+/*
+** Invalidate temp storage, either when the temp storage is changed
+** from default, or when 'file' and the temp_store_directory has changed
+*/
+static int invalidateTempStorage(Parse *pParse){
+  sqlite3 *db = pParse->db;
+  if( db->aDb[1].pBt!=0 ){
+    if( !db->autoCommit ){
+      sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
+        "from within a transaction");
+      return SQLITE_ERROR;
+    }
+    sqlite3BtreeClose(db->aDb[1].pBt);
+    db->aDb[1].pBt = 0;
+    sqlite3ResetInternalSchema(db, 0);
+  }
+  return SQLITE_OK;
+}
+#endif /* SQLITE_PAGER_PRAGMAS */
+
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+/*
+** If the TEMP database is open, close it and mark the database schema
+** as needing reloading.  This must be done when using the TEMP_STORE
+** or DEFAULT_TEMP_STORE pragmas.
+*/
+static int changeTempStorage(Parse *pParse, const char *zStorageType){
+  int ts = getTempStore(zStorageType);
+  sqlite3 *db = pParse->db;
+  if( db->temp_store==ts ) return SQLITE_OK;
+  if( invalidateTempStorage( pParse ) != SQLITE_OK ){
+    return SQLITE_ERROR;
+  }
+  db->temp_store = ts;
+  return SQLITE_OK;
+}
+#endif /* SQLITE_PAGER_PRAGMAS */
+
+/*
+** Generate code to return a single integer value.
+*/
+static void returnSingleInt(Parse *pParse, const char *zLabel, int value){
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  int mem = ++pParse->nMem;
+  sqlite3VdbeAddOp2(v, OP_Integer, value, mem);
+  if( pParse->explain==0 ){
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P4_STATIC);
+  }
+  sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
+}
+
+#ifndef SQLITE_OMIT_FLAG_PRAGMAS
+/*
+** Check to see if zRight and zLeft refer to a pragma that queries
+** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.
+** Also, implement the pragma.
+*/
+static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
+  static const struct sPragmaType {
+    const char *zName;  /* Name of the pragma */
+    int mask;           /* Mask for the db->flags value */
+  } aPragma[] = {
+    { "full_column_names",        SQLITE_FullColNames  },
+    { "short_column_names",       SQLITE_ShortColNames },
+    { "count_changes",            SQLITE_CountRows     },
+    { "empty_result_callbacks",   SQLITE_NullCallback  },
+    { "legacy_file_format",       SQLITE_LegacyFileFmt },
+    { "fullfsync",                SQLITE_FullFSync     },
+#ifdef SQLITE_DEBUG
+    { "sql_trace",                SQLITE_SqlTrace      },
+    { "vdbe_listing",             SQLITE_VdbeListing   },
+    { "vdbe_trace",               SQLITE_VdbeTrace     },
+#endif
+#ifndef SQLITE_OMIT_CHECK
+    { "ignore_check_constraints", SQLITE_IgnoreChecks  },
+#endif
+    /* The following is VERY experimental */
+    { "writable_schema",          SQLITE_WriteSchema|SQLITE_RecoveryMode },
+    { "omit_readlock",            SQLITE_NoReadlock    },
+
+    /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
+    ** flag if there are any active statements. */
+    { "read_uncommitted",         SQLITE_ReadUncommitted },
+  };
+  int i;
+  const struct sPragmaType *p;
+  for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){
+    if( sqlite3StrICmp(zLeft, p->zName)==0 ){
+      sqlite3 *db = pParse->db;
+      Vdbe *v;
+      v = sqlite3GetVdbe(pParse);
+      if( v ){
+        if( zRight==0 ){
+          returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
+        }else{
+          if( getBoolean(zRight) ){
+            db->flags |= p->mask;
+          }else{
+            db->flags &= ~p->mask;
+          }
+
+          /* Many of the flag-pragmas modify the code generated by the SQL 
+          ** compiler (eg. count_changes). So add an opcode to expire all
+          ** compiled SQL statements after modifying a pragma value.
+          */
+          sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
+        }
+      }
+
+      return 1;
+    }
+  }
+  return 0;
+}
+#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
+
+/*
+** Process a pragma statement.  
+**
+** Pragmas are of this form:
+**
+**      PRAGMA [database.]id [= value]
+**
+** The identifier might also be a string.  The value is a string, and
+** identifier, or a number.  If minusFlag is true, then the value is
+** a number that was preceded by a minus sign.
+**
+** If the left side is "database.id" then pId1 is the database name
+** and pId2 is the id.  If the left side is just "id" then pId1 is the
+** id and pId2 is any empty string.
+*/
+void sqlite3Pragma(
+  Parse *pParse, 
+  Token *pId1,        /* First part of [database.]id field */
+  Token *pId2,        /* Second part of [database.]id field, or NULL */
+  Token *pValue,      /* Token for <value>, or NULL */
+  int minusFlag       /* True if a '-' sign preceded <value> */
+){
+  char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
+  char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
+  const char *zDb = 0;   /* The database name */
+  Token *pId;            /* Pointer to <id> token */
+  int iDb;               /* Database index for <database> */
+  sqlite3 *db = pParse->db;
+  Db *pDb;
+  Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
+  if( v==0 ) return;
+  pParse->nMem = 2;
+
+  /* Interpret the [database.] part of the pragma statement. iDb is the
+  ** index of the database this pragma is being applied to in db.aDb[]. */
+  iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
+  if( iDb<0 ) return;
+  pDb = &db->aDb[iDb];
+
+  /* If the temp database has been explicitly named as part of the 
+  ** pragma, make sure it is open. 
+  */
+  if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
+    return;
+  }
+
+  zLeft = sqlite3NameFromToken(db, pId);
+  if( !zLeft ) return;
+  if( minusFlag ){
+    zRight = sqlite3MPrintf(db, "-%T", pValue);
+  }else{
+    zRight = sqlite3NameFromToken(db, pValue);
+  }
+
+  zDb = ((iDb>0)?pDb->zName:0);
+  if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
+    goto pragma_out;
+  }
+ 
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+  /*
+  **  PRAGMA [database.]default_cache_size
+  **  PRAGMA [database.]default_cache_size=N
+  **
+  ** The first form reports the current persistent setting for the
+  ** page cache size.  The value returned is the maximum number of
+  ** pages in the page cache.  The second form sets both the current
+  ** page cache size value and the persistent page cache size value
+  ** stored in the database file.
+  **
+  ** The default cache size is stored in meta-value 2 of page 1 of the
+  ** database file.  The cache size is actually the absolute value of
+  ** this memory location.  The sign of meta-value 2 determines the
+  ** synchronous setting.  A negative value means synchronous is off
+  ** and a positive value means synchronous is on.
+  */
+  if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
+    static const VdbeOpList getCacheSize[] = {
+      { OP_ReadCookie,  0, 1,        2},  /* 0 */
+      { OP_IfPos,       1, 6,        0},
+      { OP_Integer,     0, 2,        0},
+      { OP_Subtract,    1, 2,        1},
+      { OP_IfPos,       1, 6,        0},
+      { OP_Integer,     0, 1,        0},  /* 5 */
+      { OP_ResultRow,   1, 1,        0},
+    };
+    int addr;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    sqlite3VdbeUsesBtree(v, iDb);
+    if( !zRight ){
+      sqlite3VdbeSetNumCols(v, 1);
+      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P4_STATIC);
+      pParse->nMem += 2;
+      addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
+      sqlite3VdbeChangeP1(v, addr, iDb);
+      sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE);
+    }else{
+      int size = atoi(zRight);
+      if( size<0 ) size = -size;
+      sqlite3BeginWriteOperation(pParse, 0, iDb);
+      sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
+      sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, 2, 2);
+      addr = sqlite3VdbeAddOp2(v, OP_IfPos, 2, 0);
+      sqlite3VdbeAddOp2(v, OP_Integer, -size, 1);
+      sqlite3VdbeJumpHere(v, addr);
+      sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 2, 1);
+      pDb->pSchema->cache_size = size;
+      sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
+    }
+  }else
+
+  /*
+  **  PRAGMA [database.]page_size
+  **  PRAGMA [database.]page_size=N
+  **
+  ** The first form reports the current setting for the
+  ** database page size in bytes.  The second form sets the
+  ** database page size value.  The value can only be set if
+  ** the database has not yet been created.
+  */
+  if( sqlite3StrICmp(zLeft,"page_size")==0 ){
+    Btree *pBt = pDb->pBt;
+    if( !zRight ){
+      int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
+      returnSingleInt(pParse, "page_size", size);
+    }else{
+      /* Malloc may fail when setting the page-size, as there is an internal
+      ** buffer that the pager module resizes using sqlite3_realloc().
+      */
+      if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1) ){
+        db->mallocFailed = 1;
+      }
+    }
+  }else
+
+  /*
+  **  PRAGMA [database.]max_page_count
+  **  PRAGMA [database.]max_page_count=N
+  **
+  ** The first form reports the current setting for the
+  ** maximum number of pages in the database file.  The 
+  ** second form attempts to change this setting.  Both
+  ** forms return the current setting.
+  */
+  if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){
+    Btree *pBt = pDb->pBt;
+    int newMax = 0;
+    if( zRight ){
+      newMax = atoi(zRight);
+    }
+    if( pBt ){
+      newMax = sqlite3BtreeMaxPageCount(pBt, newMax);
+    }
+    returnSingleInt(pParse, "max_page_count", newMax);
+  }else
+
+  /*
+  **  PRAGMA [database.]locking_mode
+  **  PRAGMA [database.]locking_mode = (normal|exclusive)
+  */
+  if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
+    const char *zRet = "normal";
+    int eMode = getLockingMode(zRight);
+
+    if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
+      /* Simple "PRAGMA locking_mode;" statement. This is a query for
+      ** the current default locking mode (which may be different to
+      ** the locking-mode of the main database).
+      */
+      eMode = db->dfltLockMode;
+    }else{
+      Pager *pPager;
+      if( pId2->n==0 ){
+        /* This indicates that no database name was specified as part
+        ** of the PRAGMA command. In this case the locking-mode must be
+        ** set on all attached databases, as well as the main db file.
+        **
+        ** Also, the sqlite3.dfltLockMode variable is set so that
+        ** any subsequently attached databases also use the specified
+        ** locking mode.
+        */
+        int ii;
+        assert(pDb==&db->aDb[0]);
+        for(ii=2; ii<db->nDb; ii++){
+          pPager = sqlite3BtreePager(db->aDb[ii].pBt);
+          sqlite3PagerLockingMode(pPager, eMode);
+        }
+        db->dfltLockMode = eMode;
+      }
+      pPager = sqlite3BtreePager(pDb->pBt);
+      eMode = sqlite3PagerLockingMode(pPager, eMode);
+    }
+
+    assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
+    if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
+      zRet = "exclusive";
+    }
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P4_STATIC);
+    sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
+    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
+  }else
+#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
+
+  /*
+  **  PRAGMA [database.]auto_vacuum
+  **  PRAGMA [database.]auto_vacuum=N
+  **
+  ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
+  */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
+    Btree *pBt = pDb->pBt;
+    if( sqlite3ReadSchema(pParse) ){
+      goto pragma_out;
+    }
+    if( !zRight ){
+      int auto_vacuum = 
+          pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
+      returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
+    }else{
+      int eAuto = getAutoVacuum(zRight);
+      db->nextAutovac = eAuto;
+      if( eAuto>=0 ){
+        /* Call SetAutoVacuum() to set initialize the internal auto and
+        ** incr-vacuum flags. This is required in case this connection
+        ** creates the database file. It is important that it is created
+        ** as an auto-vacuum capable db.
+        */
+        int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
+        if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
+          /* When setting the auto_vacuum mode to either "full" or 
+          ** "incremental", write the value of meta[6] in the database
+          ** file. Before writing to meta[6], check that meta[3] indicates
+          ** that this really is an auto-vacuum capable database.
+          */
+          static const VdbeOpList setMeta6[] = {
+            { OP_Transaction,    0,               1,        0},    /* 0 */
+            { OP_ReadCookie,     0,               1,        3},    /* 1 */
+            { OP_If,             1,               0,        0},    /* 2 */
+            { OP_Halt,           SQLITE_OK,       OE_Abort, 0},    /* 3 */
+            { OP_Integer,        0,               1,        0},    /* 4 */
+            { OP_SetCookie,      0,               6,        1},    /* 5 */
+          };
+          int iAddr;
+          iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
+          sqlite3VdbeChangeP1(v, iAddr, iDb);
+          sqlite3VdbeChangeP1(v, iAddr+1, iDb);
+          sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
+          sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
+          sqlite3VdbeChangeP1(v, iAddr+5, iDb);
+          sqlite3VdbeUsesBtree(v, iDb);
+        }
+      }
+    }
+  }else
+#endif
+
+  /*
+  **  PRAGMA [database.]incremental_vacuum(N)
+  **
+  ** Do N steps of incremental vacuuming on a database.
+  */
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
+    int iLimit, addr;
+    if( sqlite3ReadSchema(pParse) ){
+      goto pragma_out;
+    }
+    if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
+      iLimit = 0x7fffffff;
+    }
+    sqlite3BeginWriteOperation(pParse, 0, iDb);
+    sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
+    addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
+    sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
+    sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
+    sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
+    sqlite3VdbeJumpHere(v, addr);
+  }else
+#endif
+
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+  /*
+  **  PRAGMA [database.]cache_size
+  **  PRAGMA [database.]cache_size=N
+  **
+  ** The first form reports the current local setting for the
+  ** page cache size.  The local setting can be different from
+  ** the persistent cache size value that is stored in the database
+  ** file itself.  The value returned is the maximum number of
+  ** pages in the page cache.  The second form sets the local
+  ** page cache size value.  It does not change the persistent
+  ** cache size stored on the disk so the cache size will revert
+  ** to its default value when the database is closed and reopened.
+  ** N should be a positive integer.
+  */
+  if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    if( !zRight ){
+      returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
+    }else{
+      int size = atoi(zRight);
+      if( size<0 ) size = -size;
+      pDb->pSchema->cache_size = size;
+      sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
+    }
+  }else
+
+  /*
+  **   PRAGMA temp_store
+  **   PRAGMA temp_store = "default"|"memory"|"file"
+  **
+  ** Return or set the local value of the temp_store flag.  Changing
+  ** the local value does not make changes to the disk file and the default
+  ** value will be restored the next time the database is opened.
+  **
+  ** Note that it is possible for the library compile-time options to
+  ** override this setting
+  */
+  if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
+    if( !zRight ){
+      returnSingleInt(pParse, "temp_store", db->temp_store);
+    }else{
+      changeTempStorage(pParse, zRight);
+    }
+  }else
+
+  /*
+  **   PRAGMA temp_store_directory
+  **   PRAGMA temp_store_directory = ""|"directory_name"
+  **
+  ** Return or set the local value of the temp_store_directory flag.  Changing
+  ** the value sets a specific directory to be used for temporary files.
+  ** Setting to a null string reverts to the default temporary directory search.
+  ** If temporary directory is changed, then invalidateTempStorage.
+  **
+  */
+  if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
+    if( !zRight ){
+      if( sqlite3_temp_directory ){
+        sqlite3VdbeSetNumCols(v, 1);
+        sqlite3VdbeSetColName(v, 0, COLNAME_NAME, 
+            "temp_store_directory", P4_STATIC);
+        sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
+        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
+      }
+    }else{
+      if( zRight[0] 
+       && !sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE) 
+      ){
+        sqlite3ErrorMsg(pParse, "not a writable directory");
+        goto pragma_out;
+      }
+      if( TEMP_STORE==0
+       || (TEMP_STORE==1 && db->temp_store<=1)
+       || (TEMP_STORE==2 && db->temp_store==1)
+      ){
+        invalidateTempStorage(pParse);
+      }
+      sqlite3_free(sqlite3_temp_directory);
+      if( zRight[0] ){
+        sqlite3_temp_directory = zRight;
+        zRight = 0;
+      }else{
+        sqlite3_temp_directory = 0;
+      }
+    }
+  }else
+
+  /*
+  **   PRAGMA [database.]synchronous
+  **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
+  **
+  ** Return or set the local value of the synchronous flag.  Changing
+  ** the local value does not make changes to the disk file and the
+  ** default value will be restored the next time the database is
+  ** opened.
+  */
+  if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    if( !zRight ){
+      returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
+    }else{
+      if( !db->autoCommit ){
+        sqlite3ErrorMsg(pParse, 
+            "Safety level may not be changed inside a transaction");
+      }else{
+        pDb->safety_level = getSafetyLevel(zRight)+1;
+      }
+    }
+  }else
+#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
+
+#ifndef SQLITE_OMIT_FLAG_PRAGMAS
+  if( flagPragma(pParse, zLeft, zRight) ){
+    /* The flagPragma() subroutine also generates any necessary code
+    ** there is nothing more to do here */
+  }else
+#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
+
+#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
+  /*
+  **   PRAGMA table_info(<table>)
+  **
+  ** Return a single row for each column of the named table. The columns of
+  ** the returned data set are:
+  **
+  ** cid:        Column id (numbered from left to right, starting at 0)
+  ** name:       Column name
+  ** type:       Column declaration type.
+  ** notnull:    True if 'NOT NULL' is part of column declaration
+  ** dflt_value: The default value for the column, if any.
+  */
+  if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
+    Table *pTab;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    pTab = sqlite3FindTable(db, zRight, zDb);
+    if( pTab ){
+      int i;
+      int nHidden = 0;
+      Column *pCol;
+      sqlite3VdbeSetNumCols(v, 6);
+      pParse->nMem = 6;
+      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P4_STATIC);
+      sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
+      sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P4_STATIC);
+      sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P4_STATIC);
+      sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P4_STATIC);
+      sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P4_STATIC);
+      sqlite3ViewGetColumnNames(pParse, pTab);
+      for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
+        const Token *pDflt;
+        if( IsHiddenColumn(pCol) ){
+          nHidden++;
+          continue;
+        }
+        sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
+        sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
+        sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
+           pCol->zType ? pCol->zType : "", 0);
+        sqlite3VdbeAddOp2(v, OP_Integer, pCol->notNull, 4);
+        if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){
+          sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pDflt->z, pDflt->n);
+        }else{
+          sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
+        }
+        sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
+        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
+      }
+    }
+  }else
+
+  if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
+    Index *pIdx;
+    Table *pTab;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    pIdx = sqlite3FindIndex(db, zRight, zDb);
+    if( pIdx ){
+      int i;
+      pTab = pIdx->pTable;
+      sqlite3VdbeSetNumCols(v, 3);
+      pParse->nMem = 3;
+      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P4_STATIC);
+      sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P4_STATIC);
+      sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P4_STATIC);
+      for(i=0; i<pIdx->nColumn; i++){
+        int cnum = pIdx->aiColumn[i];
+        sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
+        sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
+        assert( pTab->nCol>cnum );
+        sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
+        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
+      }
+    }
+  }else
+
+  if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
+    Index *pIdx;
+    Table *pTab;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    pTab = sqlite3FindTable(db, zRight, zDb);
+    if( pTab ){
+      v = sqlite3GetVdbe(pParse);
+      pIdx = pTab->pIndex;
+      if( pIdx ){
+        int i = 0; 
+        sqlite3VdbeSetNumCols(v, 3);
+        pParse->nMem = 3;
+        sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
+        sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
+        sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P4_STATIC);
+        while(pIdx){
+          sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
+          sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
+          sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
+          sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
+          ++i;
+          pIdx = pIdx->pNext;
+        }
+      }
+    }
+  }else
+
+  if( sqlite3StrICmp(zLeft, "database_list")==0 ){
+    int i;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    sqlite3VdbeSetNumCols(v, 3);
+    pParse->nMem = 3;
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
+    sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
+    sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P4_STATIC);
+    for(i=0; i<db->nDb; i++){
+      if( db->aDb[i].pBt==0 ) continue;
+      assert( db->aDb[i].zName!=0 );
+      sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
+           sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
+      sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
+    }
+  }else
+
+  if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
+    int i = 0;
+    HashElem *p;
+    sqlite3VdbeSetNumCols(v, 2);
+    pParse->nMem = 2;
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
+    sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
+    for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
+      CollSeq *pColl = (CollSeq *)sqliteHashData(p);
+      sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
+      sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
+    }
+  }else
+#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
+
+#ifndef SQLITE_OMIT_FOREIGN_KEY
+  if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
+    FKey *pFK;
+    Table *pTab;
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    pTab = sqlite3FindTable(db, zRight, zDb);
+    if( pTab ){
+      v = sqlite3GetVdbe(pParse);
+      pFK = pTab->pFKey;
+      if( pFK ){
+        int i = 0; 
+        sqlite3VdbeSetNumCols(v, 5);
+        pParse->nMem = 5;
+        sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P4_STATIC);
+        sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P4_STATIC);
+        sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P4_STATIC);
+        sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P4_STATIC);
+        sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P4_STATIC);
+        while(pFK){
+          int j;
+          for(j=0; j<pFK->nCol; j++){
+            char *zCol = pFK->aCol[j].zCol;
+            sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
+            sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
+            sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
+            sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
+                              pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
+            sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
+            sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
+          }
+          ++i;
+          pFK = pFK->pNextFrom;
+        }
+      }
+    }
+  }else
+#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
+
+#ifndef NDEBUG
+  if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
+    if( zRight ){
+      if( getBoolean(zRight) ){
+        sqlite3ParserTrace(stderr, "parser: ");
+      }else{
+        sqlite3ParserTrace(0, 0);
+      }
+    }
+  }else
+#endif
+
+  /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
+  ** used will be case sensitive or not depending on the RHS.
+  */
+  if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
+    if( zRight ){
+      sqlite3RegisterLikeFunctions(db, getBoolean(zRight));
+    }
+  }else
+
+#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
+# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
+#endif
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+  /* Pragma "quick_check" is an experimental reduced version of 
+  ** integrity_check designed to detect most database corruption
+  ** without most of the overhead of a full integrity-check.
+  */
+  if( sqlite3StrICmp(zLeft, "integrity_check")==0
+   || sqlite3StrICmp(zLeft, "quick_check")==0 
+  ){
+    int i, j, addr, mxErr;
+
+    /* Code that appears at the end of the integrity check.  If no error
+    ** messages have been generated, output OK.  Otherwise output the
+    ** error message
+    */
+    static const VdbeOpList endCode[] = {
+      { OP_AddImm,      1, 0,        0},    /* 0 */
+      { OP_IfNeg,       1, 0,        0},    /* 1 */
+      { OP_String8,     0, 3,        0},    /* 2 */
+      { OP_ResultRow,   3, 1,        0},
+    };
+
+    int isQuick = (zLeft[0]=='q');
+
+    /* Initialize the VDBE program */
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+    pParse->nMem = 6;
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P4_STATIC);
+
+    /* Set the maximum error count */
+    mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
+    if( zRight ){
+      mxErr = atoi(zRight);
+      if( mxErr<=0 ){
+        mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
+      }
+    }
+    sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1);  /* reg[1] holds errors left */
+
+    /* Do an integrity check on each database file */
+    for(i=0; i<db->nDb; i++){
+      HashElem *x;
+      Hash *pTbls;
+      int cnt = 0;
+
+      if( OMIT_TEMPDB && i==1 ) continue;
+
+      sqlite3CodeVerifySchema(pParse, i);
+      addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
+      sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
+      sqlite3VdbeJumpHere(v, addr);
+
+      /* Do an integrity check of the B-Tree
+      **
+      ** Begin by filling registers 2, 3, ... with the root pages numbers
+      ** for all tables and indices in the database.
+      */
+      pTbls = &db->aDb[i].pSchema->tblHash;
+      for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
+        Table *pTab = sqliteHashData(x);
+        Index *pIdx;
+        sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
+        cnt++;
+        for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+          sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
+          cnt++;
+        }
+      }
+      if( cnt==0 ) continue;
+
+      /* Make sure sufficient number of registers have been allocated */
+      if( pParse->nMem < cnt+3 ){
+        pParse->nMem = cnt+3;
+      }
+
+      /* Do the b-tree integrity checks */
+      sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
+      sqlite3VdbeChangeP5(v, i);
+      addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
+         sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
+         P4_DYNAMIC);
+      sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 2);
+      sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
+      sqlite3VdbeJumpHere(v, addr);
+
+      /* Make sure all the indices are constructed correctly.
+      */
+      for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
+        Table *pTab = sqliteHashData(x);
+        Index *pIdx;
+        int loopTop;
+
+        if( pTab->pIndex==0 ) continue;
+        addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */
+        sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
+        sqlite3VdbeJumpHere(v, addr);
+        sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, 2);  /* reg(2) will count entries */
+        loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
+        sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1);   /* increment entry count */
+        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
+          int jmp2;
+          static const VdbeOpList idxErr[] = {
+            { OP_AddImm,      1, -1,  0},
+            { OP_String8,     0,  3,  0},    /* 1 */
+            { OP_Rowid,       1,  4,  0},
+            { OP_String8,     0,  5,  0},    /* 3 */
+            { OP_String8,     0,  6,  0},    /* 4 */
+            { OP_Concat,      4,  3,  3},
+            { OP_Concat,      5,  3,  3},
+            { OP_Concat,      6,  3,  3},
+            { OP_ResultRow,   3,  1,  0},
+          };
+          sqlite3GenerateIndexKey(pParse, pIdx, 1, 3);
+          jmp2 = sqlite3VdbeAddOp3(v, OP_Found, j+2, 0, 3);
+          addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
+          sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
+          sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
+          sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC);
+          sqlite3VdbeJumpHere(v, jmp2);
+        }
+        sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
+        sqlite3VdbeJumpHere(v, loopTop);
+        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
+          static const VdbeOpList cntIdx[] = {
+             { OP_Integer,      0,  3,  0},
+             { OP_Rewind,       0,  0,  0},  /* 1 */
+             { OP_AddImm,       3,  1,  0},
+             { OP_Next,         0,  0,  0},  /* 3 */
+             { OP_Eq,           2,  0,  3},  /* 4 */
+             { OP_AddImm,       1, -1,  0},
+             { OP_String8,      0,  2,  0},  /* 6 */
+             { OP_String8,      0,  3,  0},  /* 7 */
+             { OP_Concat,       3,  2,  2},
+             { OP_ResultRow,    2,  1,  0},
+          };
+          if( pIdx->tnum==0 ) continue;
+          addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
+          sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
+          sqlite3VdbeJumpHere(v, addr);
+          addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
+          sqlite3VdbeChangeP1(v, addr+1, j+2);
+          sqlite3VdbeChangeP2(v, addr+1, addr+4);
+          sqlite3VdbeChangeP1(v, addr+3, j+2);
+          sqlite3VdbeChangeP2(v, addr+3, addr+2);
+          sqlite3VdbeJumpHere(v, addr+4);
+          sqlite3VdbeChangeP4(v, addr+6, 
+                     "wrong # of entries in index ", P4_STATIC);
+          sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_STATIC);
+        }
+      } 
+    }
+    addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
+    sqlite3VdbeChangeP2(v, addr, -mxErr);
+    sqlite3VdbeJumpHere(v, addr+1);
+    sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
+  }else
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+#ifndef SQLITE_OMIT_UTF16
+  /*
+  **   PRAGMA encoding
+  **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
+  **
+  ** In its first form, this pragma returns the encoding of the main
+  ** database. If the database is not initialized, it is initialized now.
+  **
+  ** The second form of this pragma is a no-op if the main database file
+  ** has not already been initialized. In this case it sets the default
+  ** encoding that will be used for the main database file if a new file
+  ** is created. If an existing main database file is opened, then the
+  ** default text encoding for the existing database is used.
+  ** 
+  ** In all cases new databases created using the ATTACH command are
+  ** created to use the same default text encoding as the main database. If
+  ** the main database has not been initialized and/or created when ATTACH
+  ** is executed, this is done before the ATTACH operation.
+  **
+  ** In the second form this pragma sets the text encoding to be used in
+  ** new database files created using this database handle. It is only
+  ** useful if invoked immediately after the main database i
+  */
+  if( sqlite3StrICmp(zLeft, "encoding")==0 ){
+    static const struct EncName {
+      char *zName;
+      u8 enc;
+    } encnames[] = {
+      { "UTF-8",    SQLITE_UTF8        },
+      { "UTF8",     SQLITE_UTF8        },
+      { "UTF-16le", SQLITE_UTF16LE     },
+      { "UTF16le",  SQLITE_UTF16LE     },
+      { "UTF-16be", SQLITE_UTF16BE     },
+      { "UTF16be",  SQLITE_UTF16BE     },
+      { "UTF-16",   0                  }, /* SQLITE_UTF16NATIVE */
+      { "UTF16",    0                  }, /* SQLITE_UTF16NATIVE */
+      { 0, 0 }
+    };
+    const struct EncName *pEnc;
+    if( !zRight ){    /* "PRAGMA encoding" */
+      if( sqlite3ReadSchema(pParse) ) goto pragma_out;
+      sqlite3VdbeSetNumCols(v, 1);
+      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P4_STATIC);
+      sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
+      for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
+        if( pEnc->enc==ENC(pParse->db) ){
+          sqlite3VdbeChangeP4(v, -1, pEnc->zName, P4_STATIC);
+          break;
+        }
+      }
+      sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
+    }else{                        /* "PRAGMA encoding = XXX" */
+      /* Only change the value of sqlite.enc if the database handle is not
+      ** initialized. If the main database exists, the new sqlite.enc value
+      ** will be overwritten when the schema is next loaded. If it does not
+      ** already exists, it will be created to use the new encoding value.
+      */
+      if( 
+        !(DbHasProperty(db, 0, DB_SchemaLoaded)) || 
+        DbHasProperty(db, 0, DB_Empty) 
+      ){
+        for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
+          if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
+            ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
+            break;
+          }
+        }
+        if( !pEnc->zName ){
+          sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
+        }
+      }
+    }
+  }else
+#endif /* SQLITE_OMIT_UTF16 */
+
+#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
+  /*
+  **   PRAGMA [database.]schema_version
+  **   PRAGMA [database.]schema_version = <integer>
+  **
+  **   PRAGMA [database.]user_version
+  **   PRAGMA [database.]user_version = <integer>
+  **
+  ** The pragma's schema_version and user_version are used to set or get
+  ** the value of the schema-version and user-version, respectively. Both
+  ** the schema-version and the user-version are 32-bit signed integers
+  ** stored in the database header.
+  **
+  ** The schema-cookie is usually only manipulated internally by SQLite. It
+  ** is incremented by SQLite whenever the database schema is modified (by
+  ** creating or dropping a table or index). The schema version is used by
+  ** SQLite each time a query is executed to ensure that the internal cache
+  ** of the schema used when compiling the SQL query matches the schema of
+  ** the database against which the compiled query is actually executed.
+  ** Subverting this mechanism by using "PRAGMA schema_version" to modify
+  ** the schema-version is potentially dangerous and may lead to program
+  ** crashes or database corruption. Use with caution!
+  **
+  ** The user-version is not used internally by SQLite. It may be used by
+  ** applications for any purpose.
+  */
+  if( sqlite3StrICmp(zLeft, "schema_version")==0 
+   || sqlite3StrICmp(zLeft, "user_version")==0 
+   || sqlite3StrICmp(zLeft, "freelist_count")==0 
+  ){
+
+    int iCookie;   /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
+    sqlite3VdbeUsesBtree(v, iDb);
+    switch( zLeft[0] ){
+      case 's': case 'S':
+        iCookie = 0;
+        break;
+      case 'f': case 'F':
+        iCookie = 1;
+        iDb = (-1*(iDb+1));
+        assert(iDb<=0);
+        break;
+      default:
+        iCookie = 5;
+        break;
+    }
+
+    if( zRight && iDb>=0 ){
+      /* Write the specified cookie value */
+      static const VdbeOpList setCookie[] = {
+        { OP_Transaction,    0,  1,  0},    /* 0 */
+        { OP_Integer,        0,  1,  0},    /* 1 */
+        { OP_SetCookie,      0,  0,  1},    /* 2 */
+      };
+      int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
+      sqlite3VdbeChangeP1(v, addr, iDb);
+      sqlite3VdbeChangeP1(v, addr+1, atoi(zRight));
+      sqlite3VdbeChangeP1(v, addr+2, iDb);
+      sqlite3VdbeChangeP2(v, addr+2, iCookie);
+    }else{
+      /* Read the specified cookie value */
+      static const VdbeOpList readCookie[] = {
+        { OP_ReadCookie,      0,  1,  0},    /* 0 */
+        { OP_ResultRow,       1,  1,  0}
+      };
+      int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
+      sqlite3VdbeChangeP1(v, addr, iDb);
+      sqlite3VdbeChangeP3(v, addr, iCookie);
+      sqlite3VdbeSetNumCols(v, 1);
+      sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, P4_TRANSIENT);
+    }
+  }else
+#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
+
+#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
+  /*
+  ** Report the current state of file logs for all databases
+  */
+  if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
+    static const char *const azLockName[] = {
+      "unlocked", "shared", "reserved", "pending", "exclusive"
+    };
+    int i;
+    Vdbe *v = sqlite3GetVdbe(pParse);
+    sqlite3VdbeSetNumCols(v, 2);
+    pParse->nMem = 2;
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P4_STATIC);
+    sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P4_STATIC);
+    for(i=0; i<db->nDb; i++){
+      Btree *pBt;
+      Pager *pPager;
+      const char *zState = "unknown";
+      int j;
+      if( db->aDb[i].zName==0 ) continue;
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
+      pBt = db->aDb[i].pBt;
+      if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
+        zState = "closed";
+      }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0, 
+                                     SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
+         zState = azLockName[j];
+      }
+      sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
+      sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
+    }
+  }else
+#endif
+
+#ifdef SQLITE_SSE
+  /*
+  ** Check to see if the sqlite_statements table exists.  Create it
+  ** if it does not.
+  */
+  if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){
+    extern int sqlite3CreateStatementsTable(Parse*);
+    sqlite3CreateStatementsTable(pParse);
+  }else
+#endif
+
+#if SQLITE_HAS_CODEC
+  if( sqlite3StrICmp(zLeft, "key")==0 ){
+    sqlite3_key(db, zRight, strlen(zRight));
+  }else
+#endif
+#if SQLITE_HAS_CODEC || defined(SQLITE_ENABLE_CEROD)
+  if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
+#if SQLITE_HAS_CODEC
+    if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
+      extern void sqlite3_activate_see(const char*);
+      sqlite3_activate_see(&zRight[4]);
+    }
+#endif
+#ifdef SQLITE_ENABLE_CEROD
+    if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
+      extern void sqlite3_activate_cerod(const char*);
+      sqlite3_activate_cerod(&zRight[6]);
+    }
+#endif
+  }
+#endif
+
+  {}
+
+  if( v ){
+    /* Code an OP_Expire at the end of each PRAGMA program to cause
+    ** the VDBE implementing the pragma to expire. Most (all?) pragmas
+    ** are only valid for a single execution.
+    */
+    sqlite3VdbeAddOp2(v, OP_Expire, 1, 0);
+
+    /*
+    ** Reset the safety level, in case the fullfsync flag or synchronous
+    ** setting changed.
+    */
+#ifndef SQLITE_OMIT_PAGER_PRAGMAS
+    if( db->autoCommit ){
+      sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
+                 (db->flags&SQLITE_FullFSync)!=0);
+    }
+#endif
+  }
+pragma_out:
+  sqlite3_free(zLeft);
+  sqlite3_free(zRight);
+}
+
+#endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/prepare.c b/client/src/thirdparty/sqlite-3.4.2/src/prepare.c
new file mode 100644
index 0000000..a9bc844
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/prepare.c
@@ -0,0 +1,768 @@
+/*
+** 2005 May 25
+**
+** 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 the implementation of the sqlite3_prepare()
+** interface, and routines that contribute to loading the database schema
+** from disk.
+**
+** $Id: prepare.c,v 1.75 2008/01/23 03:03:05 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+
+/*
+** Fill the InitData structure with an error message that indicates
+** that the database is corrupt.
+*/
+static void corruptSchema(InitData *pData, const char *zExtra){
+  if( !pData->db->mallocFailed ){
+    sqlite3SetString(pData->pzErrMsg, "malformed database schema",
+       zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
+  }
+  pData->rc = SQLITE_CORRUPT;
+}
+
+/*
+** This is the callback routine for the code that initializes the
+** database.  See sqlite3Init() below for additional information.
+** This routine is also called from the OP_ParseSchema opcode of the VDBE.
+**
+** Each callback contains the following information:
+**
+**     argv[0] = name of thing being created
+**     argv[1] = root page number for table or index. 0 for trigger or view.
+**     argv[2] = SQL text for the CREATE statement.
+**
+*/
+int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
+  InitData *pData = (InitData*)pInit;
+  sqlite3 *db = pData->db;
+  int iDb = pData->iDb;
+
+  assert( sqlite3_mutex_held(db->mutex) );
+  pData->rc = SQLITE_OK;
+  DbClearProperty(db, iDb, DB_Empty);
+  if( db->mallocFailed ){
+    corruptSchema(pData, 0);
+    return SQLITE_NOMEM;
+  }
+
+  assert( argc==3 );
+  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
+  if( argv[1]==0 ){
+    corruptSchema(pData, 0);
+    return 1;
+  }
+  assert( iDb>=0 && iDb<db->nDb );
+  if( argv[2] && argv[2][0] ){
+    /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
+    ** But because db->init.busy is set to 1, no VDBE code is generated
+    ** or executed.  All the parser does is build the internal data
+    ** structures that describe the table, index, or view.
+    */
+    char *zErr;
+    int rc;
+    assert( db->init.busy );
+    db->init.iDb = iDb;
+    db->init.newTnum = atoi(argv[1]);
+    rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
+    db->init.iDb = 0;
+    assert( rc!=SQLITE_OK || zErr==0 );
+    if( SQLITE_OK!=rc ){
+      pData->rc = rc;
+      if( rc==SQLITE_NOMEM ){
+        db->mallocFailed = 1;
+      }else if( rc!=SQLITE_INTERRUPT ){
+        corruptSchema(pData, zErr);
+      }
+      sqlite3_free(zErr);
+      return 1;
+    }
+  }else if( argv[0]==0 ){
+    corruptSchema(pData, 0);
+  }else{
+    /* If the SQL column is blank it means this is an index that
+    ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
+    ** constraint for a CREATE TABLE.  The index should have already
+    ** been created when we processed the CREATE TABLE.  All we have
+    ** to do here is record the root page number for that index.
+    */
+    Index *pIndex;
+    pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
+    if( pIndex==0 || pIndex->tnum!=0 ){
+      /* This can occur if there exists an index on a TEMP table which
+      ** has the same name as another index on a permanent index.  Since
+      ** the permanent table is hidden by the TEMP table, we can also
+      ** safely ignore the index on the permanent table.
+      */
+      /* Do Nothing */;
+    }else{
+      pIndex->tnum = atoi(argv[1]);
+    }
+  }
+  return 0;
+}
+
+/*
+** Attempt to read the database schema and initialize internal
+** data structures for a single database file.  The index of the
+** database file is given by iDb.  iDb==0 is used for the main
+** database.  iDb==1 should never be used.  iDb>=2 is used for
+** auxiliary databases.  Return one of the SQLITE_ error codes to
+** indicate success or failure.
+*/
+static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
+  int rc;
+  BtCursor *curMain;
+  int size;
+  Table *pTab;
+  Db *pDb;
+  char const *azArg[4];
+  int meta[10];
+  InitData initData;
+  char const *zMasterSchema;
+  char const *zMasterName = SCHEMA_TABLE(iDb);
+
+  /*
+  ** The master database table has a structure like this
+  */
+  static const char master_schema[] = 
+     "CREATE TABLE sqlite_master(\n"
+     "  type text,\n"
+     "  name text,\n"
+     "  tbl_name text,\n"
+     "  rootpage integer,\n"
+     "  sql text\n"
+     ")"
+  ;
+#ifndef SQLITE_OMIT_TEMPDB
+  static const char temp_master_schema[] = 
+     "CREATE TEMP TABLE sqlite_temp_master(\n"
+     "  type text,\n"
+     "  name text,\n"
+     "  tbl_name text,\n"
+     "  rootpage integer,\n"
+     "  sql text\n"
+     ")"
+  ;
+#else
+  #define temp_master_schema 0
+#endif
+
+  assert( iDb>=0 && iDb<db->nDb );
+  assert( db->aDb[iDb].pSchema );
+  assert( sqlite3_mutex_held(db->mutex) );
+  assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
+
+  /* zMasterSchema and zInitScript are set to point at the master schema
+  ** and initialisation script appropriate for the database being
+  ** initialised. zMasterName is the name of the master table.
+  */
+  if( !OMIT_TEMPDB && iDb==1 ){
+    zMasterSchema = temp_master_schema;
+  }else{
+    zMasterSchema = master_schema;
+  }
+  zMasterName = SCHEMA_TABLE(iDb);
+
+  /* Construct the schema tables.  */
+  azArg[0] = zMasterName;
+  azArg[1] = "1";
+  azArg[2] = zMasterSchema;
+  azArg[3] = 0;
+  initData.db = db;
+  initData.iDb = iDb;
+  initData.pzErrMsg = pzErrMsg;
+  (void)sqlite3SafetyOff(db);
+  rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
+  (void)sqlite3SafetyOn(db);
+  if( rc ){
+    rc = initData.rc;
+    goto error_out;
+  }
+  pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
+  if( pTab ){
+    pTab->readOnly = 1;
+  }
+
+  /* Create a cursor to hold the database open
+  */
+  pDb = &db->aDb[iDb];
+  if( pDb->pBt==0 ){
+    if( !OMIT_TEMPDB && iDb==1 ){
+      DbSetProperty(db, 1, DB_SchemaLoaded);
+    }
+    return SQLITE_OK;
+  }
+  sqlite3BtreeEnter(pDb->pBt);
+  rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);
+  if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
+    sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
+    sqlite3BtreeLeave(pDb->pBt);
+    goto error_out;
+  }
+
+  /* Get the database meta information.
+  **
+  ** Meta values are as follows:
+  **    meta[0]   Schema cookie.  Changes with each schema change.
+  **    meta[1]   File format of schema layer.
+  **    meta[2]   Size of the page cache.
+  **    meta[3]   Use freelist if 0.  Autovacuum if greater than zero.
+  **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
+  **    meta[5]   The user cookie. Used by the application.
+  **    meta[6]   Incremental-vacuum flag.
+  **    meta[7]
+  **    meta[8]
+  **    meta[9]
+  **
+  ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
+  ** the possible values of meta[4].
+  */
+  if( rc==SQLITE_OK ){
+    int i;
+    for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){
+      rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
+    }
+    if( rc ){
+      sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
+      sqlite3BtreeCloseCursor(curMain);
+      sqlite3BtreeLeave(pDb->pBt);
+      goto error_out;
+    }
+  }else{
+    memset(meta, 0, sizeof(meta));
+  }
+  pDb->pSchema->schema_cookie = meta[0];
+
+  /* If opening a non-empty database, check the text encoding. For the
+  ** main database, set sqlite3.enc to the encoding of the main database.
+  ** For an attached db, it is an error if the encoding is not the same
+  ** as sqlite3.enc.
+  */
+  if( meta[4] ){  /* text encoding */
+    if( iDb==0 ){
+      /* If opening the main database, set ENC(db). */
+      ENC(db) = (u8)meta[4];
+      db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
+    }else{
+      /* If opening an attached database, the encoding much match ENC(db) */
+      if( meta[4]!=ENC(db) ){
+        sqlite3BtreeCloseCursor(curMain);
+        sqlite3SetString(pzErrMsg, "attached databases must use the same"
+            " text encoding as main database", (char*)0);
+        sqlite3BtreeLeave(pDb->pBt);
+        return SQLITE_ERROR;
+      }
+    }
+  }else{
+    DbSetProperty(db, iDb, DB_Empty);
+  }
+  pDb->pSchema->enc = ENC(db);
+
+  size = meta[2];
+  if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
+  if( size<0 ) size = -size;
+  pDb->pSchema->cache_size = size;
+  sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
+
+  /*
+  ** file_format==1    Version 3.0.0.
+  ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN
+  ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults
+  ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants
+  */
+  pDb->pSchema->file_format = meta[1];
+  if( pDb->pSchema->file_format==0 ){
+    pDb->pSchema->file_format = 1;
+  }
+  if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
+    sqlite3BtreeCloseCursor(curMain);
+    sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
+    sqlite3BtreeLeave(pDb->pBt);
+    return SQLITE_ERROR;
+  }
+
+  /* Ticket #2804:  When we open a database in the newer file format,
+  ** clear the legacy_file_format pragma flag so that a VACUUM will
+  ** not downgrade the database and thus invalidate any descending
+  ** indices that the user might have created.
+  */
+  if( iDb==0 && meta[1]>=4 ){
+    db->flags &= ~SQLITE_LegacyFileFmt;
+  }
+
+  /* Read the schema information out of the schema tables
+  */
+  assert( db->init.busy );
+  if( rc==SQLITE_EMPTY ){
+    /* For an empty database, there is nothing to read */
+    rc = SQLITE_OK;
+  }else{
+    char *zSql;
+    zSql = sqlite3MPrintf(db, 
+        "SELECT name, rootpage, sql FROM '%q'.%s",
+        db->aDb[iDb].zName, zMasterName);
+    (void)sqlite3SafetyOff(db);
+#ifndef SQLITE_OMIT_AUTHORIZATION
+    {
+      int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
+      xAuth = db->xAuth;
+      db->xAuth = 0;
+#endif
+      rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
+#ifndef SQLITE_OMIT_AUTHORIZATION
+      db->xAuth = xAuth;
+    }
+#endif
+    if( rc==SQLITE_ABORT ) rc = initData.rc;
+    (void)sqlite3SafetyOn(db);
+    sqlite3_free(zSql);
+#ifndef SQLITE_OMIT_ANALYZE
+    if( rc==SQLITE_OK ){
+      sqlite3AnalysisLoad(db, iDb);
+    }
+#endif
+    sqlite3BtreeCloseCursor(curMain);
+  }
+  if( db->mallocFailed ){
+    /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */
+    rc = SQLITE_NOMEM;
+    sqlite3ResetInternalSchema(db, 0);
+  }
+  if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
+    /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
+    ** the schema loaded, even if errors occured. In this situation the 
+    ** current sqlite3_prepare() operation will fail, but the following one
+    ** will attempt to compile the supplied statement against whatever subset
+    ** of the schema was loaded before the error occured. The primary
+    ** purpose of this is to allow access to the sqlite_master table
+    ** even when its contents have been corrupted.
+    */
+    DbSetProperty(db, iDb, DB_SchemaLoaded);
+    rc = SQLITE_OK;
+  }
+  sqlite3BtreeLeave(pDb->pBt);
+
+error_out:
+  if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
+    db->mallocFailed = 1;
+  }
+  return rc;
+}
+
+/*
+** Initialize all database files - the main database file, the file
+** used to store temporary tables, and any additional database files
+** created using ATTACH statements.  Return a success code.  If an
+** error occurs, write an error message into *pzErrMsg.
+**
+** After a database is initialized, the DB_SchemaLoaded bit is set
+** bit is set in the flags field of the Db structure. If the database
+** file was of zero-length, then the DB_Empty flag is also set.
+*/
+int sqlite3Init(sqlite3 *db, char **pzErrMsg){
+  int i, rc;
+  int commit_internal = !(db->flags&SQLITE_InternChanges);
+  
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( db->init.busy ) return SQLITE_OK;
+  rc = SQLITE_OK;
+  db->init.busy = 1;
+  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
+    if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
+    rc = sqlite3InitOne(db, i, pzErrMsg);
+    if( rc ){
+      sqlite3ResetInternalSchema(db, i);
+    }
+  }
+
+  /* Once all the other databases have been initialised, load the schema
+  ** for the TEMP database. This is loaded last, as the TEMP database
+  ** schema may contain references to objects in other databases.
+  */
+#ifndef SQLITE_OMIT_TEMPDB
+  if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
+    rc = sqlite3InitOne(db, 1, pzErrMsg);
+    if( rc ){
+      sqlite3ResetInternalSchema(db, 1);
+    }
+  }
+#endif
+
+  db->init.busy = 0;
+  if( rc==SQLITE_OK && commit_internal ){
+    sqlite3CommitInternalChanges(db);
+  }
+
+  return rc; 
+}
+
+/*
+** This routine is a no-op if the database schema is already initialised.
+** Otherwise, the schema is loaded. An error code is returned.
+*/
+int sqlite3ReadSchema(Parse *pParse){
+  int rc = SQLITE_OK;
+  sqlite3 *db = pParse->db;
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( !db->init.busy ){
+    rc = sqlite3Init(db, &pParse->zErrMsg);
+  }
+  if( rc!=SQLITE_OK ){
+    pParse->rc = rc;
+    pParse->nErr++;
+  }
+  return rc;
+}
+
+
+/*
+** Check schema cookies in all databases.  If any cookie is out
+** of date, return 0.  If all schema cookies are current, return 1.
+*/
+static int schemaIsValid(sqlite3 *db){
+  int iDb;
+  int rc;
+  BtCursor *curTemp;
+  int cookie;
+  int allOk = 1;
+
+  assert( sqlite3_mutex_held(db->mutex) );
+  for(iDb=0; allOk && iDb<db->nDb; iDb++){
+    Btree *pBt;
+    pBt = db->aDb[iDb].pBt;
+    if( pBt==0 ) continue;
+    rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp);
+    if( rc==SQLITE_OK ){
+      rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
+      if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
+        allOk = 0;
+      }
+      sqlite3BtreeCloseCursor(curTemp);
+    }
+    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
+      db->mallocFailed = 1;
+    }
+  }
+  return allOk;
+}
+
+/*
+** Convert a schema pointer into the iDb index that indicates
+** which database file in db->aDb[] the schema refers to.
+**
+** If the same database is attached more than once, the first
+** attached database is returned.
+*/
+int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
+  int i = -1000000;
+
+  /* If pSchema is NULL, then return -1000000. This happens when code in 
+  ** expr.c is trying to resolve a reference to a transient table (i.e. one
+  ** created by a sub-select). In this case the return value of this 
+  ** function should never be used.
+  **
+  ** We return -1000000 instead of the more usual -1 simply because using
+  ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much 
+  ** more likely to cause a segfault than -1 (of course there are assert()
+  ** statements too, but it never hurts to play the odds).
+  */
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( pSchema ){
+    for(i=0; i<db->nDb; i++){
+      if( db->aDb[i].pSchema==pSchema ){
+        break;
+      }
+    }
+    assert( i>=0 &&i>=0 &&  i<db->nDb );
+  }
+  return i;
+}
+
+/*
+** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
+*/
+int sqlite3Prepare(
+  sqlite3 *db,              /* Database handle. */
+  const char *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const char **pzTail       /* OUT: End of parsed string */
+){
+  Parse sParse;
+  char *zErrMsg = 0;
+  int rc = SQLITE_OK;
+  int i;
+
+  assert( ppStmt );
+  *ppStmt = 0;
+  if( sqlite3SafetyOn(db) ){
+    return SQLITE_MISUSE;
+  }
+  assert( !db->mallocFailed );
+  assert( sqlite3_mutex_held(db->mutex) );
+
+  /* If any attached database schemas are locked, do not proceed with
+  ** compilation. Instead return SQLITE_LOCKED immediately.
+  */
+  for(i=0; i<db->nDb; i++) {
+    Btree *pBt = db->aDb[i].pBt;
+    if( pBt ){
+      int rc;
+      rc = sqlite3BtreeSchemaLocked(pBt);
+      if( rc ){
+        const char *zDb = db->aDb[i].zName;
+        sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
+        (void)sqlite3SafetyOff(db);
+        return SQLITE_LOCKED;
+      }
+    }
+  }
+  
+  memset(&sParse, 0, sizeof(sParse));
+  sParse.db = db;
+  if( nBytes>=0 && zSql[nBytes]!=0 ){
+    char *zSqlCopy;
+    if( SQLITE_MAX_SQL_LENGTH>0 && nBytes>SQLITE_MAX_SQL_LENGTH ){
+      sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
+      (void)sqlite3SafetyOff(db);
+      return SQLITE_TOOBIG;
+    }
+    zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
+    if( zSqlCopy ){
+      sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
+      sqlite3_free(zSqlCopy);
+    }
+    sParse.zTail = &zSql[nBytes];
+  }else{
+    sqlite3RunParser(&sParse, zSql, &zErrMsg);
+  }
+
+  if( db->mallocFailed ){
+    sParse.rc = SQLITE_NOMEM;
+  }
+  if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
+  if( sParse.checkSchema && !schemaIsValid(db) ){
+    sParse.rc = SQLITE_SCHEMA;
+  }
+  if( sParse.rc==SQLITE_SCHEMA ){
+    sqlite3ResetInternalSchema(db, 0);
+  }
+  if( db->mallocFailed ){
+    sParse.rc = SQLITE_NOMEM;
+  }
+  if( pzTail ){
+    *pzTail = sParse.zTail;
+  }
+  rc = sParse.rc;
+
+#ifndef SQLITE_OMIT_EXPLAIN
+  if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
+    if( sParse.explain==2 ){
+      sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
+      sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P4_STATIC);
+    }else{
+      sqlite3VdbeSetNumCols(sParse.pVdbe, 8);
+      sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 5, COLNAME_NAME, "p4", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 6, COLNAME_NAME, "p5", P4_STATIC);
+      sqlite3VdbeSetColName(sParse.pVdbe, 7, COLNAME_NAME, "comment",P4_STATIC);
+    }
+  }
+#endif
+
+  if( sqlite3SafetyOff(db) ){
+    rc = SQLITE_MISUSE;
+  }
+
+  if( saveSqlFlag ){
+    sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
+  }
+  if( rc!=SQLITE_OK || db->mallocFailed ){
+    sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
+    assert(!(*ppStmt));
+  }else{
+    *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
+  }
+
+  if( zErrMsg ){
+    sqlite3Error(db, rc, "%s", zErrMsg);
+    sqlite3_free(zErrMsg);
+  }else{
+    sqlite3Error(db, rc, 0);
+  }
+
+  rc = sqlite3ApiExit(db, rc);
+  assert( (rc&db->errMask)==rc );
+  return rc;
+}
+static int sqlite3LockAndPrepare(
+  sqlite3 *db,              /* Database handle. */
+  const char *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const char **pzTail       /* OUT: End of parsed string */
+){
+  int rc;
+  if( !sqlite3SafetyCheckOk(db) ){
+    return SQLITE_MISUSE;
+  }
+  sqlite3_mutex_enter(db->mutex);
+  sqlite3BtreeEnterAll(db);
+  rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
+  sqlite3BtreeLeaveAll(db);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Rerun the compilation of a statement after a schema change.
+** Return true if the statement was recompiled successfully.
+** Return false if there is an error of some kind.
+*/
+int sqlite3Reprepare(Vdbe *p){
+  int rc;
+  sqlite3_stmt *pNew;
+  const char *zSql;
+  sqlite3 *db;
+
+  assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
+  zSql = sqlite3_sql((sqlite3_stmt *)p);
+  assert( zSql!=0 );  /* Reprepare only called for prepare_v2() statements */
+  db = sqlite3VdbeDb(p);
+  assert( sqlite3_mutex_held(db->mutex) );
+  rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
+  if( rc ){
+    if( rc==SQLITE_NOMEM ){
+      db->mallocFailed = 1;
+    }
+    assert( pNew==0 );
+    return 0;
+  }else{
+    assert( pNew!=0 );
+  }
+  sqlite3VdbeSwap((Vdbe*)pNew, p);
+  sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
+  sqlite3VdbeResetStepResult((Vdbe*)pNew);
+  sqlite3VdbeFinalize((Vdbe*)pNew);
+  return 1;
+}
+
+
+/*
+** Two versions of the official API.  Legacy and new use.  In the legacy
+** version, the original SQL text is not saved in the prepared statement
+** and so if a schema change occurs, SQLITE_SCHEMA is returned by
+** sqlite3_step().  In the new version, the original SQL text is retained
+** and the statement is automatically recompiled if an schema change
+** occurs.
+*/
+int sqlite3_prepare(
+  sqlite3 *db,              /* Database handle. */
+  const char *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const char **pzTail       /* OUT: End of parsed string */
+){
+  return sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
+}
+int sqlite3_prepare_v2(
+  sqlite3 *db,              /* Database handle. */
+  const char *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const char **pzTail       /* OUT: End of parsed string */
+){
+  return sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
+}
+
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
+*/
+static int sqlite3Prepare16(
+  sqlite3 *db,              /* Database handle. */ 
+  const void *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  int saveSqlFlag,          /* True to save SQL text into the sqlite3_stmt */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const void **pzTail       /* OUT: End of parsed string */
+){
+  /* This function currently works by first transforming the UTF-16
+  ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
+  ** tricky bit is figuring out the pointer to return in *pzTail.
+  */
+  char *zSql8;
+  const char *zTail8 = 0;
+  int rc = SQLITE_OK;
+
+  if( !sqlite3SafetyCheckOk(db) ){
+    return SQLITE_MISUSE;
+  }
+  sqlite3_mutex_enter(db->mutex);
+  zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
+  if( zSql8 ){
+    rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
+  }
+
+  if( zTail8 && pzTail ){
+    /* If sqlite3_prepare returns a tail pointer, we calculate the
+    ** equivalent pointer into the UTF-16 string by counting the unicode
+    ** characters between zSql8 and zTail8, and then returning a pointer
+    ** the same number of characters into the UTF-16 string.
+    */
+    int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);
+    *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
+  }
+  sqlite3_free(zSql8); 
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Two versions of the official API.  Legacy and new use.  In the legacy
+** version, the original SQL text is not saved in the prepared statement
+** and so if a schema change occurs, SQLITE_SCHEMA is returned by
+** sqlite3_step().  In the new version, the original SQL text is retained
+** and the statement is automatically recompiled if an schema change
+** occurs.
+*/
+int sqlite3_prepare16(
+  sqlite3 *db,              /* Database handle. */ 
+  const void *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const void **pzTail       /* OUT: End of parsed string */
+){
+  return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
+}
+int sqlite3_prepare16_v2(
+  sqlite3 *db,              /* Database handle. */ 
+  const void *zSql,         /* UTF-8 encoded SQL statement. */
+  int nBytes,               /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
+  const void **pzTail       /* OUT: End of parsed string */
+){
+  return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
+}
+
+#endif /* SQLITE_OMIT_UTF16 */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/printf.c b/client/src/thirdparty/sqlite-3.4.2/src/printf.c
new file mode 100644
index 0000000..eafe842
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/printf.c
@@ -0,0 +1,904 @@
+/*
+** The "printf" code that follows dates from the 1980's.  It is in
+** the public domain.  The original comments are included here for
+** completeness.  They are very out-of-date but might be useful as
+** an historical reference.  Most of the "enhancements" have been backed
+** out so that the functionality is now the same as standard printf().
+**
+**************************************************************************
+**
+** The following modules is an enhanced replacement for the "printf" subroutines
+** found in the standard C library.  The following enhancements are
+** supported:
+**
+**      +  Additional functions.  The standard set of "printf" functions
+**         includes printf, fprintf, sprintf, vprintf, vfprintf, and
+**         vsprintf.  This module adds the following:
+**
+**           *  snprintf -- Works like sprintf, but has an extra argument
+**                          which is the size of the buffer written to.
+**
+**           *  mprintf --  Similar to sprintf.  Writes output to memory
+**                          obtained from malloc.
+**
+**           *  xprintf --  Calls a function to dispose of output.
+**
+**           *  nprintf --  No output, but returns the number of characters
+**                          that would have been output by printf.
+**
+**           *  A v- version (ex: vsnprintf) of every function is also
+**              supplied.
+**
+**      +  A few extensions to the formatting notation are supported:
+**
+**           *  The "=" flag (similar to "-") causes the output to be
+**              be centered in the appropriately sized field.
+**
+**           *  The %b field outputs an integer in binary notation.
+**
+**           *  The %c field now accepts a precision.  The character output
+**              is repeated by the number of times the precision specifies.
+**
+**           *  The %' field works like %c, but takes as its character the
+**              next character of the format string, instead of the next
+**              argument.  For example,  printf("%.78'-")  prints 78 minus
+**              signs, the same as  printf("%.78c",'-').
+**
+**      +  When compiled using GCC on a SPARC, this version of printf is
+**         faster than the library printf for SUN OS 4.1.
+**
+**      +  All functions are fully reentrant.
+**
+*/
+#include "sqliteInt.h"
+
+/*
+** Conversion types fall into various categories as defined by the
+** following enumeration.
+*/
+#define etRADIX       1 /* Integer types.  %d, %x, %o, and so forth */
+#define etFLOAT       2 /* Floating point.  %f */
+#define etEXP         3 /* Exponentional notation. %e and %E */
+#define etGENERIC     4 /* Floating or exponential, depending on exponent. %g */
+#define etSIZE        5 /* Return number of characters processed so far. %n */
+#define etSTRING      6 /* Strings. %s */
+#define etDYNSTRING   7 /* Dynamically allocated strings. %z */
+#define etPERCENT     8 /* Percent symbol. %% */
+#define etCHARX       9 /* Characters. %c */
+/* The rest are extensions, not normally found in printf() */
+#define etCHARLIT    10 /* Literal characters.  %' */
+#define etSQLESCAPE  11 /* Strings with '\'' doubled.  %q */
+#define etSQLESCAPE2 12 /* Strings with '\'' doubled and enclosed in '',
+                          NULL pointers replaced by SQL NULL.  %Q */
+#define etTOKEN      13 /* a pointer to a Token structure */
+#define etSRCLIST    14 /* a pointer to a SrcList */
+#define etPOINTER    15 /* The %p conversion */
+#define etSQLESCAPE3 16 /* %w -> Strings with '\"' doubled */
+#define etORDINAL    17 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
+
+
+/*
+** An "etByte" is an 8-bit unsigned value.
+*/
+typedef unsigned char etByte;
+
+/*
+** Each builtin conversion character (ex: the 'd' in "%d") is described
+** by an instance of the following structure
+*/
+typedef struct et_info {   /* Information about each format field */
+  char fmttype;            /* The format field code letter */
+  etByte base;             /* The base for radix conversion */
+  etByte flags;            /* One or more of FLAG_ constants below */
+  etByte type;             /* Conversion paradigm */
+  etByte charset;          /* Offset into aDigits[] of the digits string */
+  etByte prefix;           /* Offset into aPrefix[] of the prefix string */
+} et_info;
+
+/*
+** Allowed values for et_info.flags
+*/
+#define FLAG_SIGNED  1     /* True if the value to convert is signed */
+#define FLAG_INTERN  2     /* True if for internal use only */
+#define FLAG_STRING  4     /* Allow infinity precision */
+
+
+/*
+** The following table is searched linearly, so it is good to put the
+** most frequently used conversion types first.
+*/
+static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
+static const char aPrefix[] = "-x0\000X0";
+static const et_info fmtinfo[] = {
+  {  'd', 10, 1, etRADIX,      0,  0 },
+  {  's',  0, 4, etSTRING,     0,  0 },
+  {  'g',  0, 1, etGENERIC,    30, 0 },
+  {  'z',  0, 4, etDYNSTRING,  0,  0 },
+  {  'q',  0, 4, etSQLESCAPE,  0,  0 },
+  {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
+  {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
+  {  'c',  0, 0, etCHARX,      0,  0 },
+  {  'o',  8, 0, etRADIX,      0,  2 },
+  {  'u', 10, 0, etRADIX,      0,  0 },
+  {  'x', 16, 0, etRADIX,      16, 1 },
+  {  'X', 16, 0, etRADIX,      0,  4 },
+#ifndef SQLITE_OMIT_FLOATING_POINT
+  {  'f',  0, 1, etFLOAT,      0,  0 },
+  {  'e',  0, 1, etEXP,        30, 0 },
+  {  'E',  0, 1, etEXP,        14, 0 },
+  {  'G',  0, 1, etGENERIC,    14, 0 },
+#endif
+  {  'i', 10, 1, etRADIX,      0,  0 },
+  {  'n',  0, 0, etSIZE,       0,  0 },
+  {  '%',  0, 0, etPERCENT,    0,  0 },
+  {  'p', 16, 0, etPOINTER,    0,  1 },
+  {  'T',  0, 2, etTOKEN,      0,  0 },
+  {  'S',  0, 2, etSRCLIST,    0,  0 },
+  {  'r', 10, 3, etORDINAL,    0,  0 },
+};
+#define etNINFO  (sizeof(fmtinfo)/sizeof(fmtinfo[0]))
+
+/*
+** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
+** conversions will work.
+*/
+#ifndef SQLITE_OMIT_FLOATING_POINT
+/*
+** "*val" is a double such that 0.1 <= *val < 10.0
+** Return the ascii code for the leading digit of *val, then
+** multiply "*val" by 10.0 to renormalize.
+**
+** Example:
+**     input:     *val = 3.14159
+**     output:    *val = 1.4159    function return = '3'
+**
+** The counter *cnt is incremented each time.  After counter exceeds
+** 16 (the number of significant digits in a 64-bit float) '0' is
+** always returned.
+*/
+static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
+  int digit;
+  LONGDOUBLE_TYPE d;
+  if( (*cnt)++ >= 16 ) return '0';
+  digit = (int)*val;
+  d = digit;
+  digit += '0';
+  *val = (*val - d)*10.0;
+  return digit;
+}
+#endif /* SQLITE_OMIT_FLOATING_POINT */
+
+/*
+** Append N space characters to the given string buffer.
+*/
+static void appendSpace(StrAccum *pAccum, int N){
+  static const char zSpaces[] = "                             ";
+  while( N>=sizeof(zSpaces)-1 ){
+    sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
+    N -= sizeof(zSpaces)-1;
+  }
+  if( N>0 ){
+    sqlite3StrAccumAppend(pAccum, zSpaces, N);
+  }
+}
+
+/*
+** On machines with a small stack size, you can redefine the
+** SQLITE_PRINT_BUF_SIZE to be less than 350.  But beware - for
+** smaller values some %f conversions may go into an infinite loop.
+*/
+#ifndef SQLITE_PRINT_BUF_SIZE
+# define SQLITE_PRINT_BUF_SIZE 350
+#endif
+#define etBUFSIZE SQLITE_PRINT_BUF_SIZE  /* Size of the output buffer */
+
+/*
+** The root program.  All variations call this core.
+**
+** INPUTS:
+**   func   This is a pointer to a function taking three arguments
+**            1. A pointer to anything.  Same as the "arg" parameter.
+**            2. A pointer to the list of characters to be output
+**               (Note, this list is NOT null terminated.)
+**            3. An integer number of characters to be output.
+**               (Note: This number might be zero.)
+**
+**   arg    This is the pointer to anything which will be passed as the
+**          first argument to "func".  Use it for whatever you like.
+**
+**   fmt    This is the format string, as in the usual print.
+**
+**   ap     This is a pointer to a list of arguments.  Same as in
+**          vfprint.
+**
+** OUTPUTS:
+**          The return value is the total number of characters sent to
+**          the function "func".  Returns -1 on a error.
+**
+** Note that the order in which automatic variables are declared below
+** seems to make a big difference in determining how fast this beast
+** will run.
+*/
+static void vxprintf(
+  StrAccum *pAccum,                  /* Accumulate results here */
+  int useExtended,                   /* Allow extended %-conversions */
+  const char *fmt,                   /* Format string */
+  va_list ap                         /* arguments */
+){
+  int c;                     /* Next character in the format string */
+  char *bufpt;               /* Pointer to the conversion buffer */
+  int precision;             /* Precision of the current field */
+  int length;                /* Length of the field */
+  int idx;                   /* A general purpose loop counter */
+  int width;                 /* Width of the current field */
+  etByte flag_leftjustify;   /* True if "-" flag is present */
+  etByte flag_plussign;      /* True if "+" flag is present */
+  etByte flag_blanksign;     /* True if " " flag is present */
+  etByte flag_alternateform; /* True if "#" flag is present */
+  etByte flag_altform2;      /* True if "!" flag is present */
+  etByte flag_zeropad;       /* True if field width constant starts with zero */
+  etByte flag_long;          /* True if "l" flag is present */
+  etByte flag_longlong;      /* True if the "ll" flag is present */
+  etByte done;               /* Loop termination flag */
+  sqlite_uint64 longvalue;   /* Value for integer types */
+  LONGDOUBLE_TYPE realvalue; /* Value for real types */
+  const et_info *infop;      /* Pointer to the appropriate info structure */
+  char buf[etBUFSIZE];       /* Conversion buffer */
+  char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
+  etByte errorflag = 0;      /* True if an error is encountered */
+  etByte xtype;              /* Conversion paradigm */
+  char *zExtra;              /* Extra memory used for etTCLESCAPE conversions */
+#ifndef SQLITE_OMIT_FLOATING_POINT
+  int  exp, e2;              /* exponent of real numbers */
+  double rounder;            /* Used for rounding floating point values */
+  etByte flag_dp;            /* True if decimal point should be shown */
+  etByte flag_rtz;           /* True if trailing zeros should be removed */
+  etByte flag_exp;           /* True to force display of the exponent */
+  int nsd;                   /* Number of significant digits returned */
+#endif
+
+  length = 0;
+  bufpt = 0;
+  for(; (c=(*fmt))!=0; ++fmt){
+    if( c!='%' ){
+      int amt;
+      bufpt = (char *)fmt;
+      amt = 1;
+      while( (c=(*++fmt))!='%' && c!=0 ) amt++;
+      sqlite3StrAccumAppend(pAccum, bufpt, amt);
+      if( c==0 ) break;
+    }
+    if( (c=(*++fmt))==0 ){
+      errorflag = 1;
+      sqlite3StrAccumAppend(pAccum, "%", 1);
+      break;
+    }
+    /* Find out what flags are present */
+    flag_leftjustify = flag_plussign = flag_blanksign = 
+     flag_alternateform = flag_altform2 = flag_zeropad = 0;
+    done = 0;
+    do{
+      switch( c ){
+        case '-':   flag_leftjustify = 1;     break;
+        case '+':   flag_plussign = 1;        break;
+        case ' ':   flag_blanksign = 1;       break;
+        case '#':   flag_alternateform = 1;   break;
+        case '!':   flag_altform2 = 1;        break;
+        case '0':   flag_zeropad = 1;         break;
+        default:    done = 1;                 break;
+      }
+    }while( !done && (c=(*++fmt))!=0 );
+    /* Get the field width */
+    width = 0;
+    if( c=='*' ){
+      width = va_arg(ap,int);
+      if( width<0 ){
+        flag_leftjustify = 1;
+        width = -width;
+      }
+      c = *++fmt;
+    }else{
+      while( c>='0' && c<='9' ){
+        width = width*10 + c - '0';
+        c = *++fmt;
+      }
+    }
+    if( width > etBUFSIZE-10 ){
+      width = etBUFSIZE-10;
+    }
+    /* Get the precision */
+    if( c=='.' ){
+      precision = 0;
+      c = *++fmt;
+      if( c=='*' ){
+        precision = va_arg(ap,int);
+        if( precision<0 ) precision = -precision;
+        c = *++fmt;
+      }else{
+        while( c>='0' && c<='9' ){
+          precision = precision*10 + c - '0';
+          c = *++fmt;
+        }
+      }
+    }else{
+      precision = -1;
+    }
+    /* Get the conversion type modifier */
+    if( c=='l' ){
+      flag_long = 1;
+      c = *++fmt;
+      if( c=='l' ){
+        flag_longlong = 1;
+        c = *++fmt;
+      }else{
+        flag_longlong = 0;
+      }
+    }else{
+      flag_long = flag_longlong = 0;
+    }
+    /* Fetch the info entry for the field */
+    infop = 0;
+    for(idx=0; idx<etNINFO; idx++){
+      if( c==fmtinfo[idx].fmttype ){
+        infop = &fmtinfo[idx];
+        if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
+          xtype = infop->type;
+        }else{
+          return;
+        }
+        break;
+      }
+    }
+    zExtra = 0;
+    if( infop==0 ){
+      return;
+    }
+
+
+    /* Limit the precision to prevent overflowing buf[] during conversion */
+    if( precision>etBUFSIZE-40 && (infop->flags & FLAG_STRING)==0 ){
+      precision = etBUFSIZE-40;
+    }
+
+    /*
+    ** At this point, variables are initialized as follows:
+    **
+    **   flag_alternateform          TRUE if a '#' is present.
+    **   flag_altform2               TRUE if a '!' is present.
+    **   flag_plussign               TRUE if a '+' is present.
+    **   flag_leftjustify            TRUE if a '-' is present or if the
+    **                               field width was negative.
+    **   flag_zeropad                TRUE if the width began with 0.
+    **   flag_long                   TRUE if the letter 'l' (ell) prefixed
+    **                               the conversion character.
+    **   flag_longlong               TRUE if the letter 'll' (ell ell) prefixed
+    **                               the conversion character.
+    **   flag_blanksign              TRUE if a ' ' is present.
+    **   width                       The specified field width.  This is
+    **                               always non-negative.  Zero is the default.
+    **   precision                   The specified precision.  The default
+    **                               is -1.
+    **   xtype                       The class of the conversion.
+    **   infop                       Pointer to the appropriate info struct.
+    */
+    switch( xtype ){
+      case etPOINTER:
+        flag_longlong = sizeof(char*)==sizeof(i64);
+        flag_long = sizeof(char*)==sizeof(long int);
+        /* Fall through into the next case */
+      case etORDINAL:
+      case etRADIX:
+        if( infop->flags & FLAG_SIGNED ){
+          i64 v;
+          if( flag_longlong )   v = va_arg(ap,i64);
+          else if( flag_long )  v = va_arg(ap,long int);
+          else                  v = va_arg(ap,int);
+          if( v<0 ){
+            longvalue = -v;
+            prefix = '-';
+          }else{
+            longvalue = v;
+            if( flag_plussign )        prefix = '+';
+            else if( flag_blanksign )  prefix = ' ';
+            else                       prefix = 0;
+          }
+        }else{
+          if( flag_longlong )   longvalue = va_arg(ap,u64);
+          else if( flag_long )  longvalue = va_arg(ap,unsigned long int);
+          else                  longvalue = va_arg(ap,unsigned int);
+          prefix = 0;
+        }
+        if( longvalue==0 ) flag_alternateform = 0;
+        if( flag_zeropad && precision<width-(prefix!=0) ){
+          precision = width-(prefix!=0);
+        }
+        bufpt = &buf[etBUFSIZE-1];
+        if( xtype==etORDINAL ){
+          static const char zOrd[] = "thstndrd";
+          int x = longvalue % 10;
+          if( x>=4 || (longvalue/10)%10==1 ){
+            x = 0;
+          }
+          buf[etBUFSIZE-3] = zOrd[x*2];
+          buf[etBUFSIZE-2] = zOrd[x*2+1];
+          bufpt -= 2;
+        }
+        {
+          register const char *cset;      /* Use registers for speed */
+          register int base;
+          cset = &aDigits[infop->charset];
+          base = infop->base;
+          do{                                           /* Convert to ascii */
+            *(--bufpt) = cset[longvalue%base];
+            longvalue = longvalue/base;
+          }while( longvalue>0 );
+        }
+        length = &buf[etBUFSIZE-1]-bufpt;
+        for(idx=precision-length; idx>0; idx--){
+          *(--bufpt) = '0';                             /* Zero pad */
+        }
+        if( prefix ) *(--bufpt) = prefix;               /* Add sign */
+        if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
+          const char *pre;
+          char x;
+          pre = &aPrefix[infop->prefix];
+          if( *bufpt!=pre[0] ){
+            for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
+          }
+        }
+        length = &buf[etBUFSIZE-1]-bufpt;
+        break;
+      case etFLOAT:
+      case etEXP:
+      case etGENERIC:
+        realvalue = va_arg(ap,double);
+#ifndef SQLITE_OMIT_FLOATING_POINT
+        if( precision<0 ) precision = 6;         /* Set default precision */
+        if( precision>etBUFSIZE/2-10 ) precision = etBUFSIZE/2-10;
+        if( realvalue<0.0 ){
+          realvalue = -realvalue;
+          prefix = '-';
+        }else{
+          if( flag_plussign )          prefix = '+';
+          else if( flag_blanksign )    prefix = ' ';
+          else                         prefix = 0;
+        }
+        if( xtype==etGENERIC && precision>0 ) precision--;
+#if 0
+        /* Rounding works like BSD when the constant 0.4999 is used.  Wierd! */
+        for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
+#else
+        /* It makes more sense to use 0.5 */
+        for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
+#endif
+        if( xtype==etFLOAT ) realvalue += rounder;
+        /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
+        exp = 0;
+        if( sqlite3_isnan(realvalue) ){
+          bufpt = "NaN";
+          length = 3;
+          break;
+        }
+        if( realvalue>0.0 ){
+          while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
+          while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
+          while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
+          while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; }
+          while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; }
+          if( exp>350 || exp<-350 ){
+            if( prefix=='-' ){
+              bufpt = "-Inf";
+            }else if( prefix=='+' ){
+              bufpt = "+Inf";
+            }else{
+              bufpt = "Inf";
+            }
+            length = strlen(bufpt);
+            break;
+          }
+        }
+        bufpt = buf;
+        /*
+        ** If the field type is etGENERIC, then convert to either etEXP
+        ** or etFLOAT, as appropriate.
+        */
+        flag_exp = xtype==etEXP;
+        if( xtype!=etFLOAT ){
+          realvalue += rounder;
+          if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
+        }
+        if( xtype==etGENERIC ){
+          flag_rtz = !flag_alternateform;
+          if( exp<-4 || exp>precision ){
+            xtype = etEXP;
+          }else{
+            precision = precision - exp;
+            xtype = etFLOAT;
+          }
+        }else{
+          flag_rtz = 0;
+        }
+        if( xtype==etEXP ){
+          e2 = 0;
+        }else{
+          e2 = exp;
+        }
+        nsd = 0;
+        flag_dp = (precision>0) | flag_alternateform | flag_altform2;
+        /* The sign in front of the number */
+        if( prefix ){
+          *(bufpt++) = prefix;
+        }
+        /* Digits prior to the decimal point */
+        if( e2<0 ){
+          *(bufpt++) = '0';
+        }else{
+          for(; e2>=0; e2--){
+            *(bufpt++) = et_getdigit(&realvalue,&nsd);
+          }
+        }
+        /* The decimal point */
+        if( flag_dp ){
+          *(bufpt++) = '.';
+        }
+        /* "0" digits after the decimal point but before the first
+        ** significant digit of the number */
+        for(e2++; e2<0 && precision>0; precision--, e2++){
+          *(bufpt++) = '0';
+        }
+        /* Significant digits after the decimal point */
+        while( (precision--)>0 ){
+          *(bufpt++) = et_getdigit(&realvalue,&nsd);
+        }
+        /* Remove trailing zeros and the "." if no digits follow the "." */
+        if( flag_rtz && flag_dp ){
+          while( bufpt[-1]=='0' ) *(--bufpt) = 0;
+          assert( bufpt>buf );
+          if( bufpt[-1]=='.' ){
+            if( flag_altform2 ){
+              *(bufpt++) = '0';
+            }else{
+              *(--bufpt) = 0;
+            }
+          }
+        }
+        /* Add the "eNNN" suffix */
+        if( flag_exp || (xtype==etEXP && exp) ){
+          *(bufpt++) = aDigits[infop->charset];
+          if( exp<0 ){
+            *(bufpt++) = '-'; exp = -exp;
+          }else{
+            *(bufpt++) = '+';
+          }
+          if( exp>=100 ){
+            *(bufpt++) = (exp/100)+'0';                /* 100's digit */
+            exp %= 100;
+          }
+          *(bufpt++) = exp/10+'0';                     /* 10's digit */
+          *(bufpt++) = exp%10+'0';                     /* 1's digit */
+        }
+        *bufpt = 0;
+
+        /* The converted number is in buf[] and zero terminated. Output it.
+        ** Note that the number is in the usual order, not reversed as with
+        ** integer conversions. */
+        length = bufpt-buf;
+        bufpt = buf;
+
+        /* Special case:  Add leading zeros if the flag_zeropad flag is
+        ** set and we are not left justified */
+        if( flag_zeropad && !flag_leftjustify && length < width){
+          int i;
+          int nPad = width - length;
+          for(i=width; i>=nPad; i--){
+            bufpt[i] = bufpt[i-nPad];
+          }
+          i = prefix!=0;
+          while( nPad-- ) bufpt[i++] = '0';
+          length = width;
+        }
+#endif
+        break;
+      case etSIZE:
+        *(va_arg(ap,int*)) = pAccum->nChar;
+        length = width = 0;
+        break;
+      case etPERCENT:
+        buf[0] = '%';
+        bufpt = buf;
+        length = 1;
+        break;
+      case etCHARLIT:
+      case etCHARX:
+        c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt);
+        if( precision>=0 ){
+          for(idx=1; idx<precision; idx++) buf[idx] = c;
+          length = precision;
+        }else{
+          length =1;
+        }
+        bufpt = buf;
+        break;
+      case etSTRING:
+      case etDYNSTRING:
+        bufpt = va_arg(ap,char*);
+        if( bufpt==0 ){
+          bufpt = "";
+        }else if( xtype==etDYNSTRING ){
+          zExtra = bufpt;
+        }
+        length = strlen(bufpt);
+        if( precision>=0 && precision<length ) length = precision;
+        break;
+      case etSQLESCAPE:
+      case etSQLESCAPE2:
+      case etSQLESCAPE3: {
+        int i, j, n, ch, isnull;
+        int needQuote;
+        char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
+        char *escarg = va_arg(ap,char*);
+        isnull = escarg==0;
+        if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
+        for(i=n=0; (ch=escarg[i])!=0; i++){
+          if( ch==q )  n++;
+        }
+        needQuote = !isnull && xtype==etSQLESCAPE2;
+        n += i + 1 + needQuote*2;
+        if( n>etBUFSIZE ){
+          bufpt = zExtra = sqlite3_malloc( n );
+          if( bufpt==0 ) return;
+        }else{
+          bufpt = buf;
+        }
+        j = 0;
+        if( needQuote ) bufpt[j++] = q;
+        for(i=0; (ch=escarg[i])!=0; i++){
+          bufpt[j++] = ch;
+          if( ch==q ) bufpt[j++] = ch;
+        }
+        if( needQuote ) bufpt[j++] = q;
+        bufpt[j] = 0;
+        length = j;
+        /* The precision is ignored on %q and %Q */
+        /* if( precision>=0 && precision<length ) length = precision; */
+        break;
+      }
+      case etTOKEN: {
+        Token *pToken = va_arg(ap, Token*);
+        if( pToken && pToken->z ){
+          sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
+        }
+        length = width = 0;
+        break;
+      }
+      case etSRCLIST: {
+        SrcList *pSrc = va_arg(ap, SrcList*);
+        int k = va_arg(ap, int);
+        struct SrcList_item *pItem = &pSrc->a[k];
+        assert( k>=0 && k<pSrc->nSrc );
+        if( pItem->zDatabase && pItem->zDatabase[0] ){
+          sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
+          sqlite3StrAccumAppend(pAccum, ".", 1);
+        }
+        sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
+        length = width = 0;
+        break;
+      }
+    }/* End switch over the format type */
+    /*
+    ** The text of the conversion is pointed to by "bufpt" and is
+    ** "length" characters long.  The field width is "width".  Do
+    ** the output.
+    */
+    if( !flag_leftjustify ){
+      register int nspace;
+      nspace = width-length;
+      if( nspace>0 ){
+        appendSpace(pAccum, nspace);
+      }
+    }
+    if( length>0 ){
+      sqlite3StrAccumAppend(pAccum, bufpt, length);
+    }
+    if( flag_leftjustify ){
+      register int nspace;
+      nspace = width-length;
+      if( nspace>0 ){
+        appendSpace(pAccum, nspace);
+      }
+    }
+    if( zExtra ){
+      sqlite3_free(zExtra);
+    }
+  }/* End for loop over the format string */
+} /* End of function */
+
+/*
+** Append N bytes of text from z to the StrAccum object.
+*/
+void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
+  if( p->tooBig | p->mallocFailed ){
+    return;
+  }
+  if( N<0 ){
+    N = strlen(z);
+  }
+  if( N==0 ){
+    return;
+  }
+  if( p->nChar+N >= p->nAlloc ){
+    char *zNew;
+    if( !p->useMalloc ){
+      p->tooBig = 1;
+      N = p->nAlloc - p->nChar - 1;
+      if( N<=0 ){
+        return;
+      }
+    }else{
+      p->nAlloc += p->nAlloc + N + 1;
+      if( p->nAlloc > SQLITE_MAX_LENGTH ){
+        p->nAlloc = SQLITE_MAX_LENGTH;
+        if( p->nChar+N >= p->nAlloc ){
+          sqlite3StrAccumReset(p);
+          p->tooBig = 1;
+          return;
+        }
+      }
+      zNew = sqlite3_malloc( p->nAlloc );
+      if( zNew ){
+        memcpy(zNew, p->zText, p->nChar);
+        sqlite3StrAccumReset(p);
+        p->zText = zNew;
+      }else{
+        p->mallocFailed = 1;
+        sqlite3StrAccumReset(p);
+        return;
+      }
+    }
+  }
+  memcpy(&p->zText[p->nChar], z, N);
+  p->nChar += N;
+}
+
+/*
+** Finish off a string by making sure it is zero-terminated.
+** Return a pointer to the resulting string.  Return a NULL
+** pointer if any kind of error was encountered.
+*/
+char *sqlite3StrAccumFinish(StrAccum *p){
+  if( p->zText ){
+    p->zText[p->nChar] = 0;
+    if( p->useMalloc && p->zText==p->zBase ){
+      p->zText = sqlite3_malloc( p->nChar+1 );
+      if( p->zText ){
+        memcpy(p->zText, p->zBase, p->nChar+1);
+      }else{
+        p->mallocFailed = 1;
+      }
+    }
+  }
+  return p->zText;
+}
+
+/*
+** Reset an StrAccum string.  Reclaim all malloced memory.
+*/
+void sqlite3StrAccumReset(StrAccum *p){
+  if( p->zText!=p->zBase ){
+    sqlite3_free(p->zText);
+    p->zText = 0;
+  }
+}
+
+/*
+** Initialize a string accumulator
+*/
+static void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n){
+  p->zText = p->zBase = zBase;
+  p->nChar = 0;
+  p->nAlloc = n;
+  p->useMalloc = 1;
+  p->tooBig = 0;
+  p->mallocFailed = 0;
+}
+
+/*
+** Print into memory obtained from sqliteMalloc().  Use the internal
+** %-conversion extensions.
+*/
+char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
+  char *z;
+  char zBase[SQLITE_PRINT_BUF_SIZE];
+  StrAccum acc;
+  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase));
+  vxprintf(&acc, 1, zFormat, ap);
+  z = sqlite3StrAccumFinish(&acc);
+  if( acc.mallocFailed && db ){
+    db->mallocFailed = 1;
+  }
+  return z;
+}
+
+/*
+** Print into memory obtained from sqliteMalloc().  Use the internal
+** %-conversion extensions.
+*/
+char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
+  va_list ap;
+  char *z;
+  va_start(ap, zFormat);
+  z = sqlite3VMPrintf(db, zFormat, ap);
+  va_end(ap);
+  return z;
+}
+
+/*
+** Print into memory obtained from sqlite3_malloc().  Omit the internal
+** %-conversion extensions.
+*/
+char *sqlite3_vmprintf(const char *zFormat, va_list ap){
+  char *z;
+  char zBase[SQLITE_PRINT_BUF_SIZE];
+  StrAccum acc;
+  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase));
+  vxprintf(&acc, 0, zFormat, ap);
+  z = sqlite3StrAccumFinish(&acc);
+  return z;
+}
+
+/*
+** Print into memory obtained from sqlite3_malloc()().  Omit the internal
+** %-conversion extensions.
+*/
+char *sqlite3_mprintf(const char *zFormat, ...){
+  va_list ap;
+  char *z;
+  va_start(ap, zFormat);
+  z = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  return z;
+}
+
+/*
+** sqlite3_snprintf() works like snprintf() except that it ignores the
+** current locale settings.  This is important for SQLite because we
+** are not able to use a "," as the decimal point in place of "." as
+** specified by some locales.
+*/
+char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
+  char *z;
+  va_list ap;
+  StrAccum acc;
+
+  if( n<=0 ){
+    return zBuf;
+  }
+  sqlite3StrAccumInit(&acc, zBuf, n);
+  acc.useMalloc = 0;
+  va_start(ap,zFormat);
+  vxprintf(&acc, 0, zFormat, ap);
+  va_end(ap);
+  z = sqlite3StrAccumFinish(&acc);
+  return z;
+}
+
+#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) || defined(SQLITE_MEMDEBUG)
+/*
+** A version of printf() that understands %lld.  Used for debugging.
+** The printf() built into some versions of windows does not understand %lld
+** and segfaults if you give it a long long int.
+*/
+void sqlite3DebugPrintf(const char *zFormat, ...){
+  va_list ap;
+  StrAccum acc;
+  char zBuf[500];
+  sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf));
+  acc.useMalloc = 0;
+  va_start(ap,zFormat);
+  vxprintf(&acc, 0, zFormat, ap);
+  va_end(ap);
+  sqlite3StrAccumFinish(&acc);
+  fprintf(stdout,"%s", zBuf);
+  fflush(stdout);
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/random.c b/client/src/thirdparty/sqlite-3.4.2/src/random.c
new file mode 100644
index 0000000..8684ce6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/random.c
@@ -0,0 +1,121 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains code to implement a pseudo-random number
+** generator (PRNG) for SQLite.
+**
+** Random numbers are used by some of the database backends in order
+** to generate random integer keys for tables or random filenames.
+**
+** $Id: random.c,v 1.21 2008/01/16 17:46:38 drh Exp $
+*/
+#include "sqliteInt.h"
+
+
+/* All threads share a single random number generator.
+** This structure is the current state of the generator.
+*/
+static struct sqlite3PrngType {
+  unsigned char isInit;          /* True if initialized */
+  unsigned char i, j;            /* State variables */
+  unsigned char s[256];          /* State variables */
+} sqlite3Prng;
+
+/*
+** Get a single 8-bit random value from the RC4 PRNG.  The Mutex
+** must be held while executing this routine.
+**
+** Why not just use a library random generator like lrand48() for this?
+** Because the OP_NewRowid opcode in the VDBE depends on having a very
+** good source of random numbers.  The lrand48() library function may
+** well be good enough.  But maybe not.  Or maybe lrand48() has some
+** subtle problems on some systems that could cause problems.  It is hard
+** to know.  To minimize the risk of problems due to bad lrand48()
+** implementations, SQLite uses this random number generator based
+** on RC4, which we know works very well.
+**
+** (Later):  Actually, OP_NewRowid does not depend on a good source of
+** randomness any more.  But we will leave this code in all the same.
+*/
+static int randomByte(void){
+  unsigned char t;
+
+
+  /* Initialize the state of the random number generator once,
+  ** the first time this routine is called.  The seed value does
+  ** not need to contain a lot of randomness since we are not
+  ** trying to do secure encryption or anything like that...
+  **
+  ** Nothing in this file or anywhere else in SQLite does any kind of
+  ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
+  ** number generator) not as an encryption device.
+  */
+  if( !sqlite3Prng.isInit ){
+    int i;
+    char k[256];
+    sqlite3Prng.j = 0;
+    sqlite3Prng.i = 0;
+    sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
+    for(i=0; i<256; i++){
+      sqlite3Prng.s[i] = i;
+    }
+    for(i=0; i<256; i++){
+      sqlite3Prng.j += sqlite3Prng.s[i] + k[i];
+      t = sqlite3Prng.s[sqlite3Prng.j];
+      sqlite3Prng.s[sqlite3Prng.j] = sqlite3Prng.s[i];
+      sqlite3Prng.s[i] = t;
+    }
+    sqlite3Prng.isInit = 1;
+  }
+
+  /* Generate and return single random byte
+  */
+  sqlite3Prng.i++;
+  t = sqlite3Prng.s[sqlite3Prng.i];
+  sqlite3Prng.j += t;
+  sqlite3Prng.s[sqlite3Prng.i] = sqlite3Prng.s[sqlite3Prng.j];
+  sqlite3Prng.s[sqlite3Prng.j] = t;
+  t += sqlite3Prng.s[sqlite3Prng.i];
+  return sqlite3Prng.s[t];
+}
+
+/*
+** Return N random bytes.
+*/
+void sqlite3Randomness(int N, void *pBuf){
+  unsigned char *zBuf = pBuf;
+  static sqlite3_mutex *mutex = 0;
+  if( mutex==0 ){
+    mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG);
+  }
+  sqlite3_mutex_enter(mutex);
+  while( N-- ){
+    *(zBuf++) = randomByte();
+  }
+  sqlite3_mutex_leave(mutex);
+}
+
+#ifdef SQLITE_TEST
+/*
+** For testing purposes, we sometimes want to preserve the state of
+** PRNG and restore the PRNG to its saved state at a later time.
+*/
+static struct sqlite3PrngType sqlite3SavedPrng;
+void sqlite3SavePrngState(void){
+  memcpy(&sqlite3SavedPrng, &sqlite3Prng, sizeof(sqlite3Prng));
+}
+void sqlite3RestorePrngState(void){
+  memcpy(&sqlite3Prng, &sqlite3SavedPrng, sizeof(sqlite3Prng));
+}
+void sqlite3ResetPrngState(void){
+  sqlite3Prng.isInit = 0;
+}
+#endif /* SQLITE_TEST */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/select.c b/client/src/thirdparty/sqlite-3.4.2/src/select.c
new file mode 100644
index 0000000..981691f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/select.c
@@ -0,0 +1,3705 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains C code routines that are called by the parser
+** to handle SELECT statements in SQLite.
+**
+** $Id: select.c,v 1.411 2008/01/25 15:04:50 drh Exp $
+*/
+#include "sqliteInt.h"
+
+
+/*
+** Delete all the content of a Select structure but do not deallocate
+** the select structure itself.
+*/
+static void clearSelect(Select *p){
+  sqlite3ExprListDelete(p->pEList);
+  sqlite3SrcListDelete(p->pSrc);
+  sqlite3ExprDelete(p->pWhere);
+  sqlite3ExprListDelete(p->pGroupBy);
+  sqlite3ExprDelete(p->pHaving);
+  sqlite3ExprListDelete(p->pOrderBy);
+  sqlite3SelectDelete(p->pPrior);
+  sqlite3ExprDelete(p->pLimit);
+  sqlite3ExprDelete(p->pOffset);
+}
+
+/*
+** Initialize a SelectDest structure.
+*/
+void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
+  pDest->eDest = eDest;
+  pDest->iParm = iParm;
+  pDest->affinity = 0;
+  pDest->iMem = 0;
+}
+
+
+/*
+** Allocate a new Select structure and return a pointer to that
+** structure.
+*/
+Select *sqlite3SelectNew(
+  Parse *pParse,        /* Parsing context */
+  ExprList *pEList,     /* which columns to include in the result */
+  SrcList *pSrc,        /* the FROM clause -- which tables to scan */
+  Expr *pWhere,         /* the WHERE clause */
+  ExprList *pGroupBy,   /* the GROUP BY clause */
+  Expr *pHaving,        /* the HAVING clause */
+  ExprList *pOrderBy,   /* the ORDER BY clause */
+  int isDistinct,       /* true if the DISTINCT keyword is present */
+  Expr *pLimit,         /* LIMIT value.  NULL means not used */
+  Expr *pOffset         /* OFFSET value.  NULL means no offset */
+){
+  Select *pNew;
+  Select standin;
+  sqlite3 *db = pParse->db;
+  pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
+  assert( !pOffset || pLimit );   /* Can't have OFFSET without LIMIT. */
+  if( pNew==0 ){
+    pNew = &standin;
+    memset(pNew, 0, sizeof(*pNew));
+  }
+  if( pEList==0 ){
+    pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0);
+  }
+  pNew->pEList = pEList;
+  pNew->pSrc = pSrc;
+  pNew->pWhere = pWhere;
+  pNew->pGroupBy = pGroupBy;
+  pNew->pHaving = pHaving;
+  pNew->pOrderBy = pOrderBy;
+  pNew->isDistinct = isDistinct;
+  pNew->op = TK_SELECT;
+  assert( pOffset==0 || pLimit!=0 );
+  pNew->pLimit = pLimit;
+  pNew->pOffset = pOffset;
+  pNew->iLimit = -1;
+  pNew->iOffset = -1;
+  pNew->addrOpenEphm[0] = -1;
+  pNew->addrOpenEphm[1] = -1;
+  pNew->addrOpenEphm[2] = -1;
+  if( pNew==&standin) {
+    clearSelect(pNew);
+    pNew = 0;
+  }
+  return pNew;
+}
+
+/*
+** Delete the given Select structure and all of its substructures.
+*/
+void sqlite3SelectDelete(Select *p){
+  if( p ){
+    clearSelect(p);
+    sqlite3_free(p);
+  }
+}
+
+/*
+** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
+** type of join.  Return an integer constant that expresses that type
+** in terms of the following bit values:
+**
+**     JT_INNER
+**     JT_CROSS
+**     JT_OUTER
+**     JT_NATURAL
+**     JT_LEFT
+**     JT_RIGHT
+**
+** A full outer join is the combination of JT_LEFT and JT_RIGHT.
+**
+** If an illegal or unsupported join type is seen, then still return
+** a join type, but put an error in the pParse structure.
+*/
+int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
+  int jointype = 0;
+  Token *apAll[3];
+  Token *p;
+  static const struct {
+    const char zKeyword[8];
+    u8 nChar;
+    u8 code;
+  } keywords[] = {
+    { "natural", 7, JT_NATURAL },
+    { "left",    4, JT_LEFT|JT_OUTER },
+    { "right",   5, JT_RIGHT|JT_OUTER },
+    { "full",    4, JT_LEFT|JT_RIGHT|JT_OUTER },
+    { "outer",   5, JT_OUTER },
+    { "inner",   5, JT_INNER },
+    { "cross",   5, JT_INNER|JT_CROSS },
+  };
+  int i, j;
+  apAll[0] = pA;
+  apAll[1] = pB;
+  apAll[2] = pC;
+  for(i=0; i<3 && apAll[i]; i++){
+    p = apAll[i];
+    for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
+      if( p->n==keywords[j].nChar 
+          && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
+        jointype |= keywords[j].code;
+        break;
+      }
+    }
+    if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
+      jointype |= JT_ERROR;
+      break;
+    }
+  }
+  if(
+     (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
+     (jointype & JT_ERROR)!=0
+  ){
+    const char *zSp1 = " ";
+    const char *zSp2 = " ";
+    if( pB==0 ){ zSp1++; }
+    if( pC==0 ){ zSp2++; }
+    sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
+       "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
+    jointype = JT_INNER;
+  }else if( jointype & JT_RIGHT ){
+    sqlite3ErrorMsg(pParse, 
+      "RIGHT and FULL OUTER JOINs are not currently supported");
+    jointype = JT_INNER;
+  }
+  return jointype;
+}
+
+/*
+** Return the index of a column in a table.  Return -1 if the column
+** is not contained in the table.
+*/
+static int columnIndex(Table *pTab, const char *zCol){
+  int i;
+  for(i=0; i<pTab->nCol; i++){
+    if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
+  }
+  return -1;
+}
+
+/*
+** Set the value of a token to a '\000'-terminated string.
+*/
+static void setToken(Token *p, const char *z){
+  p->z = (u8*)z;
+  p->n = z ? strlen(z) : 0;
+  p->dyn = 0;
+}
+
+/*
+** Set the token to the double-quoted and escaped version of the string pointed
+** to by z. For example;
+**
+**    {a"bc}  ->  {"a""bc"}
+*/
+static void setQuotedToken(Parse *pParse, Token *p, const char *z){
+  p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z);
+  p->dyn = 1;
+  if( p->z ){
+    p->n = strlen((char *)p->z);
+  }else{
+    pParse->db->mallocFailed = 1;
+  }
+}
+
+/*
+** Create an expression node for an identifier with the name of zName
+*/
+Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){
+  Token dummy;
+  setToken(&dummy, zName);
+  return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy);
+}
+
+
+/*
+** Add a term to the WHERE expression in *ppExpr that requires the
+** zCol column to be equal in the two tables pTab1 and pTab2.
+*/
+static void addWhereTerm(
+  Parse *pParse,           /* Parsing context */
+  const char *zCol,        /* Name of the column */
+  const Table *pTab1,      /* First table */
+  const char *zAlias1,     /* Alias for first table.  May be NULL */
+  const Table *pTab2,      /* Second table */
+  const char *zAlias2,     /* Alias for second table.  May be NULL */
+  int iRightJoinTable,     /* VDBE cursor for the right table */
+  Expr **ppExpr            /* Add the equality term to this expression */
+){
+  Expr *pE1a, *pE1b, *pE1c;
+  Expr *pE2a, *pE2b, *pE2c;
+  Expr *pE;
+
+  pE1a = sqlite3CreateIdExpr(pParse, zCol);
+  pE2a = sqlite3CreateIdExpr(pParse, zCol);
+  if( zAlias1==0 ){
+    zAlias1 = pTab1->zName;
+  }
+  pE1b = sqlite3CreateIdExpr(pParse, zAlias1);
+  if( zAlias2==0 ){
+    zAlias2 = pTab2->zName;
+  }
+  pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
+  pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
+  pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
+  pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
+  if( pE ){
+    ExprSetProperty(pE, EP_FromJoin);
+    pE->iRightJoinTable = iRightJoinTable;
+  }
+  *ppExpr = sqlite3ExprAnd(pParse->db,*ppExpr, pE);
+}
+
+/*
+** Set the EP_FromJoin property on all terms of the given expression.
+** And set the Expr.iRightJoinTable to iTable for every term in the
+** expression.
+**
+** The EP_FromJoin property is used on terms of an expression to tell
+** the LEFT OUTER JOIN processing logic that this term is part of the
+** join restriction specified in the ON or USING clause and not a part
+** of the more general WHERE clause.  These terms are moved over to the
+** WHERE clause during join processing but we need to remember that they
+** originated in the ON or USING clause.
+**
+** The Expr.iRightJoinTable tells the WHERE clause processing that the
+** expression depends on table iRightJoinTable even if that table is not
+** explicitly mentioned in the expression.  That information is needed
+** for cases like this:
+**
+**    SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
+**
+** The where clause needs to defer the handling of the t1.x=5
+** term until after the t2 loop of the join.  In that way, a
+** NULL t2 row will be inserted whenever t1.x!=5.  If we do not
+** defer the handling of t1.x=5, it will be processed immediately
+** after the t1 loop and rows with t1.x!=5 will never appear in
+** the output, which is incorrect.
+*/
+static void setJoinExpr(Expr *p, int iTable){
+  while( p ){
+    ExprSetProperty(p, EP_FromJoin);
+    p->iRightJoinTable = iTable;
+    setJoinExpr(p->pLeft, iTable);
+    p = p->pRight;
+  } 
+}
+
+/*
+** This routine processes the join information for a SELECT statement.
+** ON and USING clauses are converted into extra terms of the WHERE clause.
+** NATURAL joins also create extra WHERE clause terms.
+**
+** The terms of a FROM clause are contained in the Select.pSrc structure.
+** The left most table is the first entry in Select.pSrc.  The right-most
+** table is the last entry.  The join operator is held in the entry to
+** the left.  Thus entry 0 contains the join operator for the join between
+** entries 0 and 1.  Any ON or USING clauses associated with the join are
+** also attached to the left entry.
+**
+** This routine returns the number of errors encountered.
+*/
+static int sqliteProcessJoin(Parse *pParse, Select *p){
+  SrcList *pSrc;                  /* All tables in the FROM clause */
+  int i, j;                       /* Loop counters */
+  struct SrcList_item *pLeft;     /* Left table being joined */
+  struct SrcList_item *pRight;    /* Right table being joined */
+
+  pSrc = p->pSrc;
+  pLeft = &pSrc->a[0];
+  pRight = &pLeft[1];
+  for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
+    Table *pLeftTab = pLeft->pTab;
+    Table *pRightTab = pRight->pTab;
+
+    if( pLeftTab==0 || pRightTab==0 ) continue;
+
+    /* When the NATURAL keyword is present, add WHERE clause terms for
+    ** every column that the two tables have in common.
+    */
+    if( pRight->jointype & JT_NATURAL ){
+      if( pRight->pOn || pRight->pUsing ){
+        sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
+           "an ON or USING clause", 0);
+        return 1;
+      }
+      for(j=0; j<pLeftTab->nCol; j++){
+        char *zName = pLeftTab->aCol[j].zName;
+        if( columnIndex(pRightTab, zName)>=0 ){
+          addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, 
+                              pRightTab, pRight->zAlias,
+                              pRight->iCursor, &p->pWhere);
+          
+        }
+      }
+    }
+
+    /* Disallow both ON and USING clauses in the same join
+    */
+    if( pRight->pOn && pRight->pUsing ){
+      sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
+        "clauses in the same join");
+      return 1;
+    }
+
+    /* Add the ON clause to the end of the WHERE clause, connected by
+    ** an AND operator.
+    */
+    if( pRight->pOn ){
+      setJoinExpr(pRight->pOn, pRight->iCursor);
+      p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
+      pRight->pOn = 0;
+    }
+
+    /* Create extra terms on the WHERE clause for each column named
+    ** in the USING clause.  Example: If the two tables to be joined are 
+    ** A and B and the USING clause names X, Y, and Z, then add this
+    ** to the WHERE clause:    A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
+    ** Report an error if any column mentioned in the USING clause is
+    ** not contained in both tables to be joined.
+    */
+    if( pRight->pUsing ){
+      IdList *pList = pRight->pUsing;
+      for(j=0; j<pList->nId; j++){
+        char *zName = pList->a[j].zName;
+        if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){
+          sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
+            "not present in both tables", zName);
+          return 1;
+        }
+        addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, 
+                            pRightTab, pRight->zAlias,
+                            pRight->iCursor, &p->pWhere);
+      }
+    }
+  }
+  return 0;
+}
+
+/*
+** Insert code into "v" that will push the record on the top of the
+** stack into the sorter.
+*/
+static void pushOntoSorter(
+  Parse *pParse,         /* Parser context */
+  ExprList *pOrderBy,    /* The ORDER BY clause */
+  Select *pSelect,       /* The whole SELECT statement */
+  int regData            /* Register holding data to be sorted */
+){
+  Vdbe *v = pParse->pVdbe;
+  int nExpr = pOrderBy->nExpr;
+  int regBase = sqlite3GetTempRange(pParse, nExpr+2);
+  int regRecord = sqlite3GetTempReg(pParse);
+  sqlite3ExprCodeExprList(pParse, pOrderBy, regBase);
+  sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
+  sqlite3VdbeAddOp2(v, OP_Move, regData, regBase+nExpr+1);
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
+  sqlite3VdbeAddOp2(v, OP_IdxInsert, pOrderBy->iECursor, regRecord);
+  sqlite3ReleaseTempReg(pParse, regRecord);
+  sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
+  if( pSelect->iLimit>=0 ){
+    int addr1, addr2;
+    int iLimit;
+    if( pSelect->pOffset ){
+      iLimit = pSelect->iOffset+1;
+    }else{
+      iLimit = pSelect->iLimit;
+    }
+    addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
+    sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
+    addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
+    sqlite3VdbeJumpHere(v, addr1);
+    sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
+    sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
+    sqlite3VdbeJumpHere(v, addr2);
+    pSelect->iLimit = -1;
+  }
+}
+
+/*
+** Add code to implement the OFFSET
+*/
+static void codeOffset(
+  Vdbe *v,          /* Generate code into this VM */
+  Select *p,        /* The SELECT statement being coded */
+  int iContinue     /* Jump here to skip the current record */
+){
+  if( p->iOffset>=0 && iContinue!=0 ){
+    int addr;
+    sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
+    addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
+    VdbeComment((v, "skip OFFSET records"));
+    sqlite3VdbeJumpHere(v, addr);
+  }
+}
+
+/*
+** Add code that will check to make sure the N registers starting at iMem
+** form a distinct entry.  iTab is a sorting index that holds previously
+** seen combinations of the N values.  A new entry is made in iTab
+** if the current N values are new.
+**
+** A jump to addrRepeat is made and the N+1 values are popped from the
+** stack if the top N elements are not distinct.
+*/
+static void codeDistinct(
+  Parse *pParse,     /* Parsing and code generating context */
+  int iTab,          /* A sorting index used to test for distinctness */
+  int addrRepeat,    /* Jump to here if not distinct */
+  int N,             /* Number of elements */
+  int iMem           /* First element */
+){
+  Vdbe *v;
+  int r1;
+
+  v = pParse->pVdbe;
+  r1 = sqlite3GetTempReg(pParse);
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
+  sqlite3VdbeAddOp3(v, OP_Found, iTab, addrRepeat, r1);
+  sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
+  sqlite3ReleaseTempReg(pParse, r1);
+}
+
+/*
+** Generate an error message when a SELECT is used within a subexpression
+** (example:  "a IN (SELECT * FROM table)") but it has more than 1 result
+** column.  We do this in a subroutine because the error occurs in multiple
+** places.
+*/
+static int checkForMultiColumnSelectError(
+  Parse *pParse,       /* Parse context. */
+  SelectDest *pDest,   /* Destination of SELECT results */
+  int nExpr            /* Number of result columns returned by SELECT */
+){
+  int eDest = pDest->eDest;
+  if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
+    sqlite3ErrorMsg(pParse, "only a single result allowed for "
+       "a SELECT that is part of an expression");
+    return 1;
+  }else{
+    return 0;
+  }
+}
+
+/*
+** This routine generates the code for the inside of the inner loop
+** of a SELECT.
+**
+** If srcTab and nColumn are both zero, then the pEList expressions
+** are evaluated in order to get the data for this row.  If nColumn>0
+** then data is pulled from srcTab and pEList is used only to get the
+** datatypes for each column.
+*/
+static void selectInnerLoop(
+  Parse *pParse,          /* The parser context */
+  Select *p,              /* The complete select statement being coded */
+  ExprList *pEList,       /* List of values being extracted */
+  int srcTab,             /* Pull data from this table */
+  int nColumn,            /* Number of columns in the source table */
+  ExprList *pOrderBy,     /* If not NULL, sort results using this key */
+  int distinct,           /* If >=0, make sure results are distinct */
+  SelectDest *pDest,      /* How to dispose of the results */
+  int iContinue,          /* Jump here to continue with next row */
+  int iBreak,             /* Jump here to break out of the inner loop */
+  char *aff               /* affinity string if eDest is SRT_Union */
+){
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  int hasDistinct;        /* True if the DISTINCT keyword is present */
+  int regResult;              /* Start of memory holding result set */
+  int eDest = pDest->eDest;   /* How to dispose of results */
+  int iParm = pDest->iParm;   /* First argument to disposal method */
+  int nResultCol;             /* Number of result columns */
+  int nToFree;                /* Number of result columns to release */
+
+  if( v==0 ) return;
+  assert( pEList!=0 );
+
+  /* If there was a LIMIT clause on the SELECT statement, then do the check
+  ** to see if this row should be output.
+  */
+  hasDistinct = distinct>=0 && pEList->nExpr>0;
+  if( pOrderBy==0 && !hasDistinct ){
+    codeOffset(v, p, iContinue);
+  }
+
+  /* Pull the requested columns.
+  */
+  if( nColumn>0 ){
+    nResultCol = nColumn;
+  }else{
+    nResultCol = pEList->nExpr;
+  }
+  if( pDest->iMem>0 ){
+    regResult = pDest->iMem;
+    nToFree = 0;
+  }else{
+    pDest->iMem = regResult = sqlite3GetTempRange(pParse, nResultCol);
+    nToFree = nResultCol;
+  }
+  if( nColumn>0 ){
+    for(i=0; i<nColumn; i++){
+      sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
+    }
+  }else if( eDest!=SRT_Exists ){
+    /* If the destination is an EXISTS(...) expression, the actual
+    ** values returned by the SELECT are not required.
+    */
+    for(i=0; i<nResultCol; i++){
+      sqlite3ExprCode(pParse, pEList->a[i].pExpr, regResult+i);
+    }
+  }
+  nColumn = nResultCol;
+
+  /* If the DISTINCT keyword was present on the SELECT statement
+  ** and this row has been seen before, then do not make this row
+  ** part of the result.
+  */
+  if( hasDistinct ){
+    assert( pEList!=0 );
+    assert( pEList->nExpr==nColumn );
+    codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
+    if( pOrderBy==0 ){
+      codeOffset(v, p, iContinue);
+    }
+  }
+
+  if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
+    return;
+  }
+
+  switch( eDest ){
+    /* In this mode, write each query result to the key of the temporary
+    ** table iParm.
+    */
+#ifndef SQLITE_OMIT_COMPOUND_SELECT
+    case SRT_Union: {
+      int r1;
+      r1 = sqlite3GetTempReg(pParse);
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
+      if( aff ){
+        sqlite3VdbeChangeP4(v, -1, aff, P4_STATIC);
+      }
+      sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
+      sqlite3ReleaseTempReg(pParse, r1);
+      break;
+    }
+
+    /* Construct a record from the query result, but instead of
+    ** saving that record, use it as a key to delete elements from
+    ** the temporary table iParm.
+    */
+    case SRT_Except: {
+      int r1;
+      r1 = sqlite3GetTempReg(pParse);
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
+      sqlite3VdbeChangeP4(v, -1, aff, P4_STATIC);
+      sqlite3VdbeAddOp2(v, OP_IdxDelete, iParm, r1);
+      sqlite3ReleaseTempReg(pParse, r1);
+      break;
+    }
+#endif
+
+    /* Store the result as data using a unique key.
+    */
+    case SRT_Table:
+    case SRT_EphemTab: {
+      int r1 = sqlite3GetTempReg(pParse);
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
+      if( pOrderBy ){
+        pushOntoSorter(pParse, pOrderBy, p, r1);
+      }else{
+        int r2 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
+        sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
+        sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
+        sqlite3ReleaseTempReg(pParse, r2);
+      }
+      sqlite3ReleaseTempReg(pParse, r1);
+      break;
+    }
+
+#ifndef SQLITE_OMIT_SUBQUERY
+    /* If we are creating a set for an "expr IN (SELECT ...)" construct,
+    ** then there should be a single item on the stack.  Write this
+    ** item into the set table with bogus data.
+    */
+    case SRT_Set: {
+      int addr2;
+
+      assert( nColumn==1 );
+      addr2 = sqlite3VdbeAddOp1(v, OP_IsNull, regResult);
+      p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
+      if( pOrderBy ){
+        /* At first glance you would think we could optimize out the
+        ** ORDER BY in this case since the order of entries in the set
+        ** does not matter.  But there might be a LIMIT clause, in which
+        ** case the order does matter */
+        pushOntoSorter(pParse, pOrderBy, p, regResult);
+      }else{
+        int r1 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
+        sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
+        sqlite3ReleaseTempReg(pParse, r1);
+      }
+      sqlite3VdbeJumpHere(v, addr2);
+      break;
+    }
+
+    /* If any row exist in the result set, record that fact and abort.
+    */
+    case SRT_Exists: {
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
+      /* The LIMIT clause will terminate the loop for us */
+      break;
+    }
+
+    /* If this is a scalar select that is part of an expression, then
+    ** store the results in the appropriate memory cell and break out
+    ** of the scan loop.
+    */
+    case SRT_Mem: {
+      assert( nColumn==1 );
+      if( pOrderBy ){
+        pushOntoSorter(pParse, pOrderBy, p, regResult);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Move, regResult, iParm);
+        /* The LIMIT clause will jump out of the loop for us */
+      }
+      break;
+    }
+#endif /* #ifndef SQLITE_OMIT_SUBQUERY */
+
+    /* Send the data to the callback function or to a subroutine.  In the
+    ** case of a subroutine, the subroutine itself is responsible for
+    ** popping the data from the stack.
+    */
+    case SRT_Subroutine:
+    case SRT_Callback: {
+      if( pOrderBy ){
+        int r1 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
+        pushOntoSorter(pParse, pOrderBy, p, r1);
+        sqlite3ReleaseTempReg(pParse, r1);
+      }else if( eDest==SRT_Subroutine ){
+        nToFree = 0;  /* Preserve registers. Subroutine will need them. */
+        sqlite3VdbeAddOp2(v, OP_Gosub, 0, iParm);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
+      }
+      break;
+    }
+
+#if !defined(SQLITE_OMIT_TRIGGER)
+    /* Discard the results.  This is used for SELECT statements inside
+    ** the body of a TRIGGER.  The purpose of such selects is to call
+    ** user-defined functions that have side effects.  We do not care
+    ** about the actual results of the select.
+    */
+    default: {
+      assert( eDest==SRT_Discard );
+      break;
+    }
+#endif
+  }
+
+  /* Jump to the end of the loop if the LIMIT is reached.
+  */
+  if( p->iLimit>=0 && pOrderBy==0 ){
+    sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
+    sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, iBreak);
+  }
+  sqlite3ReleaseTempRange(pParse, regResult, nToFree);
+}
+
+/*
+** Given an expression list, generate a KeyInfo structure that records
+** the collating sequence for each expression in that expression list.
+**
+** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
+** KeyInfo structure is appropriate for initializing a virtual index to
+** implement that clause.  If the ExprList is the result set of a SELECT
+** then the KeyInfo structure is appropriate for initializing a virtual
+** index to implement a DISTINCT test.
+**
+** Space to hold the KeyInfo structure is obtain from malloc.  The calling
+** function is responsible for seeing that this structure is eventually
+** freed.  Add the KeyInfo structure to the P4 field of an opcode using
+** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
+*/
+static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
+  sqlite3 *db = pParse->db;
+  int nExpr;
+  KeyInfo *pInfo;
+  struct ExprList_item *pItem;
+  int i;
+
+  nExpr = pList->nExpr;
+  pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
+  if( pInfo ){
+    pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
+    pInfo->nField = nExpr;
+    pInfo->enc = ENC(db);
+    for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
+      CollSeq *pColl;
+      pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
+      if( !pColl ){
+        pColl = db->pDfltColl;
+      }
+      pInfo->aColl[i] = pColl;
+      pInfo->aSortOrder[i] = pItem->sortOrder;
+    }
+  }
+  return pInfo;
+}
+
+
+/*
+** If the inner loop was generated using a non-null pOrderBy argument,
+** then the results were placed in a sorter.  After the loop is terminated
+** we need to run the sorter and output the results.  The following
+** routine generates the code needed to do that.
+*/
+static void generateSortTail(
+  Parse *pParse,    /* Parsing context */
+  Select *p,        /* The SELECT statement */
+  Vdbe *v,          /* Generate code into this VDBE */
+  int nColumn,      /* Number of columns of data */
+  SelectDest *pDest /* Write the sorted results here */
+){
+  int brk = sqlite3VdbeMakeLabel(v);
+  int cont = sqlite3VdbeMakeLabel(v);
+  int addr;
+  int iTab;
+  int pseudoTab = 0;
+  ExprList *pOrderBy = p->pOrderBy;
+
+  int eDest = pDest->eDest;
+  int iParm = pDest->iParm;
+
+  int regRow;
+  int regRowid;
+
+  iTab = pOrderBy->iECursor;
+  if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
+    pseudoTab = pParse->nTab++;
+    sqlite3VdbeAddOp2(v, OP_OpenPseudo, pseudoTab, 0);
+    sqlite3VdbeAddOp2(v, OP_SetNumColumns, pseudoTab, nColumn);
+  }
+  addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, brk);
+  codeOffset(v, p, cont);
+  regRow = sqlite3GetTempReg(pParse);
+  regRowid = sqlite3GetTempReg(pParse);
+  sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr + 1, regRow);
+  switch( eDest ){
+    case SRT_Table:
+    case SRT_EphemTab: {
+      sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
+      sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
+      sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
+      break;
+    }
+#ifndef SQLITE_OMIT_SUBQUERY
+    case SRT_Set: {
+      int j1;
+      assert( nColumn==1 );
+      j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regRow);
+      sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRow, &p->affinity, 1);
+      sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRow);
+      sqlite3VdbeJumpHere(v, j1);
+      break;
+    }
+    case SRT_Mem: {
+      assert( nColumn==1 );
+      sqlite3VdbeAddOp2(v, OP_Move, regRow, iParm);
+      /* The LIMIT clause will terminate the loop for us */
+      break;
+    }
+#endif
+    case SRT_Callback:
+    case SRT_Subroutine: {
+      int i;
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, regRowid);
+      sqlite3VdbeAddOp3(v, OP_Insert, pseudoTab, regRow, regRowid);
+      for(i=0; i<nColumn; i++){
+        sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i);
+      }
+      if( eDest==SRT_Callback ){
+        sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn);
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Gosub, 0, iParm);
+      }
+      break;
+    }
+    default: {
+      /* Do nothing */
+      break;
+    }
+  }
+  sqlite3ReleaseTempReg(pParse, regRow);
+  sqlite3ReleaseTempReg(pParse, regRowid);
+
+  /* Jump to the end of the loop when the LIMIT is reached
+  */
+  if( p->iLimit>=0 ){
+    sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
+    sqlite3VdbeAddOp2(v, OP_IfZero, p->iLimit, brk);
+  }
+
+  /* The bottom of the loop
+  */
+  sqlite3VdbeResolveLabel(v, cont);
+  sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
+  sqlite3VdbeResolveLabel(v, brk);
+  if( eDest==SRT_Callback || eDest==SRT_Subroutine ){
+    sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
+  }
+
+}
+
+/*
+** Return a pointer to a string containing the 'declaration type' of the
+** expression pExpr. The string may be treated as static by the caller.
+**
+** The declaration type is the exact datatype definition extracted from the
+** original CREATE TABLE statement if the expression is a column. The
+** declaration type for a ROWID field is INTEGER. Exactly when an expression
+** is considered a column can be complex in the presence of subqueries. The
+** result-set expression in all of the following SELECT statements is 
+** considered a column by this function.
+**
+**   SELECT col FROM tbl;
+**   SELECT (SELECT col FROM tbl;
+**   SELECT (SELECT col FROM tbl);
+**   SELECT abc FROM (SELECT col AS abc FROM tbl);
+** 
+** The declaration type for any expression other than a column is NULL.
+*/
+static const char *columnType(
+  NameContext *pNC, 
+  Expr *pExpr,
+  const char **pzOriginDb,
+  const char **pzOriginTab,
+  const char **pzOriginCol
+){
+  char const *zType = 0;
+  char const *zOriginDb = 0;
+  char const *zOriginTab = 0;
+  char const *zOriginCol = 0;
+  int j;
+  if( pExpr==0 || pNC->pSrcList==0 ) return 0;
+
+  switch( pExpr->op ){
+    case TK_AGG_COLUMN:
+    case TK_COLUMN: {
+      /* The expression is a column. Locate the table the column is being
+      ** extracted from in NameContext.pSrcList. This table may be real
+      ** database table or a subquery.
+      */
+      Table *pTab = 0;            /* Table structure column is extracted from */
+      Select *pS = 0;             /* Select the column is extracted from */
+      int iCol = pExpr->iColumn;  /* Index of column in pTab */
+      while( pNC && !pTab ){
+        SrcList *pTabList = pNC->pSrcList;
+        for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
+        if( j<pTabList->nSrc ){
+          pTab = pTabList->a[j].pTab;
+          pS = pTabList->a[j].pSelect;
+        }else{
+          pNC = pNC->pNext;
+        }
+      }
+
+      if( pTab==0 ){
+        /* FIX ME:
+        ** This can occurs if you have something like "SELECT new.x;" inside
+        ** a trigger.  In other words, if you reference the special "new"
+        ** table in the result set of a select.  We do not have a good way
+        ** to find the actual table type, so call it "TEXT".  This is really
+        ** something of a bug, but I do not know how to fix it.
+        **
+        ** This code does not produce the correct answer - it just prevents
+        ** a segfault.  See ticket #1229.
+        */
+        zType = "TEXT";
+        break;
+      }
+
+      assert( pTab );
+      if( pS ){
+        /* The "table" is actually a sub-select or a view in the FROM clause
+        ** of the SELECT statement. Return the declaration type and origin
+        ** data for the result-set column of the sub-select.
+        */
+        if( iCol>=0 && iCol<pS->pEList->nExpr ){
+          /* If iCol is less than zero, then the expression requests the
+          ** rowid of the sub-select or view. This expression is legal (see 
+          ** test case misc2.2.2) - it always evaluates to NULL.
+          */
+          NameContext sNC;
+          Expr *p = pS->pEList->a[iCol].pExpr;
+          sNC.pSrcList = pS->pSrc;
+          sNC.pNext = 0;
+          sNC.pParse = pNC->pParse;
+          zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
+        }
+      }else if( pTab->pSchema ){
+        /* A real table */
+        assert( !pS );
+        if( iCol<0 ) iCol = pTab->iPKey;
+        assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
+        if( iCol<0 ){
+          zType = "INTEGER";
+          zOriginCol = "rowid";
+        }else{
+          zType = pTab->aCol[iCol].zType;
+          zOriginCol = pTab->aCol[iCol].zName;
+        }
+        zOriginTab = pTab->zName;
+        if( pNC->pParse ){
+          int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
+          zOriginDb = pNC->pParse->db->aDb[iDb].zName;
+        }
+      }
+      break;
+    }
+#ifndef SQLITE_OMIT_SUBQUERY
+    case TK_SELECT: {
+      /* The expression is a sub-select. Return the declaration type and
+      ** origin info for the single column in the result set of the SELECT
+      ** statement.
+      */
+      NameContext sNC;
+      Select *pS = pExpr->pSelect;
+      Expr *p = pS->pEList->a[0].pExpr;
+      sNC.pSrcList = pS->pSrc;
+      sNC.pNext = pNC;
+      sNC.pParse = pNC->pParse;
+      zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
+      break;
+    }
+#endif
+  }
+  
+  if( pzOriginDb ){
+    assert( pzOriginTab && pzOriginCol );
+    *pzOriginDb = zOriginDb;
+    *pzOriginTab = zOriginTab;
+    *pzOriginCol = zOriginCol;
+  }
+  return zType;
+}
+
+/*
+** Generate code that will tell the VDBE the declaration types of columns
+** in the result set.
+*/
+static void generateColumnTypes(
+  Parse *pParse,      /* Parser context */
+  SrcList *pTabList,  /* List of tables */
+  ExprList *pEList    /* Expressions defining the result set */
+){
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  NameContext sNC;
+  sNC.pSrcList = pTabList;
+  sNC.pParse = pParse;
+  for(i=0; i<pEList->nExpr; i++){
+    Expr *p = pEList->a[i].pExpr;
+    const char *zOrigDb = 0;
+    const char *zOrigTab = 0;
+    const char *zOrigCol = 0;
+    const char *zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
+
+    /* The vdbe must make its own copy of the column-type and other 
+    ** column specific strings, in case the schema is reset before this
+    ** virtual machine is deleted.
+    */
+    sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P4_TRANSIENT);
+    sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P4_TRANSIENT);
+    sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P4_TRANSIENT);
+    sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P4_TRANSIENT);
+  }
+}
+
+/*
+** Generate code that will tell the VDBE the names of columns
+** in the result set.  This information is used to provide the
+** azCol[] values in the callback.
+*/
+static void generateColumnNames(
+  Parse *pParse,      /* Parser context */
+  SrcList *pTabList,  /* List of tables */
+  ExprList *pEList    /* Expressions defining the result set */
+){
+  Vdbe *v = pParse->pVdbe;
+  int i, j;
+  sqlite3 *db = pParse->db;
+  int fullNames, shortNames;
+
+#ifndef SQLITE_OMIT_EXPLAIN
+  /* If this is an EXPLAIN, skip this step */
+  if( pParse->explain ){
+    return;
+  }
+#endif
+
+  assert( v!=0 );
+  if( pParse->colNamesSet || v==0 || db->mallocFailed ) return;
+  pParse->colNamesSet = 1;
+  fullNames = (db->flags & SQLITE_FullColNames)!=0;
+  shortNames = (db->flags & SQLITE_ShortColNames)!=0;
+  sqlite3VdbeSetNumCols(v, pEList->nExpr);
+  for(i=0; i<pEList->nExpr; i++){
+    Expr *p;
+    p = pEList->a[i].pExpr;
+    if( p==0 ) continue;
+    if( pEList->a[i].zName ){
+      char *zName = pEList->a[i].zName;
+      sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName));
+      continue;
+    }
+    if( p->op==TK_COLUMN && pTabList ){
+      Table *pTab;
+      char *zCol;
+      int iCol = p->iColumn;
+      for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){}
+      assert( j<pTabList->nSrc );
+      pTab = pTabList->a[j].pTab;
+      if( iCol<0 ) iCol = pTab->iPKey;
+      assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
+      if( iCol<0 ){
+        zCol = "rowid";
+      }else{
+        zCol = pTab->aCol[iCol].zName;
+      }
+      if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
+        sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
+      }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
+        char *zName = 0;
+        char *zTab;
+ 
+        zTab = pTabList->a[j].zAlias;
+        if( fullNames || zTab==0 ) zTab = pTab->zName;
+        sqlite3SetString(&zName, zTab, ".", zCol, (char*)0);
+        sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P4_DYNAMIC);
+      }else{
+        sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol));
+      }
+    }else if( p->span.z && p->span.z[0] ){
+      sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n);
+      /* sqlite3VdbeCompressSpace(v, addr); */
+    }else{
+      char zName[30];
+      assert( p->op!=TK_COLUMN || pTabList==0 );
+      sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1);
+      sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0);
+    }
+  }
+  generateColumnTypes(pParse, pTabList, pEList);
+}
+
+#ifndef SQLITE_OMIT_COMPOUND_SELECT
+/*
+** Name of the connection operator, used for error messages.
+*/
+static const char *selectOpName(int id){
+  char *z;
+  switch( id ){
+    case TK_ALL:       z = "UNION ALL";   break;
+    case TK_INTERSECT: z = "INTERSECT";   break;
+    case TK_EXCEPT:    z = "EXCEPT";      break;
+    default:           z = "UNION";       break;
+  }
+  return z;
+}
+#endif /* SQLITE_OMIT_COMPOUND_SELECT */
+
+/*
+** Forward declaration
+*/
+static int prepSelectStmt(Parse*, Select*);
+
+/*
+** Given a SELECT statement, generate a Table structure that describes
+** the result set of that SELECT.
+*/
+Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
+  Table *pTab;
+  int i, j;
+  ExprList *pEList;
+  Column *aCol, *pCol;
+  sqlite3 *db = pParse->db;
+
+  while( pSelect->pPrior ) pSelect = pSelect->pPrior;
+  if( prepSelectStmt(pParse, pSelect) ){
+    return 0;
+  }
+  if( sqlite3SelectResolve(pParse, pSelect, 0) ){
+    return 0;
+  }
+  pTab = sqlite3DbMallocZero(db, sizeof(Table) );
+  if( pTab==0 ){
+    return 0;
+  }
+  pTab->nRef = 1;
+  pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0;
+  pEList = pSelect->pEList;
+  pTab->nCol = pEList->nExpr;
+  assert( pTab->nCol>0 );
+  pTab->aCol = aCol = sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol);
+  for(i=0, pCol=aCol; i<pTab->nCol; i++, pCol++){
+    Expr *p, *pR;
+    char *zType;
+    char *zName;
+    int nName;
+    CollSeq *pColl;
+    int cnt;
+    NameContext sNC;
+    
+    /* Get an appropriate name for the column
+    */
+    p = pEList->a[i].pExpr;
+    assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 );
+    if( (zName = pEList->a[i].zName)!=0 ){
+      /* If the column contains an "AS <name>" phrase, use <name> as the name */
+      zName = sqlite3DbStrDup(db, zName);
+    }else if( p->op==TK_DOT 
+              && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){
+      /* For columns of the from A.B use B as the name */
+      zName = sqlite3MPrintf(db, "%T", &pR->token);
+    }else if( p->span.z && p->span.z[0] ){
+      /* Use the original text of the column expression as its name */
+      zName = sqlite3MPrintf(db, "%T", &p->span);
+    }else{
+      /* If all else fails, make up a name */
+      zName = sqlite3MPrintf(db, "column%d", i+1);
+    }
+    if( !zName || db->mallocFailed ){
+      db->mallocFailed = 1;
+      sqlite3_free(zName);
+      sqlite3DeleteTable(pTab);
+      return 0;
+    }
+    sqlite3Dequote(zName);
+
+    /* Make sure the column name is unique.  If the name is not unique,
+    ** append a integer to the name so that it becomes unique.
+    */
+    nName = strlen(zName);
+    for(j=cnt=0; j<i; j++){
+      if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
+        zName[nName] = 0;
+        zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
+        j = -1;
+        if( zName==0 ) break;
+      }
+    }
+    pCol->zName = zName;
+
+    /* Get the typename, type affinity, and collating sequence for the
+    ** column.
+    */
+    memset(&sNC, 0, sizeof(sNC));
+    sNC.pSrcList = pSelect->pSrc;
+    zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
+    pCol->zType = zType;
+    pCol->affinity = sqlite3ExprAffinity(p);
+    pColl = sqlite3ExprCollSeq(pParse, p);
+    if( pColl ){
+      pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
+    }
+  }
+  pTab->iPKey = -1;
+  return pTab;
+}
+
+/*
+** Prepare a SELECT statement for processing by doing the following
+** things:
+**
+**    (1)  Make sure VDBE cursor numbers have been assigned to every
+**         element of the FROM clause.
+**
+**    (2)  Fill in the pTabList->a[].pTab fields in the SrcList that 
+**         defines FROM clause.  When views appear in the FROM clause,
+**         fill pTabList->a[].pSelect with a copy of the SELECT statement
+**         that implements the view.  A copy is made of the view's SELECT
+**         statement so that we can freely modify or delete that statement
+**         without worrying about messing up the presistent representation
+**         of the view.
+**
+**    (3)  Add terms to the WHERE clause to accomodate the NATURAL keyword
+**         on joins and the ON and USING clause of joins.
+**
+**    (4)  Scan the list of columns in the result set (pEList) looking
+**         for instances of the "*" operator or the TABLE.* operator.
+**         If found, expand each "*" to be every column in every table
+**         and TABLE.* to be every column in TABLE.
+**
+** Return 0 on success.  If there are problems, leave an error message
+** in pParse and return non-zero.
+*/
+static int prepSelectStmt(Parse *pParse, Select *p){
+  int i, j, k, rc;
+  SrcList *pTabList;
+  ExprList *pEList;
+  struct SrcList_item *pFrom;
+  sqlite3 *db = pParse->db;
+
+  if( p==0 || p->pSrc==0 || db->mallocFailed ){
+    return 1;
+  }
+  pTabList = p->pSrc;
+  pEList = p->pEList;
+
+  /* Make sure cursor numbers have been assigned to all entries in
+  ** the FROM clause of the SELECT statement.
+  */
+  sqlite3SrcListAssignCursors(pParse, p->pSrc);
+
+  /* Look up every table named in the FROM clause of the select.  If
+  ** an entry of the FROM clause is a subquery instead of a table or view,
+  ** then create a transient table structure to describe the subquery.
+  */
+  for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
+    Table *pTab;
+    if( pFrom->pTab!=0 ){
+      /* This statement has already been prepared.  There is no need
+      ** to go further. */
+      assert( i==0 );
+      return 0;
+    }
+    if( pFrom->zName==0 ){
+#ifndef SQLITE_OMIT_SUBQUERY
+      /* A sub-query in the FROM clause of a SELECT */
+      assert( pFrom->pSelect!=0 );
+      if( pFrom->zAlias==0 ){
+        pFrom->zAlias =
+          sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
+      }
+      assert( pFrom->pTab==0 );
+      pFrom->pTab = pTab = 
+        sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect);
+      if( pTab==0 ){
+        return 1;
+      }
+      /* The isEphem flag indicates that the Table structure has been
+      ** dynamically allocated and may be freed at any time.  In other words,
+      ** pTab is not pointing to a persistent table structure that defines
+      ** part of the schema. */
+      pTab->isEphem = 1;
+#endif
+    }else{
+      /* An ordinary table or view name in the FROM clause */
+      assert( pFrom->pTab==0 );
+      pFrom->pTab = pTab = 
+        sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
+      if( pTab==0 ){
+        return 1;
+      }
+      pTab->nRef++;
+#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
+      if( pTab->pSelect || IsVirtual(pTab) ){
+        /* We reach here if the named table is a really a view */
+        if( sqlite3ViewGetColumnNames(pParse, pTab) ){
+          return 1;
+        }
+        /* If pFrom->pSelect!=0 it means we are dealing with a
+        ** view within a view.  The SELECT structure has already been
+        ** copied by the outer view so we can skip the copy step here
+        ** in the inner view.
+        */
+        if( pFrom->pSelect==0 ){
+          pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect);
+        }
+      }
+#endif
+    }
+  }
+
+  /* Process NATURAL keywords, and ON and USING clauses of joins.
+  */
+  if( sqliteProcessJoin(pParse, p) ) return 1;
+
+  /* For every "*" that occurs in the column list, insert the names of
+  ** all columns in all tables.  And for every TABLE.* insert the names
+  ** of all columns in TABLE.  The parser inserted a special expression
+  ** with the TK_ALL operator for each "*" that it found in the column list.
+  ** The following code just has to locate the TK_ALL expressions and expand
+  ** each one to the list of all columns in all tables.
+  **
+  ** The first loop just checks to see if there are any "*" operators
+  ** that need expanding.
+  */
+  for(k=0; k<pEList->nExpr; k++){
+    Expr *pE = pEList->a[k].pExpr;
+    if( pE->op==TK_ALL ) break;
+    if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL
+         && pE->pLeft && pE->pLeft->op==TK_ID ) break;
+  }
+  rc = 0;
+  if( k<pEList->nExpr ){
+    /*
+    ** If we get here it means the result set contains one or more "*"
+    ** operators that need to be expanded.  Loop through each expression
+    ** in the result set and expand them one by one.
+    */
+    struct ExprList_item *a = pEList->a;
+    ExprList *pNew = 0;
+    int flags = pParse->db->flags;
+    int longNames = (flags & SQLITE_FullColNames)!=0 &&
+                      (flags & SQLITE_ShortColNames)==0;
+
+    for(k=0; k<pEList->nExpr; k++){
+      Expr *pE = a[k].pExpr;
+      if( pE->op!=TK_ALL &&
+           (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){
+        /* This particular expression does not need to be expanded.
+        */
+        pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0);
+        if( pNew ){
+          pNew->a[pNew->nExpr-1].zName = a[k].zName;
+        }else{
+          rc = 1;
+        }
+        a[k].pExpr = 0;
+        a[k].zName = 0;
+      }else{
+        /* This expression is a "*" or a "TABLE.*" and needs to be
+        ** expanded. */
+        int tableSeen = 0;      /* Set to 1 when TABLE matches */
+        char *zTName;            /* text of name of TABLE */
+        if( pE->op==TK_DOT && pE->pLeft ){
+          zTName = sqlite3NameFromToken(db, &pE->pLeft->token);
+        }else{
+          zTName = 0;
+        }
+        for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
+          Table *pTab = pFrom->pTab;
+          char *zTabName = pFrom->zAlias;
+          if( zTabName==0 || zTabName[0]==0 ){ 
+            zTabName = pTab->zName;
+          }
+          if( zTName && (zTabName==0 || zTabName[0]==0 || 
+                 sqlite3StrICmp(zTName, zTabName)!=0) ){
+            continue;
+          }
+          tableSeen = 1;
+          for(j=0; j<pTab->nCol; j++){
+            Expr *pExpr, *pRight;
+            char *zName = pTab->aCol[j].zName;
+
+            /* If a column is marked as 'hidden' (currently only possible
+            ** for virtual tables), do not include it in the expanded
+            ** result-set list.
+            */
+            if( IsHiddenColumn(&pTab->aCol[j]) ){
+              assert(IsVirtual(pTab));
+              continue;
+            }
+
+            if( i>0 ){
+              struct SrcList_item *pLeft = &pTabList->a[i-1];
+              if( (pLeft[1].jointype & JT_NATURAL)!=0 &&
+                        columnIndex(pLeft->pTab, zName)>=0 ){
+                /* In a NATURAL join, omit the join columns from the 
+                ** table on the right */
+                continue;
+              }
+              if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){
+                /* In a join with a USING clause, omit columns in the
+                ** using clause from the table on the right. */
+                continue;
+              }
+            }
+            pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
+            if( pRight==0 ) break;
+            setQuotedToken(pParse, &pRight->token, zName);
+            if( zTabName && (longNames || pTabList->nSrc>1) ){
+              Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0);
+              pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
+              if( pExpr==0 ) break;
+              setQuotedToken(pParse, &pLeft->token, zTabName);
+              setToken(&pExpr->span, 
+                  sqlite3MPrintf(db, "%s.%s", zTabName, zName));
+              pExpr->span.dyn = 1;
+              pExpr->token.z = 0;
+              pExpr->token.n = 0;
+              pExpr->token.dyn = 0;
+            }else{
+              pExpr = pRight;
+              pExpr->span = pExpr->token;
+              pExpr->span.dyn = 0;
+            }
+            if( longNames ){
+              pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span);
+            }else{
+              pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token);
+            }
+          }
+        }
+        if( !tableSeen ){
+          if( zTName ){
+            sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
+          }else{
+            sqlite3ErrorMsg(pParse, "no tables specified");
+          }
+          rc = 1;
+        }
+        sqlite3_free(zTName);
+      }
+    }
+    sqlite3ExprListDelete(pEList);
+    p->pEList = pNew;
+  }
+  if( p->pEList && p->pEList->nExpr>SQLITE_MAX_COLUMN ){
+    sqlite3ErrorMsg(pParse, "too many columns in result set");
+    rc = SQLITE_ERROR;
+  }
+  if( db->mallocFailed ){
+    rc = SQLITE_NOMEM;
+  }
+  return rc;
+}
+
+/*
+** pE is a pointer to an expression which is a single term in
+** ORDER BY or GROUP BY clause.
+**
+** If pE evaluates to an integer constant i, then return i.
+** This is an indication to the caller that it should sort
+** by the i-th column of the result set.
+**
+** If pE is a well-formed expression and the SELECT statement
+** is not compound, then return 0.  This indicates to the
+** caller that it should sort by the value of the ORDER BY
+** expression.
+**
+** If the SELECT is compound, then attempt to match pE against
+** result set columns in the left-most SELECT statement.  Return
+** the index i of the matching column, as an indication to the 
+** caller that it should sort by the i-th column.  If there is
+** no match, return -1 and leave an error message in pParse.
+*/
+static int matchOrderByTermToExprList(
+  Parse *pParse,     /* Parsing context for error messages */
+  Select *pSelect,   /* The SELECT statement with the ORDER BY clause */
+  Expr *pE,          /* The specific ORDER BY term */
+  int idx,           /* When ORDER BY term is this */
+  int isCompound,    /* True if this is a compound SELECT */
+  u8 *pHasAgg        /* True if expression contains aggregate functions */
+){
+  int i;             /* Loop counter */
+  ExprList *pEList;  /* The columns of the result set */
+  NameContext nc;    /* Name context for resolving pE */
+
+
+  /* If the term is an integer constant, return the value of that
+  ** constant */
+  pEList = pSelect->pEList;
+  if( sqlite3ExprIsInteger(pE, &i) ){
+    if( i<=0 ){
+      /* If i is too small, make it too big.  That way the calling
+      ** function still sees a value that is out of range, but does
+      ** not confuse the column number with 0 or -1 result code.
+      */
+      i = pEList->nExpr+1;
+    }
+    return i;
+  }
+
+  /* If the term is a simple identifier that try to match that identifier
+  ** against a column name in the result set.
+  */
+  if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='\'') ){
+    sqlite3 *db = pParse->db;
+    char *zCol = sqlite3NameFromToken(db, &pE->token);
+    if( zCol==0 ){
+      return -1;
+    }
+    for(i=0; i<pEList->nExpr; i++){
+      char *zAs = pEList->a[i].zName;
+      if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
+        sqlite3_free(zCol);
+        return i+1;
+      }
+    }
+    sqlite3_free(zCol);
+  }
+
+  /* Resolve all names in the ORDER BY term expression
+  */
+  memset(&nc, 0, sizeof(nc));
+  nc.pParse = pParse;
+  nc.pSrcList = pSelect->pSrc;
+  nc.pEList = pEList;
+  nc.allowAgg = 1;
+  nc.nErr = 0;
+  if( sqlite3ExprResolveNames(&nc, pE) ){
+    if( isCompound ){
+      sqlite3ErrorClear(pParse);
+      return 0;
+    }else{
+      return -1;
+    }
+  }
+  if( nc.hasAgg && pHasAgg ){
+    *pHasAgg = 1;
+  }
+
+  /* For a compound SELECT, we need to try to match the ORDER BY
+  ** expression against an expression in the result set
+  */
+  if( isCompound ){
+    for(i=0; i<pEList->nExpr; i++){
+      if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){
+        return i+1;
+      }
+    }
+  }
+  return 0;
+}
+
+
+/*
+** Analyze and ORDER BY or GROUP BY clause in a simple SELECT statement.
+** Return the number of errors seen.
+**
+** Every term of the ORDER BY or GROUP BY clause needs to be an
+** expression.  If any expression is an integer constant, then
+** that expression is replaced by the corresponding 
+** expression from the result set.
+*/
+static int processOrderGroupBy(
+  Parse *pParse,        /* Parsing context.  Leave error messages here */
+  Select *pSelect,      /* The SELECT statement containing the clause */
+  ExprList *pOrderBy,   /* The ORDER BY or GROUP BY clause to be processed */
+  int isOrder,          /* 1 for ORDER BY.  0 for GROUP BY */
+  u8 *pHasAgg           /* Set to TRUE if any term contains an aggregate */
+){
+  int i;
+  sqlite3 *db = pParse->db;
+  ExprList *pEList;
+
+  if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
+  if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){
+    const char *zType = isOrder ? "ORDER" : "GROUP";
+    sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
+    return 1;
+  }
+  pEList = pSelect->pEList;
+  if( pEList==0 ){
+    return 0;
+  }
+  for(i=0; i<pOrderBy->nExpr; i++){
+    int iCol;
+    Expr *pE = pOrderBy->a[i].pExpr;
+    iCol = matchOrderByTermToExprList(pParse, pSelect, pE, i+1, 0, pHasAgg);
+    if( iCol<0 ){
+      return 1;
+    }
+    if( iCol>pEList->nExpr ){
+      const char *zType = isOrder ? "ORDER" : "GROUP";
+      sqlite3ErrorMsg(pParse, 
+         "%r %s BY term out of range - should be "
+         "between 1 and %d", i+1, zType, pEList->nExpr);
+      return 1;
+    }
+    if( iCol>0 ){
+      CollSeq *pColl = pE->pColl;
+      int flags = pE->flags & EP_ExpCollate;
+      sqlite3ExprDelete(pE);
+      pE = sqlite3ExprDup(db, pEList->a[iCol-1].pExpr);
+      pOrderBy->a[i].pExpr = pE;
+      if( pE && pColl && flags ){
+        pE->pColl = pColl;
+        pE->flags |= flags;
+      }
+    }
+  }
+  return 0;
+}
+
+/*
+** Analyze and ORDER BY or GROUP BY clause in a SELECT statement.  Return
+** the number of errors seen.
+**
+** The processing depends on whether the SELECT is simple or compound.
+** For a simple SELECT statement, evry term of the ORDER BY or GROUP BY
+** clause needs to be an expression.  If any expression is an integer
+** constant, then that expression is replaced by the corresponding 
+** expression from the result set.
+**
+** For compound SELECT statements, every expression needs to be of
+** type TK_COLUMN with a iTable value as given in the 4th parameter.
+** If any expression is an integer, that becomes the column number.
+** Otherwise, match the expression against result set columns from
+** the left-most SELECT.
+*/
+static int processCompoundOrderBy(
+  Parse *pParse,        /* Parsing context.  Leave error messages here */
+  Select *pSelect,      /* The SELECT statement containing the ORDER BY */
+  int iTable            /* Output table for compound SELECT statements */
+){
+  int i;
+  ExprList *pOrderBy;
+  ExprList *pEList;
+  sqlite3 *db;
+  int moreToDo = 1;
+
+  pOrderBy = pSelect->pOrderBy;
+  if( pOrderBy==0 ) return 0;
+  if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){
+    sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
+    return 1;
+  }
+  db = pParse->db;
+  for(i=0; i<pOrderBy->nExpr; i++){
+    pOrderBy->a[i].done = 0;
+  }
+  while( pSelect->pPrior ){
+    pSelect = pSelect->pPrior;
+  }
+  while( pSelect && moreToDo ){
+    moreToDo = 0;
+    for(i=0; i<pOrderBy->nExpr; i++){
+      int iCol = -1;
+      Expr *pE, *pDup;
+      if( pOrderBy->a[i].done ) continue;
+      pE = pOrderBy->a[i].pExpr;
+      pDup = sqlite3ExprDup(db, pE);
+      if( !db->mallocFailed ){
+        assert(pDup);
+        iCol = matchOrderByTermToExprList(pParse, pSelect, pDup, i+1, 1, 0);
+      }
+      sqlite3ExprDelete(pDup);
+      if( iCol<0 ){
+        return 1;
+      }
+      pEList = pSelect->pEList;
+      if( pEList==0 ){
+        return 1;
+      }
+      if( iCol>pEList->nExpr ){
+        sqlite3ErrorMsg(pParse, 
+           "%r ORDER BY term out of range - should be "
+           "between 1 and %d", i+1, pEList->nExpr);
+        return 1;
+      }
+      if( iCol>0 ){
+        pE->op = TK_COLUMN;
+        pE->iTable = iTable;
+        pE->iAgg = -1;
+        pE->iColumn = iCol-1;
+        pE->pTab = 0;
+        pOrderBy->a[i].done = 1;
+      }else{
+        moreToDo = 1;
+      }
+    }
+    pSelect = pSelect->pNext;
+  }
+  for(i=0; i<pOrderBy->nExpr; i++){
+    if( pOrderBy->a[i].done==0 ){
+      sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
+            "column in the result set", i+1);
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/*
+** Get a VDBE for the given parser context.  Create a new one if necessary.
+** If an error occurs, return NULL and leave a message in pParse.
+*/
+Vdbe *sqlite3GetVdbe(Parse *pParse){
+  Vdbe *v = pParse->pVdbe;
+  if( v==0 ){
+    v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
+#ifndef SQLITE_OMIT_TRACE
+    if( v ){
+      sqlite3VdbeAddOp0(v, OP_Trace);
+    }
+#endif
+  }
+  return v;
+}
+
+
+/*
+** Compute the iLimit and iOffset fields of the SELECT based on the
+** pLimit and pOffset expressions.  pLimit and pOffset hold the expressions
+** that appear in the original SQL statement after the LIMIT and OFFSET
+** keywords.  Or NULL if those keywords are omitted. iLimit and iOffset 
+** are the integer memory register numbers for counters used to compute 
+** the limit and offset.  If there is no limit and/or offset, then 
+** iLimit and iOffset are negative.
+**
+** This routine changes the values of iLimit and iOffset only if
+** a limit or offset is defined by pLimit and pOffset.  iLimit and
+** iOffset should have been preset to appropriate default values
+** (usually but not always -1) prior to calling this routine.
+** Only if pLimit!=0 or pOffset!=0 do the limit registers get
+** redefined.  The UNION ALL operator uses this property to force
+** the reuse of the same limit and offset registers across multiple
+** SELECT statements.
+*/
+static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
+  Vdbe *v = 0;
+  int iLimit = 0;
+  int iOffset;
+  int addr1;
+
+  /* 
+  ** "LIMIT -1" always shows all rows.  There is some
+  ** contraversy about what the correct behavior should be.
+  ** The current implementation interprets "LIMIT 0" to mean
+  ** no rows.
+  */
+  if( p->pLimit ){
+    p->iLimit = iLimit = ++pParse->nMem;
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) return;
+    sqlite3ExprCode(pParse, p->pLimit, iLimit);
+    sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
+    VdbeComment((v, "LIMIT counter"));
+    sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
+  }
+  if( p->pOffset ){
+    p->iOffset = iOffset = ++pParse->nMem;
+    if( p->pLimit ){
+      pParse->nMem++;   /* Allocate an extra register for limit+offset */
+    }
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) return;
+    sqlite3ExprCode(pParse, p->pOffset, iOffset);
+    sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
+    VdbeComment((v, "OFFSET counter"));
+    addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
+    sqlite3VdbeJumpHere(v, addr1);
+    if( p->pLimit ){
+      sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
+      VdbeComment((v, "LIMIT+OFFSET"));
+      addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
+      sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
+      sqlite3VdbeJumpHere(v, addr1);
+    }
+  }
+}
+
+/*
+** Allocate a virtual index to use for sorting.
+*/
+static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){
+  if( pOrderBy ){
+    int addr;
+    assert( pOrderBy->iECursor==0 );
+    pOrderBy->iECursor = pParse->nTab++;
+    addr = sqlite3VdbeAddOp2(pParse->pVdbe, OP_OpenEphemeral,
+                            pOrderBy->iECursor, pOrderBy->nExpr+1);
+    assert( p->addrOpenEphm[2] == -1 );
+    p->addrOpenEphm[2] = addr;
+  }
+}
+
+#ifndef SQLITE_OMIT_COMPOUND_SELECT
+/*
+** Return the appropriate collating sequence for the iCol-th column of
+** the result set for the compound-select statement "p".  Return NULL if
+** the column has no default collating sequence.
+**
+** The collating sequence for the compound select is taken from the
+** left-most term of the select that has a collating sequence.
+*/
+static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
+  CollSeq *pRet;
+  if( p->pPrior ){
+    pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
+  }else{
+    pRet = 0;
+  }
+  if( pRet==0 ){
+    pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
+  }
+  return pRet;
+}
+#endif /* SQLITE_OMIT_COMPOUND_SELECT */
+
+#ifndef SQLITE_OMIT_COMPOUND_SELECT
+/*
+** This routine is called to process a query that is really the union
+** or intersection of two or more separate queries.
+**
+** "p" points to the right-most of the two queries.  the query on the
+** left is p->pPrior.  The left query could also be a compound query
+** in which case this routine will be called recursively. 
+**
+** The results of the total query are to be written into a destination
+** of type eDest with parameter iParm.
+**
+** Example 1:  Consider a three-way compound SQL statement.
+**
+**     SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
+**
+** This statement is parsed up as follows:
+**
+**     SELECT c FROM t3
+**      |
+**      `----->  SELECT b FROM t2
+**                |
+**                `------>  SELECT a FROM t1
+**
+** The arrows in the diagram above represent the Select.pPrior pointer.
+** So if this routine is called with p equal to the t3 query, then
+** pPrior will be the t2 query.  p->op will be TK_UNION in this case.
+**
+** Notice that because of the way SQLite parses compound SELECTs, the
+** individual selects always group from left to right.
+*/
+static int multiSelect(
+  Parse *pParse,        /* Parsing context */
+  Select *p,            /* The right-most of SELECTs to be coded */
+  SelectDest *pDest,    /* What to do with query results */
+  char *aff             /* If eDest is SRT_Union, the affinity string */
+){
+  int rc = SQLITE_OK;   /* Success code from a subroutine */
+  Select *pPrior;       /* Another SELECT immediately to our left */
+  Vdbe *v;              /* Generate code to this VDBE */
+  int nCol;             /* Number of columns in the result set */
+  ExprList *pOrderBy;   /* The ORDER BY clause on p */
+  int aSetP2[2];        /* Set P2 value of these op to number of columns */
+  int nSetP2 = 0;       /* Number of slots in aSetP2[] used */
+  SelectDest dest;      /* Alternative data destination */
+
+  dest = *pDest;
+
+  /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
+  ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
+  */
+  if( p==0 || p->pPrior==0 ){
+    rc = 1;
+    goto multi_select_end;
+  }
+  pPrior = p->pPrior;
+  assert( pPrior->pRightmost!=pPrior );
+  assert( pPrior->pRightmost==p->pRightmost );
+  if( pPrior->pOrderBy ){
+    sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
+      selectOpName(p->op));
+    rc = 1;
+    goto multi_select_end;
+  }
+  if( pPrior->pLimit ){
+    sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
+      selectOpName(p->op));
+    rc = 1;
+    goto multi_select_end;
+  }
+
+  /* Make sure we have a valid query engine.  If not, create a new one.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ){
+    rc = 1;
+    goto multi_select_end;
+  }
+
+  /* Create the destination temporary table if necessary
+  */
+  if( dest.eDest==SRT_EphemTab ){
+    assert( p->pEList );
+    assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
+    aSetP2[nSetP2++] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, 0);
+    dest.eDest = SRT_Table;
+  }
+
+  /* Generate code for the left and right SELECT statements.
+  */
+  pOrderBy = p->pOrderBy;
+  switch( p->op ){
+    case TK_ALL: {
+      if( pOrderBy==0 ){
+        int addr = 0;
+        assert( !pPrior->pLimit );
+        pPrior->pLimit = p->pLimit;
+        pPrior->pOffset = p->pOffset;
+        rc = sqlite3Select(pParse, pPrior, &dest, 0, 0, 0, aff);
+        p->pLimit = 0;
+        p->pOffset = 0;
+        if( rc ){
+          goto multi_select_end;
+        }
+        p->pPrior = 0;
+        p->iLimit = pPrior->iLimit;
+        p->iOffset = pPrior->iOffset;
+        if( p->iLimit>=0 ){
+          addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
+          VdbeComment((v, "Jump ahead if LIMIT reached"));
+        }
+        rc = sqlite3Select(pParse, p, &dest, 0, 0, 0, aff);
+        p->pPrior = pPrior;
+        if( rc ){
+          goto multi_select_end;
+        }
+        if( addr ){
+          sqlite3VdbeJumpHere(v, addr);
+        }
+        break;
+      }
+      /* For UNION ALL ... ORDER BY fall through to the next case */
+    }
+    case TK_EXCEPT:
+    case TK_UNION: {
+      int unionTab;    /* Cursor number of the temporary table holding result */
+      int op = 0;      /* One of the SRT_ operations to apply to self */
+      int priorOp;     /* The SRT_ operation to apply to prior selects */
+      Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
+      int addr;
+      SelectDest uniondest;
+
+      priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union;
+      if( dest.eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){
+        /* We can reuse a temporary table generated by a SELECT to our
+        ** right.
+        */
+        unionTab = dest.iParm;
+      }else{
+        /* We will need to create our own temporary table to hold the
+        ** intermediate results.
+        */
+        unionTab = pParse->nTab++;
+        if( processCompoundOrderBy(pParse, p, unionTab) ){
+          rc = 1;
+          goto multi_select_end;
+        }
+        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
+        if( priorOp==SRT_Table ){
+          assert( nSetP2<sizeof(aSetP2)/sizeof(aSetP2[0]) );
+          aSetP2[nSetP2++] = addr;
+        }else{
+          assert( p->addrOpenEphm[0] == -1 );
+          p->addrOpenEphm[0] = addr;
+          p->pRightmost->usesEphm = 1;
+        }
+        createSortingIndex(pParse, p, pOrderBy);
+        assert( p->pEList );
+      }
+
+      /* Code the SELECT statements to our left
+      */
+      assert( !pPrior->pOrderBy );
+      sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
+      rc = sqlite3Select(pParse, pPrior, &uniondest, 0, 0, 0, aff);
+      if( rc ){
+        goto multi_select_end;
+      }
+
+      /* Code the current SELECT statement
+      */
+      switch( p->op ){
+         case TK_EXCEPT:  op = SRT_Except;   break;
+         case TK_UNION:   op = SRT_Union;    break;
+         case TK_ALL:     op = SRT_Table;    break;
+      }
+      p->pPrior = 0;
+      p->pOrderBy = 0;
+      p->disallowOrderBy = pOrderBy!=0;
+      pLimit = p->pLimit;
+      p->pLimit = 0;
+      pOffset = p->pOffset;
+      p->pOffset = 0;
+      uniondest.eDest = op;
+      rc = sqlite3Select(pParse, p, &uniondest, 0, 0, 0, aff);
+      /* Query flattening in sqlite3Select() might refill p->pOrderBy.
+      ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
+      sqlite3ExprListDelete(p->pOrderBy);
+      p->pPrior = pPrior;
+      p->pOrderBy = pOrderBy;
+      sqlite3ExprDelete(p->pLimit);
+      p->pLimit = pLimit;
+      p->pOffset = pOffset;
+      p->iLimit = -1;
+      p->iOffset = -1;
+      if( rc ){
+        goto multi_select_end;
+      }
+
+
+      /* Convert the data in the temporary table into whatever form
+      ** it is that we currently need.
+      */      
+      if( dest.eDest!=priorOp || unionTab!=dest.iParm ){
+        int iCont, iBreak, iStart;
+        assert( p->pEList );
+        if( dest.eDest==SRT_Callback ){
+          Select *pFirst = p;
+          while( pFirst->pPrior ) pFirst = pFirst->pPrior;
+          generateColumnNames(pParse, 0, pFirst->pEList);
+        }
+        iBreak = sqlite3VdbeMakeLabel(v);
+        iCont = sqlite3VdbeMakeLabel(v);
+        computeLimitRegisters(pParse, p, iBreak);
+        sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
+        iStart = sqlite3VdbeCurrentAddr(v);
+        selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
+                        pOrderBy, -1, &dest, iCont, iBreak, 0);
+        sqlite3VdbeResolveLabel(v, iCont);
+        sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
+        sqlite3VdbeResolveLabel(v, iBreak);
+        sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
+      }
+      break;
+    }
+    case TK_INTERSECT: {
+      int tab1, tab2;
+      int iCont, iBreak, iStart;
+      Expr *pLimit, *pOffset;
+      int addr;
+      SelectDest intersectdest;
+      int r1;
+
+      /* INTERSECT is different from the others since it requires
+      ** two temporary tables.  Hence it has its own case.  Begin
+      ** by allocating the tables we will need.
+      */
+      tab1 = pParse->nTab++;
+      tab2 = pParse->nTab++;
+      if( processCompoundOrderBy(pParse, p, tab1) ){
+        rc = 1;
+        goto multi_select_end;
+      }
+      createSortingIndex(pParse, p, pOrderBy);
+
+      addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
+      assert( p->addrOpenEphm[0] == -1 );
+      p->addrOpenEphm[0] = addr;
+      p->pRightmost->usesEphm = 1;
+      assert( p->pEList );
+
+      /* Code the SELECTs to our left into temporary table "tab1".
+      */
+      sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
+      rc = sqlite3Select(pParse, pPrior, &intersectdest, 0, 0, 0, aff);
+      if( rc ){
+        goto multi_select_end;
+      }
+
+      /* Code the current SELECT into temporary table "tab2"
+      */
+      addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
+      assert( p->addrOpenEphm[1] == -1 );
+      p->addrOpenEphm[1] = addr;
+      p->pPrior = 0;
+      pLimit = p->pLimit;
+      p->pLimit = 0;
+      pOffset = p->pOffset;
+      p->pOffset = 0;
+      intersectdest.iParm = tab2;
+      rc = sqlite3Select(pParse, p, &intersectdest, 0, 0, 0, aff);
+      p->pPrior = pPrior;
+      sqlite3ExprDelete(p->pLimit);
+      p->pLimit = pLimit;
+      p->pOffset = pOffset;
+      if( rc ){
+        goto multi_select_end;
+      }
+
+      /* Generate code to take the intersection of the two temporary
+      ** tables.
+      */
+      assert( p->pEList );
+      if( dest.eDest==SRT_Callback ){
+        Select *pFirst = p;
+        while( pFirst->pPrior ) pFirst = pFirst->pPrior;
+        generateColumnNames(pParse, 0, pFirst->pEList);
+      }
+      iBreak = sqlite3VdbeMakeLabel(v);
+      iCont = sqlite3VdbeMakeLabel(v);
+      computeLimitRegisters(pParse, p, iBreak);
+      sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
+      r1 = sqlite3GetTempReg(pParse);
+      iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
+      sqlite3VdbeAddOp3(v, OP_NotFound, tab2, iCont, r1);
+      sqlite3ReleaseTempReg(pParse, r1);
+      selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
+                      pOrderBy, -1, &dest, iCont, iBreak, 0);
+      sqlite3VdbeResolveLabel(v, iCont);
+      sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
+      sqlite3VdbeResolveLabel(v, iBreak);
+      sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
+      sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
+      break;
+    }
+  }
+
+  /* Make sure all SELECTs in the statement have the same number of elements
+  ** in their result sets.
+  */
+  assert( p->pEList && pPrior->pEList );
+  if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
+    sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
+      " do not have the same number of result columns", selectOpName(p->op));
+    rc = 1;
+    goto multi_select_end;
+  }
+
+  /* Set the number of columns in temporary tables
+  */
+  nCol = p->pEList->nExpr;
+  while( nSetP2 ){
+    sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol);
+  }
+
+  /* Compute collating sequences used by either the ORDER BY clause or
+  ** by any temporary tables needed to implement the compound select.
+  ** Attach the KeyInfo structure to all temporary tables.  Invoke the
+  ** ORDER BY processing if there is an ORDER BY clause.
+  **
+  ** This section is run by the right-most SELECT statement only.
+  ** SELECT statements to the left always skip this part.  The right-most
+  ** SELECT might also skip this part if it has no ORDER BY clause and
+  ** no temp tables are required.
+  */
+  if( pOrderBy || p->usesEphm ){
+    int i;                        /* Loop counter */
+    KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
+    Select *pLoop;                /* For looping through SELECT statements */
+    int nKeyCol;                  /* Number of entries in pKeyInfo->aCol[] */
+    CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
+    CollSeq **aCopy;              /* A copy of pKeyInfo->aColl[] */
+
+    assert( p->pRightmost==p );
+    nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0);
+    pKeyInfo = sqlite3DbMallocZero(pParse->db,
+                       sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1));
+    if( !pKeyInfo ){
+      rc = SQLITE_NOMEM;
+      goto multi_select_end;
+    }
+
+    pKeyInfo->enc = ENC(pParse->db);
+    pKeyInfo->nField = nCol;
+
+    for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
+      *apColl = multiSelectCollSeq(pParse, p, i);
+      if( 0==*apColl ){
+        *apColl = pParse->db->pDfltColl;
+      }
+    }
+
+    for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
+      for(i=0; i<2; i++){
+        int addr = pLoop->addrOpenEphm[i];
+        if( addr<0 ){
+          /* If [0] is unused then [1] is also unused.  So we can
+          ** always safely abort as soon as the first unused slot is found */
+          assert( pLoop->addrOpenEphm[1]<0 );
+          break;
+        }
+        sqlite3VdbeChangeP2(v, addr, nCol);
+        sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
+        pLoop->addrOpenEphm[i] = -1;
+      }
+    }
+
+    if( pOrderBy ){
+      struct ExprList_item *pOTerm = pOrderBy->a;
+      int nOrderByExpr = pOrderBy->nExpr;
+      int addr;
+      u8 *pSortOrder;
+
+      /* Reuse the same pKeyInfo for the ORDER BY as was used above for
+      ** the compound select statements.  Except we have to change out the
+      ** pKeyInfo->aColl[] values.  Some of the aColl[] values will be
+      ** reused when constructing the pKeyInfo for the ORDER BY, so make
+      ** a copy.  Sufficient space to hold both the nCol entries for
+      ** the compound select and the nOrderbyExpr entries for the ORDER BY
+      ** was allocated above.  But we need to move the compound select
+      ** entries out of the way before constructing the ORDER BY entries.
+      ** Move the compound select entries into aCopy[] where they can be
+      ** accessed and reused when constructing the ORDER BY entries.
+      ** Because nCol might be greater than or less than nOrderByExpr
+      ** we have to use memmove() when doing the copy.
+      */
+      aCopy = &pKeyInfo->aColl[nOrderByExpr];
+      pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol];
+      memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*));
+
+      apColl = pKeyInfo->aColl;
+      for(i=0; i<nOrderByExpr; i++, pOTerm++, apColl++, pSortOrder++){
+        Expr *pExpr = pOTerm->pExpr;
+        if( (pExpr->flags & EP_ExpCollate) ){
+          assert( pExpr->pColl!=0 );
+          *apColl = pExpr->pColl;
+        }else{
+          *apColl = aCopy[pExpr->iColumn];
+        }
+        *pSortOrder = pOTerm->sortOrder;
+      }
+      assert( p->pRightmost==p );
+      assert( p->addrOpenEphm[2]>=0 );
+      addr = p->addrOpenEphm[2];
+      sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2);
+      pKeyInfo->nField = nOrderByExpr;
+      sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
+      pKeyInfo = 0;
+      generateSortTail(pParse, p, v, p->pEList->nExpr, &dest);
+    }
+
+    sqlite3_free(pKeyInfo);
+  }
+
+multi_select_end:
+  pDest->iMem = dest.iMem;
+  return rc;
+}
+#endif /* SQLITE_OMIT_COMPOUND_SELECT */
+
+#ifndef SQLITE_OMIT_VIEW
+/* Forward Declarations */
+static void substExprList(sqlite3*, ExprList*, int, ExprList*);
+static void substSelect(sqlite3*, Select *, int, ExprList *);
+
+/*
+** Scan through the expression pExpr.  Replace every reference to
+** a column in table number iTable with a copy of the iColumn-th
+** entry in pEList.  (But leave references to the ROWID column 
+** unchanged.)
+**
+** This routine is part of the flattening procedure.  A subquery
+** whose result set is defined by pEList appears as entry in the
+** FROM clause of a SELECT such that the VDBE cursor assigned to that
+** FORM clause entry is iTable.  This routine make the necessary 
+** changes to pExpr so that it refers directly to the source table
+** of the subquery rather the result set of the subquery.
+*/
+static void substExpr(
+  sqlite3 *db,        /* Report malloc errors to this connection */
+  Expr *pExpr,        /* Expr in which substitution occurs */
+  int iTable,         /* Table to be substituted */
+  ExprList *pEList    /* Substitute expressions */
+){
+  if( pExpr==0 ) return;
+  if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
+    if( pExpr->iColumn<0 ){
+      pExpr->op = TK_NULL;
+    }else{
+      Expr *pNew;
+      assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
+      assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 );
+      pNew = pEList->a[pExpr->iColumn].pExpr;
+      assert( pNew!=0 );
+      pExpr->op = pNew->op;
+      assert( pExpr->pLeft==0 );
+      pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft);
+      assert( pExpr->pRight==0 );
+      pExpr->pRight = sqlite3ExprDup(db, pNew->pRight);
+      assert( pExpr->pList==0 );
+      pExpr->pList = sqlite3ExprListDup(db, pNew->pList);
+      pExpr->iTable = pNew->iTable;
+      pExpr->pTab = pNew->pTab;
+      pExpr->iColumn = pNew->iColumn;
+      pExpr->iAgg = pNew->iAgg;
+      sqlite3TokenCopy(db, &pExpr->token, &pNew->token);
+      sqlite3TokenCopy(db, &pExpr->span, &pNew->span);
+      pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect);
+      pExpr->flags = pNew->flags;
+    }
+  }else{
+    substExpr(db, pExpr->pLeft, iTable, pEList);
+    substExpr(db, pExpr->pRight, iTable, pEList);
+    substSelect(db, pExpr->pSelect, iTable, pEList);
+    substExprList(db, pExpr->pList, iTable, pEList);
+  }
+}
+static void substExprList(
+  sqlite3 *db,         /* Report malloc errors here */
+  ExprList *pList,     /* List to scan and in which to make substitutes */
+  int iTable,          /* Table to be substituted */
+  ExprList *pEList     /* Substitute values */
+){
+  int i;
+  if( pList==0 ) return;
+  for(i=0; i<pList->nExpr; i++){
+    substExpr(db, pList->a[i].pExpr, iTable, pEList);
+  }
+}
+static void substSelect(
+  sqlite3 *db,         /* Report malloc errors here */
+  Select *p,           /* SELECT statement in which to make substitutions */
+  int iTable,          /* Table to be replaced */
+  ExprList *pEList     /* Substitute values */
+){
+  if( !p ) return;
+  substExprList(db, p->pEList, iTable, pEList);
+  substExprList(db, p->pGroupBy, iTable, pEList);
+  substExprList(db, p->pOrderBy, iTable, pEList);
+  substExpr(db, p->pHaving, iTable, pEList);
+  substExpr(db, p->pWhere, iTable, pEList);
+  substSelect(db, p->pPrior, iTable, pEList);
+}
+#endif /* !defined(SQLITE_OMIT_VIEW) */
+
+#ifndef SQLITE_OMIT_VIEW
+/*
+** This routine attempts to flatten subqueries in order to speed
+** execution.  It returns 1 if it makes changes and 0 if no flattening
+** occurs.
+**
+** To understand the concept of flattening, consider the following
+** query:
+**
+**     SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
+**
+** The default way of implementing this query is to execute the
+** subquery first and store the results in a temporary table, then
+** run the outer query on that temporary table.  This requires two
+** passes over the data.  Furthermore, because the temporary table
+** has no indices, the WHERE clause on the outer query cannot be
+** optimized.
+**
+** This routine attempts to rewrite queries such as the above into
+** a single flat select, like this:
+**
+**     SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
+**
+** The code generated for this simpification gives the same result
+** but only has to scan the data once.  And because indices might 
+** exist on the table t1, a complete scan of the data might be
+** avoided.
+**
+** Flattening is only attempted if all of the following are true:
+**
+**   (1)  The subquery and the outer query do not both use aggregates.
+**
+**   (2)  The subquery is not an aggregate or the outer query is not a join.
+**
+**   (3)  The subquery is not the right operand of a left outer join, or
+**        the subquery is not itself a join.  (Ticket #306)
+**
+**   (4)  The subquery is not DISTINCT or the outer query is not a join.
+**
+**   (5)  The subquery is not DISTINCT or the outer query does not use
+**        aggregates.
+**
+**   (6)  The subquery does not use aggregates or the outer query is not
+**        DISTINCT.
+**
+**   (7)  The subquery has a FROM clause.
+**
+**   (8)  The subquery does not use LIMIT or the outer query is not a join.
+**
+**   (9)  The subquery does not use LIMIT or the outer query does not use
+**        aggregates.
+**
+**  (10)  The subquery does not use aggregates or the outer query does not
+**        use LIMIT.
+**
+**  (11)  The subquery and the outer query do not both have ORDER BY clauses.
+**
+**  (12)  The subquery is not the right term of a LEFT OUTER JOIN or the
+**        subquery has no WHERE clause.  (added by ticket #350)
+**
+**  (13)  The subquery and outer query do not both use LIMIT
+**
+**  (14)  The subquery does not use OFFSET
+**
+**  (15)  The outer query is not part of a compound select or the
+**        subquery does not have both an ORDER BY and a LIMIT clause.
+**        (See ticket #2339)
+**
+** In this routine, the "p" parameter is a pointer to the outer query.
+** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
+** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
+**
+** If flattening is not attempted, this routine is a no-op and returns 0.
+** If flattening is attempted this routine returns 1.
+**
+** All of the expression analysis must occur on both the outer query and
+** the subquery before this routine runs.
+*/
+static int flattenSubquery(
+  sqlite3 *db,         /* Database connection */
+  Select *p,           /* The parent or outer SELECT statement */
+  int iFrom,           /* Index in p->pSrc->a[] of the inner subquery */
+  int isAgg,           /* True if outer SELECT uses aggregate functions */
+  int subqueryIsAgg    /* True if the subquery uses aggregate functions */
+){
+  Select *pSub;       /* The inner query or "subquery" */
+  SrcList *pSrc;      /* The FROM clause of the outer query */
+  SrcList *pSubSrc;   /* The FROM clause of the subquery */
+  ExprList *pList;    /* The result set of the outer query */
+  int iParent;        /* VDBE cursor number of the pSub result set temp table */
+  int i;              /* Loop counter */
+  Expr *pWhere;                    /* The WHERE clause */
+  struct SrcList_item *pSubitem;   /* The subquery */
+
+  /* Check to see if flattening is permitted.  Return 0 if not.
+  */
+  if( p==0 ) return 0;
+  pSrc = p->pSrc;
+  assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
+  pSubitem = &pSrc->a[iFrom];
+  pSub = pSubitem->pSelect;
+  assert( pSub!=0 );
+  if( isAgg && subqueryIsAgg ) return 0;                 /* Restriction (1)  */
+  if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;          /* Restriction (2)  */
+  pSubSrc = pSub->pSrc;
+  assert( pSubSrc );
+  /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
+  ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
+  ** because they could be computed at compile-time.  But when LIMIT and OFFSET
+  ** became arbitrary expressions, we were forced to add restrictions (13)
+  ** and (14). */
+  if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
+  if( pSub->pOffset ) return 0;                          /* Restriction (14) */
+  if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){
+    return 0;                                            /* Restriction (15) */
+  }
+  if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */
+  if( (pSub->isDistinct || pSub->pLimit) 
+         && (pSrc->nSrc>1 || isAgg) ){          /* Restrictions (4)(5)(8)(9) */
+     return 0;       
+  }
+  if( p->isDistinct && subqueryIsAgg ) return 0;         /* Restriction (6)  */
+  if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
+     return 0;                                           /* Restriction (11) */
+  }
+
+  /* Restriction 3:  If the subquery is a join, make sure the subquery is 
+  ** not used as the right operand of an outer join.  Examples of why this
+  ** is not allowed:
+  **
+  **         t1 LEFT OUTER JOIN (t2 JOIN t3)
+  **
+  ** If we flatten the above, we would get
+  **
+  **         (t1 LEFT OUTER JOIN t2) JOIN t3
+  **
+  ** which is not at all the same thing.
+  */
+  if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){
+    return 0;
+  }
+
+  /* Restriction 12:  If the subquery is the right operand of a left outer
+  ** join, make sure the subquery has no WHERE clause.
+  ** An examples of why this is not allowed:
+  **
+  **         t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
+  **
+  ** If we flatten the above, we would get
+  **
+  **         (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
+  **
+  ** But the t2.x>0 test will always fail on a NULL row of t2, which
+  ** effectively converts the OUTER JOIN into an INNER JOIN.
+  */
+  if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){
+    return 0;
+  }
+
+  /* If we reach this point, it means flattening is permitted for the
+  ** iFrom-th entry of the FROM clause in the outer query.
+  */
+
+  /* Move all of the FROM elements of the subquery into the
+  ** the FROM clause of the outer query.  Before doing this, remember
+  ** the cursor number for the original outer query FROM element in
+  ** iParent.  The iParent cursor will never be used.  Subsequent code
+  ** will scan expressions looking for iParent references and replace
+  ** those references with expressions that resolve to the subquery FROM
+  ** elements we are now copying in.
+  */
+  iParent = pSubitem->iCursor;
+  {
+    int nSubSrc = pSubSrc->nSrc;
+    int jointype = pSubitem->jointype;
+
+    sqlite3DeleteTable(pSubitem->pTab);
+    sqlite3_free(pSubitem->zDatabase);
+    sqlite3_free(pSubitem->zName);
+    sqlite3_free(pSubitem->zAlias);
+    pSubitem->pTab = 0;
+    pSubitem->zDatabase = 0;
+    pSubitem->zName = 0;
+    pSubitem->zAlias = 0;
+    if( nSubSrc>1 ){
+      int extra = nSubSrc - 1;
+      for(i=1; i<nSubSrc; i++){
+        pSrc = sqlite3SrcListAppend(db, pSrc, 0, 0);
+        if( pSrc==0 ){
+          p->pSrc = 0;
+          return 1;
+        }
+      }
+      p->pSrc = pSrc;
+      for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){
+        pSrc->a[i] = pSrc->a[i-extra];
+      }
+    }
+    for(i=0; i<nSubSrc; i++){
+      pSrc->a[i+iFrom] = pSubSrc->a[i];
+      memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
+    }
+    pSrc->a[iFrom].jointype = jointype;
+  }
+
+  /* Now begin substituting subquery result set expressions for 
+  ** references to the iParent in the outer query.
+  ** 
+  ** Example:
+  **
+  **   SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
+  **   \                     \_____________ subquery __________/          /
+  **    \_____________________ outer query ______________________________/
+  **
+  ** We look at every expression in the outer query and every place we see
+  ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
+  */
+  pList = p->pEList;
+  for(i=0; i<pList->nExpr; i++){
+    Expr *pExpr;
+    if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
+      pList->a[i].zName = 
+             sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
+    }
+  }
+  substExprList(db, p->pEList, iParent, pSub->pEList);
+  if( isAgg ){
+    substExprList(db, p->pGroupBy, iParent, pSub->pEList);
+    substExpr(db, p->pHaving, iParent, pSub->pEList);
+  }
+  if( pSub->pOrderBy ){
+    assert( p->pOrderBy==0 );
+    p->pOrderBy = pSub->pOrderBy;
+    pSub->pOrderBy = 0;
+  }else if( p->pOrderBy ){
+    substExprList(db, p->pOrderBy, iParent, pSub->pEList);
+  }
+  if( pSub->pWhere ){
+    pWhere = sqlite3ExprDup(db, pSub->pWhere);
+  }else{
+    pWhere = 0;
+  }
+  if( subqueryIsAgg ){
+    assert( p->pHaving==0 );
+    p->pHaving = p->pWhere;
+    p->pWhere = pWhere;
+    substExpr(db, p->pHaving, iParent, pSub->pEList);
+    p->pHaving = sqlite3ExprAnd(db, p->pHaving, 
+                                sqlite3ExprDup(db, pSub->pHaving));
+    assert( p->pGroupBy==0 );
+    p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
+  }else{
+    substExpr(db, p->pWhere, iParent, pSub->pEList);
+    p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
+  }
+
+  /* The flattened query is distinct if either the inner or the
+  ** outer query is distinct. 
+  */
+  p->isDistinct = p->isDistinct || pSub->isDistinct;
+
+  /*
+  ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
+  **
+  ** One is tempted to try to add a and b to combine the limits.  But this
+  ** does not work if either limit is negative.
+  */
+  if( pSub->pLimit ){
+    p->pLimit = pSub->pLimit;
+    pSub->pLimit = 0;
+  }
+
+  /* Finially, delete what is left of the subquery and return
+  ** success.
+  */
+  sqlite3SelectDelete(pSub);
+  return 1;
+}
+#endif /* SQLITE_OMIT_VIEW */
+
+/*
+** Analyze the SELECT statement passed as an argument to see if it
+** is a min() or max() query. Return ORDERBY_MIN or ORDERBY_MAX if 
+** it is, or 0 otherwise. At present, a query is considered to be
+** a min()/max() query if:
+**
+**   1. There is a single object in the FROM clause.
+**
+**   2. There is a single expression in the result set, and it is
+**      either min(x) or max(x), where x is a column reference.
+*/
+static int minMaxQuery(Parse *pParse, Select *p){
+  Expr *pExpr;
+  ExprList *pEList = p->pEList;
+
+  if( pEList->nExpr!=1 ) return ORDERBY_NORMAL;
+  pExpr = pEList->a[0].pExpr;
+  pEList = pExpr->pList;
+  if( pExpr->op!=TK_AGG_FUNCTION || pEList==0 || pEList->nExpr!=1 ) return 0;
+  if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return ORDERBY_NORMAL;
+  if( pExpr->token.n!=3 ) return ORDERBY_NORMAL;
+  if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
+    return ORDERBY_MIN;
+  }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
+    return ORDERBY_MAX;
+  }
+  return ORDERBY_NORMAL;
+}
+
+/*
+** This routine resolves any names used in the result set of the
+** supplied SELECT statement. If the SELECT statement being resolved
+** is a sub-select, then pOuterNC is a pointer to the NameContext 
+** of the parent SELECT.
+*/
+int sqlite3SelectResolve(
+  Parse *pParse,         /* The parser context */
+  Select *p,             /* The SELECT statement being coded. */
+  NameContext *pOuterNC  /* The outer name context. May be NULL. */
+){
+  ExprList *pEList;          /* Result set. */
+  int i;                     /* For-loop variable used in multiple places */
+  NameContext sNC;           /* Local name-context */
+  ExprList *pGroupBy;        /* The group by clause */
+
+  /* If this routine has run before, return immediately. */
+  if( p->isResolved ){
+    assert( !pOuterNC );
+    return SQLITE_OK;
+  }
+  p->isResolved = 1;
+
+  /* If there have already been errors, do nothing. */
+  if( pParse->nErr>0 ){
+    return SQLITE_ERROR;
+  }
+
+  /* Prepare the select statement. This call will allocate all cursors
+  ** required to handle the tables and subqueries in the FROM clause.
+  */
+  if( prepSelectStmt(pParse, p) ){
+    return SQLITE_ERROR;
+  }
+
+  /* Resolve the expressions in the LIMIT and OFFSET clauses. These
+  ** are not allowed to refer to any names, so pass an empty NameContext.
+  */
+  memset(&sNC, 0, sizeof(sNC));
+  sNC.pParse = pParse;
+  if( sqlite3ExprResolveNames(&sNC, p->pLimit) ||
+      sqlite3ExprResolveNames(&sNC, p->pOffset) ){
+    return SQLITE_ERROR;
+  }
+
+  /* Set up the local name-context to pass to ExprResolveNames() to
+  ** resolve the expression-list.
+  */
+  sNC.allowAgg = 1;
+  sNC.pSrcList = p->pSrc;
+  sNC.pNext = pOuterNC;
+
+  /* Resolve names in the result set. */
+  pEList = p->pEList;
+  if( !pEList ) return SQLITE_ERROR;
+  for(i=0; i<pEList->nExpr; i++){
+    Expr *pX = pEList->a[i].pExpr;
+    if( sqlite3ExprResolveNames(&sNC, pX) ){
+      return SQLITE_ERROR;
+    }
+  }
+
+  /* If there are no aggregate functions in the result-set, and no GROUP BY 
+  ** expression, do not allow aggregates in any of the other expressions.
+  */
+  assert( !p->isAgg );
+  pGroupBy = p->pGroupBy;
+  if( pGroupBy || sNC.hasAgg ){
+    p->isAgg = 1;
+  }else{
+    sNC.allowAgg = 0;
+  }
+
+  /* If a HAVING clause is present, then there must be a GROUP BY clause.
+  */
+  if( p->pHaving && !pGroupBy ){
+    sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
+    return SQLITE_ERROR;
+  }
+
+  /* Add the expression list to the name-context before parsing the
+  ** other expressions in the SELECT statement. This is so that
+  ** expressions in the WHERE clause (etc.) can refer to expressions by
+  ** aliases in the result set.
+  **
+  ** Minor point: If this is the case, then the expression will be
+  ** re-evaluated for each reference to it.
+  */
+  sNC.pEList = p->pEList;
+  if( sqlite3ExprResolveNames(&sNC, p->pWhere) ||
+     sqlite3ExprResolveNames(&sNC, p->pHaving) ){
+    return SQLITE_ERROR;
+  }
+  if( p->pPrior==0 ){
+    if( processOrderGroupBy(pParse, p, p->pOrderBy, 1, &sNC.hasAgg) ){
+      return SQLITE_ERROR;
+    }
+  }
+  if( processOrderGroupBy(pParse, p, pGroupBy, 0, &sNC.hasAgg) ){
+    return SQLITE_ERROR;
+  }
+
+  if( pParse->db->mallocFailed ){
+    return SQLITE_NOMEM;
+  }
+
+  /* Make sure the GROUP BY clause does not contain aggregate functions.
+  */
+  if( pGroupBy ){
+    struct ExprList_item *pItem;
+  
+    for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
+      if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
+        sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
+            "the GROUP BY clause");
+        return SQLITE_ERROR;
+      }
+    }
+  }
+
+  /* If this is one SELECT of a compound, be sure to resolve names
+  ** in the other SELECTs.
+  */
+  if( p->pPrior ){
+    return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC);
+  }else{
+    return SQLITE_OK;
+  }
+}
+
+/*
+** Reset the aggregate accumulator.
+**
+** The aggregate accumulator is a set of memory cells that hold
+** intermediate results while calculating an aggregate.  This
+** routine simply stores NULLs in all of those memory cells.
+*/
+static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  struct AggInfo_func *pFunc;
+  if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
+    return;
+  }
+  for(i=0; i<pAggInfo->nColumn; i++){
+    sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
+  }
+  for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
+    sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
+    if( pFunc->iDistinct>=0 ){
+      Expr *pE = pFunc->pExpr;
+      if( pE->pList==0 || pE->pList->nExpr!=1 ){
+        sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed "
+           "by an expression");
+        pFunc->iDistinct = -1;
+      }else{
+        KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList);
+        sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
+                          (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
+      }
+    }
+  }
+}
+
+/*
+** Invoke the OP_AggFinalize opcode for every aggregate function
+** in the AggInfo structure.
+*/
+static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  struct AggInfo_func *pF;
+  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
+    ExprList *pList = pF->pExpr->pList;
+    sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
+                      (void*)pF->pFunc, P4_FUNCDEF);
+  }
+}
+
+/*
+** Update the accumulator memory cells for an aggregate based on
+** the current cursor position.
+*/
+static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
+  Vdbe *v = pParse->pVdbe;
+  int i;
+  struct AggInfo_func *pF;
+  struct AggInfo_col *pC;
+
+  pAggInfo->directMode = 1;
+  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
+    int nArg;
+    int addrNext = 0;
+    int regAgg;
+    ExprList *pList = pF->pExpr->pList;
+    if( pList ){
+      nArg = pList->nExpr;
+      regAgg = sqlite3GetTempRange(pParse, nArg);
+      sqlite3ExprCodeExprList(pParse, pList, regAgg);
+    }else{
+      nArg = 0;
+      regAgg = 0;
+    }
+    if( pF->iDistinct>=0 ){
+      addrNext = sqlite3VdbeMakeLabel(v);
+      assert( nArg==1 );
+      codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
+    }
+    if( pF->pFunc->needCollSeq ){
+      CollSeq *pColl = 0;
+      struct ExprList_item *pItem;
+      int j;
+      assert( pList!=0 );  /* pList!=0 if pF->pFunc->needCollSeq is true */
+      for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
+        pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
+      }
+      if( !pColl ){
+        pColl = pParse->db->pDfltColl;
+      }
+      sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
+    }
+    sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
+                      (void*)pF->pFunc, P4_FUNCDEF);
+    sqlite3VdbeChangeP5(v, nArg);
+    sqlite3ReleaseTempRange(pParse, regAgg, nArg);
+    if( addrNext ){
+      sqlite3VdbeResolveLabel(v, addrNext);
+    }
+  }
+  for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
+    sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
+  }
+  pAggInfo->directMode = 0;
+}
+
+#ifndef SQLITE_OMIT_TRIGGER
+/*
+** This function is used when a SELECT statement is used to create a
+** temporary table for iterating through when running an INSTEAD OF
+** UPDATE or INSTEAD OF DELETE trigger. 
+**
+** If possible, the SELECT statement is modified so that NULL values
+** are stored in the temporary table for all columns for which the 
+** corresponding bit in argument mask is not set. If mask takes the
+** special value 0xffffffff, then all columns are populated.
+*/
+void sqlite3SelectMask(Parse *pParse, Select *p, u32 mask){
+  if( p && !p->pPrior && !p->isDistinct && mask!=0xffffffff ){
+    ExprList *pEList;
+    int i;
+    sqlite3SelectResolve(pParse, p, 0);
+    pEList = p->pEList;
+    for(i=0; pEList && i<pEList->nExpr && i<32; i++){
+      if( !(mask&((u32)1<<i)) ){
+        sqlite3ExprDelete(pEList->a[i].pExpr);
+        pEList->a[i].pExpr = sqlite3Expr(pParse->db, TK_NULL, 0, 0, 0);
+      }
+    }
+  }
+}
+#endif
+
+/*
+** Generate code for the given SELECT statement.
+**
+** The results are distributed in various ways depending on the
+** contents of the SelectDest structure pointed to by argument pDest
+** as follows:
+**
+**     pDest->eDest    Result
+**     ------------    -------------------------------------------
+**     SRT_Callback    Invoke the callback for each row of the result.
+**
+**     SRT_Mem         Store first result in memory cell pDest->iParm
+**
+**     SRT_Set         Store non-null results as keys of table pDest->iParm. 
+**                     Apply the affinity pDest->affinity before storing them.
+**
+**     SRT_Union       Store results as a key in a temporary table pDest->iParm.
+**
+**     SRT_Except      Remove results from the temporary table pDest->iParm.
+**
+**     SRT_Table       Store results in temporary table pDest->iParm
+**
+**     SRT_EphemTab    Create an temporary table pDest->iParm and store
+**                     the result there. The cursor is left open after
+**                     returning.
+**
+**     SRT_Subroutine  For each row returned, push the results onto the
+**                     vdbe stack and call the subroutine (via OP_Gosub)
+**                     at address pDest->iParm.
+**
+**     SRT_Exists      Store a 1 in memory cell pDest->iParm if the result
+**                     set is not empty.
+**
+**     SRT_Discard     Throw the results away.
+**
+** See the selectInnerLoop() function for a canonical listing of the 
+** allowed values of eDest and their meanings.
+**
+** This routine returns the number of errors.  If any errors are
+** encountered, then an appropriate error message is left in
+** pParse->zErrMsg.
+**
+** This routine does NOT free the Select structure passed in.  The
+** calling function needs to do that.
+**
+** The pParent, parentTab, and *pParentAgg fields are filled in if this
+** SELECT is a subquery.  This routine may try to combine this SELECT
+** with its parent to form a single flat query.  In so doing, it might
+** change the parent query from a non-aggregate to an aggregate query.
+** For that reason, the pParentAgg flag is passed as a pointer, so it
+** can be changed.
+**
+** Example 1:   The meaning of the pParent parameter.
+**
+**    SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3;
+**    \                      \_______ subquery _______/        /
+**     \                                                      /
+**      \____________________ outer query ___________________/
+**
+** This routine is called for the outer query first.   For that call,
+** pParent will be NULL.  During the processing of the outer query, this 
+** routine is called recursively to handle the subquery.  For the recursive
+** call, pParent will point to the outer query.  Because the subquery is
+** the second element in a three-way join, the parentTab parameter will
+** be 1 (the 2nd value of a 0-indexed array.)
+*/
+int sqlite3Select(
+  Parse *pParse,         /* The parser context */
+  Select *p,             /* The SELECT statement being coded. */
+  SelectDest *pDest,     /* What to do with the query results */
+  Select *pParent,       /* Another SELECT for which this is a sub-query */
+  int parentTab,         /* Index in pParent->pSrc of this query */
+  int *pParentAgg,       /* True if pParent uses aggregate functions */
+  char *aff              /* If eDest is SRT_Union, the affinity string */
+){
+  int i, j;              /* Loop counters */
+  WhereInfo *pWInfo;     /* Return from sqlite3WhereBegin() */
+  Vdbe *v;               /* The virtual machine under construction */
+  int isAgg;             /* True for select lists like "count(*)" */
+  ExprList *pEList;      /* List of columns to extract. */
+  SrcList *pTabList;     /* List of tables to select from */
+  Expr *pWhere;          /* The WHERE clause.  May be NULL */
+  ExprList *pOrderBy;    /* The ORDER BY clause.  May be NULL */
+  ExprList *pGroupBy;    /* The GROUP BY clause.  May be NULL */
+  Expr *pHaving;         /* The HAVING clause.  May be NULL */
+  int isDistinct;        /* True if the DISTINCT keyword is present */
+  int distinct;          /* Table to use for the distinct set */
+  int rc = 1;            /* Value to return from this function */
+  int addrSortIndex;     /* Address of an OP_OpenEphemeral instruction */
+  AggInfo sAggInfo;      /* Information used by aggregate queries */
+  int iEnd;              /* Address of the end of the query */
+  sqlite3 *db;           /* The database connection */
+
+  db = pParse->db;
+  if( p==0 || db->mallocFailed || pParse->nErr ){
+    return 1;
+  }
+  if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
+  memset(&sAggInfo, 0, sizeof(sAggInfo));
+
+  pOrderBy = p->pOrderBy;
+  if( IgnorableOrderby(pDest) ){
+    p->pOrderBy = 0;
+
+    /* In these cases the DISTINCT operator makes no difference to the
+    ** results, so remove it if it were specified.
+    */
+    assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || 
+           pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
+    p->isDistinct = 0;
+  }
+  if( sqlite3SelectResolve(pParse, p, 0) ){
+    goto select_end;
+  }
+  p->pOrderBy = pOrderBy;
+
+#ifndef SQLITE_OMIT_COMPOUND_SELECT
+  /* If there is are a sequence of queries, do the earlier ones first.
+  */
+  if( p->pPrior ){
+    if( p->pRightmost==0 ){
+      Select *pLoop, *pRight = 0;
+      int cnt = 0;
+      for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
+        pLoop->pRightmost = p;
+        pLoop->pNext = pRight;
+        pRight = pLoop;
+      }
+      if( SQLITE_MAX_COMPOUND_SELECT>0 && cnt>SQLITE_MAX_COMPOUND_SELECT ){
+        sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
+        return 1;
+      }
+    }
+    return multiSelect(pParse, p, pDest, aff);
+  }
+#endif
+
+  /* Make local copies of the parameters for this query.
+  */
+  pTabList = p->pSrc;
+  pWhere = p->pWhere;
+  pGroupBy = p->pGroupBy;
+  pHaving = p->pHaving;
+  isAgg = p->isAgg;
+  isDistinct = p->isDistinct;
+  pEList = p->pEList;
+  if( pEList==0 ) goto select_end;
+
+  /* 
+  ** Do not even attempt to generate any code if we have already seen
+  ** errors before this routine starts.
+  */
+  if( pParse->nErr>0 ) goto select_end;
+
+  /* If writing to memory or generating a set
+  ** only a single column may be output.
+  */
+#ifndef SQLITE_OMIT_SUBQUERY
+  if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
+    goto select_end;
+  }
+#endif
+
+  /* ORDER BY is ignored for some destinations.
+  */
+  if( IgnorableOrderby(pDest) ){
+    pOrderBy = 0;
+  }
+
+  /* Begin generating code.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ) goto select_end;
+
+  /* Generate code for all sub-queries in the FROM clause
+  */
+#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
+  for(i=0; i<pTabList->nSrc; i++){
+    const char *zSavedAuthContext = 0;
+    int needRestoreContext;
+    struct SrcList_item *pItem = &pTabList->a[i];
+    SelectDest dest;
+
+    if( pItem->pSelect==0 || pItem->isPopulated ) continue;
+    if( pItem->zName!=0 ){
+      zSavedAuthContext = pParse->zAuthContext;
+      pParse->zAuthContext = pItem->zName;
+      needRestoreContext = 1;
+    }else{
+      needRestoreContext = 0;
+    }
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+    /* Increment Parse.nHeight by the height of the largest expression
+    ** tree refered to by this, the parent select. The child select
+    ** may contain expression trees of at most
+    ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
+    ** more conservative than necessary, but much easier than enforcing
+    ** an exact limit.
+    */
+    pParse->nHeight += sqlite3SelectExprHeight(p);
+#endif
+    sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
+    sqlite3Select(pParse, pItem->pSelect, &dest, p, i, &isAgg, 0);
+    if( db->mallocFailed ){
+      goto select_end;
+    }
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+    pParse->nHeight -= sqlite3SelectExprHeight(p);
+#endif
+    if( needRestoreContext ){
+      pParse->zAuthContext = zSavedAuthContext;
+    }
+    pTabList = p->pSrc;
+    pWhere = p->pWhere;
+    if( !IgnorableOrderby(pDest) ){
+      pOrderBy = p->pOrderBy;
+    }
+    pGroupBy = p->pGroupBy;
+    pHaving = p->pHaving;
+    isDistinct = p->isDistinct;
+  }
+#endif
+
+  /* Check for the special case of a min() or max() function by itself
+  ** in the result set.
+  */
+#if 0
+  if( simpleMinMaxQuery(pParse, p, pDest) ){
+    rc = 0;
+    goto select_end;
+  }
+#endif
+
+  /* Check to see if this is a subquery that can be "flattened" into its parent.
+  ** If flattening is a possiblity, do so and return immediately.  
+  */
+#ifndef SQLITE_OMIT_VIEW
+  if( pParent && pParentAgg &&
+      flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){
+    if( isAgg ) *pParentAgg = 1;
+    goto select_end;
+  }
+#endif
+
+  /* If possible, rewrite the query to use GROUP BY instead of DISTINCT.
+  ** GROUP BY may use an index, DISTINCT never does.
+  */
+  if( p->isDistinct && !p->isAgg && !p->pGroupBy ){
+    p->pGroupBy = sqlite3ExprListDup(db, p->pEList);
+    pGroupBy = p->pGroupBy;
+    p->isDistinct = 0;
+    isDistinct = 0;
+  }
+
+  /* If there is an ORDER BY clause, then this sorting
+  ** index might end up being unused if the data can be 
+  ** extracted in pre-sorted order.  If that is the case, then the
+  ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
+  ** we figure out that the sorting index is not needed.  The addrSortIndex
+  ** variable is used to facilitate that change.
+  */
+  if( pOrderBy ){
+    KeyInfo *pKeyInfo;
+    pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
+    pOrderBy->iECursor = pParse->nTab++;
+    p->addrOpenEphm[2] = addrSortIndex =
+      sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
+                           pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
+                           (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
+  }else{
+    addrSortIndex = -1;
+  }
+
+  /* If the output is destined for a temporary table, open that table.
+  */
+  if( pDest->eDest==SRT_EphemTab ){
+    sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr);
+  }
+
+  /* Set the limiter.
+  */
+  iEnd = sqlite3VdbeMakeLabel(v);
+  computeLimitRegisters(pParse, p, iEnd);
+
+  /* Open a virtual index to use for the distinct set.
+  */
+  if( isDistinct ){
+    KeyInfo *pKeyInfo;
+    assert( isAgg || pGroupBy );
+    distinct = pParse->nTab++;
+    pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
+    sqlite3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0,
+                        (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
+  }else{
+    distinct = -1;
+  }
+
+  /* Aggregate and non-aggregate queries are handled differently */
+  if( !isAgg && pGroupBy==0 ){
+    /* This case is for non-aggregate queries
+    ** Begin the database scan
+    */
+    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0);
+    if( pWInfo==0 ) goto select_end;
+
+    /* If sorting index that was created by a prior OP_OpenEphemeral 
+    ** instruction ended up not being needed, then change the OP_OpenEphemeral
+    ** into an OP_Noop.
+    */
+    if( addrSortIndex>=0 && pOrderBy==0 ){
+      sqlite3VdbeChangeToNoop(v, addrSortIndex, 1);
+      p->addrOpenEphm[2] = -1;
+    }
+
+    /* Use the standard inner loop
+    */
+    assert(!isDistinct);
+    selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, pDest,
+                    pWInfo->iContinue, pWInfo->iBreak, aff);
+
+    /* End the database scan loop.
+    */
+    sqlite3WhereEnd(pWInfo);
+  }else{
+    /* This is the processing for aggregate queries */
+    NameContext sNC;    /* Name context for processing aggregate information */
+    int iAMem;          /* First Mem address for storing current GROUP BY */
+    int iBMem;          /* First Mem address for previous GROUP BY */
+    int iUseFlag;       /* Mem address holding flag indicating that at least
+                        ** one row of the input to the aggregator has been
+                        ** processed */
+    int iAbortFlag;     /* Mem address which causes query abort if positive */
+    int groupBySort;    /* Rows come from source in GROUP BY order */
+
+
+    /* The following variables hold addresses or labels for parts of the
+    ** virtual machine program we are putting together */
+    int addrOutputRow;      /* Start of subroutine that outputs a result row */
+    int addrSetAbort;       /* Set the abort flag and return */
+    int addrInitializeLoop; /* Start of code that initializes the input loop */
+    int addrTopOfLoop;      /* Top of the input loop */
+    int addrGroupByChange;  /* Code that runs when any GROUP BY term changes */
+    int addrProcessRow;     /* Code to process a single input row */
+    int addrEnd;            /* End of all processing */
+    int addrSortingIdx;     /* The OP_OpenEphemeral for the sorting index */
+    int addrReset;          /* Subroutine for resetting the accumulator */
+
+    addrEnd = sqlite3VdbeMakeLabel(v);
+
+    /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
+    ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
+    ** SELECT statement.
+    */
+    memset(&sNC, 0, sizeof(sNC));
+    sNC.pParse = pParse;
+    sNC.pSrcList = pTabList;
+    sNC.pAggInfo = &sAggInfo;
+    sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
+    sAggInfo.pGroupBy = pGroupBy;
+    sqlite3ExprAnalyzeAggList(&sNC, pEList);
+    sqlite3ExprAnalyzeAggList(&sNC, pOrderBy);
+    if( pHaving ){
+      sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
+    }
+    sAggInfo.nAccumulator = sAggInfo.nColumn;
+    for(i=0; i<sAggInfo.nFunc; i++){
+      sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->pList);
+    }
+    if( db->mallocFailed ) goto select_end;
+
+    /* Processing for aggregates with GROUP BY is very different and
+    ** much more complex than aggregates without a GROUP BY.
+    */
+    if( pGroupBy ){
+      KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
+
+      /* Create labels that we will be needing
+      */
+     
+      addrInitializeLoop = sqlite3VdbeMakeLabel(v);
+      addrGroupByChange = sqlite3VdbeMakeLabel(v);
+      addrProcessRow = sqlite3VdbeMakeLabel(v);
+
+      /* If there is a GROUP BY clause we might need a sorting index to
+      ** implement it.  Allocate that sorting index now.  If it turns out
+      ** that we do not need it after all, the OpenEphemeral instruction
+      ** will be converted into a Noop.  
+      */
+      sAggInfo.sortingIdx = pParse->nTab++;
+      pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
+      addrSortingIdx =
+          sqlite3VdbeAddOp4(v, OP_OpenEphemeral, sAggInfo.sortingIdx,
+                         sAggInfo.nSortingColumn, 0,
+                         (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
+
+      /* Initialize memory locations used by GROUP BY aggregate processing
+      */
+      iUseFlag = ++pParse->nMem;
+      iAbortFlag = ++pParse->nMem;
+      iAMem = pParse->nMem + 1;
+      pParse->nMem += pGroupBy->nExpr;
+      iBMem = pParse->nMem + 1;
+      pParse->nMem += pGroupBy->nExpr;
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
+      VdbeComment((v, "clear abort flag"));
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
+      VdbeComment((v, "indicate accumulator empty"));
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, addrInitializeLoop);
+
+      /* Generate a subroutine that outputs a single row of the result
+      ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
+      ** is less than or equal to zero, the subroutine is a no-op.  If
+      ** the processing calls for the query to abort, this subroutine
+      ** increments the iAbortFlag memory location before returning in
+      ** order to signal the caller to abort.
+      */
+      addrSetAbort = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
+      VdbeComment((v, "set abort flag"));
+      sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+      addrOutputRow = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
+      VdbeComment((v, "Groupby result generator entry point"));
+      sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+      finalizeAggFunctions(pParse, &sAggInfo);
+      if( pHaving ){
+        sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
+      }
+      selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
+                      distinct, pDest,
+                      addrOutputRow+1, addrSetAbort, aff);
+      sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+      VdbeComment((v, "end groupby result generator"));
+
+      /* Generate a subroutine that will reset the group-by accumulator
+      */
+      addrReset = sqlite3VdbeCurrentAddr(v);
+      resetAccumulator(pParse, &sAggInfo);
+      sqlite3VdbeAddOp2(v, OP_Return, 0, 0);
+
+      /* Begin a loop that will extract all source rows in GROUP BY order.
+      ** This might involve two separate loops with an OP_Sort in between, or
+      ** it might be a single loop that uses an index to extract information
+      ** in the right order to begin with.
+      */
+      sqlite3VdbeResolveLabel(v, addrInitializeLoop);
+      sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrReset);
+      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0);
+      if( pWInfo==0 ) goto select_end;
+      if( pGroupBy==0 ){
+        /* The optimizer is able to deliver rows in group by order so
+        ** we do not have to sort.  The OP_OpenEphemeral table will be
+        ** cancelled later because we still need to use the pKeyInfo
+        */
+        pGroupBy = p->pGroupBy;
+        groupBySort = 0;
+      }else{
+        /* Rows are coming out in undetermined order.  We have to push
+        ** each row into a sorting index, terminate the first loop,
+        ** then loop over the sorting index in order to get the output
+        ** in sorted order
+        */
+        int regBase;
+        int regRecord;
+        int nCol;
+        int nGroupBy;
+
+        groupBySort = 1;
+        nGroupBy = pGroupBy->nExpr;
+        nCol = nGroupBy + 1;
+        j = nGroupBy+1;
+        for(i=0; i<sAggInfo.nColumn; i++){
+          if( sAggInfo.aCol[i].iSorterColumn>=j ){
+            nCol++;
+            j++;
+          }
+        }
+        regBase = sqlite3GetTempRange(pParse, nCol);
+        sqlite3ExprCodeExprList(pParse, pGroupBy, regBase);
+        sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
+        j = nGroupBy+1;
+        for(i=0; i<sAggInfo.nColumn; i++){
+          struct AggInfo_col *pCol = &sAggInfo.aCol[i];
+          if( pCol->iSorterColumn>=j ){
+            sqlite3ExprCodeGetColumn(v, pCol->pTab, pCol->iColumn, pCol->iTable,
+                                     j + regBase);
+            j++;
+          }
+        }
+        regRecord = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
+        sqlite3VdbeAddOp2(v, OP_IdxInsert, sAggInfo.sortingIdx, regRecord);
+        sqlite3ReleaseTempReg(pParse, regRecord);
+        sqlite3ReleaseTempRange(pParse, regBase, nCol);
+        sqlite3WhereEnd(pWInfo);
+        sqlite3VdbeAddOp2(v, OP_Sort, sAggInfo.sortingIdx, addrEnd);
+        VdbeComment((v, "GROUP BY sort"));
+        sAggInfo.useSortingIdx = 1;
+      }
+
+      /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
+      ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
+      ** Then compare the current GROUP BY terms against the GROUP BY terms
+      ** from the previous row currently stored in a0, a1, a2...
+      */
+      addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
+      for(j=0; j<pGroupBy->nExpr; j++){
+        if( groupBySort ){
+          sqlite3VdbeAddOp3(v, OP_Column, sAggInfo.sortingIdx, j, iBMem+j);
+        }else{
+          sAggInfo.directMode = 1;
+          sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
+        }
+      }
+      for(j=pGroupBy->nExpr-1; j>=0; j--){
+        if( j==0 ){
+          sqlite3VdbeAddOp3(v, OP_Eq, iAMem+j, addrProcessRow, iBMem+j);
+        }else{
+          sqlite3VdbeAddOp3(v, OP_Ne, iAMem+j, addrGroupByChange, iBMem+j);
+        }
+        sqlite3VdbeChangeP4(v, -1, (void*)pKeyInfo->aColl[j], P4_COLLSEQ);
+        sqlite3VdbeChangeP5(v, SQLITE_NULLEQUAL);
+      }
+
+      /* Generate code that runs whenever the GROUP BY changes.
+      ** Change in the GROUP BY are detected by the previous code
+      ** block.  If there were no changes, this block is skipped.
+      **
+      ** This code copies current group by terms in b0,b1,b2,...
+      ** over to a0,a1,a2.  It then calls the output subroutine
+      ** and resets the aggregate accumulator registers in preparation
+      ** for the next GROUP BY batch.
+      */
+      sqlite3VdbeResolveLabel(v, addrGroupByChange);
+      for(j=0; j<pGroupBy->nExpr; j++){
+        sqlite3VdbeAddOp2(v, OP_Move, iBMem+j, iAMem+j);
+      }
+      sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrOutputRow);
+      VdbeComment((v, "output one row"));
+      sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
+      VdbeComment((v, "check abort flag"));
+      sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrReset);
+      VdbeComment((v, "reset accumulator"));
+
+      /* Update the aggregate accumulators based on the content of
+      ** the current row
+      */
+      sqlite3VdbeResolveLabel(v, addrProcessRow);
+      updateAccumulator(pParse, &sAggInfo);
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
+      VdbeComment((v, "indicate data in accumulator"));
+
+      /* End of the loop
+      */
+      if( groupBySort ){
+        sqlite3VdbeAddOp2(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop);
+      }else{
+        sqlite3WhereEnd(pWInfo);
+        sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1);
+      }
+
+      /* Output the final row of result
+      */
+      sqlite3VdbeAddOp2(v, OP_Gosub, 0, addrOutputRow);
+      VdbeComment((v, "output final row"));
+      
+    } /* endif pGroupBy */
+    else {
+      ExprList *pMinMax = 0;
+      ExprList *pDel = 0;
+      u8 flag;
+
+      /* Check if the query is of one of the following forms:
+      **
+      **   SELECT min(x) FROM ...
+      **   SELECT max(x) FROM ...
+      **
+      ** If it is, then ask the code in where.c to attempt to sort results
+      ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause. 
+      ** If where.c is able to produce results sorted in this order, then
+      ** add vdbe code to break out of the processing loop after the 
+      ** first iteration (since the first iteration of the loop is 
+      ** guaranteed to operate on the row with the minimum or maximum 
+      ** value of x, the only row required).
+      **
+      ** A special flag must be passed to sqlite3WhereBegin() to slightly
+      ** modify behaviour as follows:
+      **
+      **   + If the query is a "SELECT min(x)", then the loop coded by
+      **     where.c should not iterate over any values with a NULL value
+      **     for x.
+      **
+      **   + The optimizer code in where.c (the thing that decides which
+      **     index or indices to use) should place a different priority on 
+      **     satisfying the 'ORDER BY' clause than it does in other cases.
+      **     Refer to code and comments in where.c for details.
+      */
+      flag = minMaxQuery(pParse, p);
+      if( flag ){
+        pDel = pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->pList);
+        if( pMinMax && !db->mallocFailed ){
+          pMinMax->a[0].sortOrder = ((flag==ORDERBY_MIN)?0:1);
+          pMinMax->a[0].pExpr->op = TK_COLUMN;
+        }
+      }
+
+      /* This case runs if the aggregate has no GROUP BY clause.  The
+      ** processing is much simpler since there is only a single row
+      ** of output.
+      */
+      resetAccumulator(pParse, &sAggInfo);
+      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, flag);
+      if( pWInfo==0 ){
+        sqlite3ExprListDelete(pDel);
+        goto select_end;
+      }
+      updateAccumulator(pParse, &sAggInfo);
+      if( !pMinMax && flag ){
+        sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak);
+        VdbeComment((v, "%s() by index", (flag==ORDERBY_MIN?"min":"max")));
+      }
+      sqlite3WhereEnd(pWInfo);
+      finalizeAggFunctions(pParse, &sAggInfo);
+      pOrderBy = 0;
+      if( pHaving ){
+        sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
+      }
+      selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, 
+                      pDest, addrEnd, addrEnd, aff);
+
+      sqlite3ExprListDelete(pDel);
+    }
+    sqlite3VdbeResolveLabel(v, addrEnd);
+    
+  } /* endif aggregate query */
+
+  /* If there is an ORDER BY clause, then we need to sort the results
+  ** and send them to the callback one by one.
+  */
+  if( pOrderBy ){
+    generateSortTail(pParse, p, v, pEList->nExpr, pDest);
+  }
+
+#ifndef SQLITE_OMIT_SUBQUERY
+  /* If this was a subquery, we have now converted the subquery into a
+  ** temporary table.  So set the SrcList_item.isPopulated flag to prevent
+  ** this subquery from being evaluated again and to force the use of
+  ** the temporary table.
+  */
+  if( pParent ){
+    assert( pParent->pSrc->nSrc>parentTab );
+    assert( pParent->pSrc->a[parentTab].pSelect==p );
+    pParent->pSrc->a[parentTab].isPopulated = 1;
+  }
+#endif
+
+  /* Jump here to skip this query
+  */
+  sqlite3VdbeResolveLabel(v, iEnd);
+
+  /* The SELECT was successfully coded.   Set the return code to 0
+  ** to indicate no errors.
+  */
+  rc = 0;
+
+  /* Control jumps to here if an error is encountered above, or upon
+  ** successful coding of the SELECT.
+  */
+select_end:
+
+  /* Identify column names if we will be using them in a callback.  This
+  ** step is skipped if the output is going to some other destination.
+  */
+  if( rc==SQLITE_OK && pDest->eDest==SRT_Callback ){
+    generateColumnNames(pParse, pTabList, pEList);
+  }
+
+  sqlite3_free(sAggInfo.aCol);
+  sqlite3_free(sAggInfo.aFunc);
+  return rc;
+}
+
+#if defined(SQLITE_DEBUG)
+/*
+*******************************************************************************
+** The following code is used for testing and debugging only.  The code
+** that follows does not appear in normal builds.
+**
+** These routines are used to print out the content of all or part of a 
+** parse structures such as Select or Expr.  Such printouts are useful
+** for helping to understand what is happening inside the code generator
+** during the execution of complex SELECT statements.
+**
+** These routine are not called anywhere from within the normal
+** code base.  Then are intended to be called from within the debugger
+** or from temporary "printf" statements inserted for debugging.
+*/
+void sqlite3PrintExpr(Expr *p){
+  if( p->token.z && p->token.n>0 ){
+    sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z);
+  }else{
+    sqlite3DebugPrintf("(%d", p->op);
+  }
+  if( p->pLeft ){
+    sqlite3DebugPrintf(" ");
+    sqlite3PrintExpr(p->pLeft);
+  }
+  if( p->pRight ){
+    sqlite3DebugPrintf(" ");
+    sqlite3PrintExpr(p->pRight);
+  }
+  sqlite3DebugPrintf(")");
+}
+void sqlite3PrintExprList(ExprList *pList){
+  int i;
+  for(i=0; i<pList->nExpr; i++){
+    sqlite3PrintExpr(pList->a[i].pExpr);
+    if( i<pList->nExpr-1 ){
+      sqlite3DebugPrintf(", ");
+    }
+  }
+}
+void sqlite3PrintSelect(Select *p, int indent){
+  sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
+  sqlite3PrintExprList(p->pEList);
+  sqlite3DebugPrintf("\n");
+  if( p->pSrc ){
+    char *zPrefix;
+    int i;
+    zPrefix = "FROM";
+    for(i=0; i<p->pSrc->nSrc; i++){
+      struct SrcList_item *pItem = &p->pSrc->a[i];
+      sqlite3DebugPrintf("%*s ", indent+6, zPrefix);
+      zPrefix = "";
+      if( pItem->pSelect ){
+        sqlite3DebugPrintf("(\n");
+        sqlite3PrintSelect(pItem->pSelect, indent+10);
+        sqlite3DebugPrintf("%*s)", indent+8, "");
+      }else if( pItem->zName ){
+        sqlite3DebugPrintf("%s", pItem->zName);
+      }
+      if( pItem->pTab ){
+        sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName);
+      }
+      if( pItem->zAlias ){
+        sqlite3DebugPrintf(" AS %s", pItem->zAlias);
+      }
+      if( i<p->pSrc->nSrc-1 ){
+        sqlite3DebugPrintf(",");
+      }
+      sqlite3DebugPrintf("\n");
+    }
+  }
+  if( p->pWhere ){
+    sqlite3DebugPrintf("%*s WHERE ", indent, "");
+    sqlite3PrintExpr(p->pWhere);
+    sqlite3DebugPrintf("\n");
+  }
+  if( p->pGroupBy ){
+    sqlite3DebugPrintf("%*s GROUP BY ", indent, "");
+    sqlite3PrintExprList(p->pGroupBy);
+    sqlite3DebugPrintf("\n");
+  }
+  if( p->pHaving ){
+    sqlite3DebugPrintf("%*s HAVING ", indent, "");
+    sqlite3PrintExpr(p->pHaving);
+    sqlite3DebugPrintf("\n");
+  }
+  if( p->pOrderBy ){
+    sqlite3DebugPrintf("%*s ORDER BY ", indent, "");
+    sqlite3PrintExprList(p->pOrderBy);
+    sqlite3DebugPrintf("\n");
+  }
+}
+/* End of the structure debug printing code
+*****************************************************************************/
+#endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/server.c b/client/src/thirdparty/sqlite-3.4.2/src/server.c
new file mode 100644
index 0000000..d32c590
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/server.c
@@ -0,0 +1,485 @@
+/*
+** 2006 January 07
+**
+** 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 demonstration code.  Nothing in this file gets compiled
+** or linked into the SQLite library unless you use a non-standard option:
+**
+**      -DSQLITE_SERVER=1
+**
+** The configure script will never generate a Makefile with the option
+** above.  You will need to manually modify the Makefile if you want to
+** include any of the code from this file in your project.  Or, at your
+** option, you may copy and paste the code from this file and
+** thereby avoiding a recompile of SQLite.
+**
+**
+** This source file demonstrates how to use SQLite to create an SQL database 
+** server thread in a multiple-threaded program.  One or more client threads
+** send messages to the server thread and the server thread processes those
+** messages in the order received and returns the results to the client.
+**
+** One might ask:  "Why bother?  Why not just let each thread connect
+** to the database directly?"  There are a several of reasons to
+** prefer the client/server approach.
+**
+**    (1)  Some systems (ex: Redhat9) have broken threading implementations
+**         that prevent SQLite database connections from being used in
+**         a thread different from the one where they were created.  With
+**         the client/server approach, all database connections are created
+**         and used within the server thread.  Client calls to the database
+**         can be made from multiple threads (though not at the same time!)
+**
+**    (2)  Beginning with SQLite version 3.3.0, when two or more 
+**         connections to the same database occur within the same thread,
+**         they can optionally share their database cache.  This reduces
+**         I/O and memory requirements.  Cache shared is controlled using
+**         the sqlite3_enable_shared_cache() API.
+**
+**    (3)  Database connections on a shared cache use table-level locking
+**         instead of file-level locking for improved concurrency.
+**
+**    (4)  Database connections on a shared cache can by optionally
+**         set to READ UNCOMMITTED isolation.  (The default isolation for
+**         SQLite is SERIALIZABLE.)  When this occurs, readers will
+**         never be blocked by a writer and writers will not be
+**         blocked by readers.  There can still only be a single writer
+**         at a time, but multiple readers can simultaneously exist with
+**         that writer.  This is a huge increase in concurrency.
+**
+** To summarize the rational for using a client/server approach: prior
+** to SQLite version 3.3.0 it probably was not worth the trouble.  But
+** with SQLite version 3.3.0 and beyond you can get significant performance
+** and concurrency improvements and memory usage reductions by going
+** client/server.
+**
+** Note:  The extra features of version 3.3.0 described by points (2)
+** through (4) above are only available if you compile without the
+** option -DSQLITE_OMIT_SHARED_CACHE. 
+**
+** Here is how the client/server approach works:  The database server
+** thread is started on this procedure:
+**
+**       void *sqlite3_server(void *NotUsed);
+**
+** The sqlite_server procedure runs as long as the g.serverHalt variable
+** is false.  A mutex is used to make sure no more than one server runs
+** at a time.  The server waits for messages to arrive on a message
+** queue and processes the messages in order.
+**
+** Two convenience routines are provided for starting and stopping the
+** server thread:
+**
+**       void sqlite3_server_start(void);
+**       void sqlite3_server_stop(void);
+**
+** Both of the convenience routines return immediately.  Neither will
+** ever give an error.  If a server is already started or already halted,
+** then the routines are effectively no-ops.
+**
+** Clients use the following interfaces:
+**
+**       sqlite3_client_open
+**       sqlite3_client_prepare
+**       sqlite3_client_step
+**       sqlite3_client_reset
+**       sqlite3_client_finalize
+**       sqlite3_client_close
+**
+** These interfaces work exactly like the standard core SQLite interfaces
+** having the same names without the "_client_" infix.  Many other SQLite
+** interfaces can be used directly without having to send messages to the
+** server as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.
+** The following interfaces fall into this second category:
+**
+**       sqlite3_bind_*
+**       sqlite3_changes
+**       sqlite3_clear_bindings
+**       sqlite3_column_*
+**       sqlite3_complete
+**       sqlite3_create_collation
+**       sqlite3_create_function
+**       sqlite3_data_count
+**       sqlite3_db_handle
+**       sqlite3_errcode
+**       sqlite3_errmsg
+**       sqlite3_last_insert_rowid
+**       sqlite3_total_changes
+**       sqlite3_transfer_bindings
+**
+** A single SQLite connection (an sqlite3* object) or an SQLite statement
+** (an sqlite3_stmt* object) should only be passed to a single interface
+** function at a time.  The connections and statements can be passed from
+** any thread to any of the functions listed in the second group above as
+** long as the same connection is not in use by two threads at once and
+** as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.  Additional
+** information about the SQLITE_ENABLE_MEMORY_MANAGEMENT constraint is
+** below.
+**
+** The busy handler for all database connections should remain turned
+** off.  That means that any lock contention will cause the associated
+** sqlite3_client_step() call to return immediately with an SQLITE_BUSY
+** error code.  If a busy handler is enabled and lock contention occurs,
+** then the entire server thread will block.  This will cause not only
+** the requesting client to block but every other database client as
+** well.  It is possible to enhance the code below so that lock
+** contention will cause the message to be placed back on the top of
+** the queue to be tried again later.  But such enhanced processing is
+** not included here, in order to keep the example simple.
+**
+** This example code assumes the use of pthreads.  Pthreads
+** implementations are available for windows.  (See, for example
+** http://sourceware.org/pthreads-win32/announcement.html.)  Or, you
+** can translate the locking and thread synchronization code to use
+** windows primitives easily enough.  The details are left as an
+** exercise to the reader.
+**
+**** Restrictions Associated With SQLITE_ENABLE_MEMORY_MANAGEMENT ****
+**
+** If you compile with SQLITE_ENABLE_MEMORY_MANAGEMENT defined, then
+** SQLite includes code that tracks how much memory is being used by
+** each thread.  These memory counts can become confused if memory
+** is allocated by one thread and then freed by another.  For that
+** reason, when SQLITE_ENABLE_MEMORY_MANAGEMENT is used, all operations
+** that might allocate or free memory should be performanced in the same
+** thread that originally created the database connection.  In that case,
+** many of the operations that are listed above as safe to be performed
+** in separate threads would need to be sent over to the server to be
+** done there.  If SQLITE_ENABLE_MEMORY_MANAGEMENT is defined, then
+** the following functions can be used safely from different threads
+** without messing up the allocation counts:
+**
+**       sqlite3_bind_parameter_name
+**       sqlite3_bind_parameter_index
+**       sqlite3_changes
+**       sqlite3_column_blob
+**       sqlite3_column_count
+**       sqlite3_complete
+**       sqlite3_data_count
+**       sqlite3_db_handle
+**       sqlite3_errcode
+**       sqlite3_errmsg
+**       sqlite3_last_insert_rowid
+**       sqlite3_total_changes
+**
+** The remaining functions are not thread-safe when memory management
+** is enabled.  So one would have to define some new interface routines
+** along the following lines:
+**
+**       sqlite3_client_bind_*
+**       sqlite3_client_clear_bindings
+**       sqlite3_client_column_*
+**       sqlite3_client_create_collation
+**       sqlite3_client_create_function
+**       sqlite3_client_transfer_bindings
+**
+** The example code in this file is intended for use with memory
+** management turned off.  So the implementation of these additional
+** client interfaces is left as an exercise to the reader.
+**
+** It may seem surprising to the reader that the list of safe functions
+** above does not include things like sqlite3_bind_int() or
+** sqlite3_column_int().  But those routines might, in fact, allocate
+** or deallocate memory.  In the case of sqlite3_bind_int(), if the
+** parameter was previously bound to a string that string might need
+** to be deallocated before the new integer value is inserted.  In
+** the case of sqlite3_column_int(), the value of the column might be
+** a UTF-16 string which will need to be converted to UTF-8 then into
+** an integer.
+*/
+
+/*
+** Only compile the code in this file on UNIX with a THREADSAFE build
+** and only if the SQLITE_SERVER macro is defined.
+*/
+#ifdef SQLITE_SERVER
+#if defined(OS_UNIX) && OS_UNIX && defined(THREADSAFE) && THREADSAFE
+
+/*
+** We require only pthreads and the public interface of SQLite.
+*/
+#include <pthread.h>
+#include "sqlite3.h"
+
+/*
+** Messages are passed from client to server and back again as 
+** instances of the following structure.
+*/
+typedef struct SqlMessage SqlMessage;
+struct SqlMessage {
+  int op;                      /* Opcode for the message */
+  sqlite3 *pDb;                /* The SQLite connection */
+  sqlite3_stmt *pStmt;         /* A specific statement */
+  int errCode;                 /* Error code returned */
+  const char *zIn;             /* Input filename or SQL statement */
+  int nByte;                   /* Size of the zIn parameter for prepare() */
+  const char *zOut;            /* Tail of the SQL statement */
+  SqlMessage *pNext;           /* Next message in the queue */
+  SqlMessage *pPrev;           /* Previous message in the queue */
+  pthread_mutex_t clientMutex; /* Hold this mutex to access the message */
+  pthread_cond_t clientWakeup; /* Signal to wake up the client */
+};
+
+/*
+** Legal values for SqlMessage.op
+*/
+#define MSG_Open       1  /* sqlite3_open(zIn, &pDb) */
+#define MSG_Prepare    2  /* sqlite3_prepare(pDb, zIn, nByte, &pStmt, &zOut) */
+#define MSG_Step       3  /* sqlite3_step(pStmt) */
+#define MSG_Reset      4  /* sqlite3_reset(pStmt) */
+#define MSG_Finalize   5  /* sqlite3_finalize(pStmt) */
+#define MSG_Close      6  /* sqlite3_close(pDb) */
+#define MSG_Done       7  /* Server has finished with this message */
+
+
+/*
+** State information about the server is stored in a static variable
+** named "g" as follows:
+*/
+static struct ServerState {
+  pthread_mutex_t queueMutex;   /* Hold this mutex to access the msg queue */
+  pthread_mutex_t serverMutex;  /* Held by the server while it is running */
+  pthread_cond_t serverWakeup;  /* Signal this condvar to wake up the server */
+  volatile int serverHalt;      /* Server halts itself when true */
+  SqlMessage *pQueueHead;       /* Head of the message queue */
+  SqlMessage *pQueueTail;       /* Tail of the message queue */
+} g = {
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_COND_INITIALIZER,
+};
+
+/*
+** Send a message to the server.  Block until we get a reply.
+**
+** The mutex and condition variable in the message are uninitialized
+** when this routine is called.  This routine takes care of 
+** initializing them and destroying them when it has finished.
+*/
+static void sendToServer(SqlMessage *pMsg){
+  /* Initialize the mutex and condition variable on the message
+  */
+  pthread_mutex_init(&pMsg->clientMutex, 0);
+  pthread_cond_init(&pMsg->clientWakeup, 0);
+
+  /* Add the message to the head of the server's message queue.
+  */
+  pthread_mutex_lock(&g.queueMutex);
+  pMsg->pNext = g.pQueueHead;
+  if( g.pQueueHead==0 ){
+    g.pQueueTail = pMsg;
+  }else{
+    g.pQueueHead->pPrev = pMsg;
+  }
+  pMsg->pPrev = 0;
+  g.pQueueHead = pMsg;
+  pthread_mutex_unlock(&g.queueMutex);
+
+  /* Signal the server that the new message has be queued, then
+  ** block waiting for the server to process the message.
+  */
+  pthread_mutex_lock(&pMsg->clientMutex);
+  pthread_cond_signal(&g.serverWakeup);
+  while( pMsg->op!=MSG_Done ){
+    pthread_cond_wait(&pMsg->clientWakeup, &pMsg->clientMutex);
+  }
+  pthread_mutex_unlock(&pMsg->clientMutex);
+
+  /* Destroy the mutex and condition variable of the message.
+  */
+  pthread_mutex_destroy(&pMsg->clientMutex);
+  pthread_cond_destroy(&pMsg->clientWakeup);
+}
+
+/*
+** The following 6 routines are client-side implementations of the
+** core SQLite interfaces:
+**
+**        sqlite3_open
+**        sqlite3_prepare
+**        sqlite3_step
+**        sqlite3_reset
+**        sqlite3_finalize
+**        sqlite3_close
+**
+** Clients should use the following client-side routines instead of 
+** the core routines above.
+**
+**        sqlite3_client_open
+**        sqlite3_client_prepare
+**        sqlite3_client_step
+**        sqlite3_client_reset
+**        sqlite3_client_finalize
+**        sqlite3_client_close
+**
+** Each of these routines creates a message for the desired operation,
+** sends that message to the server, waits for the server to process
+** then message and return a response.
+*/
+int sqlite3_client_open(const char *zDatabaseName, sqlite3 **ppDb){
+  SqlMessage msg;
+  msg.op = MSG_Open;
+  msg.zIn = zDatabaseName;
+  sendToServer(&msg);
+  *ppDb = msg.pDb;
+  return msg.errCode;
+}
+int sqlite3_client_prepare(
+  sqlite3 *pDb,
+  const char *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const char **pzTail
+){
+  SqlMessage msg;
+  msg.op = MSG_Prepare;
+  msg.pDb = pDb;
+  msg.zIn = zSql;
+  msg.nByte = nByte;
+  sendToServer(&msg);
+  *ppStmt = msg.pStmt;
+  if( pzTail ) *pzTail = msg.zOut;
+  return msg.errCode;
+}
+int sqlite3_client_step(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Step;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_reset(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Reset;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_finalize(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Finalize;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_close(sqlite3 *pDb){
+  SqlMessage msg;
+  msg.op = MSG_Close;
+  msg.pDb = pDb;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+
+/*
+** This routine implements the server.  To start the server, first
+** make sure g.serverHalt is false, then create a new detached thread
+** on this procedure.  See the sqlite3_server_start() routine below
+** for an example.  This procedure loops until g.serverHalt becomes
+** true.
+*/
+void *sqlite3_server(void *NotUsed){
+  sqlite3_enable_shared_cache(1);
+  if( pthread_mutex_trylock(&g.serverMutex) ){
+    sqlite3_enable_shared_cache(0);
+    return 0;  /* Another server is already running */
+  }
+  while( !g.serverHalt ){
+    SqlMessage *pMsg;
+
+    /* Remove the last message from the message queue.
+    */
+    pthread_mutex_lock(&g.queueMutex);
+    while( g.pQueueTail==0 && g.serverHalt==0 ){
+      pthread_cond_wait(&g.serverWakeup, &g.queueMutex);
+    }
+    pMsg = g.pQueueTail;
+    if( pMsg ){
+      if( pMsg->pPrev ){
+        pMsg->pPrev->pNext = 0;
+      }else{
+        g.pQueueHead = 0;
+      }
+      g.pQueueTail = pMsg->pPrev;
+    }
+    pthread_mutex_unlock(&g.queueMutex);
+    if( pMsg==0 ) break;
+
+    /* Process the message just removed
+    */
+    pthread_mutex_lock(&pMsg->clientMutex);
+    switch( pMsg->op ){
+      case MSG_Open: {
+        pMsg->errCode = sqlite3_open(pMsg->zIn, &pMsg->pDb);
+        break;
+      }
+      case MSG_Prepare: {
+        pMsg->errCode = sqlite3_prepare(pMsg->pDb, pMsg->zIn, pMsg->nByte,
+                                        &pMsg->pStmt, &pMsg->zOut);
+        break;
+      }
+      case MSG_Step: {
+        pMsg->errCode = sqlite3_step(pMsg->pStmt);
+        break;
+      }
+      case MSG_Reset: {
+        pMsg->errCode = sqlite3_reset(pMsg->pStmt);
+        break;
+      }
+      case MSG_Finalize: {
+        pMsg->errCode = sqlite3_finalize(pMsg->pStmt);
+        break;
+      }
+      case MSG_Close: {
+        pMsg->errCode = sqlite3_close(pMsg->pDb);
+        break;
+      }
+    }
+
+    /* Signal the client that the message has been processed.
+    */
+    pMsg->op = MSG_Done;
+    pthread_mutex_unlock(&pMsg->clientMutex);
+    pthread_cond_signal(&pMsg->clientWakeup);
+  }
+  pthread_mutex_unlock(&g.serverMutex);
+  sqlite3_thread_cleanup();
+  return 0;
+}
+
+/*
+** Start a server thread if one is not already running.  If there
+** is aleady a server thread running, the new thread will quickly
+** die and this routine is effectively a no-op.
+*/
+void sqlite3_server_start(void){
+  pthread_t x;
+  int rc;
+  g.serverHalt = 0;
+  rc = pthread_create(&x, 0, sqlite3_server, 0);
+  if( rc==0 ){
+    pthread_detach(x);
+  }
+}
+
+/*
+** If a server thread is running, then stop it.  If no server is
+** running, this routine is effectively a no-op.
+**
+** This routine returns immediately without waiting for the server
+** thread to stop.  But be assured that the server will eventually stop.
+*/
+void sqlite3_server_stop(void){
+  g.serverHalt = 1;
+  pthread_cond_broadcast(&g.serverWakeup);
+}
+
+#endif /* defined(OS_UNIX) && OS_UNIX && defined(THREADSAFE) && THREADSAFE */
+#endif /* defined(SQLITE_SERVER) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/shell.c b/client/src/thirdparty/sqlite-3.4.2/src/shell.c
new file mode 100644
index 0000000..6fe9324
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/shell.c
@@ -0,0 +1,2087 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains code to implement the "sqlite" command line
+** utility for accessing SQLite databases.
+**
+** $Id: shell.c,v 1.174 2008/01/21 16:22:46 drh Exp $
+*/
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include "sqlite3.h"
+#include <ctype.h>
+#include <stdarg.h>
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
+# include <signal.h>
+# include <pwd.h>
+# include <unistd.h>
+# include <sys/types.h>
+#endif
+
+#ifdef __OS2__
+# include <unistd.h>
+#endif
+
+#if defined(HAVE_READLINE) && HAVE_READLINE==1
+# include <readline/readline.h>
+# include <readline/history.h>
+#else
+# define readline(p) local_getline(p,stdin)
+# define add_history(X)
+# define read_history(X)
+# define write_history(X)
+# define stifle_history(X)
+#endif
+
+#if defined(_WIN32) || defined(WIN32)
+# include <io.h>
+#else
+/* Make sure isatty() has a prototype.
+*/
+extern int isatty();
+#endif
+
+#if defined(_WIN32_WCE)
+/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
+ * thus we always assume that we have a console. That can be
+ * overridden with the -batch command line option.
+ */
+#define isatty(x) 1
+#endif
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__)
+#include <sys/time.h>
+#include <sys/resource.h>
+
+/* Saved resource information for the beginning of an operation */
+static struct rusage sBegin;
+
+/* True if the timer is enabled */
+static int enableTimer = 0;
+
+/*
+** Begin timing an operation
+*/
+static void beginTimer(void){
+  if( enableTimer ){
+    getrusage(RUSAGE_SELF, &sBegin);
+  }
+}
+
+/* Return the difference of two time_structs in microseconds */
+static int timeDiff(struct timeval *pStart, struct timeval *pEnd){
+  return (pEnd->tv_usec - pStart->tv_usec) + 
+         1000000*(pEnd->tv_sec - pStart->tv_sec);
+}
+
+/*
+** Print the timing results.
+*/
+static void endTimer(void){
+  if( enableTimer ){
+    struct rusage sEnd;
+    getrusage(RUSAGE_SELF, &sEnd);
+    printf("CPU Time: user %f sys %f\n",
+       0.000001*timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
+       0.000001*timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
+  }
+}
+#define BEGIN_TIMER beginTimer()
+#define END_TIMER endTimer()
+#define HAS_TIMER 1
+#else
+#define BEGIN_TIMER 
+#define END_TIMER
+#define HAS_TIMER 0
+#endif
+
+
+/*
+** If the following flag is set, then command execution stops
+** at an error if we are not interactive.
+*/
+static int bail_on_error = 0;
+
+/*
+** Threat stdin as an interactive input if the following variable
+** is true.  Otherwise, assume stdin is connected to a file or pipe.
+*/
+static int stdin_is_interactive = 1;
+
+/*
+** The following is the open SQLite database.  We make a pointer
+** to this database a static variable so that it can be accessed
+** by the SIGINT handler to interrupt database processing.
+*/
+static sqlite3 *db = 0;
+
+/*
+** True if an interrupt (Control-C) has been received.
+*/
+static volatile int seenInterrupt = 0;
+
+/*
+** This is the name of our program. It is set in main(), used
+** in a number of other places, mostly for error messages.
+*/
+static char *Argv0;
+
+/*
+** Prompt strings. Initialized in main. Settable with
+**   .prompt main continue
+*/
+static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
+static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
+
+/*
+** Write I/O traces to the following stream.
+*/
+#ifdef SQLITE_ENABLE_IOTRACE
+static FILE *iotrace = 0;
+#endif
+
+/*
+** This routine works like printf in that its first argument is a
+** format string and subsequent arguments are values to be substituted
+** in place of % fields.  The result of formatting this string
+** is written to iotrace.
+*/
+#ifdef SQLITE_ENABLE_IOTRACE
+static void iotracePrintf(const char *zFormat, ...){
+  va_list ap;
+  char *z;
+  if( iotrace==0 ) return;
+  va_start(ap, zFormat);
+  z = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  fprintf(iotrace, "%s", z);
+  sqlite3_free(z);
+}
+#endif
+
+
+/*
+** Determines if a string is a number of not.
+*/
+static int isNumber(const char *z, int *realnum){
+  if( *z=='-' || *z=='+' ) z++;
+  if( !isdigit(*z) ){
+    return 0;
+  }
+  z++;
+  if( realnum ) *realnum = 0;
+  while( isdigit(*z) ){ z++; }
+  if( *z=='.' ){
+    z++;
+    if( !isdigit(*z) ) return 0;
+    while( isdigit(*z) ){ z++; }
+    if( realnum ) *realnum = 1;
+  }
+  if( *z=='e' || *z=='E' ){
+    z++;
+    if( *z=='+' || *z=='-' ) z++;
+    if( !isdigit(*z) ) return 0;
+    while( isdigit(*z) ){ z++; }
+    if( realnum ) *realnum = 1;
+  }
+  return *z==0;
+}
+
+/*
+** A global char* and an SQL function to access its current value 
+** from within an SQL statement. This program used to use the 
+** sqlite_exec_printf() API to substitue a string into an SQL statement.
+** The correct way to do this with sqlite3 is to use the bind API, but
+** since the shell is built around the callback paradigm it would be a lot
+** of work. Instead just use this hack, which is quite harmless.
+*/
+static const char *zShellStatic = 0;
+static void shellstaticFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  assert( 0==argc );
+  assert( zShellStatic );
+  sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
+}
+
+
+/*
+** This routine reads a line of text from FILE in, stores
+** the text in memory obtained from malloc() and returns a pointer
+** to the text.  NULL is returned at end of file, or if malloc()
+** fails.
+**
+** The interface is like "readline" but no command-line editing
+** is done.
+*/
+static char *local_getline(char *zPrompt, FILE *in){
+  char *zLine;
+  int nLine;
+  int n;
+  int eol;
+
+  if( zPrompt && *zPrompt ){
+    printf("%s",zPrompt);
+    fflush(stdout);
+  }
+  nLine = 100;
+  zLine = malloc( nLine );
+  if( zLine==0 ) return 0;
+  n = 0;
+  eol = 0;
+  while( !eol ){
+    if( n+100>nLine ){
+      nLine = nLine*2 + 100;
+      zLine = realloc(zLine, nLine);
+      if( zLine==0 ) return 0;
+    }
+    if( fgets(&zLine[n], nLine - n, in)==0 ){
+      if( n==0 ){
+        free(zLine);
+        return 0;
+      }
+      zLine[n] = 0;
+      eol = 1;
+      break;
+    }
+    while( zLine[n] ){ n++; }
+    if( n>0 && zLine[n-1]=='\n' ){
+      n--;
+      zLine[n] = 0;
+      eol = 1;
+    }
+  }
+  zLine = realloc( zLine, n+1 );
+  return zLine;
+}
+
+/*
+** Retrieve a single line of input text.
+**
+** zPrior is a string of prior text retrieved.  If not the empty
+** string, then issue a continuation prompt.
+*/
+static char *one_input_line(const char *zPrior, FILE *in){
+  char *zPrompt;
+  char *zResult;
+  if( in!=0 ){
+    return local_getline(0, in);
+  }
+  if( zPrior && zPrior[0] ){
+    zPrompt = continuePrompt;
+  }else{
+    zPrompt = mainPrompt;
+  }
+  zResult = readline(zPrompt);
+#if defined(HAVE_READLINE) && HAVE_READLINE==1
+  if( zResult && *zResult ) add_history(zResult);
+#endif
+  return zResult;
+}
+
+struct previous_mode_data {
+  int valid;        /* Is there legit data in here? */
+  int mode;
+  int showHeader;
+  int colWidth[100];
+};
+
+/*
+** An pointer to an instance of this structure is passed from
+** the main program to the callback.  This is used to communicate
+** state and mode information.
+*/
+struct callback_data {
+  sqlite3 *db;            /* The database */
+  int echoOn;            /* True to echo input commands */
+  int cnt;               /* Number of records displayed so far */
+  FILE *out;             /* Write results here */
+  int mode;              /* An output mode setting */
+  int writableSchema;    /* True if PRAGMA writable_schema=ON */
+  int showHeader;        /* True to show column names in List or Column mode */
+  char *zDestTable;      /* Name of destination table when MODE_Insert */
+  char separator[20];    /* Separator character for MODE_List */
+  int colWidth[100];     /* Requested width of each column when in column mode*/
+  int actualWidth[100];  /* Actual width of each column */
+  char nullvalue[20];    /* The text to print when a NULL comes back from
+                         ** the database */
+  struct previous_mode_data explainPrev;
+                         /* Holds the mode information just before
+                         ** .explain ON */
+  char outfile[FILENAME_MAX]; /* Filename for *out */
+  const char *zDbFilename;    /* name of the database file */
+};
+
+/*
+** These are the allowed modes.
+*/
+#define MODE_Line     0  /* One column per line.  Blank line between records */
+#define MODE_Column   1  /* One record per line in neat columns */
+#define MODE_List     2  /* One record per line with a separator */
+#define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
+#define MODE_Html     4  /* Generate an XHTML table */
+#define MODE_Insert   5  /* Generate SQL "insert" statements */
+#define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
+#define MODE_Csv      7  /* Quote strings, numbers are plain */
+#define MODE_NUM_OF   8  /* The number of modes (not a mode itself) */
+#define MODE_Explain  9  /* Like MODE_Column, but do not truncate data */
+
+static const char *modeDescr[MODE_NUM_OF] = {
+  "line",
+  "column",
+  "list",
+  "semi",
+  "html",
+  "insert",
+  "tcl",
+  "csv",
+};
+
+/*
+** Number of elements in an array
+*/
+#define ArraySize(X)  (sizeof(X)/sizeof(X[0]))
+
+/*
+** Output the given string as a quoted string using SQL quoting conventions.
+*/
+static void output_quoted_string(FILE *out, const char *z){
+  int i;
+  int nSingle = 0;
+  for(i=0; z[i]; i++){
+    if( z[i]=='\'' ) nSingle++;
+  }
+  if( nSingle==0 ){
+    fprintf(out,"'%s'",z);
+  }else{
+    fprintf(out,"'");
+    while( *z ){
+      for(i=0; z[i] && z[i]!='\''; i++){}
+      if( i==0 ){
+        fprintf(out,"''");
+        z++;
+      }else if( z[i]=='\'' ){
+        fprintf(out,"%.*s''",i,z);
+        z += i+1;
+      }else{
+        fprintf(out,"%s",z);
+        break;
+      }
+    }
+    fprintf(out,"'");
+  }
+}
+
+/*
+** Output the given string as a quoted according to C or TCL quoting rules.
+*/
+static void output_c_string(FILE *out, const char *z){
+  unsigned int c;
+  fputc('"', out);
+  while( (c = *(z++))!=0 ){
+    if( c=='\\' ){
+      fputc(c, out);
+      fputc(c, out);
+    }else if( c=='\t' ){
+      fputc('\\', out);
+      fputc('t', out);
+    }else if( c=='\n' ){
+      fputc('\\', out);
+      fputc('n', out);
+    }else if( c=='\r' ){
+      fputc('\\', out);
+      fputc('r', out);
+    }else if( !isprint(c) ){
+      fprintf(out, "\\%03o", c&0xff);
+    }else{
+      fputc(c, out);
+    }
+  }
+  fputc('"', out);
+}
+
+/*
+** Output the given string with characters that are special to
+** HTML escaped.
+*/
+static void output_html_string(FILE *out, const char *z){
+  int i;
+  while( *z ){
+    for(i=0; z[i] && z[i]!='<' && z[i]!='&'; i++){}
+    if( i>0 ){
+      fprintf(out,"%.*s",i,z);
+    }
+    if( z[i]=='<' ){
+      fprintf(out,"&lt;");
+    }else if( z[i]=='&' ){
+      fprintf(out,"&amp;");
+    }else{
+      break;
+    }
+    z += i + 1;
+  }
+}
+
+/*
+** If a field contains any character identified by a 1 in the following
+** array, then the string must be quoted for CSV.
+*/
+static const char needCsvQuote[] = {
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 0, 1, 0, 0, 0, 0, 1,   0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
+};
+
+/*
+** Output a single term of CSV.  Actually, p->separator is used for
+** the separator, which may or may not be a comma.  p->nullvalue is
+** the null value.  Strings are quoted using ANSI-C rules.  Numbers
+** appear outside of quotes.
+*/
+static void output_csv(struct callback_data *p, const char *z, int bSep){
+  FILE *out = p->out;
+  if( z==0 ){
+    fprintf(out,"%s",p->nullvalue);
+  }else{
+    int i;
+    int nSep = strlen(p->separator);
+    for(i=0; z[i]; i++){
+      if( needCsvQuote[((unsigned char*)z)[i]] 
+         || (z[i]==p->separator[0] && 
+             (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){
+        i = 0;
+        break;
+      }
+    }
+    if( i==0 ){
+      putc('"', out);
+      for(i=0; z[i]; i++){
+        if( z[i]=='"' ) putc('"', out);
+        putc(z[i], out);
+      }
+      putc('"', out);
+    }else{
+      fprintf(out, "%s", z);
+    }
+  }
+  if( bSep ){
+    fprintf(p->out, "%s", p->separator);
+  }
+}
+
+#ifdef SIGINT
+/*
+** This routine runs when the user presses Ctrl-C
+*/
+static void interrupt_handler(int NotUsed){
+  seenInterrupt = 1;
+  if( db ) sqlite3_interrupt(db);
+}
+#endif
+
+/*
+** This is the callback routine that the SQLite library
+** invokes for each row of a query result.
+*/
+static int callback(void *pArg, int nArg, char **azArg, char **azCol){
+  int i;
+  struct callback_data *p = (struct callback_data*)pArg;
+  switch( p->mode ){
+    case MODE_Line: {
+      int w = 5;
+      if( azArg==0 ) break;
+      for(i=0; i<nArg; i++){
+        int len = strlen(azCol[i] ? azCol[i] : "");
+        if( len>w ) w = len;
+      }
+      if( p->cnt++>0 ) fprintf(p->out,"\n");
+      for(i=0; i<nArg; i++){
+        fprintf(p->out,"%*s = %s\n", w, azCol[i],
+                azArg[i] ? azArg[i] : p->nullvalue);
+      }
+      break;
+    }
+    case MODE_Explain:
+    case MODE_Column: {
+      if( p->cnt++==0 ){
+        for(i=0; i<nArg; i++){
+          int w, n;
+          if( i<ArraySize(p->colWidth) ){
+            w = p->colWidth[i];
+          }else{
+            w = 0;
+          }
+          if( w<=0 ){
+            w = strlen(azCol[i] ? azCol[i] : "");
+            if( w<10 ) w = 10;
+            n = strlen(azArg && azArg[i] ? azArg[i] : p->nullvalue);
+            if( w<n ) w = n;
+          }
+          if( i<ArraySize(p->actualWidth) ){
+            p->actualWidth[i] = w;
+          }
+          if( p->showHeader ){
+            fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": "  ");
+          }
+        }
+        if( p->showHeader ){
+          for(i=0; i<nArg; i++){
+            int w;
+            if( i<ArraySize(p->actualWidth) ){
+               w = p->actualWidth[i];
+            }else{
+               w = 10;
+            }
+            fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------"
+                   "----------------------------------------------------------",
+                    i==nArg-1 ? "\n": "  ");
+          }
+        }
+      }
+      if( azArg==0 ) break;
+      for(i=0; i<nArg; i++){
+        int w;
+        if( i<ArraySize(p->actualWidth) ){
+           w = p->actualWidth[i];
+        }else{
+           w = 10;
+        }
+        if( p->mode==MODE_Explain && azArg[i] && strlen(azArg[i])>w ){
+          w = strlen(azArg[i]);
+        }
+        fprintf(p->out,"%-*.*s%s",w,w,
+            azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");
+      }
+      break;
+    }
+    case MODE_Semi:
+    case MODE_List: {
+      if( p->cnt++==0 && p->showHeader ){
+        for(i=0; i<nArg; i++){
+          fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator);
+        }
+      }
+      if( azArg==0 ) break;
+      for(i=0; i<nArg; i++){
+        char *z = azArg[i];
+        if( z==0 ) z = p->nullvalue;
+        fprintf(p->out, "%s", z);
+        if( i<nArg-1 ){
+          fprintf(p->out, "%s", p->separator);
+        }else if( p->mode==MODE_Semi ){
+          fprintf(p->out, ";\n");
+        }else{
+          fprintf(p->out, "\n");
+        }
+      }
+      break;
+    }
+    case MODE_Html: {
+      if( p->cnt++==0 && p->showHeader ){
+        fprintf(p->out,"<TR>");
+        for(i=0; i<nArg; i++){
+          fprintf(p->out,"<TH>%s</TH>",azCol[i]);
+        }
+        fprintf(p->out,"</TR>\n");
+      }
+      if( azArg==0 ) break;
+      fprintf(p->out,"<TR>");
+      for(i=0; i<nArg; i++){
+        fprintf(p->out,"<TD>");
+        output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
+        fprintf(p->out,"</TD>\n");
+      }
+      fprintf(p->out,"</TR>\n");
+      break;
+    }
+    case MODE_Tcl: {
+      if( p->cnt++==0 && p->showHeader ){
+        for(i=0; i<nArg; i++){
+          output_c_string(p->out,azCol[i] ? azCol[i] : "");
+          fprintf(p->out, "%s", p->separator);
+        }
+        fprintf(p->out,"\n");
+      }
+      if( azArg==0 ) break;
+      for(i=0; i<nArg; i++){
+        output_c_string(p->out, azArg[i] ? azArg[i] : p->nullvalue);
+        fprintf(p->out, "%s", p->separator);
+      }
+      fprintf(p->out,"\n");
+      break;
+    }
+    case MODE_Csv: {
+      if( p->cnt++==0 && p->showHeader ){
+        for(i=0; i<nArg; i++){
+          output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
+        }
+        fprintf(p->out,"\n");
+      }
+      if( azArg==0 ) break;
+      for(i=0; i<nArg; i++){
+        output_csv(p, azArg[i], i<nArg-1);
+      }
+      fprintf(p->out,"\n");
+      break;
+    }
+    case MODE_Insert: {
+      if( azArg==0 ) break;
+      fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable);
+      for(i=0; i<nArg; i++){
+        char *zSep = i>0 ? ",": "";
+        if( azArg[i]==0 ){
+          fprintf(p->out,"%sNULL",zSep);
+        }else if( isNumber(azArg[i], 0) ){
+          fprintf(p->out,"%s%s",zSep, azArg[i]);
+        }else{
+          if( zSep[0] ) fprintf(p->out,"%s",zSep);
+          output_quoted_string(p->out, azArg[i]);
+        }
+      }
+      fprintf(p->out,");\n");
+      break;
+    }
+  }
+  return 0;
+}
+
+/*
+** Set the destination table field of the callback_data structure to
+** the name of the table given.  Escape any quote characters in the
+** table name.
+*/
+static void set_table_name(struct callback_data *p, const char *zName){
+  int i, n;
+  int needQuote;
+  char *z;
+
+  if( p->zDestTable ){
+    free(p->zDestTable);
+    p->zDestTable = 0;
+  }
+  if( zName==0 ) return;
+  needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
+  for(i=n=0; zName[i]; i++, n++){
+    if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
+      needQuote = 1;
+      if( zName[i]=='\'' ) n++;
+    }
+  }
+  if( needQuote ) n += 2;
+  z = p->zDestTable = malloc( n+1 );
+  if( z==0 ){
+    fprintf(stderr,"Out of memory!\n");
+    exit(1);
+  }
+  n = 0;
+  if( needQuote ) z[n++] = '\'';
+  for(i=0; zName[i]; i++){
+    z[n++] = zName[i];
+    if( zName[i]=='\'' ) z[n++] = '\'';
+  }
+  if( needQuote ) z[n++] = '\'';
+  z[n] = 0;
+}
+
+/* zIn is either a pointer to a NULL-terminated string in memory obtained
+** from malloc(), or a NULL pointer. The string pointed to by zAppend is
+** added to zIn, and the result returned in memory obtained from malloc().
+** zIn, if it was not NULL, is freed.
+**
+** If the third argument, quote, is not '\0', then it is used as a 
+** quote character for zAppend.
+*/
+static char *appendText(char *zIn, char const *zAppend, char quote){
+  int len;
+  int i;
+  int nAppend = strlen(zAppend);
+  int nIn = (zIn?strlen(zIn):0);
+
+  len = nAppend+nIn+1;
+  if( quote ){
+    len += 2;
+    for(i=0; i<nAppend; i++){
+      if( zAppend[i]==quote ) len++;
+    }
+  }
+
+  zIn = (char *)realloc(zIn, len);
+  if( !zIn ){
+    return 0;
+  }
+
+  if( quote ){
+    char *zCsr = &zIn[nIn];
+    *zCsr++ = quote;
+    for(i=0; i<nAppend; i++){
+      *zCsr++ = zAppend[i];
+      if( zAppend[i]==quote ) *zCsr++ = quote;
+    }
+    *zCsr++ = quote;
+    *zCsr++ = '\0';
+    assert( (zCsr-zIn)==len );
+  }else{
+    memcpy(&zIn[nIn], zAppend, nAppend);
+    zIn[len-1] = '\0';
+  }
+
+  return zIn;
+}
+
+
+/*
+** Execute a query statement that has a single result column.  Print
+** that result column on a line by itself with a semicolon terminator.
+**
+** This is used, for example, to show the schema of the database by
+** querying the SQLITE_MASTER table.
+*/
+static int run_table_dump_query(FILE *out, sqlite3 *db, const char *zSelect){
+  sqlite3_stmt *pSelect;
+  int rc;
+  rc = sqlite3_prepare(db, zSelect, -1, &pSelect, 0);
+  if( rc!=SQLITE_OK || !pSelect ){
+    return rc;
+  }
+  rc = sqlite3_step(pSelect);
+  while( rc==SQLITE_ROW ){
+    fprintf(out, "%s;\n", sqlite3_column_text(pSelect, 0));
+    rc = sqlite3_step(pSelect);
+  }
+  return sqlite3_finalize(pSelect);
+}
+
+
+/*
+** This is a different callback routine used for dumping the database.
+** Each row received by this callback consists of a table name,
+** the table type ("index" or "table") and SQL to create the table.
+** This routine should print text sufficient to recreate the table.
+*/
+static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
+  int rc;
+  const char *zTable;
+  const char *zType;
+  const char *zSql;
+  struct callback_data *p = (struct callback_data *)pArg;
+
+  if( nArg!=3 ) return 1;
+  zTable = azArg[0];
+  zType = azArg[1];
+  zSql = azArg[2];
+  
+  if( strcmp(zTable, "sqlite_sequence")==0 ){
+    fprintf(p->out, "DELETE FROM sqlite_sequence;\n");
+  }else if( strcmp(zTable, "sqlite_stat1")==0 ){
+    fprintf(p->out, "ANALYZE sqlite_master;\n");
+  }else if( strncmp(zTable, "sqlite_", 7)==0 ){
+    return 0;
+  }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
+    char *zIns;
+    if( !p->writableSchema ){
+      fprintf(p->out, "PRAGMA writable_schema=ON;\n");
+      p->writableSchema = 1;
+    }
+    zIns = sqlite3_mprintf(
+       "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
+       "VALUES('table','%q','%q',0,'%q');",
+       zTable, zTable, zSql);
+    fprintf(p->out, "%s\n", zIns);
+    sqlite3_free(zIns);
+    return 0;
+  }else{
+    fprintf(p->out, "%s;\n", zSql);
+  }
+
+  if( strcmp(zType, "table")==0 ){
+    sqlite3_stmt *pTableInfo = 0;
+    char *zSelect = 0;
+    char *zTableInfo = 0;
+    char *zTmp = 0;
+   
+    zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
+    zTableInfo = appendText(zTableInfo, zTable, '"');
+    zTableInfo = appendText(zTableInfo, ");", 0);
+
+    rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
+    if( zTableInfo ) free(zTableInfo);
+    if( rc!=SQLITE_OK || !pTableInfo ){
+      return 1;
+    }
+
+    zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
+    zTmp = appendText(zTmp, zTable, '"');
+    if( zTmp ){
+      zSelect = appendText(zSelect, zTmp, '\'');
+    }
+    zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
+    rc = sqlite3_step(pTableInfo);
+    while( rc==SQLITE_ROW ){
+      const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
+      zSelect = appendText(zSelect, "quote(", 0);
+      zSelect = appendText(zSelect, zText, '"');
+      rc = sqlite3_step(pTableInfo);
+      if( rc==SQLITE_ROW ){
+        zSelect = appendText(zSelect, ") || ',' || ", 0);
+      }else{
+        zSelect = appendText(zSelect, ") ", 0);
+      }
+    }
+    rc = sqlite3_finalize(pTableInfo);
+    if( rc!=SQLITE_OK ){
+      if( zSelect ) free(zSelect);
+      return 1;
+    }
+    zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
+    zSelect = appendText(zSelect, zTable, '"');
+
+    rc = run_table_dump_query(p->out, p->db, zSelect);
+    if( rc==SQLITE_CORRUPT ){
+      zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
+      rc = run_table_dump_query(p->out, p->db, zSelect);
+    }
+    if( zSelect ) free(zSelect);
+  }
+  return 0;
+}
+
+/*
+** Run zQuery.  Use dump_callback() as the callback routine so that
+** the contents of the query are output as SQL statements.
+**
+** If we get a SQLITE_CORRUPT error, rerun the query after appending
+** "ORDER BY rowid DESC" to the end.
+*/
+static int run_schema_dump_query(
+  struct callback_data *p, 
+  const char *zQuery,
+  char **pzErrMsg
+){
+  int rc;
+  rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg);
+  if( rc==SQLITE_CORRUPT ){
+    char *zQ2;
+    int len = strlen(zQuery);
+    if( pzErrMsg ) sqlite3_free(*pzErrMsg);
+    zQ2 = malloc( len+100 );
+    if( zQ2==0 ) return rc;
+    sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery);
+    rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg);
+    free(zQ2);
+  }
+  return rc;
+}
+
+/*
+** Text of a help message
+*/
+static char zHelp[] =
+  ".bail ON|OFF           Stop after hitting an error.  Default OFF\n"
+  ".databases             List names and files of attached databases\n"
+  ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
+  ".echo ON|OFF           Turn command echo on or off\n"
+  ".exit                  Exit this program\n"
+  ".explain ON|OFF        Turn output mode suitable for EXPLAIN on or off.\n"
+  ".header(s) ON|OFF      Turn display of headers on or off\n"
+  ".help                  Show this message\n"
+  ".import FILE TABLE     Import data from FILE into TABLE\n"
+  ".indices TABLE         Show names of all indices on TABLE\n"
+#ifdef SQLITE_ENABLE_IOTRACE
+  ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
+#endif
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+  ".load FILE ?ENTRY?     Load an extension library\n"
+#endif
+  ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
+  "                         csv      Comma-separated values\n"
+  "                         column   Left-aligned columns.  (See .width)\n"
+  "                         html     HTML <table> code\n"
+  "                         insert   SQL insert statements for TABLE\n"
+  "                         line     One value per line\n"
+  "                         list     Values delimited by .separator string\n"
+  "                         tabs     Tab-separated values\n"
+  "                         tcl      TCL list elements\n"
+  ".nullvalue STRING      Print STRING in place of NULL values\n"
+  ".output FILENAME       Send output to FILENAME\n"
+  ".output stdout         Send output to the screen\n"
+  ".prompt MAIN CONTINUE  Replace the standard prompts\n"
+  ".quit                  Exit this program\n"
+  ".read FILENAME         Execute SQL in FILENAME\n"
+  ".schema ?TABLE?        Show the CREATE statements\n"
+  ".separator STRING      Change separator used by output mode and .import\n"
+  ".show                  Show the current values for various settings\n"
+  ".tables ?PATTERN?      List names of tables matching a LIKE pattern\n"
+  ".timeout MS            Try opening locked tables for MS milliseconds\n"
+#if HAS_TIMER
+  ".timer ON|OFF          Turn the CPU timer measurement on or off\n"
+#endif
+  ".width NUM NUM ...     Set column widths for \"column\" mode\n"
+;
+
+/* Forward reference */
+static int process_input(struct callback_data *p, FILE *in);
+
+/*
+** Make sure the database is open.  If it is not, then open it.  If
+** the database fails to open, print an error message and exit.
+*/
+static void open_db(struct callback_data *p){
+  if( p->db==0 ){
+    sqlite3_open(p->zDbFilename, &p->db);
+    db = p->db;
+    sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0,
+        shellstaticFunc, 0, 0);
+    if( SQLITE_OK!=sqlite3_errcode(db) ){
+      fprintf(stderr,"Unable to open database \"%s\": %s\n", 
+          p->zDbFilename, sqlite3_errmsg(db));
+      exit(1);
+    }
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+    sqlite3_enable_load_extension(p->db, 1);
+#endif
+  }
+}
+
+/*
+** Do C-language style dequoting.
+**
+**    \t    -> tab
+**    \n    -> newline
+**    \r    -> carriage return
+**    \NNN  -> ascii character NNN in octal
+**    \\    -> backslash
+*/
+static void resolve_backslashes(char *z){
+  int i, j, c;
+  for(i=j=0; (c = z[i])!=0; i++, j++){
+    if( c=='\\' ){
+      c = z[++i];
+      if( c=='n' ){
+        c = '\n';
+      }else if( c=='t' ){
+        c = '\t';
+      }else if( c=='r' ){
+        c = '\r';
+      }else if( c>='0' && c<='7' ){
+        c -= '0';
+        if( z[i+1]>='0' && z[i+1]<='7' ){
+          i++;
+          c = (c<<3) + z[i] - '0';
+          if( z[i+1]>='0' && z[i+1]<='7' ){
+            i++;
+            c = (c<<3) + z[i] - '0';
+          }
+        }
+      }
+    }
+    z[j] = c;
+  }
+  z[j] = 0;
+}
+
+/*
+** Interpret zArg as a boolean value.  Return either 0 or 1.
+*/
+static int booleanValue(char *zArg){
+  int val = atoi(zArg);
+  int j;
+  for(j=0; zArg[j]; j++){
+    zArg[j] = tolower(zArg[j]);
+  }
+  if( strcmp(zArg,"on")==0 ){
+    val = 1;
+  }else if( strcmp(zArg,"yes")==0 ){
+    val = 1;
+  }
+  return val;
+}
+
+/*
+** If an input line begins with "." then invoke this routine to
+** process that line.
+**
+** Return 1 on error, 2 to exit, and 0 otherwise.
+*/
+static int do_meta_command(char *zLine, struct callback_data *p){
+  int i = 1;
+  int nArg = 0;
+  int n, c;
+  int rc = 0;
+  char *azArg[50];
+
+  /* Parse the input line into tokens.
+  */
+  while( zLine[i] && nArg<ArraySize(azArg) ){
+    while( isspace((unsigned char)zLine[i]) ){ i++; }
+    if( zLine[i]==0 ) break;
+    if( zLine[i]=='\'' || zLine[i]=='"' ){
+      int delim = zLine[i++];
+      azArg[nArg++] = &zLine[i];
+      while( zLine[i] && zLine[i]!=delim ){ i++; }
+      if( zLine[i]==delim ){
+        zLine[i++] = 0;
+      }
+      if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
+    }else{
+      azArg[nArg++] = &zLine[i];
+      while( zLine[i] && !isspace((unsigned char)zLine[i]) ){ i++; }
+      if( zLine[i] ) zLine[i++] = 0;
+      resolve_backslashes(azArg[nArg-1]);
+    }
+  }
+
+  /* Process the input line.
+  */
+  if( nArg==0 ) return rc;
+  n = strlen(azArg[0]);
+  c = azArg[0][0];
+  if( c=='b' && n>1 && strncmp(azArg[0], "bail", n)==0 && nArg>1 ){
+    bail_on_error = booleanValue(azArg[1]);
+  }else
+
+  if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
+    struct callback_data data;
+    char *zErrMsg = 0;
+    open_db(p);
+    memcpy(&data, p, sizeof(data));
+    data.showHeader = 1;
+    data.mode = MODE_Column;
+    data.colWidth[0] = 3;
+    data.colWidth[1] = 15;
+    data.colWidth[2] = 58;
+    data.cnt = 0;
+    sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
+    if( zErrMsg ){
+      fprintf(stderr,"Error: %s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+  }else
+
+  if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
+    char *zErrMsg = 0;
+    open_db(p);
+    fprintf(p->out, "BEGIN TRANSACTION;\n");
+    p->writableSchema = 0;
+    if( nArg==1 ){
+      run_schema_dump_query(p, 
+        "SELECT name, type, sql FROM sqlite_master "
+        "WHERE sql NOT NULL AND type=='table'", 0
+      );
+      run_table_dump_query(p->out, p->db,
+        "SELECT sql FROM sqlite_master "
+        "WHERE sql NOT NULL AND type IN ('index','trigger','view')"
+      );
+    }else{
+      int i;
+      for(i=1; i<nArg; i++){
+        zShellStatic = azArg[i];
+        run_schema_dump_query(p,
+          "SELECT name, type, sql FROM sqlite_master "
+          "WHERE tbl_name LIKE shellstatic() AND type=='table'"
+          "  AND sql NOT NULL", 0);
+        run_table_dump_query(p->out, p->db,
+          "SELECT sql FROM sqlite_master "
+          "WHERE sql NOT NULL"
+          "  AND type IN ('index','trigger','view')"
+          "  AND tbl_name LIKE shellstatic()"
+        );
+        zShellStatic = 0;
+      }
+    }
+    if( p->writableSchema ){
+      fprintf(p->out, "PRAGMA writable_schema=OFF;\n");
+      p->writableSchema = 0;
+    }
+    if( zErrMsg ){
+      fprintf(stderr,"Error: %s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+    }else{
+      fprintf(p->out, "COMMIT;\n");
+    }
+  }else
+
+  if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 ){
+    p->echoOn = booleanValue(azArg[1]);
+  }else
+
+  if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
+    rc = 2;
+  }else
+
+  if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
+    int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
+    if(val == 1) {
+      if(!p->explainPrev.valid) {
+        p->explainPrev.valid = 1;
+        p->explainPrev.mode = p->mode;
+        p->explainPrev.showHeader = p->showHeader;
+        memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth));
+      }
+      /* We could put this code under the !p->explainValid
+      ** condition so that it does not execute if we are already in
+      ** explain mode. However, always executing it allows us an easy
+      ** was to reset to explain mode in case the user previously
+      ** did an .explain followed by a .width, .mode or .header
+      ** command.
+      */
+      p->mode = MODE_Explain;
+      p->showHeader = 1;
+      memset(p->colWidth,0,ArraySize(p->colWidth));
+      p->colWidth[0] = 4;                  /* addr */
+      p->colWidth[1] = 13;                 /* opcode */
+      p->colWidth[2] = 4;                  /* P1 */
+      p->colWidth[3] = 4;                  /* P2 */
+      p->colWidth[4] = 4;                  /* P3 */
+      p->colWidth[5] = 13;                 /* P4 */
+      p->colWidth[6] = 2;                  /* P5 */
+      p->colWidth[7] = 13;                  /* Comment */
+    }else if (p->explainPrev.valid) {
+      p->explainPrev.valid = 0;
+      p->mode = p->explainPrev.mode;
+      p->showHeader = p->explainPrev.showHeader;
+      memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth));
+    }
+  }else
+
+  if( c=='h' && (strncmp(azArg[0], "header", n)==0 ||
+                 strncmp(azArg[0], "headers", n)==0 )&& nArg>1 ){
+    p->showHeader = booleanValue(azArg[1]);
+  }else
+
+  if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
+    fprintf(stderr,zHelp);
+  }else
+
+  if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg>=3 ){
+    char *zTable = azArg[2];    /* Insert data into this table */
+    char *zFile = azArg[1];     /* The file from which to extract data */
+    sqlite3_stmt *pStmt;        /* A statement */
+    int rc;                     /* Result code */
+    int nCol;                   /* Number of columns in the table */
+    int nByte;                  /* Number of bytes in an SQL string */
+    int i, j;                   /* Loop counters */
+    int nSep;                   /* Number of bytes in p->separator[] */
+    char *zSql;                 /* An SQL statement */
+    char *zLine;                /* A single line of input from the file */
+    char **azCol;               /* zLine[] broken up into columns */
+    char *zCommit;              /* How to commit changes */   
+    FILE *in;                   /* The input file */
+    int lineno = 0;             /* Line number of input file */
+
+    open_db(p);
+    nSep = strlen(p->separator);
+    if( nSep==0 ){
+      fprintf(stderr, "non-null separator required for import\n");
+      return 0;
+    }
+    zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
+    if( zSql==0 ) return 0;
+    nByte = strlen(zSql);
+    rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
+    sqlite3_free(zSql);
+    if( rc ){
+      fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
+      nCol = 0;
+      rc = 1;
+    }else{
+      nCol = sqlite3_column_count(pStmt);
+    }
+    sqlite3_finalize(pStmt);
+    if( nCol==0 ) return 0;
+    zSql = malloc( nByte + 20 + nCol*2 );
+    if( zSql==0 ) return 0;
+    sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable);
+    j = strlen(zSql);
+    for(i=1; i<nCol; i++){
+      zSql[j++] = ',';
+      zSql[j++] = '?';
+    }
+    zSql[j++] = ')';
+    zSql[j] = 0;
+    rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
+    free(zSql);
+    if( rc ){
+      fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));
+      sqlite3_finalize(pStmt);
+      return 1;
+    }
+    in = fopen(zFile, "rb");
+    if( in==0 ){
+      fprintf(stderr, "cannot open file: %s\n", zFile);
+      sqlite3_finalize(pStmt);
+      return 0;
+    }
+    azCol = malloc( sizeof(azCol[0])*(nCol+1) );
+    if( azCol==0 ){
+      fclose(in);
+      return 0;
+    }
+    sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
+    zCommit = "COMMIT";
+    while( (zLine = local_getline(0, in))!=0 ){
+      char *z;
+      i = 0;
+      lineno++;
+      azCol[0] = zLine;
+      for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){
+        if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){
+          *z = 0;
+          i++;
+          if( i<nCol ){
+            azCol[i] = &z[nSep];
+            z += nSep-1;
+          }
+        }
+      }
+      *z = 0;
+      if( i+1!=nCol ){
+        fprintf(stderr,"%s line %d: expected %d columns of data but found %d\n",
+           zFile, lineno, nCol, i+1);
+        zCommit = "ROLLBACK";
+        break;
+      }
+      for(i=0; i<nCol; i++){
+        sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
+      }
+      sqlite3_step(pStmt);
+      rc = sqlite3_reset(pStmt);
+      free(zLine);
+      if( rc!=SQLITE_OK ){
+        fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db));
+        zCommit = "ROLLBACK";
+        rc = 1;
+        break;
+      }
+    }
+    free(azCol);
+    fclose(in);
+    sqlite3_finalize(pStmt);
+    sqlite3_exec(p->db, zCommit, 0, 0, 0);
+  }else
+
+  if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){
+    struct callback_data data;
+    char *zErrMsg = 0;
+    open_db(p);
+    memcpy(&data, p, sizeof(data));
+    data.showHeader = 0;
+    data.mode = MODE_List;
+    zShellStatic = azArg[1];
+    sqlite3_exec(p->db,
+      "SELECT name FROM sqlite_master "
+      "WHERE type='index' AND tbl_name LIKE shellstatic() "
+      "UNION ALL "
+      "SELECT name FROM sqlite_temp_master "
+      "WHERE type='index' AND tbl_name LIKE shellstatic() "
+      "ORDER BY 1",
+      callback, &data, &zErrMsg
+    );
+    zShellStatic = 0;
+    if( zErrMsg ){
+      fprintf(stderr,"Error: %s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+  }else
+
+#ifdef SQLITE_ENABLE_IOTRACE
+  if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
+    extern void (*sqlite3_io_trace)(const char*, ...);
+    if( iotrace && iotrace!=stdout ) fclose(iotrace);
+    iotrace = 0;
+    if( nArg<2 ){
+      sqlite3_io_trace = 0;
+    }else if( strcmp(azArg[1], "-")==0 ){
+      sqlite3_io_trace = iotracePrintf;
+      iotrace = stdout;
+    }else{
+      iotrace = fopen(azArg[1], "w");
+      if( iotrace==0 ){
+        fprintf(stderr, "cannot open \"%s\"\n", azArg[1]);
+        sqlite3_io_trace = 0;
+      }else{
+        sqlite3_io_trace = iotracePrintf;
+      }
+    }
+  }else
+#endif
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+  if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){
+    const char *zFile, *zProc;
+    char *zErrMsg = 0;
+    int rc;
+    zFile = azArg[1];
+    zProc = nArg>=3 ? azArg[2] : 0;
+    open_db(p);
+    rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
+    if( rc!=SQLITE_OK ){
+      fprintf(stderr, "%s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+      rc = 1;
+    }
+  }else
+#endif
+
+  if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg>=2 ){
+    int n2 = strlen(azArg[1]);
+    if( strncmp(azArg[1],"line",n2)==0
+        ||
+        strncmp(azArg[1],"lines",n2)==0 ){
+      p->mode = MODE_Line;
+    }else if( strncmp(azArg[1],"column",n2)==0
+              ||
+              strncmp(azArg[1],"columns",n2)==0 ){
+      p->mode = MODE_Column;
+    }else if( strncmp(azArg[1],"list",n2)==0 ){
+      p->mode = MODE_List;
+    }else if( strncmp(azArg[1],"html",n2)==0 ){
+      p->mode = MODE_Html;
+    }else if( strncmp(azArg[1],"tcl",n2)==0 ){
+      p->mode = MODE_Tcl;
+    }else if( strncmp(azArg[1],"csv",n2)==0 ){
+      p->mode = MODE_Csv;
+      sqlite3_snprintf(sizeof(p->separator), p->separator, ",");
+    }else if( strncmp(azArg[1],"tabs",n2)==0 ){
+      p->mode = MODE_List;
+      sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");
+    }else if( strncmp(azArg[1],"insert",n2)==0 ){
+      p->mode = MODE_Insert;
+      if( nArg>=3 ){
+        set_table_name(p, azArg[2]);
+      }else{
+        set_table_name(p, "table");
+      }
+    }else {
+      fprintf(stderr,"mode should be one of: "
+         "column csv html insert line list tabs tcl\n");
+    }
+  }else
+
+  if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) {
+    sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue,
+                     "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
+  }else
+
+  if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
+    if( p->out!=stdout ){
+      fclose(p->out);
+    }
+    if( strcmp(azArg[1],"stdout")==0 ){
+      p->out = stdout;
+      sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout");
+    }else{
+      p->out = fopen(azArg[1], "wb");
+      if( p->out==0 ){
+        fprintf(stderr,"can't write to \"%s\"\n", azArg[1]);
+        p->out = stdout;
+      } else {
+         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]);
+      }
+    }
+  }else
+
+  if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){
+    if( nArg >= 2) {
+      strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
+    }
+    if( nArg >= 3) {
+      strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
+    }
+  }else
+
+  if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
+    rc = 2;
+  }else
+
+  if( c=='r' && strncmp(azArg[0], "read", n)==0 && nArg==2 ){
+    FILE *alt = fopen(azArg[1], "rb");
+    if( alt==0 ){
+      fprintf(stderr,"can't open \"%s\"\n", azArg[1]);
+    }else{
+      process_input(p, alt);
+      fclose(alt);
+    }
+  }else
+
+  if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
+    struct callback_data data;
+    char *zErrMsg = 0;
+    open_db(p);
+    memcpy(&data, p, sizeof(data));
+    data.showHeader = 0;
+    data.mode = MODE_Semi;
+    if( nArg>1 ){
+      int i;
+      for(i=0; azArg[1][i]; i++) azArg[1][i] = tolower(azArg[1][i]);
+      if( strcmp(azArg[1],"sqlite_master")==0 ){
+        char *new_argv[2], *new_colv[2];
+        new_argv[0] = "CREATE TABLE sqlite_master (\n"
+                      "  type text,\n"
+                      "  name text,\n"
+                      "  tbl_name text,\n"
+                      "  rootpage integer,\n"
+                      "  sql text\n"
+                      ")";
+        new_argv[1] = 0;
+        new_colv[0] = "sql";
+        new_colv[1] = 0;
+        callback(&data, 1, new_argv, new_colv);
+      }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
+        char *new_argv[2], *new_colv[2];
+        new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
+                      "  type text,\n"
+                      "  name text,\n"
+                      "  tbl_name text,\n"
+                      "  rootpage integer,\n"
+                      "  sql text\n"
+                      ")";
+        new_argv[1] = 0;
+        new_colv[0] = "sql";
+        new_colv[1] = 0;
+        callback(&data, 1, new_argv, new_colv);
+      }else{
+        zShellStatic = azArg[1];
+        sqlite3_exec(p->db,
+          "SELECT sql FROM "
+          "  (SELECT * FROM sqlite_master UNION ALL"
+          "   SELECT * FROM sqlite_temp_master) "
+          "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL "
+          "ORDER BY substr(type,2,1), name",
+          callback, &data, &zErrMsg);
+        zShellStatic = 0;
+      }
+    }else{
+      sqlite3_exec(p->db,
+         "SELECT sql FROM "
+         "  (SELECT * FROM sqlite_master UNION ALL"
+         "   SELECT * FROM sqlite_temp_master) "
+         "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'"
+         "ORDER BY substr(type,2,1), name",
+         callback, &data, &zErrMsg
+      );
+    }
+    if( zErrMsg ){
+      fprintf(stderr,"Error: %s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+  }else
+
+  if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){
+    sqlite3_snprintf(sizeof(p->separator), p->separator,
+                     "%.*s", (int)sizeof(p->separator)-1, azArg[1]);
+  }else
+
+  if( c=='s' && strncmp(azArg[0], "show", n)==0){
+    int i;
+    fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
+    fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
+    fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
+    fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);
+    fprintf(p->out,"%9.9s: ", "nullvalue");
+      output_c_string(p->out, p->nullvalue);
+      fprintf(p->out, "\n");
+    fprintf(p->out,"%9.9s: %s\n","output",
+                                 strlen(p->outfile) ? p->outfile : "stdout");
+    fprintf(p->out,"%9.9s: ", "separator");
+      output_c_string(p->out, p->separator);
+      fprintf(p->out, "\n");
+    fprintf(p->out,"%9.9s: ","width");
+    for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
+      fprintf(p->out,"%d ",p->colWidth[i]);
+    }
+    fprintf(p->out,"\n");
+  }else
+
+  if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
+    char **azResult;
+    int nRow, rc;
+    char *zErrMsg;
+    open_db(p);
+    if( nArg==1 ){
+      rc = sqlite3_get_table(p->db,
+        "SELECT name FROM sqlite_master "
+        "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'"
+        "UNION ALL "
+        "SELECT name FROM sqlite_temp_master "
+        "WHERE type IN ('table','view') "
+        "ORDER BY 1",
+        &azResult, &nRow, 0, &zErrMsg
+      );
+    }else{
+      zShellStatic = azArg[1];
+      rc = sqlite3_get_table(p->db,
+        "SELECT name FROM sqlite_master "
+        "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
+        "UNION ALL "
+        "SELECT name FROM sqlite_temp_master "
+        "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' "
+        "ORDER BY 1",
+        &azResult, &nRow, 0, &zErrMsg
+      );
+      zShellStatic = 0;
+    }
+    if( zErrMsg ){
+      fprintf(stderr,"Error: %s\n", zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+    if( rc==SQLITE_OK ){
+      int len, maxlen = 0;
+      int i, j;
+      int nPrintCol, nPrintRow;
+      for(i=1; i<=nRow; i++){
+        if( azResult[i]==0 ) continue;
+        len = strlen(azResult[i]);
+        if( len>maxlen ) maxlen = len;
+      }
+      nPrintCol = 80/(maxlen+2);
+      if( nPrintCol<1 ) nPrintCol = 1;
+      nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
+      for(i=0; i<nPrintRow; i++){
+        for(j=i+1; j<=nRow; j+=nPrintRow){
+          char *zSp = j<=nPrintRow ? "" : "  ";
+          printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : "");
+        }
+        printf("\n");
+      }
+    }else{
+      rc = 1;
+    }
+    sqlite3_free_table(azResult);
+  }else
+
+  if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){
+    open_db(p);
+    sqlite3_busy_timeout(p->db, atoi(azArg[1]));
+  }else
+  
+#if HAS_TIMER  
+  if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg>1 ){
+    enableTimer = booleanValue(azArg[1]);
+  }else
+#endif
+
+  if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
+    int j;
+    assert( nArg<=ArraySize(azArg) );
+    for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
+      p->colWidth[j-1] = atoi(azArg[j]);
+    }
+  }else
+
+
+  {
+    fprintf(stderr, "unknown command or invalid arguments: "
+      " \"%s\". Enter \".help\" for help\n", azArg[0]);
+  }
+
+  return rc;
+}
+
+/*
+** Return TRUE if a semicolon occurs anywhere in the first N characters
+** of string z[].
+*/
+static int _contains_semicolon(const char *z, int N){
+  int i;
+  for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }
+  return 0;
+}
+
+/*
+** Test to see if a line consists entirely of whitespace.
+*/
+static int _all_whitespace(const char *z){
+  for(; *z; z++){
+    if( isspace(*(unsigned char*)z) ) continue;
+    if( *z=='/' && z[1]=='*' ){
+      z += 2;
+      while( *z && (*z!='*' || z[1]!='/') ){ z++; }
+      if( *z==0 ) return 0;
+      z++;
+      continue;
+    }
+    if( *z=='-' && z[1]=='-' ){
+      z += 2;
+      while( *z && *z!='\n' ){ z++; }
+      if( *z==0 ) return 1;
+      continue;
+    }
+    return 0;
+  }
+  return 1;
+}
+
+/*
+** Return TRUE if the line typed in is an SQL command terminator other
+** than a semi-colon.  The SQL Server style "go" command is understood
+** as is the Oracle "/".
+*/
+static int _is_command_terminator(const char *zLine){
+  while( isspace(*(unsigned char*)zLine) ){ zLine++; };
+  if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1;  /* Oracle */
+  if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o'
+         && _all_whitespace(&zLine[2]) ){
+    return 1;  /* SQL Server */
+  }
+  return 0;
+}
+
+/*
+** Read input from *in and process it.  If *in==0 then input
+** is interactive - the user is typing it it.  Otherwise, input
+** is coming from a file or device.  A prompt is issued and history
+** is saved only if input is interactive.  An interrupt signal will
+** cause this routine to exit immediately, unless input is interactive.
+**
+** Return the number of errors.
+*/
+static int process_input(struct callback_data *p, FILE *in){
+  char *zLine = 0;
+  char *zSql = 0;
+  int nSql = 0;
+  int nSqlPrior = 0;
+  char *zErrMsg;
+  int rc;
+  int errCnt = 0;
+  int lineno = 0;
+  int startline = 0;
+
+  while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
+    fflush(p->out);
+    free(zLine);
+    zLine = one_input_line(zSql, in);
+    if( zLine==0 ){
+      break;  /* We have reached EOF */
+    }
+    if( seenInterrupt ){
+      if( in!=0 ) break;
+      seenInterrupt = 0;
+    }
+    lineno++;
+    if( p->echoOn ) printf("%s\n", zLine);
+    if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
+    if( zLine && zLine[0]=='.' && nSql==0 ){
+      rc = do_meta_command(zLine, p);
+      if( rc==2 ){
+        break;
+      }else if( rc ){
+        errCnt++;
+      }
+      continue;
+    }
+    if( _is_command_terminator(zLine) ){
+      memcpy(zLine,";",2);
+    }
+    nSqlPrior = nSql;
+    if( zSql==0 ){
+      int i;
+      for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
+      if( zLine[i]!=0 ){
+        nSql = strlen(zLine);
+        zSql = malloc( nSql+1 );
+        if( zSql==0 ){
+          fprintf(stderr, "out of memory\n");
+          exit(1);
+        }
+        memcpy(zSql, zLine, nSql+1);
+        startline = lineno;
+      }
+    }else{
+      int len = strlen(zLine);
+      zSql = realloc( zSql, nSql + len + 2 );
+      if( zSql==0 ){
+        fprintf(stderr,"%s: out of memory!\n", Argv0);
+        exit(1);
+      }
+      zSql[nSql++] = '\n';
+      memcpy(&zSql[nSql], zLine, len+1);
+      nSql += len;
+    }
+    if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
+                && sqlite3_complete(zSql) ){
+      p->cnt = 0;
+      open_db(p);
+      BEGIN_TIMER;
+      rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg);
+      END_TIMER;
+      if( rc || zErrMsg ){
+        char zPrefix[100];
+        if( in!=0 || !stdin_is_interactive ){
+          sqlite3_snprintf(sizeof(zPrefix), zPrefix, 
+                           "SQL error near line %d:", startline);
+        }else{
+          sqlite3_snprintf(sizeof(zPrefix), zPrefix, "SQL error:");
+        }
+        if( zErrMsg!=0 ){
+          printf("%s %s\n", zPrefix, zErrMsg);
+          sqlite3_free(zErrMsg);
+          zErrMsg = 0;
+        }else{
+          printf("%s %s\n", zPrefix, sqlite3_errmsg(p->db));
+        }
+        errCnt++;
+      }
+      free(zSql);
+      zSql = 0;
+      nSql = 0;
+    }
+  }
+  if( zSql ){
+    if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);
+    free(zSql);
+  }
+  free(zLine);
+  return errCnt;
+}
+
+/*
+** Return a pathname which is the user's home directory.  A
+** 0 return indicates an error of some kind.  Space to hold the
+** resulting string is obtained from malloc().  The calling
+** function should free the result.
+*/
+static char *find_home_dir(void){
+  char *home_dir = NULL;
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE)
+  struct passwd *pwent;
+  uid_t uid = getuid();
+  if( (pwent=getpwuid(uid)) != NULL) {
+    home_dir = pwent->pw_dir;
+  }
+#endif
+
+#if defined(_WIN32_WCE)
+  /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
+   */
+  home_dir = strdup("/");
+#else
+
+#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
+  if (!home_dir) {
+    home_dir = getenv("USERPROFILE");
+  }
+#endif
+
+  if (!home_dir) {
+    home_dir = getenv("HOME");
+  }
+
+#if defined(_WIN32) || defined(WIN32) || defined(__OS2__)
+  if (!home_dir) {
+    char *zDrive, *zPath;
+    int n;
+    zDrive = getenv("HOMEDRIVE");
+    zPath = getenv("HOMEPATH");
+    if( zDrive && zPath ){
+      n = strlen(zDrive) + strlen(zPath) + 1;
+      home_dir = malloc( n );
+      if( home_dir==0 ) return 0;
+      sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
+      return home_dir;
+    }
+    home_dir = "c:\\";
+  }
+#endif
+
+#endif /* !_WIN32_WCE */
+
+  if( home_dir ){
+    int n = strlen(home_dir) + 1;
+    char *z = malloc( n );
+    if( z ) memcpy(z, home_dir, n);
+    home_dir = z;
+  }
+
+  return home_dir;
+}
+
+/*
+** Read input from the file given by sqliterc_override.  Or if that
+** parameter is NULL, take input from ~/.sqliterc
+*/
+static void process_sqliterc(
+  struct callback_data *p,        /* Configuration data */
+  const char *sqliterc_override   /* Name of config file. NULL to use default */
+){
+  char *home_dir = NULL;
+  const char *sqliterc = sqliterc_override;
+  char *zBuf = 0;
+  FILE *in = NULL;
+  int nBuf;
+
+  if (sqliterc == NULL) {
+    home_dir = find_home_dir();
+    if( home_dir==0 ){
+      fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0);
+      return;
+    }
+    nBuf = strlen(home_dir) + 16;
+    zBuf = malloc( nBuf );
+    if( zBuf==0 ){
+      fprintf(stderr,"%s: out of memory!\n", Argv0);
+      exit(1);
+    }
+    sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir);
+    free(home_dir);
+    sqliterc = (const char*)zBuf;
+  }
+  in = fopen(sqliterc,"rb");
+  if( in ){
+    if( stdin_is_interactive ){
+      printf("-- Loading resources from %s\n",sqliterc);
+    }
+    process_input(p,in);
+    fclose(in);
+  }
+  free(zBuf);
+  return;
+}
+
+/*
+** Show available command line options
+*/
+static const char zOptions[] = 
+  "   -init filename       read/process named file\n"
+  "   -echo                print commands before execution\n"
+  "   -[no]header          turn headers on or off\n"
+  "   -bail                stop after hitting an error\n"
+  "   -interactive         force interactive I/O\n"
+  "   -batch               force batch I/O\n"
+  "   -column              set output mode to 'column'\n"
+  "   -csv                 set output mode to 'csv'\n"
+  "   -html                set output mode to HTML\n"
+  "   -line                set output mode to 'line'\n"
+  "   -list                set output mode to 'list'\n"
+  "   -separator 'x'       set output field separator (|)\n"
+  "   -nullvalue 'text'    set text string for NULL values\n"
+  "   -version             show SQLite version\n"
+;
+static void usage(int showDetail){
+  fprintf(stderr,
+      "Usage: %s [OPTIONS] FILENAME [SQL]\n"  
+      "FILENAME is the name of an SQLite database. A new database is created\n"
+      "if the file does not previously exist.\n", Argv0);
+  if( showDetail ){
+    fprintf(stderr, "OPTIONS include:\n%s", zOptions);
+  }else{
+    fprintf(stderr, "Use the -help option for additional information\n");
+  }
+  exit(1);
+}
+
+/*
+** Initialize the state information in data
+*/
+static void main_init(struct callback_data *data) {
+  memset(data, 0, sizeof(*data));
+  data->mode = MODE_List;
+  memcpy(data->separator,"|", 2);
+  data->showHeader = 0;
+  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
+  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
+}
+
+int main(int argc, char **argv){
+  char *zErrMsg = 0;
+  struct callback_data data;
+  const char *zInitFile = 0;
+  char *zFirstCmd = 0;
+  int i;
+  int rc = 0;
+
+  Argv0 = argv[0];
+  main_init(&data);
+  stdin_is_interactive = isatty(0);
+
+  /* Make sure we have a valid signal handler early, before anything
+  ** else is done.
+  */
+#ifdef SIGINT
+  signal(SIGINT, interrupt_handler);
+#endif
+
+  /* Do an initial pass through the command-line argument to locate
+  ** the name of the database file, the name of the initialization file,
+  ** and the first command to execute.
+  */
+  for(i=1; i<argc-1; i++){
+    char *z;
+    if( argv[i][0]!='-' ) break;
+    z = argv[i];
+    if( z[0]=='-' && z[1]=='-' ) z++;
+    if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){
+      i++;
+    }else if( strcmp(argv[i],"-init")==0 ){
+      i++;
+      zInitFile = argv[i];
+    }
+  }
+  if( i<argc ){
+    data.zDbFilename = argv[i++];
+  }else{
+#ifndef SQLITE_OMIT_MEMORYDB
+    data.zDbFilename = ":memory:";
+#else
+    data.zDbFilename = 0;
+#endif
+  }
+  if( i<argc ){
+    zFirstCmd = argv[i++];
+  }
+  data.out = stdout;
+
+#ifdef SQLITE_OMIT_MEMORYDB
+  if( data.zDbFilename==0 ){
+    fprintf(stderr,"%s: no database filename specified\n", argv[0]);
+    exit(1);
+  }
+#endif
+
+  /* Go ahead and open the database file if it already exists.  If the
+  ** file does not exist, delay opening it.  This prevents empty database
+  ** files from being created if a user mistypes the database name argument
+  ** to the sqlite command-line tool.
+  */
+  if( access(data.zDbFilename, 0)==0 ){
+    open_db(&data);
+  }
+
+  /* Process the initialization file if there is one.  If no -init option
+  ** is given on the command line, look for a file named ~/.sqliterc and
+  ** try to process it.
+  */
+  process_sqliterc(&data,zInitFile);
+
+  /* Make a second pass through the command-line argument and set
+  ** options.  This second pass is delayed until after the initialization
+  ** file is processed so that the command-line arguments will override
+  ** settings in the initialization file.
+  */
+  for(i=1; i<argc && argv[i][0]=='-'; i++){
+    char *z = argv[i];
+    if( z[1]=='-' ){ z++; }
+    if( strcmp(z,"-init")==0 ){
+      i++;
+    }else if( strcmp(z,"-html")==0 ){
+      data.mode = MODE_Html;
+    }else if( strcmp(z,"-list")==0 ){
+      data.mode = MODE_List;
+    }else if( strcmp(z,"-line")==0 ){
+      data.mode = MODE_Line;
+    }else if( strcmp(z,"-column")==0 ){
+      data.mode = MODE_Column;
+    }else if( strcmp(z,"-csv")==0 ){
+      data.mode = MODE_Csv;
+      memcpy(data.separator,",",2);
+    }else if( strcmp(z,"-separator")==0 ){
+      i++;
+      sqlite3_snprintf(sizeof(data.separator), data.separator,
+                       "%.*s",(int)sizeof(data.separator)-1,argv[i]);
+    }else if( strcmp(z,"-nullvalue")==0 ){
+      i++;
+      sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
+                       "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]);
+    }else if( strcmp(z,"-header")==0 ){
+      data.showHeader = 1;
+    }else if( strcmp(z,"-noheader")==0 ){
+      data.showHeader = 0;
+    }else if( strcmp(z,"-echo")==0 ){
+      data.echoOn = 1;
+    }else if( strcmp(z,"-bail")==0 ){
+      bail_on_error = 1;
+    }else if( strcmp(z,"-version")==0 ){
+      printf("%s\n", sqlite3_libversion());
+      return 0;
+    }else if( strcmp(z,"-interactive")==0 ){
+      stdin_is_interactive = 1;
+    }else if( strcmp(z,"-batch")==0 ){
+      stdin_is_interactive = 0;
+    }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){
+      usage(1);
+    }else{
+      fprintf(stderr,"%s: unknown option: %s\n", Argv0, z);
+      fprintf(stderr,"Use -help for a list of options.\n");
+      return 1;
+    }
+  }
+
+  if( zFirstCmd ){
+    /* Run just the command that follows the database name
+    */
+    if( zFirstCmd[0]=='.' ){
+      do_meta_command(zFirstCmd, &data);
+      exit(0);
+    }else{
+      int rc;
+      open_db(&data);
+      rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg);
+      if( rc!=0 && zErrMsg!=0 ){
+        fprintf(stderr,"SQL error: %s\n", zErrMsg);
+        exit(1);
+      }
+    }
+  }else{
+    /* Run commands received from standard input
+    */
+    if( stdin_is_interactive ){
+      char *zHome;
+      char *zHistory = 0;
+      int nHistory;
+      printf(
+        "SQLite version %s\n"
+        "Enter \".help\" for instructions\n",
+        sqlite3_libversion()
+      );
+      zHome = find_home_dir();
+      if( zHome && (zHistory = malloc(nHistory = strlen(zHome)+20))!=0 ){
+        sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
+      }
+#if defined(HAVE_READLINE) && HAVE_READLINE==1
+      if( zHistory ) read_history(zHistory);
+#endif
+      rc = process_input(&data, 0);
+      if( zHistory ){
+        stifle_history(100);
+        write_history(zHistory);
+        free(zHistory);
+      }
+      free(zHome);
+    }else{
+      rc = process_input(&data, stdin);
+    }
+  }
+  set_table_name(&data, 0);
+  if( db ){
+    if( sqlite3_close(db)!=SQLITE_OK ){
+      fprintf(stderr,"error closing database: %s\n", sqlite3_errmsg(db));
+    }
+  }
+  return rc;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/sqlite.h.in b/client/src/thirdparty/sqlite-3.4.2/src/sqlite.h.in
new file mode 100644
index 0000000..9b1aaf6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/sqlite.h.in
@@ -0,0 +1,4804 @@
+/*
+** 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.
+**
+*************************************************************************
+** This header file defines the interface that the SQLite library
+** presents to client programs.  If a C-function, structure, datatype,
+** or constant definition does not appear in this file, then it is
+** not a published API of SQLite, is subject to change without
+** notice, and should not be referenced by programs that use SQLite.
+**
+** Some of the definitions that are in this file are marked as
+** "experimental".  Experimental interfaces are normally new
+** features recently added to SQLite.  We do not anticipate changes 
+** to experimental interfaces but reserve to make minor changes if
+** experience from use "in the wild" suggest such changes are prudent.
+**
+** The official C-language API documentation for SQLite is derived
+** from comments in this file.  This file is the authoritative source
+** on how SQLite interfaces are suppose to operate.
+**
+** The name of this file under configuration management is "sqlite.h.in".
+** The makefile makes some minor changes to this file (such as inserting
+** the version number) and changes its name to "sqlite3.h" as
+** part of the build process.
+**
+** @(#) $Id: sqlite.h.in,v 1.284 2008/02/06 14:11:35 drh Exp $
+*/
+#ifndef _SQLITE3_H_
+#define _SQLITE3_H_
+#include <stdarg.h>     /* Needed for the definition of va_list */
+
+/*
+** Make sure we can call this stuff from C++.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+** Add the ability to override 'extern'
+*/
+#ifndef SQLITE_EXTERN
+# define SQLITE_EXTERN extern
+#endif
+
+/*
+** Make sure these symbols where not defined by some previous header
+** file.
+*/
+#ifdef SQLITE_VERSION
+# undef SQLITE_VERSION
+#endif
+#ifdef SQLITE_VERSION_NUMBER
+# undef SQLITE_VERSION_NUMBER
+#endif
+
+/*
+** CAPI3REF: Compile-Time Library Version Numbers {F10010}
+**
+** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in
+** the sqlite3.h file specify the version of SQLite with which
+** that header file is associated.
+**
+** The "version" of SQLite is a strong of the form "X.Y.Z".
+** The phrase "alpha" or "beta" might be appended after the Z.
+** The X value is major version number always 3 in SQLite3.
+** The X value only changes when  backwards compatibility is
+** broken and we intend to never break
+** backwards compatibility.  The Y value is the minor version
+** number and only changes when
+** there are major feature enhancements that are forwards compatible
+** but not backwards compatible.  The Z value is release number
+** and is incremented with
+** each release but resets back to 0 when Y is incremented.
+**
+** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()].
+**
+** INVARIANTS:
+**
+** {F10011} The SQLITE_VERSION #define in the sqlite3.h header file
+**          evaluates to a string literal that is the SQLite version
+**          with which the header file is associated.
+**
+** {F10014} The SQLITE_VERSION_NUMBER #define resolves to an integer
+**          with the value  (X*1000000 + Y*1000 + Z) where X, Y, and
+**          Z are the major version, minor version, and release number.
+*/
+#define SQLITE_VERSION         "--VERS--"
+#define SQLITE_VERSION_NUMBER --VERSION-NUMBER--
+
+/*
+** CAPI3REF: Run-Time Library Version Numbers {F10020}
+** KEYWORDS: sqlite3_version
+**
+** These features provide the same information as the [SQLITE_VERSION]
+** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated
+** with the library instead of the header file.  Cautious programmers might
+** include a check in their application to verify that 
+** sqlite3_libversion_number() always returns the value 
+** [SQLITE_VERSION_NUMBER].
+**
+** The sqlite3_libversion() function returns the same information as is
+** in the sqlite3_version[] string constant.  The function is provided
+** for use in DLLs since DLL users usually do not have direct access to string
+** constants within the DLL.
+**
+** INVARIANTS:
+**
+** {F10021} The [sqlite3_libversion_number()] interface returns an integer
+**          equal to [SQLITE_VERSION_NUMBER]. 
+**
+** {F10022} The [sqlite3_version] string constant contains the text of the
+**          [SQLITE_VERSION] string. 
+**
+** {F10023} The [sqlite3_libversion()] function returns
+**          a pointer to the [sqlite3_version] string constant.
+*/
+SQLITE_EXTERN const char sqlite3_version[];
+const char *sqlite3_libversion(void);
+int sqlite3_libversion_number(void);
+
+/*
+** CAPI3REF: Test To See If The Library Is Threadsafe {F10100}
+**
+** SQLite can be compiled with or without mutexes.  When
+** the SQLITE_THREADSAFE C preprocessor macro is true, mutexes
+** are enabled and SQLite is threadsafe.  When that macro os false,
+** the mutexes are omitted.  Without the mutexes, it is not safe
+** to use SQLite from more than one thread.
+**
+** There is a measurable performance penalty for enabling mutexes.
+** So if speed is of utmost importance, it makes sense to disable
+** the mutexes.  But for maximum safety, mutexes should be enabled.
+** The default behavior is for mutexes to be enabled.
+**
+** This interface can be used by a program to make sure that the
+** version of SQLite that it is linking against was compiled with
+** the desired setting of the SQLITE_THREADSAFE macro.
+**
+** INVARIANTS:
+**
+** {F10101} The [sqlite3_threadsafe()] function returns nonzero if
+**          SQLite was compiled with its mutexes enabled or zero
+**          if SQLite was compiled with mutexes disabled.
+*/
+int sqlite3_threadsafe(void);
+
+/*
+** CAPI3REF: Database Connection Handle {F12000}
+** KEYWORDS: {database connection}
+**
+** Each open SQLite database is represented by pointer to an instance of the
+** opaque structure named "sqlite3".  It is useful to think of an sqlite3
+** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and
+** [sqlite3_open_v2()] interfaces are its constructors
+** and [sqlite3_close()] is its destructor.  There are many other interfaces
+** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and
+** [sqlite3_busy_timeout()] to name but three) that are methods on this
+** object.
+*/
+typedef struct sqlite3 sqlite3;
+
+
+/*
+** CAPI3REF: 64-Bit Integer Types {F10200}
+** KEYWORDS: sqlite_int64 sqlite_uint64
+**
+** Because there is no cross-platform way to specify 64-bit integer types
+** SQLite includes typedefs for 64-bit signed and unsigned integers.
+**
+** The sqlite3_int64 and sqlite3_uint64 are the preferred type
+** definitions.  The sqlite_int64 and sqlite_uint64 types are
+** supported for backwards compatibility only.
+**
+** INVARIANTS:
+**
+** {F10201} The [sqlite_int64] and [sqlite3_int64] types specify a
+**          64-bit signed integer.
+**
+** {F10202} The [sqlite_uint64] and [sqlite3_uint64] types specify
+**          a 64-bit unsigned integer.
+*/
+#ifdef SQLITE_INT64_TYPE
+  typedef SQLITE_INT64_TYPE sqlite_int64;
+  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+  typedef __int64 sqlite_int64;
+  typedef unsigned __int64 sqlite_uint64;
+#else
+  typedef long long int sqlite_int64;
+  typedef unsigned long long int sqlite_uint64;
+#endif
+typedef sqlite_int64 sqlite3_int64;
+typedef sqlite_uint64 sqlite3_uint64;
+
+/*
+** If compiling for a processor that lacks floating point support,
+** substitute integer for floating-point
+*/
+#ifdef SQLITE_OMIT_FLOATING_POINT
+# define double sqlite3_int64
+#endif
+
+/*
+** CAPI3REF: Closing A Database Connection {F12010}
+**
+** This routine is the destructor for the [sqlite3] object.  
+**
+** Applications should [sqlite3_finalize | finalize] all
+** [prepared statements] and
+** [sqlite3_blob_close | close] all [sqlite3_blob | BLOBs] 
+** associated with the [sqlite3] object prior
+** to attempting to close the [sqlite3] object.
+**
+** <todo>What happens to pending transactions?  Are they
+** rolled back, or abandoned?</todo>
+**
+** INVARIANTS:
+**
+** {F12011} The [sqlite3_close()] interface destroys an [sqlite3] object
+**          allocated by a prior call to [sqlite3_open()],
+**          [sqlite3_open16()], or [sqlite3_open_v2()].
+**
+** {F12012} The [sqlite3_close()] function releases all memory used by the
+**          connection and closes all open files.
+**
+** {F12013} If the database connection contains
+**          [prepared statements] that have not been
+**          finalized by [sqlite3_finalize()], then [sqlite3_close()]
+**          returns [SQLITE_BUSY] and leaves the connection open.
+**
+** {F12014} Giving sqlite3_close() a NULL pointer is a harmless no-op.
+**
+** LIMITATIONS:
+**
+** {U12015} The parameter to [sqlite3_close()] must be an [sqlite3] object
+**          pointer previously obtained from [sqlite3_open()] or the 
+**          equivalent, or NULL.
+**
+** {U12016} The parameter to [sqlite3_close()] must not have been previously
+**          closed.
+*/
+int sqlite3_close(sqlite3 *);
+
+/*
+** The type for a callback function.
+** This is legacy and deprecated.  It is included for historical
+** compatibility and is not documented.
+*/
+typedef int (*sqlite3_callback)(void*,int,char**, char**);
+
+/*
+** CAPI3REF: One-Step Query Execution Interface {F12100}
+**
+** The sqlite3_exec() interface is a convenient way of running
+** one or more SQL statements without a lot of C code.  The
+** SQL statements are passed in as the second parameter to
+** sqlite3_exec().  The statements are evaluated one by one
+** until either an error or an interrupt is encountered or
+** until they are all done.  The 3rd parameter is an optional
+** callback that is invoked once for each row of any query results
+** produced by the SQL statements.  The 5th parameter tells where
+** to write any error messages.
+**
+** The sqlite3_exec() interface is implemented in terms of
+** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
+** The sqlite3_exec() routine does nothing that cannot be done
+** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
+** The sqlite3_exec() is just a convenient wrapper.
+**
+** INVARIANTS:
+** 
+** {F12101} The [sqlite3_exec()] interface evaluates zero or more UTF-8
+**          encoded, semicolon-separated, SQL statements in the
+**          zero-terminated string of its 2nd parameter within the
+**          context of the [sqlite3] object given in the 1st parameter.
+**
+** {F12104} The return value of [sqlite3_exec()] is SQLITE_OK if all
+**          SQL statements run successfully.
+**
+** {F12105} The return value of [sqlite3_exec()] is an appropriate 
+**          non-zero error code if any SQL statement fails.
+**
+** {F12107} If one or more of the SQL statements handed to [sqlite3_exec()]
+**          return results and the 3rd parameter is not NULL, then
+**          the callback function specified by the 3rd parameter is
+**          invoked once for each row of result.
+**
+** {F12110} If the callback returns a non-zero value then [sqlite3_exec()]
+**          will aborted the SQL statement it is currently evaluating,
+**          skip all subsequent SQL statements, and return [SQLITE_ABORT].
+**          <todo>What happens to *errmsg here?  Does the result code for
+**          sqlite3_errcode() get set?</todo>
+**
+** {F12113} The [sqlite3_exec()] routine will pass its 4th parameter through
+**          as the 1st parameter of the callback.
+**
+** {F12116} The [sqlite3_exec()] routine sets the 2nd parameter of its
+**          callback to be the number of columns in the current row of
+**          result.
+**
+** {F12119} The [sqlite3_exec()] routine sets the 3rd parameter of its 
+**          callback to be an array of pointers to strings holding the
+**          values for each column in the current result set row as
+**          obtained from [sqlite3_column_text()].
+**
+** {F12122} The [sqlite3_exec()] routine sets the 4th parameter of its
+**          callback to be an array of pointers to strings holding the
+**          names of result columns as obtained from [sqlite3_column_name()].
+**
+** {F12125} If the 3rd parameter to [sqlite3_exec()] is NULL then
+**          [sqlite3_exec()] never invokes a callback.  All query
+**          results are silently discarded.
+**
+** {F12128} If an error occurs while parsing or evaluating any of the SQL
+**          statements handed to [sqlite3_exec()] then [sqlite3_exec()] will
+**          return an [error code] other than [SQLITE_OK].
+**
+** {F12131} If an error occurs while parsing or evaluating any of the SQL
+**          handed to [sqlite3_exec()] and if the 5th parameter (errmsg)
+**          to [sqlite3_exec()] is not NULL, then an error message is
+**          allocated using the equivalent of [sqlite3_mprintf()] and
+**          *errmsg is made to point to that message.
+**
+** {F12134} The [sqlite3_exec()] routine does not change the value of
+**          *errmsg if errmsg is NULL or if there are no errors.
+**
+** {F12137} The [sqlite3_exec()] function sets the error code and message
+**          accessible via [sqlite3_errcode()] and [sqlite3_errmsg()].
+**
+** LIMITATIONS:
+**
+** {U12141} The first parameter to [sqlite3_exec()] must be an valid and open
+**          [database connection].
+**
+** {U12142} The database connection must not be closed while
+**          [sqlite3_exec()] is running.
+** 
+** {U12143} The calling function is should use [sqlite3_free()] to free
+**          the memory that *errmsg is left pointing at once the error
+**          message is no longer needed.
+**
+** {U12145} The SQL statement text in the 2nd parameter to [sqlite3_exec()]
+**          must remain unchanged while [sqlite3_exec()] is running.
+*/
+int sqlite3_exec(
+  sqlite3*,                                  /* An open database */
+  const char *sql,                           /* SQL to be evaluted */
+  int (*callback)(void*,int,char**,char**),  /* Callback function */
+  void *,                                    /* 1st argument to callback */
+  char **errmsg                              /* Error msg written here */
+);
+
+/*
+** CAPI3REF: Result Codes {F10210}
+** KEYWORDS: SQLITE_OK {error code} {error codes}
+**
+** Many SQLite functions return an integer result code from the set shown
+** here in order to indicates success or failure.
+**
+** See also: [SQLITE_IOERR_READ | extended result codes]
+*/
+#define SQLITE_OK           0   /* Successful result */
+/* beginning-of-error-codes */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */
+#define SQLITE_EMPTY       16   /* Database is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
+#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_FORMAT      24   /* Auxiliary database format error */
+#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
+#define SQLITE_NOTADB      26   /* File opened that is not a database file */
+#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
+/* end-of-error-codes */
+
+/*
+** CAPI3REF: Extended Result Codes {F10220}
+** KEYWORDS: {extended error code} {extended error codes}
+** KEYWORDS: {extended result codes}
+**
+** In its default configuration, SQLite API routines return one of 26 integer
+** [SQLITE_OK | result codes].  However, experience has shown that
+** many of these result codes are too course-grained.  They do not provide as
+** much information about problems as programmers might like.  In an effort to
+** address this, newer versions of SQLite (version 3.3.8 and later) include
+** support for additional result codes that provide more detailed information
+** about errors. The extended result codes are enabled or disabled
+** for each database connection using the [sqlite3_extended_result_codes()]
+** API.
+** 
+** Some of the available extended result codes are listed here.
+** One may expect the number of extended result codes will be expand
+** over time.  Software that uses extended result codes should expect
+** to see new result codes in future releases of SQLite.
+**
+** The SQLITE_OK result code will never be extended.  It will always
+** be exactly zero.
+** 
+** INVARIANTS:
+**
+** {F10223} The symbolic name for an extended result code always contains
+**          a related primary result code as a prefix.
+**
+** {F10224} Primary result code names contain a single "_" character.
+**
+** {F10225} Extended result code names contain two or more "_" characters.
+**
+** {F10226} The numeric value of an extended result code contains the
+**          numeric value of its corresponding primary result code it
+**          its least significant 8 bits.
+*/
+#define SQLITE_IOERR_READ          (SQLITE_IOERR | (1<<8))
+#define SQLITE_IOERR_SHORT_READ    (SQLITE_IOERR | (2<<8))
+#define SQLITE_IOERR_WRITE         (SQLITE_IOERR | (3<<8))
+#define SQLITE_IOERR_FSYNC         (SQLITE_IOERR | (4<<8))
+#define SQLITE_IOERR_DIR_FSYNC     (SQLITE_IOERR | (5<<8))
+#define SQLITE_IOERR_TRUNCATE      (SQLITE_IOERR | (6<<8))
+#define SQLITE_IOERR_FSTAT         (SQLITE_IOERR | (7<<8))
+#define SQLITE_IOERR_UNLOCK        (SQLITE_IOERR | (8<<8))
+#define SQLITE_IOERR_RDLOCK        (SQLITE_IOERR | (9<<8))
+#define SQLITE_IOERR_DELETE        (SQLITE_IOERR | (10<<8))
+#define SQLITE_IOERR_BLOCKED       (SQLITE_IOERR | (11<<8))
+#define SQLITE_IOERR_NOMEM         (SQLITE_IOERR | (12<<8))
+
+/*
+** CAPI3REF: Flags For File Open Operations {F10230}
+**
+** These bit values are intended for use in then
+** 3rd parameter to the [sqlite3_open_v2()] interface and
+** in the 4th parameter to the xOpen method of the
+** [sqlite3_vfs] object.
+*/
+#define SQLITE_OPEN_READONLY         0x00000001
+#define SQLITE_OPEN_READWRITE        0x00000002
+#define SQLITE_OPEN_CREATE           0x00000004
+#define SQLITE_OPEN_DELETEONCLOSE    0x00000008
+#define SQLITE_OPEN_EXCLUSIVE        0x00000010
+#define SQLITE_OPEN_MAIN_DB          0x00000100
+#define SQLITE_OPEN_TEMP_DB          0x00000200
+#define SQLITE_OPEN_TRANSIENT_DB     0x00000400
+#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800
+#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000
+#define SQLITE_OPEN_SUBJOURNAL       0x00002000
+#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000
+
+/*
+** CAPI3REF: Device Characteristics {F10240}
+**
+** The xDeviceCapabilities method of the [sqlite3_io_methods]
+** object returns an integer which is a vector of the these
+** bit values expressing I/O characteristics of the mass storage
+** device that holds the file that the [sqlite3_io_methods]
+** refers to.
+**
+** The SQLITE_IOCAP_ATOMIC property means that all writes of
+** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
+** mean that writes of blocks that are nnn bytes in size and
+** are aligned to an address which is an integer multiple of
+** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
+** that when data is appended to a file, the data is appended
+** first then the size of the file is extended, never the other
+** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
+** information is written to disk in the same order as calls
+** to xWrite().
+*/
+#define SQLITE_IOCAP_ATOMIC          0x00000001
+#define SQLITE_IOCAP_ATOMIC512       0x00000002
+#define SQLITE_IOCAP_ATOMIC1K        0x00000004
+#define SQLITE_IOCAP_ATOMIC2K        0x00000008
+#define SQLITE_IOCAP_ATOMIC4K        0x00000010
+#define SQLITE_IOCAP_ATOMIC8K        0x00000020
+#define SQLITE_IOCAP_ATOMIC16K       0x00000040
+#define SQLITE_IOCAP_ATOMIC32K       0x00000080
+#define SQLITE_IOCAP_ATOMIC64K       0x00000100
+#define SQLITE_IOCAP_SAFE_APPEND     0x00000200
+#define SQLITE_IOCAP_SEQUENTIAL      0x00000400
+
+/*
+** CAPI3REF: File Locking Levels {F10250}
+**
+** SQLite uses one of these integer values as the second
+** argument to calls it makes to the xLock() and xUnlock() methods
+** of an [sqlite3_io_methods] object.
+*/
+#define SQLITE_LOCK_NONE          0
+#define SQLITE_LOCK_SHARED        1
+#define SQLITE_LOCK_RESERVED      2
+#define SQLITE_LOCK_PENDING       3
+#define SQLITE_LOCK_EXCLUSIVE     4
+
+/*
+** CAPI3REF: Synchronization Type Flags {F10260}
+**
+** When SQLite invokes the xSync() method of an
+** [sqlite3_io_methods] object it uses a combination of the
+** these integer values as the second argument.
+**
+** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
+** sync operation only needs to flush data to mass storage.  Inode
+** information need not be flushed. The SQLITE_SYNC_NORMAL means 
+** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means 
+** to use Mac OS-X style fullsync instead of fsync().
+*/
+#define SQLITE_SYNC_NORMAL        0x00002
+#define SQLITE_SYNC_FULL          0x00003
+#define SQLITE_SYNC_DATAONLY      0x00010
+
+
+/*
+** CAPI3REF: OS Interface Open File Handle {F11110}
+**
+** An [sqlite3_file] object represents an open file in the OS
+** interface layer.  Individual OS interface implementations will
+** want to subclass this object by appending additional fields
+** for their own use.  The pMethods entry is a pointer to an
+** [sqlite3_io_methods] object that defines methods for performing
+** I/O operations on the open file.
+*/
+typedef struct sqlite3_file sqlite3_file;
+struct sqlite3_file {
+  const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
+};
+
+/*
+** CAPI3REF: OS Interface File Virtual Methods Object {F11120}
+**
+** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to
+** an instance of the this object.  This object defines the
+** methods used to perform various operations against the open file.
+**
+** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
+** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
+*  The second choice is an
+** OS-X style fullsync.  The SQLITE_SYNC_DATA flag may be ORed in to
+** indicate that only the data of the file and not its inode needs to be
+** synced.
+** 
+** The integer values to xLock() and xUnlock() are one of
+** <ul>
+** <li> [SQLITE_LOCK_NONE],
+** <li> [SQLITE_LOCK_SHARED],
+** <li> [SQLITE_LOCK_RESERVED],
+** <li> [SQLITE_LOCK_PENDING], or
+** <li> [SQLITE_LOCK_EXCLUSIVE].
+** </ul>
+** xLock() increases the lock. xUnlock() decreases the lock.  
+** The xCheckReservedLock() method looks
+** to see if any database connection, either in this
+** process or in some other process, is holding an RESERVED,
+** PENDING, or EXCLUSIVE lock on the file.  It returns true
+** if such a lock exists and false if not.
+** 
+** The xFileControl() method is a generic interface that allows custom
+** VFS implementations to directly control an open file using the
+** [sqlite3_file_control()] interface.  The second "op" argument
+** is an integer opcode.   The third
+** argument is a generic pointer which is intended to be a pointer
+** to a structure that may contain arguments or space in which to
+** write return values.  Potential uses for xFileControl() might be
+** functions to enable blocking locks with timeouts, to change the
+** locking strategy (for example to use dot-file locks), to inquire
+** about the status of a lock, or to break stale locks.  The SQLite
+** core reserves opcodes less than 100 for its own use. 
+** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
+** Applications that define a custom xFileControl method should use opcodes 
+** greater than 100 to avoid conflicts.
+**
+** The xSectorSize() method returns the sector size of the
+** device that underlies the file.  The sector size is the
+** minimum write that can be performed without disturbing
+** other bytes in the file.  The xDeviceCharacteristics()
+** method returns a bit vector describing behaviors of the
+** underlying device:
+**
+** <ul>
+** <li> [SQLITE_IOCAP_ATOMIC]
+** <li> [SQLITE_IOCAP_ATOMIC512]
+** <li> [SQLITE_IOCAP_ATOMIC1K]
+** <li> [SQLITE_IOCAP_ATOMIC2K]
+** <li> [SQLITE_IOCAP_ATOMIC4K]
+** <li> [SQLITE_IOCAP_ATOMIC8K]
+** <li> [SQLITE_IOCAP_ATOMIC16K]
+** <li> [SQLITE_IOCAP_ATOMIC32K]
+** <li> [SQLITE_IOCAP_ATOMIC64K]
+** <li> [SQLITE_IOCAP_SAFE_APPEND]
+** <li> [SQLITE_IOCAP_SEQUENTIAL]
+** </ul>
+**
+** The SQLITE_IOCAP_ATOMIC property means that all writes of
+** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
+** mean that writes of blocks that are nnn bytes in size and
+** are aligned to an address which is an integer multiple of
+** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
+** that when data is appended to a file, the data is appended
+** first then the size of the file is extended, never the other
+** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
+** information is written to disk in the same order as calls
+** to xWrite().
+*/
+typedef struct sqlite3_io_methods sqlite3_io_methods;
+struct sqlite3_io_methods {
+  int iVersion;
+  int (*xClose)(sqlite3_file*);
+  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
+  int (*xSync)(sqlite3_file*, int flags);
+  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
+  int (*xLock)(sqlite3_file*, int);
+  int (*xUnlock)(sqlite3_file*, int);
+  int (*xCheckReservedLock)(sqlite3_file*);
+  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
+  int (*xSectorSize)(sqlite3_file*);
+  int (*xDeviceCharacteristics)(sqlite3_file*);
+  /* Additional methods may be added in future releases */
+};
+
+/*
+** CAPI3REF: Standard File Control Opcodes {F11310}
+**
+** These integer constants are opcodes for the xFileControl method
+** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()]
+** interface.
+**
+** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
+** opcode cases the xFileControl method to write the current state of
+** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
+** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
+** into an integer that the pArg argument points to. This capability
+** is used during testing and only needs to be supported when SQLITE_TEST
+** is defined.
+*/
+#define SQLITE_FCNTL_LOCKSTATE        1
+
+/*
+** CAPI3REF: Mutex Handle {F17110}
+**
+** The mutex module within SQLite defines [sqlite3_mutex] to be an
+** abstract type for a mutex object.  The SQLite core never looks
+** at the internal representation of an [sqlite3_mutex].  It only
+** deals with pointers to the [sqlite3_mutex] object.
+**
+** Mutexes are created using [sqlite3_mutex_alloc()].
+*/
+typedef struct sqlite3_mutex sqlite3_mutex;
+
+/*
+** CAPI3REF: OS Interface Object {F11140}
+**
+** An instance of this object defines the interface between the
+** SQLite core and the underlying operating system.  The "vfs"
+** in the name of the object stands for "virtual file system".
+**
+** The iVersion field is initially 1 but may be larger for future
+** versions of SQLite.  Additional fields may be appended to this
+** object when the iVersion value is increased.
+**
+** The szOsFile field is the size of the subclassed [sqlite3_file]
+** structure used by this VFS.  mxPathname is the maximum length of
+** a pathname in this VFS.
+**
+** Registered vfs modules are kept on a linked list formed by
+** the pNext pointer.  The [sqlite3_vfs_register()]
+** and [sqlite3_vfs_unregister()] interfaces manage this list
+** in a thread-safe way.  The [sqlite3_vfs_find()] interface
+** searches the list.
+**
+** The pNext field is the only fields in the sqlite3_vfs 
+** structure that SQLite will ever modify.  SQLite will only access
+** or modify this field while holding a particular static mutex.
+** The application should never modify anything within the sqlite3_vfs
+** object once the object has been registered.
+**
+** The zName field holds the name of the VFS module.  The name must
+** be unique across all VFS modules.
+**
+** {F11141} SQLite will guarantee that the zFilename string passed to
+** xOpen() is a full pathname as generated by xFullPathname() and
+** that the string will be valid and unchanged until xClose() is
+** called.  {END} So the [sqlite3_file] can store a pointer to the
+** filename if it needs to remember the filename for some reason.
+**
+** {F11142} The flags argument to xOpen() includes all bits set in
+** the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
+** or [sqlite3_open16()] is used, then flags includes at least
+** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END}
+** If xOpen() opens a file read-only then it sets *pOutFlags to
+** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be
+** set.
+** 
+** {F11143} SQLite will also add one of the following flags to the xOpen()
+** call, depending on the object being opened:
+** 
+** <ul>
+** <li>  [SQLITE_OPEN_MAIN_DB]
+** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
+** <li>  [SQLITE_OPEN_TEMP_DB]
+** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
+** <li>  [SQLITE_OPEN_TRANSIENT_DB]
+** <li>  [SQLITE_OPEN_SUBJOURNAL]
+** <li>  [SQLITE_OPEN_MASTER_JOURNAL]
+** </ul> {END}
+**
+** The file I/O implementation can use the object type flags to
+** changes the way it deals with files.  For example, an application
+** that does not care about crash recovery or rollback, might make
+** the open of a journal file a no-op.  Writes to this journal are
+** also a no-op.  Any attempt to read the journal return SQLITE_IOERR.
+** Or the implementation might recognize the a database file will
+** be doing page-aligned sector reads and writes in a random order
+** and set up its I/O subsystem accordingly.
+** 
+** SQLite might also add one of the following flags to the xOpen
+** method:
+** 
+** <ul>
+** <li> [SQLITE_OPEN_DELETEONCLOSE]
+** <li> [SQLITE_OPEN_EXCLUSIVE]
+** </ul>
+** 
+** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
+** deleted when it is closed.  {F11146} The [SQLITE_OPEN_DELETEONCLOSE]
+** will be set for TEMP  databases, journals and for subjournals. 
+** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
+** for exclusive access.  This flag is set for all files except
+** for the main database file. {END}
+** 
+** {F11148} At least szOsFile bytes of memory is allocated by SQLite 
+** to hold the  [sqlite3_file] structure passed as the third 
+** argument to xOpen.  {END}  The xOpen method does not have to
+** allocate the structure; it should just fill it in.
+** 
+** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] 
+** to test for the existance of a file,
+** or [SQLITE_ACCESS_READWRITE] to test to see
+** if a file is readable and writable, or [SQLITE_ACCESS_READ]
+** to test to see if a file is at least readable.  {END} The file can be a 
+** directory.
+** 
+** {F11150} SQLite will always allocate at least mxPathname+1 byte for
+** the output buffers for xGetTempname and xFullPathname. {F11151} The exact
+** size of the output buffer is also passed as a parameter to both 
+** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN
+** should be returned. As this is handled as a fatal error by SQLite,
+** vfs implementations should endeavor to prevent this by setting 
+** mxPathname to a sufficiently large value.
+** 
+** The xRandomness(), xSleep(), and xCurrentTime() interfaces
+** are not strictly a part of the filesystem, but they are
+** included in the VFS structure for completeness.
+** The xRandomness() function attempts to return nBytes bytes
+** of good-quality randomness into zOut.  The return value is
+** the actual number of bytes of randomness obtained.  The
+** xSleep() method cause the calling thread to sleep for at
+** least the number of microseconds given.  The xCurrentTime()
+** method returns a Julian Day Number for the current date and
+** time.
+*/
+typedef struct sqlite3_vfs sqlite3_vfs;
+struct sqlite3_vfs {
+  int iVersion;            /* Structure version number */
+  int szOsFile;            /* Size of subclassed sqlite3_file */
+  int mxPathname;          /* Maximum file pathname length */
+  sqlite3_vfs *pNext;      /* Next registered VFS */
+  const char *zName;       /* Name of this virtual file system */
+  void *pAppData;          /* Pointer to application-specific data */
+  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
+               int flags, int *pOutFlags);
+  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
+  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags);
+  int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut);
+  int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
+  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
+  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
+  void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
+  void (*xDlClose)(sqlite3_vfs*, void*);
+  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
+  int (*xSleep)(sqlite3_vfs*, int microseconds);
+  int (*xCurrentTime)(sqlite3_vfs*, double*);
+  /* New fields may be appended in figure versions.  The iVersion
+  ** value will increment whenever this happens. */
+};
+
+/*
+** CAPI3REF: Flags for the xAccess VFS method {F11190}
+**
+** {F11191} These integer constants can be used as the third parameter to
+** the xAccess method of an [sqlite3_vfs] object. {END}  They determine
+** the kind of what kind of permissions the xAccess method is
+** looking for.  {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method
+** simply checks to see if the file exists. {F11193} With
+** SQLITE_ACCESS_READWRITE, the xAccess method checks to see
+** if the file is both readable and writable.  {F11194} With
+** SQLITE_ACCESS_READ the xAccess method
+** checks to see if the file is readable.
+*/
+#define SQLITE_ACCESS_EXISTS    0
+#define SQLITE_ACCESS_READWRITE 1
+#define SQLITE_ACCESS_READ      2
+
+/*
+** CAPI3REF: Enable Or Disable Extended Result Codes {F12200}
+**
+** The sqlite3_extended_result_codes() routine enables or disables the
+** [SQLITE_IOERR_READ | extended result codes] feature of SQLite.
+** The extended result codes are disabled by default for historical
+** compatibility.
+**
+** INVARIANTS:
+**
+** {F12201} Each new [database connection] has the 
+**          [extended result codes] feature
+**          disabled by default.
+**
+** {F12202} The [sqlite3_extended_result_codes(D,F)] interface will enable
+**          [extended result codes] for the 
+**          [database connection] D if the F parameter
+**          is true, or disable them if F is false.
+*/
+int sqlite3_extended_result_codes(sqlite3*, int onoff);
+
+/*
+** CAPI3REF: Last Insert Rowid {F12220}
+**
+** Each entry in an SQLite table has a unique 64-bit signed
+** integer key called the "rowid". The rowid is always available
+** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
+** names are not also used by explicitly declared columns. If
+** the table has a column of type INTEGER PRIMARY KEY then that column
+** is another an alias for the rowid.
+**
+** This routine returns the rowid of the most recent
+** successful INSERT into the database from the database connection
+** shown in the first argument.  If no successful inserts
+** have ever occurred on this database connection, zero is returned.
+**
+** If an INSERT occurs within a trigger, then the rowid of the
+** inserted row is returned by this routine as long as the trigger
+** is running.  But once the trigger terminates, the value returned
+** by this routine reverts to the last value inserted before the
+** trigger fired.
+**
+** An INSERT that fails due to a constraint violation is not a
+** successful insert and does not change the value returned by this
+** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
+** and INSERT OR ABORT make no changes to the return value of this
+** routine when their insertion fails.  When INSERT OR REPLACE 
+** encounters a constraint violation, it does not fail.  The
+** INSERT continues to completion after deleting rows that caused
+** the constraint problem so INSERT OR REPLACE will always change
+** the return value of this interface. 
+**
+** For the purposes of this routine, an insert is considered to
+** be successful even if it is subsequently rolled back.
+**
+** INVARIANTS:
+**
+** {F12221} The [sqlite3_last_insert_rowid()] function returns the
+**          rowid of the most recent successful insert done
+**          on the same database connection and within the same
+**          trigger context, or zero if there have
+**          been no qualifying inserts on that connection.
+**
+** {F12223} The [sqlite3_last_insert_rowid()] function returns
+**          same value when called from the same trigger context
+**          immediately before and after a ROLLBACK.
+**
+** LIMITATIONS:
+**
+** {U12232} If separate thread does a new insert on the same
+**          database connection while the [sqlite3_last_insert_rowid()]
+**          function is running and thus changes the last insert rowid,
+**          then the value returned by [sqlite3_last_insert_rowid()] is
+**          unpredictable and might not equal either the old or the new
+**          last insert rowid.
+*/
+sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
+
+/*
+** CAPI3REF: Count The Number Of Rows Modified {F12240}
+**
+** This function returns the number of database rows that were changed
+** or inserted or deleted by the most recently completed SQL statement
+** on the connection specified by the first parameter.  Only
+** changes that are directly specified by the INSERT, UPDATE, or
+** DELETE statement are counted.  Auxiliary changes caused by
+** triggers are not counted. Use the [sqlite3_total_changes()] function
+** to find the total number of changes including changes caused by triggers.
+**
+** A "row changes" is a change to a single row of a single table
+** caused by an INSERT, DELETE, or UPDATE statement.  Rows that
+** are changed as side effects of REPLACE constraint resolution,
+** rollback, ABORT processing, DROP TABLE, or by any other
+** mechanisms do not count as direct row changes.
+**
+** A "trigger context" is a scope of execution that begins and
+** ends with the script of a trigger.  Most SQL statements are
+** evaluated outside of any trigger.  This is the "top level"
+** trigger context.  If a trigger fires from the top level, a
+** new trigger context is entered for the duration of that one
+** trigger.  Subtriggers create subcontexts for their duration.
+**
+** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
+** not create a new trigger context.
+**
+** This function returns the number of direct row changes in the
+** most recent INSERT, UPDATE, or DELETE statement within the same
+** trigger context.
+**
+** So when called from the top level, this function returns the
+** number of changes in the most recent INSERT, UPDATE, or DELETE
+** that also occurred at the top level.
+** Within the body of a trigger, the sqlite3_changes() interface
+** can be called to find the number of
+** changes in the most recently completed INSERT, UPDATE, or DELETE
+** statement within the body of the same trigger.
+** However, the number returned does not include in changes
+** caused by subtriggers since they have their own context.
+**
+** SQLite implements the command "DELETE FROM table" without
+** a WHERE clause by dropping and recreating the table.  (This is much
+** faster than going through and deleting individual elements from the
+** table.)  Because of this optimization, the deletions in
+** "DELETE FROM table" are not row changes and will not be counted
+** by the sqlite3_changes() or [sqlite3_total_changes()] functions.
+** To get an accurate count of the number of rows deleted, use
+** "DELETE FROM table WHERE 1" instead.
+**
+** INVARIANTS:
+**
+** {F12241} The [sqlite3_changes()] function returns the number of
+**          row changes caused by the most recent INSERT, UPDATE,
+**          or DELETE statement on the same database connection and
+**          within the same trigger context, or zero if there have
+**          not been any qualifying row changes.
+**
+** LIMITATIONS:
+**
+** {U12252} If a separate thread makes changes on the same database connection
+**          while [sqlite3_changes()] is running then the value returned
+**          is unpredictable and unmeaningful.
+*/
+int sqlite3_changes(sqlite3*);
+
+/*
+** CAPI3REF: Total Number Of Rows Modified {F12260}
+***
+** This function returns the number of row changes caused
+** by INSERT, UPDATE or DELETE statements since the database handle
+** was opened.  The count includes all changes from all trigger
+** contexts.  But the count does not include changes used to
+** implement REPLACE constraints, do rollbacks or ABORT processing,
+** or DROP table processing.
+** The changes
+** are counted as soon as the statement that makes them is completed 
+** (when the statement handle is passed to [sqlite3_reset()] or 
+** [sqlite3_finalize()]).
+**
+** SQLite implements the command "DELETE FROM table" without
+** a WHERE clause by dropping and recreating the table.  (This is much
+** faster than going
+** through and deleting individual elements form the table.)  Because of
+** this optimization, the change count for "DELETE FROM table" will be
+** zero regardless of the number of elements that were originally in the
+** table. To get an accurate count of the number of rows deleted, use
+** "DELETE FROM table WHERE 1" instead.
+**
+** See also the [sqlite3_changes()] interface.
+**
+** INVARIANTS:
+** 
+** {F12261} The [sqlite3_total_changes()] returns the total number
+**          of row changes caused by INSERT, UPDATE, and/or DELETE
+**          statements on the same [database connection], in any
+**          trigger context, since the database connection was
+**          created.
+**
+** LIMITATIONS:
+**
+** {U12264} If a separate thread makes changes on the same database connection
+**          while [sqlite3_total_changes()] is running then the value 
+**          returned is unpredictable and unmeaningful.
+*/
+int sqlite3_total_changes(sqlite3*);
+
+/*
+** CAPI3REF: Interrupt A Long-Running Query {F12270}
+**
+** This function causes any pending database operation to abort and
+** return at its earliest opportunity. This routine is typically
+** called in response to a user action such as pressing "Cancel"
+** or Ctrl-C where the user wants a long query operation to halt
+** immediately.
+**
+** It is safe to call this routine from a thread different from the
+** thread that is currently running the database operation.  But it
+** is not safe to call this routine with a database connection that
+** is closed or might close before sqlite3_interrupt() returns.
+**
+** If an SQL is very nearly finished at the time when sqlite3_interrupt()
+** is called, then it might not have an opportunity to be interrupted.
+** It might continue to completion.
+** An SQL operation that is interrupted will return
+** [SQLITE_INTERRUPT].  If the interrupted SQL operation is an
+** INSERT, UPDATE, or DELETE that is inside an explicit transaction, 
+** then the entire transaction will be rolled back automatically.
+** A call to sqlite3_interrupt() has no effect on SQL statements
+** that are started after sqlite3_interrupt() returns.
+**
+** INVARIANTS:
+**
+** {F12271} The [sqlite3_interrupt()] interface will force all running
+**          SQL statements associated with the same database connection
+**          to halt after processing at most one additional row of
+**          data.
+**
+** {F12272} Any SQL statement that is interrupted by [sqlite3_interrupt()]
+**          will return [SQLITE_INTERRUPT].
+**
+** LIMITATIONS:
+**
+** {U12279} If the database connection closes while [sqlite3_interrupt()]
+**          is running then bad things will likely happen.
+*/
+void sqlite3_interrupt(sqlite3*);
+
+/*
+** CAPI3REF: Determine If An SQL Statement Is Complete {F10510}
+**
+** These routines are useful for command-line input to determine if the
+** currently entered text seems to form complete a SQL statement or
+** if additional input is needed before sending the text into
+** SQLite for parsing.  These routines return true if the input string
+** appears to be a complete SQL statement.  A statement is judged to be
+** complete if it ends with a semicolon token and is not a fragment of a
+** CREATE TRIGGER statement.  Semicolons that are embedded within
+** string literals or quoted identifier names or comments are not
+** independent tokens (they are part of the token in which they are
+** embedded) and thus do not count as a statement terminator.
+**
+** These routines do not parse the SQL and
+** so will not detect syntactically incorrect SQL.
+**
+** INVARIANTS:
+**
+** {F10511} The sqlite3_complete() and sqlite3_complete16() functions
+**          return true (non-zero) if and only if the last
+**          non-whitespace token in their input is a semicolon that
+**          is not in between the BEGIN and END of a CREATE TRIGGER
+**          statement.
+**
+** LIMITATIONS:
+**
+** {U10512} The input to sqlite3_complete() must be a zero-terminated
+**          UTF-8 string.
+**
+** {U10513} The input to sqlite3_complete16() must be a zero-terminated
+**          UTF-16 string in native byte order.
+*/
+int sqlite3_complete(const char *sql);
+int sqlite3_complete16(const void *sql);
+
+/*
+** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310}
+**
+** This routine identifies a callback function that might be
+** invoked whenever an attempt is made to open a database table 
+** that another thread or process has locked.
+** If the busy callback is NULL, then [SQLITE_BUSY]
+** or [SQLITE_IOERR_BLOCKED]
+** is returned immediately upon encountering the lock.
+** If the busy callback is not NULL, then the
+** callback will be invoked with two arguments.  The
+** first argument to the handler is a copy of the void* pointer which
+** is the third argument to this routine.  The second argument to
+** the handler is the number of times that the busy handler has
+** been invoked for this locking event.   If the
+** busy callback returns 0, then no additional attempts are made to
+** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
+** If the callback returns non-zero, then another attempt
+** is made to open the database for reading and the cycle repeats.
+**
+** The presence of a busy handler does not guarantee that
+** it will be invoked when there is lock contention.
+** If SQLite determines that invoking the busy handler could result in
+** a deadlock, it will go ahead and return [SQLITE_BUSY] or
+** [SQLITE_IOERR_BLOCKED] instead of invoking the
+** busy handler.
+** Consider a scenario where one process is holding a read lock that
+** it is trying to promote to a reserved lock and
+** a second process is holding a reserved lock that it is trying
+** to promote to an exclusive lock.  The first process cannot proceed
+** because it is blocked by the second and the second process cannot
+** proceed because it is blocked by the first.  If both processes
+** invoke the busy handlers, neither will make any progress.  Therefore,
+** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
+** will induce the first process to release its read lock and allow
+** the second process to proceed.
+**
+** The default busy callback is NULL.
+**
+** The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
+** when SQLite is in the middle of a large transaction where all the
+** changes will not fit into the in-memory cache.  SQLite will
+** already hold a RESERVED lock on the database file, but it needs
+** to promote this lock to EXCLUSIVE so that it can spill cache
+** pages into the database file without harm to concurrent
+** readers.  If it is unable to promote the lock, then the in-memory
+** cache will be left in an inconsistent state and so the error
+** code is promoted from the relatively benign [SQLITE_BUSY] to
+** the more severe [SQLITE_IOERR_BLOCKED].  This error code promotion
+** forces an automatic rollback of the changes.  See the
+** <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError">
+** CorruptionFollowingBusyError</a> wiki page for a discussion of why
+** this is important.
+**	
+** There can only be a single busy handler defined for each database
+** connection.  Setting a new busy handler clears any previous one. 
+** Note that calling [sqlite3_busy_timeout()] will also set or clear
+** the busy handler.
+**
+** INVARIANTS:
+**
+** {F12311} The [sqlite3_busy_handler()] function replaces the busy handler
+**          callback in the database connection identified by the 1st
+**          parameter with a new busy handler identified by the 2nd and 3rd
+**          parameters.
+**
+** {F12312} The default busy handler for new database connections is NULL.
+**
+** {F12314} When two or more database connection share a common cache,
+**          the busy handler for the database connection currently using
+**          the cache is invoked when the cache encounters a lock.
+**
+** {F12316} If a busy handler callback returns zero, then the SQLite
+**          interface that provoked the locking event will return
+**          [SQLITE_BUSY].
+**
+** {F12318} SQLite will invokes the busy handler with two argument which
+**          are a copy of the pointer supplied by the 3rd parameter to
+**          [sqlite3_busy_handler()] and a count of the number of prior
+**          invocations of the busy handler for the same locking event.
+**
+** LIMITATIONS:
+**
+** {U12319} A busy handler should not call close the database connection
+**          or prepared statement that invoked the busy handler.
+*/
+int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
+
+/*
+** CAPI3REF: Set A Busy Timeout {F12340}
+**
+** This routine sets a [sqlite3_busy_handler | busy handler]
+** that sleeps for a while when a
+** table is locked.  The handler will sleep multiple times until 
+** at least "ms" milliseconds of sleeping have been done. {F12343} After
+** "ms" milliseconds of sleeping, the handler returns 0 which
+** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
+**
+** Calling this routine with an argument less than or equal to zero
+** turns off all busy handlers.
+**
+** There can only be a single busy handler for a particular database
+** connection.  If another busy handler was defined  
+** (using [sqlite3_busy_handler()]) prior to calling
+** this routine, that other busy handler is cleared.
+**
+** INVARIANTS:
+**
+** {F12341} The [sqlite3_busy_timeout()] function overrides any prior
+**          [sqlite3_busy_timeout()] or [sqlite3_busy_handler()] setting
+**          on the same database connection.
+**
+** {F12343} If the 2nd parameter to [sqlite3_busy_timeout()] is less than
+**          or equal to zero, then the busy handler is cleared so that
+**          all subsequent locking events immediately return [SQLITE_BUSY].
+**
+** {F12344} If the 2nd parameter to [sqlite3_busy_timeout()] is a positive
+**          number N, then a busy handler is set that repeatedly calls
+**          the xSleep() method in the VFS interface until either the
+**          lock clears or until the cumulative sleep time reported back
+**          by xSleep() exceeds N milliseconds.
+*/
+int sqlite3_busy_timeout(sqlite3*, int ms);
+
+/*
+** CAPI3REF: Convenience Routines For Running Queries {F12370}
+**
+** Definition: A <b>result table</b> is memory data structure created by the
+** [sqlite3_get_table()] interface.  A result table records the
+** complete query results from one or more queries.
+**
+** The table conceptually has a number of rows and columns.  But
+** these numbers are not part of the result table itself.  These
+** numbers are obtained separately.  Let N be the number of rows
+** and M be the number of columns.
+**
+** A result table is an array of pointers to zero-terminated
+** UTF-8 strings.  There are (N+1)*M elements in the array.  
+** The first M pointers point to zero-terminated strings that 
+** contain the names of the columns.
+** The remaining entries all point to query results.  NULL
+** values are give a NULL pointer.  All other values are in
+** their UTF-8 zero-terminated string representation as returned by
+** [sqlite3_column_text()].
+**
+** A result table might consists of one or more memory allocations.
+** It is not safe to pass a result table directly to [sqlite3_free()].
+** A result table should be deallocated using [sqlite3_free_table()].
+**
+** As an example of the result table format, suppose a query result
+** is as follows:
+**
+** <blockquote><pre>
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+** </pre></blockquote>
+**
+** There are two column (M==2) and three rows (N==3).  Thus the
+** result table has 8 entries.  Suppose the result table is stored
+** in an array names azResult.  Then azResult holds this content:
+**
+** <blockquote><pre>
+**        azResult&#91;0] = "Name";
+**        azResult&#91;1] = "Age";
+**        azResult&#91;2] = "Alice";
+**        azResult&#91;3] = "43";
+**        azResult&#91;4] = "Bob";
+**        azResult&#91;5] = "28";
+**        azResult&#91;6] = "Cindy";
+**        azResult&#91;7] = "21";
+** </pre></blockquote>
+**
+** The sqlite3_get_table() function evaluates one or more
+** semicolon-separated SQL statements in the zero-terminated UTF-8
+** string of its 2nd parameter.  It returns a result table to the
+** pointer given in its 3rd parameter.
+**
+** After the calling function has finished using the result, it should 
+** pass the pointer to the result table to sqlite3_free_table() in order to 
+** release the memory that was malloc-ed.  Because of the way the 
+** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
+** function must not try to call [sqlite3_free()] directly.  Only 
+** [sqlite3_free_table()] is able to release the memory properly and safely.
+**
+** The sqlite3_get_table() interface is implemented as a wrapper around
+** [sqlite3_exec()].  The sqlite3_get_table() routine does not have access
+** to any internal data structures of SQLite.  It uses only the public
+** interface defined here.  As a consequence, errors that occur in the
+** wrapper layer outside of the internal [sqlite3_exec()] call are not
+** reflected in subsequent calls to [sqlite3_errcode()] or
+** [sqlite3_errmsg()].
+**
+** INVARIANTS:
+**
+** {F12371} If a [sqlite3_get_table()] fails a memory allocation, then
+**          it frees the result table under construction, aborts the
+**          query in process, skips any subsequent queries, sets the
+**          *resultp output pointer to NULL and returns [SQLITE_NOMEM].
+**
+** {F12373} If the ncolumn parameter to [sqlite3_get_table()] is not NULL
+**          then [sqlite3_get_table()] write the number of columns in the
+**          result set of the query into *ncolumn if the query is
+**          successful (if the function returns SQLITE_OK).
+**
+** {F12374} If the nrow parameter to [sqlite3_get_table()] is not NULL
+**          then [sqlite3_get_table()] write the number of rows in the
+**          result set of the query into *nrow if the query is
+**          successful (if the function returns SQLITE_OK).
+**
+** {F12376} The [sqlite3_get_table()] function sets its *ncolumn value
+**          to the number of columns in the result set of the query in the
+**          sql parameter, or to zero if the query in sql has an empty
+**          result set.
+*/
+int sqlite3_get_table(
+  sqlite3*,             /* An open database */
+  const char *sql,      /* SQL to be evaluated */
+  char ***pResult,      /* Results of the query */
+  int *nrow,            /* Number of result rows written here */
+  int *ncolumn,         /* Number of result columns written here */
+  char **errmsg         /* Error msg written here */
+);
+void sqlite3_free_table(char **result);
+
+/*
+** CAPI3REF: Formatted String Printing Functions {F17400}
+**
+** These routines are workalikes of the "printf()" family of functions
+** from the standard C library.
+**
+** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
+** results into memory obtained from [sqlite3_malloc()].
+** The strings returned by these two routines should be
+** released by [sqlite3_free()].   Both routines return a
+** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
+** memory to hold the resulting string.
+**
+** In sqlite3_snprintf() routine is similar to "snprintf()" from
+** the standard C library.  The result is written into the
+** buffer supplied as the second parameter whose size is given by
+** the first parameter. Note that the order of the
+** first two parameters is reversed from snprintf().  This is an
+** historical accident that cannot be fixed without breaking
+** backwards compatibility.  Note also that sqlite3_snprintf()
+** returns a pointer to its buffer instead of the number of
+** characters actually written into the buffer.  We admit that
+** the number of characters written would be a more useful return
+** value but we cannot change the implementation of sqlite3_snprintf()
+** now without breaking compatibility.
+**
+** As long as the buffer size is greater than zero, sqlite3_snprintf()
+** guarantees that the buffer is always zero-terminated.  The first
+** parameter "n" is the total size of the buffer, including space for
+** the zero terminator.  So the longest string that can be completely
+** written will be n-1 characters.
+**
+** These routines all implement some additional formatting
+** options that are useful for constructing SQL statements.
+** All of the usual printf formatting options apply.  In addition, there
+** is are "%q", "%Q", and "%z" options.
+**
+** The %q option works like %s in that it substitutes a null-terminated
+** string from the argument list.  But %q also doubles every '\'' character.
+** %q is designed for use inside a string literal.  By doubling each '\''
+** character it escapes that character and allows it to be inserted into
+** the string.
+**
+** For example, so some string variable contains text as follows:
+**
+** <blockquote><pre>
+**  char *zText = "It's a happy day!";
+** </pre></blockquote>
+**
+** One can use this text in an SQL statement as follows:
+**
+** <blockquote><pre>
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+** </pre></blockquote>
+**
+** Because the %q format string is used, the '\'' character in zText
+** is escaped and the SQL generated is as follows:
+**
+** <blockquote><pre>
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+** </pre></blockquote>
+**
+** This is correct.  Had we used %s instead of %q, the generated SQL
+** would have looked like this:
+**
+** <blockquote><pre>
+**  INSERT INTO table1 VALUES('It's a happy day!');
+** </pre></blockquote>
+**
+** This second example is an SQL syntax error.  As a general rule you
+** should always use %q instead of %s when inserting text into a string 
+** literal.
+**
+** The %Q option works like %q except it also adds single quotes around
+** the outside of the total string.  Or if the parameter in the argument
+** list is a NULL pointer, %Q substitutes the text "NULL" (without single
+** quotes) in place of the %Q option. {END}  So, for example, one could say:
+**
+** <blockquote><pre>
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+** </pre></blockquote>
+**
+** The code above will render a correct SQL statement in the zSQL
+** variable even if the zText variable is a NULL pointer.
+**
+** The "%z" formatting option works exactly like "%s" with the
+** addition that after the string has been read and copied into
+** the result, [sqlite3_free()] is called on the input string. {END}
+**
+** INVARIANTS:
+**
+** {F17403}  The [sqlite3_mprintf()] and [sqlite3_vmprintf()] interfaces
+**           return either pointers to zero-terminated UTF-8 strings held in
+**           memory obtained from [sqlite3_malloc()] or NULL pointers if
+**           a call to [sqlite3_malloc()] fails.
+**
+** {F17406}  The [sqlite3_snprintf()] interface writes a zero-terminated
+**           UTF-8 string into the buffer pointed to by the second parameter
+**           provided that the first parameter is greater than zero.
+**
+** {F17407}  The [sqlite3_snprintf()] interface does not writes slots of
+**           its output buffer (the second parameter) outside the range
+**           of 0 through N-1 (where N is the first parameter)
+**           regardless of the length of the string
+**           requested by the format specification.
+**   
+*/
+char *sqlite3_mprintf(const char*,...);
+char *sqlite3_vmprintf(const char*, va_list);
+char *sqlite3_snprintf(int,char*,const char*, ...);
+
+/*
+** CAPI3REF: Memory Allocation Subsystem {F17300}
+**
+** The SQLite core  uses these three routines for all of its own
+** internal memory allocation needs. "Core" in the previous sentence
+** does not include operating-system specific VFS implementation.  The
+** windows VFS uses native malloc and free for some operations.
+**
+** The sqlite3_malloc() routine returns a pointer to a block
+** of memory at least N bytes in length, where N is the parameter.
+** If sqlite3_malloc() is unable to obtain sufficient free
+** memory, it returns a NULL pointer.  If the parameter N to
+** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
+** a NULL pointer.
+**
+** Calling sqlite3_free() with a pointer previously returned
+** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
+** that it might be reused.  The sqlite3_free() routine is
+** a no-op if is called with a NULL pointer.  Passing a NULL pointer
+** to sqlite3_free() is harmless.  After being freed, memory
+** should neither be read nor written.  Even reading previously freed
+** memory might result in a segmentation fault or other severe error.
+** Memory corruption, a segmentation fault, or other severe error
+** might result if sqlite3_free() is called with a non-NULL pointer that
+** was not obtained from sqlite3_malloc() or sqlite3_free().
+**
+** The sqlite3_realloc() interface attempts to resize a
+** prior memory allocation to be at least N bytes, where N is the
+** second parameter.  The memory allocation to be resized is the first
+** parameter.  If the first parameter to sqlite3_realloc()
+** is a NULL pointer then its behavior is identical to calling
+** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
+** If the second parameter to sqlite3_realloc() is zero or
+** negative then the behavior is exactly the same as calling
+** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
+** Sqlite3_realloc() returns a pointer to a memory allocation
+** of at least N bytes in size or NULL if sufficient memory is unavailable.
+** If M is the size of the prior allocation, then min(N,M) bytes
+** of the prior allocation are copied into the beginning of buffer returned
+** by sqlite3_realloc() and the prior allocation is freed.
+** If sqlite3_realloc() returns NULL, then the prior allocation
+** is not freed.
+**
+** The memory returned by sqlite3_malloc() and sqlite3_realloc()
+** is always aligned to at least an 8 byte boundary. {END}
+**
+** The default implementation
+** of the memory allocation subsystem uses the malloc(), realloc()
+** and free() provided by the standard C library. {F17382} However, if 
+** SQLite is compiled with the following C preprocessor macro
+**
+** <blockquote> SQLITE_MEMORY_SIZE=<i>NNN</i> </blockquote>
+**
+** where <i>NNN</i> is an integer, then SQLite create a static
+** array of at least <i>NNN</i> bytes in size and use that array
+** for all of its dynamic memory allocation needs. {END}  Additional
+** memory allocator options may be added in future releases.
+**
+** In SQLite version 3.5.0 and 3.5.1, it was possible to define
+** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
+** implementation of these routines to be omitted.  That capability
+** is no longer provided.  Only built-in memory allocators can be
+** used.
+**
+** The windows OS interface layer calls
+** the system malloc() and free() directly when converting
+** filenames between the UTF-8 encoding used by SQLite
+** and whatever filename encoding is used by the particular windows
+** installation.  Memory allocation errors are detected, but
+** they are reported back as [SQLITE_CANTOPEN] or
+** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
+**
+** INVARIANTS:
+**
+** {F17303}  The [sqlite3_malloc(N)] interface returns either a pointer to 
+**           newly checked-out block of at least N bytes of memory
+**           that is 8-byte aligned, 
+**           or it returns NULL if it is unable to fulfill the request.
+**
+** {F17304}  The [sqlite3_malloc(N)] interface returns a NULL pointer if
+**           N is less than or equal to zero.
+**
+** {F17305}  The [sqlite3_free(P)] interface releases memory previously
+**           returned from [sqlite3_malloc()] or [sqlite3_realloc()],
+**           making it available for reuse.
+**
+** {F17306}  A call to [sqlite3_free(NULL)] is a harmless no-op.
+**
+** {F17310}  A call to [sqlite3_realloc(0,N)] is equivalent to a call
+**           to [sqlite3_malloc(N)].
+**
+** {F17312}  A call to [sqlite3_realloc(P,0)] is equivalent to a call
+**           to [sqlite3_free(P)].
+**
+** {F17315}  The SQLite core uses [sqlite3_malloc()], [sqlite3_realloc()],
+**           and [sqlite3_free()] for all of its memory allocation and
+**           deallocation needs.
+**
+** {F17318}  The [sqlite3_realloc(P,N)] interface returns either a pointer
+**           to a block of checked-out memory of at least N bytes in size
+**           that is 8-byte aligned, or a NULL pointer.
+**
+** {F17321}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
+**           copies the first K bytes of content from P into the newly allocated
+**           where K is the lessor of N and the size of the buffer P.
+**
+** {F17322}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first
+**           releases the buffer P.
+**
+** {F17323}  When [sqlite3_realloc(P,N)] returns NULL, the buffer P is
+**           not modified or released.
+**
+** LIMITATIONS:
+**
+** {U17350}  The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
+**           must be either NULL or else a pointer obtained from a prior
+**           invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that has
+**           not been released.
+**
+** {U17351}  The application must not read or write any part of 
+**           a block of memory after it has been released using
+**           [sqlite3_free()] or [sqlite3_realloc()].
+**
+*/
+void *sqlite3_malloc(int);
+void *sqlite3_realloc(void*, int);
+void sqlite3_free(void*);
+
+/*
+** CAPI3REF: Memory Allocator Statistics {F17370}
+**
+** SQLite provides these two interfaces for reporting on the status
+** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
+** the memory allocation subsystem included within the SQLite.
+**
+** INVARIANTS:
+**
+** {F17371} The [sqlite3_memory_used()] routine returns the
+**          number of bytes of memory currently outstanding 
+**          (malloced but not freed).
+**
+** {F17373} The [sqlite3_memory_highwater()] routine returns the maximum
+**          value of [sqlite3_memory_used()] 
+**          since the highwater mark was last reset.
+**
+** {F17374} The values returned by [sqlite3_memory_used()] and
+**          [sqlite3_memory_highwater()] include any overhead
+**          added by SQLite in its implementation of [sqlite3_malloc()],
+**          but not overhead added by the any underlying system library
+**          routines that [sqlite3_malloc()] may call.
+** 
+** {F17375} The memory highwater mark is reset to the current value of
+**          [sqlite3_memory_used()] if and only if the parameter to
+**          [sqlite3_memory_highwater()] is true.  The value returned
+**          by [sqlite3_memory_highwater(1)] is the highwater mark
+**          prior to the reset.
+*/
+sqlite3_int64 sqlite3_memory_used(void);
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
+
+/*
+** CAPI3REF: Compile-Time Authorization Callbacks {F12500}
+**
+** This routine registers a authorizer callback with a particular
+** database connection, supplied in the first argument.
+** The authorizer callback is invoked as SQL statements are being compiled
+** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
+** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  At various
+** points during the compilation process, as logic is being created
+** to perform various actions, the authorizer callback is invoked to
+** see if those actions are allowed.  The authorizer callback should
+** return SQLITE_OK to allow the action, [SQLITE_IGNORE] to disallow the
+** specific action but allow the SQL statement to continue to be
+** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
+** rejected with an error.   If the authorizer callback returns
+** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
+** then [sqlite3_prepare_v2()] or equivalent call that triggered
+** the authorizer will fail with an error message.
+**
+** When the callback returns [SQLITE_OK], that means the operation
+** requested is ok.  When the callback returns [SQLITE_DENY], the
+** [sqlite3_prepare_v2()] or equivalent call that triggered the
+** authorizer will fail with an error message explaining that
+** access is denied.  If the authorizer code is [SQLITE_READ]
+** and the callback returns [SQLITE_IGNORE] then the prepared
+** statement is constructed to insert a NULL value in place of
+** the table column that would have
+** been read if [SQLITE_OK] had been returned.  The [SQLITE_IGNORE]
+** return can be used to deny an untrusted user access to individual
+** columns of a table.
+**
+** The first parameter to the authorizer callback is a copy of
+** the third parameter to the sqlite3_set_authorizer() interface.
+** The second parameter to the callback is an integer 
+** [SQLITE_COPY | action code] that specifies the particular action
+** to be authorized. The third through sixth
+** parameters to the callback are zero-terminated strings that contain 
+** additional details about the action to be authorized.
+**
+** An authorizer is used when preparing SQL statements from an untrusted
+** source, to ensure that the SQL statements do not try to access data
+** that they are not allowed to see, or that they do not try to
+** execute malicious statements that damage the database.  For
+** example, an application may allow a user to enter arbitrary
+** SQL queries for evaluation by a database.  But the application does
+** not want the user to be able to make arbitrary changes to the
+** database.  An authorizer could then be put in place while the
+** user-entered SQL is being prepared that disallows everything
+** except SELECT statements.  
+**
+** Only a single authorizer can be in place on a database connection
+** at a time.  Each call to sqlite3_set_authorizer overrides the
+** previous call.  Disable the authorizer by installing a NULL callback.
+** The authorizer is disabled by default.
+**
+** Note that the authorizer callback is invoked only during 
+** [sqlite3_prepare()] or its variants.  Authorization is not
+** performed during statement evaluation in [sqlite3_step()].
+**
+** INVARIANTS:
+**
+** {F12501} The [sqlite3_set_authorizer(D,...)] interface registers a
+**          authorizer callback with database connection D.
+**
+** {F12502} The authorizer callback is invoked as SQL statements are
+**          being compiled
+**
+** {F12503} If the authorizer callback returns any value other than
+**          [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] then
+**          the [sqlite3_prepare_v2()] or equivalent call that caused
+**          the authorizer callback to run shall fail with an
+**          [SQLITE_ERROR] error code and an appropriate error message.
+**
+** {F12504} When the authorizer callback returns [SQLITE_OK], the operation
+**          described is coded normally.
+**
+** {F12505} When the authorizer callback returns [SQLITE_DENY], the
+**          [sqlite3_prepare_v2()] or equivalent call that caused the
+**          authorizer callback to run shall fail
+**          with an [SQLITE_ERROR] error code and an error message
+**          explaining that access is denied.
+**
+** {F12506} If the authorizer code (the 2nd parameter to the authorizer
+**          callback) is [SQLITE_READ] and the authorizer callback returns
+**          [SQLITE_IGNORE] then the prepared statement is constructed to
+**          insert a NULL value in place of the table column that would have
+**          been read if [SQLITE_OK] had been returned.
+**
+** {F12507} If the authorizer code (the 2nd parameter to the authorizer
+**          callback) is anything other than [SQLITE_READ], then
+**          a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. 
+**
+** {F12510} The first parameter to the authorizer callback is a copy of
+**          the third parameter to the [sqlite3_set_authorizer()] interface.
+**
+** {F12511} The second parameter to the callback is an integer 
+**          [SQLITE_COPY | action code] that specifies the particular action
+**          to be authorized.
+**
+** {F12512} The third through sixth parameters to the callback are
+**          zero-terminated strings that contain 
+**          additional details about the action to be authorized.
+**
+** {F12520} Each call to [sqlite3_set_authorizer()] overrides the
+**          any previously installed authorizer.
+**
+** {F12521} A NULL authorizer means that no authorization
+**          callback is invoked.
+**
+** {F12522} The default authorizer is NULL.
+*/
+int sqlite3_set_authorizer(
+  sqlite3*,
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
+  void *pUserData
+);
+
+/*
+** CAPI3REF: Authorizer Return Codes {F12590}
+**
+** The [sqlite3_set_authorizer | authorizer callback function] must
+** return either [SQLITE_OK] or one of these two constants in order
+** to signal SQLite whether or not the action is permitted.  See the
+** [sqlite3_set_authorizer | authorizer documentation] for additional
+** information.
+*/
+#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
+#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
+
+/*
+** CAPI3REF: Authorizer Action Codes {F12550}
+**
+** The [sqlite3_set_authorizer()] interface registers a callback function
+** that is invoked to authorizer certain SQL statement actions.  The
+** second parameter to the callback is an integer code that specifies
+** what action is being authorized.  These are the integer action codes that
+** the authorizer callback may be passed.
+**
+** These action code values signify what kind of operation is to be 
+** authorized.  The 3rd and 4th parameters to the authorization
+** callback function will be parameters or NULL depending on which of these
+** codes is used as the second parameter.  The 5th parameter to the
+** authorizer callback is the name of the database ("main", "temp", 
+** etc.) if applicable.  The 6th parameter to the authorizer callback
+** is the name of the inner-most trigger or view that is responsible for
+** the access attempt or NULL if this access attempt is directly from 
+** top-level SQL code.
+**
+** INVARIANTS:
+**
+** {F12551} The second parameter to an 
+**          [sqlite3_set_authorizer | authorizer callback is always an integer
+**          [SQLITE_COPY | authorizer code] that specifies what action
+**          is being authorized.
+**
+** {F12552} The 3rd and 4th parameters to the 
+**          [sqlite3_set_authorizer | authorization callback function]
+**          will be parameters or NULL depending on which 
+**          [SQLITE_COPY | authorizer code] is used as the second parameter.
+**
+** {F12553} The 5th parameter to the
+**          [sqlite3_set_authorizer | authorizer callback] is the name
+**          of the database (example: "main", "temp", etc.) if applicable.
+**
+** {F12554} The 6th parameter to the
+**          [sqlite3_set_authorizer | authorizer callback] is the name
+**          of the inner-most trigger or view that is responsible for
+**          the access attempt or NULL if this access attempt is directly from 
+**          top-level SQL code.
+*/
+/******************************************* 3rd ************ 4th ***********/
+#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
+#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
+#define SQLITE_DELETE                9   /* Table Name      NULL            */
+#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
+#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
+#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
+#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
+#define SQLITE_INSERT               18   /* Table Name      NULL            */
+#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
+#define SQLITE_READ                 20   /* Table Name      Column Name     */
+#define SQLITE_SELECT               21   /* NULL            NULL            */
+#define SQLITE_TRANSACTION          22   /* NULL            NULL            */
+#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
+#define SQLITE_ATTACH               24   /* Filename        NULL            */
+#define SQLITE_DETACH               25   /* Database Name   NULL            */
+#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
+#define SQLITE_REINDEX              27   /* Index Name      NULL            */
+#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
+#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
+#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
+#define SQLITE_FUNCTION             31   /* Function Name   NULL            */
+#define SQLITE_COPY                  0   /* No longer used */
+
+/*
+** CAPI3REF: Tracing And Profiling Functions {F12280}
+**
+** These routines register callback functions that can be used for
+** tracing and profiling the execution of SQL statements.
+**
+** The callback function registered by sqlite3_trace() is invoked at
+** various times when an SQL statement is being run by [sqlite3_step()].
+** The callback returns a UTF-8 rendering of the SQL statement text
+** as the statement first begins executing.  Additional callbacks occur
+** as each triggersubprogram is entered.  The callbacks for triggers
+** contain a UTF-8 SQL comment that identifies the trigger.
+** 
+** The callback function registered by sqlite3_profile() is invoked
+** as each SQL statement finishes.  The profile callback contains
+** the original statement text and an estimate of wall-clock time
+** of how long that statement took to run.
+**
+** The sqlite3_profile() API is currently considered experimental and
+** is subject to change or removal in a future release.
+**
+** The trigger reporting feature of the trace callback is considered
+** experimental and is subject to change or removal in future releases.
+** Future versions of SQLite might also add new trace callback 
+** invocations.
+**
+** INVARIANTS:
+**
+** {F12281} The callback function registered by [sqlite3_trace()] is
+**          whenever an SQL statement first begins to execute and
+**          whenever a trigger subprogram first begins to run.
+**
+** {F12282} Each call to [sqlite3_trace()] overrides the previously
+**          registered trace callback.
+**
+** {F12283} A NULL trace callback disables tracing.
+**
+** {F12284} The first argument to the trace callback is a copy of
+**          the pointer which was the 3rd argument to [sqlite3_trace()].
+**
+** {F12285} The second argument to the trace callback is a
+**          zero-terminated UTF8 string containing the original text
+**          of the SQL statement as it was passed into [sqlite3_prepare_v2()]
+**          or the equivalent, or an SQL comment indicating the beginning
+**          of a trigger subprogram.
+**
+** {F12287} The callback function registered by [sqlite3_profile()] is invoked
+**          as each SQL statement finishes.
+**
+** {F12288} The first parameter to the profile callback is a copy of
+**          the 3rd parameter to [sqlite3_profile()].
+**
+** {F12289} The second parameter to the profile callback is a
+**          zero-terminated UTF-8 string that contains the complete text of
+**          the SQL statement as it was processed by [sqlite3_prepare_v2()]
+**          or the equivalent.
+**
+** {F12290} The third parameter to the profile  callback is an estimate
+**          of the number of nanoseconds of wall-clock time required to
+**          run the SQL statement from start to finish.
+*/
+void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
+void *sqlite3_profile(sqlite3*,
+   void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
+
+/*
+** CAPI3REF: Query Progress Callbacks {F12910}
+**
+** This routine configures a callback function - the
+** progress callback - that is invoked periodically during long
+** running calls to [sqlite3_exec()], [sqlite3_step()] and
+** [sqlite3_get_table()].   An example use for this 
+** interface is to keep a GUI updated during a large query.
+**
+** If the progress callback returns non-zero, the opertion is
+** interrupted.  This feature can be used to implement a
+** "Cancel" button on a GUI dialog box.
+**
+** INVARIANTS:
+**
+** {F12911} The callback function registered by [sqlite3_progress_handler()]
+**          is invoked periodically during long running calls to
+**          [sqlite3_step()].
+**
+** {F12912} The progress callback is invoked once for every N virtual
+**          machine opcodes, where N is the second argument to 
+**          the [sqlite3_progress_handler()] call that registered
+**          the callback.  <todo>What if N is less than 1?</todo>
+**
+** {F12913} The progress callback itself is identified by the third
+**          argument to [sqlite3_progress_handler()].
+**
+** {F12914} The fourth argument [sqlite3_progress_handler()] is a
+***         void pointer passed to the progress callback
+**          function each time it is invoked.
+**
+** {F12915} If a call to [sqlite3_step()] results in fewer than
+**          N opcodes being executed,
+**          then the progress callback is never invoked. {END}
+** 
+** {F12916} Every call to [sqlite3_progress_handler()]
+**          overwrites any previously registere progress handler.
+**
+** {F12917} If the progress handler callback is NULL then no progress
+**          handler is invoked.
+**
+** {F12918} If the progress callback returns a result other than 0, then
+**          the behavior is a if [sqlite3_interrupt()] had been called.
+*/
+void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
+
+/*
+** CAPI3REF: Opening A New Database Connection {F12700}
+**
+** These routines open an SQLite database file whose name
+** is given by the filename argument.
+** The filename argument is interpreted as UTF-8
+** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16
+** in the native byte order for [sqlite3_open16()].
+** An [sqlite3*] handle is usually returned in *ppDb, even
+** if an error occurs.  The only exception is if SQLite is unable
+** to allocate memory to hold the [sqlite3] object, a NULL will
+** be written into *ppDb instead of a pointer to the [sqlite3] object.
+** If the database is opened (and/or created)
+** successfully, then [SQLITE_OK] is returned.  Otherwise an
+** error code is returned.  The
+** [sqlite3_errmsg()] or [sqlite3_errmsg16()]  routines can be used to obtain
+** an English language description of the error.
+**
+** The default encoding for the database will be UTF-8 if
+** [sqlite3_open()] or [sqlite3_open_v2()] is called and
+** UTF-16 in the native byte order if [sqlite3_open16()] is used.
+**
+** Whether or not an error occurs when it is opened, resources
+** associated with the [sqlite3*] handle should be released by passing it
+** to [sqlite3_close()] when it is no longer required.
+**
+** The [sqlite3_open_v2()] interface works like [sqlite3_open()] 
+** except that it acccepts two additional parameters for additional control
+** over the new database connection.  The flags parameter can be
+** one of:
+**
+** <ol>
+** <li>  [SQLITE_OPEN_READONLY]
+** <li>  [SQLITE_OPEN_READWRITE]
+** <li>  [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+** </ol>
+**
+** The first value opens the database read-only. 
+** If the database does not previously exist, an error is returned.
+** The second option opens
+** the database for reading and writing if possible, or reading only if
+** if the file is write protected.  In either case the database
+** must already exist or an error is returned.  The third option
+** opens the database for reading and writing and creates it if it does
+** not already exist.
+** The third options is behavior that is always used for [sqlite3_open()]
+** and [sqlite3_open16()].
+**
+** If the filename is ":memory:", then an private
+** in-memory database is created for the connection.  This in-memory
+** database will vanish when the database connection is closed.  Future
+** version of SQLite might make use of additional special filenames
+** that begin with the ":" character.  It is recommended that 
+** when a database filename really does begin with
+** ":" that you prefix the filename with a pathname like "./" to
+** avoid ambiguity.
+**
+** If the filename is an empty string, then a private temporary
+** on-disk database will be created.  This private database will be
+** automatically deleted as soon as the database connection is closed.
+**
+** The fourth parameter to sqlite3_open_v2() is the name of the
+** [sqlite3_vfs] object that defines the operating system 
+** interface that the new database connection should use.  If the
+** fourth parameter is a NULL pointer then the default [sqlite3_vfs]
+** object is used.
+**
+** <b>Note to windows users:</b>  The encoding used for the filename argument
+** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever
+** codepage is currently defined.  Filenames containing international
+** characters must be converted to UTF-8 prior to passing them into
+** [sqlite3_open()] or [sqlite3_open_v2()].
+**
+** INVARIANTS:
+**
+** {F12701} The [sqlite3_open()], [sqlite3_open16()], and
+**          [sqlite3_open_v2()] interfaces create a new
+**          [database connection] associated with
+**          the database file given in their first parameter.
+**
+** {F12702} The filename argument is interpreted as UTF-8
+**          for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16
+**          in the native byte order for [sqlite3_open16()].
+**
+** {F12703} A successful invocation of [sqlite3_open()], [sqlite3_open16()], 
+**          or [sqlite3_open_v2()] writes a pointer to a new
+**          [database connection] into *ppDb.
+**
+** {F12704} The [sqlite3_open()], [sqlite3_open16()], and
+**          [sqlite3_open_v2()] interfaces return [SQLITE_OK] upon success,
+**          or an appropriate [error code] on failure.
+**
+** {F12706} The default text encoding for a new database created using
+**          [sqlite3_open()] or [sqlite3_open_v2()] will be UTF-8.
+**
+** {F12707} The default text encoding for a new database created using
+**          [sqlite3_open16()] will be UTF-16.
+**
+** {F12709} The [sqlite3_open(F,D)] interface is equivalent to
+**          [sqlite3_open_v2(F,D,G,0)] where the G parameter is
+**          [SQLITE_OPEN_READWRITE]|[SQLITE_OPEN_CREATE].
+**
+** {F12711} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_READONLY] then the database is opened
+**          for reading only.
+**
+** {F12712} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_READWRITE] then the database is opened
+**          reading and writing if possible, or for reading only if the
+**          file is write protected by the operating system.
+**
+** {F12713} If the G parameter to [sqlite3_open(v2(F,D,G,V)] omits the
+**          bit value [SQLITE_OPEN_CREATE] and the database does not
+**          previously exist, an error is returned.
+**
+** {F12714} If the G parameter to [sqlite3_open(v2(F,D,G,V)] contains the
+**          bit value [SQLITE_OPEN_CREATE] and the database does not
+**          previously exist, then an attempt is made to create and
+**          initialize the database.
+**
+** {F12717} If the filename argument to [sqlite3_open()], [sqlite3_open16()],
+**          or [sqlite3_open_v2()] is ":memory:", then an private,
+**          ephemeral, in-memory database is created for the connection.
+**          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
+**          in sqlite3_open_v2()?</todo>
+**
+** {F12719} If the filename is an empty string, then a private, ephermeral
+**          on-disk database will be created.
+**          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required
+**          in sqlite3_open_v2()?</todo>
+**
+** {F12721} The [database connection] created by 
+**          [sqlite3_open_v2(F,D,G,V)] will use the
+**          [sqlite3_vfs] object identified by the V parameter, or
+**          the default [sqlite3_vfs] object is V is a NULL pointer.
+*/
+int sqlite3_open(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+int sqlite3_open16(
+  const void *filename,   /* Database filename (UTF-16) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+int sqlite3_open_v2(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb,         /* OUT: SQLite db handle */
+  int flags,              /* Flags */
+  const char *zVfs        /* Name of VFS module to use */
+);
+
+/*
+** CAPI3REF: Error Codes And Messages {F12800}
+**
+** The sqlite3_errcode() interface returns the numeric
+** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code]
+** for the most recent failed sqlite3_* API call associated
+** with [sqlite3] handle 'db'. If a prior API call failed but the
+** most recent API call succeeded, the return value from sqlite3_errcode()
+** is undefined.
+**
+** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
+** text that describes the error, as either UTF8 or UTF16 respectively.
+** Memory to hold the error message string is managed internally.
+** The application does not need to worry with freeing the result.
+** However, the error string might be overwritten or deallocated b
+** subsequent calls to other SQLite interface functions.
+**
+** INVARIANTS:
+**
+** {F12801} The [sqlite3_errcode(D)] interface returns the numeric
+**          [SQLITE_OK | result code] or
+**          [SQLITE_IOERR_READ | extended result code]
+**          for the most recent failed interface call associated
+**          with [sqlite3] handle D.
+**
+** {U12802} If a prior API call failed but the most recent API call
+**          succeeded, the return value from [sqlite3_errcode()],
+**          [sqlite3_errmsg()], and [sqlite3_errmsg16()] are undefined.
+**
+** {F12803} The [sqlite3_errmsg(D)] and [sqlite3_errmsg16(D)]
+**          interfaces return English-language text that describes
+**          the error in the mostly recently failed interface call,
+**          encoded as either UTF8 or UTF16 respectively.
+**
+** {U12804} The strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]
+**          are only valid until the next SQLite interface call.
+**
+** {F12807} Calls to [sqlite3_errcode()], [sqlite3_errmsg()], and
+**          [sqlite3_errmsg16()] themselves do not affect the
+**          results of future invocations of these routines.
+**
+** {F12808} Calls to API routines that do not return an error code
+**          (example: [sqlite3_data_count()]) do not
+**          change the error code or message returned by
+**          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].
+**
+** {F12809} Interfaces that are not associated with a specific
+**          [database connection] (examples:
+**          [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()]
+**          do not change the values returned by
+**          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].
+*/
+int sqlite3_errcode(sqlite3 *db);
+const char *sqlite3_errmsg(sqlite3*);
+const void *sqlite3_errmsg16(sqlite3*);
+
+/*
+** CAPI3REF: SQL Statement Object {F13000}
+** KEYWORDS: {prepared statement} {prepared statements}
+**
+** An instance of this object represent single SQL statements.  This
+** object is variously known as a "prepared statement" or a 
+** "compiled SQL statement" or simply as a "statement".
+** 
+** The life of a statement object goes something like this:
+**
+** <ol>
+** <li> Create the object using [sqlite3_prepare_v2()] or a related
+**      function.
+** <li> Bind values to host parameters using
+**      [sqlite3_bind_blob | sqlite3_bind_* interfaces].
+** <li> Run the SQL by calling [sqlite3_step()] one or more times.
+** <li> Reset the statement using [sqlite3_reset()] then go back
+**      to step 2.  Do this zero or more times.
+** <li> Destroy the object using [sqlite3_finalize()].
+** </ol>
+**
+** Refer to documentation on individual methods above for additional
+** information.
+*/
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+/*
+** CAPI3REF: Compiling An SQL Statement {F13010}
+**
+** To execute an SQL query, it must first be compiled into a byte-code
+** program using one of these routines. 
+**
+** The first argument "db" is an [database connection] 
+** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()]
+** or [sqlite3_open16()]. 
+** The second argument "zSql" is the statement to be compiled, encoded
+** as either UTF-8 or UTF-16.  The sqlite3_prepare() and sqlite3_prepare_v2()
+** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2()
+** use UTF-16. {END}
+**
+** If the nByte argument is less
+** than zero, then zSql is read up to the first zero terminator.
+** If nByte is non-negative, then it is the maximum number of 
+** bytes read from zSql.  When nByte is non-negative, the
+** zSql string ends at either the first '\000' or '\u0000' character or 
+** until the nByte-th byte, whichever comes first. {END}
+**
+** *pzTail is made to point to the first byte past the end of the
+** first SQL statement in zSql.  These routines only compiles the first
+** statement in zSql, so *pzTail is left pointing to what remains
+** uncompiled.
+**
+** *ppStmt is left pointing to a compiled [prepared statement] that can be
+** executed using [sqlite3_step()].  Or if there is an error, *ppStmt may be
+** set to NULL.  If the input text contains no SQL (if the input
+** is and empty string or a comment) then *ppStmt is set to NULL.
+** {U13018} The calling procedure is responsible for deleting the
+** compiled SQL statement
+** using [sqlite3_finalize()] after it has finished with it.
+**
+** On success, [SQLITE_OK] is returned.  Otherwise an 
+** [error code] is returned.
+**
+** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
+** recommended for all new programs. The two older interfaces are retained
+** for backwards compatibility, but their use is discouraged.
+** In the "v2" interfaces, the prepared statement
+** that is returned (the [sqlite3_stmt] object) contains a copy of the 
+** original SQL text. {END} This causes the [sqlite3_step()] interface to
+** behave a differently in two ways:
+**
+** <ol>
+** <li>
+** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
+** always used to do, [sqlite3_step()] will automatically recompile the SQL
+** statement and try to run it again.  If the schema has changed in
+** a way that makes the statement no longer valid, [sqlite3_step()] will still
+** return [SQLITE_SCHEMA].  But unlike the legacy behavior, 
+** [SQLITE_SCHEMA] is now a fatal error.  Calling
+** [sqlite3_prepare_v2()] again will not make the
+** error go away.  Note: use [sqlite3_errmsg()] to find the text
+** of the parsing error that results in an [SQLITE_SCHEMA] return. {END}
+** </li>
+**
+** <li>
+** When an error occurs, 
+** [sqlite3_step()] will return one of the detailed 
+** [error codes] or [extended error codes]. 
+** The legacy behavior was that [sqlite3_step()] would only return a generic
+** [SQLITE_ERROR] result code and you would have to make a second call to
+** [sqlite3_reset()] in order to find the underlying cause of the problem.
+** With the "v2" prepare interfaces, the underlying reason for the error is
+** returned immediately.
+** </li>
+** </ol>
+**
+** INVARIANTS:
+**
+** {F13011} The [sqlite3_prepare(db,zSql,...)] and
+**          [sqlite3_prepare_v2(db,zSql,...)] interfaces interpret the
+**          text in their zSql parameter as UTF-8.
+**
+** {F13012} The [sqlite3_prepare16(db,zSql,...)] and
+**          [sqlite3_prepare16_v2(db,zSql,...)] interfaces interpret the
+**          text in their zSql parameter as UTF-16 in the native byte order.
+**
+** {F13013} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)]
+**          and its variants is less than zero, then SQL text is
+**          read from zSql is read up to the first zero terminator.
+**
+** {F13014} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)]
+**          and its variants is non-negative, then nBytes bytes
+**          SQL text is read from zSql.
+**
+** {F13015} In [sqlite3_prepare_v2(db,zSql,N,P,pzTail)] and its variants
+**          if the zSql input text contains more than one SQL statement
+**          and pzTail is not NULL, then *pzTail is made to point to the
+**          first byte past the end of the first SQL statement in zSql.
+**          <todo>What does *pzTail point to if there is one statement?</todo>
+**
+** {F13016} A successful call to [sqlite3_prepare_v2(db,zSql,N,ppStmt,...)]
+**          or one of its variants writes into *ppStmt a pointer to a new
+**          [prepared statement] or a pointer to NULL
+**          if zSql contains nothing other than whitespace or comments. 
+**
+** {F13019} The [sqlite3_prepare_v2()] interface and its variants return
+**          [SQLITE_OK] or an appropriate [error code] upon failure.
+*/
+int sqlite3_prepare(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare_v2(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16_v2(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nByte,              /* Maximum length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+
+/*
+** CAPIREF: Retrieving Statement SQL {F13100}
+**
+** This intereface can be used to retrieve a saved copy of the original
+** SQL text used to create a [prepared statement].
+**
+** INVARIANTS:
+**
+** {F13101} If the [prepared statement] passed as 
+**          the an argument to [sqlite3_sql()] was compiled
+**          compiled using either [sqlite3_prepare_v2()] or
+**          [sqlite3_prepare16_v2()],
+**          then [sqlite3_sql()] function returns a pointer to a
+**          zero-terminated string containing a UTF-8 rendering
+**          of the original SQL statement.
+**
+** {F13102} If the [prepared statement] passed as 
+**          the an argument to [sqlite3_sql()] was compiled
+**          compiled using either [sqlite3_prepare()] or
+**          [sqlite3_prepare16()],
+**          then [sqlite3_sql()] function returns a NULL pointer.
+**
+** {F13103} The string returned by [sqlite3_sql(S)] is valid until the
+**          [prepared statement] S is deleted using [sqlite3_finalize(S)].
+*/
+const char *sqlite3_sql(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF:  Dynamically Typed Value Object  {F15000}
+**
+** SQLite uses the sqlite3_value object to represent all values
+** that are or can be stored in a database table.
+** SQLite uses dynamic typing for the values it stores.  
+** Values stored in sqlite3_value objects can be
+** be integers, floating point values, strings, BLOBs, or NULL.
+*/
+typedef struct Mem sqlite3_value;
+
+/*
+** CAPI3REF:  SQL Function Context Object {F16001}
+**
+** The context in which an SQL function executes is stored in an
+** sqlite3_context object.  A pointer to an sqlite3_context
+** object is always first parameter to application-defined SQL functions.
+*/
+typedef struct sqlite3_context sqlite3_context;
+
+/*
+** CAPI3REF:  Binding Values To Prepared Statements {F13500}
+**
+** In the SQL strings input to [sqlite3_prepare_v2()] and its
+** variants, literals may be replace by a parameter in one
+** of these forms:
+**
+** <ul>
+** <li>  ?
+** <li>  ?NNN
+** <li>  :VVV
+** <li>  @VVV
+** <li>  $VVV
+** </ul>
+**
+** In the parameter forms shown above NNN is an integer literal,
+** VVV alpha-numeric parameter name.
+** The values of these parameters (also called "host parameter names"
+** or "SQL parameters")
+** can be set using the sqlite3_bind_*() routines defined here.
+**
+** The first argument to the sqlite3_bind_*() routines always
+** is a pointer to the [sqlite3_stmt] object returned from
+** [sqlite3_prepare_v2()] or its variants. The second
+** argument is the index of the parameter to be set. The
+** first parameter has an index of 1.  When the same named
+** parameter is used more than once, second and subsequent
+** occurrences have the same index as the first occurrence. 
+** The index for named parameters can be looked up using the
+** [sqlite3_bind_parameter_name()] API if desired.  The index
+** for "?NNN" parameters is the value of NNN.
+** The NNN value must be between 1 and the compile-time
+** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999).
+**
+** The third argument is the value to bind to the parameter.
+**
+** In those
+** routines that have a fourth argument, its value is the number of bytes
+** in the parameter.  To be clear: the value is the number of <u>bytes</u>
+** in the value, not the number of characters.   The number
+** of bytes does not include the zero-terminator at the end of strings.
+** If the fourth parameter is negative, the length of the string is
+** number of bytes up to the first zero terminator.
+**
+** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
+** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
+** string after SQLite has finished with it. If the fifth argument is
+** the special value [SQLITE_STATIC], then SQLite assumes that the
+** information is in static, unmanaged space and does not need to be freed.
+** If the fifth argument has the value [SQLITE_TRANSIENT], then
+** SQLite makes its own private copy of the data immediately, before
+** the sqlite3_bind_*() routine returns.
+**
+** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
+** is filled with zeros.  A zeroblob uses a fixed amount of memory
+** (just an integer to hold it size) while it is being processed.
+** Zeroblobs are intended to serve as place-holders for BLOBs whose
+** content is later written using 
+** [sqlite3_blob_open | increment BLOB I/O] routines. A negative
+** value for the zeroblob results in a zero-length BLOB.
+**
+** The sqlite3_bind_*() routines must be called after
+** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and
+** before [sqlite3_step()].
+** Bindings are not cleared by the [sqlite3_reset()] routine.
+** Unbound parameters are interpreted as NULL.
+**
+** These routines return [SQLITE_OK] on success or an error code if
+** anything goes wrong.  [SQLITE_RANGE] is returned if the parameter
+** index is out of range.  [SQLITE_NOMEM] is returned if malloc fails.
+** [SQLITE_MISUSE] might be returned if these routines are called on a
+** virtual machine that is the wrong state or which has already been finalized.
+** Detection of misuse is unreliable.  Applications should not depend
+** on SQLITE_MISUSE returns.  SQLITE_MISUSE is intended to indicate a
+** a logic error in the application.  Future versions of SQLite might
+** panic rather than return SQLITE_MISUSE.
+**
+** See also: [sqlite3_bind_parameter_count()],
+** [sqlite3_bind_parameter_name()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13506} The [sqlite3_prepare | SQL statement compiler] recognizes
+**          tokens of the forms "?", "?NNN", "$VVV", ":VVV", and "@VVV"
+**          as SQL parameters, where NNN is any sequence of one or more
+**          digits and where VVV is any sequence of one or more 
+**          alphanumeric characters or "::" optionally followed by
+**          a string containing no spaces and contained within parentheses.
+**
+** {F13509} The initial value of an SQL parameter is NULL.
+**
+** {F13512} The index of an "?" SQL parameter is one larger than the
+**          largest index of SQL parameter to the left, or 1 if
+**          the "?" is the leftmost SQL parameter.
+**
+** {F13515} The index of an "?NNN" SQL parameter is the integer NNN.
+**
+** {F13518} The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is
+**          the same as the index of leftmost occurances of the same
+**          parameter, or one more than the largest index over all
+**          parameters to the left if this is the first occurrance
+**          of this parameter, or 1 if this is the leftmost parameter.
+**
+** {F13521} The [sqlite3_prepare | SQL statement compiler] fail with
+**          an [SQLITE_RANGE] error if the index of an SQL parameter
+**          is less than 1 or greater than SQLITE_MAX_VARIABLE_NUMBER.
+**
+** {F13524} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,V,...)]
+**          associate the value V with all SQL parameters having an
+**          index of N in the [prepared statement] S.
+**
+** {F13527} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,...)]
+**          override prior calls with the same values of S and N.
+**
+** {F13530} Bindings established by [sqlite3_bind_text | sqlite3_bind(S,...)]
+**          persist across calls to [sqlite3_reset(S)].
+**
+** {F13533} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds the first L
+**          bytes of the blob or string pointed to by V, when L
+**          is non-negative.
+**
+** {F13536} In calls to [sqlite3_bind_text(S,N,V,L,D)] or
+**          [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds characters
+**          from V through the first zero character when L is negative.
+**
+** {F13539} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is the special
+**          constant [SQLITE_STATIC], SQLite assumes that the value V
+**          is held in static unmanaged space that will not change
+**          during the lifetime of the binding.
+**
+** {F13542} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is the special
+**          constant [SQLITE_TRANSIENT], the routine makes a 
+**          private copy of V value before it returns.
+**
+** {F13545} In calls to [sqlite3_bind_blob(S,N,V,L,D)],
+**          [sqlite3_bind_text(S,N,V,L,D)], or
+**          [sqlite3_bind_text16(S,N,V,L,D)] when D is a pointer to
+**          a function, SQLite invokes that function to destroy the
+**          V value after it has finished using the V value.
+**
+** {F13548} In calls to [sqlite3_bind_zeroblob(S,N,V,L)] the value bound
+**          is a blob of L bytes, or a zero-length blob if L is negative.
+*/
+int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+int sqlite3_bind_double(sqlite3_stmt*, int, double);
+int sqlite3_bind_int(sqlite3_stmt*, int, int);
+int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
+int sqlite3_bind_null(sqlite3_stmt*, int);
+int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
+int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
+int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
+
+/*
+** CAPI3REF: Number Of SQL Parameters {F13600}
+**
+** This routine can be used to find the number of SQL parameters
+** in a prepared statement.  SQL parameters are tokens of the
+** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
+** place-holders for values that are [sqlite3_bind_blob | bound]
+** to the parameters at a later time.
+**
+** This routine actually returns the index of the largest parameter.
+** For all forms except ?NNN, this will correspond to the number of
+** unique parameters.  If parameters of the ?NNN are used, there may
+** be gaps in the list.
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_name()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13601} The [sqlite3_bind_parameter_count(S)] interface returns
+**          the largest index of all SQL parameters in the
+**          [prepared statement] S, or 0 if S
+**          contains no SQL parameters.
+*/
+int sqlite3_bind_parameter_count(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Name Of A Host Parameter {F13620}
+**
+** This routine returns a pointer to the name of the n-th
+** SQL parameter in a [prepared statement].
+** SQL parameters of the form ":AAA" or "@AAA" or "$AAA" have a name
+** which is the string ":AAA" or "@AAA" or "$VVV". 
+** In other words, the initial ":" or "$" or "@"
+** is included as part of the name.
+** Parameters of the form "?" or "?NNN" have no name.
+**
+** The first host parameter has an index of 1, not 0.
+**
+** If the value n is out of range or if the n-th parameter is
+** nameless, then NULL is returned.  The returned string is
+** always in the UTF-8 encoding even if the named parameter was
+** originally specified as UTF-16 in [sqlite3_prepare16()] or
+** [sqlite3_prepare16_v2()].
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_count()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13621} The [sqlite3_bind_parameter_name(S,N)] interface returns
+**          a UTF-8 rendering of the name of the SQL parameter in
+**          [prepared statement] S having index N, or
+**          NULL if there is no SQL parameter with index N or if the
+**          parameter with index N is an anonymous parameter "?" or
+**          a numbered parameter "?NNN".
+*/
+const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
+
+/*
+** CAPI3REF: Index Of A Parameter With A Given Name {F13640}
+**
+** Return the index of an SQL parameter given its name.  The
+** index value returned is suitable for use as the second
+** parameter to [sqlite3_bind_blob|sqlite3_bind()].  A zero
+** is returned if no matching parameter is found.  The parameter
+** name must be given in UTF-8 even if the original statement
+** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
+**
+** See also: [sqlite3_bind_blob|sqlite3_bind()],
+** [sqlite3_bind_parameter_count()], and
+** [sqlite3_bind_parameter_index()].
+**
+** INVARIANTS:
+**
+** {F13641} The [sqlite3_bind_parameter_index(S,N)] interface returns
+**          the index of SQL parameter in [prepared statement]
+**          S whose name matches the UTF-8 string N, or 0 if there is
+**          no match.
+*/
+int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
+
+/*
+** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660}
+**
+** Contrary to the intuition of many, [sqlite3_reset()] does not
+** reset the [sqlite3_bind_blob | bindings] on a 
+** [prepared statement].  Use this routine to
+** reset all host parameters to NULL.
+**
+** INVARIANTS:
+**
+** {F13661} The [sqlite3_clear_bindings(S)] interface resets all
+**          SQL parameter bindings in [prepared statement] S
+**          back to NULL.
+*/
+int sqlite3_clear_bindings(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Number Of Columns In A Result Set {F13710}
+**
+** Return the number of columns in the result set returned by the 
+** [prepared statement]. This routine returns 0
+** if pStmt is an SQL statement that does not return data (for 
+** example an UPDATE).
+**
+** INVARIANTS:
+**
+** {F13711} The [sqlite3_column_count(S)] interface returns the number of
+**          columns in the result set generated by the
+**          [prepared statement] S, or 0 if S does not generate
+**          a result set.
+*/
+int sqlite3_column_count(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Column Names In A Result Set {F13720}
+**
+** These routines return the name assigned to a particular column
+** in the result set of a SELECT statement.  The sqlite3_column_name()
+** interface returns a pointer to a zero-terminated UTF8 string
+** and sqlite3_column_name16() returns a pointer to a zero-terminated
+** UTF16 string.  The first parameter is the
+** [prepared statement] that implements the SELECT statement.
+** The second parameter is the column number.  The left-most column is
+** number 0.
+**
+** The returned string pointer is valid until either the 
+** [prepared statement] is destroyed by [sqlite3_finalize()]
+** or until the next call sqlite3_column_name() or sqlite3_column_name16()
+** on the same column.
+**
+** If sqlite3_malloc() fails during the processing of either routine
+** (for example during a conversion from UTF-8 to UTF-16) then a
+** NULL pointer is returned.
+**
+** The name of a result column is the value of the "AS" clause for
+** that column, if there is an AS clause.  If there is no AS clause
+** then the name of the column is unspecified and may change from
+** one release of SQLite to the next.
+**
+** INVARIANTS:
+**
+** {F13721} A successful invocation of the [sqlite3_column_name(S,N)]
+**          interface returns the name
+**          of the Nth column (where 0 is the left-most column) for the
+**          result set of [prepared statement] S as a
+**          zero-terminated UTF-8 string.
+**
+** {F13723} A successful invocation of the [sqlite3_column_name16(S,N)]
+**          interface returns the name
+**          of the Nth column (where 0 is the left-most column) for the
+**          result set of [prepared statement] S as a
+**          zero-terminated UTF-16 string in the native byte order.
+**
+** {F13724} The [sqlite3_column_name()] and [sqlite3_column_name16()]
+**          interfaces return a NULL pointer if they are unable to
+**          allocate memory memory to hold there normal return strings.
+**
+** {F13725} If the N parameter to [sqlite3_column_name(S,N)] or
+**          [sqlite3_column_name16(S,N)] is out of range, then the
+**          interfaces returns a NULL pointer.
+** 
+** {F13726} The strings returned by [sqlite3_column_name(S,N)] and
+**          [sqlite3_column_name16(S,N)] are valid until the next
+**          call to either routine with the same S and N parameters
+**          or until [sqlite3_finalize(S)] is called.
+**
+** {F13727} When a result column of a [SELECT] statement contains
+**          an AS clause, the name of that column is the indentifier
+**          to the right of the AS keyword.
+*/
+const char *sqlite3_column_name(sqlite3_stmt*, int N);
+const void *sqlite3_column_name16(sqlite3_stmt*, int N);
+
+/*
+** CAPI3REF: Source Of Data In A Query Result {F13740}
+**
+** These routines provide a means to determine what column of what
+** table in which database a result of a SELECT statement comes from.
+** The name of the database or table or column can be returned as
+** either a UTF8 or UTF16 string.  The _database_ routines return
+** the database name, the _table_ routines return the table name, and
+** the origin_ routines return the column name.
+** The returned string is valid until
+** the [prepared statement] is destroyed using
+** [sqlite3_finalize()] or until the same information is requested
+** again in a different encoding.
+**
+** The names returned are the original un-aliased names of the
+** database, table, and column.
+**
+** The first argument to the following calls is a [prepared statement].
+** These functions return information about the Nth column returned by 
+** the statement, where N is the second function argument.
+**
+** If the Nth column returned by the statement is an expression
+** or subquery and is not a column value, then all of these functions
+** return NULL.  These routine might also return NULL if a memory
+** allocation error occurs.  Otherwise, they return the 
+** name of the attached database, table and column that query result
+** column was extracted from.
+**
+** As with all other SQLite APIs, those postfixed with "16" return
+** UTF-16 encoded strings, the other functions return UTF-8. {END}
+**
+** These APIs are only available if the library was compiled with the 
+** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined.
+**
+** {U13751}
+** If two or more threads call one or more of these routines against the same
+** prepared statement and column at the same time then the results are
+** undefined.
+**
+** INVARIANTS:
+**
+** {F13741} The [sqlite3_column_database_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the database from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13742} The [sqlite3_column_database_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the database from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13743} The [sqlite3_column_table_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the table from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13744} The [sqlite3_column_table_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the table from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13745} The [sqlite3_column_origin_name(S,N)] interface returns either
+**          the UTF-8 zero-terminated name of the table column from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13746} The [sqlite3_column_origin_name16(S,N)] interface returns either
+**          the UTF-16 native byte order
+**          zero-terminated name of the table column from which the 
+**          Nth result column of [prepared statement] S 
+**          is extracted, or NULL if the the Nth column of S is a
+**          general expression or if unable to allocate memory
+**          to store the name.
+**          
+** {F13748} The return values from
+**          [sqlite3_column_database_name|column metadata interfaces]
+**          are valid
+**          for the lifetime of the [prepared statement]
+**          or until the encoding is changed by another metadata
+**          interface call for the same prepared statement and column.
+**
+** LIMITATIONS:
+**
+** {U13751} If two or more threads call one or more
+**          [sqlite3_column_database_name|column metadata interfaces]
+**          the same [prepared statement] and result column
+**          at the same time then the results are undefined.
+*/
+const char *sqlite3_column_database_name(sqlite3_stmt*,int);
+const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_table_name(sqlite3_stmt*,int);
+const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
+const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
+
+/*
+** CAPI3REF: Declared Datatype Of A Query Result {F13760}
+**
+** The first parameter is a [prepared statement]. 
+** If this statement is a SELECT statement and the Nth column of the 
+** returned result set of that SELECT is a table column (not an
+** expression or subquery) then the declared type of the table
+** column is returned.  If the Nth column of the result set is an
+** expression or subquery, then a NULL pointer is returned.
+** The returned string is always UTF-8 encoded.  {END} 
+** For example, in the database schema:
+**
+** CREATE TABLE t1(c1 VARIANT);
+**
+** And the following statement compiled:
+**
+** SELECT c1 + 1, c1 FROM t1;
+**
+** Then this routine would return the string "VARIANT" for the second
+** result column (i==1), and a NULL pointer for the first result column
+** (i==0).
+**
+** SQLite uses dynamic run-time typing.  So just because a column
+** is declared to contain a particular type does not mean that the
+** data stored in that column is of the declared type.  SQLite is
+** strongly typed, but the typing is dynamic not static.  Type
+** is associated with individual values, not with the containers
+** used to hold those values.
+**
+** INVARIANTS:
+**
+** {F13761}  A successful call to [sqlite3_column_decltype(S,N)]
+**           returns a zero-terminated UTF-8 string containing the
+**           the declared datatype of the table column that appears
+**           as the Nth column (numbered from 0) of the result set to the
+**           [prepared statement] S.
+**
+** {F13762}  A successful call to [sqlite3_column_decltype16(S,N)]
+**           returns a zero-terminated UTF-16 native byte order string
+**           containing the declared datatype of the table column that appears
+**           as the Nth column (numbered from 0) of the result set to the
+**           [prepared statement] S.
+**
+** {F13763}  If N is less than 0 or N is greater than or equal to
+**           the number of columns in [prepared statement] S
+**           or if the Nth column of S is an expression or subquery rather
+**           than a table column or if a memory allocation failure
+**           occurs during encoding conversions, then
+**           calls to [sqlite3_column_decltype(S,N)] or
+**           [sqlite3_column_decltype16(S,N)] return NULL.
+*/
+const char *sqlite3_column_decltype(sqlite3_stmt*,int);
+const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+
+/* 
+** CAPI3REF:  Evaluate An SQL Statement {F13200}
+**
+** After an [prepared statement] has been prepared with a call
+** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of
+** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()],
+** then this function must be called one or more times to evaluate the 
+** statement.
+**
+** The details of the behavior of this sqlite3_step() interface depend
+** on whether the statement was prepared using the newer "v2" interface
+** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
+** interface [sqlite3_prepare()] and [sqlite3_prepare16()].  The use of the
+** new "v2" interface is recommended for new applications but the legacy
+** interface will continue to be supported.
+**
+** In the lagacy interface, the return value will be either [SQLITE_BUSY], 
+** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
+** With the "v2" interface, any of the other [SQLITE_OK | result code]
+** or [SQLITE_IOERR_READ | extended result code] might be returned as
+** well.
+**
+** [SQLITE_BUSY] means that the database engine was unable to acquire the
+** database locks it needs to do its job.  If the statement is a COMMIT
+** or occurs outside of an explicit transaction, then you can retry the
+** statement.  If the statement is not a COMMIT and occurs within a
+** explicit transaction then you should rollback the transaction before
+** continuing.
+**
+** [SQLITE_DONE] means that the statement has finished executing
+** successfully.  sqlite3_step() should not be called again on this virtual
+** machine without first calling [sqlite3_reset()] to reset the virtual
+** machine back to its initial state.
+**
+** If the SQL statement being executed returns any data, then 
+** [SQLITE_ROW] is returned each time a new row of data is ready
+** for processing by the caller. The values may be accessed using
+** the [sqlite3_column_int | column access functions].
+** sqlite3_step() is called again to retrieve the next row of data.
+** 
+** [SQLITE_ERROR] means that a run-time error (such as a constraint
+** violation) has occurred.  sqlite3_step() should not be called again on
+** the VM. More information may be found by calling [sqlite3_errmsg()].
+** With the legacy interface, a more specific error code (example:
+** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
+** can be obtained by calling [sqlite3_reset()] on the
+** [prepared statement].  In the "v2" interface,
+** the more specific error code is returned directly by sqlite3_step().
+**
+** [SQLITE_MISUSE] means that the this routine was called inappropriately.
+** Perhaps it was called on a [prepared statement] that has
+** already been [sqlite3_finalize | finalized] or on one that had 
+** previously returned [SQLITE_ERROR] or [SQLITE_DONE].  Or it could
+** be the case that the same database connection is being used by two or
+** more threads at the same moment in time.
+**
+** <b>Goofy Interface Alert:</b>
+** In the legacy interface, 
+** the sqlite3_step() API always returns a generic error code,
+** [SQLITE_ERROR], following any error other than [SQLITE_BUSY]
+** and [SQLITE_MISUSE].  You must call [sqlite3_reset()] or
+** [sqlite3_finalize()] in order to find one of the specific
+** [error codes] that better describes the error.
+** We admit that this is a goofy design.  The problem has been fixed
+** with the "v2" interface.  If you prepare all of your SQL statements
+** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
+** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the 
+** more specific [error codes] are returned directly
+** by sqlite3_step().  The use of the "v2" interface is recommended.
+**
+** INVARIANTS:
+**
+** {F13202}  If [prepared statement] S is ready to be
+**           run, then [sqlite3_step(S)] advances that prepared statement
+**           until to completion or until it is ready to return another
+**           row of the result set or an interrupt or run-time error occurs.
+**
+** {F15304}  When a call to [sqlite3_step(S)] causes the 
+**           [prepared statement] S to run to completion,
+**           the function returns [SQLITE_DONE].
+**
+** {F15306}  When a call to [sqlite3_step(S)] stops because it is ready
+**           to return another row of the result set, it returns
+**           [SQLITE_ROW].
+**
+** {F15308}  If a call to [sqlite3_step(S)] encounters an
+**           [sqlite3_interrupt|interrupt] or a run-time error,
+**           it returns an appropraite error code that is not one of
+**           [SQLITE_OK], [SQLITE_ROW], or [SQLITE_DONE].
+**
+** {F15310}  If an [sqlite3_interrupt|interrupt] or run-time error
+**           occurs during a call to [sqlite3_step(S)]
+**           for a [prepared statement] S created using
+**           legacy interfaces [sqlite3_prepare()] or
+**           [sqlite3_prepare16()] then the function returns either
+**           [SQLITE_ERROR], [SQLITE_BUSY], or [SQLITE_MISUSE].
+*/
+int sqlite3_step(sqlite3_stmt*);
+
+/*
+** CAPI3REF: Number of columns in a result set {F13770}
+**
+** Return the number of values in the current row of the result set.
+**
+** INVARIANTS:
+**
+** {F13771}  After a call to [sqlite3_step(S)] that returns
+**           [SQLITE_ROW], the [sqlite3_data_count(S)] routine
+**           will return the same value as the
+**           [sqlite3_column_count(S)] function.
+**
+** {F13772}  After [sqlite3_step(S)] has returned any value other than
+**           [SQLITE_ROW] or before [sqlite3_step(S)] has been 
+**           called on the [prepared statement] for
+**           the first time since it was [sqlite3_prepare|prepared]
+**           or [sqlite3_reset|reset], the [sqlite3_data_count(S)]
+**           routine returns zero.
+*/
+int sqlite3_data_count(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Fundamental Datatypes {F10265}
+** KEYWORDS: SQLITE_TEXT
+**
+** {F10266}Every value in SQLite has one of five fundamental datatypes:
+**
+** <ul>
+** <li> 64-bit signed integer
+** <li> 64-bit IEEE floating point number
+** <li> string
+** <li> BLOB
+** <li> NULL
+** </ul> {END}
+**
+** These constants are codes for each of those types.
+**
+** Note that the SQLITE_TEXT constant was also used in SQLite version 2
+** for a completely different meaning.  Software that links against both
+** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not
+** SQLITE_TEXT.
+*/
+#define SQLITE_INTEGER  1
+#define SQLITE_FLOAT    2
+#define SQLITE_BLOB     4
+#define SQLITE_NULL     5
+#ifdef SQLITE_TEXT
+# undef SQLITE_TEXT
+#else
+# define SQLITE_TEXT     3
+#endif
+#define SQLITE3_TEXT     3
+
+/*
+** CAPI3REF: Results Values From A Query {F13800}
+**
+** These routines form the "result set query" interface.
+**
+** These routines return information about
+** a single column of the current result row of a query.  In every
+** case the first argument is a pointer to the 
+** [prepared statement] that is being
+** evaluated (the [sqlite3_stmt*] that was returned from 
+** [sqlite3_prepare_v2()] or one of its variants) and
+** the second argument is the index of the column for which information 
+** should be returned.  The left-most column of the result set
+** has an index of 0.
+**
+** If the SQL statement is not currently point to a valid row, or if the
+** the column index is out of range, the result is undefined. 
+** These routines may only be called when the most recent call to
+** [sqlite3_step()] has returned [SQLITE_ROW] and neither
+** [sqlite3_reset()] nor [sqlite3_finalize()] has been call subsequently.
+** If any of these routines are called after [sqlite3_reset()] or
+** [sqlite3_finalize()] or after [sqlite3_step()] has returned
+** something other than [SQLITE_ROW], the results are undefined.
+** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
+** are called from a different thread while any of these routines
+** are pending, then the results are undefined.  
+**
+** The sqlite3_column_type() routine returns 
+** [SQLITE_INTEGER | datatype code] for the initial data type
+** of the result column.  The returned value is one of [SQLITE_INTEGER],
+** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].  The value
+** returned by sqlite3_column_type() is only meaningful if no type
+** conversions have occurred as described below.  After a type conversion,
+** the value returned by sqlite3_column_type() is undefined.  Future
+** versions of SQLite may change the behavior of sqlite3_column_type()
+** following a type conversion.
+**
+** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() 
+** routine returns the number of bytes in that BLOB or string.
+** If the result is a UTF-16 string, then sqlite3_column_bytes() converts
+** the string to UTF-8 and then returns the number of bytes.
+** If the result is a numeric value then sqlite3_column_bytes() uses
+** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
+** the number of bytes in that string.
+** The value returned does not include the zero terminator at the end
+** of the string.  For clarity: the value returned is the number of
+** bytes in the string, not the number of characters.
+**
+** Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
+** even empty strings, are always zero terminated.  The return
+** value from sqlite3_column_blob() for a zero-length blob is an arbitrary
+** pointer, possibly even a NULL pointer.
+**
+** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
+** but leaves the result in UTF-16 in native byte order instead of UTF-8.  
+** The zero terminator is not included in this count.
+**
+** These routines attempt to convert the value where appropriate.  For
+** example, if the internal representation is FLOAT and a text result
+** is requested, [sqlite3_snprintf()] is used internally to do the conversion
+** automatically.  The following table details the conversions that
+** are applied:
+**
+** <blockquote>
+** <table border="1">
+** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
+**
+** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
+** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
+** <tr><td>  NULL    <td>   TEXT    <td> Result is NULL pointer
+** <tr><td>  NULL    <td>   BLOB    <td> Result is NULL pointer
+** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
+** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
+** <tr><td> INTEGER  <td>   BLOB    <td> Same as for INTEGER->TEXT
+** <tr><td>  FLOAT   <td> INTEGER   <td> Convert from float to integer
+** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
+** <tr><td>  FLOAT   <td>   BLOB    <td> Same as FLOAT->TEXT
+** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
+** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
+** <tr><td>  TEXT    <td>   BLOB    <td> No change
+** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
+** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
+** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
+** </table>
+** </blockquote>
+**
+** The table above makes reference to standard C library functions atoi()
+** and atof().  SQLite does not really use these functions.  It has its
+** on equavalent internal routines.  The atoi() and atof() names are
+** used in the table for brevity and because they are familiar to most
+** C programmers.
+**
+** Note that when type conversions occur, pointers returned by prior
+** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
+** sqlite3_column_text16() may be invalidated. 
+** Type conversions and pointer invalidations might occur
+** in the following cases:
+**
+** <ul>
+** <li><p>  The initial content is a BLOB and sqlite3_column_text() 
+**          or sqlite3_column_text16() is called.  A zero-terminator might
+**          need to be added to the string.</p></li>
+**
+** <li><p>  The initial content is UTF-8 text and sqlite3_column_bytes16() or
+**          sqlite3_column_text16() is called.  The content must be converted
+**          to UTF-16.</p></li>
+**
+** <li><p>  The initial content is UTF-16 text and sqlite3_column_bytes() or
+**          sqlite3_column_text() is called.  The content must be converted
+**          to UTF-8.</p></li>
+** </ul>
+**
+** Conversions between UTF-16be and UTF-16le are always done in place and do
+** not invalidate a prior pointer, though of course the content of the buffer
+** that the prior pointer points to will have been modified.  Other kinds
+** of conversion are done in place when it is possible, but sometime it is
+** not possible and in those cases prior pointers are invalidated.  
+**
+** The safest and easiest to remember policy is to invoke these routines
+** in one of the following ways:
+**
+**  <ul>
+**  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
+**  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
+**  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
+**  </ul>
+**
+** In other words, you should call sqlite3_column_text(), sqlite3_column_blob(),
+** or sqlite3_column_text16() first to force the result into the desired
+** format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to
+** find the size of the result.  Do not mix call to sqlite3_column_text() or
+** sqlite3_column_blob() with calls to sqlite3_column_bytes16().  And do not
+** mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes().
+**
+** The pointers returned are valid until a type conversion occurs as
+** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
+** [sqlite3_finalize()] is called.  The memory space used to hold strings
+** and blobs is freed automatically.  Do <b>not</b> pass the pointers returned
+** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into 
+** [sqlite3_free()].
+**
+** If a memory allocation error occurs during the evaluation of any
+** of these routines, a default value is returned.  The default value
+** is either the integer 0, the floating point number 0.0, or a NULL
+** pointer.  Subsequent calls to [sqlite3_errcode()] will return
+** [SQLITE_NOMEM].
+**
+** INVARIANTS:
+**
+** {F13803} The [sqlite3_column_blob(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a blob and then returns a
+**          pointer to the converted value.
+**
+** {F13806} The [sqlite3_column_bytes(S,N)] interface returns the
+**          number of bytes in the blob or string (exclusive of the
+**          zero terminator on the string) that was returned by the
+**          most recent call to [sqlite3_column_blob(S,N)] or
+**          [sqlite3_column_text(S,N)].
+**
+** {F13809} The [sqlite3_column_bytes16(S,N)] interface returns the
+**          number of bytes in the string (exclusive of the
+**          zero terminator on the string) that was returned by the
+**          most recent call to [sqlite3_column_text16(S,N)].
+**
+** {F13812} The [sqlite3_column_double(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a floating point value and
+**          returns a copy of that value.
+**
+** {F13815} The [sqlite3_column_int(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a 32-bit signed integer and
+**          returns a copy of that integer.
+**
+** {F13818} The [sqlite3_column_int64(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a 64-bit signed integer and
+**          returns a copy of that integer.
+**
+** {F13821} The [sqlite3_column_text(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a zero-terminated UTF-8 
+**          string and returns a pointer to that string.
+**
+** {F13824} The [sqlite3_column_text16(S,N)] interface converts the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S into a zero-terminated 2-byte
+**          aligned UTF-16 native byte order
+**          string and returns a pointer to that string.
+**
+** {F13827} The [sqlite3_column_type(S,N)] interface returns
+**          one of [SQLITE_NULL], [SQLITE_INTEGER], [SQLITE_FLOAT],
+**          [SQLITE_TEXT], or [SQLITE_BLOB] as appropriate for
+**          the Nth column in the current row of the result set for
+**          [prepared statement] S.
+**
+** {F13830} The [sqlite3_column_value(S,N)] interface returns a
+**          pointer to the [sqlite3_value] object that for the
+**          Nth column in the current row of the result set for
+**          [prepared statement] S.
+*/
+const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
+double sqlite3_column_double(sqlite3_stmt*, int iCol);
+int sqlite3_column_int(sqlite3_stmt*, int iCol);
+sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
+const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
+const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
+int sqlite3_column_type(sqlite3_stmt*, int iCol);
+sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
+
+/*
+** CAPI3REF: Destroy A Prepared Statement Object {F13300}
+**
+** The sqlite3_finalize() function is called to delete a 
+** [prepared statement]. If the statement was
+** executed successfully, or not executed at all, then SQLITE_OK is returned.
+** If execution of the statement failed then an 
+** [error code] or [extended error code]
+** is returned. 
+**
+** This routine can be called at any point during the execution of the
+** [prepared statement].  If the virtual machine has not 
+** completed execution when this routine is called, that is like
+** encountering an error or an interrupt.  (See [sqlite3_interrupt()].) 
+** Incomplete updates may be rolled back and transactions cancelled,  
+** depending on the circumstances, and the 
+** [error code] returned will be [SQLITE_ABORT].
+**
+** INVARIANTS:
+**
+** {F11302} The [sqlite3_finalize(S)] interface destroys the
+**          [prepared statement] S and releases all
+**          memory and file resources held by that object.
+**
+** {F11304} If the most recent call to [sqlite3_step(S)] for the
+**          [prepared statement] S returned an error,
+**          then [sqlite3_finalize(S)] returns that same error.
+*/
+int sqlite3_finalize(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Reset A Prepared Statement Object {F13330}
+**
+** The sqlite3_reset() function is called to reset a 
+** [prepared statement] object.
+** back to its initial state, ready to be re-executed.
+** Any SQL statement variables that had values bound to them using
+** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
+** Use [sqlite3_clear_bindings()] to reset the bindings.
+**
+** {F11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S
+**          back to the beginning of its program.
+**
+** {F11334} If the most recent call to [sqlite3_step(S)] for 
+**          [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
+**          or if [sqlite3_step(S)] has never before been called on S,
+**          then [sqlite3_reset(S)] returns [SQLITE_OK].
+**
+** {F11336} If the most recent call to [sqlite3_step(S)] for
+**          [prepared statement] S indicated an error, then
+**          [sqlite3_reset(S)] returns an appropriate [error code].
+**
+** {F11338} The [sqlite3_reset(S)] interface does not change the values
+**          of any [sqlite3_bind_blob|bindings] on [prepared statement] S.
+*/
+int sqlite3_reset(sqlite3_stmt *pStmt);
+
+/*
+** CAPI3REF: Create Or Redefine SQL Functions {F16100}
+** KEYWORDS: {function creation routines} 
+**
+** These two functions (collectively known as
+** "function creation routines") are used to add SQL functions or aggregates
+** or to redefine the behavior of existing SQL functions or aggregates.  The
+** difference only between the two is that the second parameter, the
+** name of the (scalar) function or aggregate, is encoded in UTF-8 for
+** sqlite3_create_function() and UTF-16 for sqlite3_create_function16().
+**
+** The first argument is the [database connection] that holds the
+** SQL function or aggregate is to be added or redefined. If a single
+** program uses more than one database handle internally, then SQL
+** functions or aggregates must be added individually to each database
+** handle with which they will be used.
+**
+** The second parameter is the name of the SQL function to be created
+** or redefined.
+** The length of the name is limited to 255 bytes, exclusive of the 
+** zero-terminator.  Note that the name length limit is in bytes, not
+** characters.  Any attempt to create a function with a longer name
+** will result in an SQLITE_ERROR error.
+**
+** The third parameter is the number of arguments that the SQL function or
+** aggregate takes. If this parameter is negative, then the SQL function or
+** aggregate may take any number of arguments.
+**
+** The fourth parameter, eTextRep, specifies what 
+** [SQLITE_UTF8 | text encoding] this SQL function prefers for
+** its parameters.  Any SQL function implementation should be able to work
+** work with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
+** more efficient with one encoding than another.  It is allowed to
+** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
+** times with the same function but with different values of eTextRep.
+** When multiple implementations of the same function are available, SQLite
+** will pick the one that involves the least amount of data conversion.
+** If there is only a single implementation which does not care what
+** text encoding is used, then the fourth argument should be
+** [SQLITE_ANY].
+**
+** The fifth parameter is an arbitrary pointer.  The implementation
+** of the function can gain access to this pointer using
+** [sqlite3_user_data()].
+**
+** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are
+** pointers to C-language functions that implement the SQL
+** function or aggregate. A scalar SQL function requires an implementation of
+** the xFunc callback only, NULL pointers should be passed as the xStep
+** and xFinal parameters. An aggregate SQL function requires an implementation
+** of xStep and xFinal and NULL should be passed for xFunc. To delete an
+** existing SQL function or aggregate, pass NULL for all three function
+** callback.
+**
+** It is permitted to register multiple implementations of the same
+** functions with the same name but with either differing numbers of
+** arguments or differing perferred text encodings.  SQLite will use
+** the implementation most closely matches the way in which the
+** SQL function is used.
+**
+** INVARIANTS:
+**
+** {F16103} The [sqlite3_create_function16()] interface behaves exactly
+**          like [sqlite3_create_function()] in every way except that it
+**          interprets the zFunctionName argument as
+**          zero-terminated UTF-16 native byte order instead of as a
+**          zero-terminated UTF-8.
+**
+** {F16106} 
+*/
+int sqlite3_create_function(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+int sqlite3_create_function16(
+  sqlite3 *db,
+  const void *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+
+/*
+** CAPI3REF: Text Encodings {F10267}
+**
+** These constant define integer codes that represent the various
+** text encodings supported by SQLite.
+*/
+#define SQLITE_UTF8           1
+#define SQLITE_UTF16LE        2
+#define SQLITE_UTF16BE        3
+#define SQLITE_UTF16          4    /* Use native byte order */
+#define SQLITE_ANY            5    /* sqlite3_create_function only */
+#define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
+
+/*
+** CAPI3REF: Obsolete Functions
+**
+** These functions are all now obsolete.  In order to maintain
+** backwards compatibility with older code, we continue to support
+** these functions.  However, new development projects should avoid
+** the use of these functions.  To help encourage people to avoid
+** using these functions, we are not going to tell you want they do.
+*/
+int sqlite3_aggregate_count(sqlite3_context*);
+int sqlite3_expired(sqlite3_stmt*);
+int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
+int sqlite3_global_recover(void);
+void sqlite3_thread_cleanup(void);
+int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
+
+/*
+** CAPI3REF: Obtaining SQL Function Parameter Values {F15100}
+**
+** The C-language implementation of SQL functions and aggregates uses
+** this set of interface routines to access the parameter values on
+** the function or aggregate.
+**
+** The xFunc (for scalar functions) or xStep (for aggregates) parameters
+** to [sqlite3_create_function()] and [sqlite3_create_function16()]
+** define callbacks that implement the SQL functions and aggregates.
+** The 4th parameter to these callbacks is an array of pointers to
+** [sqlite3_value] objects.  There is one [sqlite3_value] object for
+** each parameter to the SQL function.  These routines are used to
+** extract values from the [sqlite3_value] objects.
+**
+** These routines work just like the corresponding 
+** [sqlite3_column_blob | sqlite3_column_* routines] except that 
+** these routines take a single [sqlite3_value*] pointer instead
+** of an [sqlite3_stmt*] pointer and an integer column number.
+**
+** The sqlite3_value_text16() interface extracts a UTF16 string
+** in the native byte-order of the host machine.  The
+** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
+** extract UTF16 strings as big-endian and little-endian respectively.
+**
+** The sqlite3_value_numeric_type() interface attempts to apply
+** numeric affinity to the value.  This means that an attempt is
+** made to convert the value to an integer or floating point.  If
+** such a conversion is possible without loss of information (in other
+** words if the value is a string that looks like a number)
+** then the conversion is done.  Otherwise no conversion occurs.  The 
+** [SQLITE_INTEGER | datatype] after conversion is returned.
+**
+** Please pay particular attention to the fact that the pointer that
+** is returned from [sqlite3_value_blob()], [sqlite3_value_text()], or
+** [sqlite3_value_text16()] can be invalidated by a subsequent call to
+** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
+** or [sqlite3_value_text16()].  
+**
+** These routines must be called from the same thread as
+** the SQL function that supplied the sqlite3_value* parameters.
+** Or, if the sqlite3_value* argument comes from the [sqlite3_column_value()]
+** interface, then these routines should be called from the same thread
+** that ran [sqlite3_column_value()].
+**
+*/
+const void *sqlite3_value_blob(sqlite3_value*);
+int sqlite3_value_bytes(sqlite3_value*);
+int sqlite3_value_bytes16(sqlite3_value*);
+double sqlite3_value_double(sqlite3_value*);
+int sqlite3_value_int(sqlite3_value*);
+sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
+const unsigned char *sqlite3_value_text(sqlite3_value*);
+const void *sqlite3_value_text16(sqlite3_value*);
+const void *sqlite3_value_text16le(sqlite3_value*);
+const void *sqlite3_value_text16be(sqlite3_value*);
+int sqlite3_value_type(sqlite3_value*);
+int sqlite3_value_numeric_type(sqlite3_value*);
+
+/*
+** CAPI3REF: Obtain Aggregate Function Context {F16210}
+**
+** The implementation of aggregate SQL functions use this routine to allocate
+** a structure for storing their state.  
+** {F16211} The first time the sqlite3_aggregate_context() routine is
+** is called for a particular aggregate, SQLite allocates nBytes of memory
+** zeros that memory, and returns a pointer to it.
+** {F16212} On second and subsequent calls to sqlite3_aggregate_context()
+** for the same aggregate function index, the same buffer is returned. {END}
+** The implementation
+** of the aggregate can use the returned buffer to accumulate data.
+**
+** {F16213} SQLite automatically frees the allocated buffer when the aggregate
+** query concludes. {END}
+**
+** The first parameter should be a copy of the 
+** [sqlite3_context | SQL function context] that is the first
+** parameter to the callback routine that implements the aggregate
+** function.
+**
+** This routine must be called from the same thread in which
+** the aggregate SQL function is running.
+*/
+void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
+
+/*
+** CAPI3REF: User Data For Functions {F16240}
+**
+** {F16241} The sqlite3_user_data() interface returns a copy of
+** the pointer that was the pUserData parameter (the 5th parameter)
+** of the the [sqlite3_create_function()]
+** and [sqlite3_create_function16()] routines that originally
+** registered the application defined function. {END}
+**
+** {U16243} This routine must be called from the same thread in which
+** the application-defined function is running.
+*/
+void *sqlite3_user_data(sqlite3_context*);
+
+/*
+** CAPI3REF: Function Auxiliary Data {F16270}
+**
+** The following two functions may be used by scalar SQL functions to
+** associate meta-data with argument values. If the same value is passed to
+** multiple invocations of the same SQL function during query execution, under
+** some circumstances the associated meta-data may be preserved. This may
+** be used, for example, to add a regular-expression matching scalar
+** function. The compiled version of the regular expression is stored as
+** meta-data associated with the SQL value passed as the regular expression
+** pattern.  The compiled regular expression can be reused on multiple
+** invocations of the same function so that the original pattern string
+** does not need to be recompiled on each invocation.
+**
+** {F16271}
+** The sqlite3_get_auxdata() interface returns a pointer to the meta-data
+** associated by the sqlite3_set_auxdata() function with the Nth argument
+** value to the application-defined function.
+** {F16272} If no meta-data has been ever been set for the Nth
+** argument of the function, or if the cooresponding function parameter
+** has changed since the meta-data was set, then sqlite3_get_auxdata()
+** returns a NULL pointer.
+**
+** {F16275} The sqlite3_set_auxdata() interface saves the meta-data
+** pointed to by its 3rd parameter as the meta-data for the N-th
+** argument of the application-defined function. {END} Subsequent
+** calls to sqlite3_get_auxdata() might return this data, if it has
+** not been destroyed. 
+** {F16277} If it is not NULL, SQLite will invoke the destructor 
+** function given by the 4th parameter to sqlite3_set_auxdata() on
+** the meta-data when the corresponding function parameter changes
+** or when the SQL statement completes, whichever comes first. {END}
+**
+** In practice, meta-data is preserved between function calls for
+** expressions that are constant at compile time. This includes literal
+** values and SQL variables.
+**
+** These routines must be called from the same thread in which
+** the SQL function is running.
+*/
+void *sqlite3_get_auxdata(sqlite3_context*, int N);
+void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
+
+
+/*
+** CAPI3REF: Constants Defining Special Destructor Behavior {F10280}
+**
+** These are special value for the destructor that is passed in as the
+** final argument to routines like [sqlite3_result_blob()].  If the destructor
+** argument is SQLITE_STATIC, it means that the content pointer is constant
+** and will never change.  It does not need to be destroyed.  The 
+** SQLITE_TRANSIENT value means that the content will likely change in
+** the near future and that SQLite should make its own private copy of
+** the content before returning.
+**
+** The typedef is necessary to work around problems in certain
+** C++ compilers.  See ticket #2191.
+*/
+typedef void (*sqlite3_destructor_type)(void*);
+#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
+#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
+
+/*
+** CAPI3REF: Setting The Result Of An SQL Function {F16400}
+**
+** These routines are used by the xFunc or xFinal callbacks that
+** implement SQL functions and aggregates.  See
+** [sqlite3_create_function()] and [sqlite3_create_function16()]
+** for additional information.
+**
+** These functions work very much like the 
+** [sqlite3_bind_blob | sqlite3_bind_*] family of functions used
+** to bind values to host parameters in prepared statements.
+** Refer to the
+** [sqlite3_bind_blob | sqlite3_bind_* documentation] for
+** additional information.
+**
+** {F16402} The sqlite3_result_blob() interface sets the result from
+** an application defined function to be the BLOB whose content is pointed
+** to by the second parameter and which is N bytes long where N is the
+** third parameter. 
+** {F16403} The sqlite3_result_zeroblob() inerfaces set the result of
+** the application defined function to be a BLOB containing all zero
+** bytes and N bytes in size, where N is the value of the 2nd parameter.
+**
+** {F16407} The sqlite3_result_double() interface sets the result from
+** an application defined function to be a floating point value specified
+** by its 2nd argument.
+**
+** {F16409} The sqlite3_result_error() and sqlite3_result_error16() functions
+** cause the implemented SQL function to throw an exception.
+** {F16411} SQLite uses the string pointed to by the
+** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
+** as the text of an error message. {F16412} SQLite interprets the error
+** message string from sqlite3_result_error() as UTF8.  {F16413} SQLite
+** interprets the string from sqlite3_result_error16() as UTF16 in native
+** byte order.  {F16414} If the third parameter to sqlite3_result_error()
+** or sqlite3_result_error16() is negative then SQLite takes as the error
+** message all text up through the first zero character.
+** {F16415} If the third parameter to sqlite3_result_error() or
+** sqlite3_result_error16() is non-negative then SQLite takes that many
+** bytes (not characters) from the 2nd parameter as the error message.
+** {F16417} The sqlite3_result_error() and sqlite3_result_error16()
+** routines make a copy private copy of the error message text before
+** they return.  {END} Hence, the calling function can deallocate or
+** modify the text after they return without harm.
+** The sqlite3_result_error_code() function changes the error code
+** returned by SQLite as a result of an error in a function.  By default,
+** the error code is SQLITE_ERROR. 
+**
+** {F16421} The sqlite3_result_toobig() interface causes SQLite
+** to throw an error indicating that a string or BLOB is to long
+** to represent.  {F16422} The sqlite3_result_nomem() interface
+** causes SQLite to throw an exception indicating that the a
+** memory allocation failed.
+**
+** {F16431} The sqlite3_result_int() interface sets the return value
+** of the application-defined function to be the 32-bit signed integer
+** value given in the 2nd argument.
+** {F16432} The sqlite3_result_int64() interface sets the return value
+** of the application-defined function to be the 64-bit signed integer
+** value given in the 2nd argument.
+**
+** {F16437} The sqlite3_result_null() interface sets the return value
+** of the application-defined function to be NULL.
+**
+** {F16441} The sqlite3_result_text(), sqlite3_result_text16(), 
+** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
+** set the return value of the application-defined function to be
+** a text string which is represented as UTF-8, UTF-16 native byte order,
+** UTF-16 little endian, or UTF-16 big endian, respectively.
+** {F16442} SQLite takes the text result from the application from
+** the 2nd parameter of the sqlite3_result_text* interfaces.
+** {F16444} If the 3rd parameter to the sqlite3_result_text* interfaces
+** is negative, then SQLite takes result text from the 2nd parameter 
+** through the first zero character.
+** {F16447} If the 3rd parameter to the sqlite3_result_text* interfaces
+** is non-negative, then as many bytes (not characters) of the text
+** pointed to by the 2nd parameter are taken as the application-defined
+** function result.
+** {F16451} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
+** function as the destructor on the text or blob result when it has
+** finished using that result.
+** {F16453} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is the special constant SQLITE_STATIC, then
+** SQLite assumes that the text or blob result is constant space and
+** does not copy the space or call a destructor when it has
+** finished using that result.
+** {F16454} If the 4th parameter to the sqlite3_result_text* interfaces
+** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
+** then SQLite makes a copy of the result into space obtained from
+** from [sqlite3_malloc()] before it returns.
+**
+** {F16461} The sqlite3_result_value() interface sets the result of
+** the application-defined function to be a copy the [sqlite3_value]
+** object specified by the 2nd parameter.  {F16463} The
+** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
+** so that [sqlite3_value] specified in the parameter may change or
+** be deallocated after sqlite3_result_value() returns without harm.
+**
+** {U16491} These routines are called from within the different thread 
+** than the one containing the application-defined function that recieved
+** the [sqlite3_context] pointer, the results are undefined.
+*/
+void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
+void sqlite3_result_double(sqlite3_context*, double);
+void sqlite3_result_error(sqlite3_context*, const char*, int);
+void sqlite3_result_error16(sqlite3_context*, const void*, int);
+void sqlite3_result_error_toobig(sqlite3_context*);
+void sqlite3_result_error_nomem(sqlite3_context*);
+void sqlite3_result_error_code(sqlite3_context*, int);
+void sqlite3_result_int(sqlite3_context*, int);
+void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
+void sqlite3_result_null(sqlite3_context*);
+void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
+void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
+void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
+void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
+void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
+void sqlite3_result_zeroblob(sqlite3_context*, int n);
+
+/*
+** CAPI3REF: Define New Collating Sequences {F16600}
+**
+** {F16601}
+** These functions are used to add new collation sequences to the
+** [sqlite3*] handle specified as the first argument. 
+**
+** {F16602}
+** The name of the new collation sequence is specified as a UTF-8 string
+** for sqlite3_create_collation() and sqlite3_create_collation_v2()
+** and a UTF-16 string for sqlite3_create_collation16(). {F16603} In all cases
+** the name is passed as the second function argument.
+**
+** {F16604}
+** The third argument may be one of the constants [SQLITE_UTF8],
+** [SQLITE_UTF16LE] or [SQLITE_UTF16BE], indicating that the user-supplied
+** routine expects to be passed pointers to strings encoded using UTF-8,
+** UTF-16 little-endian or UTF-16 big-endian respectively. {F16605} The
+** third argument might also be [SQLITE_UTF16_ALIGNED] to indicate that
+** the routine expects pointers to 16-bit word aligned strings
+** of UTF16 in the native byte order of the host computer.
+**
+** {F16607}
+** A pointer to the user supplied routine must be passed as the fifth
+** argument. {F16609} If it is NULL, this is the same as deleting the collation
+** sequence (so that SQLite cannot call it anymore).
+** {F16611} Each time the application
+** supplied function is invoked, it is passed a copy of the void* passed as
+** the fourth argument to sqlite3_create_collation() or
+** sqlite3_create_collation16() as its first parameter.
+**
+** {F16612}
+** The remaining arguments to the application-supplied routine are two strings,
+** each represented by a (length, data) pair and encoded in the encoding
+** that was passed as the third argument when the collation sequence was
+** registered. {END} The application defined collation routine should
+** return negative, zero or positive if
+** the first string is less than, equal to, or greater than the second
+** string. i.e. (STRING1 - STRING2).
+**
+** {F16615}
+** The sqlite3_create_collation_v2() works like sqlite3_create_collation()
+** excapt that it takes an extra argument which is a destructor for
+** the collation.  {F16617} The destructor is called when the collation is
+** destroyed and is passed a copy of the fourth parameter void* pointer
+** of the sqlite3_create_collation_v2().
+** {F16618}  Collations are destroyed when
+** they are overridden by later calls to the collation creation functions
+** or when the [sqlite3*] database handle is closed using [sqlite3_close()].
+*/
+int sqlite3_create_collation(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+int sqlite3_create_collation_v2(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*),
+  void(*xDestroy)(void*)
+);
+int sqlite3_create_collation16(
+  sqlite3*, 
+  const char *zName, 
+  int eTextRep, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+
+/*
+** CAPI3REF: Collation Needed Callbacks {F16700}
+**
+** {F16701}
+** To avoid having to register all collation sequences before a database
+** can be used, a single callback function may be registered with the
+** database handle to be called whenever an undefined collation sequence is
+** required.
+**
+** {F16702}
+** If the function is registered using the sqlite3_collation_needed() API,
+** then it is passed the names of undefined collation sequences as strings
+** encoded in UTF-8. {F16703} If sqlite3_collation_needed16() is used, the names
+** are passed as UTF-16 in machine native byte order. {F16704} A call to either
+** function replaces any existing callback.
+**
+** {F16705} When the callback is invoked, the first argument passed is a copy
+** of the second argument to sqlite3_collation_needed() or
+** sqlite3_collation_needed16(). {F16706} The second argument is the database
+** handle.  {F16707} The third argument is one of [SQLITE_UTF8],
+** [SQLITE_UTF16BE], or [SQLITE_UTF16LE], indicating the most
+** desirable form of the collation sequence function required.
+** {F16708} The fourth parameter is the name of the
+** required collation sequence. {END}
+**
+** The callback function should register the desired collation using
+** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
+** [sqlite3_create_collation_v2()].
+*/
+int sqlite3_collation_needed(
+  sqlite3*, 
+  void*, 
+  void(*)(void*,sqlite3*,int eTextRep,const char*)
+);
+int sqlite3_collation_needed16(
+  sqlite3*, 
+  void*,
+  void(*)(void*,sqlite3*,int eTextRep,const void*)
+);
+
+/*
+** Specify the key for an encrypted database.  This routine should be
+** called right after sqlite3_open().
+**
+** The code to implement this API is not available in the public release
+** of SQLite.
+*/
+int sqlite3_key(
+  sqlite3 *db,                   /* Database to be rekeyed */
+  const void *pKey, int nKey     /* The key */
+);
+
+/*
+** Change the key on an open database.  If the current database is not
+** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
+** database is decrypted.
+**
+** The code to implement this API is not available in the public release
+** of SQLite.
+*/
+int sqlite3_rekey(
+  sqlite3 *db,                   /* Database to be rekeyed */
+  const void *pKey, int nKey     /* The new key */
+);
+
+/*
+** CAPI3REF:  Suspend Execution For A Short Time {F10530}
+**
+** {F10531} The sqlite3_sleep() function
+** causes the current thread to suspend execution
+** for at least a number of milliseconds specified in its parameter.
+**
+** {F10532} If the operating system does not support sleep requests with 
+** millisecond time resolution, then the time will be rounded up to 
+** the nearest second. {F10533} The number of milliseconds of sleep actually 
+** requested from the operating system is returned.
+**
+** {F10534} SQLite implements this interface by calling the xSleep()
+** method of the default [sqlite3_vfs] object. {END}
+*/
+int sqlite3_sleep(int);
+
+/*
+** CAPI3REF:  Name Of The Folder Holding Temporary Files {F10310}
+**
+** If this global variable is made to point to a string which is
+** the name of a folder (a.ka. directory), then all temporary files
+** created by SQLite will be placed in that directory.  If this variable
+** is NULL pointer, then SQLite does a search for an appropriate temporary
+** file directory.
+**
+** It is not safe to modify this variable once a database connection
+** has been opened.  It is intended that this variable be set once
+** as part of process initialization and before any SQLite interface
+** routines have been call and remain unchanged thereafter.
+*/
+SQLITE_EXTERN char *sqlite3_temp_directory;
+
+/*
+** CAPI3REF:  Test To See If The Database Is In Auto-Commit Mode {F12930}
+**
+** The sqlite3_get_autocommit() interfaces returns non-zero or
+** zero if the given database connection is or is not in autocommit mode,
+** respectively.   Autocommit mode is on
+** by default.  Autocommit mode is disabled by a [BEGIN] statement.
+** Autocommit mode is reenabled by a [COMMIT] or [ROLLBACK].
+**
+** If certain kinds of errors occur on a statement within a multi-statement
+** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], 
+** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
+** transaction might be rolled back automatically.  The only way to
+** find out if SQLite automatically rolled back the transaction after
+** an error is to use this function.
+**
+** INVARIANTS:
+**
+** {F12931} The [sqlite3_get_autocommit()] interface returns non-zero or
+**          zero if the given database connection is or is not in autocommit
+**          mode, respectively.
+**
+** {F12932} Autocommit mode is on by default.
+**
+** {F12933} Autocommit mode is disabled by a successful [BEGIN] statement.
+**
+** {F12934} Autocommit mode is enabled by a successful [COMMIT] or [ROLLBACK]
+**          statement.
+** 
+**
+** LIMITATIONS:
+***
+** {U12936} If another thread changes the autocommit status of the database
+**          connection while this routine is running, then the return value
+**          is undefined.
+*/
+int sqlite3_get_autocommit(sqlite3*);
+
+/*
+** CAPI3REF:  Find The Database Handle Of A Prepared Statement {F13120}
+**
+** {F13121} The sqlite3_db_handle interface
+** returns the [sqlite3*] database handle to which a
+** [prepared statement] belongs.
+** {F13122} the database handle returned by sqlite3_db_handle
+** is the same database handle that was
+** the first argument to the [sqlite3_prepare_v2()] or its variants
+** that was used to create the statement in the first place.
+*/
+sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
+
+
+/*
+** CAPI3REF: Commit And Rollback Notification Callbacks {F12950}
+**
+** {F12951} The sqlite3_commit_hook() interface registers a callback
+** function to be invoked whenever a transaction is committed.
+** {F12952} Any callback set by a previous call to sqlite3_commit_hook()
+** for the same database connection is overridden.
+** {F12953} The sqlite3_rollback_hook() interface registers a callback
+** function to be invoked whenever a transaction is committed.
+** {F12954} Any callback set by a previous call to sqlite3_commit_hook()
+** for the same database connection is overridden.
+** {F12956} The pArg argument is passed through
+** to the callback.  {F12957} If the callback on a commit hook function 
+** returns non-zero, then the commit is converted into a rollback.
+**
+** {F12958} If another function was previously registered, its
+** pArg value is returned.  Otherwise NULL is returned.
+**
+** {F12959} Registering a NULL function disables the callback.
+**
+** {F12961} For the purposes of this API, a transaction is said to have been 
+** rolled back if an explicit "ROLLBACK" statement is executed, or
+** an error or constraint causes an implicit rollback to occur.
+** {F12962} The rollback callback is not invoked if a transaction is
+** automatically rolled back because the database connection is closed.
+** {F12964} The rollback callback is not invoked if a transaction is
+** rolled back because a commit callback returned non-zero.
+** <todo> Check on this </todo> {END}
+**
+** These are experimental interfaces and are subject to change.
+*/
+void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
+void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
+
+/*
+** CAPI3REF: Data Change Notification Callbacks {F12970}
+**
+** {F12971} The sqlite3_update_hook() interface
+** registers a callback function with the database connection identified by the 
+** first argument to be invoked whenever a row is updated, inserted or deleted.
+** {F12972} Any callback set by a previous call to this function for the same 
+** database connection is overridden.
+**
+** {F12974} The second argument is a pointer to the function to invoke when a 
+** row is updated, inserted or deleted. 
+** {F12976} The first argument to the callback is
+** a copy of the third argument to sqlite3_update_hook().
+** {F12977} The second callback 
+** argument is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
+** depending on the operation that caused the callback to be invoked.
+** {F12978} The third and 
+** fourth arguments to the callback contain pointers to the database and 
+** table name containing the affected row.
+** {F12979} The final callback parameter is 
+** the rowid of the row.
+** {F12981} In the case of an update, this is the rowid after 
+** the update takes place.
+**
+** {F12983} The update hook is not invoked when internal system tables are
+** modified (i.e. sqlite_master and sqlite_sequence).
+**
+** {F12984} If another function was previously registered, its pArg value
+** is returned.  {F12985} Otherwise NULL is returned.
+*/
+void *sqlite3_update_hook(
+  sqlite3*, 
+  void(*)(void *,int ,char const *,char const *,sqlite3_int64),
+  void*
+);
+
+/*
+** CAPI3REF:  Enable Or Disable Shared Pager Cache {F10330}
+**
+** {F10331}
+** This routine enables or disables the sharing of the database cache
+** and schema data structures between connections to the same database.
+** {F10332}
+** Sharing is enabled if the argument is true and disabled if the argument
+** is false.
+**
+** {F10333} Cache sharing is enabled and disabled
+** for an entire process. {END} This is a change as of SQLite version 3.5.0.
+** In prior versions of SQLite, sharing was
+** enabled or disabled for each thread separately.
+**
+** {F10334}
+** The cache sharing mode set by this interface effects all subsequent
+** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
+** {F10335} Existing database connections continue use the sharing mode
+** that was in effect at the time they were opened. {END}
+**
+** Virtual tables cannot be used with a shared cache.  {F10336} When shared
+** cache is enabled, the [sqlite3_create_module()] API used to register
+** virtual tables will always return an error. {END}
+**
+** {F10337} This routine returns [SQLITE_OK] if shared cache was
+** enabled or disabled successfully.  {F10338} An [error code]
+** is returned otherwise. {END}
+**
+** {F10339} Shared cache is disabled by default. {END} But this might change in
+** future releases of SQLite.  Applications that care about shared
+** cache setting should set it explicitly.
+*/
+int sqlite3_enable_shared_cache(int);
+
+/*
+** CAPI3REF:  Attempt To Free Heap Memory {F17340}
+**
+** {F17341} The sqlite3_release_memory() interface attempts to
+** free N bytes of heap memory by deallocating non-essential memory
+** allocations held by the database labrary. {END}  Memory used
+** to cache database pages to improve performance is an example of
+** non-essential memory.  {F16342} sqlite3_release_memory() returns
+** the number of bytes actually freed, which might be more or less
+** than the amount requested.
+*/
+int sqlite3_release_memory(int);
+
+/*
+** CAPI3REF:  Impose A Limit On Heap Size {F17350}
+**
+** {F16351} The sqlite3_soft_heap_limit() interface
+** places a "soft" limit on the amount of heap memory that may be allocated
+** by SQLite. {F16352} If an internal allocation is requested 
+** that would exceed the soft heap limit, [sqlite3_release_memory()] is
+** invoked one or more times to free up some space before the allocation
+** is made. {END}
+**
+** {F16353} The limit is called "soft", because if
+** [sqlite3_release_memory()] cannot
+** free sufficient memory to prevent the limit from being exceeded,
+** the memory is allocated anyway and the current operation proceeds.
+**
+** {F16354}
+** A negative or zero value for N means that there is no soft heap limit and
+** [sqlite3_release_memory()] will only be called when memory is exhausted.
+** {F16355} The default value for the soft heap limit is zero.
+**
+** SQLite makes a best effort to honor the soft heap limit.  
+** {F16356} But if the soft heap limit cannot honored, execution will
+** continue without error or notification. {END}  This is why the limit is 
+** called a "soft" limit.  It is advisory only.
+**
+** Prior to SQLite version 3.5.0, this routine only constrained the memory
+** allocated by a single thread - the same thread in which this routine
+** runs.  Beginning with SQLite version 3.5.0, the soft heap limit is
+** applied to all threads. {F16357} The value specified for the soft heap limit
+** is an upper bound on the total memory allocation for all threads. {END}  In
+** version 3.5.0 there is no mechanism for limiting the heap usage for
+** individual threads.
+*/
+void sqlite3_soft_heap_limit(int);
+
+/*
+** CAPI3REF:  Extract Metadata About A Column Of A Table {F12850}
+**
+** This routine
+** returns meta-data about a specific column of a specific database
+** table accessible using the connection handle passed as the first function 
+** argument.
+**
+** The column is identified by the second, third and fourth parameters to 
+** this function. The second parameter is either the name of the database
+** (i.e. "main", "temp" or an attached database) containing the specified
+** table or NULL. If it is NULL, then all attached databases are searched
+** for the table using the same algorithm as the database engine uses to 
+** resolve unqualified table references.
+**
+** The third and fourth parameters to this function are the table and column 
+** name of the desired column, respectively. Neither of these parameters 
+** may be NULL.
+**
+** Meta information is returned by writing to the memory locations passed as
+** the 5th and subsequent parameters to this function. Any of these 
+** arguments may be NULL, in which case the corresponding element of meta 
+** information is ommitted.
+**
+** <pre>
+** Parameter     Output Type      Description
+** -----------------------------------
+**
+**   5th         const char*      Data type
+**   6th         const char*      Name of the default collation sequence 
+**   7th         int              True if the column has a NOT NULL constraint
+**   8th         int              True if the column is part of the PRIMARY KEY
+**   9th         int              True if the column is AUTOINCREMENT
+** </pre>
+**
+**
+** The memory pointed to by the character pointers returned for the 
+** declaration type and collation sequence is valid only until the next 
+** call to any sqlite API function.
+**
+** If the specified table is actually a view, then an error is returned.
+**
+** If the specified column is "rowid", "oid" or "_rowid_" and an 
+** INTEGER PRIMARY KEY column has been explicitly declared, then the output 
+** parameters are set for the explicitly declared column. If there is no
+** explicitly declared IPK column, then the output parameters are set as 
+** follows:
+**
+** <pre>
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+** </pre>
+**
+** This function may load one or more schemas from database files. If an
+** error occurs during this process, or if the requested table or column
+** cannot be found, an SQLITE error code is returned and an error message
+** left in the database handle (to be retrieved using sqlite3_errmsg()).
+**
+** This API is only available if the library was compiled with the
+** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined.
+*/
+int sqlite3_table_column_metadata(
+  sqlite3 *db,                /* Connection handle */
+  const char *zDbName,        /* Database name or NULL */
+  const char *zTableName,     /* Table name */
+  const char *zColumnName,    /* Column name */
+  char const **pzDataType,    /* OUTPUT: Declared data type */
+  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
+  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
+  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
+  int *pAutoinc               /* OUTPUT: True if column is auto-increment */
+);
+
+/*
+** CAPI3REF: Load An Extension {F12600}
+**
+** {F12601} The sqlite3_load_extension() interface
+** attempts to load an SQLite extension library contained in the file
+** zFile. {F12602} The entry point is zProc. {F12603} zProc may be 0
+** in which case the name of the entry point defaults
+** to "sqlite3_extension_init".
+**
+** {F12604} The sqlite3_load_extension() interface shall
+** return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
+**
+** {F12605}
+** If an error occurs and pzErrMsg is not 0, then the
+** sqlite3_load_extension() interface shall attempt to fill *pzErrMsg with 
+** error message text stored in memory obtained from [sqlite3_malloc()].
+** {END}  The calling function should free this memory
+** by calling [sqlite3_free()].
+**
+** {F12606}
+** Extension loading must be enabled using [sqlite3_enable_load_extension()]
+** prior to calling this API or an error will be returned.
+*/
+int sqlite3_load_extension(
+  sqlite3 *db,          /* Load the extension into this database connection */
+  const char *zFile,    /* Name of the shared library containing extension */
+  const char *zProc,    /* Entry point.  Derived from zFile if 0 */
+  char **pzErrMsg       /* Put error message here if not 0 */
+);
+
+/*
+** CAPI3REF:  Enable Or Disable Extension Loading {F12620}
+**
+** So as not to open security holes in older applications that are
+** unprepared to deal with extension loading, and as a means of disabling
+** extension loading while evaluating user-entered SQL, the following
+** API is provided to turn the [sqlite3_load_extension()] mechanism on and
+** off.  {F12622} It is off by default. {END} See ticket #1863.
+**
+** {F12621} Call the sqlite3_enable_load_extension() routine
+** with onoff==1 to turn extension loading on
+** and call it with onoff==0 to turn it back off again. {END}
+*/
+int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
+
+/*
+** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640}
+**
+** {F12641} This function
+** registers an extension entry point that is automatically invoked
+** whenever a new database connection is opened using
+** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. {END}
+**
+** This API can be invoked at program startup in order to register
+** one or more statically linked extensions that will be available
+** to all new database connections.
+**
+** {F12642} Duplicate extensions are detected so calling this routine multiple
+** times with the same extension is harmless.
+**
+** {F12643} This routine stores a pointer to the extension in an array
+** that is obtained from sqlite_malloc(). {END} If you run a memory leak
+** checker on your program and it reports a leak because of this
+** array, then invoke [sqlite3_reset_auto_extension()] prior
+** to shutdown to free the memory.
+**
+** {F12644} Automatic extensions apply across all threads. {END}
+**
+** This interface is experimental and is subject to change or
+** removal in future releases of SQLite.
+*/
+int sqlite3_auto_extension(void *xEntryPoint);
+
+
+/*
+** CAPI3REF: Reset Automatic Extension Loading {F12660}
+**
+** {F12661} This function disables all previously registered
+** automatic extensions. {END}  This
+** routine undoes the effect of all prior [sqlite3_auto_extension()]
+** calls.
+**
+** {F12662} This call disabled automatic extensions in all threads. {END}
+**
+** This interface is experimental and is subject to change or
+** removal in future releases of SQLite.
+*/
+void sqlite3_reset_auto_extension(void);
+
+
+/*
+****** EXPERIMENTAL - subject to change without notice **************
+**
+** The interface to the virtual-table mechanism is currently considered
+** to be experimental.  The interface might change in incompatible ways.
+** If this is a problem for you, do not use the interface at this time.
+**
+** When the virtual-table mechanism stablizes, we will declare the
+** interface fixed, support it indefinitely, and remove this comment.
+*/
+
+/*
+** Structures used by the virtual table interface
+*/
+typedef struct sqlite3_vtab sqlite3_vtab;
+typedef struct sqlite3_index_info sqlite3_index_info;
+typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
+typedef struct sqlite3_module sqlite3_module;
+
+/*
+** A module is a class of virtual tables.  Each module is defined
+** by an instance of the following structure.  This structure consists
+** mostly of methods for the module.
+*/
+struct sqlite3_module {
+  int iVersion;
+  int (*xCreate)(sqlite3*, void *pAux,
+               int argc, const char *const*argv,
+               sqlite3_vtab **ppVTab, char**);
+  int (*xConnect)(sqlite3*, void *pAux,
+               int argc, const char *const*argv,
+               sqlite3_vtab **ppVTab, char**);
+  int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
+  int (*xDisconnect)(sqlite3_vtab *pVTab);
+  int (*xDestroy)(sqlite3_vtab *pVTab);
+  int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
+  int (*xClose)(sqlite3_vtab_cursor*);
+  int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
+                int argc, sqlite3_value **argv);
+  int (*xNext)(sqlite3_vtab_cursor*);
+  int (*xEof)(sqlite3_vtab_cursor*);
+  int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
+  int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
+  int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
+  int (*xBegin)(sqlite3_vtab *pVTab);
+  int (*xSync)(sqlite3_vtab *pVTab);
+  int (*xCommit)(sqlite3_vtab *pVTab);
+  int (*xRollback)(sqlite3_vtab *pVTab);
+  int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
+                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+                       void **ppArg);
+
+  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
+};
+
+/*
+** The sqlite3_index_info structure and its substructures is used to
+** pass information into and receive the reply from the xBestIndex
+** method of an sqlite3_module.  The fields under **Inputs** are the
+** inputs to xBestIndex and are read-only.  xBestIndex inserts its
+** results into the **Outputs** fields.
+**
+** The aConstraint[] array records WHERE clause constraints of the
+** form:
+**
+**         column OP expr
+**
+** Where OP is =, &lt;, &lt;=, &gt;, or &gt;=.  
+** The particular operator is stored
+** in aConstraint[].op.  The index of the column is stored in 
+** aConstraint[].iColumn.  aConstraint[].usable is TRUE if the
+** expr on the right-hand side can be evaluated (and thus the constraint
+** is usable) and false if it cannot.
+**
+** The optimizer automatically inverts terms of the form "expr OP column"
+** and makes other simplifications to the WHERE clause in an attempt to
+** get as many WHERE clause terms into the form shown above as possible.
+** The aConstraint[] array only reports WHERE clause terms in the correct
+** form that refer to the particular virtual table being queried.
+**
+** Information about the ORDER BY clause is stored in aOrderBy[].
+** Each term of aOrderBy records a column of the ORDER BY clause.
+**
+** The xBestIndex method must fill aConstraintUsage[] with information
+** about what parameters to pass to xFilter.  If argvIndex>0 then
+** the right-hand side of the corresponding aConstraint[] is evaluated
+** and becomes the argvIndex-th entry in argv.  If aConstraintUsage[].omit
+** is true, then the constraint is assumed to be fully handled by the
+** virtual table and is not checked again by SQLite.
+**
+** The idxNum and idxPtr values are recorded and passed into xFilter.
+** sqlite3_free() is used to free idxPtr if needToFreeIdxPtr is true.
+**
+** The orderByConsumed means that output from xFilter will occur in
+** the correct order to satisfy the ORDER BY clause so that no separate
+** sorting step is required.
+**
+** The estimatedCost value is an estimate of the cost of doing the
+** particular lookup.  A full scan of a table with N entries should have
+** a cost of N.  A binary search of a table of N entries should have a
+** cost of approximately log(N).
+*/
+struct sqlite3_index_info {
+  /* Inputs */
+  int nConstraint;           /* Number of entries in aConstraint */
+  struct sqlite3_index_constraint {
+     int iColumn;              /* Column on left-hand side of constraint */
+     unsigned char op;         /* Constraint operator */
+     unsigned char usable;     /* True if this constraint is usable */
+     int iTermOffset;          /* Used internally - xBestIndex should ignore */
+  } *aConstraint;            /* Table of WHERE clause constraints */
+  int nOrderBy;              /* Number of terms in the ORDER BY clause */
+  struct sqlite3_index_orderby {
+     int iColumn;              /* Column number */
+     unsigned char desc;       /* True for DESC.  False for ASC. */
+  } *aOrderBy;               /* The ORDER BY clause */
+
+  /* Outputs */
+  struct sqlite3_index_constraint_usage {
+    int argvIndex;           /* if >0, constraint is part of argv to xFilter */
+    unsigned char omit;      /* Do not code a test for this constraint */
+  } *aConstraintUsage;
+  int idxNum;                /* Number used to identify the index */
+  char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
+  int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
+  int orderByConsumed;       /* True if output is already ordered */
+  double estimatedCost;      /* Estimated cost of using this index */
+};
+#define SQLITE_INDEX_CONSTRAINT_EQ    2
+#define SQLITE_INDEX_CONSTRAINT_GT    4
+#define SQLITE_INDEX_CONSTRAINT_LE    8
+#define SQLITE_INDEX_CONSTRAINT_LT    16
+#define SQLITE_INDEX_CONSTRAINT_GE    32
+#define SQLITE_INDEX_CONSTRAINT_MATCH 64
+
+/*
+** This routine is used to register a new module name with an SQLite
+** connection.  Module names must be registered before creating new
+** virtual tables on the module, or before using preexisting virtual
+** tables of the module.
+*/
+int sqlite3_create_module(
+  sqlite3 *db,               /* SQLite connection to register module with */
+  const char *zName,         /* Name of the module */
+  const sqlite3_module *,    /* Methods for the module */
+  void *                     /* Client data for xCreate/xConnect */
+);
+
+/*
+** This routine is identical to the sqlite3_create_module() method above,
+** except that it allows a destructor function to be specified. It is
+** even more experimental than the rest of the virtual tables API.
+*/
+int sqlite3_create_module_v2(
+  sqlite3 *db,               /* SQLite connection to register module with */
+  const char *zName,         /* Name of the module */
+  const sqlite3_module *,    /* Methods for the module */
+  void *,                    /* Client data for xCreate/xConnect */
+  void(*xDestroy)(void*)     /* Module destructor function */
+);
+
+/*
+** Every module implementation uses a subclass of the following structure
+** to describe a particular instance of the module.  Each subclass will
+** be tailored to the specific needs of the module implementation.   The
+** purpose of this superclass is to define certain fields that are common
+** to all module implementations.
+**
+** Virtual tables methods can set an error message by assigning a
+** string obtained from sqlite3_mprintf() to zErrMsg.  The method should
+** take care that any prior string is freed by a call to sqlite3_free()
+** prior to assigning a new string to zErrMsg.  After the error message
+** is delivered up to the client application, the string will be automatically
+** freed by sqlite3_free() and the zErrMsg field will be zeroed.  Note
+** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field
+** since virtual tables are commonly implemented in loadable extensions which
+** do not have access to sqlite3MPrintf() or sqlite3Free().
+*/
+struct sqlite3_vtab {
+  const sqlite3_module *pModule;  /* The module for this virtual table */
+  int nRef;                       /* Used internally */
+  char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
+  /* Virtual table implementations will typically add additional fields */
+};
+
+/* Every module implementation uses a subclass of the following structure
+** to describe cursors that point into the virtual table and are used
+** to loop through the virtual table.  Cursors are created using the
+** xOpen method of the module.  Each module implementation will define
+** the content of a cursor structure to suit its own needs.
+**
+** This superclass exists in order to define fields of the cursor that
+** are common to all implementations.
+*/
+struct sqlite3_vtab_cursor {
+  sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
+  /* Virtual table implementations will typically add additional fields */
+};
+
+/*
+** The xCreate and xConnect methods of a module use the following API
+** to declare the format (the names and datatypes of the columns) of
+** the virtual tables they implement.
+*/
+int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable);
+
+/*
+** Virtual tables can provide alternative implementations of functions
+** using the xFindFunction method.  But global versions of those functions
+** must exist in order to be overloaded.
+**
+** This API makes sure a global version of a function with a particular
+** name and number of parameters exists.  If no such function exists
+** before this API is called, a new function is created.  The implementation
+** of the new function always causes an exception to be thrown.  So
+** the new function is not good for anything by itself.  Its only
+** purpose is to be a place-holder function that can be overloaded
+** by virtual tables.
+**
+** This API should be considered part of the virtual table interface,
+** which is experimental and subject to change.
+*/
+int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
+
+/*
+** The interface to the virtual-table mechanism defined above (back up
+** to a comment remarkably similar to this one) is currently considered
+** to be experimental.  The interface might change in incompatible ways.
+** If this is a problem for you, do not use the interface at this time.
+**
+** When the virtual-table mechanism stabilizes, we will declare the
+** interface fixed, support it indefinitely, and remove this comment.
+**
+****** EXPERIMENTAL - subject to change without notice **************
+*/
+
+/*
+** CAPI3REF: A Handle To An Open BLOB {F17800}
+**
+** An instance of the following opaque structure is used to 
+** represent an blob-handle.  A blob-handle is created by
+** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()].
+** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
+** can be used to read or write small subsections of the blob.
+** The [sqlite3_blob_bytes()] interface returns the size of the
+** blob in bytes.
+*/
+typedef struct sqlite3_blob sqlite3_blob;
+
+/*
+** CAPI3REF: Open A BLOB For Incremental I/O {F17810}
+**
+** {F17811} This interfaces opens a handle to the blob located
+** in row iRow,, column zColumn, table zTable in database zDb;
+** in other words,  the same blob that would be selected by:
+**
+** <pre>
+**     SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;
+** </pre> {END}
+**
+** {F17812} If the flags parameter is non-zero, the blob is opened for 
+** read and write access. If it is zero, the blob is opened for read 
+** access. {END}
+**
+** {F17813} On success, [SQLITE_OK] is returned and the new 
+** [sqlite3_blob | blob handle] is written to *ppBlob. 
+** {F17814} Otherwise an error code is returned and 
+** any value written to *ppBlob should not be used by the caller.
+** {F17815} This function sets the database-handle error code and message
+** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()].
+** <todo>We should go through and mark all interfaces that behave this
+** way with a similar statement</todo>
+*/
+int sqlite3_blob_open(
+  sqlite3*,
+  const char *zDb,
+  const char *zTable,
+  const char *zColumn,
+  sqlite3_int64 iRow,
+  int flags,
+  sqlite3_blob **ppBlob
+);
+
+/*
+** CAPI3REF:  Close A BLOB Handle {F17830}
+**
+** Close an open [sqlite3_blob | blob handle].
+**
+** {F17831} Closing a BLOB shall cause the current transaction to commit
+** if there are no other BLOBs, no pending prepared statements, and the
+** database connection is in autocommit mode.
+** {F17832} If any writes were made to the BLOB, they might be held in cache
+** until the close operation if they will fit. {END}
+** Closing the BLOB often forces the changes
+** out to disk and so if any I/O errors occur, they will likely occur
+** at the time when the BLOB is closed.  {F17833} Any errors that occur during
+** closing are reported as a non-zero return value.
+**
+** {F17839} The BLOB is closed unconditionally.  Even if this routine returns
+** an error code, the BLOB is still closed.
+*/
+int sqlite3_blob_close(sqlite3_blob *);
+
+/*
+** CAPI3REF:  Return The Size Of An Open BLOB {F17805}
+**
+** {F16806} Return the size in bytes of the blob accessible via the open 
+** [sqlite3_blob | blob-handle] passed as an argument.
+*/
+int sqlite3_blob_bytes(sqlite3_blob *);
+
+/*
+** CAPI3REF:  Read Data From A BLOB Incrementally {F17850}
+**
+** This function is used to read data from an open 
+** [sqlite3_blob | blob-handle] into a caller supplied buffer.
+** {F17851} n bytes of data are copied into buffer
+** z from the open blob, starting at offset iOffset.
+**
+** {F17852} If offset iOffset is less than n bytes from the end of the blob, 
+** [SQLITE_ERROR] is returned and no data is read.  {F17853} If n is
+** less than zero [SQLITE_ERROR] is returned and no data is read.
+**
+** {F17854} On success, SQLITE_OK is returned. Otherwise, an 
+** [error code] or an [extended error code] is returned.
+*/
+int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset);
+
+/*
+** CAPI3REF:  Write Data Into A BLOB Incrementally {F17870}
+**
+** This function is used to write data into an open 
+** [sqlite3_blob | blob-handle] from a user supplied buffer.
+** {F17871} n bytes of data are copied from the buffer
+** pointed to by z into the open blob, starting at offset iOffset.
+**
+** {F17872} If the [sqlite3_blob | blob-handle] passed as the first argument
+** was not opened for writing (the flags parameter to [sqlite3_blob_open()]
+*** was zero), this function returns [SQLITE_READONLY].
+**
+** {F17873} This function may only modify the contents of the blob; it is
+** not possible to increase the size of a blob using this API.
+** {F17874} If offset iOffset is less than n bytes from the end of the blob, 
+** [SQLITE_ERROR] is returned and no data is written.  {F17875} If n is
+** less than zero [SQLITE_ERROR] is returned and no data is written.
+**
+** {F17876} On success, SQLITE_OK is returned. Otherwise, an 
+** [error code] or an [extended error code] is returned.
+*/
+int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
+
+/*
+** CAPI3REF:  Virtual File System Objects {F11200}
+**
+** A virtual filesystem (VFS) is an [sqlite3_vfs] object
+** that SQLite uses to interact
+** with the underlying operating system.  Most builds come with a
+** single default VFS that is appropriate for the host computer.
+** New VFSes can be registered and existing VFSes can be unregistered.
+** The following interfaces are provided.
+**
+** {F11201} The sqlite3_vfs_find() interface returns a pointer to 
+** a VFS given its name.  {F11202} Names are case sensitive.
+** {F11203} Names are zero-terminated UTF-8 strings.
+** {F11204} If there is no match, a NULL
+** pointer is returned. {F11205} If zVfsName is NULL then the default 
+** VFS is returned. {END}
+**
+** {F11210} New VFSes are registered with sqlite3_vfs_register().
+** {F11211} Each new VFS becomes the default VFS if the makeDflt flag is set.
+** {F11212} The same VFS can be registered multiple times without injury.
+** {F11213} To make an existing VFS into the default VFS, register it again
+** with the makeDflt flag set. {U11214} If two different VFSes with the
+** same name are registered, the behavior is undefined.  {U11215} If a
+** VFS is registered with a name that is NULL or an empty string,
+** then the behavior is undefined.
+** 
+** {F11220} Unregister a VFS with the sqlite3_vfs_unregister() interface.
+** {F11221} If the default VFS is unregistered, another VFS is chosen as
+** the default.  The choice for the new VFS is arbitrary.
+*/
+sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
+int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
+int sqlite3_vfs_unregister(sqlite3_vfs*);
+
+/*
+** CAPI3REF: Mutexes {F17000}
+**
+** The SQLite core uses these routines for thread
+** synchronization.  Though they are intended for internal
+** use by SQLite, code that links against SQLite is
+** permitted to use any of these routines.
+**
+** The SQLite source code contains multiple implementations 
+** of these mutex routines.  An appropriate implementation
+** is selected automatically at compile-time.  The following
+** implementations are available in the SQLite core:
+**
+** <ul>
+** <li>   SQLITE_MUTEX_OS2
+** <li>   SQLITE_MUTEX_PTHREAD
+** <li>   SQLITE_MUTEX_W32
+** <li>   SQLITE_MUTEX_NOOP
+** </ul>
+**
+** The SQLITE_MUTEX_NOOP implementation is a set of routines 
+** that does no real locking and is appropriate for use in 
+** a single-threaded application.  The SQLITE_MUTEX_OS2,
+** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations
+** are appropriate for use on os/2, unix, and windows.
+** 
+** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
+** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
+** implementation is included with the library.  The
+** mutex interface routines defined here become external
+** references in the SQLite library for which implementations
+** must be provided by the application.  This facility allows an
+** application that links against SQLite to provide its own mutex
+** implementation without having to modify the SQLite core.
+**
+** {F17011} The sqlite3_mutex_alloc() routine allocates a new
+** mutex and returns a pointer to it. {F17012} If it returns NULL
+** that means that a mutex could not be allocated. {F17013} SQLite
+** will unwind its stack and return an error. {F17014} The argument
+** to sqlite3_mutex_alloc() is one of these integer constants:
+**
+** <ul>
+** <li>  SQLITE_MUTEX_FAST
+** <li>  SQLITE_MUTEX_RECURSIVE
+** <li>  SQLITE_MUTEX_STATIC_MASTER
+** <li>  SQLITE_MUTEX_STATIC_MEM
+** <li>  SQLITE_MUTEX_STATIC_MEM2
+** <li>  SQLITE_MUTEX_STATIC_PRNG
+** <li>  SQLITE_MUTEX_STATIC_LRU
+** </ul> {END}
+**
+** {F17015} The first two constants cause sqlite3_mutex_alloc() to create
+** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
+** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END}
+** The mutex implementation does not need to make a distinction
+** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
+** not want to.  {F17016} But SQLite will only request a recursive mutex in
+** cases where it really needs one.  {END} If a faster non-recursive mutex
+** implementation is available on the host platform, the mutex subsystem
+** might return such a mutex in response to SQLITE_MUTEX_FAST.
+**
+** {F17017} The other allowed parameters to sqlite3_mutex_alloc() each return
+** a pointer to a static preexisting mutex. {END}  Four static mutexes are
+** used by the current version of SQLite.  Future versions of SQLite
+** may add additional static mutexes.  Static mutexes are for internal
+** use by SQLite only.  Applications that use SQLite mutexes should
+** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
+** SQLITE_MUTEX_RECURSIVE.
+**
+** {F17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
+** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
+** returns a different mutex on every call.  {F17034} But for the static 
+** mutex types, the same mutex is returned on every call that has
+** the same type number. {END}
+**
+** {F17019} The sqlite3_mutex_free() routine deallocates a previously
+** allocated dynamic mutex. {F17020} SQLite is careful to deallocate every
+** dynamic mutex that it allocates. {U17021} The dynamic mutexes must not be in 
+** use when they are deallocated. {U17022} Attempting to deallocate a static
+** mutex results in undefined behavior. {F17023} SQLite never deallocates
+** a static mutex. {END}
+**
+** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
+** to enter a mutex. {F17024} If another thread is already within the mutex,
+** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
+** SQLITE_BUSY. {F17025}  The sqlite3_mutex_try() interface returns SQLITE_OK
+** upon successful entry.  {F17026} Mutexes created using
+** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
+** {F17027} In such cases the,
+** mutex must be exited an equal number of times before another thread
+** can enter.  {U17028} If the same thread tries to enter any other
+** kind of mutex more than once, the behavior is undefined.
+** {F17029} SQLite will never exhibit
+** such behavior in its own use of mutexes. {END}
+**
+** Some systems (ex: windows95) do not the operation implemented by
+** sqlite3_mutex_try().  On those systems, sqlite3_mutex_try() will
+** always return SQLITE_BUSY.  {F17030} The SQLite core only ever uses
+** sqlite3_mutex_try() as an optimization so this is acceptable behavior. {END}
+**
+** {F17031} The sqlite3_mutex_leave() routine exits a mutex that was
+** previously entered by the same thread.  {U17032} The behavior
+** is undefined if the mutex is not currently entered by the
+** calling thread or is not currently allocated.  {F17033} SQLite will
+** never do either. {END}
+**
+** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
+*/
+sqlite3_mutex *sqlite3_mutex_alloc(int);
+void sqlite3_mutex_free(sqlite3_mutex*);
+void sqlite3_mutex_enter(sqlite3_mutex*);
+int sqlite3_mutex_try(sqlite3_mutex*);
+void sqlite3_mutex_leave(sqlite3_mutex*);
+
+/*
+** CAPI3REF: Mutex Verifcation Routines {F17080}
+**
+** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
+** are intended for use inside assert() statements. {F17081} The SQLite core
+** never uses these routines except inside an assert() and applications
+** are advised to follow the lead of the core.  {F17082} The core only
+** provides implementations for these routines when it is compiled
+** with the SQLITE_DEBUG flag.  {U17087} External mutex implementations
+** are only required to provide these routines if SQLITE_DEBUG is
+** defined and if NDEBUG is not defined.
+**
+** {F17083} These routines should return true if the mutex in their argument
+** is held or not held, respectively, by the calling thread. {END}
+**
+** {X17084} The implementation is not required to provided versions of these
+** routines that actually work.
+** If the implementation does not provide working
+** versions of these routines, it should at least provide stubs
+** that always return true so that one does not get spurious
+** assertion failures. {END}
+**
+** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then
+** the routine should return 1.  {END} This seems counter-intuitive since
+** clearly the mutex cannot be held if it does not exist.  But the
+** the reason the mutex does not exist is because the build is not
+** using mutexes.  And we do not want the assert() containing the
+** call to sqlite3_mutex_held() to fail, so a non-zero return is
+** the appropriate thing to do.  {F17086} The sqlite3_mutex_notheld() 
+** interface should also return 1 when given a NULL pointer.
+*/
+int sqlite3_mutex_held(sqlite3_mutex*);
+int sqlite3_mutex_notheld(sqlite3_mutex*);
+
+/*
+** CAPI3REF: Mutex Types {F17001}
+**
+** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument
+** which is one of these integer constants. {END}
+*/
+#define SQLITE_MUTEX_FAST             0
+#define SQLITE_MUTEX_RECURSIVE        1
+#define SQLITE_MUTEX_STATIC_MASTER    2
+#define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
+#define SQLITE_MUTEX_STATIC_MEM2      4  /* sqlite3_release_memory() */
+#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
+#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
+
+/*
+** CAPI3REF: Low-Level Control Of Database Files {F11300}
+**
+** {F11301} The [sqlite3_file_control()] interface makes a direct call to the
+** xFileControl method for the [sqlite3_io_methods] object associated
+** with a particular database identified by the second argument. {F11302} The
+** name of the database is the name assigned to the database by the
+** <a href="lang_attach.html">ATTACH</a> SQL command that opened the
+** database. {F11303} To control the main database file, use the name "main"
+** or a NULL pointer. {F11304} The third and fourth parameters to this routine
+** are passed directly through to the second and third parameters of
+** the xFileControl method.  {F11305} The return value of the xFileControl
+** method becomes the return value of this routine.
+**
+** {F11306} If the second parameter (zDbName) does not match the name of any
+** open database file, then SQLITE_ERROR is returned. {F11307} This error
+** code is not remembered and will not be recalled by [sqlite3_errcode()]
+** or [sqlite3_errmsg()]. {U11308} The underlying xFileControl method might
+** also return SQLITE_ERROR.  {U11309} There is no way to distinguish between
+** an incorrect zDbName and an SQLITE_ERROR return from the underlying
+** xFileControl method. {END}
+**
+** See also: [SQLITE_FCNTL_LOCKSTATE]
+*/
+int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
+
+/*
+** CAPI3REF: Testing Interface {F11400}
+**
+** The sqlite3_test_control() interface is used to read out internal
+** state of SQLite and to inject faults into SQLite for testing
+** purposes.  The first parameter a operation code that determines
+** the number, meaning, and operation of all subsequent parameters.
+**
+** This interface is not for use by applications.  It exists solely
+** for verifying the correct operation of the SQLite library.  Depending
+** on how the SQLite library is compiled, this interface might not exist.
+**
+** The details of the operation codes, their meanings, the parameters
+** they take, and what they do are all subject to change without notice.
+** Unlike most of the SQLite API, this function is not guaranteed to
+** operate consistently from one release to the next.
+*/
+int sqlite3_test_control(int op, ...);
+
+/*
+** CAPI3REF: Testing Interface Operation Codes {F11410}
+**
+** These constants are the valid operation code parameters used
+** as the first argument to [sqlite3_test_control()].
+**
+** These parameters and their meansing are subject to change
+** without notice.  These values are for testing purposes only.
+** Applications should not use any of these parameters or the
+** [sqlite3_test_control()] interface.
+*/
+#define SQLITE_TESTCTRL_FAULT_CONFIG             1
+#define SQLITE_TESTCTRL_FAULT_FAILURES           2
+#define SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES    3
+#define SQLITE_TESTCTRL_FAULT_PENDING            4
+
+
+
+
+
+/*
+** Undo the hack that converts floating point types to integer for
+** builds on processors without floating point support.
+*/
+#ifdef SQLITE_OMIT_FLOATING_POINT
+# undef double
+#endif
+
+#ifdef __cplusplus
+}  /* End of the 'extern "C"' block */
+#endif
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/sqlite3ext.h b/client/src/thirdparty/sqlite-3.4.2/src/sqlite3ext.h
new file mode 100644
index 0000000..5d4c2de
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/sqlite3ext.h
@@ -0,0 +1,350 @@
+/*
+** 2006 June 7
+**
+** 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 header file defines the SQLite interface for use by
+** shared libraries that want to be imported as extensions into
+** an SQLite instance.  Shared libraries that intend to be loaded
+** as extensions by SQLite should #include this file instead of 
+** sqlite3.h.
+**
+** @(#) $Id: sqlite3ext.h,v 1.17 2007/08/31 16:11:36 drh Exp $
+*/
+#ifndef _SQLITE3EXT_H_
+#define _SQLITE3EXT_H_
+#include "sqlite3.h"
+
+typedef struct sqlite3_api_routines sqlite3_api_routines;
+
+/*
+** The following structure hold pointers to all of the SQLite API
+** routines.
+**
+** WARNING:  In order to maintain backwards compatibility, add new
+** interfaces to the end of this structure only.  If you insert new
+** interfaces in the middle of this structure, then older different
+** versions of SQLite will not be able to load each others shared
+** libraries!
+*/
+struct sqlite3_api_routines {
+  void * (*aggregate_context)(sqlite3_context*,int nBytes);
+  int  (*aggregate_count)(sqlite3_context*);
+  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
+  int  (*bind_double)(sqlite3_stmt*,int,double);
+  int  (*bind_int)(sqlite3_stmt*,int,int);
+  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
+  int  (*bind_null)(sqlite3_stmt*,int);
+  int  (*bind_parameter_count)(sqlite3_stmt*);
+  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
+  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
+  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
+  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
+  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
+  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
+  int  (*busy_timeout)(sqlite3*,int ms);
+  int  (*changes)(sqlite3*);
+  int  (*close)(sqlite3*);
+  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*));
+  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*));
+  const void * (*column_blob)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
+  int  (*column_count)(sqlite3_stmt*pStmt);
+  const char * (*column_database_name)(sqlite3_stmt*,int);
+  const void * (*column_database_name16)(sqlite3_stmt*,int);
+  const char * (*column_decltype)(sqlite3_stmt*,int i);
+  const void * (*column_decltype16)(sqlite3_stmt*,int);
+  double  (*column_double)(sqlite3_stmt*,int iCol);
+  int  (*column_int)(sqlite3_stmt*,int iCol);
+  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
+  const char * (*column_name)(sqlite3_stmt*,int);
+  const void * (*column_name16)(sqlite3_stmt*,int);
+  const char * (*column_origin_name)(sqlite3_stmt*,int);
+  const void * (*column_origin_name16)(sqlite3_stmt*,int);
+  const char * (*column_table_name)(sqlite3_stmt*,int);
+  const void * (*column_table_name16)(sqlite3_stmt*,int);
+  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
+  const void * (*column_text16)(sqlite3_stmt*,int iCol);
+  int  (*column_type)(sqlite3_stmt*,int iCol);
+  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
+  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
+  int  (*complete)(const char*sql);
+  int  (*complete16)(const void*sql);
+  int  (*create_collation)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*));
+  int  (*create_collation16)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*));
+  int  (*create_function)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
+  int  (*create_function16)(sqlite3*,const void*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
+  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
+  int  (*data_count)(sqlite3_stmt*pStmt);
+  sqlite3 * (*db_handle)(sqlite3_stmt*);
+  int (*declare_vtab)(sqlite3*,const char*);
+  int  (*enable_shared_cache)(int);
+  int  (*errcode)(sqlite3*db);
+  const char * (*errmsg)(sqlite3*);
+  const void * (*errmsg16)(sqlite3*);
+  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
+  int  (*expired)(sqlite3_stmt*);
+  int  (*finalize)(sqlite3_stmt*pStmt);
+  void  (*free)(void*);
+  void  (*free_table)(char**result);
+  int  (*get_autocommit)(sqlite3*);
+  void * (*get_auxdata)(sqlite3_context*,int);
+  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
+  int  (*global_recover)(void);
+  void  (*interruptx)(sqlite3*);
+  sqlite_int64  (*last_insert_rowid)(sqlite3*);
+  const char * (*libversion)(void);
+  int  (*libversion_number)(void);
+  void *(*malloc)(int);
+  char * (*mprintf)(const char*,...);
+  int  (*open)(const char*,sqlite3**);
+  int  (*open16)(const void*,sqlite3**);
+  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
+  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
+  void *(*realloc)(void*,int);
+  int  (*reset)(sqlite3_stmt*pStmt);
+  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_double)(sqlite3_context*,double);
+  void  (*result_error)(sqlite3_context*,const char*,int);
+  void  (*result_error16)(sqlite3_context*,const void*,int);
+  void  (*result_int)(sqlite3_context*,int);
+  void  (*result_int64)(sqlite3_context*,sqlite_int64);
+  void  (*result_null)(sqlite3_context*);
+  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
+  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_value)(sqlite3_context*,sqlite3_value*);
+  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
+  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,const char*,const char*),void*);
+  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
+  char * (*snprintf)(int,char*,const char*,...);
+  int  (*step)(sqlite3_stmt*);
+  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,char const**,char const**,int*,int*,int*);
+  void  (*thread_cleanup)(void);
+  int  (*total_changes)(sqlite3*);
+  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
+  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
+  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,sqlite_int64),void*);
+  void * (*user_data)(sqlite3_context*);
+  const void * (*value_blob)(sqlite3_value*);
+  int  (*value_bytes)(sqlite3_value*);
+  int  (*value_bytes16)(sqlite3_value*);
+  double  (*value_double)(sqlite3_value*);
+  int  (*value_int)(sqlite3_value*);
+  sqlite_int64  (*value_int64)(sqlite3_value*);
+  int  (*value_numeric_type)(sqlite3_value*);
+  const unsigned char * (*value_text)(sqlite3_value*);
+  const void * (*value_text16)(sqlite3_value*);
+  const void * (*value_text16be)(sqlite3_value*);
+  const void * (*value_text16le)(sqlite3_value*);
+  int  (*value_type)(sqlite3_value*);
+  char *(*vmprintf)(const char*,va_list);
+  /* Added ??? */
+  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
+  /* Added by 3.3.13 */
+  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  int (*clear_bindings)(sqlite3_stmt*);
+  /* Added by 3.4.1 */
+  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,void (*xDestroy)(void *));
+  /* Added by 3.5.0 */
+  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
+  int (*blob_bytes)(sqlite3_blob*);
+  int (*blob_close)(sqlite3_blob*);
+  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,int,sqlite3_blob**);
+  int (*blob_read)(sqlite3_blob*,void*,int,int);
+  int (*blob_write)(sqlite3_blob*,const void*,int,int);
+  int (*create_collation_v2)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*),void(*)(void*));
+  int (*file_control)(sqlite3*,const char*,int,void*);
+  sqlite3_int64 (*memory_highwater)(int);
+  sqlite3_int64 (*memory_used)(void);
+  sqlite3_mutex *(*mutex_alloc)(int);
+  void (*mutex_enter)(sqlite3_mutex*);
+  void (*mutex_free)(sqlite3_mutex*);
+  void (*mutex_leave)(sqlite3_mutex*);
+  int (*mutex_try)(sqlite3_mutex*);
+  int (*open_v2)(const char*,sqlite3**,int,const char*);
+  int (*release_memory)(int);
+  void (*result_error_nomem)(sqlite3_context*);
+  void (*result_error_toobig)(sqlite3_context*);
+  int (*sleep)(int);
+  void (*soft_heap_limit)(int);
+  sqlite3_vfs *(*vfs_find)(const char*);
+  int (*vfs_register)(sqlite3_vfs*,int);
+  int (*vfs_unregister)(sqlite3_vfs*);
+};
+
+/*
+** The following macros redefine the API routines so that they are
+** redirected throught the global sqlite3_api structure.
+**
+** This header file is also used by the loadext.c source file
+** (part of the main SQLite library - not an extension) so that
+** it can get access to the sqlite3_api_routines structure
+** definition.  But the main library does not want to redefine
+** the API.  So the redefinition macros are only valid if the
+** SQLITE_CORE macros is undefined.
+*/
+#ifndef SQLITE_CORE
+#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
+#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
+#define sqlite3_bind_blob              sqlite3_api->bind_blob
+#define sqlite3_bind_double            sqlite3_api->bind_double
+#define sqlite3_bind_int               sqlite3_api->bind_int
+#define sqlite3_bind_int64             sqlite3_api->bind_int64
+#define sqlite3_bind_null              sqlite3_api->bind_null
+#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
+#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
+#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
+#define sqlite3_bind_text              sqlite3_api->bind_text
+#define sqlite3_bind_text16            sqlite3_api->bind_text16
+#define sqlite3_bind_value             sqlite3_api->bind_value
+#define sqlite3_busy_handler           sqlite3_api->busy_handler
+#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
+#define sqlite3_changes                sqlite3_api->changes
+#define sqlite3_close                  sqlite3_api->close
+#define sqlite3_collation_needed       sqlite3_api->collation_needed
+#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
+#define sqlite3_column_blob            sqlite3_api->column_blob
+#define sqlite3_column_bytes           sqlite3_api->column_bytes
+#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
+#define sqlite3_column_count           sqlite3_api->column_count
+#define sqlite3_column_database_name   sqlite3_api->column_database_name
+#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
+#define sqlite3_column_decltype        sqlite3_api->column_decltype
+#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
+#define sqlite3_column_double          sqlite3_api->column_double
+#define sqlite3_column_int             sqlite3_api->column_int
+#define sqlite3_column_int64           sqlite3_api->column_int64
+#define sqlite3_column_name            sqlite3_api->column_name
+#define sqlite3_column_name16          sqlite3_api->column_name16
+#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
+#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
+#define sqlite3_column_table_name      sqlite3_api->column_table_name
+#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
+#define sqlite3_column_text            sqlite3_api->column_text
+#define sqlite3_column_text16          sqlite3_api->column_text16
+#define sqlite3_column_type            sqlite3_api->column_type
+#define sqlite3_column_value           sqlite3_api->column_value
+#define sqlite3_commit_hook            sqlite3_api->commit_hook
+#define sqlite3_complete               sqlite3_api->complete
+#define sqlite3_complete16             sqlite3_api->complete16
+#define sqlite3_create_collation       sqlite3_api->create_collation
+#define sqlite3_create_collation16     sqlite3_api->create_collation16
+#define sqlite3_create_function        sqlite3_api->create_function
+#define sqlite3_create_function16      sqlite3_api->create_function16
+#define sqlite3_create_module          sqlite3_api->create_module
+#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
+#define sqlite3_data_count             sqlite3_api->data_count
+#define sqlite3_db_handle              sqlite3_api->db_handle
+#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
+#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
+#define sqlite3_errcode                sqlite3_api->errcode
+#define sqlite3_errmsg                 sqlite3_api->errmsg
+#define sqlite3_errmsg16               sqlite3_api->errmsg16
+#define sqlite3_exec                   sqlite3_api->exec
+#define sqlite3_expired                sqlite3_api->expired
+#define sqlite3_finalize               sqlite3_api->finalize
+#define sqlite3_free                   sqlite3_api->free
+#define sqlite3_free_table             sqlite3_api->free_table
+#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
+#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
+#define sqlite3_get_table              sqlite3_api->get_table
+#define sqlite3_global_recover         sqlite3_api->global_recover
+#define sqlite3_interrupt              sqlite3_api->interruptx
+#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
+#define sqlite3_libversion             sqlite3_api->libversion
+#define sqlite3_libversion_number      sqlite3_api->libversion_number
+#define sqlite3_malloc                 sqlite3_api->malloc
+#define sqlite3_mprintf                sqlite3_api->mprintf
+#define sqlite3_open                   sqlite3_api->open
+#define sqlite3_open16                 sqlite3_api->open16
+#define sqlite3_prepare                sqlite3_api->prepare
+#define sqlite3_prepare16              sqlite3_api->prepare16
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_profile                sqlite3_api->profile
+#define sqlite3_progress_handler       sqlite3_api->progress_handler
+#define sqlite3_realloc                sqlite3_api->realloc
+#define sqlite3_reset                  sqlite3_api->reset
+#define sqlite3_result_blob            sqlite3_api->result_blob
+#define sqlite3_result_double          sqlite3_api->result_double
+#define sqlite3_result_error           sqlite3_api->result_error
+#define sqlite3_result_error16         sqlite3_api->result_error16
+#define sqlite3_result_int             sqlite3_api->result_int
+#define sqlite3_result_int64           sqlite3_api->result_int64
+#define sqlite3_result_null            sqlite3_api->result_null
+#define sqlite3_result_text            sqlite3_api->result_text
+#define sqlite3_result_text16          sqlite3_api->result_text16
+#define sqlite3_result_text16be        sqlite3_api->result_text16be
+#define sqlite3_result_text16le        sqlite3_api->result_text16le
+#define sqlite3_result_value           sqlite3_api->result_value
+#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
+#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
+#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
+#define sqlite3_snprintf               sqlite3_api->snprintf
+#define sqlite3_step                   sqlite3_api->step
+#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
+#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
+#define sqlite3_total_changes          sqlite3_api->total_changes
+#define sqlite3_trace                  sqlite3_api->trace
+#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
+#define sqlite3_update_hook            sqlite3_api->update_hook
+#define sqlite3_user_data              sqlite3_api->user_data
+#define sqlite3_value_blob             sqlite3_api->value_blob
+#define sqlite3_value_bytes            sqlite3_api->value_bytes
+#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
+#define sqlite3_value_double           sqlite3_api->value_double
+#define sqlite3_value_int              sqlite3_api->value_int
+#define sqlite3_value_int64            sqlite3_api->value_int64
+#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
+#define sqlite3_value_text             sqlite3_api->value_text
+#define sqlite3_value_text16           sqlite3_api->value_text16
+#define sqlite3_value_text16be         sqlite3_api->value_text16be
+#define sqlite3_value_text16le         sqlite3_api->value_text16le
+#define sqlite3_value_type             sqlite3_api->value_type
+#define sqlite3_vmprintf               sqlite3_api->vmprintf
+#define sqlite3_overload_function      sqlite3_api->overload_function
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
+#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
+#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
+#define sqlite3_blob_close             sqlite3_api->blob_close
+#define sqlite3_blob_open              sqlite3_api->blob_open
+#define sqlite3_blob_read              sqlite3_api->blob_read
+#define sqlite3_blob_write             sqlite3_api->blob_write
+#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
+#define sqlite3_file_control           sqlite3_api->file_control
+#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
+#define sqlite3_memory_used            sqlite3_api->memory_used
+#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
+#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
+#define sqlite3_mutex_free             sqlite3_api->mutex_free
+#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
+#define sqlite3_mutex_try              sqlite3_api->mutex_try
+#define sqlite3_open_v2                sqlite3_api->open_v2
+#define sqlite3_release_memory         sqlite3_api->release_memory
+#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
+#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
+#define sqlite3_sleep                  sqlite3_api->sleep
+#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
+#define sqlite3_vfs_find               sqlite3_api->vfs_find
+#define sqlite3_vfs_register           sqlite3_api->vfs_register
+#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
+#endif /* SQLITE_CORE */
+
+#define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api;
+#define SQLITE_EXTENSION_INIT2(v)  sqlite3_api = v;
+
+#endif /* _SQLITE3EXT_H_ */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/sqliteInt.h b/client/src/thirdparty/sqlite-3.4.2/src/sqliteInt.h
new file mode 100644
index 0000000..2f26f58
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/sqliteInt.h
@@ -0,0 +1,2089 @@
+/*
+** 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.
+**
+*************************************************************************
+** Internal interface definitions for SQLite.
+**
+** @(#) $Id: sqliteInt.h,v 1.659 2008/02/02 04:47:09 danielk1977 Exp $
+*/
+#ifndef _SQLITEINT_H_
+#define _SQLITEINT_H_
+
+/*
+** The macro unlikely() is a hint that surrounds a boolean
+** expression that is usually false.  Macro likely() surrounds
+** a boolean expression that is usually true.  GCC is able to
+** use these hints to generate better code, sometimes.
+*/
+#if defined(__GNUC__) && 0
+# define likely(X)    __builtin_expect((X),1)
+# define unlikely(X)  __builtin_expect((X),0)
+#else
+# define likely(X)    !!(X)
+# define unlikely(X)  !!(X)
+#endif
+
+
+/*
+** These #defines should enable >2GB file support on Posix if the
+** underlying operating system supports it.  If the OS lacks
+** large file support, or if the OS is windows, these should be no-ops.
+**
+** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
+** system #includes.  Hence, this block of code must be the very first
+** code in all source files.
+**
+** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
+** on the compiler command line.  This is necessary if you are compiling
+** on a recent machine (ex: RedHat 7.2) but you want your code to work
+** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
+** without this option, LFS is enable.  But LFS does not exist in the kernel
+** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
+** portability you should omit LFS.
+**
+** Similar is true for MacOS.  LFS is only supported on MacOS 9 and later.
+*/
+#ifndef SQLITE_DISABLE_LFS
+# define _LARGE_FILE       1
+# ifndef _FILE_OFFSET_BITS
+#   define _FILE_OFFSET_BITS 64
+# endif
+# define _LARGEFILE_SOURCE 1
+#endif
+
+
+#include "sqliteLimit.h"
+
+/*
+** For testing purposes, the various size limit constants are really
+** variables that we can modify in the testfixture.
+*/
+#ifdef SQLITE_TEST
+  #undef SQLITE_MAX_LENGTH
+  #undef SQLITE_MAX_COLUMN
+  #undef SQLITE_MAX_SQL_LENGTH
+  #undef SQLITE_MAX_EXPR_DEPTH
+  #undef SQLITE_MAX_COMPOUND_SELECT
+  #undef SQLITE_MAX_VDBE_OP
+  #undef SQLITE_MAX_FUNCTION_ARG
+  #undef SQLITE_MAX_VARIABLE_NUMBER
+  #undef SQLITE_MAX_PAGE_SIZE
+  #undef SQLITE_MAX_PAGE_COUNT
+  #undef SQLITE_MAX_LIKE_PATTERN_LENGTH
+
+  #define SQLITE_MAX_LENGTH              sqlite3MAX_LENGTH
+  #define SQLITE_MAX_COLUMN              sqlite3MAX_COLUMN
+  #define SQLITE_MAX_SQL_LENGTH          sqlite3MAX_SQL_LENGTH
+  #define SQLITE_MAX_EXPR_DEPTH          sqlite3MAX_EXPR_DEPTH
+  #define SQLITE_MAX_COMPOUND_SELECT     sqlite3MAX_COMPOUND_SELECT
+  #define SQLITE_MAX_VDBE_OP             sqlite3MAX_VDBE_OP
+  #define SQLITE_MAX_FUNCTION_ARG        sqlite3MAX_FUNCTION_ARG
+  #define SQLITE_MAX_VARIABLE_NUMBER     sqlite3MAX_VARIABLE_NUMBER
+  #define SQLITE_MAX_PAGE_SIZE           sqlite3MAX_PAGE_SIZE
+  #define SQLITE_MAX_PAGE_COUNT          sqlite3MAX_PAGE_COUNT
+  #define SQLITE_MAX_LIKE_PATTERN_LENGTH sqlite3MAX_LIKE_PATTERN_LENGTH
+
+  extern int sqlite3MAX_LENGTH;
+  extern int sqlite3MAX_COLUMN;
+  extern int sqlite3MAX_SQL_LENGTH;
+  extern int sqlite3MAX_EXPR_DEPTH;
+  extern int sqlite3MAX_COMPOUND_SELECT;
+  extern int sqlite3MAX_VDBE_OP;
+  extern int sqlite3MAX_FUNCTION_ARG;
+  extern int sqlite3MAX_VARIABLE_NUMBER;
+  extern int sqlite3MAX_PAGE_SIZE;
+  extern int sqlite3MAX_PAGE_COUNT;
+  extern int sqlite3MAX_LIKE_PATTERN_LENGTH;
+#endif
+
+
+/*
+** The SQLITE_THREADSAFE macro must be defined as either 0 or 1.
+** Older versions of SQLite used an optional THREADSAFE macro.
+** We support that for legacy
+*/
+#if !defined(SQLITE_THREADSAFE)
+#if defined(THREADSAFE)
+# define SQLITE_THREADSAFE THREADSAFE
+#else
+# define SQLITE_THREADSAFE 1
+#endif
+#endif
+
+/*
+** We need to define _XOPEN_SOURCE as follows in order to enable
+** recursive mutexes on most unix systems.  But Mac OS X is different.
+** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,
+** so it is omitted there.  See ticket #2673.
+**
+** Later we learn that _XOPEN_SOURCE is poorly or incorrectly
+** implemented on some systems.  So we avoid defining it at all
+** if it is already defined or if it is unneeded because we are
+** not doing a threadsafe build.  Ticket #2681.
+**
+** See also ticket #2741.
+*/
+#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE
+#  define _XOPEN_SOURCE 500  /* Needed to enable pthread recursive mutexes */
+#endif
+
+#if defined(SQLITE_TCL) || defined(TCLSH)
+# include <tcl.h>
+#endif
+
+/*
+** Many people are failing to set -DNDEBUG=1 when compiling SQLite.
+** Setting NDEBUG makes the code smaller and run faster.  So the following
+** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1
+** option is set.  Thus NDEBUG becomes an opt-in rather than an opt-out
+** feature.
+*/
+#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 
+# define NDEBUG 1
+#endif
+
+#include "sqlite3.h"
+#include "hash.h"
+#include "parse.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>
+
+#define sqlite3_isnan(X)  ((X)!=(X))
+
+/*
+** If compiling for a processor that lacks floating point support,
+** substitute integer for floating-point
+*/
+#ifdef SQLITE_OMIT_FLOATING_POINT
+# define double sqlite_int64
+# define LONGDOUBLE_TYPE sqlite_int64
+# ifndef SQLITE_BIG_DBL
+#   define SQLITE_BIG_DBL (0x7fffffffffffffff)
+# endif
+# define SQLITE_OMIT_DATETIME_FUNCS 1
+# define SQLITE_OMIT_TRACE 1
+# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
+#endif
+#ifndef SQLITE_BIG_DBL
+# define SQLITE_BIG_DBL (1e99)
+#endif
+
+/*
+** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
+** afterward. Having this macro allows us to cause the C compiler 
+** to omit code used by TEMP tables without messy #ifndef statements.
+*/
+#ifdef SQLITE_OMIT_TEMPDB
+#define OMIT_TEMPDB 1
+#else
+#define OMIT_TEMPDB 0
+#endif
+
+/*
+** If the following macro is set to 1, then NULL values are considered
+** distinct when determining whether or not two entries are the same
+** in a UNIQUE index.  This is the way PostgreSQL, Oracle, DB2, MySQL,
+** OCELOT, and Firebird all work.  The SQL92 spec explicitly says this
+** is the way things are suppose to work.
+**
+** If the following macro is set to 0, the NULLs are indistinct for
+** a UNIQUE index.  In this mode, you can only have a single NULL entry
+** for a column declared UNIQUE.  This is the way Informix and SQL Server
+** work.
+*/
+#define NULL_DISTINCT_FOR_UNIQUE 1
+
+/*
+** The "file format" number is an integer that is incremented whenever
+** the VDBE-level file format changes.  The following macros define the
+** the default file format for new databases and the maximum file format
+** that the library can read.
+*/
+#define SQLITE_MAX_FILE_FORMAT 4
+#ifndef SQLITE_DEFAULT_FILE_FORMAT
+# define SQLITE_DEFAULT_FILE_FORMAT 1
+#endif
+
+/*
+** Provide a default value for TEMP_STORE in case it is not specified
+** on the command-line
+*/
+#ifndef TEMP_STORE
+# define TEMP_STORE 1
+#endif
+
+/*
+** GCC does not define the offsetof() macro so we'll have to do it
+** ourselves.
+*/
+#ifndef offsetof
+#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
+#endif
+
+/*
+** Check to see if this machine uses EBCDIC.  (Yes, believe it or
+** not, there are still machines out there that use EBCDIC.)
+*/
+#if 'A' == '\301'
+# define SQLITE_EBCDIC 1
+#else
+# define SQLITE_ASCII 1
+#endif
+
+/*
+** Integers of known sizes.  These typedefs might change for architectures
+** where the sizes very.  Preprocessor macros are available so that the
+** types can be conveniently redefined at compile-type.  Like this:
+**
+**         cc '-DUINTPTR_TYPE=long long int' ...
+*/
+#ifndef UINT32_TYPE
+# define UINT32_TYPE unsigned int
+#endif
+#ifndef UINT16_TYPE
+# define UINT16_TYPE unsigned short int
+#endif
+#ifndef INT16_TYPE
+# define INT16_TYPE short int
+#endif
+#ifndef UINT8_TYPE
+# define UINT8_TYPE unsigned char
+#endif
+#ifndef INT8_TYPE
+# define INT8_TYPE signed char
+#endif
+#ifndef LONGDOUBLE_TYPE
+# define LONGDOUBLE_TYPE long double
+#endif
+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 UINT8_TYPE i8;             /* 1-byte signed integer */
+
+/*
+** Macros to determine whether the machine is big or little endian,
+** evaluated at runtime.
+*/
+#ifdef SQLITE_AMALGAMATION
+const int sqlite3One;
+#else
+extern const int sqlite3one;
+#endif
+#if defined(i386) || defined(__i386__) || defined(_M_IX86)
+# define SQLITE_BIGENDIAN    0
+# define SQLITE_LITTLEENDIAN 1
+# define SQLITE_UTF16NATIVE  SQLITE_UTF16LE
+#else
+# define SQLITE_BIGENDIAN    (*(char *)(&sqlite3one)==0)
+# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
+# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
+#endif
+
+/*
+** An instance of the following structure is used to store the busy-handler
+** callback for a given sqlite handle. 
+**
+** The sqlite.busyHandler member of the sqlite struct contains the busy
+** callback for the database handle. Each pager opened via the sqlite
+** handle is passed a pointer to sqlite.busyHandler. The busy-handler
+** callback is currently invoked only from within pager.c.
+*/
+typedef struct BusyHandler BusyHandler;
+struct BusyHandler {
+  int (*xFunc)(void *,int);  /* The busy callback */
+  void *pArg;                /* First arg to busy callback */
+  int nBusy;                 /* Incremented with each busy call */
+};
+
+/*
+** Name of the master database table.  The master database table
+** is a special table that holds the names and attributes of all
+** user tables and indices.
+*/
+#define MASTER_NAME       "sqlite_master"
+#define TEMP_MASTER_NAME  "sqlite_temp_master"
+
+/*
+** The root-page of the master database table.
+*/
+#define MASTER_ROOT       1
+
+/*
+** The name of the schema table.
+*/
+#define SCHEMA_TABLE(x)  ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
+
+/*
+** A convenience macro that returns the number of elements in
+** an array.
+*/
+#define ArraySize(X)    (sizeof(X)/sizeof(X[0]))
+
+/*
+** Forward references to structures
+*/
+typedef struct AggInfo AggInfo;
+typedef struct AuthContext AuthContext;
+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 FKey FKey;
+typedef struct FuncDef FuncDef;
+typedef struct IdList IdList;
+typedef struct Index Index;
+typedef struct KeyClass KeyClass;
+typedef struct KeyInfo KeyInfo;
+typedef struct Module Module;
+typedef struct NameContext NameContext;
+typedef struct Parse Parse;
+typedef struct Select Select;
+typedef struct SrcList SrcList;
+typedef struct StrAccum StrAccum;
+typedef struct Table Table;
+typedef struct TableLock TableLock;
+typedef struct Token Token;
+typedef struct TriggerStack TriggerStack;
+typedef struct TriggerStep TriggerStep;
+typedef struct Trigger Trigger;
+typedef struct WhereInfo WhereInfo;
+typedef struct WhereLevel WhereLevel;
+
+/*
+** Defer sourcing vdbe.h and btree.h until after the "u8" and 
+** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
+** pointer types (i.e. FuncDef) defined above.
+*/
+#include "btree.h"
+#include "vdbe.h"
+#include "pager.h"
+
+#include "os.h"
+#include "mutex.h"
+
+/*
+** Each database file to be accessed by the system is an instance
+** of the following structure.  There are normally two of these structures
+** in the sqlite.aDb[] array.  aDb[0] is the main database file and
+** aDb[1] is the database file used to hold temporary tables.  Additional
+** databases may be attached.
+*/
+struct Db {
+  char *zName;         /* Name of this database */
+  Btree *pBt;          /* The B*Tree structure for this database file */
+  u8 inTrans;          /* 0: not writable.  1: Transaction.  2: Checkpoint */
+  u8 safety_level;     /* How aggressive at synching data to disk */
+  void *pAux;               /* Auxiliary data.  Usually NULL */
+  void (*xFreeAux)(void*);  /* Routine to free pAux */
+  Schema *pSchema;     /* Pointer to database schema (possibly shared) */
+};
+
+/*
+** An instance of the following structure stores a database schema.
+**
+** If there are no virtual tables configured in this schema, the
+** Schema.db variable is set to NULL. After the first virtual table
+** has been added, it is set to point to the database connection 
+** used to create the connection. Once a virtual table has been
+** added to the Schema structure and the Schema.db variable populated, 
+** only that database connection may use the Schema to prepare 
+** statements.
+*/
+struct Schema {
+  int schema_cookie;   /* Database schema version number for this file */
+  Hash tblHash;        /* All tables indexed by name */
+  Hash idxHash;        /* All (named) indices indexed by name */
+  Hash trigHash;       /* All triggers indexed by name */
+  Hash aFKey;          /* Foreign keys indexed by to-table */
+  Table *pSeqTab;      /* The sqlite_sequence table used by AUTOINCREMENT */
+  u8 file_format;      /* Schema format version for this file */
+  u8 enc;              /* Text encoding used by this database */
+  u16 flags;           /* Flags associated with this schema */
+  int cache_size;      /* Number of pages to use in the cache */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  sqlite3 *db;         /* "Owner" connection. See comment above */
+#endif
+};
+
+/*
+** These macros can be used to test, set, or clear bits in the 
+** Db.flags field.
+*/
+#define DbHasProperty(D,I,P)     (((D)->aDb[I].pSchema->flags&(P))==(P))
+#define DbHasAnyProperty(D,I,P)  (((D)->aDb[I].pSchema->flags&(P))!=0)
+#define DbSetProperty(D,I,P)     (D)->aDb[I].pSchema->flags|=(P)
+#define DbClearProperty(D,I,P)   (D)->aDb[I].pSchema->flags&=~(P)
+
+/*
+** Allowed values for the DB.flags field.
+**
+** The DB_SchemaLoaded flag is set after the database schema has been
+** read into internal hash tables.
+**
+** DB_UnresetViews means that one or more views have column names that
+** have been filled out.  If the schema changes, these column names might
+** changes and so the view will need to be reset.
+*/
+#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) */
+
+
+/*
+** Each database is an instance of the following structure.
+**
+** The sqlite.lastRowid records the last insert rowid generated by an
+** insert statement.  Inserts on views do not affect its value.  Each
+** trigger has its own context, so that lastRowid can be updated inside
+** triggers as usual.  The previous value will be restored once the trigger
+** exits.  Upon entering a before or instead of trigger, lastRowid is no
+** longer (since after version 2.8.12) reset to -1.
+**
+** The sqlite.nChange does not count changes within triggers and keeps no
+** context.  It is reset at start of sqlite3_exec.
+** The sqlite.lsChange represents the number of changes made by the last
+** insert, update, or delete statement.  It remains constant throughout the
+** length of a statement and is then updated by OP_SetCounts.  It keeps a
+** context stack just like lastRowid so that the count of changes
+** within a trigger is not seen outside the trigger.  Changes to views do not
+** affect the value of lsChange.
+** The sqlite.csChange keeps track of the number of current changes (since
+** the last statement) and is used to update sqlite_lsChange.
+**
+** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16
+** store the most recent error code and, if applicable, string. The
+** internal function sqlite3Error() is used to set these variables
+** consistently.
+*/
+struct sqlite3 {
+  sqlite3_vfs *pVfs;            /* OS Interface */
+  int nDb;                      /* Number of backends currently in use */
+  Db *aDb;                      /* All backends */
+  int flags;                    /* Miscellanous flags. See below */
+  int openFlags;                /* Flags passed to sqlite3_vfs.xOpen() */
+  int errCode;                  /* Most recent error code (SQLITE_*) */
+  int errMask;                  /* & result codes with this before returning */
+  u8 autoCommit;                /* The auto-commit flag. */
+  u8 temp_store;                /* 1: file 2: memory 0: default */
+  u8 mallocFailed;              /* True if we have seen a malloc failure */
+  signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
+  int nTable;                   /* Number of tables in the database */
+  CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */
+  i64 lastRowid;                /* ROWID of most recent insert (see above) */
+  i64 priorNewRowid;            /* Last randomly generated ROWID */
+  int magic;                    /* Magic number for detect library misuse */
+  int nChange;                  /* Value returned by sqlite3_changes() */
+  int nTotalChange;             /* Value returned by sqlite3_total_changes() */
+  sqlite3_mutex *mutex;         /* Connection mutex */
+  struct sqlite3InitInfo {      /* Information used during initialization */
+    int iDb;                    /* When back is being initialized */
+    int newTnum;                /* Rootpage of table being initialized */
+    u8 busy;                    /* TRUE if currently initializing */
+  } init;
+  int nExtension;               /* Number of loaded extensions */
+  void **aExtension;            /* Array of shared libraray handles */
+  struct Vdbe *pVdbe;           /* List of active virtual machines */
+  int activeVdbeCnt;            /* Number of vdbes currently executing */
+  void (*xTrace)(void*,const char*);        /* Trace function */
+  void *pTraceArg;                          /* Argument to the trace function */
+  void (*xProfile)(void*,const char*,u64);  /* Profiling function */
+  void *pProfileArg;                        /* Argument to profile function */
+  void *pCommitArg;                 /* Argument to xCommitCallback() */   
+  int (*xCommitCallback)(void*);    /* Invoked at every commit. */
+  void *pRollbackArg;               /* Argument to xRollbackCallback() */   
+  void (*xRollbackCallback)(void*); /* Invoked at every commit. */
+  void *pUpdateArg;
+  void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
+  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
+  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
+  void *pCollNeededArg;
+  sqlite3_value *pErr;          /* Most recent error message */
+  char *zErrMsg;                /* Most recent error message (UTF-8 encoded) */
+  char *zErrMsg16;              /* Most recent error message (UTF-16 encoded) */
+  union {
+    int isInterrupted;          /* True if sqlite3_interrupt has been called */
+    double notUsed1;            /* Spacer */
+  } u1;
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
+                                /* Access authorization function */
+  void *pAuthArg;               /* 1st argument to the access auth function */
+#endif
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+  int (*xProgress)(void *);     /* The progress callback */
+  void *pProgressArg;           /* Argument to the progress callback */
+  int nProgressOps;             /* Number of opcodes for progress callback */
+#endif
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  Hash aModule;                 /* populated by sqlite3_create_module() */
+  Table *pVTab;                 /* vtab with active Connect/Create method */
+  sqlite3_vtab **aVTrans;       /* Virtual tables with open transactions */
+  int nVTrans;                  /* Allocated size of aVTrans */
+#endif
+  Hash aFunc;                   /* All functions that can be in SQL exprs */
+  Hash aCollSeq;                /* All collating sequences */
+  BusyHandler busyHandler;      /* Busy callback */
+  int busyTimeout;              /* Busy handler timeout, in msec */
+  Db aDbStatic[2];              /* Static space for the 2 default backends */
+#ifdef SQLITE_SSE
+  sqlite3_stmt *pFetch;         /* Used by SSE to fetch stored statements */
+#endif
+  u8 dfltLockMode;              /* Default locking-mode for attached dbs */
+};
+
+/*
+** A macro to discover the encoding of a database.
+*/
+#define ENC(db) ((db)->aDb[0].pSchema->enc)
+
+/*
+** Possible values for the sqlite.flags and or Db.flags fields.
+**
+** On sqlite.flags, the SQLITE_InTrans value means that we have
+** executed a BEGIN.  On Db.flags, SQLITE_InTrans means a statement
+** transaction is active on that particular database file.
+*/
+#define SQLITE_VdbeTrace      0x00000001  /* True to trace VDBE execution */
+#define SQLITE_InTrans        0x00000008  /* True if in a transaction */
+#define SQLITE_InternChanges  0x00000010  /* Uncommitted Hash table changes */
+#define SQLITE_FullColNames   0x00000020  /* Show full column names on SELECT */
+#define SQLITE_ShortColNames  0x00000040  /* Show short columns names */
+#define SQLITE_CountRows      0x00000080  /* Count rows changed by INSERT, */
+                                          /*   DELETE, or UPDATE and return */
+                                          /*   the count using a callback. */
+#define SQLITE_NullCallback   0x00000100  /* Invoke the callback once if the */
+                                          /*   result set is empty */
+#define SQLITE_SqlTrace       0x00000200  /* Debug print SQL as it executes */
+#define SQLITE_VdbeListing    0x00000400  /* Debug listings of VDBE programs */
+#define SQLITE_WriteSchema    0x00000800  /* OK to update SQLITE_MASTER */
+#define SQLITE_NoReadlock     0x00001000  /* Readlocks are omitted when 
+                                          ** accessing read-only databases */
+#define SQLITE_IgnoreChecks   0x00002000  /* Do not enforce check constraints */
+#define SQLITE_ReadUncommitted 0x00004000 /* For shared-cache mode */
+#define SQLITE_LegacyFileFmt  0x00008000  /* Create new databases in format 1 */
+#define SQLITE_FullFSync      0x00010000  /* Use full fsync on the backend */
+#define SQLITE_LoadExtension  0x00020000  /* Enable load_extension */
+
+#define SQLITE_RecoveryMode   0x00040000  /* Ignore schema errors */
+#define SQLITE_SharedCache    0x00080000  /* Cache sharing is enabled */
+#define SQLITE_Vtab           0x00100000  /* There exists a virtual table */
+
+/*
+** Possible values for the sqlite.magic field.
+** The numbers are obtained at random and have no special meaning, other
+** than being distinct from one another.
+*/
+#define SQLITE_MAGIC_OPEN     0xa029a697  /* Database is open */
+#define SQLITE_MAGIC_CLOSED   0x9f3c2d33  /* Database is closed */
+#define SQLITE_MAGIC_SICK     0x4b771290  /* Error and awaiting close */
+#define SQLITE_MAGIC_BUSY     0xf03b7906  /* Database currently in use */
+#define SQLITE_MAGIC_ERROR    0xb5357930  /* An SQLITE_MISUSE error occurred */
+
+/*
+** Each SQL function is defined by an instance of the following
+** structure.  A pointer to this structure is stored in the sqlite.aFunc
+** hash table.  When multiple functions have the same name, the hash table
+** points to a linked list of these structures.
+*/
+struct FuncDef {
+  i16 nArg;            /* Number of arguments.  -1 means unlimited */
+  u8 iPrefEnc;         /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */
+  u8 needCollSeq;      /* True if sqlite3GetFuncCollSeq() might be called */
+  u8 flags;            /* Some combination of SQLITE_FUNC_* */
+  void *pUserData;     /* User data parameter */
+  FuncDef *pNext;      /* Next function with same name */
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
+  void (*xFinalize)(sqlite3_context*);                /* Aggregate finializer */
+  char zName[1];       /* SQL name of the function.  MUST BE LAST */
+};
+
+/*
+** Each SQLite module (virtual table definition) is defined by an
+** instance of the following structure, stored in the sqlite3.aModule
+** hash table.
+*/
+struct Module {
+  const sqlite3_module *pModule;       /* Callback pointers */
+  const char *zName;                   /* Name passed to create_module() */
+  void *pAux;                          /* pAux passed to create_module() */
+  void (*xDestroy)(void *);            /* Module destructor function */
+};
+
+/*
+** Possible values for FuncDef.flags
+*/
+#define SQLITE_FUNC_LIKE   0x01  /* Candidate for the LIKE optimization */
+#define SQLITE_FUNC_CASE   0x02  /* Case-sensitive LIKE-type function */
+#define SQLITE_FUNC_EPHEM  0x04  /* Ephermeral.  Delete with VDBE */
+
+/*
+** information about each column of an SQL table is held in an instance
+** of this structure.
+*/
+struct Column {
+  char *zName;     /* Name of this column */
+  Expr *pDflt;     /* Default value of this column */
+  char *zType;     /* Data type for this column */
+  char *zColl;     /* Collating sequence.  If NULL, use the default */
+  u8 notNull;      /* True if there is a NOT NULL constraint */
+  u8 isPrimKey;    /* True if this column is part of the PRIMARY KEY */
+  char affinity;   /* One of the SQLITE_AFF_... values */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  u8 isHidden;     /* True if this column is 'hidden' */
+#endif
+};
+
+/*
+** A "Collating Sequence" is defined by an instance of the following
+** structure. Conceptually, a collating sequence consists of a name and
+** a comparison routine that defines the order of that sequence.
+**
+** There may two seperate implementations of the collation function, one
+** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that
+** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine
+** native byte order. When a collation sequence is invoked, SQLite selects
+** the version that will require the least expensive encoding
+** translations, if any.
+**
+** The CollSeq.pUser member variable is an extra parameter that passed in
+** as the first argument to the UTF-8 comparison function, xCmp.
+** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,
+** xCmp16.
+**
+** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the
+** collating sequence is undefined.  Indices built on an undefined
+** collating sequence may not be read or written.
+*/
+struct CollSeq {
+  char *zName;          /* Name of the collating sequence, UTF-8 encoded */
+  u8 enc;               /* Text encoding handled by xCmp() */
+  u8 type;              /* One of the SQLITE_COLL_... values below */
+  void *pUser;          /* First argument to xCmp() */
+  int (*xCmp)(void*,int, const void*, int, const void*);
+  void (*xDel)(void*);  /* Destructor for pUser */
+};
+
+/*
+** Allowed values of CollSeq flags:
+*/
+#define SQLITE_COLL_BINARY  1  /* The default memcmp() collating sequence */
+#define SQLITE_COLL_NOCASE  2  /* The built-in NOCASE collating sequence */
+#define SQLITE_COLL_REVERSE 3  /* The built-in REVERSE collating sequence */
+#define SQLITE_COLL_USER    0  /* Any other user-defined collating sequence */
+
+/*
+** A sort order can be either ASC or DESC.
+*/
+#define SQLITE_SO_ASC       0  /* Sort in ascending order */
+#define SQLITE_SO_DESC      1  /* Sort in ascending order */
+
+/*
+** Column affinity types.
+**
+** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
+** 't' for SQLITE_AFF_TEXT.  But we can save a little space and improve
+** the speed a little by number the values consecutively.  
+**
+** But rather than start with 0 or 1, we begin with 'a'.  That way,
+** when multiple affinity types are concatenated into a string and
+** used as the P4 operand, they will be more readable.
+**
+** Note also that the numeric types are grouped together so that testing
+** for a numeric type is a single comparison.
+*/
+#define SQLITE_AFF_TEXT     'a'
+#define SQLITE_AFF_NONE     'b'
+#define SQLITE_AFF_NUMERIC  'c'
+#define SQLITE_AFF_INTEGER  'd'
+#define SQLITE_AFF_REAL     'e'
+
+#define sqlite3IsNumericAffinity(X)  ((X)>=SQLITE_AFF_NUMERIC)
+
+/*
+** The SQLITE_AFF_MASK values masks off the significant bits of an
+** affinity value. 
+*/
+#define SQLITE_AFF_MASK     0x67
+
+/*
+** Additional bit values that can be ORed with an affinity without
+** changing the affinity.
+*/
+#define SQLITE_JUMPIFNULL   0x08  /* jumps if either operand is NULL */
+#define SQLITE_NULLEQUAL    0x10  /* compare NULLs equal */
+#define SQLITE_STOREP2      0x80  /* Store result in reg[P2] rather than jump */
+
+/*
+** Each SQL table is represented in memory by an instance of the
+** following structure.
+**
+** Table.zName is the name of the table.  The case of the original
+** CREATE TABLE statement is stored, but case is not significant for
+** comparisons.
+**
+** Table.nCol is the number of columns in this table.  Table.aCol is a
+** pointer to an array of Column structures, one for each column.
+**
+** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
+** the column that is that key.   Otherwise Table.iPKey is negative.  Note
+** that the datatype of the PRIMARY KEY must be INTEGER for this field to
+** be set.  An INTEGER PRIMARY KEY is used as the rowid for each row of
+** the table.  If a table has no INTEGER PRIMARY KEY, then a random rowid
+** is generated for each row of the table.  Table.hasPrimKey is true if
+** the table has any PRIMARY KEY, INTEGER or otherwise.
+**
+** Table.tnum is the page number for the root BTree page of the table in the
+** database file.  If Table.iDb is the index of the database table backend
+** in sqlite.aDb[].  0 is for the main database and 1 is for the file that
+** holds temporary tables and indices.  If Table.isEphem
+** is true, then the table is stored in a file that is automatically deleted
+** when the VDBE cursor to the table is closed.  In this case Table.tnum 
+** refers VDBE cursor number that holds the table open, not to the root
+** page number.  Transient tables are used to hold the results of a
+** sub-query that appears instead of a real table name in the FROM clause 
+** of a SELECT statement.
+*/
+struct Table {
+  char *zName;     /* Name of the table */
+  int nCol;        /* Number of columns in this table */
+  Column *aCol;    /* Information about each column */
+  int iPKey;       /* If not less then 0, use aCol[iPKey] as the primary key */
+  Index *pIndex;   /* List of SQL indexes on this table. */
+  int tnum;        /* Root BTree node for this table (see note above) */
+  Select *pSelect; /* NULL for tables.  Points to definition if a view. */
+  int nRef;          /* Number of pointers to this Table */
+  Trigger *pTrigger; /* List of SQL triggers on this table */
+  FKey *pFKey;       /* Linked list of all foreign keys in this table */
+  char *zColAff;     /* String defining the affinity of each column */
+#ifndef SQLITE_OMIT_CHECK
+  Expr *pCheck;      /* The AND of all CHECK constraints */
+#endif
+#ifndef SQLITE_OMIT_ALTERTABLE
+  int addColOffset;  /* Offset in CREATE TABLE statement to add a new column */
+#endif
+  u8 readOnly;     /* True if this table should not be written by the user */
+  u8 isEphem;      /* True if created using OP_OpenEphermeral */
+  u8 hasPrimKey;   /* True if there exists a primary key */
+  u8 keyConf;      /* What to do in case of uniqueness conflict on iPKey */
+  u8 autoInc;      /* True if the integer primary key is autoincrement */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  u8 isVirtual;             /* True if this is a virtual table */
+  u8 isCommit;              /* True once the CREATE TABLE has been committed */
+  Module *pMod;             /* Pointer to the implementation of the module */
+  sqlite3_vtab *pVtab;      /* Pointer to the module instance */
+  int nModuleArg;           /* Number of arguments to the module */
+  char **azModuleArg;       /* Text of all module args. [0] is module name */
+#endif
+  Schema *pSchema;          /* Schema that contains this table */
+};
+
+/*
+** Test to see whether or not a table is a virtual table.  This is
+** done as a macro so that it will be optimized out when virtual
+** table support is omitted from the build.
+*/
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+#  define IsVirtual(X)      ((X)->isVirtual)
+#  define IsHiddenColumn(X) ((X)->isHidden)
+#else
+#  define IsVirtual(X)      0
+#  define IsHiddenColumn(X) 0
+#endif
+
+/*
+** Each foreign key constraint is an instance of the following structure.
+**
+** A foreign key is associated with two tables.  The "from" table is
+** the table that contains the REFERENCES clause that creates the foreign
+** key.  The "to" table is the table that is named in the REFERENCES clause.
+** Consider this example:
+**
+**     CREATE TABLE ex1(
+**       a INTEGER PRIMARY KEY,
+**       b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
+**     );
+**
+** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
+**
+** Each REFERENCES clause generates an instance of the following structure
+** which is attached to the from-table.  The to-table need not exist when
+** the from-table is created.  The existance of the to-table is not checked
+** until an attempt is made to insert data into the from-table.
+**
+** The sqlite.aFKey hash table stores pointers to this structure
+** given the name of a to-table.  For each to-table, all foreign keys
+** associated with that table are on a linked list using the FKey.pNextTo
+** field.
+*/
+struct FKey {
+  Table *pFrom;     /* The table that constains the REFERENCES clause */
+  FKey *pNextFrom;  /* Next foreign key in pFrom */
+  char *zTo;        /* Name of table that the key points to */
+  FKey *pNextTo;    /* Next foreign key that points to zTo */
+  int nCol;         /* Number of columns in this key */
+  struct sColMap {  /* Mapping of columns in pFrom to columns in zTo */
+    int iFrom;         /* Index of column in pFrom */
+    char *zCol;        /* Name of column in zTo.  If 0 use PRIMARY KEY */
+  } *aCol;          /* One entry for each of nCol column s */
+  u8 isDeferred;    /* True if constraint checking is deferred till COMMIT */
+  u8 updateConf;    /* How to resolve conflicts that occur on UPDATE */
+  u8 deleteConf;    /* How to resolve conflicts that occur on DELETE */
+  u8 insertConf;    /* How to resolve conflicts that occur on INSERT */
+};
+
+/*
+** SQLite supports many different ways to resolve a constraint
+** error.  ROLLBACK processing means that a constraint violation
+** causes the operation in process to fail and for the current transaction
+** to be rolled back.  ABORT processing means the operation in process
+** fails and any prior changes from that one operation are backed out,
+** but the transaction is not rolled back.  FAIL processing means that
+** the operation in progress stops and returns an error code.  But prior
+** changes due to the same operation are not backed out and no rollback
+** occurs.  IGNORE means that the particular row that caused the constraint
+** error is not inserted or updated.  Processing continues and no error
+** is returned.  REPLACE means that preexisting database rows that caused
+** a UNIQUE constraint violation are removed so that the new insert or
+** update can proceed.  Processing continues and no error is reported.
+**
+** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
+** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
+** same as ROLLBACK for DEFERRED keys.  SETNULL means that the foreign
+** key is set to NULL.  CASCADE means that a DELETE or UPDATE of the
+** referenced table row is propagated into the row that holds the
+** foreign key.
+** 
+** The following symbolic values are used to record which type
+** of action to take.
+*/
+#define OE_None     0   /* There is no constraint to check */
+#define OE_Rollback 1   /* Fail the operation and rollback the transaction */
+#define OE_Abort    2   /* Back out changes but do no rollback transaction */
+#define OE_Fail     3   /* Stop the operation but leave all prior changes */
+#define OE_Ignore   4   /* Ignore the error. Do not do the INSERT or UPDATE */
+#define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */
+
+#define OE_Restrict 6   /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
+#define OE_SetNull  7   /* Set the foreign key value to NULL */
+#define OE_SetDflt  8   /* Set the foreign key value to its default */
+#define OE_Cascade  9   /* Cascade the changes */
+
+#define OE_Default  99  /* Do whatever the default action is */
+
+
+/*
+** An instance of the following structure is passed as the first
+** argument to sqlite3VdbeKeyCompare and is used to control the 
+** comparison of the two index keys.
+**
+** If the KeyInfo.incrKey value is true and the comparison would
+** otherwise be equal, then return a result as if the second key
+** were larger.
+*/
+struct KeyInfo {
+  sqlite3 *db;        /* The database connection */
+  u8 enc;             /* Text encoding - one of the TEXT_Utf* values */
+  u8 incrKey;         /* Increase 2nd key by epsilon before comparison */
+  u8 prefixIsEqual;   /* Treat a prefix as equal */
+  int nField;         /* Number of entries in aColl[] */
+  u8 *aSortOrder;     /* If defined an aSortOrder[i] is true, sort DESC */
+  CollSeq *aColl[1];  /* Collating sequence for each term of the key */
+};
+
+/*
+** Each SQL index is represented in memory by an
+** instance of the following structure.
+**
+** The columns of the table that are to be indexed are described
+** by the aiColumn[] field of this structure.  For example, suppose
+** we have the following table and index:
+**
+**     CREATE TABLE Ex1(c1 int, c2 int, c3 text);
+**     CREATE INDEX Ex2 ON Ex1(c3,c1);
+**
+** In the Table structure describing Ex1, nCol==3 because there are
+** three columns in the table.  In the Index structure describing
+** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
+** The value of aiColumn is {2, 0}.  aiColumn[0]==2 because the 
+** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
+** The second column to be indexed (c1) has an index of 0 in
+** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
+**
+** The Index.onError field determines whether or not the indexed columns
+** must be unique and what to do if they are not.  When Index.onError=OE_None,
+** it means this is not a unique index.  Otherwise it is a unique index
+** and the value of Index.onError indicate the which conflict resolution 
+** algorithm to employ whenever an attempt is made to insert a non-unique
+** element.
+*/
+struct Index {
+  char *zName;     /* Name of this index */
+  int nColumn;     /* Number of columns in the table used by this index */
+  int *aiColumn;   /* Which columns are used by this index.  1st is 0 */
+  unsigned *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */
+  Table *pTable;   /* The SQL table being indexed */
+  int tnum;        /* Page containing root of this index in database file */
+  u8 onError;      /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
+  u8 autoIndex;    /* True if is automatically created (ex: by UNIQUE) */
+  char *zColAff;   /* String defining the affinity of each column */
+  Index *pNext;    /* The next index associated with the same table */
+  Schema *pSchema; /* Schema containing this index */
+  u8 *aSortOrder;  /* Array of size Index.nColumn. True==DESC, False==ASC */
+  char **azColl;   /* Array of collation sequence names for index */
+};
+
+/*
+** Each token coming out of the lexer is an instance of
+** this structure.  Tokens are also used as part of an expression.
+**
+** Note if Token.z==0 then Token.dyn and Token.n are undefined and
+** may contain random values.  Do not make any assuptions about Token.dyn
+** and Token.n when Token.z==0.
+*/
+struct Token {
+  const unsigned char *z; /* Text of the token.  Not NULL-terminated! */
+  unsigned dyn  : 1;      /* True for malloced memory, false for static */
+  unsigned n    : 31;     /* Number of characters in this token */
+};
+
+/*
+** An instance of this structure contains information needed to generate
+** code for a SELECT that contains aggregate functions.
+**
+** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
+** pointer to this structure.  The Expr.iColumn field is the index in
+** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
+** code for that node.
+**
+** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
+** original Select structure that describes the SELECT statement.  These
+** fields do not need to be freed when deallocating the AggInfo structure.
+*/
+struct AggInfo {
+  u8 directMode;          /* Direct rendering mode means take data directly
+                          ** from source tables rather than from accumulators */
+  u8 useSortingIdx;       /* In direct mode, reference the sorting index rather
+                          ** than the source table */
+  int sortingIdx;         /* Cursor number of the sorting index */
+  ExprList *pGroupBy;     /* The group by clause */
+  int nSortingColumn;     /* Number of columns in the sorting index */
+  struct AggInfo_col {    /* For each column used in source tables */
+    Table *pTab;             /* Source table */
+    int iTable;              /* Cursor number of the source table */
+    int iColumn;             /* Column number within the source table */
+    int iSorterColumn;       /* Column number in the sorting index */
+    int iMem;                /* Memory location that acts as accumulator */
+    Expr *pExpr;             /* The original expression */
+  } *aCol;
+  int nColumn;            /* Number of used entries in aCol[] */
+  int nColumnAlloc;       /* Number of slots allocated for aCol[] */
+  int nAccumulator;       /* Number of columns that show through to the output.
+                          ** Additional columns are used only as parameters to
+                          ** aggregate functions */
+  struct AggInfo_func {   /* For each aggregate function */
+    Expr *pExpr;             /* Expression encoding the function */
+    FuncDef *pFunc;          /* The aggregate function implementation */
+    int iMem;                /* Memory location that acts as accumulator */
+    int iDistinct;           /* Ephermeral table used to enforce DISTINCT */
+  } *aFunc;
+  int nFunc;              /* Number of entries in aFunc[] */
+  int nFuncAlloc;         /* Number of slots allocated for aFunc[] */
+};
+
+/*
+** Each node of an expression in the parse tree is an instance
+** of this structure.
+**
+** Expr.op is the opcode.  The integer parser token codes are reused
+** as opcodes here.  For example, the parser defines TK_GE to be an integer
+** code representing the ">=" operator.  This same integer code is reused
+** to represent the greater-than-or-equal-to operator in the expression
+** tree.
+**
+** Expr.pRight and Expr.pLeft are subexpressions.  Expr.pList is a list
+** of argument if the expression is a function.
+**
+** Expr.token is the operator token for this node.  For some expressions
+** that have subexpressions, Expr.token can be the complete text that gave
+** rise to the Expr.  In the latter case, the token is marked as being
+** a compound token.
+**
+** An expression of the form ID or ID.ID refers to a column in a table.
+** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
+** the integer cursor number of a VDBE cursor pointing to that table and
+** Expr.iColumn is the column number for the specific column.  If the
+** expression is used as a result in an aggregate SELECT, then the
+** value is also stored in the Expr.iAgg column in the aggregate so that
+** it can be accessed after all aggregates are computed.
+**
+** If the expression is a function, the Expr.iTable is an integer code
+** representing which function.  If the expression is an unbound variable
+** marker (a question mark character '?' in the original SQL) then the
+** Expr.iTable holds the index number for that variable.
+**
+** If the expression is a subquery then Expr.iColumn holds an integer
+** register number containing the result of the subquery.  If the
+** subquery gives a constant result, then iTable is -1.  If the subquery
+** gives a different answer at different times during statement processing
+** then iTable is the address of a subroutine that computes the subquery.
+**
+** The Expr.pSelect field points to a SELECT statement.  The SELECT might
+** be the right operand of an IN operator.  Or, if a scalar SELECT appears
+** in an expression the opcode is TK_SELECT and Expr.pSelect is the only
+** operand.
+**
+** If the Expr is of type OP_Column, and the table it is selecting from
+** is a disk table or the "old.*" pseudo-table, then pTab points to the
+** corresponding table definition.
+*/
+struct Expr {
+  u8 op;                 /* Operation performed by this node */
+  char affinity;         /* The affinity of the column or 0 if not a column */
+  u16 flags;             /* Various flags.  See below */
+  CollSeq *pColl;        /* The collation type of the column or 0 */
+  Expr *pLeft, *pRight;  /* Left and right subnodes */
+  ExprList *pList;       /* A list of expressions used as function arguments
+                         ** or in "<expr> IN (<expr-list)" */
+  Token token;           /* An operand token */
+  Token span;            /* Complete text of the expression */
+  int iTable, iColumn;   /* When op==TK_COLUMN, then this expr node means the
+                         ** iColumn-th field of the iTable-th table. */
+  AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
+  int iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
+  int iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
+  Select *pSelect;       /* When the expression is a sub-select.  Also the
+                         ** right side of "<expr> IN (<select>)" */
+  Table *pTab;           /* Table for OP_Column expressions. */
+/*  Schema *pSchema; */
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+  int nHeight;           /* Height of the tree headed by this node */
+#endif
+};
+
+/*
+** The following are the meanings of bits in the Expr.flags field.
+*/
+#define EP_FromJoin     0x01  /* Originated in ON or USING clause of a join */
+#define EP_Agg          0x02  /* Contains one or more aggregate functions */
+#define EP_Resolved     0x04  /* IDs have been resolved to COLUMNs */
+#define EP_Error        0x08  /* Expression contains one or more errors */
+#define EP_Distinct     0x10  /* Aggregate function with DISTINCT keyword */
+#define EP_VarSelect    0x20  /* pSelect is correlated, not constant */
+#define EP_Dequoted     0x40  /* True if the string has been dequoted */
+#define EP_InfixFunc    0x80  /* True for an infix function: LIKE, GLOB, etc */
+#define EP_ExpCollate  0x100  /* Collating sequence specified explicitly */
+
+/*
+** These macros can be used to test, set, or clear bits in the 
+** Expr.flags field.
+*/
+#define ExprHasProperty(E,P)     (((E)->flags&(P))==(P))
+#define ExprHasAnyProperty(E,P)  (((E)->flags&(P))!=0)
+#define ExprSetProperty(E,P)     (E)->flags|=(P)
+#define ExprClearProperty(E,P)   (E)->flags&=~(P)
+
+/*
+** A list of expressions.  Each expression may optionally have a
+** name.  An expr/name combination can be used in several ways, such
+** as the list of "expr AS ID" fields following a "SELECT" or in the
+** list of "ID = expr" items in an UPDATE.  A list of expressions can
+** also be used as the argument to a function, in which case the a.zName
+** field is not used.
+*/
+struct ExprList {
+  int nExpr;             /* Number of expressions on the list */
+  int nAlloc;            /* Number of entries allocated below */
+  int iECursor;          /* VDBE Cursor associated with this ExprList */
+  struct ExprList_item {
+    Expr *pExpr;           /* The list of expressions */
+    char *zName;           /* Token associated with this expression */
+    u8 sortOrder;          /* 1 for DESC or 0 for ASC */
+    u8 isAgg;              /* True if this is an aggregate like count(*) */
+    u8 done;               /* A flag to indicate when processing is finished */
+  } *a;                  /* One entry for each expression */
+};
+
+/*
+** An instance of this structure can hold a simple list of identifiers,
+** such as the list "a,b,c" in the following statements:
+**
+**      INSERT INTO t(a,b,c) VALUES ...;
+**      CREATE INDEX idx ON t(a,b,c);
+**      CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
+**
+** The IdList.a.idx field is used when the IdList represents the list of
+** column names after a table name in an INSERT statement.  In the statement
+**
+**     INSERT INTO t(a,b,c) ...
+**
+** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
+*/
+struct IdList {
+  struct IdList_item {
+    char *zName;      /* Name of the identifier */
+    int idx;          /* Index in some Table.aCol[] of a column named zName */
+  } *a;
+  int nId;         /* Number of identifiers on the list */
+  int nAlloc;      /* Number of entries allocated for a[] below */
+};
+
+/*
+** The bitmask datatype defined below is used for various optimizations.
+**
+** Changing this from a 64-bit to a 32-bit type limits the number of
+** tables in a join to 32 instead of 64.  But it also reduces the size
+** of the library by 738 bytes on ix86.
+*/
+typedef u64 Bitmask;
+
+/*
+** The following structure describes the FROM clause of a SELECT statement.
+** Each table or subquery in the FROM clause is a separate element of
+** the SrcList.a[] array.
+**
+** With the addition of multiple database support, the following structure
+** can also be used to describe a particular table such as the table that
+** is modified by an INSERT, DELETE, or UPDATE statement.  In standard SQL,
+** such a table must be a simple name: ID.  But in SQLite, the table can
+** now be identified by a database name, a dot, then the table name: ID.ID.
+**
+** The jointype starts out showing the join type between the current table
+** and the next table on the list.  The parser builds the list this way.
+** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
+** jointype expresses the join between the table and the previous table.
+*/
+struct SrcList {
+  i16 nSrc;        /* Number of tables or subqueries in the FROM clause */
+  i16 nAlloc;      /* Number of entries allocated in a[] below */
+  struct SrcList_item {
+    char *zDatabase;  /* Name of database holding this table */
+    char *zName;      /* Name of the table */
+    char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
+    Table *pTab;      /* An SQL table corresponding to zName */
+    Select *pSelect;  /* A SELECT statement used in place of a table name */
+    u8 isPopulated;   /* Temporary table associated with SELECT is populated */
+    u8 jointype;      /* Type of join between this able and the previous */
+    int iCursor;      /* The VDBE cursor number used to access this table */
+    Expr *pOn;        /* The ON clause of a join */
+    IdList *pUsing;   /* The USING clause of a join */
+    Bitmask colUsed;  /* Bit N (1<<N) set if column N or pTab is used */
+  } a[1];             /* One entry for each identifier on the list */
+};
+
+/*
+** Permitted values of the SrcList.a.jointype field
+*/
+#define JT_INNER     0x0001    /* Any kind of inner or cross join */
+#define JT_CROSS     0x0002    /* Explicit use of the CROSS keyword */
+#define JT_NATURAL   0x0004    /* True for a "natural" join */
+#define JT_LEFT      0x0008    /* Left outer join */
+#define JT_RIGHT     0x0010    /* Right outer join */
+#define JT_OUTER     0x0020    /* The "OUTER" keyword is present */
+#define JT_ERROR     0x0040    /* unknown or unsupported join type */
+
+/*
+** For each nested loop in a WHERE clause implementation, the WhereInfo
+** structure contains a single instance of this structure.  This structure
+** is intended to be private the the where.c module and should not be
+** access or modified by other modules.
+**
+** The pIdxInfo and pBestIdx fields are used to help pick the best
+** index on a virtual table.  The pIdxInfo pointer contains indexing
+** information for the i-th table in the FROM clause before reordering.
+** All the pIdxInfo pointers are freed by whereInfoFree() in where.c.
+** The pBestIdx pointer is a copy of pIdxInfo for the i-th table after
+** FROM clause ordering.  This is a little confusing so I will repeat
+** it in different words.  WhereInfo.a[i].pIdxInfo is index information 
+** for WhereInfo.pTabList.a[i].  WhereInfo.a[i].pBestInfo is the
+** index information for the i-th loop of the join.  pBestInfo is always
+** either NULL or a copy of some pIdxInfo.  So for cleanup it is 
+** sufficient to free all of the pIdxInfo pointers.
+** 
+*/
+struct WhereLevel {
+  int iFrom;            /* Which entry in the FROM clause */
+  int flags;            /* Flags associated with this level */
+  int iMem;             /* First memory cell used by this level */
+  int iLeftJoin;        /* Memory cell used to implement LEFT OUTER JOIN */
+  Index *pIdx;          /* Index used.  NULL if no index */
+  int iTabCur;          /* The VDBE cursor used to access the table */
+  int iIdxCur;          /* The VDBE cursor used to acesss pIdx */
+  int brk;              /* Jump here to break out of the loop */
+  int nxt;              /* Jump here to start the next IN combination */
+  int cont;             /* Jump here to continue with the next loop cycle */
+  int top;              /* First instruction of interior of the loop */
+  int op, p1, p2;       /* Opcode used to terminate the loop */
+  int nEq;              /* Number of == or IN constraints on this loop */
+  int nIn;              /* Number of IN operators constraining this loop */
+  struct InLoop {
+    int iCur;              /* The VDBE cursor used by this IN operator */
+    int topAddr;           /* Top of the IN loop */
+  } *aInLoop;           /* Information about each nested IN operator */
+  sqlite3_index_info *pBestIdx;  /* Index information for this level */
+
+  /* The following field is really not part of the current level.  But
+  ** we need a place to cache index information for each table in the
+  ** FROM clause and the WhereLevel structure is a convenient place.
+  */
+  sqlite3_index_info *pIdxInfo;  /* Index info for n-th source table */
+};
+
+#define ORDERBY_NORMAL 0
+#define ORDERBY_MIN    1
+#define ORDERBY_MAX    2
+
+/*
+** The WHERE clause processing routine has two halves.  The
+** first part does the start of the WHERE loop and the second
+** half does the tail of the WHERE loop.  An instance of
+** this structure is returned by the first half and passed
+** into the second half to give some continuity.
+*/
+struct WhereInfo {
+  Parse *pParse;
+  SrcList *pTabList;   /* List of tables in the join */
+  int iTop;            /* The very beginning of the WHERE loop */
+  int iContinue;       /* Jump here to continue with next record */
+  int iBreak;          /* Jump here to break out of the loop */
+  int nLevel;          /* Number of nested loop */
+  sqlite3_index_info **apInfo;  /* Array of pointers to index info structures */
+  WhereLevel a[1];     /* Information about each nest loop in the WHERE */
+};
+
+/*
+** A NameContext defines a context in which to resolve table and column
+** names.  The context consists of a list of tables (the pSrcList) field and
+** a list of named expression (pEList).  The named expression list may
+** be NULL.  The pSrc corresponds to the FROM clause of a SELECT or
+** to the table being operated on by INSERT, UPDATE, or DELETE.  The
+** pEList corresponds to the result set of a SELECT and is NULL for
+** other statements.
+**
+** NameContexts can be nested.  When resolving names, the inner-most 
+** context is searched first.  If no match is found, the next outer
+** context is checked.  If there is still no match, the next context
+** is checked.  This process continues until either a match is found
+** or all contexts are check.  When a match is found, the nRef member of
+** the context containing the match is incremented. 
+**
+** Each subquery gets a new NameContext.  The pNext field points to the
+** NameContext in the parent query.  Thus the process of scanning the
+** NameContext list corresponds to searching through successively outer
+** subqueries looking for a match.
+*/
+struct NameContext {
+  Parse *pParse;       /* The parser */
+  SrcList *pSrcList;   /* One or more tables used to resolve names */
+  ExprList *pEList;    /* Optional list of named expressions */
+  int nRef;            /* Number of names resolved by this context */
+  int nErr;            /* Number of errors encountered while resolving names */
+  u8 allowAgg;         /* Aggregate functions allowed here */
+  u8 hasAgg;           /* True if aggregates are seen */
+  u8 isCheck;          /* True if resolving names in a CHECK constraint */
+  int nDepth;          /* Depth of subquery recursion. 1 for no recursion */
+  AggInfo *pAggInfo;   /* Information about aggregates at this level */
+  NameContext *pNext;  /* Next outer name context.  NULL for outermost */
+};
+
+/*
+** An instance of the following structure contains all information
+** needed to generate code for a single SELECT statement.
+**
+** nLimit is set to -1 if there is no LIMIT clause.  nOffset is set to 0.
+** If there is a LIMIT clause, the parser sets nLimit to the value of the
+** limit and nOffset to the value of the offset (or 0 if there is not
+** offset).  But later on, nLimit and nOffset become the memory locations
+** in the VDBE that record the limit and offset counters.
+**
+** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
+** These addresses must be stored so that we can go back and fill in
+** the P4_KEYINFO and P2 parameters later.  Neither the KeyInfo nor
+** the number of columns in P2 can be computed at the same time
+** as the OP_OpenEphm instruction is coded because not
+** enough information about the compound query is known at that point.
+** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
+** for the result set.  The KeyInfo for addrOpenTran[2] contains collating
+** sequences for the ORDER BY clause.
+*/
+struct Select {
+  ExprList *pEList;      /* The fields of the result */
+  u8 op;                 /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
+  u8 isDistinct;         /* True if the DISTINCT keyword is present */
+  u8 isResolved;         /* True once sqlite3SelectResolve() has run. */
+  u8 isAgg;              /* True if this is an aggregate query */
+  u8 usesEphm;           /* True if uses an OpenEphemeral opcode */
+  u8 disallowOrderBy;    /* Do not allow an ORDER BY to be attached if TRUE */
+  char affinity;         /* MakeRecord with this affinity for SRT_Set */
+  SrcList *pSrc;         /* The FROM clause */
+  Expr *pWhere;          /* The WHERE clause */
+  ExprList *pGroupBy;    /* The GROUP BY clause */
+  Expr *pHaving;         /* The HAVING clause */
+  ExprList *pOrderBy;    /* The ORDER BY clause */
+  Select *pPrior;        /* Prior select in a compound select statement */
+  Select *pNext;         /* Next select to the left in a compound */
+  Select *pRightmost;    /* Right-most select in a compound select statement */
+  Expr *pLimit;          /* LIMIT expression. NULL means not used. */
+  Expr *pOffset;         /* OFFSET expression. NULL means not used. */
+  int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
+  int addrOpenEphm[3];   /* OP_OpenEphem opcodes related to this select */
+};
+
+/*
+** The results of a select can be distributed in several ways.
+*/
+#define SRT_Union        1  /* Store result as keys in an index */
+#define SRT_Except       2  /* Remove result from a UNION index */
+#define SRT_Exists       3  /* Store 1 if the result is not empty */
+#define SRT_Discard      4  /* Do not save the results anywhere */
+
+/* The ORDER BY clause is ignored for all of the above */
+#define IgnorableOrderby(X) ((X->eDest)<=SRT_Discard)
+
+#define SRT_Callback     5  /* Invoke a callback with each row of result */
+#define SRT_Mem          6  /* Store result in a memory cell */
+#define SRT_Set          7  /* Store non-null results as keys in an index */
+#define SRT_Table        8  /* Store result as data with an automatic rowid */
+#define SRT_EphemTab     9  /* Create transient tab and store like SRT_Table */
+#define SRT_Subroutine  10  /* Call a subroutine to handle results */
+
+/*
+** A structure used to customize the behaviour of sqlite3Select(). See
+** comments above sqlite3Select() for details.
+*/
+typedef struct SelectDest SelectDest;
+struct SelectDest {
+  u8 eDest;         /* How to dispose of the results */
+  u8 affinity;      /* Affinity used when eDest==SRT_Set */
+  int iParm;        /* A parameter used by the eDest disposal method */
+  int iMem;         /* Base register where results are written */
+};
+
+/*
+** An SQL parser context.  A copy of this structure is passed through
+** the parser and down into all the parser action routine in order to
+** carry around information that is global to the entire parse.
+**
+** The structure is divided into two parts.  When the parser and code
+** generate call themselves recursively, the first part of the structure
+** is constant but the second part is reset at the beginning and end of
+** each recursion.
+**
+** The nTableLock and aTableLock variables are only used if the shared-cache 
+** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
+** used to store the set of table-locks required by the statement being
+** compiled. Function sqlite3TableLock() is used to add entries to the
+** list.
+*/
+struct Parse {
+  sqlite3 *db;         /* The main database structure */
+  int rc;              /* Return code from execution */
+  char *zErrMsg;       /* An error message */
+  Vdbe *pVdbe;         /* An engine for executing database bytecode */
+  u8 colNamesSet;      /* TRUE after OP_ColumnName has been issued to pVdbe */
+  u8 nameClash;        /* A permanent table name clashes with temp table name */
+  u8 checkSchema;      /* Causes schema cookie check after an error */
+  u8 nested;           /* Number of nested calls to the parser/code generator */
+  u8 parseError;       /* True after a parsing error.  Ticket #1794 */
+  u8 nTempReg;         /* Number of temporary registers in aTempReg[] */
+  u8 nTempInUse;       /* Number of aTempReg[] currently checked out */
+  int aTempReg[8];     /* Holding area for temporary registers */
+  int nRangeReg;       /* Size of the temporary register block */
+  int iRangeReg;       /* First register in temporary register block */
+  int nErr;            /* Number of errors seen */
+  int nTab;            /* Number of previously allocated VDBE cursors */
+  int nMem;            /* Number of memory cells used so far */
+  int nSet;            /* Number of sets used so far */
+  int ckBase;          /* Base register of data during check constraints */
+  u32 writeMask;       /* Start a write transaction on these databases */
+  u32 cookieMask;      /* Bitmask of schema verified databases */
+  int cookieGoto;      /* Address of OP_Goto to cookie verifier subroutine */
+  int cookieValue[SQLITE_MAX_ATTACHED+2];  /* Values of cookies to verify */
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  int nTableLock;        /* Number of locks in aTableLock */
+  TableLock *aTableLock; /* Required table locks for shared-cache mode */
+#endif
+
+  /* Above is constant between recursions.  Below is reset before and after
+  ** each recursion */
+
+  int regRowid;        /* Register holding rowid of CREATE TABLE entry */
+  int regRoot;         /* Register holding root page number for new objects */
+  int nVar;            /* Number of '?' variables seen in the SQL so far */
+  int nVarExpr;        /* Number of used slots in apVarExpr[] */
+  int nVarExprAlloc;   /* Number of allocated slots in apVarExpr[] */
+  Expr **apVarExpr;    /* Pointers to :aaa and $aaaa wildcard expressions */
+  u8 explain;          /* True if the EXPLAIN flag is found on the query */
+  Token sErrToken;     /* The token at which the error occurred */
+  Token sNameToken;    /* Token with unqualified schema object name */
+  Token sLastToken;    /* The last token parsed */
+  const char *zSql;    /* All SQL text */
+  const char *zTail;   /* All SQL text past the last semicolon parsed */
+  Table *pNewTable;    /* A table being constructed by CREATE TABLE */
+  Trigger *pNewTrigger;     /* Trigger under construct by a CREATE TRIGGER */
+  TriggerStack *trigStack;  /* Trigger actions being coded */
+  const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  Token sArg;                /* Complete text of a module argument */
+  u8 declareVtab;            /* True if inside sqlite3_declare_vtab() */
+  Table *pVirtualLock;       /* Require virtual table lock on this table */
+#endif
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+  int nHeight;            /* Expression tree height of current sub-select */
+#endif
+};
+
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+  #define IN_DECLARE_VTAB 0
+#else
+  #define IN_DECLARE_VTAB (pParse->declareVtab)
+#endif
+
+/*
+** An instance of the following structure can be declared on a stack and used
+** to save the Parse.zAuthContext value so that it can be restored later.
+*/
+struct AuthContext {
+  const char *zAuthContext;   /* Put saved Parse.zAuthContext here */
+  Parse *pParse;              /* The Parse structure */
+};
+
+/*
+** Bitfield flags for P2 value in OP_Insert and OP_Delete
+*/
+#define OPFLAG_NCHANGE   1    /* Set to update db->nChange */
+#define OPFLAG_LASTROWID 2    /* Set to update db->lastRowid */
+#define OPFLAG_ISUPDATE  4    /* This OP_Insert is an sql UPDATE */
+#define OPFLAG_APPEND    8    /* This is likely to be an append */
+
+/*
+ * Each trigger present in the database schema is stored as an instance of
+ * struct Trigger. 
+ *
+ * Pointers to instances of struct Trigger are stored in two ways.
+ * 1. In the "trigHash" hash table (part of the sqlite3* that represents the 
+ *    database). This allows Trigger structures to be retrieved by name.
+ * 2. All triggers associated with a single table form a linked list, using the
+ *    pNext member of struct Trigger. A pointer to the first element of the
+ *    linked list is stored as the "pTrigger" member of the associated
+ *    struct Table.
+ *
+ * The "step_list" member points to the first element of a linked list
+ * containing the SQL statements specified as the trigger program.
+ */
+struct Trigger {
+  char *name;             /* The name of the trigger                        */
+  char *table;            /* The table or view to which the trigger applies */
+  u8 op;                  /* One of TK_DELETE, TK_UPDATE, TK_INSERT         */
+  u8 tr_tm;               /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
+  Expr *pWhen;            /* The WHEN clause of the expresion (may be NULL) */
+  IdList *pColumns;       /* If this is an UPDATE OF <column-list> trigger,
+                             the <column-list> is stored here */
+  Token nameToken;        /* Token containing zName. Use during parsing only */
+  Schema *pSchema;        /* Schema containing the trigger */
+  Schema *pTabSchema;     /* Schema containing the table */
+  TriggerStep *step_list; /* Link list of trigger program steps             */
+  Trigger *pNext;         /* Next trigger associated with the table */
+};
+
+/*
+** A trigger is either a BEFORE or an AFTER trigger.  The following constants
+** determine which. 
+**
+** If there are multiple triggers, you might of some BEFORE and some AFTER.
+** In that cases, the constants below can be ORed together.
+*/
+#define TRIGGER_BEFORE  1
+#define TRIGGER_AFTER   2
+
+/*
+ * An instance of struct TriggerStep is used to store a single SQL statement
+ * that is a part of a trigger-program. 
+ *
+ * Instances of struct TriggerStep are stored in a singly linked list (linked
+ * using the "pNext" member) referenced by the "step_list" member of the 
+ * associated struct Trigger instance. The first element of the linked list is
+ * the first step of the trigger-program.
+ * 
+ * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
+ * "SELECT" statement. The meanings of the other members is determined by the 
+ * value of "op" as follows:
+ *
+ * (op == TK_INSERT)
+ * orconf    -> stores the ON CONFLICT algorithm
+ * pSelect   -> If this is an INSERT INTO ... SELECT ... statement, then
+ *              this stores a pointer to the SELECT statement. Otherwise NULL.
+ * target    -> A token holding the name of the table to insert into.
+ * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
+ *              this stores values to be inserted. Otherwise NULL.
+ * pIdList   -> If this is an INSERT INTO ... (<column-names>) VALUES ... 
+ *              statement, then this stores the column-names to be
+ *              inserted into.
+ *
+ * (op == TK_DELETE)
+ * target    -> A token holding the name of the table to delete from.
+ * pWhere    -> The WHERE clause of the DELETE statement if one is specified.
+ *              Otherwise NULL.
+ * 
+ * (op == TK_UPDATE)
+ * target    -> A token holding the name of the table to update rows of.
+ * pWhere    -> The WHERE clause of the UPDATE statement if one is specified.
+ *              Otherwise NULL.
+ * pExprList -> A list of the columns to update and the expressions to update
+ *              them to. See sqlite3Update() documentation of "pChanges"
+ *              argument.
+ * 
+ */
+struct TriggerStep {
+  int op;              /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
+  int orconf;          /* OE_Rollback etc. */
+  Trigger *pTrig;      /* The trigger that this step is a part of */
+
+  Select *pSelect;     /* Valid for SELECT and sometimes 
+                          INSERT steps (when pExprList == 0) */
+  Token target;        /* Valid for DELETE, UPDATE, INSERT steps */
+  Expr *pWhere;        /* Valid for DELETE, UPDATE steps */
+  ExprList *pExprList; /* Valid for UPDATE statements and sometimes 
+                           INSERT steps (when pSelect == 0)         */
+  IdList *pIdList;     /* Valid for INSERT statements only */
+  TriggerStep *pNext;  /* Next in the link-list */
+  TriggerStep *pLast;  /* Last element in link-list. Valid for 1st elem only */
+};
+
+/*
+ * An instance of struct TriggerStack stores information required during code
+ * generation of a single trigger program. While the trigger program is being
+ * coded, its associated TriggerStack instance is pointed to by the
+ * "pTriggerStack" member of the Parse structure.
+ *
+ * The pTab member points to the table that triggers are being coded on. The 
+ * newIdx member contains the index of the vdbe cursor that points at the temp
+ * table that stores the new.* references. If new.* references are not valid
+ * for the trigger being coded (for example an ON DELETE trigger), then newIdx
+ * is set to -1. The oldIdx member is analogous to newIdx, for old.* references.
+ *
+ * The ON CONFLICT policy to be used for the trigger program steps is stored 
+ * as the orconf member. If this is OE_Default, then the ON CONFLICT clause 
+ * specified for individual triggers steps is used.
+ *
+ * struct TriggerStack has a "pNext" member, to allow linked lists to be
+ * constructed. When coding nested triggers (triggers fired by other triggers)
+ * each nested trigger stores its parent trigger's TriggerStack as the "pNext" 
+ * pointer. Once the nested trigger has been coded, the pNext value is restored
+ * to the pTriggerStack member of the Parse stucture and coding of the parent
+ * trigger continues.
+ *
+ * Before a nested trigger is coded, the linked list pointed to by the 
+ * pTriggerStack is scanned to ensure that the trigger is not about to be coded
+ * recursively. If this condition is detected, the nested trigger is not coded.
+ */
+struct TriggerStack {
+  Table *pTab;         /* Table that triggers are currently being coded on */
+  int newIdx;          /* Index of vdbe cursor to "new" temp table */
+  int oldIdx;          /* Index of vdbe cursor to "old" temp table */
+  u32 newColMask;
+  u32 oldColMask;
+  int orconf;          /* Current orconf policy */
+  int ignoreJump;      /* where to jump to for a RAISE(IGNORE) */
+  Trigger *pTrigger;   /* The trigger currently being coded */
+  TriggerStack *pNext; /* Next trigger down on the trigger stack */
+};
+
+/*
+** The following structure contains information used by the sqliteFix...
+** routines as they walk the parse tree to make database references
+** explicit.  
+*/
+typedef struct DbFixer DbFixer;
+struct DbFixer {
+  Parse *pParse;      /* The parsing context.  Error messages written here */
+  const char *zDb;    /* Make sure all objects are contained in this database */
+  const char *zType;  /* Type of the container - used for error messages */
+  const Token *pName; /* Name of the container - used for error messages */
+};
+
+/*
+** An objected used to accumulate the text of a string where we
+** do not necessarily know how big the string will be in the end.
+*/
+struct StrAccum {
+  char *zBase;     /* A base allocation.  Not from malloc. */
+  char *zText;     /* The string collected so far */
+  int  nChar;      /* Length of the string so far */
+  int  nAlloc;     /* Amount of space allocated in zText */
+  u8   mallocFailed;   /* Becomes true if any memory allocation fails */
+  u8   useMalloc;      /* True if zText is enlargable using realloc */
+  u8   tooBig;         /* Becomes true if string size exceeds limits */
+};
+
+/*
+** A pointer to this structure is used to communicate information
+** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
+*/
+typedef struct {
+  sqlite3 *db;        /* The database being initialized */
+  int iDb;            /* 0 for main database.  1 for TEMP, 2.. for ATTACHed */
+  char **pzErrMsg;    /* Error message stored here */
+  int rc;             /* Result code stored here */
+} InitData;
+
+/*
+** Assuming zIn points to the first byte of a UTF-8 character,
+** advance zIn to point to the first byte of the next UTF-8 character.
+*/
+#define SQLITE_SKIP_UTF8(zIn) {                        \
+  if( (*(zIn++))>=0xc0 ){                              \
+    while( (*zIn & 0xc0)==0x80 ){ zIn++; }             \
+  }                                                    \
+}
+
+/*
+** The SQLITE_CORRUPT_BKPT macro can be either a constant (for production
+** builds) or a function call (for debugging).  If it is a function call,
+** it allows the operator to set a breakpoint at the spot where database
+** corruption is first detected.
+*/
+#ifdef SQLITE_DEBUG
+  int sqlite3Corrupt(void);
+# define SQLITE_CORRUPT_BKPT sqlite3Corrupt()
+# define DEBUGONLY(X)        X
+#else
+# define SQLITE_CORRUPT_BKPT SQLITE_CORRUPT
+# define DEBUGONLY(X)
+#endif
+
+/*
+** Internal function prototypes
+*/
+int sqlite3StrICmp(const char *, const char *);
+int sqlite3StrNICmp(const char *, const char *, int);
+int sqlite3IsNumber(const char*, int*, u8);
+
+void *sqlite3MallocZero(unsigned);
+void *sqlite3DbMallocZero(sqlite3*, unsigned);
+void *sqlite3DbMallocRaw(sqlite3*, unsigned);
+char *sqlite3StrDup(const char*);
+char *sqlite3StrNDup(const char*, int);
+char *sqlite3DbStrDup(sqlite3*,const char*);
+char *sqlite3DbStrNDup(sqlite3*,const char*, int);
+void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
+void *sqlite3DbRealloc(sqlite3 *, void *, int);
+
+char *sqlite3MPrintf(sqlite3*,const char*, ...);
+char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
+#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
+  void sqlite3DebugPrintf(const char*, ...);
+#endif
+#if defined(SQLITE_TEST)
+  void *sqlite3TextToPtr(const char*);
+#endif
+void sqlite3SetString(char **, ...);
+void sqlite3ErrorMsg(Parse*, const char*, ...);
+void sqlite3ErrorClear(Parse*);
+void sqlite3Dequote(char*);
+void sqlite3DequoteExpr(sqlite3*, Expr*);
+int sqlite3KeywordCode(const unsigned char*, int);
+int sqlite3RunParser(Parse*, const char*, char **);
+void sqlite3FinishCoding(Parse*);
+int sqlite3GetTempReg(Parse*);
+void sqlite3ReleaseTempReg(Parse*,int);
+int sqlite3GetTempRange(Parse*,int);
+void sqlite3ReleaseTempRange(Parse*,int,int);
+Expr *sqlite3Expr(sqlite3*, int, Expr*, Expr*, const Token*);
+Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
+Expr *sqlite3RegisterExpr(Parse*,Token*);
+Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
+void sqlite3ExprSpan(Expr*,Token*,Token*);
+Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
+void sqlite3ExprAssignVarNumber(Parse*, Expr*);
+void sqlite3ExprDelete(Expr*);
+ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*,Token*);
+void sqlite3ExprListDelete(ExprList*);
+int sqlite3Init(sqlite3*, char**);
+int sqlite3InitCallback(void*, int, char**, char**);
+void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
+void sqlite3ResetInternalSchema(sqlite3*, int);
+void sqlite3BeginParse(Parse*,int);
+void sqlite3CommitInternalChanges(sqlite3*);
+Table *sqlite3ResultSetOfSelect(Parse*,char*,Select*);
+void sqlite3OpenMasterTable(Parse *, int);
+void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
+void sqlite3AddColumn(Parse*,Token*);
+void sqlite3AddNotNull(Parse*, int);
+void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
+void sqlite3AddCheckConstraint(Parse*, Expr*);
+void sqlite3AddColumnType(Parse*,Token*);
+void sqlite3AddDefaultValue(Parse*,Expr*);
+void sqlite3AddCollateType(Parse*, Token*);
+void sqlite3EndTable(Parse*,Token*,Token*,Select*);
+
+void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
+
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
+  int sqlite3ViewGetColumnNames(Parse*,Table*);
+#else
+# define sqlite3ViewGetColumnNames(A,B) 0
+#endif
+
+void sqlite3DropTable(Parse*, SrcList*, int, int);
+void sqlite3DeleteTable(Table*);
+void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
+void *sqlite3ArrayAllocate(sqlite3*,void*,int,int,int*,int*,int*);
+IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);
+int sqlite3IdListIndex(IdList*,const char*);
+SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*);
+SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, Token*,
+                                      Select*, Expr*, IdList*);
+void sqlite3SrcListShiftJoinType(SrcList*);
+void sqlite3SrcListAssignCursors(Parse*, SrcList*);
+void sqlite3IdListDelete(IdList*);
+void sqlite3SrcListDelete(SrcList*);
+void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
+                        Token*, int, int);
+void sqlite3DropIndex(Parse*, SrcList*, int);
+int sqlite3Select(Parse*, Select*, SelectDest*, Select*, int, int*, char *aff);
+Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
+                         Expr*,ExprList*,int,Expr*,Expr*);
+void sqlite3SelectDelete(Select*);
+Table *sqlite3SrcListLookup(Parse*, SrcList*);
+int sqlite3IsReadOnly(Parse*, Table*, int);
+void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
+void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
+void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
+WhereInfo *sqlite3WhereBegin(Parse*, SrcList*, Expr*, ExprList**, u8);
+void sqlite3WhereEnd(WhereInfo*);
+void sqlite3ExprCodeGetColumn(Vdbe*, Table*, int, int, int);
+int sqlite3ExprCode(Parse*, Expr*, int);
+int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
+int sqlite3ExprCodeAndCache(Parse*, Expr*, int);
+int sqlite3ExprCodeExprList(Parse*, ExprList*, int);
+void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
+void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
+Table *sqlite3FindTable(sqlite3*,const char*, const char*);
+Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*);
+Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
+void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
+void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
+void sqlite3Vacuum(Parse*);
+int sqlite3RunVacuum(char**, sqlite3*);
+char *sqlite3NameFromToken(sqlite3*, Token*);
+int sqlite3ExprCompare(Expr*, Expr*);
+int sqlite3ExprResolveNames(NameContext *, Expr *);
+void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
+void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
+Vdbe *sqlite3GetVdbe(Parse*);
+Expr *sqlite3CreateIdExpr(Parse *, const char*);
+void sqlite3Randomness(int, void*);
+void sqlite3RollbackAll(sqlite3*);
+void sqlite3CodeVerifySchema(Parse*, int);
+void sqlite3BeginTransaction(Parse*, int);
+void sqlite3CommitTransaction(Parse*);
+void sqlite3RollbackTransaction(Parse*);
+int sqlite3ExprIsConstant(Expr*);
+int sqlite3ExprIsConstantNotJoin(Expr*);
+int sqlite3ExprIsConstantOrFunction(Expr*);
+int sqlite3ExprIsInteger(Expr*, int*);
+int sqlite3IsRowid(const char*);
+void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int);
+void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
+int sqlite3GenerateIndexKey(Parse*, Index*, int, int);
+void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
+                                     int*,int,int,int,int);
+void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*,int,int,int,int);
+int sqlite3OpenTableAndIndices(Parse*, Table*, int, int);
+void sqlite3BeginWriteOperation(Parse*, int, int);
+Expr *sqlite3ExprDup(sqlite3*,Expr*);
+void sqlite3TokenCopy(sqlite3*,Token*, Token*);
+ExprList *sqlite3ExprListDup(sqlite3*,ExprList*);
+SrcList *sqlite3SrcListDup(sqlite3*,SrcList*);
+IdList *sqlite3IdListDup(sqlite3*,IdList*);
+Select *sqlite3SelectDup(sqlite3*,Select*);
+FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,int);
+void sqlite3RegisterBuiltinFunctions(sqlite3*);
+void sqlite3RegisterDateTimeFunctions(sqlite3*);
+#ifdef SQLITE_DEBUG
+  int sqlite3SafetyOn(sqlite3*);
+  int sqlite3SafetyOff(sqlite3*);
+#else
+# define sqlite3SafetyOn(A) 0
+# define sqlite3SafetyOff(A) 0
+#endif
+int sqlite3SafetyCheckOk(sqlite3*);
+int sqlite3SafetyCheckSickOrOk(sqlite3*);
+void sqlite3ChangeCookie(Parse*, int);
+
+#ifndef SQLITE_OMIT_TRIGGER
+  void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
+                           Expr*,int, int);
+  void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
+  void sqlite3DropTrigger(Parse*, SrcList*, int);
+  void sqlite3DropTriggerPtr(Parse*, Trigger*);
+  int sqlite3TriggersExist(Parse*, Table*, int, ExprList*);
+  int sqlite3CodeRowTrigger(Parse*, int, ExprList*, int, Table *, int, int, 
+                           int, int, u32*, u32*);
+  void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
+  void sqlite3DeleteTriggerStep(TriggerStep*);
+  TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*);
+  TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*,
+                                        ExprList*,Select*,int);
+  TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, int);
+  TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*);
+  void sqlite3DeleteTrigger(Trigger*);
+  void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
+  void sqlite3SelectMask(Parse *, Select *, u32);
+#else
+# define sqlite3TriggersExist(A,B,C,D,E,F) 0
+# define sqlite3DeleteTrigger(A)
+# define sqlite3DropTriggerPtr(A,B)
+# define sqlite3UnlinkAndDeleteTrigger(A,B,C)
+# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I,J,K) 0
+# define sqlite3SelectMask(A, B, C)
+#endif
+
+int sqlite3JoinType(Parse*, Token*, Token*, Token*);
+void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
+void sqlite3DeferForeignKey(Parse*, int);
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
+  int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
+  void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
+  void sqlite3AuthContextPop(AuthContext*);
+#else
+# define sqlite3AuthRead(a,b,c,d)
+# define sqlite3AuthCheck(a,b,c,d,e)    SQLITE_OK
+# define sqlite3AuthContextPush(a,b,c)
+# define sqlite3AuthContextPop(a)  ((void)(a))
+#endif
+void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
+void sqlite3Detach(Parse*, Expr*);
+int sqlite3BtreeFactory(const sqlite3 *db, const char *zFilename,
+                       int omitJournal, int nCache, int flags, Btree **ppBtree);
+int sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
+int sqlite3FixSrcList(DbFixer*, SrcList*);
+int sqlite3FixSelect(DbFixer*, Select*);
+int sqlite3FixExpr(DbFixer*, Expr*);
+int sqlite3FixExprList(DbFixer*, ExprList*);
+int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
+int sqlite3AtoF(const char *z, double*);
+char *sqlite3_snprintf(int,char*,const char*,...);
+int sqlite3GetInt32(const char *, int*);
+int sqlite3FitsIn64Bits(const char *, int);
+int sqlite3Utf16ByteLen(const void *pData, int nChar);
+int sqlite3Utf8CharLen(const char *pData, int nByte);
+int sqlite3Utf8Read(const u8*, const u8*, const u8**);
+int sqlite3PutVarint(unsigned char *, u64);
+int sqlite3GetVarint(const unsigned char *, u64 *);
+int sqlite3GetVarint32(const unsigned char *, u32 *);
+int sqlite3VarintLen(u64 v);
+void sqlite3IndexAffinityStr(Vdbe *, Index *);
+void sqlite3TableAffinityStr(Vdbe *, Table *);
+char sqlite3CompareAffinity(Expr *pExpr, char aff2);
+int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
+char sqlite3ExprAffinity(Expr *pExpr);
+int sqlite3Atoi64(const char*, i64*);
+void sqlite3Error(sqlite3*, int, const char*,...);
+void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
+int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
+const char *sqlite3ErrStr(int);
+int sqlite3ReadSchema(Parse *pParse);
+CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char *,int,int);
+CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName);
+CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
+Expr *sqlite3ExprSetColl(Parse *pParse, Expr *, Token *);
+int sqlite3CheckCollSeq(Parse *, CollSeq *);
+int sqlite3CheckObjectName(Parse *, const char *);
+void sqlite3VdbeSetChanges(sqlite3 *, int);
+
+const void *sqlite3ValueText(sqlite3_value*, u8);
+int sqlite3ValueBytes(sqlite3_value*, u8);
+void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, 
+                        void(*)(void*));
+void sqlite3ValueFree(sqlite3_value*);
+sqlite3_value *sqlite3ValueNew(sqlite3 *);
+char *sqlite3Utf16to8(sqlite3 *, const void*, int);
+int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
+void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
+#ifndef SQLITE_AMALGAMATION
+extern const unsigned char sqlite3UpperToLower[];
+#endif
+void sqlite3RootPageMoved(Db*, int, int);
+void sqlite3Reindex(Parse*, Token*, Token*);
+void sqlite3AlterFunctions(sqlite3*);
+void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
+int sqlite3GetToken(const unsigned char *, int *);
+void sqlite3NestedParse(Parse*, const char*, ...);
+void sqlite3ExpirePreparedStatements(sqlite3*);
+void sqlite3CodeSubselect(Parse *, Expr *);
+int sqlite3SelectResolve(Parse *, Select *, NameContext *);
+void sqlite3ColumnDefault(Vdbe *, Table *, int);
+void sqlite3AlterFinishAddColumn(Parse *, Token *);
+void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
+CollSeq *sqlite3GetCollSeq(sqlite3*, CollSeq *, const char *, int);
+char sqlite3AffinityType(const Token*);
+void sqlite3Analyze(Parse*, Token*, Token*);
+int sqlite3InvokeBusyHandler(BusyHandler*);
+int sqlite3FindDb(sqlite3*, Token*);
+int sqlite3AnalysisLoad(sqlite3*,int iDB);
+void sqlite3DefaultRowEst(Index*);
+void sqlite3RegisterLikeFunctions(sqlite3*, int);
+int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
+void sqlite3AttachFunctions(sqlite3 *);
+void sqlite3MinimumFileFormat(Parse*, int, int);
+void sqlite3SchemaFree(void *);
+Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
+int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
+KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *);
+int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *, 
+  void (*)(sqlite3_context*,int,sqlite3_value **),
+  void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*));
+int sqlite3ApiExit(sqlite3 *db, int);
+int sqlite3OpenTempDatabase(Parse *);
+
+void sqlite3StrAccumAppend(StrAccum*,const char*,int);
+char *sqlite3StrAccumFinish(StrAccum*);
+void sqlite3StrAccumReset(StrAccum*);
+void sqlite3SelectDestInit(SelectDest*,int,int);
+
+/*
+** The interface to the LEMON-generated parser
+*/
+void *sqlite3ParserAlloc(void*(*)(size_t));
+void sqlite3ParserFree(void*, void(*)(void*));
+void sqlite3Parser(void*, int, Token, Parse*);
+
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+  void sqlite3CloseExtensions(sqlite3*);
+  int sqlite3AutoLoadExtensions(sqlite3*);
+#else
+# define sqlite3CloseExtensions(X)
+# define sqlite3AutoLoadExtensions(X)  SQLITE_OK
+#endif
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  void sqlite3TableLock(Parse *, int, int, u8, const char *);
+#else
+  #define sqlite3TableLock(v,w,x,y,z)
+#endif
+
+#ifdef SQLITE_TEST
+  int sqlite3Utf8To8(unsigned char*);
+#endif
+
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+#  define sqlite3VtabClear(X)
+#  define sqlite3VtabSync(X,Y) (Y)
+#  define sqlite3VtabRollback(X)
+#  define sqlite3VtabCommit(X)
+#else
+   void sqlite3VtabClear(Table*);
+   int sqlite3VtabSync(sqlite3 *db, int rc);
+   int sqlite3VtabRollback(sqlite3 *db);
+   int sqlite3VtabCommit(sqlite3 *db);
+#endif
+void sqlite3VtabLock(sqlite3_vtab*);
+void sqlite3VtabUnlock(sqlite3*, sqlite3_vtab*);
+void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*);
+void sqlite3VtabFinishParse(Parse*, Token*);
+void sqlite3VtabArgInit(Parse*);
+void sqlite3VtabArgExtend(Parse*, Token*);
+int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
+int sqlite3VtabCallConnect(Parse*, Table*);
+int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
+int sqlite3VtabBegin(sqlite3 *, sqlite3_vtab *);
+FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
+void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
+int sqlite3Reprepare(Vdbe*);
+void sqlite3ExprListCheckLength(Parse*, ExprList*, int, const char*);
+CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
+
+
+/*
+** Available fault injectors.  Should be numbered beginning with 0.
+*/
+#define SQLITE_FAULTINJECTOR_MALLOC     0
+#define SQLITE_FAULTINJECTOR_COUNT      1
+
+/*
+** The interface to the fault injector subsystem.  If the fault injector
+** mechanism is disabled at compile-time then set up macros so that no
+** unnecessary code is generated.
+*/
+#ifndef SQLITE_OMIT_FAULTINJECTOR
+  void sqlite3FaultConfig(int,int,int);
+  int sqlite3FaultFailures(int);
+  int sqlite3FaultBenignFailures(int);
+  int sqlite3FaultPending(int);
+  void sqlite3FaultBenign(int,int);
+  int sqlite3FaultStep(int);
+#else
+# define sqlite3FaultConfig(A,B,C)
+# define sqlite3FaultFailures(A)         0
+# define sqlite3FaultBenignFailures(A)   0
+# define sqlite3FaultPending(A)          (-1)
+# define sqlite3FaultBenign(A,B)
+# define sqlite3FaultStep(A)             0
+#endif
+  
+  
+
+#define IN_INDEX_ROWID           1
+#define IN_INDEX_EPH             2
+#define IN_INDEX_INDEX           3
+int sqlite3FindInIndex(Parse *, Expr *, int);
+
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+  int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
+  int sqlite3JournalSize(sqlite3_vfs *);
+  int sqlite3JournalCreate(sqlite3_file *);
+#else
+  #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)
+#endif
+
+#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0
+  void sqlite3ExprSetHeight(Expr *);
+  int sqlite3SelectExprHeight(Select *);
+#else
+  #define sqlite3ExprSetHeight(x)
+#endif
+
+u32 sqlite3Get4byte(const u8*);
+void sqlite3Put4byte(u8*, u32);
+
+#ifdef SQLITE_SSE
+#include "sseInt.h"
+#endif
+
+#ifdef SQLITE_DEBUG
+  void sqlite3ParserTrace(FILE*, char *);
+#endif
+
+/*
+** If the SQLITE_ENABLE IOTRACE exists then the global variable
+** sqlite3_io_trace is a pointer to a printf-like routine used to
+** print I/O tracing messages. 
+*/
+#ifdef SQLITE_ENABLE_IOTRACE
+# define IOTRACE(A)  if( sqlite3_io_trace ){ sqlite3_io_trace A; }
+  void sqlite3VdbeIOTraceSql(Vdbe*);
+#else
+# define IOTRACE(A)
+# define sqlite3VdbeIOTraceSql(X)
+#endif
+SQLITE_EXTERN void (*sqlite3_io_trace)(const char*,...);
+
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/sqliteLimit.h b/client/src/thirdparty/sqlite-3.4.2/src/sqliteLimit.h
new file mode 100644
index 0000000..64cf1ca
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/sqliteLimit.h
@@ -0,0 +1,179 @@
+/*
+** 2007 May 7
+**
+** 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 defines various limits of what SQLite can process.
+**
+** @(#) $Id: sqliteLimit.h,v 1.6 2007/12/17 16:20:07 drh Exp $
+*/
+
+/*
+** The maximum length of a TEXT or BLOB in bytes.   This also
+** limits the size of a row in a table or index.
+**
+** The hard limit is the ability of a 32-bit signed integer
+** to count the size: 2^31-1 or 2147483647.
+*/
+#ifndef SQLITE_MAX_LENGTH
+# define SQLITE_MAX_LENGTH 1000000000
+#endif
+
+/*
+** This is the maximum number of
+**
+**    * Columns in a table
+**    * Columns in an index
+**    * Columns in a view
+**    * Terms in the SET clause of an UPDATE statement
+**    * Terms in the result set of a SELECT statement
+**    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
+**    * Terms in the VALUES clause of an INSERT statement
+**
+** The hard upper limit here is 32676.  Most database people will
+** tell you that in a well-normalized database, you usually should
+** not have more than a dozen or so columns in any table.  And if
+** that is the case, there is no point in having more than a few
+** dozen values in any of the other situations described above.
+*/
+#ifndef SQLITE_MAX_COLUMN
+# define SQLITE_MAX_COLUMN 2000
+#endif
+
+/*
+** The maximum length of a single SQL statement in bytes.
+** A value of zero means there is no limit.
+*/
+#ifndef SQLITE_MAX_SQL_LENGTH
+# define SQLITE_MAX_SQL_LENGTH 0
+#endif
+
+/*
+** The maximum depth of an expression tree. This is limited to 
+** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 
+** want to place more severe limits on the complexity of an 
+** expression. A value of 0 (the default) means do not enforce
+** any limitation on expression tree depth.
+*/
+#ifndef SQLITE_MAX_EXPR_DEPTH
+# define SQLITE_MAX_EXPR_DEPTH 1000
+#endif
+
+/*
+** The maximum number of terms in a compound SELECT statement.
+** The code generator for compound SELECT statements does one
+** level of recursion for each term.  A stack overflow can result
+** if the number of terms is too large.  In practice, most SQL
+** never has more than 3 or 4 terms.  Use a value of 0 to disable
+** any limit on the number of terms in a compount SELECT.
+*/
+#ifndef SQLITE_MAX_COMPOUND_SELECT
+# define SQLITE_MAX_COMPOUND_SELECT 500
+#endif
+
+/*
+** The maximum number of opcodes in a VDBE program.
+** Not currently enforced.
+*/
+#ifndef SQLITE_MAX_VDBE_OP
+# define SQLITE_MAX_VDBE_OP 25000
+#endif
+
+/*
+** The maximum number of arguments to an SQL function.
+*/
+#ifndef SQLITE_MAX_FUNCTION_ARG
+# define SQLITE_MAX_FUNCTION_ARG 100
+#endif
+
+/*
+** The maximum number of in-memory pages to use for the main database
+** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
+*/
+#ifndef SQLITE_DEFAULT_CACHE_SIZE
+# define SQLITE_DEFAULT_CACHE_SIZE  2000
+#endif
+#ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
+# define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500
+#endif
+
+/*
+** The maximum number of attached databases.  This must be at least 2
+** in order to support the main database file (0) and the file used to
+** hold temporary tables (1).  And it must be less than 32 because
+** we use a bitmask of databases with a u32 in places (for example
+** the Parse.cookieMask field).
+*/
+#ifndef SQLITE_MAX_ATTACHED
+# define SQLITE_MAX_ATTACHED 10
+#endif
+
+
+/*
+** The maximum value of a ?nnn wildcard that the parser will accept.
+*/
+#ifndef SQLITE_MAX_VARIABLE_NUMBER
+# define SQLITE_MAX_VARIABLE_NUMBER 999
+#endif
+
+/* Maximum page size.  The upper bound on this value is 32768.  This a limit
+** imposed by the necessity of storing the value in a 2-byte unsigned integer
+** and the fact that the page size must be a power of 2.
+*/
+#ifndef SQLITE_MAX_PAGE_SIZE
+# define SQLITE_MAX_PAGE_SIZE 32768
+#endif
+
+
+/*
+** The default size of a database page.
+*/
+#ifndef SQLITE_DEFAULT_PAGE_SIZE
+# define SQLITE_DEFAULT_PAGE_SIZE 1024
+#endif
+#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
+# undef SQLITE_DEFAULT_PAGE_SIZE
+# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
+#endif
+
+/*
+** Ordinarily, if no value is explicitly provided, SQLite creates databases
+** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
+** device characteristics (sector-size and atomic write() support),
+** SQLite may choose a larger value. This constant is the maximum value
+** SQLite will choose on its own.
+*/
+#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE
+# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192
+#endif
+#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
+# undef SQLITE_MAX_DEFAULT_PAGE_SIZE
+# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
+#endif
+
+
+/*
+** Maximum number of pages in one database file.
+**
+** This is really just the default value for the max_page_count pragma.
+** This value can be lowered (or raised) at run-time using that the
+** max_page_count macro.
+*/
+#ifndef SQLITE_MAX_PAGE_COUNT
+# define SQLITE_MAX_PAGE_COUNT 1073741823
+#endif
+
+/*
+** Maximum length (in bytes) of the pattern in a LIKE or GLOB
+** operator.
+*/
+#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
+# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/table.c b/client/src/thirdparty/sqlite-3.4.2/src/table.c
new file mode 100644
index 0000000..88a96ee
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/table.c
@@ -0,0 +1,199 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains the sqlite3_get_table() and sqlite3_free_table()
+** interface routines.  These are just wrappers around the main
+** interface routine of sqlite3_exec().
+**
+** These routines are in a separate files so that they will not be linked
+** if they are not used.
+*/
+#include "sqliteInt.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef SQLITE_OMIT_GET_TABLE
+
+/*
+** This structure is used to pass data from sqlite3_get_table() through
+** to the callback function is uses to build the result.
+*/
+typedef struct TabResult {
+  char **azResult;
+  char *zErrMsg;
+  int nResult;
+  int nAlloc;
+  int nRow;
+  int nColumn;
+  int nData;
+  int rc;
+} TabResult;
+
+/*
+** This routine is called once for each row in the result table.  Its job
+** is to fill in the TabResult structure appropriately, allocating new
+** memory as necessary.
+*/
+static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
+  TabResult *p = (TabResult*)pArg;
+  int need;
+  int i;
+  char *z;
+
+  /* Make sure there is enough space in p->azResult to hold everything
+  ** we need to remember from this invocation of the callback.
+  */
+  if( p->nRow==0 && argv!=0 ){
+    need = nCol*2;
+  }else{
+    need = nCol;
+  }
+  if( p->nData + need >= p->nAlloc ){
+    char **azNew;
+    p->nAlloc = p->nAlloc*2 + need + 1;
+    azNew = sqlite3_realloc( p->azResult, sizeof(char*)*p->nAlloc );
+    if( azNew==0 ) goto malloc_failed;
+    p->azResult = azNew;
+  }
+
+  /* If this is the first row, then generate an extra row containing
+  ** the names of all columns.
+  */
+  if( p->nRow==0 ){
+    p->nColumn = nCol;
+    for(i=0; i<nCol; i++){
+      z = sqlite3_mprintf("%s", colv[i]);
+      if( z==0 ) goto malloc_failed;
+      p->azResult[p->nData++] = z;
+    }
+  }else if( p->nColumn!=nCol ){
+    sqlite3_free(p->zErrMsg);
+    p->zErrMsg = sqlite3_mprintf(
+       "sqlite3_get_table() called with two or more incompatible queries"
+    );
+    p->rc = SQLITE_ERROR;
+    return 1;
+  }
+
+  /* Copy over the row data
+  */
+  if( argv!=0 ){
+    for(i=0; i<nCol; i++){
+      if( argv[i]==0 ){
+        z = 0;
+      }else{
+        int n = strlen(argv[i])+1;
+        z = sqlite3_malloc( n );
+        if( z==0 ) goto malloc_failed;
+        memcpy(z, argv[i], n);
+      }
+      p->azResult[p->nData++] = z;
+    }
+    p->nRow++;
+  }
+  return 0;
+
+malloc_failed:
+  p->rc = SQLITE_NOMEM;
+  return 1;
+}
+
+/*
+** Query the database.  But instead of invoking a callback for each row,
+** malloc() for space to hold the result and return the entire results
+** at the conclusion of the call.
+**
+** The result that is written to ***pazResult is held in memory obtained
+** from malloc().  But the caller cannot free this memory directly.  
+** Instead, the entire table should be passed to sqlite3_free_table() when
+** the calling procedure is finished using it.
+*/
+int sqlite3_get_table(
+  sqlite3 *db,                /* The database on which the SQL executes */
+  const char *zSql,           /* The SQL to be executed */
+  char ***pazResult,          /* Write the result table here */
+  int *pnRow,                 /* Write the number of rows in the result here */
+  int *pnColumn,              /* Write the number of columns of result here */
+  char **pzErrMsg             /* Write error messages here */
+){
+  int rc;
+  TabResult res;
+
+  *pazResult = 0;
+  if( pnColumn ) *pnColumn = 0;
+  if( pnRow ) *pnRow = 0;
+  res.zErrMsg = 0;
+  res.nResult = 0;
+  res.nRow = 0;
+  res.nColumn = 0;
+  res.nData = 1;
+  res.nAlloc = 20;
+  res.rc = SQLITE_OK;
+  res.azResult = sqlite3_malloc(sizeof(char*)*res.nAlloc );
+  if( res.azResult==0 ){
+     db->errCode = SQLITE_NOMEM;
+     return SQLITE_NOMEM;
+  }
+  res.azResult[0] = 0;
+  rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
+  assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
+  res.azResult[0] = (char*)res.nData;
+  if( (rc&0xff)==SQLITE_ABORT ){
+    sqlite3_free_table(&res.azResult[1]);
+    if( res.zErrMsg ){
+      if( pzErrMsg ){
+        sqlite3_free(*pzErrMsg);
+        *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
+      }
+      sqlite3_free(res.zErrMsg);
+    }
+    db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
+    return res.rc;
+  }
+  sqlite3_free(res.zErrMsg);
+  if( rc!=SQLITE_OK ){
+    sqlite3_free_table(&res.azResult[1]);
+    return rc;
+  }
+  if( res.nAlloc>res.nData ){
+    char **azNew;
+    azNew = sqlite3_realloc( res.azResult, sizeof(char*)*(res.nData+1) );
+    if( azNew==0 ){
+      sqlite3_free_table(&res.azResult[1]);
+      db->errCode = SQLITE_NOMEM;
+      return SQLITE_NOMEM;
+    }
+    res.nAlloc = res.nData+1;
+    res.azResult = azNew;
+  }
+  *pazResult = &res.azResult[1];
+  if( pnColumn ) *pnColumn = res.nColumn;
+  if( pnRow ) *pnRow = res.nRow;
+  return rc;
+}
+
+/*
+** This routine frees the space the sqlite3_get_table() malloced.
+*/
+void sqlite3_free_table(
+  char **azResult            /* Result returned from from sqlite3_get_table() */
+){
+  if( azResult ){
+    int i, n;
+    azResult--;
+    assert( azResult!=0 );
+    n = (int)azResult[0];
+    for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
+    sqlite3_free(azResult);
+  }
+}
+
+#endif /* SQLITE_OMIT_GET_TABLE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/tclsqlite.c b/client/src/thirdparty/sqlite-3.4.2/src/tclsqlite.c
new file mode 100644
index 0000000..a151bb6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/tclsqlite.c
@@ -0,0 +1,2591 @@
+/*
+** 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.
+**
+*************************************************************************
+** A TCL Interface to SQLite.  Append this file to sqlite3.c and
+** compile the whole thing to build a TCL-enabled version of SQLite.
+**
+** $Id: tclsqlite.c,v 1.207 2007/11/14 06:48:48 danielk1977 Exp $
+*/
+#include "tcl.h"
+#include <errno.h>
+
+/*
+** Some additional include files are needed if this file is not
+** appended to the amalgamation.
+*/
+#ifndef SQLITE_AMALGAMATION
+# include "sqliteInt.h"
+# include <stdlib.h>
+# include <string.h>
+# include <assert.h>
+# include <ctype.h>
+#endif
+
+/*
+ * Windows needs to know which symbols to export.  Unix does not.
+ * BUILD_sqlite should be undefined for Unix.
+ */
+#ifdef BUILD_sqlite
+#undef TCL_STORAGE_CLASS
+#define TCL_STORAGE_CLASS DLLEXPORT
+#endif /* BUILD_sqlite */
+
+#define NUM_PREPARED_STMTS 10
+#define MAX_PREPARED_STMTS 100
+
+/*
+** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we
+** have to do a translation when going between the two.  Set the 
+** UTF_TRANSLATION_NEEDED macro to indicate that we need to do
+** this translation.  
+*/
+#if defined(TCL_UTF_MAX) && !defined(SQLITE_UTF8)
+# define UTF_TRANSLATION_NEEDED 1
+#endif
+
+/*
+** New SQL functions can be created as TCL scripts.  Each such function
+** is described by an instance of the following structure.
+*/
+typedef struct SqlFunc SqlFunc;
+struct SqlFunc {
+  Tcl_Interp *interp;   /* The TCL interpret to execute the function */
+  Tcl_Obj *pScript;     /* The Tcl_Obj representation of the script */
+  int useEvalObjv;      /* True if it is safe to use Tcl_EvalObjv */
+  char *zName;          /* Name of this function */
+  SqlFunc *pNext;       /* Next function on the list of them all */
+};
+
+/*
+** New collation sequences function can be created as TCL scripts.  Each such
+** function is described by an instance of the following structure.
+*/
+typedef struct SqlCollate SqlCollate;
+struct SqlCollate {
+  Tcl_Interp *interp;   /* The TCL interpret to execute the function */
+  char *zScript;        /* The script to be run */
+  SqlCollate *pNext;    /* Next function on the list of them all */
+};
+
+/*
+** Prepared statements are cached for faster execution.  Each prepared
+** statement is described by an instance of the following structure.
+*/
+typedef struct SqlPreparedStmt SqlPreparedStmt;
+struct SqlPreparedStmt {
+  SqlPreparedStmt *pNext;  /* Next in linked list */
+  SqlPreparedStmt *pPrev;  /* Previous on the list */
+  sqlite3_stmt *pStmt;     /* The prepared statement */
+  int nSql;                /* chars in zSql[] */
+  const char *zSql;        /* Text of the SQL statement */
+};
+
+typedef struct IncrblobChannel IncrblobChannel;
+
+/*
+** There is one instance of this structure for each SQLite database
+** that has been opened by the SQLite TCL interface.
+*/
+typedef struct SqliteDb SqliteDb;
+struct SqliteDb {
+  sqlite3 *db;               /* The "real" database structure. MUST BE FIRST */
+  Tcl_Interp *interp;        /* The interpreter used for this database */
+  char *zBusy;               /* The busy callback routine */
+  char *zCommit;             /* The commit hook callback routine */
+  char *zTrace;              /* The trace callback routine */
+  char *zProfile;            /* The profile callback routine */
+  char *zProgress;           /* The progress callback routine */
+  char *zAuth;               /* The authorization callback routine */
+  char *zNull;               /* Text to substitute for an SQL NULL value */
+  SqlFunc *pFunc;            /* List of SQL functions */
+  Tcl_Obj *pUpdateHook;      /* Update hook script (if any) */
+  Tcl_Obj *pRollbackHook;    /* Rollback hook script (if any) */
+  SqlCollate *pCollate;      /* List of SQL collation functions */
+  int rc;                    /* Return code of most recent sqlite3_exec() */
+  Tcl_Obj *pCollateNeeded;   /* Collation needed script */
+  SqlPreparedStmt *stmtList; /* List of prepared statements*/
+  SqlPreparedStmt *stmtLast; /* Last statement in the list */
+  int maxStmt;               /* The next maximum number of stmtList */
+  int nStmt;                 /* Number of statements in stmtList */
+  IncrblobChannel *pIncrblob;/* Linked list of open incrblob channels */
+};
+
+struct IncrblobChannel {
+  sqlite3_blob *pBlob;      /* sqlite3 blob handle */
+  SqliteDb *pDb;            /* Associated database connection */
+  int iSeek;                /* Current seek offset */
+  Tcl_Channel channel;      /* Channel identifier */
+  IncrblobChannel *pNext;   /* Linked list of all open incrblob channels */
+  IncrblobChannel *pPrev;   /* Linked list of all open incrblob channels */
+};
+
+#ifndef SQLITE_OMIT_INCRBLOB
+/*
+** Close all incrblob channels opened using database connection pDb.
+** This is called when shutting down the database connection.
+*/
+static void closeIncrblobChannels(SqliteDb *pDb){
+  IncrblobChannel *p;
+  IncrblobChannel *pNext;
+
+  for(p=pDb->pIncrblob; p; p=pNext){
+    pNext = p->pNext;
+
+    /* Note: Calling unregister here call Tcl_Close on the incrblob channel, 
+    ** which deletes the IncrblobChannel structure at *p. So do not
+    ** call Tcl_Free() here.
+    */
+    Tcl_UnregisterChannel(pDb->interp, p->channel);
+  }
+}
+
+/*
+** Close an incremental blob channel.
+*/
+static int incrblobClose(ClientData instanceData, Tcl_Interp *interp){
+  IncrblobChannel *p = (IncrblobChannel *)instanceData;
+  int rc = sqlite3_blob_close(p->pBlob);
+  sqlite3 *db = p->pDb->db;
+
+  /* Remove the channel from the SqliteDb.pIncrblob list. */
+  if( p->pNext ){
+    p->pNext->pPrev = p->pPrev;
+  }
+  if( p->pPrev ){
+    p->pPrev->pNext = p->pNext;
+  }
+  if( p->pDb->pIncrblob==p ){
+    p->pDb->pIncrblob = p->pNext;
+  }
+
+  /* Free the IncrblobChannel structure */
+  Tcl_Free((char *)p);
+
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Read data from an incremental blob channel.
+*/
+static int incrblobInput(
+  ClientData instanceData, 
+  char *buf, 
+  int bufSize,
+  int *errorCodePtr
+){
+  IncrblobChannel *p = (IncrblobChannel *)instanceData;
+  int nRead = bufSize;         /* Number of bytes to read */
+  int nBlob;                   /* Total size of the blob */
+  int rc;                      /* sqlite error code */
+
+  nBlob = sqlite3_blob_bytes(p->pBlob);
+  if( (p->iSeek+nRead)>nBlob ){
+    nRead = nBlob-p->iSeek;
+  }
+  if( nRead<=0 ){
+    return 0;
+  }
+
+  rc = sqlite3_blob_read(p->pBlob, (void *)buf, nRead, p->iSeek);
+  if( rc!=SQLITE_OK ){
+    *errorCodePtr = rc;
+    return -1;
+  }
+
+  p->iSeek += nRead;
+  return nRead;
+}
+
+/*
+** Write data to an incremental blob channel.
+*/
+static int incrblobOutput(
+  ClientData instanceData, 
+  CONST char *buf, 
+  int toWrite,
+  int *errorCodePtr
+){
+  IncrblobChannel *p = (IncrblobChannel *)instanceData;
+  int nWrite = toWrite;        /* Number of bytes to write */
+  int nBlob;                   /* Total size of the blob */
+  int rc;                      /* sqlite error code */
+
+  nBlob = sqlite3_blob_bytes(p->pBlob);
+  if( (p->iSeek+nWrite)>nBlob ){
+    *errorCodePtr = EINVAL;
+    return -1;
+  }
+  if( nWrite<=0 ){
+    return 0;
+  }
+
+  rc = sqlite3_blob_write(p->pBlob, (void *)buf, nWrite, p->iSeek);
+  if( rc!=SQLITE_OK ){
+    *errorCodePtr = EIO;
+    return -1;
+  }
+
+  p->iSeek += nWrite;
+  return nWrite;
+}
+
+/*
+** Seek an incremental blob channel.
+*/
+static int incrblobSeek(
+  ClientData instanceData, 
+  long offset,
+  int seekMode,
+  int *errorCodePtr
+){
+  IncrblobChannel *p = (IncrblobChannel *)instanceData;
+
+  switch( seekMode ){
+    case SEEK_SET:
+      p->iSeek = offset;
+      break;
+    case SEEK_CUR:
+      p->iSeek += offset;
+      break;
+    case SEEK_END:
+      p->iSeek = sqlite3_blob_bytes(p->pBlob) + offset;
+      break;
+
+    default: assert(!"Bad seekMode");
+  }
+
+  return p->iSeek;
+}
+
+
+static void incrblobWatch(ClientData instanceData, int mode){ 
+  /* NO-OP */ 
+}
+static int incrblobHandle(ClientData instanceData, int dir, ClientData *hPtr){
+  return TCL_ERROR;
+}
+
+static Tcl_ChannelType IncrblobChannelType = {
+  "incrblob",                        /* typeName                             */
+  TCL_CHANNEL_VERSION_2,             /* version                              */
+  incrblobClose,                     /* closeProc                            */
+  incrblobInput,                     /* inputProc                            */
+  incrblobOutput,                    /* outputProc                           */
+  incrblobSeek,                      /* seekProc                             */
+  0,                                 /* setOptionProc                        */
+  0,                                 /* getOptionProc                        */
+  incrblobWatch,                     /* watchProc (this is a no-op)          */
+  incrblobHandle,                    /* getHandleProc (always returns error) */
+  0,                                 /* close2Proc                           */
+  0,                                 /* blockModeProc                        */
+  0,                                 /* flushProc                            */
+  0,                                 /* handlerProc                          */
+  0,                                 /* wideSeekProc                         */
+};
+
+/*
+** Create a new incrblob channel.
+*/
+static int createIncrblobChannel(
+  Tcl_Interp *interp, 
+  SqliteDb *pDb, 
+  const char *zDb,
+  const char *zTable, 
+  const char *zColumn, 
+  sqlite_int64 iRow,
+  int isReadonly
+){
+  IncrblobChannel *p;
+  sqlite3 *db = pDb->db;
+  sqlite3_blob *pBlob;
+  int rc;
+  int flags = TCL_READABLE|(isReadonly ? 0 : TCL_WRITABLE);
+
+  /* This variable is used to name the channels: "incrblob_[incr count]" */
+  static int count = 0;
+  char zChannel[64];
+
+  rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, &pBlob);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
+    return TCL_ERROR;
+  }
+
+  p = (IncrblobChannel *)Tcl_Alloc(sizeof(IncrblobChannel));
+  p->iSeek = 0;
+  p->pBlob = pBlob;
+
+  sqlite3_snprintf(sizeof(zChannel), zChannel, "incrblob_%d", ++count);
+  p->channel = Tcl_CreateChannel(&IncrblobChannelType, zChannel, p, flags);
+  Tcl_RegisterChannel(interp, p->channel);
+
+  /* Link the new channel into the SqliteDb.pIncrblob list. */
+  p->pNext = pDb->pIncrblob;
+  p->pPrev = 0;
+  if( p->pNext ){
+    p->pNext->pPrev = p;
+  }
+  pDb->pIncrblob = p;
+  p->pDb = pDb;
+
+  Tcl_SetResult(interp, (char *)Tcl_GetChannelName(p->channel), TCL_VOLATILE);
+  return TCL_OK;
+}
+#else  /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */
+  #define closeIncrblobChannels(pDb)
+#endif
+
+/*
+** Look at the script prefix in pCmd.  We will be executing this script
+** after first appending one or more arguments.  This routine analyzes
+** the script to see if it is safe to use Tcl_EvalObjv() on the script
+** rather than the more general Tcl_EvalEx().  Tcl_EvalObjv() is much
+** faster.
+**
+** Scripts that are safe to use with Tcl_EvalObjv() consists of a
+** command name followed by zero or more arguments with no [...] or $
+** or {...} or ; to be seen anywhere.  Most callback scripts consist
+** of just a single procedure name and they meet this requirement.
+*/
+static int safeToUseEvalObjv(Tcl_Interp *interp, Tcl_Obj *pCmd){
+  /* We could try to do something with Tcl_Parse().  But we will instead
+  ** just do a search for forbidden characters.  If any of the forbidden
+  ** characters appear in pCmd, we will report the string as unsafe.
+  */
+  const char *z;
+  int n;
+  z = Tcl_GetStringFromObj(pCmd, &n);
+  while( n-- > 0 ){
+    int c = *(z++);
+    if( c=='$' || c=='[' || c==';' ) return 0;
+  }
+  return 1;
+}
+
+/*
+** Find an SqlFunc structure with the given name.  Or create a new
+** one if an existing one cannot be found.  Return a pointer to the
+** structure.
+*/
+static SqlFunc *findSqlFunc(SqliteDb *pDb, const char *zName){
+  SqlFunc *p, *pNew;
+  int i;
+  pNew = (SqlFunc*)Tcl_Alloc( sizeof(*pNew) + strlen(zName) + 1 );
+  pNew->zName = (char*)&pNew[1];
+  for(i=0; zName[i]; i++){ pNew->zName[i] = tolower(zName[i]); }
+  pNew->zName[i] = 0;
+  for(p=pDb->pFunc; p; p=p->pNext){ 
+    if( strcmp(p->zName, pNew->zName)==0 ){
+      Tcl_Free((char*)pNew);
+      return p;
+    }
+  }
+  pNew->interp = pDb->interp;
+  pNew->pScript = 0;
+  pNew->pNext = pDb->pFunc;
+  pDb->pFunc = pNew;
+  return pNew;
+}
+
+/*
+** Finalize and free a list of prepared statements
+*/
+static void flushStmtCache( SqliteDb *pDb ){
+  SqlPreparedStmt *pPreStmt;
+
+  while(  pDb->stmtList ){
+    sqlite3_finalize( pDb->stmtList->pStmt );
+    pPreStmt = pDb->stmtList;
+    pDb->stmtList = pDb->stmtList->pNext;
+    Tcl_Free( (char*)pPreStmt );
+  }
+  pDb->nStmt = 0;
+  pDb->stmtLast = 0;
+}
+
+/*
+** TCL calls this procedure when an sqlite3 database command is
+** deleted.
+*/
+static void DbDeleteCmd(void *db){
+  SqliteDb *pDb = (SqliteDb*)db;
+  flushStmtCache(pDb);
+  closeIncrblobChannels(pDb);
+  sqlite3_close(pDb->db);
+  while( pDb->pFunc ){
+    SqlFunc *pFunc = pDb->pFunc;
+    pDb->pFunc = pFunc->pNext;
+    Tcl_DecrRefCount(pFunc->pScript);
+    Tcl_Free((char*)pFunc);
+  }
+  while( pDb->pCollate ){
+    SqlCollate *pCollate = pDb->pCollate;
+    pDb->pCollate = pCollate->pNext;
+    Tcl_Free((char*)pCollate);
+  }
+  if( pDb->zBusy ){
+    Tcl_Free(pDb->zBusy);
+  }
+  if( pDb->zTrace ){
+    Tcl_Free(pDb->zTrace);
+  }
+  if( pDb->zProfile ){
+    Tcl_Free(pDb->zProfile);
+  }
+  if( pDb->zAuth ){
+    Tcl_Free(pDb->zAuth);
+  }
+  if( pDb->zNull ){
+    Tcl_Free(pDb->zNull);
+  }
+  if( pDb->pUpdateHook ){
+    Tcl_DecrRefCount(pDb->pUpdateHook);
+  }
+  if( pDb->pRollbackHook ){
+    Tcl_DecrRefCount(pDb->pRollbackHook);
+  }
+  if( pDb->pCollateNeeded ){
+    Tcl_DecrRefCount(pDb->pCollateNeeded);
+  }
+  Tcl_Free((char*)pDb);
+}
+
+/*
+** This routine is called when a database file is locked while trying
+** to execute SQL.
+*/
+static int DbBusyHandler(void *cd, int nTries){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  int rc;
+  char zVal[30];
+
+  sqlite3_snprintf(sizeof(zVal), zVal, "%d", nTries);
+  rc = Tcl_VarEval(pDb->interp, pDb->zBusy, " ", zVal, (char*)0);
+  if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
+    return 0;
+  }
+  return 1;
+}
+
+/*
+** This routine is invoked as the 'progress callback' for the database.
+*/
+static int DbProgressHandler(void *cd){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  int rc;
+
+  assert( pDb->zProgress );
+  rc = Tcl_Eval(pDb->interp, pDb->zProgress);
+  if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
+    return 1;
+  }
+  return 0;
+}
+
+#ifndef SQLITE_OMIT_TRACE
+/*
+** This routine is called by the SQLite trace handler whenever a new
+** block of SQL is executed.  The TCL script in pDb->zTrace is executed.
+*/
+static void DbTraceHandler(void *cd, const char *zSql){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  Tcl_DString str;
+
+  Tcl_DStringInit(&str);
+  Tcl_DStringAppend(&str, pDb->zTrace, -1);
+  Tcl_DStringAppendElement(&str, zSql);
+  Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
+  Tcl_DStringFree(&str);
+  Tcl_ResetResult(pDb->interp);
+}
+#endif
+
+#ifndef SQLITE_OMIT_TRACE
+/*
+** This routine is called by the SQLite profile handler after a statement
+** SQL has executed.  The TCL script in pDb->zProfile is evaluated.
+*/
+static void DbProfileHandler(void *cd, const char *zSql, sqlite_uint64 tm){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  Tcl_DString str;
+  char zTm[100];
+
+  sqlite3_snprintf(sizeof(zTm)-1, zTm, "%lld", tm);
+  Tcl_DStringInit(&str);
+  Tcl_DStringAppend(&str, pDb->zProfile, -1);
+  Tcl_DStringAppendElement(&str, zSql);
+  Tcl_DStringAppendElement(&str, zTm);
+  Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));
+  Tcl_DStringFree(&str);
+  Tcl_ResetResult(pDb->interp);
+}
+#endif
+
+/*
+** This routine is called when a transaction is committed.  The
+** TCL script in pDb->zCommit is executed.  If it returns non-zero or
+** if it throws an exception, the transaction is rolled back instead
+** of being committed.
+*/
+static int DbCommitHandler(void *cd){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  int rc;
+
+  rc = Tcl_Eval(pDb->interp, pDb->zCommit);
+  if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){
+    return 1;
+  }
+  return 0;
+}
+
+static void DbRollbackHandler(void *clientData){
+  SqliteDb *pDb = (SqliteDb*)clientData;
+  assert(pDb->pRollbackHook);
+  if( TCL_OK!=Tcl_EvalObjEx(pDb->interp, pDb->pRollbackHook, 0) ){
+    Tcl_BackgroundError(pDb->interp);
+  }
+}
+
+static void DbUpdateHandler(
+  void *p, 
+  int op,
+  const char *zDb, 
+  const char *zTbl, 
+  sqlite_int64 rowid
+){
+  SqliteDb *pDb = (SqliteDb *)p;
+  Tcl_Obj *pCmd;
+
+  assert( pDb->pUpdateHook );
+  assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
+
+  pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);
+  Tcl_IncrRefCount(pCmd);
+  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(
+    ( (op==SQLITE_INSERT)?"INSERT":(op==SQLITE_UPDATE)?"UPDATE":"DELETE"), -1));
+  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));
+  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));
+  Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));
+  Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);
+}
+
+static void tclCollateNeeded(
+  void *pCtx,
+  sqlite3 *db,
+  int enc,
+  const char *zName
+){
+  SqliteDb *pDb = (SqliteDb *)pCtx;
+  Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);
+  Tcl_IncrRefCount(pScript);
+  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));
+  Tcl_EvalObjEx(pDb->interp, pScript, 0);
+  Tcl_DecrRefCount(pScript);
+}
+
+/*
+** This routine is called to evaluate an SQL collation function implemented
+** using TCL script.
+*/
+static int tclSqlCollate(
+  void *pCtx,
+  int nA,
+  const void *zA,
+  int nB,
+  const void *zB
+){
+  SqlCollate *p = (SqlCollate *)pCtx;
+  Tcl_Obj *pCmd;
+
+  pCmd = Tcl_NewStringObj(p->zScript, -1);
+  Tcl_IncrRefCount(pCmd);
+  Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));
+  Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));
+  Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
+  Tcl_DecrRefCount(pCmd);
+  return (atoi(Tcl_GetStringResult(p->interp)));
+}
+
+/*
+** This routine is called to evaluate an SQL function implemented
+** using TCL script.
+*/
+static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value**argv){
+  SqlFunc *p = sqlite3_user_data(context);
+  Tcl_Obj *pCmd;
+  int i;
+  int rc;
+
+  if( argc==0 ){
+    /* If there are no arguments to the function, call Tcl_EvalObjEx on the
+    ** script object directly.  This allows the TCL compiler to generate
+    ** bytecode for the command on the first invocation and thus make
+    ** subsequent invocations much faster. */
+    pCmd = p->pScript;
+    Tcl_IncrRefCount(pCmd);
+    rc = Tcl_EvalObjEx(p->interp, pCmd, 0);
+    Tcl_DecrRefCount(pCmd);
+  }else{
+    /* If there are arguments to the function, make a shallow copy of the
+    ** script object, lappend the arguments, then evaluate the copy.
+    **
+    ** By "shallow" copy, we mean a only the outer list Tcl_Obj is duplicated.
+    ** The new Tcl_Obj contains pointers to the original list elements. 
+    ** That way, when Tcl_EvalObjv() is run and shimmers the first element
+    ** of the list to tclCmdNameType, that alternate representation will
+    ** be preserved and reused on the next invocation.
+    */
+    Tcl_Obj **aArg;
+    int nArg;
+    if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){
+      sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 
+      return;
+    }     
+    pCmd = Tcl_NewListObj(nArg, aArg);
+    Tcl_IncrRefCount(pCmd);
+    for(i=0; i<argc; i++){
+      sqlite3_value *pIn = argv[i];
+      Tcl_Obj *pVal;
+            
+      /* Set pVal to contain the i'th column of this row. */
+      switch( sqlite3_value_type(pIn) ){
+        case SQLITE_BLOB: {
+          int bytes = sqlite3_value_bytes(pIn);
+          pVal = Tcl_NewByteArrayObj(sqlite3_value_blob(pIn), bytes);
+          break;
+        }
+        case SQLITE_INTEGER: {
+          sqlite_int64 v = sqlite3_value_int64(pIn);
+          if( v>=-2147483647 && v<=2147483647 ){
+            pVal = Tcl_NewIntObj(v);
+          }else{
+            pVal = Tcl_NewWideIntObj(v);
+          }
+          break;
+        }
+        case SQLITE_FLOAT: {
+          double r = sqlite3_value_double(pIn);
+          pVal = Tcl_NewDoubleObj(r);
+          break;
+        }
+        case SQLITE_NULL: {
+          pVal = Tcl_NewStringObj("", 0);
+          break;
+        }
+        default: {
+          int bytes = sqlite3_value_bytes(pIn);
+          pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);
+          break;
+        }
+      }
+      rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);
+      if( rc ){
+        Tcl_DecrRefCount(pCmd);
+        sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 
+        return;
+      }
+    }
+    if( !p->useEvalObjv ){
+      /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd
+      ** is a list without a string representation.  To prevent this from
+      ** happening, make sure pCmd has a valid string representation */
+      Tcl_GetString(pCmd);
+    }
+    rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);
+    Tcl_DecrRefCount(pCmd);
+  }
+
+  if( rc && rc!=TCL_RETURN ){
+    sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1); 
+  }else{
+    Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);
+    int n;
+    u8 *data;
+    char *zType = pVar->typePtr ? pVar->typePtr->name : "";
+    char c = zType[0];
+    if( c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0 ){
+      /* Only return a BLOB type if the Tcl variable is a bytearray and
+      ** has no string representation. */
+      data = Tcl_GetByteArrayFromObj(pVar, &n);
+      sqlite3_result_blob(context, data, n, SQLITE_TRANSIENT);
+    }else if( c=='b' && strcmp(zType,"boolean")==0 ){
+      Tcl_GetIntFromObj(0, pVar, &n);
+      sqlite3_result_int(context, n);
+    }else if( c=='d' && strcmp(zType,"double")==0 ){
+      double r;
+      Tcl_GetDoubleFromObj(0, pVar, &r);
+      sqlite3_result_double(context, r);
+    }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
+          (c=='i' && strcmp(zType,"int")==0) ){
+      Tcl_WideInt v;
+      Tcl_GetWideIntFromObj(0, pVar, &v);
+      sqlite3_result_int64(context, v);
+    }else{
+      data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
+      sqlite3_result_text(context, (char *)data, n, SQLITE_TRANSIENT);
+    }
+  }
+}
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+/*
+** This is the authentication function.  It appends the authentication
+** type code and the two arguments to zCmd[] then invokes the result
+** on the interpreter.  The reply is examined to determine if the
+** authentication fails or succeeds.
+*/
+static int auth_callback(
+  void *pArg,
+  int code,
+  const char *zArg1,
+  const char *zArg2,
+  const char *zArg3,
+  const char *zArg4
+){
+  char *zCode;
+  Tcl_DString str;
+  int rc;
+  const char *zReply;
+  SqliteDb *pDb = (SqliteDb*)pArg;
+
+  switch( code ){
+    case SQLITE_COPY              : zCode="SQLITE_COPY"; break;
+    case SQLITE_CREATE_INDEX      : zCode="SQLITE_CREATE_INDEX"; break;
+    case SQLITE_CREATE_TABLE      : zCode="SQLITE_CREATE_TABLE"; break;
+    case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;
+    case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;
+    case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;
+    case SQLITE_CREATE_TEMP_VIEW  : zCode="SQLITE_CREATE_TEMP_VIEW"; break;
+    case SQLITE_CREATE_TRIGGER    : zCode="SQLITE_CREATE_TRIGGER"; break;
+    case SQLITE_CREATE_VIEW       : zCode="SQLITE_CREATE_VIEW"; break;
+    case SQLITE_DELETE            : zCode="SQLITE_DELETE"; break;
+    case SQLITE_DROP_INDEX        : zCode="SQLITE_DROP_INDEX"; break;
+    case SQLITE_DROP_TABLE        : zCode="SQLITE_DROP_TABLE"; break;
+    case SQLITE_DROP_TEMP_INDEX   : zCode="SQLITE_DROP_TEMP_INDEX"; break;
+    case SQLITE_DROP_TEMP_TABLE   : zCode="SQLITE_DROP_TEMP_TABLE"; break;
+    case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;
+    case SQLITE_DROP_TEMP_VIEW    : zCode="SQLITE_DROP_TEMP_VIEW"; break;
+    case SQLITE_DROP_TRIGGER      : zCode="SQLITE_DROP_TRIGGER"; break;
+    case SQLITE_DROP_VIEW         : zCode="SQLITE_DROP_VIEW"; break;
+    case SQLITE_INSERT            : zCode="SQLITE_INSERT"; break;
+    case SQLITE_PRAGMA            : zCode="SQLITE_PRAGMA"; break;
+    case SQLITE_READ              : zCode="SQLITE_READ"; break;
+    case SQLITE_SELECT            : zCode="SQLITE_SELECT"; break;
+    case SQLITE_TRANSACTION       : zCode="SQLITE_TRANSACTION"; break;
+    case SQLITE_UPDATE            : zCode="SQLITE_UPDATE"; break;
+    case SQLITE_ATTACH            : zCode="SQLITE_ATTACH"; break;
+    case SQLITE_DETACH            : zCode="SQLITE_DETACH"; break;
+    case SQLITE_ALTER_TABLE       : zCode="SQLITE_ALTER_TABLE"; break;
+    case SQLITE_REINDEX           : zCode="SQLITE_REINDEX"; break;
+    case SQLITE_ANALYZE           : zCode="SQLITE_ANALYZE"; break;
+    case SQLITE_CREATE_VTABLE     : zCode="SQLITE_CREATE_VTABLE"; break;
+    case SQLITE_DROP_VTABLE       : zCode="SQLITE_DROP_VTABLE"; break;
+    case SQLITE_FUNCTION          : zCode="SQLITE_FUNCTION"; break;
+    default                       : zCode="????"; break;
+  }
+  Tcl_DStringInit(&str);
+  Tcl_DStringAppend(&str, pDb->zAuth, -1);
+  Tcl_DStringAppendElement(&str, zCode);
+  Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");
+  Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");
+  Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");
+  Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");
+  rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));
+  Tcl_DStringFree(&str);
+  zReply = Tcl_GetStringResult(pDb->interp);
+  if( strcmp(zReply,"SQLITE_OK")==0 ){
+    rc = SQLITE_OK;
+  }else if( strcmp(zReply,"SQLITE_DENY")==0 ){
+    rc = SQLITE_DENY;
+  }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){
+    rc = SQLITE_IGNORE;
+  }else{
+    rc = 999;
+  }
+  return rc;
+}
+#endif /* SQLITE_OMIT_AUTHORIZATION */
+
+/*
+** zText is a pointer to text obtained via an sqlite3_result_text()
+** or similar interface. This routine returns a Tcl string object, 
+** reference count set to 0, containing the text. If a translation
+** between iso8859 and UTF-8 is required, it is preformed.
+*/
+static Tcl_Obj *dbTextToObj(char const *zText){
+  Tcl_Obj *pVal;
+#ifdef UTF_TRANSLATION_NEEDED
+  Tcl_DString dCol;
+  Tcl_DStringInit(&dCol);
+  Tcl_ExternalToUtfDString(NULL, zText, -1, &dCol);
+  pVal = Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1);
+  Tcl_DStringFree(&dCol);
+#else
+  pVal = Tcl_NewStringObj(zText, -1);
+#endif
+  return pVal;
+}
+
+/*
+** This routine reads a line of text from FILE in, stores
+** the text in memory obtained from malloc() and returns a pointer
+** to the text.  NULL is returned at end of file, or if malloc()
+** fails.
+**
+** The interface is like "readline" but no command-line editing
+** is done.
+**
+** copied from shell.c from '.import' command
+*/
+static char *local_getline(char *zPrompt, FILE *in){
+  char *zLine;
+  int nLine;
+  int n;
+  int eol;
+
+  nLine = 100;
+  zLine = malloc( nLine );
+  if( zLine==0 ) return 0;
+  n = 0;
+  eol = 0;
+  while( !eol ){
+    if( n+100>nLine ){
+      nLine = nLine*2 + 100;
+      zLine = realloc(zLine, nLine);
+      if( zLine==0 ) return 0;
+    }
+    if( fgets(&zLine[n], nLine - n, in)==0 ){
+      if( n==0 ){
+        free(zLine);
+        return 0;
+      }
+      zLine[n] = 0;
+      eol = 1;
+      break;
+    }
+    while( zLine[n] ){ n++; }
+    if( n>0 && zLine[n-1]=='\n' ){
+      n--;
+      zLine[n] = 0;
+      eol = 1;
+    }
+  }
+  zLine = realloc( zLine, n+1 );
+  return zLine;
+}
+
+
+/*
+** Figure out the column names for the data returned by the statement
+** passed as the second argument.
+**
+** If parameter papColName is not NULL, then *papColName is set to point
+** at an array allocated using Tcl_Alloc(). It is the callers responsibility
+** to free this array using Tcl_Free(), and to decrement the reference
+** count of each Tcl_Obj* member of the array.
+**
+** The return value of this function is the number of columns of data
+** returned by pStmt (and hence the size of the *papColName array).
+**
+** If pArray is not NULL, then it contains the name of a Tcl array
+** variable. The "*" member of this array is set to a list containing
+** the names of the columns returned by the statement, in order from
+** left to right. e.g. if the names of the returned columns are a, b and
+** c, it does the equivalent of the tcl command:
+**
+**     set ${pArray}(*) {a b c}
+*/
+static int
+computeColumnNames(
+  Tcl_Interp *interp, 
+  sqlite3_stmt *pStmt,              /* SQL statement */
+  Tcl_Obj ***papColName,            /* OUT: Array of column names */
+  Tcl_Obj *pArray                   /* Name of array variable (may be null) */
+){
+  int nCol;
+
+  /* Compute column names */
+  nCol = sqlite3_column_count(pStmt);
+  if( papColName ){
+    int i;
+    Tcl_Obj **apColName = (Tcl_Obj**)Tcl_Alloc( sizeof(Tcl_Obj*)*nCol );
+    for(i=0; i<nCol; i++){
+      apColName[i] = dbTextToObj(sqlite3_column_name(pStmt,i));
+      Tcl_IncrRefCount(apColName[i]);
+    }
+
+    /* If results are being stored in an array variable, then create
+    ** the array(*) entry for that array
+    */
+    if( pArray ){
+      Tcl_Obj *pColList = Tcl_NewObj();
+      Tcl_Obj *pStar = Tcl_NewStringObj("*", -1);
+      Tcl_IncrRefCount(pColList);
+      for(i=0; i<nCol; i++){
+        Tcl_ListObjAppendElement(interp, pColList, apColName[i]);
+      }
+      Tcl_IncrRefCount(pStar);
+      Tcl_ObjSetVar2(interp, pArray, pStar, pColList,0);
+      Tcl_DecrRefCount(pColList);
+      Tcl_DecrRefCount(pStar);
+    }
+    *papColName = apColName;
+  }
+
+  return nCol;
+}
+
+/*
+** The "sqlite" command below creates a new Tcl command for each
+** connection it opens to an SQLite database.  This routine is invoked
+** whenever one of those connection-specific commands is executed
+** in Tcl.  For example, if you run Tcl code like this:
+**
+**       sqlite3 db1  "my_database"
+**       db1 close
+**
+** The first command opens a connection to the "my_database" database
+** and calls that connection "db1".  The second command causes this
+** subroutine to be invoked.
+*/
+static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
+  SqliteDb *pDb = (SqliteDb*)cd;
+  int choice;
+  int rc = TCL_OK;
+  static const char *DB_strs[] = {
+    "authorizer",         "busy",              "cache",
+    "changes",            "close",             "collate",
+    "collation_needed",   "commit_hook",       "complete",
+    "copy",               "enable_load_extension","errorcode",
+    "eval",               "exists",            "function",
+    "incrblob",           "interrupt",         "last_insert_rowid",
+    "nullvalue",          "onecolumn",         "profile",
+    "progress",           "rekey",             "rollback_hook",
+    "timeout",            "total_changes",     "trace",
+    "transaction",        "update_hook",       "version",
+    0                    
+  };
+  enum DB_enum {
+    DB_AUTHORIZER,        DB_BUSY,             DB_CACHE,
+    DB_CHANGES,           DB_CLOSE,            DB_COLLATE,
+    DB_COLLATION_NEEDED,  DB_COMMIT_HOOK,      DB_COMPLETE,
+    DB_COPY,              DB_ENABLE_LOAD_EXTENSION,DB_ERRORCODE,
+    DB_EVAL,              DB_EXISTS,           DB_FUNCTION,
+    DB_INCRBLOB,          DB_INTERRUPT,        DB_LAST_INSERT_ROWID,
+    DB_NULLVALUE,         DB_ONECOLUMN,        DB_PROFILE,
+    DB_PROGRESS,          DB_REKEY,            DB_ROLLBACK_HOOK,
+    DB_TIMEOUT,           DB_TOTAL_CHANGES,    DB_TRACE,
+    DB_TRANSACTION,       DB_UPDATE_HOOK,      DB_VERSION
+  };
+  /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
+
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){
+    return TCL_ERROR;
+  }
+
+  switch( (enum DB_enum)choice ){
+
+  /*    $db authorizer ?CALLBACK?
+  **
+  ** Invoke the given callback to authorize each SQL operation as it is
+  ** compiled.  5 arguments are appended to the callback before it is
+  ** invoked:
+  **
+  **   (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
+  **   (2) First descriptive name (depends on authorization type)
+  **   (3) Second descriptive name
+  **   (4) Name of the database (ex: "main", "temp")
+  **   (5) Name of trigger that is doing the access
+  **
+  ** The callback should return on of the following strings: SQLITE_OK,
+  ** SQLITE_IGNORE, or SQLITE_DENY.  Any other return value is an error.
+  **
+  ** If this method is invoked with no arguments, the current authorization
+  ** callback string is returned.
+  */
+  case DB_AUTHORIZER: {
+#ifdef SQLITE_OMIT_AUTHORIZATION
+    Tcl_AppendResult(interp, "authorization not available in this build", 0);
+    return TCL_ERROR;
+#else
+    if( objc>3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
+      return TCL_ERROR;
+    }else if( objc==2 ){
+      if( pDb->zAuth ){
+        Tcl_AppendResult(interp, pDb->zAuth, 0);
+      }
+    }else{
+      char *zAuth;
+      int len;
+      if( pDb->zAuth ){
+        Tcl_Free(pDb->zAuth);
+      }
+      zAuth = Tcl_GetStringFromObj(objv[2], &len);
+      if( zAuth && len>0 ){
+        pDb->zAuth = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zAuth, zAuth, len+1);
+      }else{
+        pDb->zAuth = 0;
+      }
+      if( pDb->zAuth ){
+        pDb->interp = interp;
+        sqlite3_set_authorizer(pDb->db, auth_callback, pDb);
+      }else{
+        sqlite3_set_authorizer(pDb->db, 0, 0);
+      }
+    }
+#endif
+    break;
+  }
+
+  /*    $db busy ?CALLBACK?
+  **
+  ** Invoke the given callback if an SQL statement attempts to open
+  ** a locked database file.
+  */
+  case DB_BUSY: {
+    if( objc>3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK");
+      return TCL_ERROR;
+    }else if( objc==2 ){
+      if( pDb->zBusy ){
+        Tcl_AppendResult(interp, pDb->zBusy, 0);
+      }
+    }else{
+      char *zBusy;
+      int len;
+      if( pDb->zBusy ){
+        Tcl_Free(pDb->zBusy);
+      }
+      zBusy = Tcl_GetStringFromObj(objv[2], &len);
+      if( zBusy && len>0 ){
+        pDb->zBusy = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zBusy, zBusy, len+1);
+      }else{
+        pDb->zBusy = 0;
+      }
+      if( pDb->zBusy ){
+        pDb->interp = interp;
+        sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);
+      }else{
+        sqlite3_busy_handler(pDb->db, 0, 0);
+      }
+    }
+    break;
+  }
+
+  /*     $db cache flush
+  **     $db cache size n
+  **
+  ** Flush the prepared statement cache, or set the maximum number of
+  ** cached statements.
+  */
+  case DB_CACHE: {
+    char *subCmd;
+    int n;
+
+    if( objc<=2 ){
+      Tcl_WrongNumArgs(interp, 1, objv, "cache option ?arg?");
+      return TCL_ERROR;
+    }
+    subCmd = Tcl_GetStringFromObj( objv[2], 0 );
+    if( *subCmd=='f' && strcmp(subCmd,"flush")==0 ){
+      if( objc!=3 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "flush");
+        return TCL_ERROR;
+      }else{
+        flushStmtCache( pDb );
+      }
+    }else if( *subCmd=='s' && strcmp(subCmd,"size")==0 ){
+      if( objc!=4 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "size n");
+        return TCL_ERROR;
+      }else{
+        if( TCL_ERROR==Tcl_GetIntFromObj(interp, objv[3], &n) ){
+          Tcl_AppendResult( interp, "cannot convert \"", 
+               Tcl_GetStringFromObj(objv[3],0), "\" to integer", 0);
+          return TCL_ERROR;
+        }else{
+          if( n<0 ){
+            flushStmtCache( pDb );
+            n = 0;
+          }else if( n>MAX_PREPARED_STMTS ){
+            n = MAX_PREPARED_STMTS;
+          }
+          pDb->maxStmt = n;
+        }
+      }
+    }else{
+      Tcl_AppendResult( interp, "bad option \"", 
+          Tcl_GetStringFromObj(objv[2],0), "\": must be flush or size", 0);
+      return TCL_ERROR;
+    }
+    break;
+  }
+
+  /*     $db changes
+  **
+  ** Return the number of rows that were modified, inserted, or deleted by
+  ** the most recent INSERT, UPDATE or DELETE statement, not including 
+  ** any changes made by trigger programs.
+  */
+  case DB_CHANGES: {
+    Tcl_Obj *pResult;
+    if( objc!=2 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "");
+      return TCL_ERROR;
+    }
+    pResult = Tcl_GetObjResult(interp);
+    Tcl_SetIntObj(pResult, sqlite3_changes(pDb->db));
+    break;
+  }
+
+  /*    $db close
+  **
+  ** Shutdown the database
+  */
+  case DB_CLOSE: {
+    Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0));
+    break;
+  }
+
+  /*
+  **     $db collate NAME SCRIPT
+  **
+  ** Create a new SQL collation function called NAME.  Whenever
+  ** that function is called, invoke SCRIPT to evaluate the function.
+  */
+  case DB_COLLATE: {
+    SqlCollate *pCollate;
+    char *zName;
+    char *zScript;
+    int nScript;
+    if( objc!=4 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
+      return TCL_ERROR;
+    }
+    zName = Tcl_GetStringFromObj(objv[2], 0);
+    zScript = Tcl_GetStringFromObj(objv[3], &nScript);
+    pCollate = (SqlCollate*)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );
+    if( pCollate==0 ) return TCL_ERROR;
+    pCollate->interp = interp;
+    pCollate->pNext = pDb->pCollate;
+    pCollate->zScript = (char*)&pCollate[1];
+    pDb->pCollate = pCollate;
+    memcpy(pCollate->zScript, zScript, nScript+1);
+    if( sqlite3_create_collation(pDb->db, zName, SQLITE_UTF8, 
+        pCollate, tclSqlCollate) ){
+      Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
+      return TCL_ERROR;
+    }
+    break;
+  }
+
+  /*
+  **     $db collation_needed SCRIPT
+  **
+  ** Create a new SQL collation function called NAME.  Whenever
+  ** that function is called, invoke SCRIPT to evaluate the function.
+  */
+  case DB_COLLATION_NEEDED: {
+    if( objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "SCRIPT");
+      return TCL_ERROR;
+    }
+    if( pDb->pCollateNeeded ){
+      Tcl_DecrRefCount(pDb->pCollateNeeded);
+    }
+    pDb->pCollateNeeded = Tcl_DuplicateObj(objv[2]);
+    Tcl_IncrRefCount(pDb->pCollateNeeded);
+    sqlite3_collation_needed(pDb->db, pDb, tclCollateNeeded);
+    break;
+  }
+
+  /*    $db commit_hook ?CALLBACK?
+  **
+  ** Invoke the given callback just before committing every SQL transaction.
+  ** If the callback throws an exception or returns non-zero, then the
+  ** transaction is aborted.  If CALLBACK is an empty string, the callback
+  ** is disabled.
+  */
+  case DB_COMMIT_HOOK: {
+    if( objc>3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
+      return TCL_ERROR;
+    }else if( objc==2 ){
+      if( pDb->zCommit ){
+        Tcl_AppendResult(interp, pDb->zCommit, 0);
+      }
+    }else{
+      char *zCommit;
+      int len;
+      if( pDb->zCommit ){
+        Tcl_Free(pDb->zCommit);
+      }
+      zCommit = Tcl_GetStringFromObj(objv[2], &len);
+      if( zCommit && len>0 ){
+        pDb->zCommit = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zCommit, zCommit, len+1);
+      }else{
+        pDb->zCommit = 0;
+      }
+      if( pDb->zCommit ){
+        pDb->interp = interp;
+        sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);
+      }else{
+        sqlite3_commit_hook(pDb->db, 0, 0);
+      }
+    }
+    break;
+  }
+
+  /*    $db complete SQL
+  **
+  ** Return TRUE if SQL is a complete SQL statement.  Return FALSE if
+  ** additional lines of input are needed.  This is similar to the
+  ** built-in "info complete" command of Tcl.
+  */
+  case DB_COMPLETE: {
+#ifndef SQLITE_OMIT_COMPLETE
+    Tcl_Obj *pResult;
+    int isComplete;
+    if( objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "SQL");
+      return TCL_ERROR;
+    }
+    isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );
+    pResult = Tcl_GetObjResult(interp);
+    Tcl_SetBooleanObj(pResult, isComplete);
+#endif
+    break;
+  }
+
+  /*    $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
+  **
+  ** Copy data into table from filename, optionally using SEPARATOR
+  ** as column separators.  If a column contains a null string, or the
+  ** value of NULLINDICATOR, a NULL is inserted for the column.
+  ** conflict-algorithm is one of the sqlite conflict algorithms:
+  **    rollback, abort, fail, ignore, replace
+  ** On success, return the number of lines processed, not necessarily same
+  ** as 'db changes' due to conflict-algorithm selected.
+  **
+  ** This code is basically an implementation/enhancement of
+  ** the sqlite3 shell.c ".import" command.
+  **
+  ** This command usage is equivalent to the sqlite2.x COPY statement,
+  ** which imports file data into a table using the PostgreSQL COPY file format:
+  **   $db copy $conflit_algo $table_name $filename \t \\N
+  */
+  case DB_COPY: {
+    char *zTable;               /* Insert data into this table */
+    char *zFile;                /* The file from which to extract data */
+    char *zConflict;            /* The conflict algorithm to use */
+    sqlite3_stmt *pStmt;        /* A statement */
+    int rc;                     /* Result code */
+    int nCol;                   /* Number of columns in the table */
+    int nByte;                  /* Number of bytes in an SQL string */
+    int i, j;                   /* Loop counters */
+    int nSep;                   /* Number of bytes in zSep[] */
+    int nNull;                  /* Number of bytes in zNull[] */
+    char *zSql;                 /* An SQL statement */
+    char *zLine;                /* A single line of input from the file */
+    char **azCol;               /* zLine[] broken up into columns */
+    char *zCommit;              /* How to commit changes */
+    FILE *in;                   /* The input file */
+    int lineno = 0;             /* Line number of input file */
+    char zLineNum[80];          /* Line number print buffer */
+    Tcl_Obj *pResult;           /* interp result */
+
+    char *zSep;
+    char *zNull;
+    if( objc<5 || objc>7 ){
+      Tcl_WrongNumArgs(interp, 2, objv, 
+         "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");
+      return TCL_ERROR;
+    }
+    if( objc>=6 ){
+      zSep = Tcl_GetStringFromObj(objv[5], 0);
+    }else{
+      zSep = "\t";
+    }
+    if( objc>=7 ){
+      zNull = Tcl_GetStringFromObj(objv[6], 0);
+    }else{
+      zNull = "";
+    }
+    zConflict = Tcl_GetStringFromObj(objv[2], 0);
+    zTable = Tcl_GetStringFromObj(objv[3], 0);
+    zFile = Tcl_GetStringFromObj(objv[4], 0);
+    nSep = strlen(zSep);
+    nNull = strlen(zNull);
+    if( nSep==0 ){
+      Tcl_AppendResult(interp,"Error: non-null separator required for copy",0);
+      return TCL_ERROR;
+    }
+    if(sqlite3StrICmp(zConflict, "rollback") != 0 &&
+       sqlite3StrICmp(zConflict, "abort"   ) != 0 &&
+       sqlite3StrICmp(zConflict, "fail"    ) != 0 &&
+       sqlite3StrICmp(zConflict, "ignore"  ) != 0 &&
+       sqlite3StrICmp(zConflict, "replace" ) != 0 ) {
+      Tcl_AppendResult(interp, "Error: \"", zConflict, 
+            "\", conflict-algorithm must be one of: rollback, "
+            "abort, fail, ignore, or replace", 0);
+      return TCL_ERROR;
+    }
+    zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);
+    if( zSql==0 ){
+      Tcl_AppendResult(interp, "Error: no such table: ", zTable, 0);
+      return TCL_ERROR;
+    }
+    nByte = strlen(zSql);
+    rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
+    sqlite3_free(zSql);
+    if( rc ){
+      Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);
+      nCol = 0;
+    }else{
+      nCol = sqlite3_column_count(pStmt);
+    }
+    sqlite3_finalize(pStmt);
+    if( nCol==0 ) {
+      return TCL_ERROR;
+    }
+    zSql = malloc( nByte + 50 + nCol*2 );
+    if( zSql==0 ) {
+      Tcl_AppendResult(interp, "Error: can't malloc()", 0);
+      return TCL_ERROR;
+    }
+    sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
+         zConflict, zTable);
+    j = strlen(zSql);
+    for(i=1; i<nCol; i++){
+      zSql[j++] = ',';
+      zSql[j++] = '?';
+    }
+    zSql[j++] = ')';
+    zSql[j] = 0;
+    rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);
+    free(zSql);
+    if( rc ){
+      Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), 0);
+      sqlite3_finalize(pStmt);
+      return TCL_ERROR;
+    }
+    in = fopen(zFile, "rb");
+    if( in==0 ){
+      Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, NULL);
+      sqlite3_finalize(pStmt);
+      return TCL_ERROR;
+    }
+    azCol = malloc( sizeof(azCol[0])*(nCol+1) );
+    if( azCol==0 ) {
+      Tcl_AppendResult(interp, "Error: can't malloc()", 0);
+      fclose(in);
+      return TCL_ERROR;
+    }
+    (void)sqlite3_exec(pDb->db, "BEGIN", 0, 0, 0);
+    zCommit = "COMMIT";
+    while( (zLine = local_getline(0, in))!=0 ){
+      char *z;
+      i = 0;
+      lineno++;
+      azCol[0] = zLine;
+      for(i=0, z=zLine; *z; z++){
+        if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){
+          *z = 0;
+          i++;
+          if( i<nCol ){
+            azCol[i] = &z[nSep];
+            z += nSep-1;
+          }
+        }
+      }
+      if( i+1!=nCol ){
+        char *zErr;
+        int nErr = strlen(zFile) + 200;
+        zErr = malloc(nErr);
+        if( zErr ){
+          sqlite3_snprintf(nErr, zErr,
+             "Error: %s line %d: expected %d columns of data but found %d",
+             zFile, lineno, nCol, i+1);
+          Tcl_AppendResult(interp, zErr, 0);
+          free(zErr);
+        }
+        zCommit = "ROLLBACK";
+        break;
+      }
+      for(i=0; i<nCol; i++){
+        /* check for null data, if so, bind as null */
+        if ((nNull>0 && strcmp(azCol[i], zNull)==0) || strlen(azCol[i])==0) {
+          sqlite3_bind_null(pStmt, i+1);
+        }else{
+          sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
+        }
+      }
+      sqlite3_step(pStmt);
+      rc = sqlite3_reset(pStmt);
+      free(zLine);
+      if( rc!=SQLITE_OK ){
+        Tcl_AppendResult(interp,"Error: ", sqlite3_errmsg(pDb->db), 0);
+        zCommit = "ROLLBACK";
+        break;
+      }
+    }
+    free(azCol);
+    fclose(in);
+    sqlite3_finalize(pStmt);
+    (void)sqlite3_exec(pDb->db, zCommit, 0, 0, 0);
+
+    if( zCommit[0] == 'C' ){
+      /* success, set result as number of lines processed */
+      pResult = Tcl_GetObjResult(interp);
+      Tcl_SetIntObj(pResult, lineno);
+      rc = TCL_OK;
+    }else{
+      /* failure, append lineno where failed */
+      sqlite3_snprintf(sizeof(zLineNum), zLineNum,"%d",lineno);
+      Tcl_AppendResult(interp,", failed while processing line: ",zLineNum,0);
+      rc = TCL_ERROR;
+    }
+    break;
+  }
+
+  /*
+  **    $db enable_load_extension BOOLEAN
+  **
+  ** Turn the extension loading feature on or off.  It if off by
+  ** default.
+  */
+  case DB_ENABLE_LOAD_EXTENSION: {
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+    int onoff;
+    if( objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "BOOLEAN");
+      return TCL_ERROR;
+    }
+    if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
+      return TCL_ERROR;
+    }
+    sqlite3_enable_load_extension(pDb->db, onoff);
+    break;
+#else
+    Tcl_AppendResult(interp, "extension loading is turned off at compile-time",
+                     0);
+    return TCL_ERROR;
+#endif
+  }
+
+  /*
+  **    $db errorcode
+  **
+  ** Return the numeric error code that was returned by the most recent
+  ** call to sqlite3_exec().
+  */
+  case DB_ERRORCODE: {
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_errcode(pDb->db)));
+    break;
+  }
+   
+  /*
+  **    $db eval $sql ?array? ?{  ...code... }?
+  **    $db onecolumn $sql
+  **
+  ** The SQL statement in $sql is evaluated.  For each row, the values are
+  ** placed in elements of the array named "array" and ...code... is executed.
+  ** If "array" and "code" are omitted, then no callback is every invoked.
+  ** If "array" is an empty string, then the values are placed in variables
+  ** that have the same name as the fields extracted by the query.
+  **
+  ** The onecolumn method is the equivalent of:
+  **     lindex [$db eval $sql] 0
+  */
+  case DB_ONECOLUMN:
+  case DB_EVAL:
+  case DB_EXISTS: {
+    char const *zSql;      /* Next SQL statement to execute */
+    char const *zLeft;     /* What is left after first stmt in zSql */
+    sqlite3_stmt *pStmt;   /* Compiled SQL statment */
+    Tcl_Obj *pArray;       /* Name of array into which results are written */
+    Tcl_Obj *pScript;      /* Script to run for each result set */
+    Tcl_Obj **apParm;      /* Parameters that need a Tcl_DecrRefCount() */
+    int nParm;             /* Number of entries used in apParm[] */
+    Tcl_Obj *aParm[10];    /* Static space for apParm[] in the common case */
+    Tcl_Obj *pRet;         /* Value to be returned */
+    SqlPreparedStmt *pPreStmt;  /* Pointer to a prepared statement */
+    int rc2;
+
+    if( choice==DB_EVAL ){
+      if( objc<3 || objc>5 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "SQL ?ARRAY-NAME? ?SCRIPT?");
+        return TCL_ERROR;
+      }
+      pRet = Tcl_NewObj();
+      Tcl_IncrRefCount(pRet);
+    }else{
+      if( objc!=3 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "SQL");
+        return TCL_ERROR;
+      }
+      if( choice==DB_EXISTS ){
+        pRet = Tcl_NewBooleanObj(0);
+        Tcl_IncrRefCount(pRet);
+      }else{
+        pRet = 0;
+      }
+    }
+    if( objc==3 ){
+      pArray = pScript = 0;
+    }else if( objc==4 ){
+      pArray = 0;
+      pScript = objv[3];
+    }else{
+      pArray = objv[3];
+      if( Tcl_GetString(pArray)[0]==0 ) pArray = 0;
+      pScript = objv[4];
+    }
+
+    Tcl_IncrRefCount(objv[2]);
+    zSql = Tcl_GetStringFromObj(objv[2], 0);
+    while( rc==TCL_OK && zSql[0] ){
+      int i;                     /* Loop counter */
+      int nVar;                  /* Number of bind parameters in the pStmt */
+      int nCol = -1;             /* Number of columns in the result set */
+      Tcl_Obj **apColName = 0;   /* Array of column names */
+      int len;                   /* String length of zSql */
+  
+      /* Try to find a SQL statement that has already been compiled and
+      ** which matches the next sequence of SQL.
+      */
+      pStmt = 0;
+      len = strlen(zSql);
+      for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pPreStmt->pNext){
+        int n = pPreStmt->nSql;
+        if( len>=n 
+            && memcmp(pPreStmt->zSql, zSql, n)==0
+            && (zSql[n]==0 || zSql[n-1]==';')
+        ){
+          pStmt = pPreStmt->pStmt;
+          zLeft = &zSql[pPreStmt->nSql];
+
+          /* When a prepared statement is found, unlink it from the
+          ** cache list.  It will later be added back to the beginning
+          ** of the cache list in order to implement LRU replacement.
+          */
+          if( pPreStmt->pPrev ){
+            pPreStmt->pPrev->pNext = pPreStmt->pNext;
+          }else{
+            pDb->stmtList = pPreStmt->pNext;
+          }
+          if( pPreStmt->pNext ){
+            pPreStmt->pNext->pPrev = pPreStmt->pPrev;
+          }else{
+            pDb->stmtLast = pPreStmt->pPrev;
+          }
+          pDb->nStmt--;
+          break;
+        }
+      }
+  
+      /* If no prepared statement was found.  Compile the SQL text
+      */
+      if( pStmt==0 ){
+        if( SQLITE_OK!=sqlite3_prepare_v2(pDb->db, zSql, -1, &pStmt, &zLeft) ){
+          Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
+          rc = TCL_ERROR;
+          break;
+        }
+        if( pStmt==0 ){
+          if( SQLITE_OK!=sqlite3_errcode(pDb->db) ){
+            /* A compile-time error in the statement
+            */
+            Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
+            rc = TCL_ERROR;
+            break;
+          }else{
+            /* The statement was a no-op.  Continue to the next statement
+            ** in the SQL string.
+            */
+            zSql = zLeft;
+            continue;
+          }
+        }
+        assert( pPreStmt==0 );
+      }
+
+      /* Bind values to parameters that begin with $ or :
+      */  
+      nVar = sqlite3_bind_parameter_count(pStmt);
+      nParm = 0;
+      if( nVar>sizeof(aParm)/sizeof(aParm[0]) ){
+        apParm = (Tcl_Obj**)Tcl_Alloc(nVar*sizeof(apParm[0]));
+      }else{
+        apParm = aParm;
+      }
+      for(i=1; i<=nVar; i++){
+        const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
+        if( zVar!=0 && (zVar[0]=='$' || zVar[0]==':' || zVar[0]=='@') ){
+          Tcl_Obj *pVar = Tcl_GetVar2Ex(interp, &zVar[1], 0, 0);
+          if( pVar ){
+            int n;
+            u8 *data;
+            char *zType = pVar->typePtr ? pVar->typePtr->name : "";
+            char c = zType[0];
+            if( zVar[0]=='@' ||
+               (c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0) ){
+              /* Load a BLOB type if the Tcl variable is a bytearray and
+              ** it has no string representation or the host
+              ** parameter name begins with "@". */
+              data = Tcl_GetByteArrayFromObj(pVar, &n);
+              sqlite3_bind_blob(pStmt, i, data, n, SQLITE_STATIC);
+              Tcl_IncrRefCount(pVar);
+              apParm[nParm++] = pVar;
+            }else if( c=='b' && strcmp(zType,"boolean")==0 ){
+              Tcl_GetIntFromObj(interp, pVar, &n);
+              sqlite3_bind_int(pStmt, i, n);
+            }else if( c=='d' && strcmp(zType,"double")==0 ){
+              double r;
+              Tcl_GetDoubleFromObj(interp, pVar, &r);
+              sqlite3_bind_double(pStmt, i, r);
+            }else if( (c=='w' && strcmp(zType,"wideInt")==0) ||
+                  (c=='i' && strcmp(zType,"int")==0) ){
+              Tcl_WideInt v;
+              Tcl_GetWideIntFromObj(interp, pVar, &v);
+              sqlite3_bind_int64(pStmt, i, v);
+            }else{
+              data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);
+              sqlite3_bind_text(pStmt, i, (char *)data, n, SQLITE_STATIC);
+              Tcl_IncrRefCount(pVar);
+              apParm[nParm++] = pVar;
+            }
+          }else{
+            sqlite3_bind_null( pStmt, i );
+          }
+        }
+      }
+
+      /* Execute the SQL
+      */
+      while( rc==TCL_OK && pStmt && SQLITE_ROW==sqlite3_step(pStmt) ){
+
+	/* Compute column names. This must be done after the first successful
+	** call to sqlite3_step(), in case the query is recompiled and the
+        ** number or names of the returned columns changes. 
+        */
+        assert(!pArray||pScript);
+        if (nCol < 0) {
+          Tcl_Obj ***ap = (pScript?&apColName:0);
+          nCol = computeColumnNames(interp, pStmt, ap, pArray);
+        }
+
+        for(i=0; i<nCol; i++){
+          Tcl_Obj *pVal;
+          
+          /* Set pVal to contain the i'th column of this row. */
+          switch( sqlite3_column_type(pStmt, i) ){
+            case SQLITE_BLOB: {
+              int bytes = sqlite3_column_bytes(pStmt, i);
+              pVal = Tcl_NewByteArrayObj(sqlite3_column_blob(pStmt, i), bytes);
+              break;
+            }
+            case SQLITE_INTEGER: {
+              sqlite_int64 v = sqlite3_column_int64(pStmt, i);
+              if( v>=-2147483647 && v<=2147483647 ){
+                pVal = Tcl_NewIntObj(v);
+              }else{
+                pVal = Tcl_NewWideIntObj(v);
+              }
+              break;
+            }
+            case SQLITE_FLOAT: {
+              double r = sqlite3_column_double(pStmt, i);
+              pVal = Tcl_NewDoubleObj(r);
+              break;
+            }
+            case SQLITE_NULL: {
+              pVal = dbTextToObj(pDb->zNull);
+              break;
+            }
+            default: {
+              pVal = dbTextToObj((char *)sqlite3_column_text(pStmt, i));
+              break;
+            }
+          }
+  
+          if( pScript ){
+            if( pArray==0 ){
+              Tcl_ObjSetVar2(interp, apColName[i], 0, pVal, 0);
+            }else{
+              Tcl_ObjSetVar2(interp, pArray, apColName[i], pVal, 0);
+            }
+          }else if( choice==DB_ONECOLUMN ){
+            assert( pRet==0 );
+            if( pRet==0 ){
+              pRet = pVal;
+              Tcl_IncrRefCount(pRet);
+            }
+            rc = TCL_BREAK;
+            i = nCol;
+          }else if( choice==DB_EXISTS ){
+            Tcl_DecrRefCount(pRet);
+            pRet = Tcl_NewBooleanObj(1);
+            Tcl_IncrRefCount(pRet);
+            rc = TCL_BREAK;
+            i = nCol;
+          }else{
+            Tcl_ListObjAppendElement(interp, pRet, pVal);
+          }
+        }
+  
+        if( pScript ){
+          rc = Tcl_EvalObjEx(interp, pScript, 0);
+          if( rc==TCL_CONTINUE ){
+            rc = TCL_OK;
+          }
+        }
+      }
+      if( rc==TCL_BREAK ){
+        rc = TCL_OK;
+      }
+
+      /* Free the column name objects */
+      if( pScript ){
+        /* If the query returned no rows, but an array variable was 
+        ** specified, call computeColumnNames() now to populate the 
+        ** arrayname(*) variable.
+        */
+        if (pArray && nCol < 0) {
+          Tcl_Obj ***ap = (pScript?&apColName:0);
+          nCol = computeColumnNames(interp, pStmt, ap, pArray);
+        }
+        for(i=0; i<nCol; i++){
+          Tcl_DecrRefCount(apColName[i]);
+        }
+        Tcl_Free((char*)apColName);
+      }
+
+      /* Free the bound string and blob parameters */
+      for(i=0; i<nParm; i++){
+        Tcl_DecrRefCount(apParm[i]);
+      }
+      if( apParm!=aParm ){
+        Tcl_Free((char*)apParm);
+      }
+
+      /* Reset the statement.  If the result code is SQLITE_SCHEMA, then
+      ** flush the statement cache and try the statement again.
+      */
+      rc2 = sqlite3_reset(pStmt);
+      if( SQLITE_OK!=rc2 ){
+        /* If a run-time error occurs, report the error and stop reading
+        ** the SQL
+        */
+        Tcl_SetObjResult(interp, dbTextToObj(sqlite3_errmsg(pDb->db)));
+        sqlite3_finalize(pStmt);
+        rc = TCL_ERROR;
+        if( pPreStmt ) Tcl_Free((char*)pPreStmt);
+        break;
+      }else if( pDb->maxStmt<=0 ){
+        /* If the cache is turned off, deallocated the statement */
+        if( pPreStmt ) Tcl_Free((char*)pPreStmt);
+        sqlite3_finalize(pStmt);
+      }else{
+        /* Everything worked and the cache is operational.
+        ** Create a new SqlPreparedStmt structure if we need one.
+        ** (If we already have one we can just reuse it.)
+        */
+        if( pPreStmt==0 ){
+          len = zLeft - zSql;
+          pPreStmt = (SqlPreparedStmt*)Tcl_Alloc( sizeof(*pPreStmt) );
+          if( pPreStmt==0 ) return TCL_ERROR;
+          pPreStmt->pStmt = pStmt;
+          pPreStmt->nSql = len;
+          pPreStmt->zSql = sqlite3_sql(pStmt);
+          assert( strlen(pPreStmt->zSql)==len );
+          assert( 0==memcmp(pPreStmt->zSql, zSql, len) );
+        }
+
+        /* Add the prepared statement to the beginning of the cache list
+        */
+        pPreStmt->pNext = pDb->stmtList;
+        pPreStmt->pPrev = 0;
+        if( pDb->stmtList ){
+         pDb->stmtList->pPrev = pPreStmt;
+        }
+        pDb->stmtList = pPreStmt;
+        if( pDb->stmtLast==0 ){
+          assert( pDb->nStmt==0 );
+          pDb->stmtLast = pPreStmt;
+        }else{
+          assert( pDb->nStmt>0 );
+        }
+        pDb->nStmt++;
+   
+        /* If we have too many statement in cache, remove the surplus from the
+        ** end of the cache list.
+        */
+        while( pDb->nStmt>pDb->maxStmt ){
+          sqlite3_finalize(pDb->stmtLast->pStmt);
+          pDb->stmtLast = pDb->stmtLast->pPrev;
+          Tcl_Free((char*)pDb->stmtLast->pNext);
+          pDb->stmtLast->pNext = 0;
+          pDb->nStmt--;
+        }
+      }
+
+      /* Proceed to the next statement */
+      zSql = zLeft;
+    }
+    Tcl_DecrRefCount(objv[2]);
+
+    if( pRet ){
+      if( rc==TCL_OK ){
+        Tcl_SetObjResult(interp, pRet);
+      }
+      Tcl_DecrRefCount(pRet);
+    }else if( rc==TCL_OK ){
+      Tcl_ResetResult(interp);
+    }
+    break;
+  }
+
+  /*
+  **     $db function NAME SCRIPT
+  **
+  ** Create a new SQL function called NAME.  Whenever that function is
+  ** called, invoke SCRIPT to evaluate the function.
+  */
+  case DB_FUNCTION: {
+    SqlFunc *pFunc;
+    Tcl_Obj *pScript;
+    char *zName;
+    if( objc!=4 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");
+      return TCL_ERROR;
+    }
+    zName = Tcl_GetStringFromObj(objv[2], 0);
+    pScript = objv[3];
+    pFunc = findSqlFunc(pDb, zName);
+    if( pFunc==0 ) return TCL_ERROR;
+    if( pFunc->pScript ){
+      Tcl_DecrRefCount(pFunc->pScript);
+    }
+    pFunc->pScript = pScript;
+    Tcl_IncrRefCount(pScript);
+    pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript);
+    rc = sqlite3_create_function(pDb->db, zName, -1, SQLITE_UTF8,
+        pFunc, tclSqlFunc, 0, 0);
+    if( rc!=SQLITE_OK ){
+      rc = TCL_ERROR;
+      Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);
+    }
+    break;
+  }
+
+  /*
+  **     $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
+  */
+  case DB_INCRBLOB: {
+#ifdef SQLITE_OMIT_INCRBLOB
+    Tcl_AppendResult(interp, "incrblob not available in this build", 0);
+    return TCL_ERROR;
+#else
+    int isReadonly = 0;
+    const char *zDb = "main";
+    const char *zTable;
+    const char *zColumn;
+    sqlite_int64 iRow;
+
+    /* Check for the -readonly option */
+    if( objc>3 && strcmp(Tcl_GetString(objv[2]), "-readonly")==0 ){
+      isReadonly = 1;
+    }
+
+    if( objc!=(5+isReadonly) && objc!=(6+isReadonly) ){
+      Tcl_WrongNumArgs(interp, 2, objv, "?-readonly? ?DB? TABLE COLUMN ROWID");
+      return TCL_ERROR;
+    }
+
+    if( objc==(6+isReadonly) ){
+      zDb = Tcl_GetString(objv[2]);
+    }
+    zTable = Tcl_GetString(objv[objc-3]);
+    zColumn = Tcl_GetString(objv[objc-2]);
+    rc = Tcl_GetWideIntFromObj(interp, objv[objc-1], &iRow);
+
+    if( rc==TCL_OK ){
+      rc = createIncrblobChannel(
+          interp, pDb, zDb, zTable, zColumn, iRow, isReadonly
+      );
+    }
+#endif
+    break;
+  }
+
+  /*
+  **     $db interrupt
+  **
+  ** Interrupt the execution of the inner-most SQL interpreter.  This
+  ** causes the SQL statement to return an error of SQLITE_INTERRUPT.
+  */
+  case DB_INTERRUPT: {
+    sqlite3_interrupt(pDb->db);
+    break;
+  }
+
+  /*
+  **     $db nullvalue ?STRING?
+  **
+  ** Change text used when a NULL comes back from the database. If ?STRING?
+  ** is not present, then the current string used for NULL is returned.
+  ** If STRING is present, then STRING is returned.
+  **
+  */
+  case DB_NULLVALUE: {
+    if( objc!=2 && objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "NULLVALUE");
+      return TCL_ERROR;
+    }
+    if( objc==3 ){
+      int len;
+      char *zNull = Tcl_GetStringFromObj(objv[2], &len);
+      if( pDb->zNull ){
+        Tcl_Free(pDb->zNull);
+      }
+      if( zNull && len>0 ){
+        pDb->zNull = Tcl_Alloc( len + 1 );
+        strncpy(pDb->zNull, zNull, len);
+        pDb->zNull[len] = '\0';
+      }else{
+        pDb->zNull = 0;
+      }
+    }
+    Tcl_SetObjResult(interp, dbTextToObj(pDb->zNull));
+    break;
+  }
+
+  /*
+  **     $db last_insert_rowid 
+  **
+  ** Return an integer which is the ROWID for the most recent insert.
+  */
+  case DB_LAST_INSERT_ROWID: {
+    Tcl_Obj *pResult;
+    Tcl_WideInt rowid;
+    if( objc!=2 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "");
+      return TCL_ERROR;
+    }
+    rowid = sqlite3_last_insert_rowid(pDb->db);
+    pResult = Tcl_GetObjResult(interp);
+    Tcl_SetWideIntObj(pResult, rowid);
+    break;
+  }
+
+  /*
+  ** The DB_ONECOLUMN method is implemented together with DB_EVAL.
+  */
+
+  /*    $db progress ?N CALLBACK?
+  ** 
+  ** Invoke the given callback every N virtual machine opcodes while executing
+  ** queries.
+  */
+  case DB_PROGRESS: {
+    if( objc==2 ){
+      if( pDb->zProgress ){
+        Tcl_AppendResult(interp, pDb->zProgress, 0);
+      }
+    }else if( objc==4 ){
+      char *zProgress;
+      int len;
+      int N;
+      if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &N) ){
+        return TCL_ERROR;
+      };
+      if( pDb->zProgress ){
+        Tcl_Free(pDb->zProgress);
+      }
+      zProgress = Tcl_GetStringFromObj(objv[3], &len);
+      if( zProgress && len>0 ){
+        pDb->zProgress = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zProgress, zProgress, len+1);
+      }else{
+        pDb->zProgress = 0;
+      }
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+      if( pDb->zProgress ){
+        pDb->interp = interp;
+        sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb);
+      }else{
+        sqlite3_progress_handler(pDb->db, 0, 0, 0);
+      }
+#endif
+    }else{
+      Tcl_WrongNumArgs(interp, 2, objv, "N CALLBACK");
+      return TCL_ERROR;
+    }
+    break;
+  }
+
+  /*    $db profile ?CALLBACK?
+  **
+  ** Make arrangements to invoke the CALLBACK routine after each SQL statement
+  ** that has run.  The text of the SQL and the amount of elapse time are
+  ** appended to CALLBACK before the script is run.
+  */
+  case DB_PROFILE: {
+    if( objc>3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
+      return TCL_ERROR;
+    }else if( objc==2 ){
+      if( pDb->zProfile ){
+        Tcl_AppendResult(interp, pDb->zProfile, 0);
+      }
+    }else{
+      char *zProfile;
+      int len;
+      if( pDb->zProfile ){
+        Tcl_Free(pDb->zProfile);
+      }
+      zProfile = Tcl_GetStringFromObj(objv[2], &len);
+      if( zProfile && len>0 ){
+        pDb->zProfile = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zProfile, zProfile, len+1);
+      }else{
+        pDb->zProfile = 0;
+      }
+#ifndef SQLITE_OMIT_TRACE
+      if( pDb->zProfile ){
+        pDb->interp = interp;
+        sqlite3_profile(pDb->db, DbProfileHandler, pDb);
+      }else{
+        sqlite3_profile(pDb->db, 0, 0);
+      }
+#endif
+    }
+    break;
+  }
+
+  /*
+  **     $db rekey KEY
+  **
+  ** Change the encryption key on the currently open database.
+  */
+  case DB_REKEY: {
+    int nKey;
+    void *pKey;
+    if( objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "KEY");
+      return TCL_ERROR;
+    }
+    pKey = Tcl_GetByteArrayFromObj(objv[2], &nKey);
+#ifdef SQLITE_HAS_CODEC
+    rc = sqlite3_rekey(pDb->db, pKey, nKey);
+    if( rc ){
+      Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
+      rc = TCL_ERROR;
+    }
+#endif
+    break;
+  }
+
+  /*
+  **     $db timeout MILLESECONDS
+  **
+  ** Delay for the number of milliseconds specified when a file is locked.
+  */
+  case DB_TIMEOUT: {
+    int ms;
+    if( objc!=3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "MILLISECONDS");
+      return TCL_ERROR;
+    }
+    if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR;
+    sqlite3_busy_timeout(pDb->db, ms);
+    break;
+  }
+  
+  /*
+  **     $db total_changes
+  **
+  ** Return the number of rows that were modified, inserted, or deleted 
+  ** since the database handle was created.
+  */
+  case DB_TOTAL_CHANGES: {
+    Tcl_Obj *pResult;
+    if( objc!=2 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "");
+      return TCL_ERROR;
+    }
+    pResult = Tcl_GetObjResult(interp);
+    Tcl_SetIntObj(pResult, sqlite3_total_changes(pDb->db));
+    break;
+  }
+
+  /*    $db trace ?CALLBACK?
+  **
+  ** Make arrangements to invoke the CALLBACK routine for each SQL statement
+  ** that is executed.  The text of the SQL is appended to CALLBACK before
+  ** it is executed.
+  */
+  case DB_TRACE: {
+    if( objc>3 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
+      return TCL_ERROR;
+    }else if( objc==2 ){
+      if( pDb->zTrace ){
+        Tcl_AppendResult(interp, pDb->zTrace, 0);
+      }
+    }else{
+      char *zTrace;
+      int len;
+      if( pDb->zTrace ){
+        Tcl_Free(pDb->zTrace);
+      }
+      zTrace = Tcl_GetStringFromObj(objv[2], &len);
+      if( zTrace && len>0 ){
+        pDb->zTrace = Tcl_Alloc( len + 1 );
+        memcpy(pDb->zTrace, zTrace, len+1);
+      }else{
+        pDb->zTrace = 0;
+      }
+#ifndef SQLITE_OMIT_TRACE
+      if( pDb->zTrace ){
+        pDb->interp = interp;
+        sqlite3_trace(pDb->db, DbTraceHandler, pDb);
+      }else{
+        sqlite3_trace(pDb->db, 0, 0);
+      }
+#endif
+    }
+    break;
+  }
+
+  /*    $db transaction [-deferred|-immediate|-exclusive] SCRIPT
+  **
+  ** Start a new transaction (if we are not already in the midst of a
+  ** transaction) and execute the TCL script SCRIPT.  After SCRIPT
+  ** completes, either commit the transaction or roll it back if SCRIPT
+  ** throws an exception.  Or if no new transation was started, do nothing.
+  ** pass the exception on up the stack.
+  **
+  ** This command was inspired by Dave Thomas's talk on Ruby at the
+  ** 2005 O'Reilly Open Source Convention (OSCON).
+  */
+  case DB_TRANSACTION: {
+    int inTrans;
+    Tcl_Obj *pScript;
+    const char *zBegin = "BEGIN";
+    if( objc!=3 && objc!=4 ){
+      Tcl_WrongNumArgs(interp, 2, objv, "[TYPE] SCRIPT");
+      return TCL_ERROR;
+    }
+    if( objc==3 ){
+      pScript = objv[2];
+    } else {
+      static const char *TTYPE_strs[] = {
+        "deferred",   "exclusive",  "immediate", 0
+      };
+      enum TTYPE_enum {
+        TTYPE_DEFERRED, TTYPE_EXCLUSIVE, TTYPE_IMMEDIATE
+      };
+      int ttype;
+      if( Tcl_GetIndexFromObj(interp, objv[2], TTYPE_strs, "transaction type",
+                              0, &ttype) ){
+        return TCL_ERROR;
+      }
+      switch( (enum TTYPE_enum)ttype ){
+        case TTYPE_DEFERRED:    /* no-op */;                 break;
+        case TTYPE_EXCLUSIVE:   zBegin = "BEGIN EXCLUSIVE";  break;
+        case TTYPE_IMMEDIATE:   zBegin = "BEGIN IMMEDIATE";  break;
+      }
+      pScript = objv[3];
+    }
+    inTrans = !sqlite3_get_autocommit(pDb->db);
+    if( !inTrans ){
+      (void)sqlite3_exec(pDb->db, zBegin, 0, 0, 0);
+    }
+    rc = Tcl_EvalObjEx(interp, pScript, 0);
+    if( !inTrans ){
+      const char *zEnd;
+      if( rc==TCL_ERROR ){
+        zEnd = "ROLLBACK";
+      } else {
+        zEnd = "COMMIT";
+      }
+      if( sqlite3_exec(pDb->db, zEnd, 0, 0, 0) ){
+        sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);
+      }
+    }
+    break;
+  }
+
+  /*
+  **    $db update_hook ?script?
+  **    $db rollback_hook ?script?
+  */
+  case DB_UPDATE_HOOK: 
+  case DB_ROLLBACK_HOOK: {
+
+    /* set ppHook to point at pUpdateHook or pRollbackHook, depending on 
+    ** whether [$db update_hook] or [$db rollback_hook] was invoked.
+    */
+    Tcl_Obj **ppHook; 
+    if( choice==DB_UPDATE_HOOK ){
+      ppHook = &pDb->pUpdateHook;
+    }else{
+      ppHook = &pDb->pRollbackHook;
+    }
+
+    if( objc!=2 && objc!=3 ){
+       Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
+       return TCL_ERROR;
+    }
+    if( *ppHook ){
+      Tcl_SetObjResult(interp, *ppHook);
+      if( objc==3 ){
+        Tcl_DecrRefCount(*ppHook);
+        *ppHook = 0;
+      }
+    }
+    if( objc==3 ){
+      assert( !(*ppHook) );
+      if( Tcl_GetCharLength(objv[2])>0 ){
+        *ppHook = objv[2];
+        Tcl_IncrRefCount(*ppHook);
+      }
+    }
+
+    sqlite3_update_hook(pDb->db, (pDb->pUpdateHook?DbUpdateHandler:0), pDb);
+    sqlite3_rollback_hook(pDb->db,(pDb->pRollbackHook?DbRollbackHandler:0),pDb);
+
+    break;
+  }
+
+  /*    $db version
+  **
+  ** Return the version string for this database.
+  */
+  case DB_VERSION: {
+    Tcl_SetResult(interp, (char *)sqlite3_libversion(), TCL_STATIC);
+    break;
+  }
+
+
+  } /* End of the SWITCH statement */
+  return rc;
+}
+
+/*
+**   sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
+**                           ?-create BOOLEAN?
+**
+** This is the main Tcl command.  When the "sqlite" Tcl command is
+** invoked, this routine runs to process that command.
+**
+** The first argument, DBNAME, is an arbitrary name for a new
+** database connection.  This command creates a new command named
+** DBNAME that is used to control that connection.  The database
+** connection is deleted when the DBNAME command is deleted.
+**
+** The second argument is the name of the database file.
+**
+*/
+static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
+  SqliteDb *p;
+  void *pKey = 0;
+  int nKey = 0;
+  const char *zArg;
+  char *zErrMsg;
+  int i;
+  const char *zFile;
+  const char *zVfs = 0;
+  int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+  Tcl_DString translatedFilename;
+  if( objc==2 ){
+    zArg = Tcl_GetStringFromObj(objv[1], 0);
+    if( strcmp(zArg,"-version")==0 ){
+      Tcl_AppendResult(interp,sqlite3_version,0);
+      return TCL_OK;
+    }
+    if( strcmp(zArg,"-has-codec")==0 ){
+#ifdef SQLITE_HAS_CODEC
+      Tcl_AppendResult(interp,"1",0);
+#else
+      Tcl_AppendResult(interp,"0",0);
+#endif
+      return TCL_OK;
+    }
+  }
+  for(i=3; i+1<objc; i+=2){
+    zArg = Tcl_GetString(objv[i]);
+    if( strcmp(zArg,"-key")==0 ){
+      pKey = Tcl_GetByteArrayFromObj(objv[i+1], &nKey);
+    }else if( strcmp(zArg, "-vfs")==0 ){
+      i++;
+      zVfs = Tcl_GetString(objv[i]);
+    }else if( strcmp(zArg, "-readonly")==0 ){
+      int b;
+      if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
+      if( b ){
+        flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
+        flags |= SQLITE_OPEN_READONLY;
+      }else{
+        flags &= ~SQLITE_OPEN_READONLY;
+        flags |= SQLITE_OPEN_READWRITE;
+      }
+    }else if( strcmp(zArg, "-create")==0 ){
+      int b;
+      if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;
+      if( b && (flags & SQLITE_OPEN_READONLY)==0 ){
+        flags |= SQLITE_OPEN_CREATE;
+      }else{
+        flags &= ~SQLITE_OPEN_CREATE;
+      }
+    }else{
+      Tcl_AppendResult(interp, "unknown option: ", zArg, (char*)0);
+      return TCL_ERROR;
+    }
+  }
+  if( objc<3 || (objc&1)!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, 
+      "HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
+#ifdef SQLITE_HAS_CODEC
+      " ?-key CODECKEY?"
+#endif
+    );
+    return TCL_ERROR;
+  }
+  zErrMsg = 0;
+  p = (SqliteDb*)Tcl_Alloc( sizeof(*p) );
+  if( p==0 ){
+    Tcl_SetResult(interp, "malloc failed", TCL_STATIC);
+    return TCL_ERROR;
+  }
+  memset(p, 0, sizeof(*p));
+  zFile = Tcl_GetStringFromObj(objv[2], 0);
+  zFile = Tcl_TranslateFileName(interp, zFile, &translatedFilename);
+  sqlite3_open_v2(zFile, &p->db, flags, zVfs);
+  Tcl_DStringFree(&translatedFilename);
+  if( SQLITE_OK!=sqlite3_errcode(p->db) ){
+    zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
+    sqlite3_close(p->db);
+    p->db = 0;
+  }
+#ifdef SQLITE_TEST
+  if( p->db ){
+    extern int Md5_Register(sqlite3*);
+    if( Md5_Register(p->db)==SQLITE_NOMEM ){
+      zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));
+      sqlite3_close(p->db);
+      p->db = 0;
+    }
+  }
+#endif  
+#ifdef SQLITE_HAS_CODEC
+  if( p->db ){
+    sqlite3_key(p->db, pKey, nKey);
+  }
+#endif
+  if( p->db==0 ){
+    Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);
+    Tcl_Free((char*)p);
+    sqlite3_free(zErrMsg);
+    return TCL_ERROR;
+  }
+  p->maxStmt = NUM_PREPARED_STMTS;
+  p->interp = interp;
+  zArg = Tcl_GetStringFromObj(objv[1], 0);
+  Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd);
+  return TCL_OK;
+}
+
+/*
+** Provide a dummy Tcl_InitStubs if we are using this as a static
+** library.
+*/
+#ifndef USE_TCL_STUBS
+# undef  Tcl_InitStubs
+# define Tcl_InitStubs(a,b,c)
+#endif
+
+/*
+** Make sure we have a PACKAGE_VERSION macro defined.  This will be
+** defined automatically by the TEA makefile.  But other makefiles
+** do not define it.
+*/
+#ifndef PACKAGE_VERSION
+# define PACKAGE_VERSION SQLITE_VERSION
+#endif
+
+/*
+** Initialize this module.
+**
+** This Tcl module contains only a single new Tcl command named "sqlite".
+** (Hence there is no namespace.  There is no point in using a namespace
+** if the extension only supplies one new name!)  The "sqlite" command is
+** used to open a new SQLite database.  See the DbMain() routine above
+** for additional information.
+*/
+EXTERN int Sqlite3_Init(Tcl_Interp *interp){
+  Tcl_InitStubs(interp, "8.4", 0);
+  Tcl_CreateObjCommand(interp, "sqlite3", (Tcl_ObjCmdProc*)DbMain, 0, 0);
+  Tcl_PkgProvide(interp, "sqlite3", PACKAGE_VERSION);
+  Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0);
+  Tcl_PkgProvide(interp, "sqlite", PACKAGE_VERSION);
+  return TCL_OK;
+}
+EXTERN int Tclsqlite3_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
+EXTERN int Sqlite3_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
+EXTERN int Tclsqlite3_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
+
+#ifndef SQLITE_3_SUFFIX_ONLY
+EXTERN int Sqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
+EXTERN int Tclsqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }
+EXTERN int Sqlite_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
+EXTERN int Tclsqlite_SafeInit(Tcl_Interp *interp){ return TCL_OK; }
+#endif
+
+#ifdef TCLSH
+/*****************************************************************************
+** The code that follows is used to build standalone TCL interpreters
+** that are statically linked with SQLite.  
+*/
+
+/*
+** If the macro TCLSH is one, then put in code this for the
+** "main" routine that will initialize Tcl and take input from
+** standard input, or if a file is named on the command line
+** the TCL interpreter reads and evaluates that file.
+*/
+#if TCLSH==1
+static char zMainloop[] =
+  "set line {}\n"
+  "while {![eof stdin]} {\n"
+    "if {$line!=\"\"} {\n"
+      "puts -nonewline \"> \"\n"
+    "} else {\n"
+      "puts -nonewline \"% \"\n"
+    "}\n"
+    "flush stdout\n"
+    "append line [gets stdin]\n"
+    "if {[info complete $line]} {\n"
+      "if {[catch {uplevel #0 $line} result]} {\n"
+        "puts stderr \"Error: $result\"\n"
+      "} elseif {$result!=\"\"} {\n"
+        "puts $result\n"
+      "}\n"
+      "set line {}\n"
+    "} else {\n"
+      "append line \\n\n"
+    "}\n"
+  "}\n"
+;
+#endif
+
+/*
+** If the macro TCLSH is two, then get the main loop code out of
+** the separate file "spaceanal_tcl.h".
+*/
+#if TCLSH==2
+static char zMainloop[] = 
+#include "spaceanal_tcl.h"
+;
+#endif
+
+#define TCLSH_MAIN main   /* Needed to fake out mktclapp */
+int TCLSH_MAIN(int argc, char **argv){
+  Tcl_Interp *interp;
+  Tcl_FindExecutable(argv[0]);
+  interp = Tcl_CreateInterp();
+  Sqlite3_Init(interp);
+#ifdef SQLITE_TEST
+  {
+    extern int Md5_Init(Tcl_Interp*);
+    extern int Sqliteconfig_Init(Tcl_Interp*);
+    extern int Sqlitetest1_Init(Tcl_Interp*);
+    extern int Sqlitetest2_Init(Tcl_Interp*);
+    extern int Sqlitetest3_Init(Tcl_Interp*);
+    extern int Sqlitetest4_Init(Tcl_Interp*);
+    extern int Sqlitetest5_Init(Tcl_Interp*);
+    extern int Sqlitetest6_Init(Tcl_Interp*);
+    extern int Sqlitetest7_Init(Tcl_Interp*);
+    extern int Sqlitetest8_Init(Tcl_Interp*);
+    extern int Sqlitetest9_Init(Tcl_Interp*);
+    extern int Sqlitetestasync_Init(Tcl_Interp*);
+    extern int Sqlitetest_autoext_Init(Tcl_Interp*);
+    extern int Sqlitetest_hexio_Init(Tcl_Interp*);
+    extern int Sqlitetest_malloc_Init(Tcl_Interp*);
+    extern int Sqlitetestschema_Init(Tcl_Interp*);
+    extern int Sqlitetestsse_Init(Tcl_Interp*);
+    extern int Sqlitetesttclvar_Init(Tcl_Interp*);
+    extern int SqlitetestThread_Init(Tcl_Interp*);
+    extern int SqlitetestOnefile_Init();
+
+    Md5_Init(interp);
+    Sqliteconfig_Init(interp);
+    Sqlitetest1_Init(interp);
+    Sqlitetest2_Init(interp);
+    Sqlitetest3_Init(interp);
+    Sqlitetest4_Init(interp);
+    Sqlitetest5_Init(interp);
+    Sqlitetest6_Init(interp);
+    Sqlitetest7_Init(interp);
+    Sqlitetest8_Init(interp);
+    Sqlitetest9_Init(interp);
+    Sqlitetestasync_Init(interp);
+    Sqlitetest_autoext_Init(interp);
+    Sqlitetest_hexio_Init(interp);
+    Sqlitetest_malloc_Init(interp);
+    Sqlitetestschema_Init(interp);
+    Sqlitetesttclvar_Init(interp);
+    SqlitetestThread_Init(interp);
+    SqlitetestOnefile_Init(interp);
+
+#ifdef SQLITE_SSE
+    Sqlitetestsse_Init(interp);
+#endif
+  }
+#endif
+  if( argc>=2 || TCLSH==2 ){
+    int i;
+    char zArgc[32];
+    sqlite3_snprintf(sizeof(zArgc), zArgc, "%d", argc-(3-TCLSH));
+    Tcl_SetVar(interp,"argc", zArgc, TCL_GLOBAL_ONLY);
+    Tcl_SetVar(interp,"argv0",argv[1],TCL_GLOBAL_ONLY);
+    Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY);
+    for(i=3-TCLSH; i<argc; i++){
+      Tcl_SetVar(interp, "argv", argv[i],
+          TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE);
+    }
+    if( TCLSH==1 && Tcl_EvalFile(interp, argv[1])!=TCL_OK ){
+      const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
+      if( zInfo==0 ) zInfo = interp->result;
+      fprintf(stderr,"%s: %s\n", *argv, zInfo);
+      return 1;
+    }
+  }
+  if( argc<=1 || TCLSH==2 ){
+    Tcl_GlobalEval(interp, zMainloop);
+  }
+  return 0;
+}
+#endif /* TCLSH */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test1.c b/client/src/thirdparty/sqlite-3.4.2/src/test1.c
new file mode 100644
index 0000000..5fb8fa7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test1.c
@@ -0,0 +1,4641 @@
+/*
+** 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.
+**
+*************************************************************************
+** Code for testing all sorts of SQLite interfaces.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test1.c,v 1.287 2008/01/23 14:51:50 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** This is a copy of the first part of the SqliteDb structure in 
+** tclsqlite.c.  We need it here so that the get_sqlite_pointer routine
+** can extract the sqlite3* pointer from an existing Tcl SQLite
+** connection.
+*/
+struct SqliteDb {
+  sqlite3 *db;
+};
+
+/*
+** Convert text generated by the "%p" conversion format back into
+** a pointer.
+*/
+static int testHexToInt(int h){
+  if( h>='0' && h<='9' ){
+    return h - '0';
+  }else if( h>='a' && h<='f' ){
+    return h - 'a' + 10;
+  }else{
+    assert( h>='A' && h<='F' );
+    return h - 'A' + 10;
+  }
+}
+void *sqlite3TextToPtr(const char *z){
+  void *p;
+  u64 v;
+  u32 v2;
+  if( z[0]=='0' && z[1]=='x' ){
+    z += 2;
+  }
+  v = 0;
+  while( *z ){
+    v = (v<<4) + testHexToInt(*z);
+    z++;
+  }
+  if( sizeof(p)==sizeof(v) ){
+    memcpy(&p, &v, sizeof(p));
+  }else{
+    assert( sizeof(p)==sizeof(v2) );
+    v2 = (u32)v;
+    memcpy(&p, &v2, sizeof(p));
+  }
+  return p;
+}
+
+
+/*
+** A TCL command that returns the address of the sqlite* pointer
+** for an sqlite connection instance.  Bad things happen if the
+** input is not an sqlite connection.
+*/
+static int get_sqlite_pointer(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  struct SqliteDb *p;
+  Tcl_CmdInfo cmdInfo;
+  char zBuf[100];
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SQLITE-CONNECTION");
+    return TCL_ERROR;
+  }
+  if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
+    Tcl_AppendResult(interp, "command not found: ",
+           Tcl_GetString(objv[1]), (char*)0);
+    return TCL_ERROR;
+  }
+  p = (struct SqliteDb*)cmdInfo.objClientData;
+  sprintf(zBuf, "%p", p->db);
+  if( strncmp(zBuf,"0x",2) ){
+    sprintf(zBuf, "0x%p", p->db);
+  }
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Decode a pointer to an sqlite3 object.
+*/
+static int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
+  struct SqliteDb *p;
+  Tcl_CmdInfo cmdInfo;
+  if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){
+    p = (struct SqliteDb*)cmdInfo.objClientData;
+    *ppDb = p->db;
+  }else{
+    *ppDb = (sqlite3*)sqlite3TextToPtr(zA);
+  }
+  return TCL_OK;
+}
+
+
+const char *sqlite3TestErrorName(int rc){
+  const char *zName = 0;
+  switch( rc & 0xff ){
+    case SQLITE_OK:         zName = "SQLITE_OK";          break;
+    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
+    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
+    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
+    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
+    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
+    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
+    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
+    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
+    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
+    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
+    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
+    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
+    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
+    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
+    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
+    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
+    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
+    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
+    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
+    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
+    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
+    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
+    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
+    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
+    case SQLITE_NOTADB:     zName = "SQLITE_NOTADB";      break;
+    case SQLITE_TOOBIG:     zName = "SQLITE_TOOBIG";      break;
+    default:                zName = "SQLITE_Unknown";     break;
+  }
+  return zName;
+}
+#define t1ErrorName sqlite3TestErrorName
+
+/*
+** Convert an sqlite3_stmt* into an sqlite3*.  This depends on the
+** fact that the sqlite3* is the first field in the Vdbe structure.
+*/
+#define StmtToDb(X)   sqlite3_db_handle(X)
+
+/*
+** Check a return value to make sure it agrees with the results
+** from sqlite3_errcode.
+*/
+int sqlite3TestErrCode(Tcl_Interp *interp, sqlite3 *db, int rc){
+  if( rc!=SQLITE_MISUSE && rc!=SQLITE_OK && sqlite3_errcode(db)!=rc ){
+    char zBuf[200];
+    int r2 = sqlite3_errcode(db);
+    sprintf(zBuf, "error code %s (%d) does not match sqlite3_errcode %s (%d)",
+       t1ErrorName(rc), rc, t1ErrorName(r2), r2);
+    Tcl_ResetResult(interp);
+    Tcl_AppendResult(interp, zBuf, 0);
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Decode a pointer to an sqlite3_stmt object.
+*/
+static int getStmtPointer(
+  Tcl_Interp *interp, 
+  const char *zArg,  
+  sqlite3_stmt **ppStmt
+){
+  *ppStmt = (sqlite3_stmt*)sqlite3TextToPtr(zArg);
+  return TCL_OK;
+}
+
+/*
+** Generate a text representation of a pointer that can be understood
+** by the getDbPointer and getVmPointer routines above.
+**
+** The problem is, on some machines (Solaris) if you do a printf with
+** "%p" you cannot turn around and do a scanf with the same "%p" and
+** get your pointer back.  You have to prepend a "0x" before it will
+** work.  Or at least that is what is reported to me (drh).  But this
+** behavior varies from machine to machine.  The solution used her is
+** to test the string right after it is generated to see if it can be
+** understood by scanf, and if not, try prepending an "0x" to see if
+** that helps.  If nothing works, a fatal error is generated.
+*/
+int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
+  sqlite3_snprintf(100, zPtr, "%p", p);
+  return TCL_OK;
+}
+
+/*
+** The callback routine for sqlite3_exec_printf().
+*/
+static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){
+  Tcl_DString *str = (Tcl_DString*)pArg;
+  int i;
+
+  if( Tcl_DStringLength(str)==0 ){
+    for(i=0; i<argc; i++){
+      Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL");
+    }
+  }
+  for(i=0; i<argc; i++){
+    Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL");
+  }
+  return 0;
+}
+
+/*
+** The I/O tracing callback.
+*/
+static FILE *iotrace_file = 0;
+static void io_trace_callback(const char *zFormat, ...){
+  va_list ap;
+  va_start(ap, zFormat);
+  vfprintf(iotrace_file, zFormat, ap);
+  va_end(ap);
+  fflush(iotrace_file);
+}
+
+/*
+** Usage:  io_trace FILENAME
+**
+** Turn I/O tracing on or off.  If FILENAME is not an empty string,
+** I/O tracing begins going into FILENAME. If FILENAME is an empty
+** string, I/O tracing is turned off.
+*/
+static int test_io_trace(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+          " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  if( iotrace_file ){
+    if( iotrace_file!=stdout && iotrace_file!=stderr ){
+      fclose(iotrace_file);
+    }
+    iotrace_file = 0;
+    sqlite3_io_trace = 0;
+  }
+  if( argv[1][0] ){
+    if( strcmp(argv[1],"stdout")==0 ){
+      iotrace_file = stdout;
+    }else if( strcmp(argv[1],"stderr")==0 ){
+      iotrace_file = stderr;
+    }else{
+      iotrace_file = fopen(argv[1], "w");
+    }
+    sqlite3_io_trace = io_trace_callback;
+  }
+  return SQLITE_OK;
+}
+
+
+/*
+** Usage:  sqlite3_exec_printf  DB  FORMAT  STRING
+**
+** Invoke the sqlite3_exec_printf() interface using the open database
+** DB.  The SQL is the string FORMAT.  The format string should contain
+** one %s or %q.  STRING is the value inserted into %s or %q.
+*/
+static int test_exec_printf(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  Tcl_DString str;
+  int rc;
+  char *zErr = 0;
+  char *zSql;
+  char zBuf[30];
+  if( argc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB FORMAT STRING", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  Tcl_DStringInit(&str);
+  zSql = sqlite3_mprintf(argv[2], argv[3]);
+  rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
+  sqlite3_free(zSql);
+  sprintf(zBuf, "%d", rc);
+  Tcl_AppendElement(interp, zBuf);
+  Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
+  Tcl_DStringFree(&str);
+  if( zErr ) sqlite3_free(zErr);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+/*
+** Usage:  db_enter DB
+**         db_leave DB
+**
+** Enter or leave the mutex on a database connection.
+*/
+static int db_enter(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  sqlite3_mutex_enter(db->mutex);
+  return TCL_OK;
+}
+static int db_leave(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  sqlite3_mutex_leave(db->mutex);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_exec  DB  SQL
+**
+** Invoke the sqlite3_exec interface using the open database DB
+*/
+static int test_exec(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  Tcl_DString str;
+  int rc;
+  char *zErr = 0;
+  char *zSql;
+  int i, j;
+  char zBuf[30];
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB SQL", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  Tcl_DStringInit(&str);
+  zSql = sqlite3_mprintf("%s", argv[2]);
+  for(i=j=0; zSql[i];){
+    if( zSql[i]=='%' ){
+      zSql[j++] = (testHexToInt(zSql[i+1])<<4) + testHexToInt(zSql[i+2]);
+      i += 3;
+    }else{
+      zSql[j++] = zSql[i++];
+    }
+  }
+  zSql[j] = 0;
+  rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr);
+  sqlite3_free(zSql);
+  sprintf(zBuf, "%d", rc);
+  Tcl_AppendElement(interp, zBuf);
+  Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr);
+  Tcl_DStringFree(&str);
+  if( zErr ) sqlite3_free(zErr);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_exec_nr  DB  SQL
+**
+** Invoke the sqlite3_exec interface using the open database DB.  Discard
+** all results
+*/
+static int test_exec_nr(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  int rc;
+  char *zErr = 0;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB SQL", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_z_test  SEPARATOR  ARG0  ARG1 ...
+**
+** Test the %z format of sqliteMPrintf().  Use multiple mprintf() calls to 
+** concatenate arg0 through argn using separator as the separator.
+** Return the result.
+*/
+static int test_mprintf_z(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  char *zResult = 0;
+  int i;
+
+  for(i=2; i<argc && (i==2 || zResult); i++){
+    zResult = sqlite3MPrintf(0, "%z%s%s", zResult, argv[1], argv[i]);
+  }
+  Tcl_AppendResult(interp, zResult, 0);
+  sqlite3_free(zResult);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_n_test  STRING
+**
+** Test the %n format of sqliteMPrintf().  Return the length of the
+** input string.
+*/
+static int test_mprintf_n(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  char *zStr;
+  int n = 0;
+  zStr = sqlite3MPrintf(0, "%s%n", argv[1], &n);
+  sqlite3_free(zStr);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_snprintf_int  SIZE FORMAT  INT
+**
+** Test the of sqlite3_snprintf() routine.  SIZE is the size of the
+** output buffer in bytes.  The maximum size is 100.  FORMAT is the
+** format string.  INT is a single integer argument.  The FORMAT
+** string must require no more than this one integer argument.  If
+** You pass in a format string that requires more than one argument,
+** bad things will happen.
+*/
+static int test_snprintf_int(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  char zStr[100];
+  int n = atoi(argv[1]);
+  const char *zFormat = argv[2];
+  int a1 = atoi(argv[3]);
+  if( n>sizeof(zStr) ) n = sizeof(zStr);
+  strcpy(zStr, "abcdefghijklmnopqrstuvwxyz");
+  sqlite3_snprintf(n, zStr, zFormat, a1);
+  Tcl_AppendResult(interp, zStr, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_get_table_printf  DB  FORMAT  STRING  ?--no-counts?
+**
+** Invoke the sqlite3_get_table_printf() interface using the open database
+** DB.  The SQL is the string FORMAT.  The format string should contain
+** one %s or %q.  STRING is the value inserted into %s or %q.
+*/
+static int test_get_table_printf(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  Tcl_DString str;
+  int rc;
+  char *zErr = 0;
+  int nRow, nCol;
+  char **aResult;
+  int i;
+  char zBuf[30];
+  char *zSql;
+  int resCount = -1;
+  if( argc==5 ){
+    if( Tcl_GetInt(interp, argv[4], &resCount) ) return TCL_ERROR;
+  }
+  if( argc!=4 && argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB FORMAT STRING ?COUNT?", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  Tcl_DStringInit(&str);
+  zSql = sqlite3_mprintf(argv[2],argv[3]);
+  if( argc==5 ){
+    rc = sqlite3_get_table(db, zSql, &aResult, 0, 0, &zErr);
+  }else{
+    rc = sqlite3_get_table(db, zSql, &aResult, &nRow, &nCol, &zErr);
+    resCount = (nRow+1)*nCol;
+  }
+  sqlite3_free(zSql);
+  sprintf(zBuf, "%d", rc);
+  Tcl_AppendElement(interp, zBuf);
+  if( rc==SQLITE_OK ){
+    if( argc==4 ){
+      sprintf(zBuf, "%d", nRow);
+      Tcl_AppendElement(interp, zBuf);
+      sprintf(zBuf, "%d", nCol);
+      Tcl_AppendElement(interp, zBuf);
+    }
+    for(i=0; i<resCount; i++){
+      Tcl_AppendElement(interp, aResult[i] ? aResult[i] : "NULL");
+    }
+  }else{
+    Tcl_AppendElement(interp, zErr);
+  }
+  sqlite3_free_table(aResult);
+  if( zErr ) sqlite3_free(zErr);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+
+/*
+** Usage:  sqlite3_last_insert_rowid DB
+**
+** Returns the integer ROWID of the most recent insert.
+*/
+static int test_last_rowid(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  char zBuf[30];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  sprintf(zBuf, "%lld", sqlite3_last_insert_rowid(db));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:  sqlite3_key DB KEY
+**
+** Set the codec key.
+*/
+static int test_key(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  const char *zKey;
+  int nKey;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  zKey = argv[2];
+  nKey = strlen(zKey);
+#ifdef SQLITE_HAS_CODEC
+  sqlite3_key(db, zKey, nKey);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_rekey DB KEY
+**
+** Change the codec key.
+*/
+static int test_rekey(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  const char *zKey;
+  int nKey;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  zKey = argv[2];
+  nKey = strlen(zKey);
+#ifdef SQLITE_HAS_CODEC
+  sqlite3_rekey(db, zKey, nKey);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_close DB
+**
+** Closes the database opened by sqlite3_open.
+*/
+static int sqlite_test_close(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_close(db);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+
+/*
+** Implementation of the x_coalesce() function.
+** Return the first argument non-NULL argument.
+*/
+static void t1_ifnullFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int i;
+  for(i=0; i<argc; i++){
+    if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
+      int n = sqlite3_value_bytes(argv[i]);
+      sqlite3_result_text(context, (char*)sqlite3_value_text(argv[i]),
+          n, SQLITE_TRANSIENT);
+      break;
+    }
+  }
+}
+
+/*
+** These are test functions.    hex8() interprets its argument as
+** UTF8 and returns a hex encoding.  hex16le() interprets its argument
+** as UTF16le and returns a hex encoding.
+*/
+static void hex8Func(sqlite3_context *p, int argc, sqlite3_value **argv){
+  const unsigned char *z;
+  int i;
+  char zBuf[200];
+  z = sqlite3_value_text(argv[0]);
+  for(i=0; i<sizeof(zBuf)/2 - 2 && z[i]; i++){
+    sprintf(&zBuf[i*2], "%02x", z[i]&0xff);
+  }
+  zBuf[i*2] = 0;
+  sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
+}
+#ifndef SQLITE_OMIT_UTF16
+static void hex16Func(sqlite3_context *p, int argc, sqlite3_value **argv){
+  const unsigned short int *z;
+  int i;
+  char zBuf[400];
+  z = sqlite3_value_text16(argv[0]);
+  for(i=0; i<sizeof(zBuf)/4 - 4 && z[i]; i++){
+    sprintf(&zBuf[i*4], "%04x", z[i]&0xff);
+  }
+  zBuf[i*4] = 0;
+  sqlite3_result_text(p, (char*)zBuf, -1, SQLITE_TRANSIENT);
+}
+#endif
+
+/*
+** A structure into which to accumulate text.
+*/
+struct dstr {
+  int nAlloc;  /* Space allocated */
+  int nUsed;   /* Space used */
+  char *z;     /* The space */
+};
+
+/*
+** Append text to a dstr
+*/
+static void dstrAppend(struct dstr *p, const char *z, int divider){
+  int n = strlen(z);
+  if( p->nUsed + n + 2 > p->nAlloc ){
+    char *zNew;
+    p->nAlloc = p->nAlloc*2 + n + 200;
+    zNew = sqlite3_realloc(p->z, p->nAlloc);
+    if( zNew==0 ){
+      sqlite3_free(p->z);
+      memset(p, 0, sizeof(*p));
+      return;
+    }
+    p->z = zNew;
+  }
+  if( divider && p->nUsed>0 ){
+    p->z[p->nUsed++] = divider;
+  }
+  memcpy(&p->z[p->nUsed], z, n+1);
+  p->nUsed += n;
+}
+
+/*
+** Invoked for each callback from sqlite3ExecFunc
+*/
+static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){
+  struct dstr *p = (struct dstr*)pData;
+  int i;
+  for(i=0; i<argc; i++){
+    if( argv[i]==0 ){
+      dstrAppend(p, "NULL", ' ');
+    }else{
+      dstrAppend(p, argv[i], ' ');
+    }
+  }
+  return 0;
+}
+
+/*
+** Implementation of the x_sqlite_exec() function.  This function takes
+** a single argument and attempts to execute that argument as SQL code.
+** This is illegal and should set the SQLITE_MISUSE flag on the database.
+**
+** 2004-Jan-07:  We have changed this to make it legal to call sqlite3_exec()
+** from within a function call.  
+** 
+** This routine simulates the effect of having two threads attempt to
+** use the same database at the same time.
+*/
+static void sqlite3ExecFunc(
+  sqlite3_context *context, 
+  int argc,  
+  sqlite3_value **argv
+){
+  struct dstr x;
+  memset(&x, 0, sizeof(x));
+  (void)sqlite3_exec((sqlite3*)sqlite3_user_data(context),
+      (char*)sqlite3_value_text(argv[0]),
+      execFuncCallback, &x, 0);
+  sqlite3_result_text(context, x.z, x.nUsed, SQLITE_TRANSIENT);
+  sqlite3_free(x.z);
+}
+
+/*
+** Implementation of tkt2213func(), a scalar function that takes exactly
+** one argument. It has two interesting features:
+**
+** * It calls sqlite3_value_text() 3 times on the argument sqlite3_value*.
+**   If the three pointers returned are not the same an SQL error is raised.
+**
+** * Otherwise it returns a copy of the text representation of its 
+**   argument in such a way as the VDBE representation is a Mem* cell 
+**   with the MEM_Term flag clear. 
+**
+** Ticket #2213 can therefore be tested by evaluating the following
+** SQL expression:
+**
+**   tkt2213func(tkt2213func('a string'));
+*/
+static void tkt2213Function(
+  sqlite3_context *context, 
+  int argc,  
+  sqlite3_value **argv
+){
+  int nText;
+  unsigned char const *zText1;
+  unsigned char const *zText2;
+  unsigned char const *zText3;
+
+  nText = sqlite3_value_bytes(argv[0]);
+  zText1 = sqlite3_value_text(argv[0]);
+  zText2 = sqlite3_value_text(argv[0]);
+  zText3 = sqlite3_value_text(argv[0]);
+
+  if( zText1!=zText2 || zText2!=zText3 ){
+    sqlite3_result_error(context, "tkt2213 is not fixed", -1);
+  }else{
+    char *zCopy = (char *)sqlite3_malloc(nText);
+    memcpy(zCopy, zText1, nText);
+    sqlite3_result_text(context, zCopy, nText, sqlite3_free);
+  }
+}
+
+/*
+** The following SQL function takes 4 arguments.  The 2nd and
+** 4th argument must be one of these strings:  'text', 'text16',
+** or 'blob' corresponding to API functions
+**
+**      sqlite3_value_text()
+**      sqlite3_value_text16()
+**      sqlite3_value_blob()
+**
+** The third argument is a string, either 'bytes' or 'bytes16' or 'noop',
+** corresponding to APIs:
+**
+**      sqlite3_value_bytes()
+**      sqlite3_value_bytes16()
+**      noop
+**
+** The APIs designated by the 2nd through 4th arguments are applied
+** to the first argument in order.  If the pointers returned by the
+** second and fourth are different, this routine returns 1.  Otherwise,
+** this routine returns 0.
+**
+** This function is used to test to see when returned pointers from
+** the _text(), _text16() and _blob() APIs become invalidated.
+*/
+static void ptrChngFunction(
+  sqlite3_context *context, 
+  int argc,  
+  sqlite3_value **argv
+){
+  const void *p1, *p2;
+  const char *zCmd;
+  if( argc!=4 ) return;
+  zCmd = (const char*)sqlite3_value_text(argv[1]);
+  if( zCmd==0 ) return;
+  if( strcmp(zCmd,"text")==0 ){
+    p1 = (const void*)sqlite3_value_text(argv[0]);
+#ifndef SQLITE_OMIT_UTF16
+  }else if( strcmp(zCmd, "text16")==0 ){
+    p1 = (const void*)sqlite3_value_text16(argv[0]);
+#endif
+  }else if( strcmp(zCmd, "blob")==0 ){
+    p1 = (const void*)sqlite3_value_blob(argv[0]);
+  }else{
+    return;
+  }
+  zCmd = (const char*)sqlite3_value_text(argv[2]);
+  if( zCmd==0 ) return;
+  if( strcmp(zCmd,"bytes")==0 ){
+    sqlite3_value_bytes(argv[0]);
+#ifndef SQLITE_OMIT_UTF16
+  }else if( strcmp(zCmd, "bytes16")==0 ){
+    sqlite3_value_bytes16(argv[0]);
+#endif
+  }else if( strcmp(zCmd, "noop")==0 ){
+    /* do nothing */
+  }else{
+    return;
+  }
+  zCmd = (const char*)sqlite3_value_text(argv[3]);
+  if( zCmd==0 ) return;
+  if( strcmp(zCmd,"text")==0 ){
+    p2 = (const void*)sqlite3_value_text(argv[0]);
+#ifndef SQLITE_OMIT_UTF16
+  }else if( strcmp(zCmd, "text16")==0 ){
+    p2 = (const void*)sqlite3_value_text16(argv[0]);
+#endif
+  }else if( strcmp(zCmd, "blob")==0 ){
+    p2 = (const void*)sqlite3_value_blob(argv[0]);
+  }else{
+    return;
+  }
+  sqlite3_result_int(context, p1!=p2);
+}
+
+
+/*
+** Usage:  sqlite_test_create_function DB
+**
+** Call the sqlite3_create_function API on the given database in order
+** to create a function named "x_coalesce".  This function does the same thing
+** as the "coalesce" function.  This function also registers an SQL function
+** named "x_sqlite_exec" that invokes sqlite3_exec().  Invoking sqlite3_exec()
+** in this way is illegal recursion and should raise an SQLITE_MISUSE error.
+** The effect is similar to trying to use the same database connection from
+** two threads at the same time.
+**
+** The original motivation for this routine was to be able to call the
+** sqlite3_create_function function while a query is in progress in order
+** to test the SQLITE_MISUSE detection logic.
+*/
+static int test_create_function(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int rc;
+  sqlite3 *db;
+  extern void Md5_Register(sqlite3*);
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " DB\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_create_function(db, "x_coalesce", -1, SQLITE_ANY, 0, 
+        t1_ifnullFunc, 0, 0);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "hex8", 1, SQLITE_ANY, 0, 
+          hex8Func, 0, 0);
+  }
+#ifndef SQLITE_OMIT_UTF16
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "hex16", 1, SQLITE_ANY, 0, 
+          hex16Func, 0, 0);
+  }
+#endif
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "tkt2213func", 1, SQLITE_ANY, 0, 
+          tkt2213Function, 0, 0);
+  }
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "pointer_change", 4, SQLITE_ANY, 0, 
+          ptrChngFunction, 0, 0);
+  }
+
+#ifndef SQLITE_OMIT_UTF16
+  /* Use the sqlite3_create_function16() API here. Mainly for fun, but also 
+  ** because it is not tested anywhere else. */
+  if( rc==SQLITE_OK ){
+    sqlite3_value *pVal;
+    sqlite3_mutex_enter(db->mutex);
+    pVal = sqlite3ValueNew(db);
+    sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
+    if( db->mallocFailed ){
+      rc = SQLITE_NOMEM;
+    }else{
+      rc = sqlite3_create_function16(db, 
+              sqlite3ValueText(pVal, SQLITE_UTF16NATIVE),
+              1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
+    }
+    sqlite3ValueFree(pVal);
+    sqlite3_mutex_leave(db->mutex);
+  }
+#endif
+
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
+  return TCL_OK;
+}
+
+/*
+** Routines to implement the x_count() aggregate function.
+**
+** x_count() counts the number of non-null arguments.  But there are
+** some twists for testing purposes.
+**
+** If the argument to x_count() is 40 then a UTF-8 error is reported
+** on the step function.  If x_count(41) is seen, then a UTF-16 error
+** is reported on the step function.  If the total count is 42, then
+** a UTF-8 error is reported on the finalize function.
+*/
+typedef struct t1CountCtx t1CountCtx;
+struct t1CountCtx {
+  int n;
+};
+static void t1CountStep(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  t1CountCtx *p;
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0]) ) && p ){
+    p->n++;
+  }
+  if( argc>0 ){
+    int v = sqlite3_value_int(argv[0]);
+    if( v==40 ){
+      sqlite3_result_error(context, "value of 40 handed to x_count", -1);
+#ifndef SQLITE_OMIT_UTF16
+    }else if( v==41 ){
+      const char zUtf16ErrMsg[] = { 0, 0x61, 0, 0x62, 0, 0x63, 0, 0, 0};
+      sqlite3_result_error16(context, &zUtf16ErrMsg[1-SQLITE_BIGENDIAN], -1);
+#endif
+    }
+  }
+}   
+static void t1CountFinalize(sqlite3_context *context){
+  t1CountCtx *p;
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  if( p ){
+    if( p->n==42 ){
+      sqlite3_result_error(context, "x_count totals to 42", -1);
+    }else{
+      sqlite3_result_int(context, p ? p->n : 0);
+    }
+  }
+}
+
+static void legacyCountStep(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  /* no-op */
+}
+static void legacyCountFinalize(sqlite3_context *context){
+  sqlite3_result_int(context, sqlite3_aggregate_count(context));
+}
+
+/*
+** Usage:  sqlite3_create_aggregate DB
+**
+** Call the sqlite3_create_function API on the given database in order
+** to create a function named "x_count".  This function is similar
+** to the built-in count() function, with a few special quirks
+** for testing the sqlite3_result_error() APIs.
+**
+** The original motivation for this routine was to be able to call the
+** sqlite3_create_aggregate function while a query is in progress in order
+** to test the SQLITE_MISUSE detection logic.  See misuse.test.
+**
+** This routine was later extended to test the use of sqlite3_result_error()
+** within aggregate functions.
+**
+** Later: It is now also extended to register the aggregate function
+** "legacy_count()" with the supplied database handle. This is used
+** to test the deprecated sqlite3_aggregate_count() API.
+*/
+static int test_create_aggregate(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_create_function(db, "x_count", 0, SQLITE_UTF8, 0, 0,
+      t1CountStep,t1CountFinalize);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "x_count", 1, SQLITE_UTF8, 0, 0,
+        t1CountStep,t1CountFinalize);
+  }
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "legacy_count", 0, SQLITE_ANY, 0, 0,
+        legacyCountStep, legacyCountFinalize
+    );
+  }
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
+  return TCL_OK;
+}
+
+
+/*
+** Usage:  printf TEXT
+**
+** Send output to printf.  Use this rather than puts to merge the output
+** in the correct sequence with debugging printfs inserted into C code.
+** Puts uses a separate buffer and debugging statements will be out of
+** sequence if it is used.
+*/
+static int test_printf(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " TEXT\"", 0);
+    return TCL_ERROR;
+  }
+  printf("%s\n", argv[1]);
+  return TCL_OK;
+}
+
+
+
+/*
+** Usage:  sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER
+**
+** Call mprintf with three integer arguments
+*/
+static int sqlite3_mprintf_int(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int a[3], i;
+  char *z;
+  if( argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT INT INT INT\"", 0);
+    return TCL_ERROR;
+  }
+  for(i=2; i<5; i++){
+    if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
+  }
+  z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** If zNum represents an integer that will fit in 64-bits, then set
+** *pValue to that integer and return true.  Otherwise return false.
+*/
+static int sqlite3GetInt64(const char *zNum, i64 *pValue){
+  if( sqlite3FitsIn64Bits(zNum, 0) ){
+    sqlite3Atoi64(zNum, pValue);
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Usage:  sqlite3_mprintf_int64 FORMAT INTEGER INTEGER INTEGER
+**
+** Call mprintf with three 64-bit integer arguments
+*/
+static int sqlite3_mprintf_int64(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int i;
+  sqlite_int64 a[3];
+  char *z;
+  if( argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT INT INT INT\"", 0);
+    return TCL_ERROR;
+  }
+  for(i=2; i<5; i++){
+    if( !sqlite3GetInt64(argv[i], &a[i-2]) ){
+      Tcl_AppendResult(interp, "argument is not a valid 64-bit integer", 0);
+      return TCL_ERROR;
+    }
+  }
+  z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING
+**
+** Call mprintf with two integer arguments and one string argument
+*/
+static int sqlite3_mprintf_str(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int a[3], i;
+  char *z;
+  if( argc<4 || argc>5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT INT INT ?STRING?\"", 0);
+    return TCL_ERROR;
+  }
+  for(i=2; i<4; i++){
+    if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
+  }
+  z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_snprintf_str INTEGER FORMAT INTEGER INTEGER STRING
+**
+** Call mprintf with two integer arguments and one string argument
+*/
+static int sqlite3_snprintf_str(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int a[3], i;
+  int n;
+  char *z;
+  if( argc<5 || argc>6 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " INT FORMAT INT INT ?STRING?\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
+  if( n<0 ){
+    Tcl_AppendResult(interp, "N must be non-negative", 0);
+    return TCL_ERROR;
+  }
+  for(i=3; i<5; i++){
+    if( Tcl_GetInt(interp, argv[i], &a[i-3]) ) return TCL_ERROR;
+  }
+  z = sqlite3_malloc( n+1 );
+  sqlite3_snprintf(n, z, argv[2], a[0], a[1], argc>4 ? argv[5] : NULL);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_double FORMAT INTEGER INTEGER DOUBLE
+**
+** Call mprintf with two integer arguments and one double argument
+*/
+static int sqlite3_mprintf_double(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int a[3], i;
+  double r;
+  char *z;
+  if( argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT INT INT DOUBLE\"", 0);
+    return TCL_ERROR;
+  }
+  for(i=2; i<4; i++){
+    if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR;
+  }
+  if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR;
+  z = sqlite3_mprintf(argv[1], a[0], a[1], r);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_scaled FORMAT DOUBLE DOUBLE
+**
+** Call mprintf with a single double argument which is the product of the
+** two arguments given above.  This is used to generate overflow and underflow
+** doubles to test that they are converted properly.
+*/
+static int sqlite3_mprintf_scaled(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  int i;
+  double r[2];
+  char *z;
+  if( argc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT DOUBLE DOUBLE\"", 0);
+    return TCL_ERROR;
+  }
+  for(i=2; i<4; i++){
+    if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR;
+  }
+  z = sqlite3_mprintf(argv[1], r[0]*r[1]);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_stronly FORMAT STRING
+**
+** Call mprintf with a single double argument which is the product of the
+** two arguments given above.  This is used to generate overflow and underflow
+** doubles to test that they are converted properly.
+*/
+static int sqlite3_mprintf_stronly(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  char *z;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT STRING\"", 0);
+    return TCL_ERROR;
+  }
+  z = sqlite3_mprintf(argv[1], argv[2]);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_mprintf_hexdouble FORMAT HEX
+**
+** Call mprintf with a single double argument which is derived from the
+** hexadecimal encoding of an IEEE double.
+*/
+static int sqlite3_mprintf_hexdouble(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  char *z;
+  double r;
+  unsigned  x1, x2;
+  long long unsigned d;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FORMAT STRING\"", 0);
+    return TCL_ERROR;
+  }
+  if( sscanf(argv[2], "%08x%08x", &x2, &x1)!=2 ){
+    Tcl_AppendResult(interp, "2nd argument should be 16-characters of hex", 0);
+    return TCL_ERROR;
+  }
+  d = x2;
+  d = (d<<32) + x1;
+  memcpy(&r, &d, sizeof(r));
+  z = sqlite3_mprintf(argv[1], r);
+  Tcl_AppendResult(interp, z, 0);
+  sqlite3_free(z);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_enable_shared_cache      BOOLEAN
+**
+*/
+#if !defined(SQLITE_OMIT_SHARED_CACHE)
+static int test_enable_shared(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  int rc;
+  int enable;
+  int ret = 0;
+  extern int sqlite3SharedCacheEnabled;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ){
+    return TCL_ERROR;
+  }
+  ret = sqlite3SharedCacheEnabled;
+  rc = sqlite3_enable_shared_cache(enable);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)sqlite3ErrStr(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  Tcl_SetObjResult(interp, Tcl_NewBooleanObj(ret));
+  return TCL_OK;
+}
+#endif
+
+
+
+/*
+** Usage: sqlite3_extended_result_codes   DB    BOOLEAN
+**
+*/
+static int test_extended_result_codes(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  int enable;
+  sqlite3 *db;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  if( Tcl_GetBooleanFromObj(interp, objv[2], &enable) ) return TCL_ERROR;
+  sqlite3_extended_result_codes(db, enable);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_libversion_number
+**
+*/
+static int test_libversion_number(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_libversion_number()));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_table_column_metadata DB dbname tblname colname
+**
+*/
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+static int test_table_column_metadata(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  const char *zDb;
+  const char *zTbl;
+  const char *zCol;
+  int rc;
+  Tcl_Obj *pRet;
+
+  const char *zDatatype;
+  const char *zCollseq;
+  int notnull;
+  int primarykey;
+  int autoincrement;
+
+  if( objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB dbname tblname colname");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zDb = Tcl_GetString(objv[2]);
+  zTbl = Tcl_GetString(objv[3]);
+  zCol = Tcl_GetString(objv[4]);
+
+  if( strlen(zDb)==0 ) zDb = 0;
+
+  rc = sqlite3_table_column_metadata(db, zDb, zTbl, zCol, 
+      &zDatatype, &zCollseq, &notnull, &primarykey, &autoincrement);
+
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3_errmsg(db), 0);
+    return TCL_ERROR;
+  }
+
+  pRet = Tcl_NewObj();
+  Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zDatatype, -1));
+  Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zCollseq, -1));
+  Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(notnull));
+  Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(primarykey));
+  Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(autoincrement));
+  Tcl_SetObjResult(interp, pRet);
+
+  return TCL_OK;
+}
+#endif
+
+#ifndef SQLITE_OMIT_INCRBLOB
+
+/*
+** sqlite3_blob_read  CHANNEL OFFSET N
+**
+**   This command is used to test the sqlite3_blob_read() in ways that
+**   the Tcl channel interface does not. The first argument should
+**   be the name of a valid channel created by the [incrblob] method
+**   of a database handle. This function calls sqlite3_blob_read()
+**   to read N bytes from offset OFFSET from the underlying SQLite
+**   blob handle.
+**
+**   On success, a byte-array object containing the read data is 
+**   returned. On failure, the interpreter result is set to the
+**   text representation of the returned error code (i.e. "SQLITE_NOMEM")
+**   and a Tcl exception is thrown.
+*/
+static int test_blob_read(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_Channel channel;
+  ClientData instanceData;
+  sqlite3_blob *pBlob;
+  int notUsed;
+  int nByte;
+  int iOffset;
+  unsigned char *zBuf;
+  int rc;
+  
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL OFFSET N");
+    return TCL_ERROR;
+  }
+
+  channel = Tcl_GetChannel(interp, Tcl_GetString(objv[1]), &notUsed);
+  if( !channel
+   || TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iOffset)
+   || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &nByte)
+   || nByte<0 || iOffset<0
+  ){ 
+    return TCL_ERROR;
+  }
+
+  instanceData = Tcl_GetChannelInstanceData(channel);
+  pBlob = *((sqlite3_blob **)instanceData);
+
+  zBuf = (unsigned char *)Tcl_Alloc(nByte);
+  rc = sqlite3_blob_read(pBlob, zBuf, nByte, iOffset);
+  if( rc==SQLITE_OK ){
+    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zBuf, nByte));
+  }else{
+    Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
+  }
+  Tcl_Free((char *)zBuf);
+
+  return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
+}
+
+/*
+** sqlite3_blob_write CHANNEL OFFSET DATA
+**
+**   This command is used to test the sqlite3_blob_write() in ways that
+**   the Tcl channel interface does not. The first argument should
+**   be the name of a valid channel created by the [incrblob] method
+**   of a database handle. This function calls sqlite3_blob_write()
+**   to write the DATA byte-array to the underlying SQLite blob handle.
+**   at offset OFFSET.
+**
+**   On success, an empty string is returned. On failure, the interpreter
+**   result is set to the text representation of the returned error code 
+**   (i.e. "SQLITE_NOMEM") and a Tcl exception is thrown.
+*/
+static int test_blob_write(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_Channel channel;
+  ClientData instanceData;
+  sqlite3_blob *pBlob;
+  int notUsed;
+  int iOffset;
+  int rc;
+
+  unsigned char *zBuf;
+  int nBuf;
+  
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "CHANNEL OFFSET DATA");
+    return TCL_ERROR;
+  }
+
+  channel = Tcl_GetChannel(interp, Tcl_GetString(objv[1]), &notUsed);
+  if( !channel
+   || TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iOffset)
+   || iOffset<0
+  ){ 
+    return TCL_ERROR;
+  }
+
+  instanceData = Tcl_GetChannelInstanceData(channel);
+  pBlob = *((sqlite3_blob **)instanceData);
+
+  zBuf = Tcl_GetByteArrayFromObj(objv[3], &nBuf);
+  rc = sqlite3_blob_write(pBlob, zBuf, nBuf, iOffset);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
+  }
+
+  return (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
+}
+#endif
+
+/*
+** Usage: sqlite3_create_collation_v2 DB-HANDLE NAME CMP-PROC DEL-PROC
+**
+**   This Tcl proc is used for testing the experimental
+**   sqlite3_create_collation_v2() interface.
+*/
+struct TestCollationX {
+  Tcl_Interp *interp;
+  Tcl_Obj *pCmp;
+  Tcl_Obj *pDel;
+};
+typedef struct TestCollationX TestCollationX;
+static void testCreateCollationDel(void *pCtx){
+  TestCollationX *p = (TestCollationX *)pCtx;
+
+  int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
+  if( rc!=TCL_OK ){
+    Tcl_BackgroundError(p->interp);
+  }
+
+  Tcl_DecrRefCount(p->pCmp);
+  Tcl_DecrRefCount(p->pDel);
+  sqlite3_free((void *)p);
+}
+static int testCreateCollationCmp(
+  void *pCtx,
+  int nLeft,
+  const void *zLeft,
+  int nRight,
+  const void *zRight
+){
+  TestCollationX *p = (TestCollationX *)pCtx;
+  Tcl_Obj *pScript = Tcl_DuplicateObj(p->pCmp);
+  int iRes = 0;
+
+  Tcl_IncrRefCount(pScript);
+  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zLeft, nLeft));
+  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj((char *)zRight,nRight));
+
+  if( TCL_OK!=Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL)
+   || TCL_OK!=Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iRes)
+  ){
+    Tcl_BackgroundError(p->interp);
+  }
+  Tcl_DecrRefCount(pScript);
+
+  return iRes;
+}
+static int test_create_collation_v2(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  TestCollationX *p;
+  sqlite3 *db;
+
+  if( objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE NAME CMP-PROC DEL-PROC");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+
+  p = (TestCollationX *)sqlite3_malloc(sizeof(TestCollationX));
+  p->pCmp = objv[3];
+  p->pDel = objv[4];
+  p->interp = interp;
+  Tcl_IncrRefCount(p->pCmp);
+  Tcl_IncrRefCount(p->pDel);
+
+  sqlite3_create_collation_v2(db, Tcl_GetString(objv[2]), SQLITE_UTF8, 
+      (void *)p, testCreateCollationCmp, testCreateCollationDel
+  );
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_load_extension DB-HANDLE FILE ?PROC?
+*/
+static int test_load_extension(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_CmdInfo cmdInfo;
+  sqlite3 *db;
+  int rc;
+  char *zDb;
+  char *zFile;
+  char *zProc = 0;
+  char *zErr = 0;
+
+  if( objc!=4 && objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE FILE ?PROC?");
+    return TCL_ERROR;
+  }
+  zDb = Tcl_GetString(objv[1]);
+  zFile = Tcl_GetString(objv[2]);
+  if( objc==4 ){
+    zProc = Tcl_GetString(objv[3]);
+  }
+
+  /* Extract the C database handle from the Tcl command name */
+  if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
+    Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
+    return TCL_ERROR;
+  }
+  db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
+  assert(db);
+
+  /* Call the underlying C function. If an error occurs, set rc to 
+  ** TCL_ERROR and load any error string into the interpreter. If no 
+  ** error occurs, set rc to TCL_OK.
+  */
+#ifdef SQLITE_OMIT_LOAD_EXTENSION
+  rc = SQLITE_ERROR;
+  zErr = sqlite3_mprintf("this build omits sqlite3_load_extension()");
+#else
+  rc = sqlite3_load_extension(db, zFile, zProc, &zErr);
+#endif
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, zErr ? zErr : "", TCL_VOLATILE);
+    rc = TCL_ERROR;
+  }else{
+    rc = TCL_OK;
+  }
+  sqlite3_free(zErr);
+
+  return rc;
+}
+
+/*
+** Usage: sqlite3_enable_load_extension DB-HANDLE ONOFF
+*/
+static int test_enable_load(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_CmdInfo cmdInfo;
+  sqlite3 *db;
+  char *zDb;
+  int onoff;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB-HANDLE ONOFF");
+    return TCL_ERROR;
+  }
+  zDb = Tcl_GetString(objv[1]);
+
+  /* Extract the C database handle from the Tcl command name */
+  if( !Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
+    Tcl_AppendResult(interp, "command not found: ", zDb, (char*)0);
+    return TCL_ERROR;
+  }
+  db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
+  assert(db);
+
+  /* Get the onoff parameter */
+  if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){
+    return TCL_ERROR;
+  }
+
+#ifdef SQLITE_OMIT_LOAD_EXTENSION
+  Tcl_AppendResult(interp, "this build omits sqlite3_load_extension()");
+  return TCL_ERROR;
+#else
+  sqlite3_enable_load_extension(db, onoff);
+  return TCL_OK;
+#endif
+}
+
+/*
+** Usage:  sqlite_abort
+**
+** Shutdown the process immediately.  This is not a clean shutdown.
+** This command is used to test the recoverability of a database in
+** the event of a program crash.
+*/
+static int sqlite_abort(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  assert( interp==0 );   /* This will always fail */
+  return TCL_OK;
+}
+
+/*
+** The following routine is a user-defined SQL function whose purpose
+** is to test the sqlite_set_result() API.
+*/
+static void testFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  while( argc>=2 ){
+    const char *zArg0 = (char*)sqlite3_value_text(argv[0]);
+    if( zArg0 ){
+      if( 0==sqlite3StrICmp(zArg0, "int") ){
+        sqlite3_result_int(context, sqlite3_value_int(argv[1]));
+      }else if( sqlite3StrICmp(zArg0,"int64")==0 ){
+        sqlite3_result_int64(context, sqlite3_value_int64(argv[1]));
+      }else if( sqlite3StrICmp(zArg0,"string")==0 ){
+        sqlite3_result_text(context, (char*)sqlite3_value_text(argv[1]), -1,
+            SQLITE_TRANSIENT);
+      }else if( sqlite3StrICmp(zArg0,"double")==0 ){
+        sqlite3_result_double(context, sqlite3_value_double(argv[1]));
+      }else if( sqlite3StrICmp(zArg0,"null")==0 ){
+        sqlite3_result_null(context);
+      }else if( sqlite3StrICmp(zArg0,"value")==0 ){
+        sqlite3_result_value(context, argv[sqlite3_value_int(argv[1])]);
+      }else{
+        goto error_out;
+      }
+    }else{
+      goto error_out;
+    }
+    argc -= 2;
+    argv += 2;
+  }
+  return;
+
+error_out:
+  sqlite3_result_error(context,"first argument should be one of: "
+      "int int64 string double null value", -1);
+}
+
+/*
+** Usage:   sqlite_register_test_function  DB  NAME
+**
+** Register the test SQL function on the database DB under the name NAME.
+*/
+static int test_register_func(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3 *db;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " DB FUNCTION-NAME", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 
+      testFunc, 0, 0);
+  if( rc!=0 ){
+    Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
+    return TCL_ERROR;
+  }
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_finalize  STMT 
+**
+** Finalize a statement handle.
+*/
+static int test_finalize(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+  sqlite3 *db = 0;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+
+  if( pStmt ){
+    db = StmtToDb(pStmt);
+  }
+  rc = sqlite3_finalize(pStmt);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  if( db && sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_reset  STMT 
+**
+** Reset a statement handle.
+*/
+static int test_reset(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+
+  rc = sqlite3_reset(pStmt);
+  if( pStmt && sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ){
+    return TCL_ERROR;
+  }
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+/*
+  if( rc ){
+    return TCL_ERROR;
+  }
+*/
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_expired STMT 
+**
+** Return TRUE if a recompilation of the statement is recommended.
+*/
+static int test_expired(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " <STMT>", 0);
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, Tcl_NewBooleanObj(sqlite3_expired(pStmt)));
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_transfer_bindings FROMSTMT TOSTMT
+**
+** Transfer all bindings from FROMSTMT over to TOSTMT
+*/
+static int test_transfer_bind(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt1, *pStmt2;
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " FROM-STMT TO-STMT", 0);
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt1)) return TCL_ERROR;
+  if( getStmtPointer(interp, Tcl_GetString(objv[2]), &pStmt2)) return TCL_ERROR;
+  Tcl_SetObjResult(interp, 
+     Tcl_NewIntObj(sqlite3_transfer_bindings(pStmt1,pStmt2)));
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_changes DB
+**
+** Return the number of changes made to the database by the last SQL
+** execution.
+*/
+static int test_changes(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+       Tcl_GetString(objv[0]), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_changes(db)));
+  return TCL_OK;
+}
+
+/*
+** This is the "static_bind_value" that variables are bound to when
+** the FLAG option of sqlite3_bind is "static"
+*/
+static char *sqlite_static_bind_value = 0;
+static int sqlite_static_bind_nbyte = 0;
+
+/*
+** Usage:  sqlite3_bind  VM  IDX  VALUE  FLAGS
+**
+** Sets the value of the IDX-th occurance of "?" in the original SQL
+** string.  VALUE is the new value.  If FLAGS=="null" then VALUE is
+** ignored and the value is set to NULL.  If FLAGS=="static" then
+** the value is set to the value of a static variable named
+** "sqlite_static_bind_value".  If FLAGS=="normal" then a copy
+** of the VALUE is made.  If FLAGS=="blob10" then a VALUE is ignored
+** an a 10-byte blob "abc\000xyz\000pq" is inserted.
+*/
+static int test_bind(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+  int idx;
+  if( argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+       " VM IDX VALUE (null|static|normal)\"", 0);
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, argv[1], &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR;
+  if( strcmp(argv[4],"null")==0 ){
+    rc = sqlite3_bind_null(pStmt, idx);
+  }else if( strcmp(argv[4],"static")==0 ){
+    rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value, -1, 0);
+  }else if( strcmp(argv[4],"static-nbytes")==0 ){
+    rc = sqlite3_bind_text(pStmt, idx, sqlite_static_bind_value,
+                                       sqlite_static_bind_nbyte, 0);
+  }else if( strcmp(argv[4],"normal")==0 ){
+    rc = sqlite3_bind_text(pStmt, idx, argv[3], -1, SQLITE_TRANSIENT);
+  }else if( strcmp(argv[4],"blob10")==0 ){
+    rc = sqlite3_bind_text(pStmt, idx, "abc\000xyz\000pq", 10, SQLITE_STATIC);
+  }else{
+    Tcl_AppendResult(interp, "4th argument should be "
+        "\"null\" or \"static\" or \"normal\"", 0);
+    return TCL_ERROR;
+  }
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc ){
+    char zBuf[50];
+    sprintf(zBuf, "(%d) ", rc);
+    Tcl_AppendResult(interp, zBuf, sqlite3ErrStr(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Usage: add_test_collate <db ptr> <utf8> <utf16le> <utf16be>
+**
+** This function is used to test that SQLite selects the correct collation
+** sequence callback when multiple versions (for different text encodings)
+** are available.
+**
+** Calling this routine registers the collation sequence "test_collate"
+** with database handle <db>. The second argument must be a list of three
+** boolean values. If the first is true, then a version of test_collate is
+** registered for UTF-8, if the second is true, a version is registered for
+** UTF-16le, if the third is true, a UTF-16be version is available.
+** Previous versions of test_collate are deleted.
+**
+** The collation sequence test_collate is implemented by calling the
+** following TCL script:
+**
+**   "test_collate <enc> <lhs> <rhs>"
+**
+** The <lhs> and <rhs> are the two values being compared, encoded in UTF-8.
+** The <enc> parameter is the encoding of the collation function that
+** SQLite selected to call. The TCL test script implements the
+** "test_collate" proc.
+**
+** Note that this will only work with one intepreter at a time, as the
+** interp pointer to use when evaluating the TCL script is stored in
+** pTestCollateInterp.
+*/
+static Tcl_Interp* pTestCollateInterp;
+static int test_collate_func(
+  void *pCtx, 
+  int nA, const void *zA,
+  int nB, const void *zB
+){
+  Tcl_Interp *i = pTestCollateInterp;
+  int encin = (int)pCtx;
+  int res;
+  int n;
+
+  sqlite3_value *pVal;
+  Tcl_Obj *pX;
+
+  pX = Tcl_NewStringObj("test_collate", -1);
+  Tcl_IncrRefCount(pX);
+
+  switch( encin ){
+    case SQLITE_UTF8:
+      Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-8",-1));
+      break;
+    case SQLITE_UTF16LE:
+      Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16LE",-1));
+      break;
+    case SQLITE_UTF16BE:
+      Tcl_ListObjAppendElement(i,pX,Tcl_NewStringObj("UTF-16BE",-1));
+      break;
+    default:
+      assert(0);
+  }
+
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC);
+  n = sqlite3_value_bytes(pVal);
+  Tcl_ListObjAppendElement(i,pX,
+      Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
+  sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC);
+  n = sqlite3_value_bytes(pVal);
+  Tcl_ListObjAppendElement(i,pX,
+      Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
+  sqlite3ValueFree(pVal);
+
+  Tcl_EvalObjEx(i, pX, 0);
+  Tcl_DecrRefCount(pX);
+  Tcl_GetIntFromObj(i, Tcl_GetObjResult(i), &res);
+  return res;
+}
+static int test_collate(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  int val;
+  sqlite3_value *pVal;
+  int rc;
+
+  if( objc!=5 ) goto bad_args;
+  pTestCollateInterp = interp;
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+
+  if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
+  rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8, 
+          (void *)SQLITE_UTF8, val?test_collate_func:0);
+  if( rc==SQLITE_OK ){
+    if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
+    rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE, 
+            (void *)SQLITE_UTF16LE, val?test_collate_func:0);
+    if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
+
+#if 0
+    if( sqlite3_iMallocFail>0 ){
+      sqlite3_iMallocFail++;
+    }
+#endif
+    sqlite3_mutex_enter(db->mutex);
+    pVal = sqlite3ValueNew(db);
+    sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
+    if( db->mallocFailed ){
+      rc = SQLITE_NOMEM;
+    }else{
+      rc = sqlite3_create_collation16(db, 
+          sqlite3ValueText(pVal, SQLITE_UTF16NATIVE), SQLITE_UTF16BE, 
+          (void *)SQLITE_UTF16BE, val?test_collate_func:0);
+    }
+    sqlite3ValueFree(pVal);
+    sqlite3_mutex_leave(db->mutex);
+  }
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+
+bad_args:
+  Tcl_AppendResult(interp, "wrong # args: should be \"",
+      Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
+  return TCL_ERROR;
+}
+
+/*
+** When the collation needed callback is invoked, record the name of 
+** the requested collating function here.  The recorded name is linked
+** to a TCL variable and used to make sure that the requested collation
+** name is correct.
+*/
+static char zNeededCollation[200];
+static char *pzNeededCollation = zNeededCollation;
+
+
+/*
+** Called when a collating sequence is needed.  Registered using
+** sqlite3_collation_needed16().
+*/
+static void test_collate_needed_cb(
+  void *pCtx, 
+  sqlite3 *db,
+  int eTextRep,
+  const void *pName
+){
+  int enc = ENC(db);
+  int i;
+  char *z;
+  for(z = (char*)pName, i=0; *z || z[1]; z++){
+    if( *z ) zNeededCollation[i++] = *z;
+  }
+  zNeededCollation[i] = 0;
+  sqlite3_create_collation(
+      db, "test_collate", ENC(db), (void *)enc, test_collate_func);
+}
+
+/*
+** Usage: add_test_collate_needed DB
+*/
+static int test_collate_needed(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=2 ) goto bad_args;
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  rc = sqlite3_collation_needed16(db, 0, test_collate_needed_cb);
+  zNeededCollation[0] = 0;
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  return TCL_OK;
+
+bad_args:
+  Tcl_WrongNumArgs(interp, 1, objv, "DB");
+  return TCL_ERROR;
+}
+
+/*
+** tclcmd:   add_alignment_test_collations  DB
+**
+** Add two new collating sequences to the database DB
+**
+**     utf16_aligned
+**     utf16_unaligned
+**
+** Both collating sequences use the same sort order as BINARY.
+** The only difference is that the utf16_aligned collating
+** sequence is declared with the SQLITE_UTF16_ALIGNED flag.
+** Both collating functions increment the unaligned utf16 counter
+** whenever they see a string that begins on an odd byte boundary.
+*/
+static int unaligned_string_counter = 0;
+static int alignmentCollFunc(
+  void *NotUsed,
+  int nKey1, const void *pKey1,
+  int nKey2, const void *pKey2
+){
+  int rc, n;
+  n = nKey1<nKey2 ? nKey1 : nKey2;
+  if( nKey1>0 && 1==(1&(int)pKey1) ) unaligned_string_counter++;
+  if( nKey2>0 && 1==(1&(int)pKey2) ) unaligned_string_counter++;
+  rc = memcmp(pKey1, pKey2, n);
+  if( rc==0 ){
+    rc = nKey1 - nKey2;
+  }
+  return rc;
+}
+static int add_alignment_test_collations(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  if( objc>=2 ){
+    if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+    sqlite3_create_collation(db, "utf16_unaligned",
+        SQLITE_UTF16, 
+        0, alignmentCollFunc);
+    sqlite3_create_collation(db, "utf16_aligned",
+        SQLITE_UTF16 | SQLITE_UTF16_ALIGNED, 
+        0, alignmentCollFunc);
+  }
+  return SQLITE_OK;
+}
+#endif /* !defined(SQLITE_OMIT_UTF16) */
+
+/*
+** Usage: add_test_function <db ptr> <utf8> <utf16le> <utf16be>
+**
+** This function is used to test that SQLite selects the correct user
+** function callback when multiple versions (for different text encodings)
+** are available.
+**
+** Calling this routine registers up to three versions of the user function
+** "test_function" with database handle <db>.  If the second argument is
+** true, then a version of test_function is registered for UTF-8, if the
+** third is true, a version is registered for UTF-16le, if the fourth is
+** true, a UTF-16be version is available.  Previous versions of
+** test_function are deleted.
+**
+** The user function is implemented by calling the following TCL script:
+**
+**   "test_function <enc> <arg>"
+**
+** Where <enc> is one of UTF-8, UTF-16LE or UTF16BE, and <arg> is the
+** single argument passed to the SQL function. The value returned by
+** the TCL script is used as the return value of the SQL function. It
+** is passed to SQLite using UTF-16BE for a UTF-8 test_function(), UTF-8
+** for a UTF-16LE test_function(), and UTF-16LE for an implementation that
+** prefers UTF-16BE.
+*/
+#ifndef SQLITE_OMIT_UTF16
+static void test_function_utf8(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  Tcl_Interp *interp;
+  Tcl_Obj *pX;
+  sqlite3_value *pVal;
+  interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
+  pX = Tcl_NewStringObj("test_function", -1);
+  Tcl_IncrRefCount(pX);
+  Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-8", -1));
+  Tcl_ListObjAppendElement(interp, pX, 
+      Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
+  Tcl_EvalObjEx(interp, pX, 0);
+  Tcl_DecrRefCount(pX);
+  sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT);
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 
+      SQLITE_UTF8, SQLITE_STATIC);
+  sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal),
+      -1, SQLITE_TRANSIENT);
+  sqlite3ValueFree(pVal);
+}
+static void test_function_utf16le(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  Tcl_Interp *interp;
+  Tcl_Obj *pX;
+  sqlite3_value *pVal;
+  interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
+  pX = Tcl_NewStringObj("test_function", -1);
+  Tcl_IncrRefCount(pX);
+  Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16LE", -1));
+  Tcl_ListObjAppendElement(interp, pX, 
+      Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
+  Tcl_EvalObjEx(interp, pX, 0);
+  Tcl_DecrRefCount(pX);
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 
+      SQLITE_UTF8, SQLITE_STATIC);
+  sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT);
+  sqlite3ValueFree(pVal);
+}
+static void test_function_utf16be(
+  sqlite3_context *pCtx, 
+  int nArg,
+  sqlite3_value **argv
+){
+  Tcl_Interp *interp;
+  Tcl_Obj *pX;
+  sqlite3_value *pVal;
+  interp = (Tcl_Interp *)sqlite3_user_data(pCtx);
+  pX = Tcl_NewStringObj("test_function", -1);
+  Tcl_IncrRefCount(pX);
+  Tcl_ListObjAppendElement(interp, pX, Tcl_NewStringObj("UTF-16BE", -1));
+  Tcl_ListObjAppendElement(interp, pX, 
+      Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
+  Tcl_EvalObjEx(interp, pX, 0);
+  Tcl_DecrRefCount(pX);
+  pVal = sqlite3ValueNew(0);
+  sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), 
+      SQLITE_UTF8, SQLITE_STATIC);
+  sqlite3_result_text16(pCtx, sqlite3_value_text16le(pVal),
+      -1, SQLITE_TRANSIENT);
+  sqlite3_result_text16be(pCtx, sqlite3_value_text16le(pVal),
+      -1, SQLITE_TRANSIENT);
+  sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
+      -1, SQLITE_TRANSIENT);
+  sqlite3ValueFree(pVal);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+static int test_function(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3 *db;
+  int val;
+
+  if( objc!=5 ) goto bad_args;
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+
+  if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
+  if( val ){
+    sqlite3_create_function(db, "test_function", 1, SQLITE_UTF8, 
+        interp, test_function_utf8, 0, 0);
+  }
+  if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
+  if( val ){
+    sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16LE, 
+        interp, test_function_utf16le, 0, 0);
+  }
+  if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR;
+  if( val ){
+    sqlite3_create_function(db, "test_function", 1, SQLITE_UTF16BE, 
+        interp, test_function_utf16be, 0, 0);
+  }
+
+  return TCL_OK;
+bad_args:
+  Tcl_AppendResult(interp, "wrong # args: should be \"",
+      Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0);
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_ERROR;
+}
+
+/*
+** Usage:         test_errstr <err code>
+**
+** Test that the english language string equivalents for sqlite error codes
+** are sane. The parameter is an integer representing an sqlite error code.
+** The result is a list of two elements, the string representation of the
+** error code and the english language explanation.
+*/
+static int test_errstr(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  char *zCode;
+  int i;
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "<error code>");
+  }
+
+  zCode = Tcl_GetString(objv[1]);
+  for(i=0; i<200; i++){
+    if( 0==strcmp(t1ErrorName(i), zCode) ) break;
+  }
+  Tcl_SetResult(interp, (char *)sqlite3ErrStr(i), 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:    breakpoint
+**
+** This routine exists for one purpose - to provide a place to put a
+** breakpoint with GDB that can be triggered using TCL code.  The use
+** for this is when a particular test fails on (say) the 1485th iteration.
+** In the TCL test script, we can add code like this:
+**
+**     if {$i==1485} breakpoint
+**
+** Then run testfixture in the debugger and wait for the breakpoint to
+** fire.  Then additional breakpoints can be set to trace down the bug.
+*/
+static int test_breakpoint(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  char **argv            /* Text of each argument */
+){
+  return TCL_OK;         /* Do nothing */
+}
+
+/*
+** Usage:   sqlite3_bind_zeroblob  STMT IDX N
+**
+** Test the sqlite3_bind_zeroblob interface.  STMT is a prepared statement.
+** IDX is the index of a wildcard in the prepared statement.  This command
+** binds a N-byte zero-filled BLOB to the wildcard.
+*/
+static int test_bind_zeroblob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  int n;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX N");
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[3], &n) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_zeroblob(pStmt, idx, n);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_int  STMT N VALUE
+**
+** Test the sqlite3_bind_int interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a 32-bit integer VALUE to that wildcard.
+*/
+static int test_bind_int(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  int value;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_int(pStmt, idx, value);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   sqlite3_bind_int64  STMT N VALUE
+**
+** Test the sqlite3_bind_int64 interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a 64-bit integer VALUE to that wildcard.
+*/
+static int test_bind_int64(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  i64 value;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  if( Tcl_GetWideIntFromObj(interp, objv[3], &value) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_int64(pStmt, idx, value);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   sqlite3_bind_double  STMT N VALUE
+**
+** Test the sqlite3_bind_double interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a 64-bit integer VALUE to that wildcard.
+*/
+static int test_bind_double(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  double value;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  if( Tcl_GetDoubleFromObj(interp, objv[3], &value) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_double(pStmt, idx, value);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_null  STMT N
+**
+** Test the sqlite3_bind_null interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a NULL to the wildcard.
+*/
+static int test_bind_null(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  int rc;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_null(pStmt, idx);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_text  STMT N STRING BYTES
+**
+** Test the sqlite3_bind_text interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a UTF-8 string STRING to the wildcard.  The string is BYTES bytes
+** long.
+*/
+static int test_bind_text(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  int bytes;
+  char *value;
+  int rc;
+
+  if( objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  value = Tcl_GetString(objv[3]);
+  if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_text(pStmt, idx, value, bytes, SQLITE_TRANSIENT);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_text16 ?-static? STMT N STRING BYTES
+**
+** Test the sqlite3_bind_text16 interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a UTF-16 string STRING to the wildcard.  The string is BYTES bytes
+** long.
+*/
+static int test_bind_text16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3_stmt *pStmt;
+  int idx;
+  int bytes;
+  char *value;
+  int rc;
+
+  void (*xDel)() = (objc==6?SQLITE_STATIC:SQLITE_TRANSIENT);
+  Tcl_Obj *oStmt    = objv[objc-4];
+  Tcl_Obj *oN       = objv[objc-3];
+  Tcl_Obj *oString  = objv[objc-2];
+  Tcl_Obj *oBytes   = objv[objc-1];
+
+  if( objc!=5 && objc!=6){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N VALUE BYTES", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(oStmt), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, oN, &idx) ) return TCL_ERROR;
+  value = (char*)Tcl_GetByteArrayFromObj(oString, 0);
+  if( Tcl_GetIntFromObj(interp, oBytes, &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_text16(pStmt, idx, (void *)value, bytes, xDel);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_blob ?-static? STMT N DATA BYTES
+**
+** Test the sqlite3_bind_blob interface.  STMT is a prepared statement.
+** N is the index of a wildcard in the prepared statement.  This command
+** binds a BLOB to the wildcard.  The BLOB is BYTES bytes in size.
+*/
+static int test_bind_blob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int idx;
+  int bytes;
+  char *value;
+  int rc;
+  sqlite3_destructor_type xDestructor = SQLITE_TRANSIENT;
+
+  if( objc!=5 && objc!=6 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " STMT N DATA BYTES", 0);
+    return TCL_ERROR;
+  }
+
+  if( objc==6 ){
+    xDestructor = SQLITE_STATIC;
+    objv++;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
+  value = Tcl_GetString(objv[3]);
+  if( Tcl_GetIntFromObj(interp, objv[4], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_bind_blob(pStmt, idx, value, bytes, xDestructor);
+  if( sqlite3TestErrCode(interp, StmtToDb(pStmt), rc) ) return TCL_ERROR;
+  if( rc!=SQLITE_OK ){
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_parameter_count  STMT
+**
+** Return the number of wildcards in the given statement.
+*/
+static int test_bind_parameter_count(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT");
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_bind_parameter_count(pStmt)));
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_parameter_name  STMT  N
+**
+** Return the name of the Nth wildcard.  The first wildcard is 1.
+** An empty string is returned if N is out of range or if the wildcard
+** is nameless.
+*/
+static int test_bind_parameter_name(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int i;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT N");
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &i) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, 
+     Tcl_NewStringObj(sqlite3_bind_parameter_name(pStmt,i),-1)
+  );
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_bind_parameter_index  STMT  NAME
+**
+** Return the index of the wildcard called NAME.  Return 0 if there is
+** no such wildcard.
+*/
+static int test_bind_parameter_index(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT NAME");
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, 
+     Tcl_NewIntObj(
+       sqlite3_bind_parameter_index(pStmt,Tcl_GetString(objv[2]))
+     )
+  );
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_clear_bindings STMT
+**
+*/
+static int test_clear_bindings(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "STMT");
+    return TCL_ERROR;
+  }
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(pStmt)));
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_sleep MILLISECONDS
+*/
+static int test_sleep(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int ms;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "MILLISECONDS");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &ms) ){
+    return TCL_ERROR;
+  }
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_sleep(ms)));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_errcode DB
+**
+** Return the string representation of the most recent sqlite3_* API
+** error code. e.g. "SQLITE_ERROR".
+*/
+static int test_errcode(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  int rc;
+  char zBuf[30];
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  rc = sqlite3_errcode(db);
+  if( (rc&0xff)==rc ){
+    zBuf[0] = 0;
+  }else{
+    sprintf(zBuf,"+%d", rc>>8);
+  }
+  Tcl_AppendResult(interp, (char *)t1ErrorName(rc), zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   test_errmsg DB
+**
+** Returns the UTF-8 representation of the error message string for the
+** most recent sqlite3_* API call.
+*/
+static int test_errmsg(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  const char *zErr;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+
+  zErr = sqlite3_errmsg(db);
+  Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
+  return TCL_OK;
+}
+
+/*
+** Usage:   test_errmsg16 DB
+**
+** Returns the UTF-16 representation of the error message string for the
+** most recent sqlite3_* API call. This is a byte array object at the TCL 
+** level, and it includes the 0x00 0x00 terminator bytes at the end of the
+** UTF-16 string.
+*/
+static int test_errmsg16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3 *db;
+  const void *zErr;
+  int bytes = 0;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+
+  zErr = sqlite3_errmsg16(db);
+  if( zErr ){
+    bytes = sqlite3Utf16ByteLen(zErr, -1);
+  }
+  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(zErr, bytes));
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_prepare DB sql bytes tailvar
+**
+** Compile up to <bytes> bytes of the supplied SQL string <sql> using
+** database handle <DB>. The parameter <tailval> is the name of a global
+** variable that is set to the unused portion of <sql> (if any). A
+** STMT handle is returned.
+*/
+static int test_prepare(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  const char *zSql;
+  int bytes;
+  const char *zTail = 0;
+  sqlite3_stmt *pStmt = 0;
+  char zBuf[50];
+  int rc;
+
+  if( objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSql = Tcl_GetString(objv[2]);
+  if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_prepare(db, zSql, bytes, &pStmt, &zTail);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  if( zTail ){
+    if( bytes>=0 ){
+      bytes = bytes - (zTail-zSql);
+    }
+    Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
+  }
+  if( rc!=SQLITE_OK ){
+    assert( pStmt==0 );
+    sprintf(zBuf, "(%d) ", rc);
+    Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
+    return TCL_ERROR;
+  }
+
+  if( pStmt ){
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+    Tcl_AppendResult(interp, zBuf, 0);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_prepare_v2 DB sql bytes tailvar
+**
+** Compile up to <bytes> bytes of the supplied SQL string <sql> using
+** database handle <DB>. The parameter <tailval> is the name of a global
+** variable that is set to the unused portion of <sql> (if any). A
+** STMT handle is returned.
+*/
+static int test_prepare_v2(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  const char *zSql;
+  int bytes;
+  const char *zTail = 0;
+  sqlite3_stmt *pStmt = 0;
+  char zBuf[50];
+  int rc;
+
+  if( objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSql = Tcl_GetString(objv[2]);
+  if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_prepare_v2(db, zSql, bytes, &pStmt, &zTail);
+  assert(rc==SQLITE_OK || pStmt==0);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  if( zTail ){
+    if( bytes>=0 ){
+      bytes = bytes - (zTail-zSql);
+    }
+    Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
+  }
+  if( rc!=SQLITE_OK ){
+    assert( pStmt==0 );
+    sprintf(zBuf, "(%d) ", rc);
+    Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
+    return TCL_ERROR;
+  }
+
+  if( pStmt ){
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+    Tcl_AppendResult(interp, zBuf, 0);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_prepare16 DB sql bytes tailvar
+**
+** Compile up to <bytes> bytes of the supplied SQL string <sql> using
+** database handle <DB>. The parameter <tailval> is the name of a global
+** variable that is set to the unused portion of <sql> (if any). A
+** STMT handle is returned.
+*/
+static int test_prepare16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3 *db;
+  const void *zSql;
+  const void *zTail = 0;
+  Tcl_Obj *pTail = 0;
+  sqlite3_stmt *pStmt = 0;
+  char zBuf[50]; 
+  int rc;
+  int bytes;                /* The integer specified as arg 3 */
+  int objlen;               /* The byte-array length of arg 2 */
+
+  if( objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
+  if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_prepare16(db, zSql, bytes, &pStmt, &zTail);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  if( rc ){
+    return TCL_ERROR;
+  }
+
+  if( zTail ){
+    objlen = objlen - ((u8 *)zTail-(u8 *)zSql);
+  }else{
+    objlen = 0;
+  }
+  pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
+  Tcl_IncrRefCount(pTail);
+  Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
+  Tcl_DecrRefCount(pTail);
+
+  if( pStmt ){
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, zBuf, 0);
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_prepare16_v2 DB sql bytes tailvar
+**
+** Compile up to <bytes> bytes of the supplied SQL string <sql> using
+** database handle <DB>. The parameter <tailval> is the name of a global
+** variable that is set to the unused portion of <sql> (if any). A
+** STMT handle is returned.
+*/
+static int test_prepare16_v2(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3 *db;
+  const void *zSql;
+  const void *zTail = 0;
+  Tcl_Obj *pTail = 0;
+  sqlite3_stmt *pStmt = 0;
+  char zBuf[50]; 
+  int rc;
+  int bytes;                /* The integer specified as arg 3 */
+  int objlen;               /* The byte-array length of arg 2 */
+
+  if( objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSql = Tcl_GetByteArrayFromObj(objv[2], &objlen);
+  if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
+
+  rc = sqlite3_prepare16_v2(db, zSql, bytes, &pStmt, &zTail);
+  if( sqlite3TestErrCode(interp, db, rc) ) return TCL_ERROR;
+  if( rc ){
+    return TCL_ERROR;
+  }
+
+  if( zTail ){
+    objlen = objlen - ((u8 *)zTail-(u8 *)zSql);
+  }else{
+    objlen = 0;
+  }
+  pTail = Tcl_NewByteArrayObj((u8 *)zTail, objlen);
+  Tcl_IncrRefCount(pTail);
+  Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
+  Tcl_DecrRefCount(pTail);
+
+  if( pStmt ){
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, zBuf, 0);
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_open filename ?options-list?
+*/
+static int test_open(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  const char *zFilename;
+  sqlite3 *db;
+  int rc;
+  char zBuf[100];
+
+  if( objc!=3 && objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " filename options-list", 0);
+    return TCL_ERROR;
+  }
+
+  zFilename = Tcl_GetString(objv[1]);
+  rc = sqlite3_open(zFilename, &db);
+  
+  if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_open16 filename options
+*/
+static int test_open16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  const void *zFilename;
+  sqlite3 *db;
+  int rc;
+  char zBuf[100];
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " filename options-list", 0);
+    return TCL_ERROR;
+  }
+
+  zFilename = Tcl_GetByteArrayFromObj(objv[1], 0);
+  rc = sqlite3_open16(zFilename, &db);
+  
+  if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
+  Tcl_AppendResult(interp, zBuf, 0);
+#endif /* SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_complete16 <UTF-16 string>
+**
+** Return 1 if the supplied argument is a complete SQL statement, or zero
+** otherwise.
+*/
+static int test_complete16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#if !defined(SQLITE_OMIT_COMPLETE) && !defined(SQLITE_OMIT_UTF16)
+  char *zBuf;
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "<utf-16 sql>");
+    return TCL_ERROR;
+  }
+
+  zBuf = (char*)Tcl_GetByteArrayFromObj(objv[1], 0);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_complete16(zBuf)));
+#endif /* SQLITE_OMIT_COMPLETE && SQLITE_OMIT_UTF16 */
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_step STMT
+**
+** Advance the statement to the next row.
+*/
+static int test_step(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  rc = sqlite3_step(pStmt);
+
+  /* if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; */
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_count STMT 
+**
+** Return the number of columns returned by the sql statement STMT.
+*/
+static int test_column_count(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_column_count(pStmt)));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_type STMT column
+**
+** Return the type of the data in column 'column' of the current row.
+*/
+static int test_column_type(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+  int tp;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  tp = sqlite3_column_type(pStmt, col);
+  switch( tp ){
+    case SQLITE_INTEGER: 
+      Tcl_SetResult(interp, "INTEGER", TCL_STATIC); 
+      break;
+    case SQLITE_NULL:
+      Tcl_SetResult(interp, "NULL", TCL_STATIC); 
+      break;
+    case SQLITE_FLOAT:
+      Tcl_SetResult(interp, "FLOAT", TCL_STATIC); 
+      break;
+    case SQLITE_TEXT:
+      Tcl_SetResult(interp, "TEXT", TCL_STATIC); 
+      break;
+    case SQLITE_BLOB:
+      Tcl_SetResult(interp, "BLOB", TCL_STATIC); 
+      break;
+    default:
+      assert(0);
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_int64 STMT column
+**
+** Return the data in column 'column' of the current row cast as an
+** wide (64-bit) integer.
+*/
+static int test_column_int64(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+  i64 iVal;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  iVal = sqlite3_column_int64(pStmt, col);
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj(iVal));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_blob STMT column
+*/
+static int test_column_blob(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+
+  int len;
+  const void *pBlob;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  len = sqlite3_column_bytes(pStmt, col);
+  pBlob = sqlite3_column_blob(pStmt, col);
+  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_double STMT column
+**
+** Return the data in column 'column' of the current row cast as a double.
+*/
+static int test_column_double(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+  double rVal;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  rVal = sqlite3_column_double(pStmt, col);
+  Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_data_count STMT 
+**
+** Return the number of columns returned by the sql statement STMT.
+*/
+static int test_data_count(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_data_count(pStmt)));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_text STMT column
+**
+** Usage: sqlite3_column_decltype STMT column
+**
+** Usage: sqlite3_column_name STMT column
+*/
+static int test_stmt_utf8(
+  void * clientData,        /* Pointer to SQLite API function to be invoke */
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+  const char *(*xFunc)(sqlite3_stmt*, int) = clientData;
+  const char *zRet;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+  zRet = xFunc(pStmt, col);
+  if( zRet ){
+    Tcl_SetResult(interp, (char *)zRet, 0);
+  }
+  return TCL_OK;
+}
+
+static int test_global_recover(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_GLOBALRECOVER
+  int rc;
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "");
+    return TCL_ERROR;
+  }
+  rc = sqlite3_global_recover();
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_text STMT column
+**
+** Usage: sqlite3_column_decltype STMT column
+**
+** Usage: sqlite3_column_name STMT column
+*/
+static int test_stmt_utf16(
+  void * clientData,     /* Pointer to SQLite API function to be invoked */
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3_stmt *pStmt;
+  int col;
+  Tcl_Obj *pRet;
+  const void *zName16;
+  const void *(*xFunc)(sqlite3_stmt*, int) = clientData;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  zName16 = xFunc(pStmt, col);
+  if( zName16 ){
+    pRet = Tcl_NewByteArrayObj(zName16, sqlite3Utf16ByteLen(zName16, -1)+2);
+    Tcl_SetObjResult(interp, pRet);
+  }
+#endif /* SQLITE_OMIT_UTF16 */
+
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_column_int STMT column
+**
+** Usage: sqlite3_column_bytes STMT column
+**
+** Usage: sqlite3_column_bytes16 STMT column
+**
+*/
+static int test_stmt_int(
+  void * clientData,    /* Pointer to SQLite API function to be invoked */
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_stmt *pStmt;
+  int col;
+  int (*xFunc)(sqlite3_stmt*, int) = clientData;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " STMT column", 0);
+    return TCL_ERROR;
+  }
+
+  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
+
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(xFunc(pStmt, col)));
+  return TCL_OK;
+}
+
+#ifndef SQLITE_OMIT_DISKIO
+#if 0
+/*
+** Usage:  sqlite3OsOpenReadWrite <filename>
+*/
+static int test_sqlite3OsOpenReadWrite(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_file *pFile;
+  int rc;
+  int dummy;
+  char zBuf[100];
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " filename", 0);
+    return TCL_ERROR;
+  }
+
+  rc = sqlite3OsOpenReadWrite(Tcl_GetString(objv[1]), &pFile, &dummy);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  sqlite3TestMakePointerStr(interp, zBuf, pFile);
+  Tcl_SetResult(interp, zBuf, 0);
+  return TCL_ERROR;
+}
+
+/*
+** Usage:  sqlite3OsClose <file handle>
+*/
+static int test_sqlite3OsClose(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_file *pFile;
+  int rc;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " filehandle", 0);
+    return TCL_ERROR;
+  }
+
+  if( getFilePointer(interp, Tcl_GetString(objv[1]), &pFile) ){
+    return TCL_ERROR;
+  }
+  rc = sqlite3OsClose(&pFile);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3OsLock <file handle> <locktype>
+*/
+static int test_sqlite3OsLock(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_file * pFile;
+  int rc;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+        Tcl_GetString(objv[0]), 
+        " filehandle (SHARED|RESERVED|PENDING|EXCLUSIVE)", 0);
+    return TCL_ERROR;
+  }
+
+  if( getFilePointer(interp, Tcl_GetString(objv[1]), &pFile) ){
+    return TCL_ERROR;
+  }
+
+  if( 0==strcmp("SHARED", Tcl_GetString(objv[2])) ){
+    rc = sqlite3OsLock(pFile, SHARED_LOCK);
+  }
+  else if( 0==strcmp("RESERVED", Tcl_GetString(objv[2])) ){
+    rc = sqlite3OsLock(pFile, RESERVED_LOCK);
+  }
+  else if( 0==strcmp("PENDING", Tcl_GetString(objv[2])) ){
+    rc = sqlite3OsLock(pFile, PENDING_LOCK);
+  }
+  else if( 0==strcmp("EXCLUSIVE", Tcl_GetString(objv[2])) ){
+    rc = sqlite3OsLock(pFile, EXCLUSIVE_LOCK);
+  }else{
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+        Tcl_GetString(objv[0]), 
+        " filehandle (SHARED|RESERVED|PENDING|EXCLUSIVE)", 0);
+    return TCL_ERROR;
+  }
+
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3OsUnlock <file handle>
+*/
+static int test_sqlite3OsUnlock(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_file * pFile;
+  int rc;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", 
+       Tcl_GetString(objv[0]), " filehandle", 0);
+    return TCL_ERROR;
+  }
+
+  if( getFilePointer(interp, Tcl_GetString(objv[1]), &pFile) ){
+    return TCL_ERROR;
+  }
+  rc = sqlite3OsUnlock(pFile, NO_LOCK);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3OsTempFileName
+*/
+static int test_sqlite3OsTempFileName(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  char zFile[SQLITE_TEMPNAME_SIZE];
+  int rc;
+
+  rc = sqlite3OsTempFileName(zFile);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+    return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, zFile, 0);
+  return TCL_OK;
+}
+#endif
+#endif
+
+/*
+** Usage:  sqlite_set_magic  DB  MAGIC-NUMBER
+**
+** Set the db->magic value.  This is used to test error recovery logic.
+*/
+static int sqlite_set_magic(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  sqlite3 *db;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+         " DB MAGIC", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  if( strcmp(argv[2], "SQLITE_MAGIC_OPEN")==0 ){
+    db->magic = SQLITE_MAGIC_OPEN;
+  }else if( strcmp(argv[2], "SQLITE_MAGIC_CLOSED")==0 ){
+    db->magic = SQLITE_MAGIC_CLOSED;
+  }else if( strcmp(argv[2], "SQLITE_MAGIC_BUSY")==0 ){
+    db->magic = SQLITE_MAGIC_BUSY;
+  }else if( strcmp(argv[2], "SQLITE_MAGIC_ERROR")==0 ){
+    db->magic = SQLITE_MAGIC_ERROR;
+  }else if( Tcl_GetInt(interp, argv[2], &db->magic) ){
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_interrupt  DB 
+**
+** Trigger an interrupt on DB
+*/
+static int test_interrupt(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  sqlite3 *db;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  sqlite3_interrupt(db);
+  return TCL_OK;
+}
+
+static u8 *sqlite3_stack_baseline = 0;
+
+/*
+** Fill the stack with a known bitpattern.
+*/
+static void prepStack(void){
+  int i;
+  u32 bigBuf[65536];
+  for(i=0; i<sizeof(bigBuf); i++) bigBuf[i] = 0xdeadbeef;
+  sqlite3_stack_baseline = (u8*)&bigBuf[65536];
+}
+
+/*
+** Get the current stack depth.  Used for debugging only.
+*/
+u64 sqlite3StackDepth(void){
+  u8 x;
+  return (u64)(sqlite3_stack_baseline - &x);
+}
+
+/*
+** Usage:  sqlite3_stack_used DB SQL
+**
+** Try to measure the amount of stack space used by a call to sqlite3_exec
+*/
+static int test_stack_used(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  sqlite3 *db;
+  int i;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+        " DB SQL", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  prepStack();
+  (void)sqlite3_exec(db, argv[2], 0, 0, 0);
+  for(i=65535; i>=0 && ((u32*)sqlite3_stack_baseline)[-i]==0xdeadbeef; i--){}
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(i*4));
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite_delete_function DB function-name
+**
+** Delete the user function 'function-name' from database handle DB. It
+** is assumed that the user function was created as UTF8, any number of
+** arguments (the way the TCL interface does it).
+*/
+static int delete_function(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  int rc;
+  sqlite3 *db;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+        " DB function-name", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_create_function(db, argv[2], -1, SQLITE_UTF8, 0, 0, 0, 0);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite_delete_collation DB collation-name
+**
+** Delete the collation sequence 'collation-name' from database handle 
+** DB. It is assumed that the collation sequence was created as UTF8 (the 
+** way the TCL interface does it).
+*/
+static int delete_collation(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  int rc;
+  sqlite3 *db;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+        " DB function-name", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  rc = sqlite3_create_collation(db, argv[2], SQLITE_UTF8, 0, 0);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_get_autocommit DB
+**
+** Return true if the database DB is currently in auto-commit mode.
+** Return false if not.
+*/
+static int get_autocommit(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  char zBuf[30];
+  sqlite3 *db;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+        " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  sprintf(zBuf, "%d", sqlite3_get_autocommit(db));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: sqlite3_busy_timeout DB MS
+**
+** Set the busy timeout.  This is more easily done using the timeout
+** method of the TCL interface.  But we need a way to test the case
+** where it returns SQLITE_MISUSE.
+*/
+static int test_busy_timeout(
+  void * clientData,
+  Tcl_Interp *interp,
+  int argc,
+  char **argv
+){
+  int rc, ms;
+  sqlite3 *db;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+        " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[2], &ms) ) return TCL_ERROR;
+  rc = sqlite3_busy_timeout(db, ms);
+  Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:  tcl_variable_type VARIABLENAME
+**
+** Return the name of the internal representation for the
+** value of the given variable.
+*/
+static int tcl_variable_type(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Tcl_Obj *pVar;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "VARIABLE");
+    return TCL_ERROR;
+  }
+  pVar = Tcl_GetVar2Ex(interp, Tcl_GetString(objv[1]), 0, TCL_LEAVE_ERR_MSG);
+  if( pVar==0 ) return TCL_ERROR;
+  if( pVar->typePtr ){
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(pVar->typePtr->name, -1));
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_release_memory ?N?
+**
+** Attempt to release memory currently held but not actually required.
+** The integer N is the number of bytes we are trying to release.  The 
+** return value is the amount of memory actually released.
+*/
+static int test_release_memory(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
+  int N;
+  int amt;
+  if( objc!=1 && objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?N?");
+    return TCL_ERROR;
+  }
+  if( objc==2 ){
+    if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
+  }else{
+    N = -1;
+  }
+  amt = sqlite3_release_memory(N);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(amt));
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage:  sqlite3_soft_heap_limit ?N?
+**
+** Query or set the soft heap limit for the current thread.  The
+** limit is only changed if the N is present.  The previous limit
+** is returned.
+*/
+static int test_soft_heap_limit(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  static int softHeapLimit = 0;
+  int amt;
+  if( objc!=1 && objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?N?");
+    return TCL_ERROR;
+  }
+  amt = softHeapLimit;
+  if( objc==2 ){
+    int N;
+    if( Tcl_GetIntFromObj(interp, objv[1], &N) ) return TCL_ERROR;
+    sqlite3_soft_heap_limit(N);
+    softHeapLimit = N;
+  }
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(amt));
+  return TCL_OK;
+}
+
+/*
+** Usage:   sqlite3_thread_cleanup
+**
+** Call the sqlite3_thread_cleanup API.
+*/
+static int test_thread_cleanup(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_thread_cleanup();
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   sqlite3_pager_refcounts  DB
+**
+** Return a list of numbers which are the PagerRefcount for all
+** pagers on each database connection.
+*/
+static int test_pager_refcounts(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  int i;
+  int v, *a;
+  Tcl_Obj *pResult;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  pResult = Tcl_NewObj();
+  for(i=0; i<db->nDb; i++){
+    if( db->aDb[i].pBt==0 ){
+      v = -1;
+    }else{
+      sqlite3_mutex_enter(db->mutex);
+      a = sqlite3PagerStats(sqlite3BtreePager(db->aDb[i].pBt));
+      v = a[0];
+      sqlite3_mutex_leave(db->mutex);
+    }
+    Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(v));
+  }
+  Tcl_SetObjResult(interp, pResult);
+  return TCL_OK;
+}
+
+
+/*
+** tclcmd:   working_64bit_int
+**
+** Some TCL builds (ex: cygwin) do not support 64-bit integers.  This
+** leads to a number of test failures.  The present command checks the
+** TCL build to see whether or not it supports 64-bit integers.  It
+** returns TRUE if it does and FALSE if not.
+**
+** This command is used to warn users that their TCL build is defective
+** and that the errors they are seeing in the test scripts might be
+** a result of their defective TCL rather than problems in SQLite.
+*/
+static int working_64bit_int(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  Tcl_Obj *pTestObj;
+  int working = 0;
+
+  pTestObj = Tcl_NewWideIntObj(1000000*(i64)1234567890);
+  working = strcmp(Tcl_GetString(pTestObj), "1234567890000000")==0;
+  Tcl_DecrRefCount(pTestObj);
+  Tcl_SetObjResult(interp, Tcl_NewBooleanObj(working));
+  return TCL_OK;
+}
+
+
+/*
+** tclcmd:   vfs_unlink_test
+**
+** This TCL command unregisters the primary VFS and then registers
+** it back again.  This is used to test the ability to register a
+** VFS when none are previously registered, and the ability to 
+** unregister the only available VFS.  Ticket #2738
+*/
+static int vfs_unlink_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  int i;
+  sqlite3_vfs *pMain;
+  sqlite3_vfs *apVfs[20];
+  sqlite3_vfs one, two;
+
+  sqlite3_vfs_unregister(0);   /* Unregister of NULL is harmless */
+  one.zName = "__one";
+  two.zName = "__two";
+
+  /* Calling sqlite3_vfs_register with 2nd argument of 0 does not
+  ** change the default VFS
+  */
+  pMain = sqlite3_vfs_find(0);
+  sqlite3_vfs_register(&one, 0);
+  assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
+  sqlite3_vfs_register(&two, 0);
+  assert( pMain==0 || pMain==sqlite3_vfs_find(0) );
+
+  /* We can find a VFS by its name */
+  assert( sqlite3_vfs_find("__one")==&one );
+  assert( sqlite3_vfs_find("__two")==&two );
+
+  /* Calling sqlite_vfs_register with non-zero second parameter changes the
+  ** default VFS, even if the 1st parameter is an existig VFS that is
+  ** previously registered as the non-default.
+  */
+  sqlite3_vfs_register(&one, 1);
+  assert( sqlite3_vfs_find("__one")==&one );
+  assert( sqlite3_vfs_find("__two")==&two );
+  assert( sqlite3_vfs_find(0)==&one );
+  sqlite3_vfs_register(&two, 1);
+  assert( sqlite3_vfs_find("__one")==&one );
+  assert( sqlite3_vfs_find("__two")==&two );
+  assert( sqlite3_vfs_find(0)==&two );
+  if( pMain ){
+    sqlite3_vfs_register(pMain, 1);
+    assert( sqlite3_vfs_find("__one")==&one );
+    assert( sqlite3_vfs_find("__two")==&two );
+    assert( sqlite3_vfs_find(0)==pMain );
+  }
+  
+  /* Unlink the default VFS.  Repeat until there are no more VFSes
+  ** registered.
+  */
+  for(i=0; i<sizeof(apVfs)/sizeof(apVfs[0]); i++){
+    apVfs[i] = sqlite3_vfs_find(0);
+    if( apVfs[i] ){
+      assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
+      sqlite3_vfs_unregister(apVfs[i]);
+      assert( 0==sqlite3_vfs_find(apVfs[i]->zName) );
+    }
+  }
+  assert( 0==sqlite3_vfs_find(0) );
+
+  /* Relink all VFSes in reverse order. */  
+  for(i=sizeof(apVfs)/sizeof(apVfs[0])-1; i>=0; i--){
+    if( apVfs[i] ){
+      sqlite3_vfs_register(apVfs[i], 1);
+      assert( apVfs[i]==sqlite3_vfs_find(0) );
+      assert( apVfs[i]==sqlite3_vfs_find(apVfs[i]->zName) );
+    }
+  }
+
+  /* Unregister out sample VFSes. */
+  sqlite3_vfs_unregister(&one);
+  sqlite3_vfs_unregister(&two);
+
+  /* Unregistering a VFS that is not currently registered is harmless */
+  sqlite3_vfs_unregister(&one);
+  sqlite3_vfs_unregister(&two);
+  assert( sqlite3_vfs_find("__one")==0 );
+  assert( sqlite3_vfs_find("__two")==0 );
+
+  /* We should be left with the original default VFS back as the
+  ** original */
+  assert( sqlite3_vfs_find(0)==pMain );
+
+  return TCL_OK;
+}
+
+/*
+** tclcmd:   file_control_test DB
+**
+** This TCL command runs the sqlite3_file_control interface and
+** verifies correct operation of the same.
+*/
+static int file_control_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  int iArg = 0;
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  rc = sqlite3_file_control(db, 0, 0, &iArg);
+  assert( rc==SQLITE_ERROR );
+  rc = sqlite3_file_control(db, "notadatabase", SQLITE_FCNTL_LOCKSTATE, &iArg);
+  assert( rc==SQLITE_ERROR );
+  rc = sqlite3_file_control(db, "main", -1, &iArg);
+  assert( rc==SQLITE_ERROR );
+  rc = sqlite3_file_control(db, "temp", -1, &iArg);
+  assert( rc==SQLITE_ERROR );
+  return TCL_OK;  
+}
+
+/*
+** tclcmd:  save_prng_state
+*/
+static int save_prng_state(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  extern void sqlite3SavePrngState(void);
+  sqlite3SavePrngState();
+  return TCL_OK;
+}
+/*
+** tclcmd:  restore_prng_state
+*/
+static int restore_prng_state(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  extern void sqlite3RestorePrngState(void);
+  sqlite3RestorePrngState();
+  return TCL_OK;
+}
+/*
+** tclcmd:  reset_prng_state
+*/
+static int reset_prng_state(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  extern void sqlite3ResetPrngState(void);
+  sqlite3ResetPrngState();
+  return TCL_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest1_Init(Tcl_Interp *interp){
+  extern int sqlite3_search_count;
+  extern int sqlite3_interrupt_count;
+  extern int sqlite3_open_file_count;
+  extern int sqlite3_sort_count;
+  extern int sqlite3_current_time;
+  extern int sqlite3_max_blobsize;
+  extern int sqlite3BtreeSharedCacheReport(void*,
+                                          Tcl_Interp*,int,Tcl_Obj*CONST*);
+  static struct {
+     char *zName;
+     Tcl_CmdProc *xProc;
+  } aCmd[] = {
+     { "db_enter",                      (Tcl_CmdProc*)db_enter               },
+     { "db_leave",                      (Tcl_CmdProc*)db_leave               },
+     { "sqlite3_mprintf_int",           (Tcl_CmdProc*)sqlite3_mprintf_int    },
+     { "sqlite3_mprintf_int64",         (Tcl_CmdProc*)sqlite3_mprintf_int64  },
+     { "sqlite3_mprintf_str",           (Tcl_CmdProc*)sqlite3_mprintf_str    },
+     { "sqlite3_snprintf_str",          (Tcl_CmdProc*)sqlite3_snprintf_str   },
+     { "sqlite3_mprintf_stronly",       (Tcl_CmdProc*)sqlite3_mprintf_stronly},
+     { "sqlite3_mprintf_double",        (Tcl_CmdProc*)sqlite3_mprintf_double },
+     { "sqlite3_mprintf_scaled",        (Tcl_CmdProc*)sqlite3_mprintf_scaled },
+     { "sqlite3_mprintf_hexdouble",   (Tcl_CmdProc*)sqlite3_mprintf_hexdouble},
+     { "sqlite3_mprintf_z_test",        (Tcl_CmdProc*)test_mprintf_z        },
+     { "sqlite3_mprintf_n_test",        (Tcl_CmdProc*)test_mprintf_n        },
+     { "sqlite3_snprintf_int",          (Tcl_CmdProc*)test_snprintf_int     },
+     { "sqlite3_last_insert_rowid",     (Tcl_CmdProc*)test_last_rowid       },
+     { "sqlite3_exec_printf",           (Tcl_CmdProc*)test_exec_printf      },
+     { "sqlite3_exec",                  (Tcl_CmdProc*)test_exec             },
+     { "sqlite3_exec_nr",               (Tcl_CmdProc*)test_exec_nr          },
+     { "sqlite3_get_table_printf",      (Tcl_CmdProc*)test_get_table_printf },
+     { "sqlite3_close",                 (Tcl_CmdProc*)sqlite_test_close     },
+     { "sqlite3_create_function",       (Tcl_CmdProc*)test_create_function  },
+     { "sqlite3_create_aggregate",      (Tcl_CmdProc*)test_create_aggregate },
+     { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func    },
+     { "sqlite_abort",                  (Tcl_CmdProc*)sqlite_abort          },
+     { "sqlite_bind",                   (Tcl_CmdProc*)test_bind             },
+     { "breakpoint",                    (Tcl_CmdProc*)test_breakpoint       },
+     { "sqlite3_key",                   (Tcl_CmdProc*)test_key              },
+     { "sqlite3_rekey",                 (Tcl_CmdProc*)test_rekey            },
+     { "sqlite_set_magic",              (Tcl_CmdProc*)sqlite_set_magic      },
+     { "sqlite3_interrupt",             (Tcl_CmdProc*)test_interrupt        },
+     { "sqlite_delete_function",        (Tcl_CmdProc*)delete_function       },
+     { "sqlite_delete_collation",       (Tcl_CmdProc*)delete_collation      },
+     { "sqlite3_get_autocommit",        (Tcl_CmdProc*)get_autocommit        },
+     { "sqlite3_stack_used",            (Tcl_CmdProc*)test_stack_used       },
+     { "sqlite3_busy_timeout",          (Tcl_CmdProc*)test_busy_timeout     },
+     { "printf",                        (Tcl_CmdProc*)test_printf           },
+     { "sqlite3_io_trace",              (Tcl_CmdProc*)test_io_trace         },
+  };
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+     void *clientData;
+  } aObjCmd[] = {
+     { "sqlite3_connection_pointer",    get_sqlite_pointer, 0 },
+     { "sqlite3_bind_int",              test_bind_int,      0 },
+     { "sqlite3_bind_zeroblob",         test_bind_zeroblob, 0 },
+     { "sqlite3_bind_int64",            test_bind_int64,    0 },
+     { "sqlite3_bind_double",           test_bind_double,   0 },
+     { "sqlite3_bind_null",             test_bind_null     ,0 },
+     { "sqlite3_bind_text",             test_bind_text     ,0 },
+     { "sqlite3_bind_text16",           test_bind_text16   ,0 },
+     { "sqlite3_bind_blob",             test_bind_blob     ,0 },
+     { "sqlite3_bind_parameter_count",  test_bind_parameter_count, 0},
+     { "sqlite3_bind_parameter_name",   test_bind_parameter_name,  0},
+     { "sqlite3_bind_parameter_index",  test_bind_parameter_index, 0},
+     { "sqlite3_clear_bindings",        test_clear_bindings, 0},
+     { "sqlite3_sleep",                 test_sleep,          0},
+     { "sqlite3_errcode",               test_errcode       ,0 },
+     { "sqlite3_errmsg",                test_errmsg        ,0 },
+     { "sqlite3_errmsg16",              test_errmsg16      ,0 },
+     { "sqlite3_open",                  test_open          ,0 },
+     { "sqlite3_open16",                test_open16        ,0 },
+     { "sqlite3_complete16",            test_complete16    ,0 },
+
+     { "sqlite3_prepare",               test_prepare       ,0 },
+     { "sqlite3_prepare16",             test_prepare16     ,0 },
+     { "sqlite3_prepare_v2",            test_prepare_v2    ,0 },
+     { "sqlite3_prepare16_v2",          test_prepare16_v2  ,0 },
+     { "sqlite3_finalize",              test_finalize      ,0 },
+     { "sqlite3_reset",                 test_reset         ,0 },
+     { "sqlite3_expired",               test_expired       ,0 },
+     { "sqlite3_transfer_bindings",     test_transfer_bind ,0 },
+     { "sqlite3_changes",               test_changes       ,0 },
+     { "sqlite3_step",                  test_step          ,0 },
+
+     { "sqlite3_release_memory",        test_release_memory,     0},
+     { "sqlite3_soft_heap_limit",       test_soft_heap_limit,    0},
+     { "sqlite3_thread_cleanup",        test_thread_cleanup,     0},
+     { "sqlite3_pager_refcounts",       test_pager_refcounts,    0},
+
+     { "sqlite3_load_extension",        test_load_extension,     0},
+     { "sqlite3_enable_load_extension", test_enable_load,        0},
+     { "sqlite3_extended_result_codes", test_extended_result_codes, 0},
+
+     { "save_prng_state",               save_prng_state,    0 },
+     { "restore_prng_state",            restore_prng_state, 0 },
+     { "reset_prng_state",              reset_prng_state,   0 },
+
+     /* sqlite3_column_*() API */
+     { "sqlite3_column_count",          test_column_count  ,0 },
+     { "sqlite3_data_count",            test_data_count    ,0 },
+     { "sqlite3_column_type",           test_column_type   ,0 },
+     { "sqlite3_column_blob",           test_column_blob   ,0 },
+     { "sqlite3_column_double",         test_column_double ,0 },
+     { "sqlite3_column_int64",          test_column_int64  ,0 },
+     { "sqlite3_column_text",       test_stmt_utf8,  sqlite3_column_text      },
+     { "sqlite3_column_decltype",   test_stmt_utf8,  sqlite3_column_decltype  },
+     { "sqlite3_column_name",       test_stmt_utf8,  sqlite3_column_name      },
+     { "sqlite3_column_int",        test_stmt_int,   sqlite3_column_int       },
+     { "sqlite3_column_bytes",      test_stmt_int,   sqlite3_column_bytes     },
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+{ "sqlite3_column_database_name", test_stmt_utf8, sqlite3_column_database_name},
+{ "sqlite3_column_table_name", test_stmt_utf8, sqlite3_column_table_name},
+{ "sqlite3_column_origin_name", test_stmt_utf8, sqlite3_column_origin_name},
+#endif
+
+#ifndef SQLITE_OMIT_UTF16
+     { "sqlite3_column_bytes16",    test_stmt_int,   sqlite3_column_bytes16   },
+     { "sqlite3_column_text16",     test_stmt_utf16, sqlite3_column_text16    },
+     { "sqlite3_column_decltype16", test_stmt_utf16, sqlite3_column_decltype16},
+     { "sqlite3_column_name16",     test_stmt_utf16, sqlite3_column_name16    },
+     { "add_alignment_test_collations", add_alignment_test_collations, 0      },
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+{"sqlite3_column_database_name16",
+  test_stmt_utf16, sqlite3_column_database_name16},
+{"sqlite3_column_table_name16", test_stmt_utf16, sqlite3_column_table_name16},
+{"sqlite3_column_origin_name16", test_stmt_utf16, sqlite3_column_origin_name16},
+#endif
+#endif
+     { "sqlite3_create_collation_v2", test_create_collation_v2, 0 },
+     { "sqlite3_global_recover",     test_global_recover, 0   },
+     { "working_64bit_int",          working_64bit_int,   0   },
+     { "vfs_unlink_test",            vfs_unlink_test,     0   },
+     { "file_control_test",          file_control_test,   0   },
+
+     /* Functions from os.h */
+#ifndef SQLITE_OMIT_DISKIO
+#if 0
+     { "sqlite3OsOpenReadWrite",test_sqlite3OsOpenReadWrite, 0 },
+     { "sqlite3OsClose",        test_sqlite3OsClose, 0 },
+     { "sqlite3OsLock",         test_sqlite3OsLock, 0 },
+     { "sqlite3OsTempFileName", test_sqlite3OsTempFileName, 0 },
+   
+     /* Custom test interfaces */
+     { "sqlite3OsUnlock",         test_sqlite3OsUnlock, 0    },
+#endif
+#endif
+#ifndef SQLITE_OMIT_UTF16
+     { "add_test_collate",        test_collate, 0            },
+     { "add_test_collate_needed", test_collate_needed, 0     },
+     { "add_test_function",       test_function, 0           },
+#endif
+     { "sqlite3_test_errstr",     test_errstr, 0             },
+     { "tcl_variable_type",       tcl_variable_type, 0       },
+#ifndef SQLITE_OMIT_SHARED_CACHE
+     { "sqlite3_enable_shared_cache", test_enable_shared, 0  },
+     { "sqlite3_shared_cache_report", sqlite3BtreeSharedCacheReport, 0},
+#endif
+     { "sqlite3_libversion_number", test_libversion_number, 0  },
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+     { "sqlite3_table_column_metadata", test_table_column_metadata, 0  },
+#endif
+#ifndef SQLITE_OMIT_INCRBLOB
+     { "sqlite3_blob_read",  test_blob_read, 0  },
+     { "sqlite3_blob_write", test_blob_write, 0  },
+#endif
+  };
+  static int bitmask_size = sizeof(Bitmask)*8;
+  int i;
+  extern int sqlite3_sync_count, sqlite3_fullsync_count;
+  extern int sqlite3_opentemp_count;
+  extern int sqlite3_like_count;
+  extern int sqlite3_xferopt_count;
+  extern int sqlite3_pager_readdb_count;
+  extern int sqlite3_pager_writedb_count;
+  extern int sqlite3_pager_writej_count;
+  extern int sqlite3_pager_pgfree_count;
+#if OS_UNIX && defined(SQLITE_TEST) && SQLITE_THREADSAFE
+  extern int threadsOverrideEachOthersLocks;
+#endif
+#if OS_WIN
+  extern int sqlite3_os_type;
+#endif
+#ifdef SQLITE_DEBUG
+  extern int sqlite3_where_trace;
+  extern int sqlite3_os_trace;
+  extern int sqlite3_vdbe_addop_trace;
+#endif
+#ifdef SQLITE_TEST
+  extern int sqlite3_enable_in_opt;
+  extern char sqlite3_query_plan[];
+  static char *query_plan = sqlite3_query_plan;
+#endif
+
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
+        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
+  }
+  Tcl_LinkVar(interp, "sqlite_search_count", 
+      (char*)&sqlite3_search_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_sort_count", 
+      (char*)&sqlite3_sort_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_max_blobsize", 
+      (char*)&sqlite3_max_blobsize, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_like_count", 
+      (char*)&sqlite3_like_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_interrupt_count", 
+      (char*)&sqlite3_interrupt_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_open_file_count", 
+      (char*)&sqlite3_open_file_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_current_time", 
+      (char*)&sqlite3_current_time, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_xferopt_count",
+      (char*)&sqlite3_xferopt_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_pager_readdb_count",
+      (char*)&sqlite3_pager_readdb_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_pager_writedb_count",
+      (char*)&sqlite3_pager_writedb_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_pager_writej_count",
+      (char*)&sqlite3_pager_writej_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite3_pager_pgfree_count",
+      (char*)&sqlite3_pager_pgfree_count, TCL_LINK_INT);
+#ifndef SQLITE_OMIT_UTF16
+  Tcl_LinkVar(interp, "unaligned_string_counter",
+      (char*)&unaligned_string_counter, TCL_LINK_INT);
+#endif
+#if OS_UNIX && defined(SQLITE_TEST) && SQLITE_THREADSAFE
+  Tcl_LinkVar(interp, "threadsOverrideEachOthersLocks",
+      (char*)&threadsOverrideEachOthersLocks, TCL_LINK_INT);
+#endif
+#ifndef SQLITE_OMIT_UTF16
+  Tcl_LinkVar(interp, "sqlite_last_needed_collation",
+      (char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
+#endif
+#if OS_WIN
+  Tcl_LinkVar(interp, "sqlite_os_type",
+      (char*)&sqlite3_os_type, TCL_LINK_INT);
+#endif
+#ifdef SQLITE_TEST
+  Tcl_LinkVar(interp, "sqlite_query_plan",
+      (char*)&query_plan, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
+#endif
+#ifdef SQLITE_DEBUG
+  Tcl_LinkVar(interp, "sqlite_addop_trace",
+      (char*)&sqlite3_vdbe_addop_trace, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_where_trace",
+      (char*)&sqlite3_where_trace, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_os_trace",
+      (char*)&sqlite3_os_trace, TCL_LINK_INT);
+#endif
+#ifndef SQLITE_OMIT_DISKIO
+  Tcl_LinkVar(interp, "sqlite_opentemp_count",
+      (char*)&sqlite3_opentemp_count, TCL_LINK_INT);
+#endif
+  Tcl_LinkVar(interp, "sqlite_static_bind_value",
+      (char*)&sqlite_static_bind_value, TCL_LINK_STRING);
+  Tcl_LinkVar(interp, "sqlite_static_bind_nbyte",
+      (char*)&sqlite_static_bind_nbyte, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_temp_directory",
+      (char*)&sqlite3_temp_directory, TCL_LINK_STRING);
+  Tcl_LinkVar(interp, "bitmask_size",
+      (char*)&bitmask_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  Tcl_LinkVar(interp, "sqlite_sync_count",
+      (char*)&sqlite3_sync_count, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_fullsync_count",
+      (char*)&sqlite3_fullsync_count, TCL_LINK_INT);
+#ifdef SQLITE_TEST
+  Tcl_LinkVar(interp, "sqlite_enable_in_opt",
+      (char*)&sqlite3_enable_in_opt, TCL_LINK_INT);
+#endif
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test2.c b/client/src/thirdparty/sqlite-3.4.2/src/test2.c
new file mode 100644
index 0000000..9b77ff3
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test2.c
@@ -0,0 +1,619 @@
+/*
+** 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.
+**
+*************************************************************************
+** Code for testing the pager.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test2.c,v 1.52 2007/09/03 15:19:35 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** Interpret an SQLite error number
+*/
+static char *errorName(int rc){
+  char *zName;
+  switch( rc ){
+    case SQLITE_OK:         zName = "SQLITE_OK";          break;
+    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
+    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
+    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
+    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
+    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
+    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
+    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
+    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
+    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
+    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
+    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
+    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
+    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
+    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
+    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
+    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
+    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
+    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
+    default:                zName = "SQLITE_Unknown";     break;
+  }
+  return zName;
+}
+
+/*
+** Page size and reserved size used for testing.
+*/
+static int test_pagesize = 1024;
+
+/*
+** Usage:   pager_open FILENAME N-PAGE
+**
+** Open a new pager
+*/
+static int pager_open(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  u16 pageSize;
+  Pager *pPager;
+  int nPage;
+  int rc;
+  char zBuf[100];
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME N-PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
+  rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
+      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3PagerSetCachesize(pPager, nPage);
+  pageSize = test_pagesize;
+  sqlite3PagerSetPagesize(pPager, &pageSize);
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_close ID
+**
+** Close the given pager.
+*/
+static int pager_close(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerClose(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_rollback ID
+**
+** Rollback changes
+*/
+static int pager_rollback(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerRollback(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_commit ID
+**
+** Commit all changes
+*/
+static int pager_commit(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  rc = sqlite3PagerCommitPhaseTwo(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_begin ID
+**
+** Start a new checkpoint.
+*/
+static int pager_stmt_begin(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerStmtBegin(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_rollback ID
+**
+** Rollback changes to a checkpoint
+*/
+static int pager_stmt_rollback(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerStmtRollback(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_commit ID
+**
+** Commit changes to a checkpoint
+*/
+static int pager_stmt_commit(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerStmtCommit(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stats ID
+**
+** Return pager statistics.
+*/
+static int pager_stats(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int i, *a;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  a = sqlite3PagerStats(pPager);
+  for(i=0; i<9; i++){
+    static char *zName[] = {
+      "ref", "page", "max", "size", "state", "err",
+      "hit", "miss", "ovfl",
+    };
+    char zBuf[100];
+    Tcl_AppendElement(interp, zName[i]);
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",a[i]);
+    Tcl_AppendElement(interp, zBuf);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_pagecount ID
+**
+** Return the size of the database file.
+*/
+static int pager_pagecount(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",sqlite3PagerPagecount(pPager));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_get ID PGNO
+**
+** Return a pointer to a page from the database.
+*/
+static int page_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  DbPage *pPage;
+  int pgno;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  rc = sqlite3PagerGet(pPager, pgno, &pPage);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_lookup ID PGNO
+**
+** Return a pointer to a page if the page is already in cache.
+** If not in cache, return an empty string.
+*/
+static int page_lookup(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  DbPage *pPage;
+  int pgno;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  pPage = sqlite3PagerLookup(pPager, pgno);
+  if( pPage ){
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
+    Tcl_AppendResult(interp, zBuf, 0);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_truncate ID PGNO
+*/
+static int pager_truncate(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  int pgno;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  rc = sqlite3PagerTruncate(pPager, pgno);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   page_unref PAGE
+**
+** Drop a pointer to a page.
+*/
+static int page_unref(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  DbPage *pPage;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerUnref(pPage);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_read PAGE
+**
+** Return the content of a page
+*/
+static int page_read(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  char zBuf[100];
+  DbPage *pPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = sqlite3TextToPtr(argv[1]);
+  memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_number PAGE
+**
+** Return the page number for a page.
+*/
+static int page_number(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  char zBuf[100];
+  DbPage *pPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TextToPtr(argv[1]);
+  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_write PAGE DATA
+**
+** Write something into a page.
+*/
+static int page_write(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  DbPage *pPage;
+  char *pData;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE DATA\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TextToPtr(argv[1]);
+  rc = sqlite3PagerWrite(pPage);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  pData = sqlite3PagerGetData(pPage);
+  strncpy(pData, argv[2], test_pagesize-1);
+  pData[test_pagesize-1] = 0;
+  return TCL_OK;
+}
+
+#ifndef SQLITE_OMIT_DISKIO
+/*
+** Usage:   fake_big_file  N  FILENAME
+**
+** Write a few bytes at the N megabyte point of FILENAME.  This will
+** create a large file.  If the file was a valid SQLite database, then
+** the next time the database is opened, SQLite will begin allocating
+** new pages after N.  If N is 2096 or bigger, this will test the
+** ability of SQLite to write to large files.
+*/
+static int fake_big_file(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  sqlite3_vfs *pVfs;
+  sqlite3_file *fd = 0;
+  int rc;
+  int n;
+  i64 offset;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " N-MEGABYTES FILE\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
+
+  pVfs = sqlite3_vfs_find(0);
+  rc = sqlite3OsOpenMalloc(pVfs, argv[2], &fd, 
+      (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
+  );
+  if( rc ){
+    Tcl_AppendResult(interp, "open failed: ", errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  offset = n;
+  offset *= 1024*1024;
+  rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
+  sqlite3OsCloseFree(fd);
+  if( rc ){
+    Tcl_AppendResult(interp, "write failed: ", errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+#endif
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest2_Init(Tcl_Interp *interp){
+  extern int sqlite3_io_error_persist;
+  extern int sqlite3_io_error_pending;
+  extern int sqlite3_io_error_hit;
+  extern int sqlite3_diskfull_pending;
+  extern int sqlite3_diskfull;
+  extern int sqlite3_pager_n_sort_bucket;
+  static struct {
+    char *zName;
+    Tcl_CmdProc *xProc;
+  } aCmd[] = {
+    { "pager_open",              (Tcl_CmdProc*)pager_open          },
+    { "pager_close",             (Tcl_CmdProc*)pager_close         },
+    { "pager_commit",            (Tcl_CmdProc*)pager_commit        },
+    { "pager_rollback",          (Tcl_CmdProc*)pager_rollback      },
+    { "pager_stmt_begin",        (Tcl_CmdProc*)pager_stmt_begin    },
+    { "pager_stmt_commit",       (Tcl_CmdProc*)pager_stmt_commit   },
+    { "pager_stmt_rollback",     (Tcl_CmdProc*)pager_stmt_rollback },
+    { "pager_stats",             (Tcl_CmdProc*)pager_stats         },
+    { "pager_pagecount",         (Tcl_CmdProc*)pager_pagecount     },
+    { "page_get",                (Tcl_CmdProc*)page_get            },
+    { "page_lookup",             (Tcl_CmdProc*)page_lookup         },
+    { "page_unref",              (Tcl_CmdProc*)page_unref          },
+    { "page_read",               (Tcl_CmdProc*)page_read           },
+    { "page_write",              (Tcl_CmdProc*)page_write          },
+    { "page_number",             (Tcl_CmdProc*)page_number         },
+    { "pager_truncate",          (Tcl_CmdProc*)pager_truncate      },
+#ifndef SQLITE_OMIT_DISKIO
+    { "fake_big_file",           (Tcl_CmdProc*)fake_big_file       },
+#endif
+  };
+  int i;
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  Tcl_LinkVar(interp, "sqlite_io_error_pending",
+     (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_io_error_persist",
+     (char*)&sqlite3_io_error_persist, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_io_error_hit",
+     (char*)&sqlite3_io_error_hit, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_diskfull_pending",
+     (char*)&sqlite3_diskfull_pending, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_diskfull",
+     (char*)&sqlite3_diskfull, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_pending_byte",
+     (char*)&sqlite3_pending_byte, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "pager_pagesize",
+     (char*)&test_pagesize, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_pager_n_sort_bucket",
+     (char*)&sqlite3_pager_n_sort_bucket, TCL_LINK_INT);
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test3.c b/client/src/thirdparty/sqlite-3.4.2/src/test3.c
new file mode 100644
index 0000000..c7121d1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test3.c
@@ -0,0 +1,1668 @@
+/*
+** 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.
+**
+*************************************************************************
+** Code for testing the btree.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test3.c,v 1.90 2008/02/02 20:47:38 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "btreeInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** Interpret an SQLite error number
+*/
+static char *errorName(int rc){
+  char *zName;
+  switch( rc ){
+    case SQLITE_OK:         zName = "SQLITE_OK";          break;
+    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
+    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
+    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
+    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
+    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
+    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
+    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
+    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
+    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
+    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
+    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
+    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
+    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
+    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
+    default:                zName = "SQLITE_Unknown";     break;
+  }
+  return zName;
+}
+
+/*
+** A bogus sqlite3 connection structure for use in the btree
+** tests.
+*/
+static sqlite3 sDb;
+static int nRefSqlite3 = 0;
+
+/*
+** Usage:   btree_open FILENAME NCACHE FLAGS
+**
+** Open a new database
+*/
+static int btree_open(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc, nCache, flags;
+  char zBuf[100];
+  if( argc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME NCACHE FLAGS\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[3], &flags) ) return TCL_ERROR;
+  nRefSqlite3++;
+  if( nRefSqlite3==1 ){
+    sDb.pVfs = sqlite3_vfs_find(0);
+    sDb.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
+    sqlite3_mutex_enter(sDb.mutex);
+  }
+  rc = sqlite3BtreeOpen(argv[1], &sDb, &pBt, flags,
+     SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3BtreeSetCacheSize(pBt, nCache);
+  sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pBt);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_close ID
+**
+** Close the given database.
+*/
+static int btree_close(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  rc = sqlite3BtreeClose(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  nRefSqlite3--;
+  if( nRefSqlite3==0 ){
+    sqlite3_mutex_leave(sDb.mutex);
+    sqlite3_mutex_free(sDb.mutex);
+    sDb.mutex = 0;
+    sDb.pVfs = 0;
+  }
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   btree_begin_transaction ID
+**
+** Start a new transaction
+*/
+static int btree_begin_transaction(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeBeginTrans(pBt, 1);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_rollback ID
+**
+** Rollback changes
+*/
+static int btree_rollback(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeRollback(pBt);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_commit ID
+**
+** Commit all changes
+*/
+static int btree_commit(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeCommit(pBt);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_begin_statement ID
+**
+** Start a new statement transaction
+*/
+static int btree_begin_statement(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeBeginStmt(pBt);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_rollback_statement ID
+**
+** Rollback changes
+*/
+static int btree_rollback_statement(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeRollbackStmt(pBt);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_commit_statement ID
+**
+** Commit all changes
+*/
+static int btree_commit_statement(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeCommitStmt(pBt);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_create_table ID FLAGS
+**
+** Create a new table in the database
+*/
+static int btree_create_table(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc, iTable, flags;
+  char zBuf[30];
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID FLAGS\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &flags) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeCreateTable(pBt, &iTable, flags);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", iTable);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_drop_table ID TABLENUM
+**
+** Delete an entire table from the database
+*/
+static int btree_drop_table(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int iTable;
+  int rc;
+  int notUsed1;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID TABLENUM\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeDropTable(pBt, iTable, &notUsed1);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_clear_table ID TABLENUM
+**
+** Remove all entries from the given table but keep the table around.
+*/
+static int btree_clear_table(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int iTable;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID TABLENUM\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeClearTable(pBt, iTable);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_get_meta ID
+**
+** Return meta data
+*/
+static int btree_get_meta(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  for(i=0; i<SQLITE_N_BTREE_META; i++){
+    char zBuf[30];
+    unsigned int v;
+    sqlite3BtreeEnter(pBt);
+    rc = sqlite3BtreeGetMeta(pBt, i, &v);
+    sqlite3BtreeLeave(pBt);
+    if( rc!=SQLITE_OK ){
+      Tcl_AppendResult(interp, errorName(rc), 0);
+      return TCL_ERROR;
+    }
+    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",v);
+    Tcl_AppendElement(interp, zBuf);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_update_meta ID METADATA...
+**
+** Return meta data
+*/
+static int btree_update_meta(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int rc;
+  int i;
+  int aMeta[SQLITE_N_BTREE_META];
+
+  if( argc!=2+SQLITE_N_BTREE_META ){
+    char zBuf[30];
+    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",SQLITE_N_BTREE_META);
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID METADATA...\" (METADATA is ", zBuf, " integers)", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  for(i=1; i<SQLITE_N_BTREE_META; i++){
+    if( Tcl_GetInt(interp, argv[i+2], &aMeta[i]) ) return TCL_ERROR;
+  }
+  for(i=1; i<SQLITE_N_BTREE_META; i++){
+    sqlite3BtreeEnter(pBt);
+    rc = sqlite3BtreeUpdateMeta(pBt, i, aMeta[i]);
+    sqlite3BtreeLeave(pBt);
+    if( rc!=SQLITE_OK ){
+      Tcl_AppendResult(interp, errorName(rc), 0);
+      return TCL_ERROR;
+    }
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_page_dump ID PAGENUM
+**
+** Print a disassembly of a page on standard output
+*/
+static int btree_page_dump(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int iPage;
+  int rc;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &iPage) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreePageDump(pBt, iPage, 0);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_tree_dump ID PAGENUM
+**
+** Print a disassembly of a page and all its child pages on standard output
+*/
+static int btree_tree_dump(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int iPage;
+  int rc;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &iPage) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreePageDump(pBt, iPage, 1);
+  sqlite3BtreeLeave(pBt);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_pager_stats ID
+**
+** Returns pager statistics
+*/
+static int btree_pager_stats(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int i;
+  int *a;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+ 
+  /* Normally in this file, with a b-tree handle opened using the 
+  ** [btree_open] command it is safe to call sqlite3BtreeEnter() directly.
+  ** But this function is sometimes called with a btree handle obtained
+  ** from an open SQLite connection (using [btree_from_db]). In this case
+  ** we need to obtain the mutex for the controlling SQLite handle before
+  ** it is safe to call sqlite3BtreeEnter().
+  */
+  sqlite3_mutex_enter(pBt->db->mutex);
+
+  sqlite3BtreeEnter(pBt);
+  a = sqlite3PagerStats(sqlite3BtreePager(pBt));
+  for(i=0; i<11; i++){
+    static char *zName[] = {
+      "ref", "page", "max", "size", "state", "err",
+      "hit", "miss", "ovfl", "read", "write"
+    };
+    char zBuf[100];
+    Tcl_AppendElement(interp, zName[i]);
+    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",a[i]);
+    Tcl_AppendElement(interp, zBuf);
+  }
+  sqlite3BtreeLeave(pBt);
+
+  /* Release the mutex on the SQLite handle that controls this b-tree */
+  sqlite3_mutex_leave(pBt->db->mutex);
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_pager_ref_dump ID
+**
+** Print out all outstanding pages.
+*/
+static int btree_pager_ref_dump(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+#ifdef SQLITE_TEST
+  sqlite3BtreeEnter(pBt);
+  sqlite3PagerRefdump(sqlite3BtreePager(pBt));
+  sqlite3BtreeLeave(pBt);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_integrity_check ID ROOT ...
+**
+** Look through every page of the given BTree file to verify correct
+** formatting and linkage.  Return a line of text for each problem found.
+** Return an empty string if everything worked.
+*/
+static int btree_integrity_check(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int nRoot;
+  int *aRoot;
+  int i;
+  int nErr;
+  char *zResult;
+
+  if( argc<3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID ROOT ...\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  nRoot = argc-2;
+  aRoot = (int*)sqlite3_malloc( sizeof(int)*(argc-2) );
+  for(i=0; i<argc-2; i++){
+    if( Tcl_GetInt(interp, argv[i+2], &aRoot[i]) ) return TCL_ERROR;
+  }
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+  sqlite3BtreeEnter(pBt);
+  zResult = sqlite3BtreeIntegrityCheck(pBt, aRoot, nRoot, 10000, &nErr);
+  sqlite3BtreeLeave(pBt);
+#else
+  zResult = 0;
+#endif
+  sqlite3_free((void*)aRoot);
+  if( zResult ){
+    Tcl_AppendResult(interp, zResult, 0);
+    sqlite3_free(zResult); 
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_cursor_list ID
+**
+** Print information about all cursors to standard output for debugging.
+*/
+static int btree_cursor_list(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pBt);
+  sqlite3BtreeCursorList(pBt);
+  sqlite3BtreeLeave(pBt);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_cursor ID TABLENUM WRITEABLE
+**
+** Create a new cursor.  Return the ID for the cursor.
+*/
+static int btree_cursor(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  int iTable;
+  BtCursor *pCur;
+  int rc;
+  int wrFlag;
+  char zBuf[30];
+
+  if( argc!=4 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID TABLENUM WRITEABLE\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
+  if( Tcl_GetBoolean(interp, argv[3], &wrFlag) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeCursor(pBt, iTable, wrFlag, 0, 0, &pCur);
+  sqlite3BtreeLeave(pBt);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pCur);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_close_cursor ID
+**
+** Close a cursor opened using btree_cursor.
+*/
+static int btree_close_cursor(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  Btree *pBt;
+  int rc;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  pBt = pCur->pBtree;
+  sqlite3BtreeEnter(pBt);
+  rc = sqlite3BtreeCloseCursor(pCur);
+  sqlite3BtreeLeave(pBt);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_move_to ID KEY
+**
+** Move the cursor to the entry with the given key.
+*/
+static int btree_move_to(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int res;
+  char zBuf[20];
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID KEY\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
+    int iKey;
+    if( Tcl_GetInt(interp, argv[2], &iKey) ){
+      sqlite3BtreeLeave(pCur->pBtree);
+      return TCL_ERROR;
+    }
+    rc = sqlite3BtreeMoveto(pCur, 0, iKey, 0, &res);
+  }else{
+    rc = sqlite3BtreeMoveto(pCur, argv[2], strlen(argv[2]), 0, &res);  
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  if( res<0 ) res = -1;
+  if( res>0 ) res = 1;
+  sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",res);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_delete ID
+**
+** Delete the entry that the cursor is pointing to
+*/
+static int btree_delete(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeDelete(pCur);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_insert ID KEY DATA ?NZERO?
+**
+** Create a new entry with the given key and data.  If an entry already
+** exists with the same key the old entry is overwritten.
+*/
+static int btree_insert(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  BtCursor *pCur;
+  int rc;
+  int nZero;
+
+  if( objc!=4 && objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "ID KEY DATA ?NZERO?");
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(Tcl_GetString(objv[1]));
+  if( objc==5 ){
+    if( Tcl_GetIntFromObj(interp, objv[4], &nZero) ) return TCL_ERROR;
+  }else{
+    nZero = 0;
+  }
+  sqlite3BtreeEnter(pCur->pBtree);
+  if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
+    i64 iKey;
+    int len;
+    unsigned char *pBuf;
+    if( Tcl_GetWideIntFromObj(interp, objv[2], &iKey) ){
+      sqlite3BtreeLeave(pCur->pBtree);
+      return TCL_ERROR;
+    }
+    pBuf = Tcl_GetByteArrayFromObj(objv[3], &len);
+    rc = sqlite3BtreeInsert(pCur, 0, iKey, pBuf, len, nZero, 0);
+  }else{
+    int keylen;
+    int dlen;
+    unsigned char *pKBuf;
+    unsigned char *pDBuf;
+    pKBuf = Tcl_GetByteArrayFromObj(objv[2], &keylen);
+    pDBuf = Tcl_GetByteArrayFromObj(objv[3], &dlen);
+    rc = sqlite3BtreeInsert(pCur, pKBuf, keylen, pDBuf, dlen, nZero, 0);
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_next ID
+**
+** Move the cursor to the next entry in the table.  Return 0 on success
+** or 1 if the cursor was already on the last entry in the table or if
+** the table is empty.
+*/
+static int btree_next(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int res = 0;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeNext(pCur, &res);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_prev ID
+**
+** Move the cursor to the previous entry in the table.  Return 0 on
+** success and 1 if the cursor was already on the first entry in
+** the table or if the table was empty.
+*/
+static int btree_prev(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int res = 0;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreePrevious(pCur, &res);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_first ID
+**
+** Move the cursor to the first entry in the table.  Return 0 if the
+** cursor was left point to something and 1 if the table is empty.
+*/
+static int btree_first(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int res = 0;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeFirst(pCur, &res);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_last ID
+**
+** Move the cursor to the last entry in the table.  Return 0 if the
+** cursor was left point to something and 1 if the table is empty.
+*/
+static int btree_last(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int res = 0;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeLast(pCur, &res);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_eof ID
+**
+** Return TRUE if the given cursor is not pointing at a valid entry.
+** Return FALSE if the cursor does point to a valid entry.
+*/
+static int btree_eof(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  char zBuf[50];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeEof(pCur);
+  sqlite3BtreeLeave(pCur->pBtree);
+  sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", rc);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_keysize ID
+**
+** Return the number of bytes of key.  For an INTKEY table, this
+** returns the key itself.
+*/
+static int btree_keysize(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  u64 n;
+  char zBuf[50];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  sqlite3BtreeKeySize(pCur, (i64*)&n);
+  sqlite3BtreeLeave(pCur->pBtree);
+  sqlite3_snprintf(sizeof(zBuf),zBuf, "%llu", n);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_key ID
+**
+** Return the key for the entry at which the cursor is pointing.
+*/
+static int btree_key(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  u64 n;
+  char *zBuf;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  sqlite3BtreeKeySize(pCur, (i64*)&n);
+  if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
+    char zBuf2[60];
+    sqlite3_snprintf(sizeof(zBuf2),zBuf2, "%llu", n);
+    Tcl_AppendResult(interp, zBuf2, 0);
+  }else{
+    zBuf = sqlite3_malloc( n+1 );
+    rc = sqlite3BtreeKey(pCur, 0, n, zBuf);
+    if( rc ){
+      sqlite3BtreeLeave(pCur->pBtree);
+      Tcl_AppendResult(interp, errorName(rc), 0);
+      return TCL_ERROR;
+    }
+    zBuf[n] = 0;
+    Tcl_AppendResult(interp, zBuf, 0);
+    sqlite3_free(zBuf);
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_data ID ?N?
+**
+** Return the data for the entry at which the cursor is pointing.
+*/
+static int btree_data(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  u32 n;
+  char *zBuf;
+
+  if( argc!=2 && argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  if( argc==2 ){
+    sqlite3BtreeDataSize(pCur, &n);
+  }else{
+    n = atoi(argv[2]);
+  }
+  zBuf = sqlite3_malloc( n+1 );
+  rc = sqlite3BtreeData(pCur, 0, n, zBuf);
+  sqlite3BtreeLeave(pCur->pBtree);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    sqlite3_free(zBuf);
+    return TCL_ERROR;
+  }
+  zBuf[n] = 0;
+  Tcl_AppendResult(interp, zBuf, 0);
+  sqlite3_free(zBuf);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_fetch_key ID AMT
+**
+** Use the sqlite3BtreeKeyFetch() routine to get AMT bytes of the key.
+** If sqlite3BtreeKeyFetch() fails, return an empty string.
+*/
+static int btree_fetch_key(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int n;
+  int amt;
+  u64 nKey;
+  const char *zBuf;
+  char zStatic[1000];
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID AMT\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pCur->pBtree);
+  sqlite3BtreeKeySize(pCur, (i64*)&nKey);
+  zBuf = sqlite3BtreeKeyFetch(pCur, &amt);
+  if( zBuf && amt>=n ){
+    assert( nKey<sizeof(zStatic) );
+    if( n>0 ) nKey = n;
+    memcpy(zStatic, zBuf, (int)nKey); 
+    zStatic[nKey] = 0;
+    Tcl_AppendResult(interp, zStatic, 0);
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_fetch_data ID AMT
+**
+** Use the sqlite3BtreeDataFetch() routine to get AMT bytes of the key.
+** If sqlite3BtreeDataFetch() fails, return an empty string.
+*/
+static int btree_fetch_data(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int n;
+  int amt;
+  u32 nData;
+  const char *zBuf;
+  char zStatic[1000];
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID AMT\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  sqlite3BtreeEnter(pCur->pBtree);
+  sqlite3BtreeDataSize(pCur, &nData);
+  zBuf = sqlite3BtreeDataFetch(pCur, &amt);
+  if( zBuf && amt>=n ){
+    assert( nData<sizeof(zStatic) );
+    if( n>0 ) nData = n;
+    memcpy(zStatic, zBuf, (int)nData); 
+    zStatic[nData] = 0;
+    Tcl_AppendResult(interp, zStatic, 0);
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  return TCL_OK;
+}
+
+/*
+** Usage:   btree_payload_size ID
+**
+** Return the number of bytes of payload
+*/
+static int btree_payload_size(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int n2;
+  u64 n1;
+  char zBuf[50];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  sqlite3BtreeEnter(pCur->pBtree);
+  if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
+    n1 = 0;
+  }else{
+    sqlite3BtreeKeySize(pCur, (i64*)&n1);
+  }
+  sqlite3BtreeDataSize(pCur, (u32*)&n2);
+  sqlite3BtreeLeave(pCur->pBtree);
+  sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", (int)(n1+n2));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Usage:   btree_cursor_info ID ?UP-CNT?
+**
+** Return integers containing information about the entry the
+** cursor is pointing to:
+**
+**   aResult[0] =  The page number
+**   aResult[1] =  The entry number
+**   aResult[2] =  Total number of entries on this page
+**   aResult[3] =  Cell size (local payload + header)
+**   aResult[4] =  Number of free bytes on this page
+**   aResult[5] =  Number of free blocks on the page
+**   aResult[6] =  Total payload size (local + overflow)
+**   aResult[7] =  Header size in bytes
+**   aResult[8] =  Local payload size
+**   aResult[9] =  Parent page number
+**   aResult[10]=  Page number of the first overflow page
+*/
+static int btree_cursor_info(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  BtCursor *pCur;
+  int rc;
+  int i, j;
+  int up;
+  int aResult[11];
+  char zBuf[400];
+
+  if( argc!=2 && argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID ?UP-CNT?\"", 0);
+    return TCL_ERROR;
+  }
+  pCur = sqlite3TextToPtr(argv[1]);
+  if( argc==3 ){
+    if( Tcl_GetInt(interp, argv[2], &up) ) return TCL_ERROR;
+  }else{
+    up = 0;
+  }
+  sqlite3BtreeEnter(pCur->pBtree);
+  rc = sqlite3BtreeCursorInfo(pCur, aResult, up);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    sqlite3BtreeLeave(pCur->pBtree);
+    return TCL_ERROR;
+  }
+  j = 0;
+  for(i=0; i<sizeof(aResult)/sizeof(aResult[0]); i++){
+    sqlite3_snprintf(40,&zBuf[j]," %d", aResult[i]);
+    j += strlen(&zBuf[j]);
+  }
+  sqlite3BtreeLeave(pCur->pBtree);
+  Tcl_AppendResult(interp, &zBuf[1], 0);
+  return SQLITE_OK;
+}
+
+/*
+** Copied from btree.c:
+*/
+static u32 t4Get4byte(unsigned char *p){
+  return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+
+/*
+**   btree_ovfl_info  BTREE  CURSOR
+**
+** Given a cursor, return the sequence of pages number that form the
+** overflow pages for the data of the entry that the cursor is point
+** to.
+*/ 
+static int btree_ovfl_info(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Btree *pBt;
+  BtCursor *pCur;
+  Pager *pPager;
+  int rc;
+  int n;
+  int dataSize;
+  u32 pgno;
+  void *pPage;
+  int aResult[11];
+  char zElem[100];
+  Tcl_DString str;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 
+                    " BTREE CURSOR", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  pCur = sqlite3TextToPtr(argv[2]);
+  if( (*(void**)pCur) != (void*)pBt ){
+    Tcl_AppendResult(interp, "Cursor ", argv[2], " does not belong to btree ",
+       argv[1], 0);
+    return TCL_ERROR;
+  }
+  sqlite3BtreeEnter(pBt);
+  pPager = sqlite3BtreePager(pBt);
+  rc = sqlite3BtreeCursorInfo(pCur, aResult, 0);
+  if( rc ){
+    Tcl_AppendResult(interp, errorName(rc), 0);
+    sqlite3BtreeLeave(pBt);
+    return TCL_ERROR;
+  }
+  dataSize = pBt->pBt->usableSize;
+  Tcl_DStringInit(&str);
+  n = aResult[6] - aResult[8];
+  n = (n + dataSize - 1)/dataSize;
+  pgno = (u32)aResult[10];
+  while( pgno && n-- ){
+    DbPage *pDbPage;
+    sprintf(zElem, "%d", pgno);
+    Tcl_DStringAppendElement(&str, zElem);
+    if( sqlite3PagerGet(pPager, pgno, &pDbPage)!=SQLITE_OK ){
+      Tcl_DStringFree(&str);
+      Tcl_AppendResult(interp, "unable to get page ", zElem, 0);
+      sqlite3BtreeLeave(pBt);
+      return TCL_ERROR;
+    }
+    pPage = sqlite3PagerGetData(pDbPage);
+    pgno = t4Get4byte((unsigned char*)pPage);
+    sqlite3PagerUnref(pDbPage);
+  }
+  sqlite3BtreeLeave(pBt);
+  Tcl_DStringResult(interp, &str);
+  return SQLITE_OK;
+}
+
+/*
+** The command is provided for the purpose of setting breakpoints.
+** in regression test scripts.
+**
+** By setting a GDB breakpoint on this procedure and executing the
+** btree_breakpoint command in a test script, we can stop GDB at
+** the point in the script where the btree_breakpoint command is
+** inserted.  This is useful for debugging.
+*/
+static int btree_breakpoint(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  return TCL_OK;
+}
+
+/*
+** usage:   varint_test  START  MULTIPLIER  COUNT  INCREMENT
+**
+** This command tests the sqlite3PutVarint() and sqlite3GetVarint()
+** routines, both for accuracy and for speed.
+**
+** An integer is written using PutVarint() and read back with
+** GetVarint() and varified to be unchanged.  This repeats COUNT
+** times.  The first integer is START*MULTIPLIER.  Each iteration
+** increases the integer by INCREMENT.
+**
+** This command returns nothing if it works.  It returns an error message
+** if something goes wrong.
+*/
+static int btree_varint_test(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  u32 start, mult, count, incr;
+  u64 in, out;
+  int n1, n2, i, j;
+  unsigned char zBuf[100];
+  if( argc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " START MULTIPLIER COUNT INCREMENT\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[1], (int*)&start) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[2], (int*)&mult) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[3], (int*)&count) ) return TCL_ERROR;
+  if( Tcl_GetInt(interp, argv[4], (int*)&incr) ) return TCL_ERROR;
+  in = start;
+  in *= mult;
+  for(i=0; i<count; i++){
+    char zErr[200];
+    n1 = sqlite3PutVarint(zBuf, in);
+    if( n1>9 || n1<1 ){
+      sprintf(zErr, "PutVarint returned %d - should be between 1 and 9", n1);
+      Tcl_AppendResult(interp, zErr, 0);
+      return TCL_ERROR;
+    }
+    n2 = sqlite3GetVarint(zBuf, &out);
+    if( n1!=n2 ){
+      sprintf(zErr, "PutVarint returned %d and GetVarint returned %d", n1, n2);
+      Tcl_AppendResult(interp, zErr, 0);
+      return TCL_ERROR;
+    }
+    if( in!=out ){
+      sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx", in, out);
+      Tcl_AppendResult(interp, zErr, 0);
+      return TCL_ERROR;
+    }
+    if( (in & 0xffffffff)==in ){
+      u32 out32;
+      n2 = sqlite3GetVarint32(zBuf, &out32);
+      out = out32;
+      if( n1!=n2 ){
+        sprintf(zErr, "PutVarint returned %d and GetVarint32 returned %d", 
+                  n1, n2);
+        Tcl_AppendResult(interp, zErr, 0);
+        return TCL_ERROR;
+      }
+      if( in!=out ){
+        sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx from GetVarint32",
+            in, out);
+        Tcl_AppendResult(interp, zErr, 0);
+        return TCL_ERROR;
+      }
+    }
+
+    /* In order to get realistic timings, run getVarint 19 more times.
+    ** This is because getVarint is called about 20 times more often
+    ** than putVarint.
+    */
+    for(j=0; j<19; j++){
+      sqlite3GetVarint(zBuf, &out);
+    }
+    in += incr;
+  }
+  return TCL_OK;
+}
+
+/*
+** usage:   btree_from_db  DB-HANDLE
+**
+** This command returns the btree handle for the main database associated
+** with the database-handle passed as the argument. Example usage:
+**
+** sqlite3 db test.db
+** set bt [btree_from_db db]
+*/
+static int btree_from_db(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  char zBuf[100];
+  Tcl_CmdInfo info;
+  sqlite3 *db;
+  Btree *pBt;
+  int iDb = 0;
+
+  if( argc!=2 && argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " DB-HANDLE ?N?\"", 0);
+    return TCL_ERROR;
+  }
+
+  if( 1!=Tcl_GetCommandInfo(interp, argv[1], &info) ){
+    Tcl_AppendResult(interp, "No such db-handle: \"", argv[1], "\"", 0);
+    return TCL_ERROR;
+  }
+  if( argc==3 ){
+    iDb = atoi(argv[2]);
+  }
+
+  db = *((sqlite3 **)info.objClientData);
+  assert( db );
+
+  pBt = db->aDb[iDb].pBt;
+  sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", pBt);
+  Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
+  return TCL_OK;
+}
+
+
+/*
+** usage:   btree_set_cache_size ID NCACHE
+**
+** Set the size of the cache used by btree $ID.
+*/
+static int btree_set_cache_size(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int nCache;
+  Btree *pBt;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " BT NCACHE\"", 0);
+    return TCL_ERROR;
+  }
+  pBt = sqlite3TextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
+
+  sqlite3_mutex_enter(pBt->db->mutex);
+  sqlite3BtreeEnter(pBt);
+  sqlite3BtreeSetCacheSize(pBt, nCache);
+  sqlite3BtreeLeave(pBt);
+  sqlite3_mutex_leave(pBt->db->mutex);
+
+  return TCL_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest3_Init(Tcl_Interp *interp){
+  extern int sqlite3_btree_trace;
+  static struct {
+     char *zName;
+     Tcl_CmdProc *xProc;
+  } aCmd[] = {
+     { "btree_open",               (Tcl_CmdProc*)btree_open               },
+     { "btree_close",              (Tcl_CmdProc*)btree_close              },
+     { "btree_begin_transaction",  (Tcl_CmdProc*)btree_begin_transaction  },
+     { "btree_commit",             (Tcl_CmdProc*)btree_commit             },
+     { "btree_rollback",           (Tcl_CmdProc*)btree_rollback           },
+     { "btree_create_table",       (Tcl_CmdProc*)btree_create_table       },
+     { "btree_drop_table",         (Tcl_CmdProc*)btree_drop_table         },
+     { "btree_clear_table",        (Tcl_CmdProc*)btree_clear_table        },
+     { "btree_get_meta",           (Tcl_CmdProc*)btree_get_meta           },
+     { "btree_update_meta",        (Tcl_CmdProc*)btree_update_meta        },
+     { "btree_page_dump",          (Tcl_CmdProc*)btree_page_dump          },
+     { "btree_tree_dump",          (Tcl_CmdProc*)btree_tree_dump          },
+     { "btree_pager_stats",        (Tcl_CmdProc*)btree_pager_stats        },
+     { "btree_pager_ref_dump",     (Tcl_CmdProc*)btree_pager_ref_dump     },
+     { "btree_cursor",             (Tcl_CmdProc*)btree_cursor             },
+     { "btree_close_cursor",       (Tcl_CmdProc*)btree_close_cursor       },
+     { "btree_move_to",            (Tcl_CmdProc*)btree_move_to            },
+     { "btree_delete",             (Tcl_CmdProc*)btree_delete             },
+     { "btree_next",               (Tcl_CmdProc*)btree_next               },
+     { "btree_prev",               (Tcl_CmdProc*)btree_prev               },
+     { "btree_eof",                (Tcl_CmdProc*)btree_eof                },
+     { "btree_keysize",            (Tcl_CmdProc*)btree_keysize            },
+     { "btree_key",                (Tcl_CmdProc*)btree_key                },
+     { "btree_data",               (Tcl_CmdProc*)btree_data               },
+     { "btree_fetch_key",          (Tcl_CmdProc*)btree_fetch_key          },
+     { "btree_fetch_data",         (Tcl_CmdProc*)btree_fetch_data         },
+     { "btree_payload_size",       (Tcl_CmdProc*)btree_payload_size       },
+     { "btree_first",              (Tcl_CmdProc*)btree_first              },
+     { "btree_last",               (Tcl_CmdProc*)btree_last               },
+     { "btree_integrity_check",    (Tcl_CmdProc*)btree_integrity_check    },
+     { "btree_breakpoint",         (Tcl_CmdProc*)btree_breakpoint         },
+     { "btree_varint_test",        (Tcl_CmdProc*)btree_varint_test        },
+     { "btree_begin_statement",    (Tcl_CmdProc*)btree_begin_statement    },
+     { "btree_commit_statement",   (Tcl_CmdProc*)btree_commit_statement   },
+     { "btree_rollback_statement", (Tcl_CmdProc*)btree_rollback_statement },
+     { "btree_from_db",            (Tcl_CmdProc*)btree_from_db            },
+     { "btree_set_cache_size",     (Tcl_CmdProc*)btree_set_cache_size     },
+     { "btree_cursor_info",        (Tcl_CmdProc*)btree_cursor_info        },
+     { "btree_ovfl_info",          (Tcl_CmdProc*)btree_ovfl_info          },
+     { "btree_cursor_list",        (Tcl_CmdProc*)btree_cursor_list        },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  Tcl_LinkVar(interp, "btree_trace", (char*)&sqlite3_btree_trace,
+     TCL_LINK_INT);
+
+  /* The btree_insert command is implemented using the tcl 'object'
+  ** interface, not the string interface like the other commands in this
+  ** file. This is so binary data can be inserted into btree tables.
+  */
+  Tcl_CreateObjCommand(interp, "btree_insert", btree_insert, 0, 0);
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test4.c b/client/src/thirdparty/sqlite-3.4.2/src/test4.c
new file mode 100644
index 0000000..4a47d2f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test4.c
@@ -0,0 +1,716 @@
+/*
+** 2003 December 18
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the the SQLite library in a multithreaded environment.
+**
+** $Id: test4.c,v 1.21 2007/08/22 11:41:18 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#if defined(OS_UNIX) && OS_UNIX==1 && SQLITE_THREADSAFE
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <sched.h>
+#include <ctype.h>
+
+/*
+** Each thread is controlled by an instance of the following
+** structure.
+*/
+typedef struct Thread Thread;
+struct Thread {
+  /* The first group of fields are writable by the master and read-only
+  ** to the thread. */
+  char *zFilename;       /* Name of database file */
+  void (*xOp)(Thread*);  /* next operation to do */
+  char *zArg;            /* argument usable by xOp */
+  int opnum;             /* Operation number */
+  int busy;              /* True if this thread is in use */
+
+  /* The next group of fields are writable by the thread but read-only to the
+  ** master. */
+  int completed;        /* Number of operations completed */
+  sqlite3 *db;           /* Open database */
+  sqlite3_stmt *pStmt;     /* Pending operation */
+  char *zErr;           /* operation error */
+  char *zStaticErr;     /* Static error message */
+  int rc;               /* operation return code */
+  int argc;             /* number of columns in result */
+  const char *argv[100];    /* result columns */
+  const char *colv[100];    /* result column names */
+};
+
+/*
+** There can be as many as 26 threads running at once.  Each is named
+** by a capital letter: A, B, C, ..., Y, Z.
+*/
+#define N_THREAD 26
+static Thread threadset[N_THREAD];
+
+
+/*
+** The main loop for a thread.  Threads use busy waiting. 
+*/
+static void *thread_main(void *pArg){
+  Thread *p = (Thread*)pArg;
+  if( p->db ){
+    sqlite3_close(p->db);
+  }
+  sqlite3_open(p->zFilename, &p->db);
+  if( SQLITE_OK!=sqlite3_errcode(p->db) ){
+    p->zErr = strdup(sqlite3_errmsg(p->db));
+    sqlite3_close(p->db);
+    p->db = 0;
+  }
+  p->pStmt = 0;
+  p->completed = 1;
+  while( p->opnum<=p->completed ) sched_yield();
+  while( p->xOp ){
+    if( p->zErr && p->zErr!=p->zStaticErr ){
+      sqlite3_free(p->zErr);
+      p->zErr = 0;
+    }
+    (*p->xOp)(p);
+    p->completed++;
+    while( p->opnum<=p->completed ) sched_yield();
+  }
+  if( p->pStmt ){
+    sqlite3_finalize(p->pStmt);
+    p->pStmt = 0;
+  }
+  if( p->db ){
+    sqlite3_close(p->db);
+    p->db = 0;
+  }
+  if( p->zErr && p->zErr!=p->zStaticErr ){
+    sqlite3_free(p->zErr);
+    p->zErr = 0;
+  }
+  p->completed++;
+  sqlite3_thread_cleanup();
+  return 0;
+}
+
+/*
+** Get a thread ID which is an upper case letter.  Return the index.
+** If the argument is not a valid thread ID put an error message in
+** the interpreter and return -1.
+*/
+static int parse_thread_id(Tcl_Interp *interp, const char *zArg){
+  if( zArg==0 || zArg[0]==0 || zArg[1]!=0 || !isupper((unsigned char)zArg[0]) ){
+    Tcl_AppendResult(interp, "thread ID must be an upper case letter", 0);
+    return -1;
+  }
+  return zArg[0] - 'A';
+}
+
+/*
+** Usage:    thread_create NAME  FILENAME
+**
+** NAME should be an upper case letter.  Start the thread running with
+** an open connection to the given database.
+*/
+static int tcl_thread_create(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  pthread_t x;
+  int rc;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID FILENAME", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( threadset[i].busy ){
+    Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);
+    return TCL_ERROR;
+  }
+  threadset[i].busy = 1;
+  sqlite3_free(threadset[i].zFilename);
+  threadset[i].zFilename = sqlite3StrDup(argv[2]);
+  threadset[i].opnum = 1;
+  threadset[i].completed = 0;
+  rc = pthread_create(&x, 0, thread_main, &threadset[i]);
+  if( rc ){
+    Tcl_AppendResult(interp, "failed to create the thread", 0);
+    sqlite3_free(threadset[i].zFilename);
+    threadset[i].busy = 0;
+    return TCL_ERROR;
+  }
+  pthread_detach(x);
+  return TCL_OK;
+}
+
+/*
+** Wait for a thread to reach its idle state.
+*/
+static void thread_wait(Thread *p){
+  while( p->opnum>p->completed ) sched_yield();
+}
+
+/*
+** Usage:  thread_wait ID
+**
+** Wait on thread ID to reach its idle state.
+*/
+static int tcl_thread_wait(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  return TCL_OK;
+}
+
+/*
+** Stop a thread.
+*/
+static void stop_thread(Thread *p){
+  thread_wait(p);
+  p->xOp = 0;
+  p->opnum++;
+  thread_wait(p);
+  sqlite3_free(p->zArg);
+  p->zArg = 0;
+  sqlite3_free(p->zFilename);
+  p->zFilename = 0;
+  p->busy = 0;
+}
+
+/*
+** Usage:  thread_halt ID
+**
+** Cause a thread to shut itself down.  Wait for the shutdown to be
+** completed.  If ID is "*" then stop all threads.
+*/
+static int tcl_thread_halt(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  if( argv[1][0]=='*' && argv[1][1]==0 ){
+    for(i=0; i<N_THREAD; i++){
+      if( threadset[i].busy ) stop_thread(&threadset[i]);
+    }
+  }else{
+    i = parse_thread_id(interp, argv[1]);
+    if( i<0 ) return TCL_ERROR;
+    if( !threadset[i].busy ){
+      Tcl_AppendResult(interp, "no such thread", 0);
+      return TCL_ERROR;
+    }
+    stop_thread(&threadset[i]);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_argc  ID
+**
+** Wait on the most recent thread_step to complete, then return the
+** number of columns in the result set.
+*/
+static int tcl_thread_argc(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  sprintf(zBuf, "%d", threadset[i].argc);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_argv  ID   N
+**
+** Wait on the most recent thread_step to complete, then return the
+** value of the N-th columns in the result set.
+*/
+static int tcl_thread_argv(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  int n;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID N", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  thread_wait(&threadset[i]);
+  if( n<0 || n>=threadset[i].argc ){
+    Tcl_AppendResult(interp, "column number out of range", 0);
+    return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, threadset[i].argv[n], 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_colname  ID   N
+**
+** Wait on the most recent thread_step to complete, then return the
+** name of the N-th columns in the result set.
+*/
+static int tcl_thread_colname(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  int n;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID N", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  thread_wait(&threadset[i]);
+  if( n<0 || n>=threadset[i].argc ){
+    Tcl_AppendResult(interp, "column number out of range", 0);
+    return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, threadset[i].colv[n], 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_result  ID
+**
+** Wait on the most recent operation to complete, then return the
+** result code from that operation.
+*/
+static int tcl_thread_result(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  const char *zName;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  switch( threadset[i].rc ){
+    case SQLITE_OK:         zName = "SQLITE_OK";          break;
+    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
+    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
+    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
+    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
+    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
+    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
+    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
+    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
+    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
+    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
+    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
+    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
+    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
+    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
+    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
+    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
+    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
+    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
+    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
+    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
+    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
+    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
+    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
+    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
+    default:                zName = "SQLITE_Unknown";     break;
+  }
+  Tcl_AppendResult(interp, zName, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_error  ID
+**
+** Wait on the most recent operation to complete, then return the
+** error string.
+*/
+static int tcl_thread_error(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  Tcl_AppendResult(interp, threadset[i].zErr, 0);
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to compile an SQL statement.
+*/
+static void do_compile(Thread *p){
+  if( p->db==0 ){
+    p->zErr = p->zStaticErr = "no database is open";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  if( p->pStmt ){
+    sqlite3_finalize(p->pStmt);
+    p->pStmt = 0;
+  }
+  p->rc = sqlite3_prepare(p->db, p->zArg, -1, &p->pStmt, 0);
+}
+
+/*
+** Usage: thread_compile ID SQL
+**
+** Compile a new virtual machine.
+*/
+static int tcl_thread_compile(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID SQL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  threadset[i].xOp = do_compile;
+  sqlite3_free(threadset[i].zArg);
+  threadset[i].zArg = sqlite3StrDup(argv[2]);
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to step the virtual machine.
+*/
+static void do_step(Thread *p){
+  int i;
+  if( p->pStmt==0 ){
+    p->zErr = p->zStaticErr = "no virtual machine available";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  p->rc = sqlite3_step(p->pStmt);
+  if( p->rc==SQLITE_ROW ){
+    p->argc = sqlite3_column_count(p->pStmt);
+    for(i=0; i<sqlite3_data_count(p->pStmt); i++){
+      p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);
+    }
+    for(i=0; i<p->argc; i++){
+      p->colv[i] = sqlite3_column_name(p->pStmt, i);
+    }
+  }
+}
+
+/*
+** Usage: thread_step ID
+**
+** Advance the virtual machine by one step
+*/
+static int tcl_thread_step(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " IDL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  threadset[i].xOp = do_step;
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to finalize a virtual machine.
+*/
+static void do_finalize(Thread *p){
+  if( p->pStmt==0 ){
+    p->zErr = p->zStaticErr = "no virtual machine available";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  p->rc = sqlite3_finalize(p->pStmt);
+  p->pStmt = 0;
+}
+
+/*
+** Usage: thread_finalize ID
+**
+** Finalize the virtual machine.
+*/
+static int tcl_thread_finalize(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " IDL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  threadset[i].xOp = do_finalize;
+  sqlite3_free(threadset[i].zArg);
+  threadset[i].zArg = 0;
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_swap ID ID
+**
+** Interchange the sqlite* pointer between two threads.
+*/
+static int tcl_thread_swap(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i, j;
+  sqlite3 *temp;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID1 ID2", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  j = parse_thread_id(interp, argv[2]);
+  if( j<0 ) return TCL_ERROR;
+  if( !threadset[j].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[j]);
+  temp = threadset[i].db;
+  threadset[i].db = threadset[j].db;
+  threadset[j].db = temp;
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_db_get ID
+**
+** Return the database connection pointer for the given thread.  Then
+** remove the pointer from the thread itself.  Afterwards, the thread
+** can be stopped and the connection can be used by the main thread.
+*/
+static int tcl_thread_db_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+  extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  sqlite3TestMakePointerStr(interp, zBuf, threadset[i].db);
+  threadset[i].db = 0;
+  Tcl_AppendResult(interp, zBuf, (char*)0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_stmt_get ID
+**
+** Return the database stmt pointer for the given thread.  Then
+** remove the pointer from the thread itself. 
+*/
+static int tcl_thread_stmt_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+  extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  sqlite3TestMakePointerStr(interp, zBuf, threadset[i].pStmt);
+  threadset[i].pStmt = 0;
+  Tcl_AppendResult(interp, zBuf, (char*)0);
+  return TCL_OK;
+}
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest4_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_CmdProc *xProc;
+  } aCmd[] = {
+     { "thread_create",     (Tcl_CmdProc*)tcl_thread_create     },
+     { "thread_wait",       (Tcl_CmdProc*)tcl_thread_wait       },
+     { "thread_halt",       (Tcl_CmdProc*)tcl_thread_halt       },
+     { "thread_argc",       (Tcl_CmdProc*)tcl_thread_argc       },
+     { "thread_argv",       (Tcl_CmdProc*)tcl_thread_argv       },
+     { "thread_colname",    (Tcl_CmdProc*)tcl_thread_colname    },
+     { "thread_result",     (Tcl_CmdProc*)tcl_thread_result     },
+     { "thread_error",      (Tcl_CmdProc*)tcl_thread_error      },
+     { "thread_compile",    (Tcl_CmdProc*)tcl_thread_compile    },
+     { "thread_step",       (Tcl_CmdProc*)tcl_thread_step       },
+     { "thread_finalize",   (Tcl_CmdProc*)tcl_thread_finalize   },
+     { "thread_swap",       (Tcl_CmdProc*)tcl_thread_swap       },
+     { "thread_db_get",     (Tcl_CmdProc*)tcl_thread_db_get     },
+     { "thread_stmt_get",   (Tcl_CmdProc*)tcl_thread_stmt_get   },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  return TCL_OK;
+}
+#else
+int Sqlitetest4_Init(Tcl_Interp *interp){ return TCL_OK; }
+#endif /* OS_UNIX */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test5.c b/client/src/thirdparty/sqlite-3.4.2/src/test5.c
new file mode 100644
index 0000000..58d65aa
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test5.c
@@ -0,0 +1,217 @@
+/*
+** 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.
+**
+*************************************************************************
+** Code for testing the utf.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library. Specifically, the code in this file
+** is used for testing the SQLite routines for converting between
+** the various supported unicode encodings.
+**
+** $Id: test5.c,v 1.20 2007/08/21 19:33:57 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** The first argument is a TCL UTF-8 string. Return the byte array
+** object with the encoded representation of the string, including
+** the NULL terminator.
+*/
+static int binarize(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int len;
+  char *bytes;
+  Tcl_Obj *pRet;
+  assert(objc==2);
+
+  bytes = Tcl_GetStringFromObj(objv[1], &len);
+  pRet = Tcl_NewByteArrayObj((u8*)bytes, len+1);
+  Tcl_SetObjResult(interp, pRet);
+  return TCL_OK;
+}
+
+/*
+** Usage: test_value_overhead <repeat-count> <do-calls>.
+**
+** This routine is used to test the overhead of calls to
+** sqlite3_value_text(), on a value that contains a UTF-8 string. The idea
+** is to figure out whether or not it is a problem to use sqlite3_value
+** structures with collation sequence functions.
+**
+** If <do-calls> is 0, then the calls to sqlite3_value_text() are not
+** actually made.
+*/
+static int test_value_overhead(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int do_calls;
+  int repeat_count;
+  int i;
+  Mem val;
+  const char *zVal;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " <repeat-count> <do-calls>", 0);
+    return TCL_ERROR;
+  }
+
+  if( Tcl_GetIntFromObj(interp, objv[1], &repeat_count) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &do_calls) ) return TCL_ERROR;
+
+  val.flags = MEM_Str|MEM_Term|MEM_Static;
+  val.z = "hello world";
+  val.type = SQLITE_TEXT;
+  val.enc = SQLITE_UTF8;
+
+  for(i=0; i<repeat_count; i++){
+    if( do_calls ){
+      zVal = (char*)sqlite3_value_text(&val);
+    }
+  }
+
+  return TCL_OK;
+}
+
+static u8 name_to_enc(Tcl_Interp *interp, Tcl_Obj *pObj){
+  struct EncName {
+    char *zName;
+    u8 enc;
+  } encnames[] = {
+    { "UTF8", SQLITE_UTF8 },
+    { "UTF16LE", SQLITE_UTF16LE },
+    { "UTF16BE", SQLITE_UTF16BE },
+    { "UTF16", SQLITE_UTF16NATIVE },
+    { 0, 0 }
+  };
+  struct EncName *pEnc;
+  char *z = Tcl_GetString(pObj);
+  for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
+    if( 0==sqlite3StrICmp(z, pEnc->zName) ){
+      break;
+    }
+  }
+  if( !pEnc->enc ){
+    Tcl_AppendResult(interp, "No such encoding: ", z, 0);
+  }
+  return pEnc->enc;
+}
+
+/*
+** Usage:   test_translate <string/blob> <from enc> <to enc> ?<transient>?
+**
+*/
+static int test_translate(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  u8 enc_from;
+  u8 enc_to;
+  sqlite3_value *pVal;
+
+  char *z;
+  int len;
+  void (*xDel)(void *p) = SQLITE_STATIC;
+
+  if( objc!=4 && objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), 
+        " <string/blob> <from enc> <to enc>", 0
+    );
+    return TCL_ERROR;
+  }
+  if( objc==5 ){
+    xDel = sqlite3_free;
+  }
+
+  enc_from = name_to_enc(interp, objv[2]);
+  if( !enc_from ) return TCL_ERROR;
+  enc_to = name_to_enc(interp, objv[3]);
+  if( !enc_to ) return TCL_ERROR;
+
+  pVal = sqlite3ValueNew(0);
+
+  if( enc_from==SQLITE_UTF8 ){
+    z = Tcl_GetString(objv[1]);
+    if( objc==5 ){
+      z = sqlite3StrDup(z);
+    }
+    sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
+  }else{
+    z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len);
+    if( objc==5 ){
+      char *zTmp = z;
+      z = sqlite3_malloc(len);
+      memcpy(z, zTmp, len);
+    }
+    sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
+  }
+
+  z = (char *)sqlite3ValueText(pVal, enc_to);
+  len = sqlite3ValueBytes(pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);
+  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len));
+
+  sqlite3ValueFree(pVal);
+
+  return TCL_OK;
+}
+
+/*
+** Usage: translate_selftest
+**
+** Call sqlite3UtfSelfTest() to run the internal tests for unicode
+** translation. If there is a problem an assert() will fail.
+**/
+void sqlite3UtfSelfTest();
+static int test_translate_selftest(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3UtfSelfTest();
+#endif
+  return SQLITE_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest5_Init(Tcl_Interp *interp){
+  static struct {
+    char *zName;
+    Tcl_ObjCmdProc *xProc;
+  } aCmd[] = {
+    { "binarize",                (Tcl_ObjCmdProc*)binarize },
+    { "test_value_overhead",     (Tcl_ObjCmdProc*)test_value_overhead },
+    { "test_translate",          (Tcl_ObjCmdProc*)test_translate     },
+    { "translate_selftest",      (Tcl_ObjCmdProc*)test_translate_selftest},
+  };
+  int i;
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  return SQLITE_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test6.c b/client/src/thirdparty/sqlite-3.4.2/src/test6.c
new file mode 100644
index 0000000..9330a1d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test6.c
@@ -0,0 +1,879 @@
+/*
+** 2004 May 22
+**
+** 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 that modified the OS layer in order to simulate
+** the effect on the database file of an OS crash or power failure.  This
+** is used to test the ability of SQLite to recover from those situations.
+*/
+#if SQLITE_TEST          /* This file is used for testing only */
+#include "sqliteInt.h"
+#include "tcl.h"
+
+#ifndef SQLITE_OMIT_DISKIO  /* This file is a no-op if disk I/O is disabled */
+
+/* #define TRACE_CRASHTEST */
+
+typedef struct CrashFile CrashFile;
+typedef struct CrashGlobal CrashGlobal;
+typedef struct WriteBuffer WriteBuffer;
+
+/*
+** Method:
+**
+**   This layer is implemented as a wrapper around the "real" 
+**   sqlite3_file object for the host system. Each time data is 
+**   written to the file object, instead of being written to the
+**   underlying file, the write operation is stored in an in-memory 
+**   structure (type WriteBuffer). This structure is placed at the
+**   end of a global ordered list (the write-list).
+**
+**   When data is read from a file object, the requested region is
+**   first retrieved from the real file. The write-list is then 
+**   traversed and data copied from any overlapping WriteBuffer 
+**   structures to the output buffer. i.e. a read() operation following
+**   one or more write() operations works as expected, even if no
+**   data has actually been written out to the real file.
+**
+**   When a fsync() operation is performed, an operating system crash 
+**   may be simulated, in which case exit(-1) is called (the call to 
+**   xSync() never returns). Whether or not a crash is simulated,
+**   the data associated with a subset of the WriteBuffer structures 
+**   stored in the write-list is written to the real underlying files 
+**   and the entries removed from the write-list. If a crash is simulated,
+**   a subset of the buffers may be corrupted before the data is written.
+**
+**   The exact subset of the write-list written and/or corrupted is
+**   determined by the simulated device characteristics and sector-size.
+**
+** "Normal" mode:
+**
+**   Normal mode is used when the simulated device has none of the
+**   SQLITE_IOCAP_XXX flags set.
+**
+**   In normal mode, if the fsync() is not a simulated crash, the 
+**   write-list is traversed from beginning to end. Each WriteBuffer
+**   structure associated with the file handle used to call xSync()
+**   is written to the real file and removed from the write-list.
+**
+**   If a crash is simulated, one of the following takes place for 
+**   each WriteBuffer in the write-list, regardless of which 
+**   file-handle it is associated with:
+**
+**     1. The buffer is correctly written to the file, just as if
+**        a crash were not being simulated.
+**
+**     2. Nothing is done.
+**
+**     3. Garbage data is written to all sectors of the file that 
+**        overlap the region specified by the WriteBuffer. Or garbage
+**        data is written to some contiguous section within the 
+**        overlapped sectors.
+**
+** Device Characteristic flag handling:
+**
+**   If the IOCAP_ATOMIC flag is set, then option (3) above is 
+**   never selected.
+**
+**   If the IOCAP_ATOMIC512 flag is set, and the WriteBuffer represents
+**   an aligned write() of an integer number of 512 byte regions, then
+**   option (3) above is never selected. Instead, each 512 byte region
+**   is either correctly written or left completely untouched. Similar
+**   logic governs the behaviour if any of the other ATOMICXXX flags
+**   is set.
+**
+**   If either the IOCAP_SAFEAPPEND or IOCAP_SEQUENTIAL flags are set
+**   and a crash is being simulated, then an entry of the write-list is
+**   selected at random. Everything in the list after the selected entry 
+**   is discarded before processing begins.
+**
+**   If IOCAP_SEQUENTIAL is set and a crash is being simulated, option 
+**   (1) is selected for all write-list entries except the last. If a 
+**   crash is not being simulated, then all entries in the write-list
+**   that occur before at least one write() on the file-handle specified
+**   as part of the xSync() are written to their associated real files.
+**
+**   If IOCAP_SAFEAPPEND is set and the first byte written by the write()
+**   operation is one byte past the current end of the file, then option
+**   (1) is always selected.
+*/
+
+/*
+** Each write operation in the write-list is represented by an instance
+** of the following structure.
+**
+** If zBuf is 0, then this structure represents a call to xTruncate(), 
+** not xWrite(). In that case, iOffset is the size that the file is
+** truncated to.
+*/
+struct WriteBuffer {
+  i64 iOffset;                 /* Byte offset of the start of this write() */
+  int nBuf;                    /* Number of bytes written */
+  u8 *zBuf;                    /* Pointer to copy of written data */
+  CrashFile *pFile;            /* File this write() applies to */
+
+  WriteBuffer *pNext;          /* Next in CrashGlobal.pWriteList */
+};
+
+struct CrashFile {
+  const sqlite3_io_methods *pMethod;   /* Must be first */
+  sqlite3_file *pRealFile;             /* Underlying "real" file handle */
+  char *zName;
+
+  /* Cache of the entire file. This is used to speed up OsRead() and 
+  ** OsFileSize() calls. Although both could be done by traversing the
+  ** write-list, in practice this is impractically slow.
+  */
+  int iSize;                           /* Size of file in bytes */
+  int nData;                           /* Size of buffer allocated at zData */
+  u8 *zData;                           /* Buffer containing file contents */
+};
+
+struct CrashGlobal {
+  WriteBuffer *pWriteList;     /* Head of write-list */
+  WriteBuffer *pWriteListEnd;  /* End of write-list */
+
+  int iSectorSize;             /* Value of simulated sector size */
+  int iDeviceCharacteristics;  /* Value of simulated device characteristics */
+
+  int iCrash;                  /* Crash on the iCrash'th call to xSync() */
+  char zCrashFile[500];        /* Crash during an xSync() on this file */ 
+};
+
+static CrashGlobal g = {0, 0, SQLITE_DEFAULT_SECTOR_SIZE, 0, 0};
+
+/*
+** Set this global variable to 1 to enable crash testing.
+*/
+static int sqlite3CrashTestEnable = 0;
+
+static void *crash_malloc(int nByte){
+  return (void *)Tcl_Alloc((size_t)nByte);
+}
+static void crash_free(void *p){
+  Tcl_Free(p);
+}
+static void *crash_realloc(void *p, int n){
+  return (void *)Tcl_Realloc(p, (size_t)n);
+}
+
+/*
+** Flush the write-list as if xSync() had been called on file handle
+** pFile. If isCrash is true, simulate a crash.
+*/
+static int writeListSync(CrashFile *pFile, int isCrash){
+  int rc = SQLITE_OK;
+  int iDc = g.iDeviceCharacteristics;
+
+  WriteBuffer *pWrite;
+  WriteBuffer **ppPtr;
+
+  /* If this is not a crash simulation, set pFinal to point to the 
+  ** last element of the write-list that is associated with file handle
+  ** pFile.
+  **
+  ** If this is a crash simulation, set pFinal to an arbitrarily selected
+  ** element of the write-list.
+  */
+  WriteBuffer *pFinal = 0;
+  if( !isCrash ){
+    for(pWrite=g.pWriteList; pWrite; pWrite=pWrite->pNext){
+      if( pWrite->pFile==pFile ){
+        pFinal = pWrite;
+      }
+    }
+  }else if( iDc&(SQLITE_IOCAP_SEQUENTIAL|SQLITE_IOCAP_SAFE_APPEND) ){
+    int nWrite = 0;
+    int iFinal;
+    for(pWrite=g.pWriteList; pWrite; pWrite=pWrite->pNext) nWrite++;
+    sqlite3Randomness(sizeof(int), &iFinal);
+    iFinal = ((iFinal<0)?-1*iFinal:iFinal)%nWrite;
+    for(pWrite=g.pWriteList; iFinal>0; pWrite=pWrite->pNext) iFinal--;
+    pFinal = pWrite;
+  }
+
+#ifdef TRACE_CRASHTEST
+  printf("Sync %s (is %s crash)\n", pFile->zName, (isCrash?"a":"not a"));
+#endif
+
+  ppPtr = &g.pWriteList;
+  for(pWrite=*ppPtr; rc==SQLITE_OK && pWrite; pWrite=*ppPtr){
+    sqlite3_file *pRealFile = pWrite->pFile->pRealFile;
+
+    /* (eAction==1)      -> write block out normally,
+    ** (eAction==2)      -> do nothing,
+    ** (eAction==3)      -> trash sectors.
+    */
+    int eAction = 0;
+    if( !isCrash ){
+      eAction = 2;
+      if( (pWrite->pFile==pFile || iDc&SQLITE_IOCAP_SEQUENTIAL) ){
+        eAction = 1;
+      }
+    }else{
+      char random;
+      sqlite3Randomness(1, &random);
+
+      /* Do not select option 3 (sector trashing) if the IOCAP_ATOMIC flag 
+      ** is set or this is an OsTruncate(), not an Oswrite().
+      */
+      if( (iDc&SQLITE_IOCAP_ATOMIC) || (pWrite->zBuf==0) ){
+        random &= 0x01;
+      }
+
+      /* If IOCAP_SEQUENTIAL is set and this is not the final entry
+      ** in the truncated write-list, always select option 1 (write
+      ** out correctly).
+      */
+      if( (iDc&SQLITE_IOCAP_SEQUENTIAL && pWrite!=pFinal) ){
+        random = 0;
+      }
+
+      /* If IOCAP_SAFE_APPEND is set and this OsWrite() operation is
+      ** an append (first byte of the written region is 1 byte past the
+      ** current EOF), always select option 1 (write out correctly).
+      */
+      if( iDc&SQLITE_IOCAP_SAFE_APPEND && pWrite->zBuf ){
+        i64 iSize;
+        sqlite3OsFileSize(pRealFile, &iSize);
+        if( iSize==pWrite->iOffset ){
+          random = 0;
+        }
+      }
+
+      if( (random&0x06)==0x06 ){
+        eAction = 3;
+      }else{
+        eAction = ((random&0x01)?2:1);
+      }
+    }
+
+    switch( eAction ){
+      case 1: {               /* Write out correctly */
+        if( pWrite->zBuf ){
+          rc = sqlite3OsWrite(
+              pRealFile, pWrite->zBuf, pWrite->nBuf, pWrite->iOffset
+          );
+        }else{
+          rc = sqlite3OsTruncate(pRealFile, pWrite->iOffset);
+        }
+        *ppPtr = pWrite->pNext;
+#ifdef TRACE_CRASHTEST
+        if( isCrash ){
+          printf("Writing %d bytes @ %d (%s)\n", 
+            pWrite->nBuf, (int)pWrite->iOffset, pWrite->pFile->zName
+          );
+        }
+#endif
+        crash_free(pWrite);
+        break;
+      }
+      case 2: {               /* Do nothing */
+        ppPtr = &pWrite->pNext;
+#ifdef TRACE_CRASHTEST
+        if( isCrash ){
+          printf("Omiting %d bytes @ %d (%s)\n", 
+            pWrite->nBuf, (int)pWrite->iOffset, pWrite->pFile->zName
+          );
+        }
+#endif
+        break;
+      }
+      case 3: {               /* Trash sectors */
+        u8 *zGarbage;
+        int iFirst = (pWrite->iOffset/g.iSectorSize);
+        int iLast = (pWrite->iOffset+pWrite->nBuf-1)/g.iSectorSize;
+
+        assert(pWrite->zBuf);
+
+#ifdef TRACE_CRASHTEST
+        printf("Trashing %d sectors @ sector %d (%s)\n", 
+            1+iLast-iFirst, iFirst, pWrite->pFile->zName
+        );
+#endif
+
+        zGarbage = crash_malloc(g.iSectorSize);
+        if( zGarbage ){
+          sqlite3_int64 i;
+          for(i=iFirst; rc==SQLITE_OK && i<=iLast; i++){
+            sqlite3Randomness(g.iSectorSize, zGarbage); 
+            rc = sqlite3OsWrite(
+              pRealFile, zGarbage, g.iSectorSize, i*g.iSectorSize
+            );
+          }
+          crash_free(zGarbage);
+        }else{
+          rc = SQLITE_NOMEM;
+        }
+
+        ppPtr = &pWrite->pNext;
+        break;
+      }
+
+      default:
+        assert(!"Cannot happen");
+    }
+
+    if( pWrite==pFinal ) break;
+  }
+
+  if( rc==SQLITE_OK && isCrash ){
+    exit(-1);
+  }
+
+  for(pWrite=g.pWriteList; pWrite && pWrite->pNext; pWrite=pWrite->pNext);
+  g.pWriteListEnd = pWrite;
+
+  return rc;
+}
+
+/*
+** Add an entry to the end of the write-list.
+*/
+static int writeListAppend(
+  sqlite3_file *pFile,
+  sqlite3_int64 iOffset,
+  const u8 *zBuf,
+  int nBuf
+){
+  WriteBuffer *pNew;
+
+  assert((zBuf && nBuf) || (!nBuf && !zBuf));
+
+  pNew = (WriteBuffer *)crash_malloc(sizeof(WriteBuffer) + nBuf);
+  if( pNew==0 ){
+    fprintf(stderr, "out of memory in the crash simulator\n");
+  }
+  memset(pNew, 0, sizeof(WriteBuffer)+nBuf);
+  pNew->iOffset = iOffset;
+  pNew->nBuf = nBuf;
+  pNew->pFile = (CrashFile *)pFile;
+  if( zBuf ){
+    pNew->zBuf = (u8 *)&pNew[1];
+    memcpy(pNew->zBuf, zBuf, nBuf);
+  }
+
+  if( g.pWriteList ){
+    assert(g.pWriteListEnd);
+    g.pWriteListEnd->pNext = pNew;
+  }else{
+    g.pWriteList = pNew;
+  }
+  g.pWriteListEnd = pNew;
+  
+  return SQLITE_OK;
+}
+
+/*
+** Close a crash-file.
+*/
+static int cfClose(sqlite3_file *pFile){
+  CrashFile *pCrash = (CrashFile *)pFile;
+  writeListSync(pCrash, 0);
+  sqlite3OsClose(pCrash->pRealFile);
+  return SQLITE_OK;
+}
+
+/*
+** Read data from a crash-file.
+*/
+static int cfRead(
+  sqlite3_file *pFile, 
+  void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  CrashFile *pCrash = (CrashFile *)pFile;
+
+  /* Check the file-size to see if this is a short-read */
+  if( pCrash->iSize<(iOfst+iAmt) ){
+    return SQLITE_IOERR_SHORT_READ;
+  }
+
+  memcpy(zBuf, &pCrash->zData[iOfst], iAmt);
+  return SQLITE_OK;
+}
+
+/*
+** Write data to a crash-file.
+*/
+static int cfWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  CrashFile *pCrash = (CrashFile *)pFile;
+  if( iAmt+iOfst>pCrash->iSize ){
+    pCrash->iSize = iAmt+iOfst;
+  }
+  while( pCrash->iSize>pCrash->nData ){
+    u8 *zNew;
+    int nNew = (pCrash->nData*2) + 4096;
+    zNew = crash_realloc(pCrash->zData, nNew);
+    if( !zNew ){
+      return SQLITE_NOMEM;
+    }
+    memset(&zNew[pCrash->nData], 0, nNew-pCrash->nData);
+    pCrash->nData = nNew;
+    pCrash->zData = zNew;
+  }
+  memcpy(&pCrash->zData[iOfst], zBuf, iAmt);
+  return writeListAppend(pFile, iOfst, zBuf, iAmt);
+}
+
+/*
+** Truncate a crash-file.
+*/
+static int cfTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  CrashFile *pCrash = (CrashFile *)pFile;
+  assert(size>=0);
+  if( pCrash->iSize>size ){
+    pCrash->iSize = size;
+  }
+  return writeListAppend(pFile, size, 0, 0);
+}
+
+/*
+** Sync a crash-file.
+*/
+static int cfSync(sqlite3_file *pFile, int flags){
+  CrashFile *pCrash = (CrashFile *)pFile;
+  int isCrash = 0;
+
+  const char *zName = pCrash->zName;
+  const char *zCrashFile = g.zCrashFile;
+  int nName = strlen(zName);
+  int nCrashFile = strlen(zCrashFile);
+
+  if( nCrashFile>0 && zCrashFile[nCrashFile-1]=='*' ){
+    nCrashFile--;
+    if( nName>nCrashFile ) nName = nCrashFile;
+  }
+
+  if( nName==nCrashFile && 0==memcmp(zName, zCrashFile, nName) ){
+    if( (--g.iCrash)==0 ) isCrash = 1;
+  }
+
+  return writeListSync(pCrash, isCrash);
+}
+
+/*
+** Return the current file-size of the crash-file.
+*/
+static int cfFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  CrashFile *pCrash = (CrashFile *)pFile;
+  *pSize = (i64)pCrash->iSize;
+  return SQLITE_OK;
+}
+
+/*
+** Calls related to file-locks are passed on to the real file handle.
+*/
+static int cfLock(sqlite3_file *pFile, int eLock){
+  return sqlite3OsLock(((CrashFile *)pFile)->pRealFile, eLock);
+}
+static int cfUnlock(sqlite3_file *pFile, int eLock){
+  return sqlite3OsUnlock(((CrashFile *)pFile)->pRealFile, eLock);
+}
+static int cfCheckReservedLock(sqlite3_file *pFile){
+  return sqlite3OsCheckReservedLock(((CrashFile *)pFile)->pRealFile);
+}
+static int cfFileControl(sqlite3_file *pFile, int op, void *pArg){
+  return sqlite3OsFileControl(((CrashFile *)pFile)->pRealFile, op, pArg);
+}
+
+/*
+** The xSectorSize() and xDeviceCharacteristics() functions return
+** the global values configured by the [sqlite_crashparams] tcl
+*  interface.
+*/
+static int cfSectorSize(sqlite3_file *pFile){
+  return g.iSectorSize;
+}
+static int cfDeviceCharacteristics(sqlite3_file *pFile){
+  return g.iDeviceCharacteristics;
+}
+
+static const sqlite3_io_methods CrashFileVtab = {
+  1,                            /* iVersion */
+  cfClose,                      /* xClose */
+  cfRead,                       /* xRead */
+  cfWrite,                      /* xWrite */
+  cfTruncate,                   /* xTruncate */
+  cfSync,                       /* xSync */
+  cfFileSize,                   /* xFileSize */
+  cfLock,                       /* xLock */
+  cfUnlock,                     /* xUnlock */
+  cfCheckReservedLock,          /* xCheckReservedLock */
+  cfFileControl,                /* xFileControl */
+  cfSectorSize,                 /* xSectorSize */
+  cfDeviceCharacteristics       /* xDeviceCharacteristics */
+};
+
+/*
+** Application data for the crash VFS
+*/
+struct crashAppData {
+  sqlite3_vfs *pOrig;                   /* Wrapped vfs structure */
+};
+
+/*
+** Open a crash-file file handle.
+**
+** The caller will have allocated pVfs->szOsFile bytes of space
+** at pFile. This file uses this space for the CrashFile structure
+** and allocates space for the "real" file structure using 
+** sqlite3_malloc(). The assumption here is (pVfs->szOsFile) is
+** equal or greater than sizeof(CrashFile).
+*/
+static int cfOpen(
+  sqlite3_vfs *pCfVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  int rc;
+  CrashFile *pWrapper = (CrashFile *)pFile;
+  sqlite3_file *pReal = (sqlite3_file*)&pWrapper[1];
+
+  memset(pWrapper, 0, sizeof(CrashFile));
+  rc = sqlite3OsOpen(pVfs, zName, pReal, flags, pOutFlags);
+
+  if( rc==SQLITE_OK ){
+    i64 iSize;
+    pWrapper->pMethod = &CrashFileVtab;
+    pWrapper->zName = (char *)zName;
+    pWrapper->pRealFile = pReal;
+    rc = sqlite3OsFileSize(pReal, &iSize);
+    pWrapper->iSize = (int)iSize;
+  }
+  if( rc==SQLITE_OK ){
+    pWrapper->nData = (4096 + pWrapper->iSize);
+    pWrapper->zData = crash_malloc(pWrapper->nData);
+    if( pWrapper->zData ){
+      memset(pWrapper->zData, 0, pWrapper->nData);
+      rc = sqlite3OsRead(pReal, pWrapper->zData, pWrapper->iSize, 0); 
+    }else{
+      rc = SQLITE_NOMEM;
+    }
+  }
+  if( rc!=SQLITE_OK && pWrapper->pMethod ){
+    sqlite3OsClose(pFile);
+  }
+  return rc;
+}
+
+static int cfDelete(sqlite3_vfs *pCfVfs, const char *zPath, int dirSync){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xDelete(pVfs, zPath, dirSync);
+}
+static int cfAccess(sqlite3_vfs *pCfVfs, const char *zPath, int flags){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xAccess(pVfs, zPath, flags);
+}
+static int cfGetTempname(sqlite3_vfs *pCfVfs, int nBufOut, char *zBufOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);
+}
+static int cfFullPathname(
+  sqlite3_vfs *pCfVfs, 
+  const char *zPath, 
+  int nPathOut,
+  char *zPathOut
+){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
+}
+static void *cfDlOpen(sqlite3_vfs *pCfVfs, const char *zPath){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xDlOpen(pVfs, zPath);
+}
+static void cfDlError(sqlite3_vfs *pCfVfs, int nByte, char *zErrMsg){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  pVfs->xDlError(pVfs, nByte, zErrMsg);
+}
+static void *cfDlSym(sqlite3_vfs *pCfVfs, void *pHandle, const char *zSymbol){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xDlSym(pVfs, pHandle, zSymbol);
+}
+static void cfDlClose(sqlite3_vfs *pCfVfs, void *pHandle){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  pVfs->xDlClose(pVfs, pHandle);
+}
+static int cfRandomness(sqlite3_vfs *pCfVfs, int nByte, char *zBufOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xRandomness(pVfs, nByte, zBufOut);
+}
+static int cfSleep(sqlite3_vfs *pCfVfs, int nMicro){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xSleep(pVfs, nMicro);
+}
+static int cfCurrentTime(sqlite3_vfs *pCfVfs, double *pTimeOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pCfVfs->pAppData;
+  return pVfs->xCurrentTime(pVfs, pTimeOut);
+}
+
+static int processDevSymArgs(
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[],
+  int *piDeviceChar,
+  int *piSectorSize
+){
+  struct DeviceFlag {
+    char *zName;
+    int iValue;
+  } aFlag[] = {
+    { "atomic",      SQLITE_IOCAP_ATOMIC      },
+    { "atomic512",   SQLITE_IOCAP_ATOMIC512   },
+    { "atomic1k",    SQLITE_IOCAP_ATOMIC1K    },
+    { "atomic2k",    SQLITE_IOCAP_ATOMIC2K    },
+    { "atomic4k",    SQLITE_IOCAP_ATOMIC4K    },
+    { "atomic8k",    SQLITE_IOCAP_ATOMIC8K    },
+    { "atomic16k",   SQLITE_IOCAP_ATOMIC16K   },
+    { "atomic32k",   SQLITE_IOCAP_ATOMIC32K   },
+    { "atomic64k",   SQLITE_IOCAP_ATOMIC64K   },
+    { "sequential",  SQLITE_IOCAP_SEQUENTIAL  },
+    { "safe_append", SQLITE_IOCAP_SAFE_APPEND },
+    { 0, 0 }
+  };
+
+  int i;
+  int iDc = 0;
+  int iSectorSize = 0;
+  int setSectorsize = 0;
+  int setDeviceChar = 0;
+
+  for(i=0; i<objc; i+=2){
+    int nOpt;
+    char *zOpt = Tcl_GetStringFromObj(objv[i], &nOpt);
+
+    if( (nOpt>11 || nOpt<2 || strncmp("-sectorsize", zOpt, nOpt)) 
+     && (nOpt>16 || nOpt<2 || strncmp("-characteristics", zOpt, nOpt))
+    ){
+      Tcl_AppendResult(interp, 
+        "Bad option: \"", zOpt, 
+        "\" - must be \"-characteristics\" or \"-sectorsize\"", 0
+      );
+      return TCL_ERROR;
+    }
+    if( i==objc-1 ){
+      Tcl_AppendResult(interp, "Option requires an argument: \"", zOpt, "\"",0);
+      return TCL_ERROR;
+    }
+
+    if( zOpt[1]=='s' ){
+      if( Tcl_GetIntFromObj(interp, objv[i+1], &iSectorSize) ){
+        return TCL_ERROR;
+      }
+      setSectorsize = 1;
+    }else{
+      int j;
+      Tcl_Obj **apObj;
+      int nObj;
+      if( Tcl_ListObjGetElements(interp, objv[i+1], &nObj, &apObj) ){
+        return TCL_ERROR;
+      }
+      for(j=0; j<nObj; j++){
+        int rc;
+        int iChoice;
+        Tcl_Obj *pFlag = Tcl_DuplicateObj(apObj[j]);
+        Tcl_IncrRefCount(pFlag);
+        Tcl_UtfToLower(Tcl_GetString(pFlag));
+ 
+        rc = Tcl_GetIndexFromObjStruct(
+            interp, pFlag, aFlag, sizeof(aFlag[0]), "no such flag", 0, &iChoice
+        );
+        Tcl_DecrRefCount(pFlag);
+        if( rc ){
+          return TCL_ERROR;
+        }
+
+        iDc |= aFlag[iChoice].iValue;
+      }
+      setDeviceChar = 1;
+    }
+  }
+
+  if( setDeviceChar ){
+    *piDeviceChar = iDc;
+  }
+  if( setSectorsize ){
+    *piSectorSize = iSectorSize;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** tclcmd:   sqlite_crash_enable ENABLE
+**
+** Parameter ENABLE must be a boolean value. If true, then the "crash"
+** vfs is added to the system. If false, it is removed.
+*/
+static int crashEnableCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int isEnable;
+  static sqlite3_vfs crashVfs = {
+    1,                  /* iVersion */
+    0,                  /* szOsFile */
+    0,                  /* mxPathname */
+    0,                  /* pNext */
+    "crash",            /* zName */
+    0,                  /* pAppData */
+  
+    cfOpen,               /* xOpen */
+    cfDelete,             /* xDelete */
+    cfAccess,             /* xAccess */
+    cfGetTempname,        /* xGetTempName */
+    cfFullPathname,       /* xFullPathname */
+    cfDlOpen,             /* xDlOpen */
+    cfDlError,            /* xDlError */
+    cfDlSym,              /* xDlSym */
+    cfDlClose,            /* xDlClose */
+    cfRandomness,         /* xRandomness */
+    cfSleep,              /* xSleep */
+    cfCurrentTime         /* xCurrentTime */
+  };
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "ENABLE");
+    return TCL_ERROR;
+  }
+
+  if( Tcl_GetBooleanFromObj(interp, objv[1], &isEnable) ){
+    return TCL_ERROR;
+  }
+
+  if( (isEnable && crashVfs.pAppData) || (!isEnable && !crashVfs.pAppData) ){
+    return TCL_OK;
+  }
+
+  if( crashVfs.pAppData==0 ){
+    sqlite3_vfs *pOriginalVfs = sqlite3_vfs_find(0);
+    crashVfs.mxPathname = pOriginalVfs->mxPathname;
+    crashVfs.pAppData = (void *)pOriginalVfs;
+    crashVfs.szOsFile = sizeof(CrashFile) + pOriginalVfs->szOsFile;
+    sqlite3_vfs_register(&crashVfs, 0);
+  }else{
+    crashVfs.pAppData = 0;
+    sqlite3_vfs_unregister(&crashVfs);
+  }
+
+  return TCL_OK;
+}
+
+/*
+** tclcmd:   sqlite_crashparams ?OPTIONS? DELAY CRASHFILE
+**
+** This procedure implements a TCL command that enables crash testing
+** in testfixture.  Once enabled, crash testing cannot be disabled.
+**
+** Available options are "-characteristics" and "-sectorsize". Both require
+** an argument. For -sectorsize, this is the simulated sector size in
+** bytes. For -characteristics, the argument must be a list of io-capability
+** flags to simulate. Valid flags are "atomic", "atomic512", "atomic1K",
+** "atomic2K", "atomic4K", "atomic8K", "atomic16K", "atomic32K", 
+** "atomic64K", "sequential" and "safe_append".
+**
+** Example:
+**
+**   sqlite_crashparams -sect 1024 -char {atomic sequential} ./test.db 1
+**
+*/
+static int crashParamsObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int iDelay;
+  const char *zCrashFile;
+  int nCrashFile, iDc, iSectorSize;
+
+  iDc = -1;
+  iSectorSize = -1;
+
+  if( objc<3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?OPTIONS? DELAY CRASHFILE");
+    goto error;
+  }
+
+  zCrashFile = Tcl_GetStringFromObj(objv[objc-1], &nCrashFile);
+  if( nCrashFile>=sizeof(g.zCrashFile) ){
+    Tcl_AppendResult(interp, "Filename is too long: \"", zCrashFile, "\"", 0);
+    goto error;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[objc-2], &iDelay) ){
+    goto error;
+  }
+
+  if( processDevSymArgs(interp, objc-3, &objv[1], &iDc, &iSectorSize) ){
+    return TCL_ERROR;
+  }
+
+  if( iDc>=0 ){
+    g.iDeviceCharacteristics = iDc;
+  }
+  if( iSectorSize>=0 ){
+    g.iSectorSize = iSectorSize;
+  }
+
+  g.iCrash = iDelay;
+  memcpy(g.zCrashFile, zCrashFile, nCrashFile+1);
+  sqlite3CrashTestEnable = 1;
+  return TCL_OK;
+
+error:
+  return TCL_ERROR;
+}
+
+static int devSymObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  void devsym_register(int iDeviceChar, int iSectorSize);
+
+  int iDc = -1;
+  int iSectorSize = -1;
+
+  if( processDevSymArgs(interp, objc-1, &objv[1], &iDc, &iSectorSize) ){
+    return TCL_ERROR;
+  }
+  devsym_register(iDc, iSectorSize);
+
+  return TCL_OK;
+}
+
+#endif /* SQLITE_OMIT_DISKIO */
+
+/*
+** This procedure registers the TCL procedures defined in this file.
+*/
+int Sqlitetest6_Init(Tcl_Interp *interp){
+#ifndef SQLITE_OMIT_DISKIO
+  Tcl_CreateObjCommand(interp, "sqlite3_crash_enable", crashEnableCmd, 0, 0);
+  Tcl_CreateObjCommand(interp, "sqlite3_crashparams", crashParamsObjCmd, 0, 0);
+  Tcl_CreateObjCommand(interp, "sqlite3_simulate_device", devSymObjCmd, 0, 0);
+#endif
+  return TCL_OK;
+}
+
+#endif /* SQLITE_TEST */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test7.c b/client/src/thirdparty/sqlite-3.4.2/src/test7.c
new file mode 100644
index 0000000..897d911
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test7.c
@@ -0,0 +1,723 @@
+/*
+** 2006 January 09
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the client/server version of the SQLite library.
+** Derived from test4.c.
+**
+** $Id: test7.c,v 1.10 2007/10/05 15:04:13 danielk1977 Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+
+/*
+** This test only works on UNIX with a SQLITE_THREADSAFE build that includes
+** the SQLITE_SERVER option.
+*/
+#if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE) && \
+    defined(OS_UNIX) && OS_UNIX && SQLITE_THREADSAFE
+
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <sched.h>
+#include <ctype.h>
+
+/*
+** Interfaces defined in server.c
+*/
+int sqlite3_client_open(const char*, sqlite3**);
+int sqlite3_client_prepare(sqlite3*,const char*,int,
+                           sqlite3_stmt**,const char**);
+int sqlite3_client_step(sqlite3_stmt*);
+int sqlite3_client_reset(sqlite3_stmt*);
+int sqlite3_client_finalize(sqlite3_stmt*);
+int sqlite3_client_close(sqlite3*);
+int sqlite3_server_start(void);
+int sqlite3_server_stop(void);
+
+/*
+** Each thread is controlled by an instance of the following
+** structure.
+*/
+typedef struct Thread Thread;
+struct Thread {
+  /* The first group of fields are writable by the supervisor thread
+  ** and read-only to the client threads
+  */
+  char *zFilename;         /* Name of database file */
+  void (*xOp)(Thread*);    /* next operation to do */
+  char *zArg;              /* argument usable by xOp */
+  volatile int opnum;      /* Operation number */
+  volatile int busy;       /* True if this thread is in use */
+
+  /* The next group of fields are writable by the client threads 
+  ** but read-only to the superviser thread.
+  */
+  volatile int completed;  /* Number of operations completed */
+  sqlite3 *db;             /* Open database */
+  sqlite3_stmt *pStmt;     /* Pending operation */
+  char *zErr;              /* operation error */
+  char *zStaticErr;        /* Static error message */
+  int rc;                  /* operation return code */
+  int argc;                /* number of columns in result */
+  const char *argv[100];   /* result columns */
+  const char *colv[100];   /* result column names */
+};
+
+/*
+** There can be as many as 26 threads running at once.  Each is named
+** by a capital letter: A, B, C, ..., Y, Z.
+*/
+#define N_THREAD 26
+static Thread threadset[N_THREAD];
+
+/*
+** The main loop for a thread.  Threads use busy waiting. 
+*/
+static void *client_main(void *pArg){
+  Thread *p = (Thread*)pArg;
+  if( p->db ){
+    sqlite3_client_close(p->db);
+  }
+  sqlite3_client_open(p->zFilename, &p->db);
+  if( SQLITE_OK!=sqlite3_errcode(p->db) ){
+    p->zErr = strdup(sqlite3_errmsg(p->db));
+    sqlite3_client_close(p->db);
+    p->db = 0;
+  }
+  p->pStmt = 0;
+  p->completed = 1;
+  while( p->opnum<=p->completed ) sched_yield();
+  while( p->xOp ){
+    if( p->zErr && p->zErr!=p->zStaticErr ){
+      sqlite3_free(p->zErr);
+      p->zErr = 0;
+    }
+    (*p->xOp)(p);
+    p->completed++;
+    while( p->opnum<=p->completed ) sched_yield();
+  }
+  if( p->pStmt ){
+    sqlite3_client_finalize(p->pStmt);
+    p->pStmt = 0;
+  }
+  if( p->db ){
+    sqlite3_client_close(p->db);
+    p->db = 0;
+  }
+  if( p->zErr && p->zErr!=p->zStaticErr ){
+    sqlite3_free(p->zErr);
+    p->zErr = 0;
+  }
+  p->completed++;
+  sqlite3_thread_cleanup();
+  return 0;
+}
+
+/*
+** Get a thread ID which is an upper case letter.  Return the index.
+** If the argument is not a valid thread ID put an error message in
+** the interpreter and return -1.
+*/
+static int parse_client_id(Tcl_Interp *interp, const char *zArg){
+  if( zArg==0 || zArg[0]==0 || zArg[1]!=0 || !isupper((unsigned char)zArg[0]) ){
+    Tcl_AppendResult(interp, "thread ID must be an upper case letter", 0);
+    return -1;
+  }
+  return zArg[0] - 'A';
+}
+
+/*
+** Usage:    client_create NAME  FILENAME
+**
+** NAME should be an upper case letter.  Start the thread running with
+** an open connection to the given database.
+*/
+static int tcl_client_create(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  pthread_t x;
+  int rc;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID FILENAME", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( threadset[i].busy ){
+    Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);
+    return TCL_ERROR;
+  }
+  threadset[i].busy = 1;
+  sqlite3_free(threadset[i].zFilename);
+  threadset[i].zFilename = sqlite3StrDup(argv[2]);
+  threadset[i].opnum = 1;
+  threadset[i].completed = 0;
+  rc = pthread_create(&x, 0, client_main, &threadset[i]);
+  if( rc ){
+    Tcl_AppendResult(interp, "failed to create the thread", 0);
+    sqlite3_free(threadset[i].zFilename);
+    threadset[i].busy = 0;
+    return TCL_ERROR;
+  }
+  pthread_detach(x);
+  sqlite3_server_start();
+  return TCL_OK;
+}
+
+/*
+** Wait for a thread to reach its idle state.
+*/
+static void client_wait(Thread *p){
+  while( p->opnum>p->completed ) sched_yield();
+}
+
+/*
+** Usage:  client_wait ID
+**
+** Wait on thread ID to reach its idle state.
+*/
+static int tcl_client_wait(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  return TCL_OK;
+}
+
+/*
+** Stop a thread.
+*/
+static void stop_thread(Thread *p){
+  client_wait(p);
+  p->xOp = 0;
+  p->opnum++;
+  client_wait(p);
+  sqlite3_free(p->zArg);
+  p->zArg = 0;
+  sqlite3_free(p->zFilename);
+  p->zFilename = 0;
+  p->busy = 0;
+}
+
+/*
+** Usage:  client_halt ID
+**
+** Cause a client thread to shut itself down.  Wait for the shutdown to be
+** completed.  If ID is "*" then stop all client threads.
+*/
+static int tcl_client_halt(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  if( argv[1][0]=='*' && argv[1][1]==0 ){
+    for(i=0; i<N_THREAD; i++){
+      if( threadset[i].busy ){
+        stop_thread(&threadset[i]);
+      }
+    }
+  }else{
+    i = parse_client_id(interp, argv[1]);
+    if( i<0 ) return TCL_ERROR;
+    if( !threadset[i].busy ){
+      Tcl_AppendResult(interp, "no such thread", 0);
+      return TCL_ERROR;
+    }
+    stop_thread(&threadset[i]);
+  }
+
+  /* If no client threads are still running, also stop the server */
+  for(i=0; i<N_THREAD && threadset[i].busy==0; i++){}
+  if( i>=N_THREAD ){
+    sqlite3_server_stop();
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage: client_argc  ID
+**
+** Wait on the most recent client_step to complete, then return the
+** number of columns in the result set.
+*/
+static int tcl_client_argc(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  sprintf(zBuf, "%d", threadset[i].argc);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: client_argv  ID   N
+**
+** Wait on the most recent client_step to complete, then return the
+** value of the N-th columns in the result set.
+*/
+static int tcl_client_argv(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  int n;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID N", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  client_wait(&threadset[i]);
+  if( n<0 || n>=threadset[i].argc ){
+    Tcl_AppendResult(interp, "column number out of range", 0);
+    return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, threadset[i].argv[n], 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: client_colname  ID   N
+**
+** Wait on the most recent client_step to complete, then return the
+** name of the N-th columns in the result set.
+*/
+static int tcl_client_colname(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  int n;
+
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID N", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
+  client_wait(&threadset[i]);
+  if( n<0 || n>=threadset[i].argc ){
+    Tcl_AppendResult(interp, "column number out of range", 0);
+    return TCL_ERROR;
+  }
+  Tcl_AppendResult(interp, threadset[i].colv[n], 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: client_result  ID
+**
+** Wait on the most recent operation to complete, then return the
+** result code from that operation.
+*/
+static int tcl_client_result(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  const char *zName;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  switch( threadset[i].rc ){
+    case SQLITE_OK:         zName = "SQLITE_OK";          break;
+    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
+    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
+    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
+    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
+    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
+    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
+    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
+    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
+    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
+    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
+    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
+    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
+    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
+    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
+    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
+    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
+    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
+    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
+    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
+    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
+    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
+    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
+    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
+    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
+    default:                zName = "SQLITE_Unknown";     break;
+  }
+  Tcl_AppendResult(interp, zName, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: client_error  ID
+**
+** Wait on the most recent operation to complete, then return the
+** error string.
+*/
+static int tcl_client_error(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  Tcl_AppendResult(interp, threadset[i].zErr, 0);
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to compile an SQL statement.
+*/
+static void do_compile(Thread *p){
+  if( p->db==0 ){
+    p->zErr = p->zStaticErr = "no database is open";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  if( p->pStmt ){
+    sqlite3_client_finalize(p->pStmt);
+    p->pStmt = 0;
+  }
+  p->rc = sqlite3_client_prepare(p->db, p->zArg, -1, &p->pStmt, 0);
+}
+
+/*
+** Usage: client_compile ID SQL
+**
+** Compile a new virtual machine.
+*/
+static int tcl_client_compile(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID SQL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  threadset[i].xOp = do_compile;
+  sqlite3_free(threadset[i].zArg);
+  threadset[i].zArg = sqlite3StrDup(argv[2]);
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to step the virtual machine.
+*/
+static void do_step(Thread *p){
+  int i;
+  if( p->pStmt==0 ){
+    p->zErr = p->zStaticErr = "no virtual machine available";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  p->rc = sqlite3_client_step(p->pStmt);
+  if( p->rc==SQLITE_ROW ){
+    p->argc = sqlite3_column_count(p->pStmt);
+    for(i=0; i<sqlite3_data_count(p->pStmt); i++){
+      p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);
+    }
+    for(i=0; i<p->argc; i++){
+      p->colv[i] = sqlite3_column_name(p->pStmt, i);
+    }
+  }
+}
+
+/*
+** Usage: client_step ID
+**
+** Advance the virtual machine by one step
+*/
+static int tcl_client_step(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " IDL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  threadset[i].xOp = do_step;
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to finalize a virtual machine.
+*/
+static void do_finalize(Thread *p){
+  if( p->pStmt==0 ){
+    p->zErr = p->zStaticErr = "no virtual machine available";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  p->rc = sqlite3_client_finalize(p->pStmt);
+  p->pStmt = 0;
+}
+
+/*
+** Usage: client_finalize ID
+**
+** Finalize the virtual machine.
+*/
+static int tcl_client_finalize(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " IDL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  threadset[i].xOp = do_finalize;
+  sqlite3_free(threadset[i].zArg);
+  threadset[i].zArg = 0;
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** This procedure runs in the thread to reset a virtual machine.
+*/
+static void do_reset(Thread *p){
+  if( p->pStmt==0 ){
+    p->zErr = p->zStaticErr = "no virtual machine available";
+    p->rc = SQLITE_ERROR;
+    return;
+  }
+  p->rc = sqlite3_client_reset(p->pStmt);
+  p->pStmt = 0;
+}
+
+/*
+** Usage: client_reset ID
+**
+** Finalize the virtual machine.
+*/
+static int tcl_client_reset(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " IDL", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  threadset[i].xOp = do_reset;
+  sqlite3_free(threadset[i].zArg);
+  threadset[i].zArg = 0;
+  threadset[i].opnum++;
+  return TCL_OK;
+}
+
+/*
+** Usage: client_swap ID ID
+**
+** Interchange the sqlite* pointer between two threads.
+*/
+static int tcl_client_swap(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i, j;
+  sqlite3 *temp;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID1 ID2", 0);
+    return TCL_ERROR;
+  }
+  i = parse_client_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[i]);
+  j = parse_client_id(interp, argv[2]);
+  if( j<0 ) return TCL_ERROR;
+  if( !threadset[j].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  client_wait(&threadset[j]);
+  temp = threadset[i].db;
+  threadset[i].db = threadset[j].db;
+  threadset[j].db = temp;
+  return TCL_OK;
+}
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest7_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_CmdProc *xProc;
+  } aCmd[] = {
+     { "client_create",     (Tcl_CmdProc*)tcl_client_create     },
+     { "client_wait",       (Tcl_CmdProc*)tcl_client_wait       },
+     { "client_halt",       (Tcl_CmdProc*)tcl_client_halt       },
+     { "client_argc",       (Tcl_CmdProc*)tcl_client_argc       },
+     { "client_argv",       (Tcl_CmdProc*)tcl_client_argv       },
+     { "client_colname",    (Tcl_CmdProc*)tcl_client_colname    },
+     { "client_result",     (Tcl_CmdProc*)tcl_client_result     },
+     { "client_error",      (Tcl_CmdProc*)tcl_client_error      },
+     { "client_compile",    (Tcl_CmdProc*)tcl_client_compile    },
+     { "client_step",       (Tcl_CmdProc*)tcl_client_step       },
+     { "client_reset",      (Tcl_CmdProc*)tcl_client_reset      },
+     { "client_finalize",   (Tcl_CmdProc*)tcl_client_finalize   },
+     { "client_swap",       (Tcl_CmdProc*)tcl_client_swap       },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  return TCL_OK;
+}
+#else
+int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; }
+#endif /* OS_UNIX */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test8.c b/client/src/thirdparty/sqlite-3.4.2/src/test8.c
new file mode 100644
index 0000000..944ac68
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test8.c
@@ -0,0 +1,1218 @@
+/*
+** 2006 June 10
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the virtual table interfaces.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test8.c,v 1.59 2008/01/22 21:30:53 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+
+typedef struct echo_vtab echo_vtab;
+typedef struct echo_cursor echo_cursor;
+
+/*
+** The test module defined in this file uses four global Tcl variables to
+** commicate with test-scripts:
+**
+**     $::echo_module
+**     $::echo_module_sync_fail
+**     $::echo_module_begin_fail
+**     $::echo_module_cost
+**
+** The variable ::echo_module is a list. Each time one of the following
+** methods is called, one or more elements are appended to the list.
+** This is used for automated testing of virtual table modules.
+**
+** The ::echo_module_sync_fail variable is set by test scripts and read
+** by code in this file. If it is set to the name of a real table in the
+** the database, then all xSync operations on echo virtual tables that
+** use the named table as a backing store will fail.
+*/
+
+/* 
+** An echo virtual-table object.
+**
+** echo.vtab.aIndex is an array of booleans. The nth entry is true if 
+** the nth column of the real table is the left-most column of an index
+** (implicit or otherwise). In other words, if SQLite can optimize
+** a query like "SELECT * FROM real_table WHERE col = ?".
+**
+** Member variable aCol[] contains copies of the column names of the real
+** table.
+*/
+struct echo_vtab {
+  sqlite3_vtab base;
+  Tcl_Interp *interp;     /* Tcl interpreter containing debug variables */
+  sqlite3 *db;            /* Database connection */
+
+  int isPattern;
+  char *zThis;            /* Name of the echo table */
+  char *zTableName;       /* Name of the real table */
+  char *zLogName;         /* Name of the log table */
+  int nCol;               /* Number of columns in the real table */
+  int *aIndex;            /* Array of size nCol. True if column has an index */
+  char **aCol;            /* Array of size nCol. Column names */
+};
+
+/* An echo cursor object */
+struct echo_cursor {
+  sqlite3_vtab_cursor base;
+  sqlite3_stmt *pStmt;
+};
+
+/*
+** 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.
+**
+** Examples:
+**
+**     "abc"   becomes   abc
+**     'xyz'   becomes   xyz
+**     [pqr]   becomes   pqr
+**     `mno`   becomes   mno
+*/
+static void dequoteString(char *z){
+  int quote;
+  int i, j;
+  if( z==0 ) return;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return;
+  }
+  for(i=1, j=0; z[i]; i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        z[j++] = 0;
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+}
+
+/*
+** Retrieve the column names for the table named zTab via database
+** connection db. SQLITE_OK is returned on success, or an sqlite error
+** code otherwise.
+**
+** If successful, the number of columns is written to *pnCol. *paCol is
+** set to point at sqlite3_malloc()'d space containing the array of
+** nCol column names. The caller is responsible for calling sqlite3_free
+** on *paCol.
+*/
+static int getColumnNames(
+  sqlite3 *db, 
+  const char *zTab,
+  char ***paCol, 
+  int *pnCol
+){
+  char **aCol = 0;
+  char *zSql;
+  sqlite3_stmt *pStmt = 0;
+  int rc = SQLITE_OK;
+  int nCol = 0;
+
+  /* Prepare the statement "SELECT * FROM <tbl>". The column names
+  ** of the result set of the compiled SELECT will be the same as
+  ** the column names of table <tbl>.
+  */
+  zSql = sqlite3_mprintf("SELECT * FROM %Q", zTab);
+  if( !zSql ){
+    rc = SQLITE_NOMEM;
+    goto out;
+  }
+  rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
+  sqlite3_free(zSql);
+
+  if( rc==SQLITE_OK ){
+    int ii;
+    int nBytes;
+    char *zSpace;
+    nCol = sqlite3_column_count(pStmt);
+
+    /* Figure out how much space to allocate for the array of column names 
+    ** (including space for the strings themselves). Then allocate it.
+    */
+    nBytes = sizeof(char *) * nCol;
+    for(ii=0; ii<nCol; ii++){
+      nBytes += (strlen(sqlite3_column_name(pStmt, ii)) + 1);
+    }
+    aCol = (char **)sqlite3MallocZero(nBytes);
+    if( !aCol ){
+      rc = SQLITE_NOMEM;
+      goto out;
+    }
+
+    /* Copy the column names into the allocated space and set up the
+    ** pointers in the aCol[] array.
+    */
+    zSpace = (char *)(&aCol[nCol]);
+    for(ii=0; ii<nCol; ii++){
+      aCol[ii] = zSpace;
+      zSpace += sprintf(zSpace, "%s", sqlite3_column_name(pStmt, ii));
+      zSpace++;
+    }
+    assert( (zSpace-nBytes)==(char *)aCol );
+  }
+
+  *paCol = aCol;
+  *pnCol = nCol;
+
+out:
+  sqlite3_finalize(pStmt);
+  return rc;
+}
+
+/*
+** Parameter zTab is the name of a table in database db with nCol 
+** columns. This function allocates an array of integers nCol in 
+** size and populates it according to any implicit or explicit 
+** indices on table zTab.
+**
+** If successful, SQLITE_OK is returned and *paIndex set to point 
+** at the allocated array. Otherwise, an error code is returned.
+**
+** See comments associated with the member variable aIndex above 
+** "struct echo_vtab" for details of the contents of the array.
+*/
+static int getIndexArray(
+  sqlite3 *db,             /* Database connection */
+  const char *zTab,        /* Name of table in database db */
+  int nCol,
+  int **paIndex
+){
+  sqlite3_stmt *pStmt = 0;
+  int *aIndex = 0;
+  int rc;
+  char *zSql;
+
+  /* Allocate space for the index array */
+  aIndex = (int *)sqlite3MallocZero(sizeof(int) * nCol);
+  if( !aIndex ){
+    rc = SQLITE_NOMEM;
+    goto get_index_array_out;
+  }
+
+  /* Compile an sqlite pragma to loop through all indices on table zTab */
+  zSql = sqlite3MPrintf(0, "PRAGMA index_list(%s)", zTab);
+  if( !zSql ){
+    rc = SQLITE_NOMEM;
+    goto get_index_array_out;
+  }
+  rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
+  sqlite3_free(zSql);
+
+  /* For each index, figure out the left-most column and set the 
+  ** corresponding entry in aIndex[] to 1.
+  */
+  while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
+    const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
+    sqlite3_stmt *pStmt2 = 0;
+    zSql = sqlite3MPrintf(0, "PRAGMA index_info(%s)", zIdx);
+    if( !zSql ){
+      rc = SQLITE_NOMEM;
+      goto get_index_array_out;
+    }
+    rc = sqlite3_prepare(db, zSql, -1, &pStmt2, 0);
+    sqlite3_free(zSql);
+    if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
+      int cid = sqlite3_column_int(pStmt2, 1);
+      assert( cid>=0 && cid<nCol );
+      aIndex[cid] = 1;
+    }
+    if( pStmt2 ){
+      rc = sqlite3_finalize(pStmt2);
+    }
+    if( rc!=SQLITE_OK ){
+      goto get_index_array_out;
+    }
+  }
+
+
+get_index_array_out:
+  if( pStmt ){
+    int rc2 = sqlite3_finalize(pStmt);
+    if( rc==SQLITE_OK ){
+      rc = rc2;
+    }
+  }
+  if( rc!=SQLITE_OK ){
+    sqlite3_free(aIndex);
+    aIndex = 0;
+  }
+  *paIndex = aIndex;
+  return rc;
+}
+
+/*
+** Global Tcl variable $echo_module is a list. This routine appends
+** the string element zArg to that list in interpreter interp.
+*/
+static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
+  int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
+  Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
+}
+
+/*
+** This function is called from within the echo-modules xCreate and
+** xConnect methods. The argc and argv arguments are copies of those 
+** passed to the calling method. This function is responsible for
+** calling sqlite3_declare_vtab() to declare the schema of the virtual
+** table being created or connected.
+**
+** If the constructor was passed just one argument, i.e.:
+**
+**   CREATE TABLE t1 AS echo(t2);
+**
+** Then t2 is assumed to be the name of a *real* database table. The
+** schema of the virtual table is declared by passing a copy of the 
+** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
+** Hence, the virtual table should have exactly the same column names and 
+** types as the real table.
+*/
+static int echoDeclareVtab(
+  echo_vtab *pVtab, 
+  sqlite3 *db 
+){
+  int rc = SQLITE_OK;
+
+  if( pVtab->zTableName ){
+    sqlite3_stmt *pStmt = 0;
+    rc = sqlite3_prepare(db, 
+        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
+        -1, &pStmt, 0);
+    if( rc==SQLITE_OK ){
+      sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
+      if( sqlite3_step(pStmt)==SQLITE_ROW ){
+        int rc2;
+        const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
+        rc = sqlite3_declare_vtab(db, zCreateTable);
+        rc2 = sqlite3_finalize(pStmt);
+        if( rc==SQLITE_OK ){
+          rc = rc2;
+        }
+      } else {
+        rc = sqlite3_finalize(pStmt);
+        if( rc==SQLITE_OK ){ 
+          rc = SQLITE_ERROR;
+        }
+      }
+      if( rc==SQLITE_OK ){
+        rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
+      }
+      if( rc==SQLITE_OK ){
+        rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
+      }
+    }
+  }
+
+  return rc;
+}
+
+/*
+** This function frees all runtime structures associated with the virtual
+** table pVtab.
+*/
+static int echoDestructor(sqlite3_vtab *pVtab){
+  echo_vtab *p = (echo_vtab*)pVtab;
+  sqlite3_free(p->aIndex);
+  sqlite3_free(p->aCol);
+  sqlite3_free(p->zThis);
+  sqlite3_free(p->zTableName);
+  sqlite3_free(p->zLogName);
+  sqlite3_free(p);
+  return 0;
+}
+
+typedef struct EchoModule EchoModule;
+struct EchoModule {
+  Tcl_Interp *interp;
+};
+
+/*
+** This function is called to do the work of the xConnect() method -
+** to allocate the required in-memory structures for a newly connected
+** virtual table.
+*/
+static int echoConstructor(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  int rc;
+  int i;
+  echo_vtab *pVtab;
+
+  /* Allocate the sqlite3_vtab/echo_vtab structure itself */
+  pVtab = sqlite3MallocZero( sizeof(*pVtab) );
+  if( !pVtab ){
+    return SQLITE_NOMEM;
+  }
+  pVtab->interp = ((EchoModule *)pAux)->interp;
+  pVtab->db = db;
+
+  /* Allocate echo_vtab.zThis */
+  pVtab->zThis = sqlite3MPrintf(0, "%s", argv[2]);
+  if( !pVtab->zThis ){
+    echoDestructor((sqlite3_vtab *)pVtab);
+    return SQLITE_NOMEM;
+  }
+
+  /* Allocate echo_vtab.zTableName */
+  if( argc>3 ){
+    pVtab->zTableName = sqlite3MPrintf(0, "%s", argv[3]);
+    dequoteString(pVtab->zTableName);
+    if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
+      char *z = sqlite3MPrintf(0, "%s%s", argv[2], &(pVtab->zTableName[1]));
+      sqlite3_free(pVtab->zTableName);
+      pVtab->zTableName = z;
+      pVtab->isPattern = 1;
+    }
+    if( !pVtab->zTableName ){
+      echoDestructor((sqlite3_vtab *)pVtab);
+      return SQLITE_NOMEM;
+    }
+  }
+
+  /* Log the arguments to this function to Tcl var ::echo_module */
+  for(i=0; i<argc; i++){
+    appendToEchoModule(pVtab->interp, argv[i]);
+  }
+
+  /* Invoke sqlite3_declare_vtab and set up other members of the echo_vtab
+  ** structure. If an error occurs, delete the sqlite3_vtab structure and
+  ** return an error code.
+  */
+  rc = echoDeclareVtab(pVtab, db);
+  if( rc!=SQLITE_OK ){
+    echoDestructor((sqlite3_vtab *)pVtab);
+    return rc;
+  }
+
+  /* Success. Set *ppVtab and return */
+  *ppVtab = &pVtab->base;
+  return SQLITE_OK;
+}
+
+/* 
+** Echo virtual table module xCreate method.
+*/
+static int echoCreate(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  int rc = SQLITE_OK;
+  appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");
+  rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
+
+  /* If there were two arguments passed to the module at the SQL level 
+  ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then 
+  ** the second argument is used as a table name. Attempt to create
+  ** such a table with a single column, "logmsg". This table will
+  ** be used to log calls to the xUpdate method. It will be deleted
+  ** when the virtual table is DROPed.
+  **
+  ** Note: The main point of this is to test that we can drop tables
+  ** from within an xDestroy method call.
+  */
+  if( rc==SQLITE_OK && argc==5 ){
+    char *zSql;
+    echo_vtab *pVtab = *(echo_vtab **)ppVtab;
+    pVtab->zLogName = sqlite3MPrintf(0, "%s", argv[4]);
+    zSql = sqlite3MPrintf(0, "CREATE TABLE %Q(logmsg)", pVtab->zLogName);
+    rc = sqlite3_exec(db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+    if( rc!=SQLITE_OK ){
+      *pzErr = sqlite3StrDup(sqlite3_errmsg(db));
+    }
+  }
+
+  if( *ppVtab && rc!=SQLITE_OK ){
+    echoDestructor(*ppVtab);
+    *ppVtab = 0;
+  }
+
+  return rc;
+}
+
+/* 
+** Echo virtual table module xConnect method.
+*/
+static int echoConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  appendToEchoModule(((EchoModule *)pAux)->interp, "xConnect");
+  return echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
+}
+
+/* 
+** Echo virtual table module xDisconnect method.
+*/
+static int echoDisconnect(sqlite3_vtab *pVtab){
+  appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
+  return echoDestructor(pVtab);
+}
+
+/* 
+** Echo virtual table module xDestroy method.
+*/
+static int echoDestroy(sqlite3_vtab *pVtab){
+  int rc = SQLITE_OK;
+  echo_vtab *p = (echo_vtab *)pVtab;
+  appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
+
+  /* Drop the "log" table, if one exists (see echoCreate() for details) */
+  if( p && p->zLogName ){
+    char *zSql;
+    zSql = sqlite3MPrintf(0, "DROP TABLE %Q", p->zLogName);
+    rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+  }
+
+  if( rc==SQLITE_OK ){
+    rc = echoDestructor(pVtab);
+  }
+  return rc;
+}
+
+/* 
+** Echo virtual table module xOpen method.
+*/
+static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  echo_cursor *pCur;
+  pCur = sqlite3MallocZero(sizeof(echo_cursor));
+  *ppCursor = (sqlite3_vtab_cursor *)pCur;
+  return (pCur ? SQLITE_OK : SQLITE_NOMEM);
+}
+
+/* 
+** Echo virtual table module xClose method.
+*/
+static int echoClose(sqlite3_vtab_cursor *cur){
+  int rc;
+  echo_cursor *pCur = (echo_cursor *)cur;
+  sqlite3_stmt *pStmt = pCur->pStmt;
+  pCur->pStmt = 0;
+  sqlite3_free(pCur);
+  rc = sqlite3_finalize(pStmt);
+  return rc;
+}
+
+/*
+** Return non-zero if the cursor does not currently point to a valid record
+** (i.e if the scan has finished), or zero otherwise.
+*/
+static int echoEof(sqlite3_vtab_cursor *cur){
+  return (((echo_cursor *)cur)->pStmt ? 0 : 1);
+}
+
+/* 
+** Echo virtual table module xNext method.
+*/
+static int echoNext(sqlite3_vtab_cursor *cur){
+  int rc = SQLITE_OK;
+  echo_cursor *pCur = (echo_cursor *)cur;
+
+  if( pCur->pStmt ){
+    rc = sqlite3_step(pCur->pStmt);
+    if( rc==SQLITE_ROW ){
+      rc = SQLITE_OK;
+    }else{
+      rc = sqlite3_finalize(pCur->pStmt);
+      pCur->pStmt = 0;
+    }
+  }
+
+  return rc;
+}
+
+/* 
+** Echo virtual table module xColumn method.
+*/
+static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
+  int iCol = i + 1;
+  sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
+  if( !pStmt ){
+    sqlite3_result_null(ctx);
+  }else{
+    assert( sqlite3_data_count(pStmt)>iCol );
+    sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
+  }
+  return SQLITE_OK;
+}
+
+/* 
+** Echo virtual table module xRowid method.
+*/
+static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
+  sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
+  *pRowid = sqlite3_column_int64(pStmt, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Compute a simple hash of the null terminated string zString.
+**
+** This module uses only sqlite3_index_info.idxStr, not 
+** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
+** in echoBestIndex(), idxNum is set to the corresponding hash value.
+** In echoFilter(), code assert()s that the supplied idxNum value is
+** indeed the hash of the supplied idxStr.
+*/
+static int hashString(const char *zString){
+  int val = 0;
+  int ii;
+  for(ii=0; zString[ii]; ii++){
+    val = (val << 3) + (int)zString[ii];
+  }
+  return val;
+}
+
+/* 
+** Echo virtual table module xFilter method.
+*/
+static int echoFilter(
+  sqlite3_vtab_cursor *pVtabCursor, 
+  int idxNum, const char *idxStr,
+  int argc, sqlite3_value **argv
+){
+  int rc;
+  int i;
+
+  echo_cursor *pCur = (echo_cursor *)pVtabCursor;
+  echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
+  sqlite3 *db = pVtab->db;
+
+  /* Check that idxNum matches idxStr */
+  assert( idxNum==hashString(idxStr) );
+
+  /* Log arguments to the ::echo_module Tcl variable */
+  appendToEchoModule(pVtab->interp, "xFilter");
+  appendToEchoModule(pVtab->interp, idxStr);
+  for(i=0; i<argc; i++){
+    appendToEchoModule(pVtab->interp, (const char*)sqlite3_value_text(argv[i]));
+  }
+
+  sqlite3_finalize(pCur->pStmt);
+  pCur->pStmt = 0;
+
+  /* Prepare the SQL statement created by echoBestIndex and bind the
+  ** runtime parameters passed to this function to it.
+  */
+  rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
+  assert( pCur->pStmt || rc!=SQLITE_OK );
+  for(i=0; rc==SQLITE_OK && i<argc; i++){
+    sqlite3_bind_value(pCur->pStmt, i+1, argv[i]);
+  }
+
+  /* If everything was successful, advance to the first row of the scan */
+  if( rc==SQLITE_OK ){
+    rc = echoNext(pVtabCursor);
+  }
+
+  return rc;
+}
+
+
+/*
+** A helper function used by echoUpdate() and echoBestIndex() for
+** manipulating strings in concert with the sqlite3_mprintf() function.
+**
+** Parameter pzStr points to a pointer to a string allocated with
+** sqlite3_mprintf. The second parameter, zAppend, points to another
+** string. The two strings are concatenated together and *pzStr
+** set to point at the result. The initial buffer pointed to by *pzStr
+** is deallocated via sqlite3_free().
+**
+** If the third argument, doFree, is true, then sqlite3_free() is
+** also called to free the buffer pointed to by zAppend.
+*/
+static void string_concat(char **pzStr, char *zAppend, int doFree, int *pRc){
+  char *zIn = *pzStr;
+  if( !zAppend && doFree && *pRc==SQLITE_OK ){
+    *pRc = SQLITE_NOMEM;
+  }
+  if( *pRc!=SQLITE_OK ){
+    sqlite3_free(zIn);
+    zIn = 0;
+  }else{
+    if( zIn ){
+      char *zTemp = zIn;
+      zIn = sqlite3_mprintf("%s%s", zIn, zAppend);
+      sqlite3_free(zTemp);
+    }else{
+      zIn = sqlite3_mprintf("%s", zAppend);
+    }
+    if( !zIn ){
+      *pRc = SQLITE_NOMEM;
+    }
+  }
+  *pzStr = zIn;
+  if( doFree ){
+    sqlite3_free(zAppend);
+  }
+}
+
+/*
+** The echo module implements the subset of query constraints and sort
+** orders that may take advantage of SQLite indices on the underlying
+** real table. For example, if the real table is declared as:
+**
+**     CREATE TABLE real(a, b, c);
+**     CREATE INDEX real_index ON real(b);
+**
+** then the echo module handles WHERE or ORDER BY clauses that refer
+** to the column "b", but not "a" or "c". If a multi-column index is
+** present, only its left most column is considered. 
+**
+** This xBestIndex method encodes the proposed search strategy as
+** an SQL query on the real table underlying the virtual echo module 
+** table and stores the query in sqlite3_index_info.idxStr. The SQL
+** statement is of the form:
+**
+**   SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
+**
+** where the <where-clause> and <order-by-clause> are determined
+** by the contents of the structure pointed to by the pIdxInfo argument.
+*/
+static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
+  int ii;
+  char *zQuery = 0;
+  char *zNew;
+  int nArg = 0;
+  const char *zSep = "WHERE";
+  echo_vtab *pVtab = (echo_vtab *)tab;
+  sqlite3_stmt *pStmt = 0;
+  Tcl_Interp *interp = pVtab->interp;
+
+  int nRow;
+  int useIdx = 0;
+  int rc = SQLITE_OK;
+  int useCost = 0;
+  double cost;
+
+  /* Determine the number of rows in the table and store this value in local
+  ** variable nRow. The 'estimated-cost' of the scan will be the number of
+  ** rows in the table for a linear scan, or the log (base 2) of the 
+  ** number of rows if the proposed scan uses an index.  
+  */
+  if( Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY) ){
+    cost = atof(Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY));
+    useCost = 1;
+  } else {
+    zQuery = sqlite3_mprintf("SELECT count(*) FROM %Q", pVtab->zTableName);
+    if( !zQuery ){
+      return SQLITE_NOMEM;
+    }
+    rc = sqlite3_prepare(pVtab->db, zQuery, -1, &pStmt, 0);
+    sqlite3_free(zQuery);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+    sqlite3_step(pStmt);
+    nRow = sqlite3_column_int(pStmt, 0);
+    rc = sqlite3_finalize(pStmt);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+  }
+
+  zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
+  if( !zQuery ){
+    return SQLITE_NOMEM;
+  }
+  for(ii=0; ii<pIdxInfo->nConstraint; ii++){
+    const struct sqlite3_index_constraint *pConstraint;
+    struct sqlite3_index_constraint_usage *pUsage;
+    int iCol;
+
+    pConstraint = &pIdxInfo->aConstraint[ii];
+    pUsage = &pIdxInfo->aConstraintUsage[ii];
+
+    iCol = pConstraint->iColumn;
+    if( pVtab->aIndex[iCol] ){
+      char *zCol = pVtab->aCol[iCol];
+      char *zOp = 0;
+      useIdx = 1;
+      if( iCol<0 ){
+        zCol = "rowid";
+      }
+      switch( pConstraint->op ){
+        case SQLITE_INDEX_CONSTRAINT_EQ:
+          zOp = "="; break;
+        case SQLITE_INDEX_CONSTRAINT_LT:
+          zOp = "<"; break;
+        case SQLITE_INDEX_CONSTRAINT_GT:
+          zOp = ">"; break;
+        case SQLITE_INDEX_CONSTRAINT_LE:
+          zOp = "<="; break;
+        case SQLITE_INDEX_CONSTRAINT_GE:
+          zOp = ">="; break;
+        case SQLITE_INDEX_CONSTRAINT_MATCH:
+          zOp = "LIKE"; break;
+      }
+      if( zOp[0]=='L' ){
+        zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')", 
+                               zSep, zCol);
+      } else {
+        zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zCol, zOp);
+      }
+      string_concat(&zQuery, zNew, 1, &rc);
+
+      zSep = "AND";
+      pUsage->argvIndex = ++nArg;
+      pUsage->omit = 1;
+    }
+  }
+
+  /* If there is only one term in the ORDER BY clause, and it is
+  ** on a column that this virtual table has an index for, then consume 
+  ** the ORDER BY clause.
+  */
+  if( pIdxInfo->nOrderBy==1 && pVtab->aIndex[pIdxInfo->aOrderBy->iColumn] ){
+    int iCol = pIdxInfo->aOrderBy->iColumn;
+    char *zCol = pVtab->aCol[iCol];
+    char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
+    if( iCol<0 ){
+      zCol = "rowid";
+    }
+    zNew = sqlite3_mprintf(" ORDER BY %s %s", zCol, zDir);
+    string_concat(&zQuery, zNew, 1, &rc);
+    pIdxInfo->orderByConsumed = 1;
+  }
+
+  appendToEchoModule(pVtab->interp, "xBestIndex");;
+  appendToEchoModule(pVtab->interp, zQuery);
+
+  if( !zQuery ){
+    return rc;
+  }
+  pIdxInfo->idxNum = hashString(zQuery);
+  pIdxInfo->idxStr = zQuery;
+  pIdxInfo->needToFreeIdxStr = 1;
+  if (useCost) {
+    pIdxInfo->estimatedCost = cost;
+  } else if( useIdx ){
+    /* Approximation of log2(nRow). */
+    for( ii=0; ii<(sizeof(int)*8); ii++ ){
+      if( nRow & (1<<ii) ){
+        pIdxInfo->estimatedCost = (double)ii;
+      }
+    }
+  } else {
+    pIdxInfo->estimatedCost = (double)nRow;
+  }
+  return rc;
+}
+
+/*
+** The xUpdate method for echo module virtual tables.
+** 
+**    apData[0]  apData[1]  apData[2..]
+**
+**    INTEGER                              DELETE            
+**
+**    INTEGER    NULL       (nCol args)    UPDATE (do not set rowid)
+**    INTEGER    INTEGER    (nCol args)    UPDATE (with SET rowid = <arg1>)
+**
+**    NULL       NULL       (nCol args)    INSERT INTO (automatic rowid value)
+**    NULL       INTEGER    (nCol args)    INSERT (incl. rowid value)
+**
+*/
+int echoUpdate(
+  sqlite3_vtab *tab, 
+  int nData, 
+  sqlite3_value **apData, 
+  sqlite_int64 *pRowid
+){
+  echo_vtab *pVtab = (echo_vtab *)tab;
+  sqlite3 *db = pVtab->db;
+  int rc = SQLITE_OK;
+
+  sqlite3_stmt *pStmt;
+  char *z = 0;               /* SQL statement to execute */
+  int bindArgZero = 0;       /* True to bind apData[0] to sql var no. nData */
+  int bindArgOne = 0;        /* True to bind apData[1] to sql var no. 1 */
+  int i;                     /* Counter variable used by for loops */
+
+  assert( nData==pVtab->nCol+2 || nData==1 );
+
+  /* If apData[0] is an integer and nData>1 then do an UPDATE */
+  if( nData>1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
+    char *zSep = " SET";
+    z = sqlite3_mprintf("UPDATE %Q", pVtab->zTableName);
+    if( !z ){
+      rc = SQLITE_NOMEM;
+    }
+
+    bindArgOne = (apData[1] && sqlite3_value_type(apData[1])==SQLITE_INTEGER);
+    bindArgZero = 1;
+
+    if( bindArgOne ){
+       string_concat(&z, " SET rowid=?1 ", 0, &rc);
+       zSep = ",";
+    }
+    for(i=2; i<nData; i++){
+      if( apData[i]==0 ) continue;
+      string_concat(&z, sqlite3_mprintf(
+          "%s %Q=?%d", zSep, pVtab->aCol[i-2], i), 1, &rc);
+      zSep = ",";
+    }
+    string_concat(&z, sqlite3_mprintf(" WHERE rowid=?%d", nData), 1, &rc);
+  }
+
+  /* If apData[0] is an integer and nData==1 then do a DELETE */
+  else if( nData==1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
+    z = sqlite3_mprintf("DELETE FROM %Q WHERE rowid = ?1", pVtab->zTableName);
+    if( !z ){
+      rc = SQLITE_NOMEM;
+    }
+    bindArgZero = 1;
+  }
+
+  /* If the first argument is NULL and there are more than two args, INSERT */
+  else if( nData>2 && sqlite3_value_type(apData[0])==SQLITE_NULL ){
+    int ii;
+    char *zInsert = 0;
+    char *zValues = 0;
+  
+    zInsert = sqlite3_mprintf("INSERT INTO %Q (", pVtab->zTableName);
+    if( !zInsert ){
+      rc = SQLITE_NOMEM;
+    }
+    if( sqlite3_value_type(apData[1])==SQLITE_INTEGER ){
+      bindArgOne = 1;
+      zValues = sqlite3_mprintf("?");
+      string_concat(&zInsert, "rowid", 0, &rc);
+    }
+
+    assert((pVtab->nCol+2)==nData);
+    for(ii=2; ii<nData; ii++){
+      string_concat(&zInsert, 
+          sqlite3_mprintf("%s%Q", zValues?", ":"", pVtab->aCol[ii-2]), 1, &rc);
+      string_concat(&zValues, 
+          sqlite3_mprintf("%s?%d", zValues?", ":"", ii), 1, &rc);
+    }
+
+    string_concat(&z, zInsert, 1, &rc);
+    string_concat(&z, ") VALUES(", 0, &rc);
+    string_concat(&z, zValues, 1, &rc);
+    string_concat(&z, ")", 0, &rc);
+  }
+
+  /* Anything else is an error */
+  else{
+    assert(0);
+    return SQLITE_ERROR;
+  }
+
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_prepare(db, z, -1, &pStmt, 0);
+  }
+  assert( rc!=SQLITE_OK || pStmt );
+  sqlite3_free(z);
+  if( rc==SQLITE_OK ) {
+    if( bindArgZero ){
+      sqlite3_bind_value(pStmt, nData, apData[0]);
+    }
+    if( bindArgOne ){
+      sqlite3_bind_value(pStmt, 1, apData[1]);
+    }
+    for(i=2; i<nData; i++){
+      if( apData[i] ) sqlite3_bind_value(pStmt, i, apData[i]);
+    }
+    sqlite3_step(pStmt);
+    rc = sqlite3_finalize(pStmt);
+  }
+
+  if( pRowid && rc==SQLITE_OK ){
+    *pRowid = sqlite3_last_insert_rowid(db);
+  }
+
+  return rc;
+}
+
+/*
+** xBegin, xSync, xCommit and xRollback callbacks for echo module
+** virtual tables. Do nothing other than add the name of the callback
+** to the $::echo_module Tcl variable.
+*/
+static int echoTransactionCall(sqlite3_vtab *tab, const char *zCall){
+  char *z;
+  echo_vtab *pVtab = (echo_vtab *)tab;
+  z = sqlite3_mprintf("echo(%s)", pVtab->zTableName);
+  appendToEchoModule(pVtab->interp, zCall);
+  appendToEchoModule(pVtab->interp, z);
+  sqlite3_free(z);
+  return (z?SQLITE_OK:SQLITE_NOMEM);
+}
+static int echoBegin(sqlite3_vtab *tab){
+  int rc;
+  echo_vtab *pVtab = (echo_vtab *)tab;
+  Tcl_Interp *interp = pVtab->interp;
+  const char *zVal; 
+
+  rc = echoTransactionCall(tab, "xBegin");
+
+  if( rc==SQLITE_OK ){
+    /* Check if the $::echo_module_begin_fail variable is defined. If it is,
+    ** and it is set to the name of the real table underlying this virtual
+    ** echo module table, then cause this xSync operation to fail.
+    */
+    zVal = Tcl_GetVar(interp, "echo_module_begin_fail", TCL_GLOBAL_ONLY);
+    if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
+      rc = SQLITE_ERROR;
+    }
+  }
+  return rc;
+}
+static int echoSync(sqlite3_vtab *tab){
+  int rc;
+  echo_vtab *pVtab = (echo_vtab *)tab;
+  Tcl_Interp *interp = pVtab->interp;
+  const char *zVal; 
+
+  rc = echoTransactionCall(tab, "xSync");
+
+  if( rc==SQLITE_OK ){
+    /* Check if the $::echo_module_sync_fail variable is defined. If it is,
+    ** and it is set to the name of the real table underlying this virtual
+    ** echo module table, then cause this xSync operation to fail.
+    */
+    zVal = Tcl_GetVar(interp, "echo_module_sync_fail", TCL_GLOBAL_ONLY);
+    if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
+      rc = -1;
+    }
+  }
+  return rc;
+}
+static int echoCommit(sqlite3_vtab *tab){
+  int rc;
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 1);
+  rc = echoTransactionCall(tab, "xCommit");
+  sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
+  return rc;
+}
+static int echoRollback(sqlite3_vtab *tab){
+  return echoTransactionCall(tab, "xRollback");
+}
+
+/*
+** Implementation of "GLOB" function on the echo module.  Pass
+** all arguments to the ::echo_glob_overload procedure of TCL
+** and return the result of that procedure as a string.
+*/
+static void overloadedGlobFunction(
+  sqlite3_context *pContext,
+  int nArg,
+  sqlite3_value **apArg
+){
+  Tcl_Interp *interp = sqlite3_user_data(pContext);
+  Tcl_DString str;
+  int i;
+  int rc;
+  Tcl_DStringInit(&str);
+  Tcl_DStringAppendElement(&str, "::echo_glob_overload");
+  for(i=0; i<nArg; i++){
+    Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i]));
+  }
+  rc = Tcl_Eval(interp, Tcl_DStringValue(&str));
+  Tcl_DStringFree(&str);
+  if( rc ){
+    sqlite3_result_error(pContext, Tcl_GetStringResult(interp), -1);
+  }else{
+    sqlite3_result_text(pContext, Tcl_GetStringResult(interp),
+                        -1, SQLITE_TRANSIENT);
+  }
+  Tcl_ResetResult(interp);
+}
+
+/*
+** This is the xFindFunction implementation for the echo module.
+** SQLite calls this routine when the first argument of a function
+** is a column of an echo virtual table.  This routine can optionally
+** override the implementation of that function.  It will choose to
+** do so if the function is named "glob", and a TCL command named
+** ::echo_glob_overload exists.
+*/
+static int echoFindFunction(
+  sqlite3_vtab *vtab,
+  int nArg,
+  const char *zFuncName,
+  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
+  void **ppArg
+){
+  echo_vtab *pVtab = (echo_vtab *)vtab;
+  Tcl_Interp *interp = pVtab->interp;
+  Tcl_CmdInfo info;
+  if( strcmp(zFuncName,"glob")!=0 ){
+    return 0;
+  }
+  if( Tcl_GetCommandInfo(interp, "::echo_glob_overload", &info)==0 ){
+    return 0;
+  }
+  *pxFunc = overloadedGlobFunction;
+  *ppArg = interp;
+  return 1;
+}
+
+static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
+  int rc = SQLITE_OK;
+  echo_vtab *p = (echo_vtab *)vtab;
+
+  if( p->isPattern ){
+    int nThis = strlen(p->zThis);
+    char *zSql = sqlite3MPrintf(0, "ALTER TABLE %s RENAME TO %s%s", 
+        p->zTableName, zNewName, &p->zTableName[nThis]
+    );
+    rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
+    sqlite3_free(zSql);
+  }
+
+  return rc;
+}
+
+/*
+** A virtual table module that merely "echos" the contents of another
+** table (like an SQL VIEW).
+*/
+static sqlite3_module echoModule = {
+  0,                         /* iVersion */
+  echoCreate,
+  echoConnect,
+  echoBestIndex,
+  echoDisconnect, 
+  echoDestroy,
+  echoOpen,                  /* xOpen - open a cursor */
+  echoClose,                 /* xClose - close a cursor */
+  echoFilter,                /* xFilter - configure scan constraints */
+  echoNext,                  /* xNext - advance a cursor */
+  echoEof,                   /* xEof */
+  echoColumn,                /* xColumn - read data */
+  echoRowid,                 /* xRowid - read data */
+  echoUpdate,                /* xUpdate - write data */
+  echoBegin,                 /* xBegin - begin transaction */
+  echoSync,                  /* xSync - sync transaction */
+  echoCommit,                /* xCommit - commit transaction */
+  echoRollback,              /* xRollback - rollback transaction */
+  echoFindFunction,          /* xFindFunction - function overloading */
+  echoRename,                /* xRename - rename the table */
+};
+
+/*
+** Decode a pointer to an sqlite3 object.
+*/
+static int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
+  *ppDb = (sqlite3*)sqlite3TextToPtr(zA);
+  return TCL_OK;
+}
+
+static void moduleDestroy(void *p){
+  sqlite3_free(p);
+}
+
+/*
+** Register the echo virtual table module.
+*/
+static int register_echo_module(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  EchoModule *pMod;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  pMod = sqlite3_malloc(sizeof(EchoModule));
+  pMod->interp = interp;
+  sqlite3_create_module_v2(db, "echo", &echoModule, (void*)pMod, moduleDestroy);
+  return TCL_OK;
+}
+
+/*
+** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
+**
+** sqlite3_declare_vtab DB SQL
+*/
+static int declare_vtab(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  int rc;
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  rc = sqlite3_declare_vtab(db, Tcl_GetString(objv[2]));
+  if( rc!=SQLITE_OK ){
+    Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest8_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+     void *clientData;
+  } aObjCmd[] = {
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+     { "register_echo_module",   register_echo_module, 0 },
+     { "sqlite3_declare_vtab",   declare_vtab, 0 },
+#endif
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
+        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
+  }
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test9.c b/client/src/thirdparty/sqlite-3.4.2/src/test9.c
new file mode 100644
index 0000000..a1fb49b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test9.c
@@ -0,0 +1,193 @@
+/*
+** 2007 March 29
+**
+** 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 obscure tests of the C-interface required
+** for completeness. Test code is written in C for these cases
+** as there is not much point in binding to Tcl.
+**
+** $Id: test9.c,v 1.5 2008/01/23 12:52:41 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** c_collation_test
+*/
+static int c_collation_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  const char *zErrFunction = "N/A";
+  sqlite3 *db;
+
+  int rc;
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "");
+    return TCL_ERROR;
+  }
+
+  /* Open a database. */
+  rc = sqlite3_open(":memory:", &db);
+  if( rc!=SQLITE_OK ){
+    zErrFunction = "sqlite3_open";
+    goto error_out;
+  }
+
+  rc = sqlite3_create_collation(db, "collate", 456, 0, 0);
+  if( rc!=SQLITE_ERROR ){
+    sqlite3_close(db);
+    zErrFunction = "sqlite3_create_collation";
+    goto error_out;
+  }
+
+  sqlite3_close(db);
+  return TCL_OK;
+
+error_out:
+  Tcl_ResetResult(interp);
+  Tcl_AppendResult(interp, "Error testing function: ", zErrFunction, 0);
+  return TCL_ERROR;
+}
+
+/*
+** c_realloc_test
+*/
+static int c_realloc_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  void *p;
+  const char *zErrFunction = "N/A";
+
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "");
+    return TCL_ERROR;
+  }
+
+  p = sqlite3_malloc(5);
+  if( !p ){
+    zErrFunction = "sqlite3_malloc";
+    goto error_out;
+  }
+
+  /* Test that realloc()ing a block of memory to a negative size is
+  ** the same as free()ing that memory.
+  */
+  p = sqlite3_realloc(p, -1);
+  if( p ){
+    zErrFunction = "sqlite3_realloc";
+    goto error_out;
+  }
+
+  return TCL_OK;
+
+error_out:
+  Tcl_ResetResult(interp);
+  Tcl_AppendResult(interp, "Error testing function: ", zErrFunction, 0);
+  return TCL_ERROR;
+}
+
+
+/*
+** c_misuse_test
+*/
+static int c_misuse_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  const char *zErrFunction = "N/A";
+  sqlite3 *db = 0;
+  int rc;
+
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "");
+    return TCL_ERROR;
+  }
+
+  /* Open a database. Then close it again. We need to do this so that
+  ** we have a "closed database handle" to pass to various API functions.
+  */
+  rc = sqlite3_open(":memory:", &db);
+  if( rc!=SQLITE_OK ){
+    zErrFunction = "sqlite3_open";
+    goto error_out;
+  }
+  sqlite3_close(db);
+
+
+  rc = sqlite3_errcode(db);
+  if( rc!=SQLITE_MISUSE ){
+    zErrFunction = "sqlite3_errcode";
+    goto error_out;
+  }
+
+  rc = sqlite3_prepare(db, 0, 0, 0, 0);
+  if( rc!=SQLITE_MISUSE ){
+    zErrFunction = "sqlite3_prepare";
+    goto error_out;
+  }
+
+  rc = sqlite3_prepare_v2(db, 0, 0, 0, 0);
+  if( rc!=SQLITE_MISUSE ){
+    zErrFunction = "sqlite3_prepare_v2";
+    goto error_out;
+  }
+
+#ifndef SQLITE_OMIT_UTF16
+  rc = sqlite3_prepare16(db, 0, 0, 0, 0);
+  if( rc!=SQLITE_MISUSE ){
+    zErrFunction = "sqlite3_prepare16";
+    goto error_out;
+  }
+  rc = sqlite3_prepare16_v2(db, 0, 0, 0, 0);
+  if( rc!=SQLITE_MISUSE ){
+    zErrFunction = "sqlite3_prepare16_v2";
+    goto error_out;
+  }
+#endif
+
+  return TCL_OK;
+
+error_out:
+  Tcl_ResetResult(interp);
+  Tcl_AppendResult(interp, "Error testing function: ", zErrFunction, 0);
+  return TCL_ERROR;
+}
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest9_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+     void *clientData;
+  } aObjCmd[] = {
+     { "c_misuse_test",    c_misuse_test, 0 },
+     { "c_realloc_test",   c_realloc_test, 0 },
+     { "c_collation_test", c_collation_test, 0 },
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
+        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
+  }
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_async.c b/client/src/thirdparty/sqlite-3.4.2/src/test_async.c
new file mode 100644
index 0000000..3f2c579
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_async.c
@@ -0,0 +1,1708 @@
+/*
+** 2005 December 14
+**
+** 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 an example implementation of an asynchronous IO 
+** backend for SQLite.
+**
+** WHAT IS ASYNCHRONOUS I/O?
+**
+** With asynchronous I/O, write requests are handled by a separate thread
+** running in the background.  This means that the thread that initiates
+** a database write does not have to wait for (sometimes slow) disk I/O
+** to occur.  The write seems to happen very quickly, though in reality
+** it is happening at its usual slow pace in the background.
+**
+** Asynchronous I/O appears to give better responsiveness, but at a price.
+** You lose the Durable property.  With the default I/O backend of SQLite,
+** once a write completes, you know that the information you wrote is
+** safely on disk.  With the asynchronous I/O, this is not the case.  If
+** your program crashes or if a power lose occurs after the database
+** write but before the asynchronous write thread has completed, then the
+** database change might never make it to disk and the next user of the
+** database might not see your change.
+**
+** You lose Durability with asynchronous I/O, but you still retain the
+** other parts of ACID:  Atomic,  Consistent, and Isolated.  Many
+** appliations get along fine without the Durablity.
+**
+** HOW IT WORKS
+**
+** Asynchronous I/O works by creating a special SQLite "vfs" structure
+** and registering it with sqlite3_vfs_register(). When files opened via 
+** this vfs are written to (using sqlite3OsWrite()), the data is not 
+** written directly to disk, but is placed in the "write-queue" to be
+** handled by the background thread.
+**
+** When files opened with the asynchronous vfs are read from 
+** (using sqlite3OsRead()), the data is read from the file on 
+** disk and the write-queue, so that from the point of view of
+** the vfs reader the OsWrite() appears to have already completed.
+**
+** The special vfs is registered (and unregistered) by calls to 
+** function asyncEnable() (see below).
+**
+** LIMITATIONS
+**
+** This demonstration code is deliberately kept simple in order to keep
+** the main ideas clear and easy to understand.  Real applications that
+** want to do asynchronous I/O might want to add additional capabilities.
+** For example, in this demonstration if writes are happening at a steady
+** stream that exceeds the I/O capability of the background writer thread,
+** the queue of pending write operations will grow without bound until we
+** run out of memory.  Users of this technique may want to keep track of
+** the quantity of pending writes and stop accepting new write requests
+** when the buffer gets to be too big.
+**
+** LOCKING + CONCURRENCY
+**
+** Multiple connections from within a single process that use this
+** implementation of asynchronous IO may access a single database
+** file concurrently. From the point of view of the user, if all
+** connections are from within a single process, there is no difference
+** between the concurrency offered by "normal" SQLite and SQLite
+** using the asynchronous backend.
+**
+** If connections from within multiple database files may access the
+** database file, the ENABLE_FILE_LOCKING symbol (see below) must be
+** defined. If it is not defined, then no locks are established on 
+** the database file. In this case, if multiple processes access 
+** the database file, corruption will quickly result.
+**
+** If ENABLE_FILE_LOCKING is defined (the default), then connections 
+** from within multiple processes may access a single database file 
+** without risking corruption. However concurrency is reduced as
+** follows:
+**
+**   * When a connection using asynchronous IO begins a database
+**     transaction, the database is locked immediately. However the
+**     lock is not released until after all relevant operations
+**     in the write-queue have been flushed to disk. This means
+**     (for example) that the database may remain locked for some 
+**     time after a "COMMIT" or "ROLLBACK" is issued.
+**
+**   * If an application using asynchronous IO executes transactions
+**     in quick succession, other database users may be effectively
+**     locked out of the database. This is because when a BEGIN
+**     is executed, a database lock is established immediately. But
+**     when the corresponding COMMIT or ROLLBACK occurs, the lock
+**     is not released until the relevant part of the write-queue 
+**     has been flushed through. As a result, if a COMMIT is followed
+**     by a BEGIN before the write-queue is flushed through, the database 
+**     is never unlocked,preventing other processes from accessing 
+**     the database.
+**
+** Defining ENABLE_FILE_LOCKING when using an NFS or other remote 
+** file-system may slow things down, as synchronous round-trips to the 
+** server may be required to establish database file locks.
+*/
+#define ENABLE_FILE_LOCKING
+
+#ifndef SQLITE_AMALGAMATION
+# include "sqliteInt.h"
+#endif
+#include <tcl.h>
+
+/*
+** This test uses pthreads and hence only works on unix and with
+** a threadsafe build of SQLite.
+*/
+#if OS_UNIX && SQLITE_THREADSAFE
+
+/*
+** This demo uses pthreads.  If you do not have a pthreads implementation
+** for your operating system, you will need to recode the threading 
+** logic.
+*/
+#include <pthread.h>
+#include <sched.h>
+
+/* Useful macros used in several places */
+#define MIN(x,y) ((x)<(y)?(x):(y))
+#define MAX(x,y) ((x)>(y)?(x):(y))
+
+/* Forward references */
+typedef struct AsyncWrite AsyncWrite;
+typedef struct AsyncFile AsyncFile;
+typedef struct AsyncFileData AsyncFileData;
+typedef struct AsyncFileLock AsyncFileLock;
+typedef struct AsyncLock AsyncLock;
+
+/* Enable for debugging */
+static int sqlite3async_trace = 0;
+# define ASYNC_TRACE(X) if( sqlite3async_trace ) asyncTrace X
+static void asyncTrace(const char *zFormat, ...){
+  char *z;
+  va_list ap;
+  va_start(ap, zFormat);
+  z = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  fprintf(stderr, "[%d] %s", (int)pthread_self(), z);
+  sqlite3_free(z);
+}
+
+/*
+** THREAD SAFETY NOTES
+**
+** Basic rules:
+**
+**     * Both read and write access to the global write-op queue must be 
+**       protected by the async.queueMutex. As are the async.ioError and
+**       async.nFile variables.
+**
+**     * The async.aLock hash-table and all AsyncLock and AsyncFileLock
+**       structures must be protected by the async.lockMutex mutex.
+**
+**     * The file handles from the underlying system are assumed not to 
+**       be thread safe.
+**
+**     * See the last two paragraphs under "The Writer Thread" for
+**       an assumption to do with file-handle synchronization by the Os.
+**
+** Deadlock prevention:
+**
+**     There are three mutex used by the system: the "writer" mutex, 
+**     the "queue" mutex and the "lock" mutex. Rules are:
+**
+**     * It is illegal to block on the writer mutex when any other mutex
+**       are held, and 
+**
+**     * It is illegal to block on the queue mutex when the lock mutex
+**       is held.
+**
+**     i.e. mutex's must be grabbed in the order "writer", "queue", "lock".
+**
+** File system operations (invoked by SQLite thread):
+**
+**     xOpen
+**     xDelete
+**     xFileExists
+**
+** File handle operations (invoked by SQLite thread):
+**
+**         asyncWrite, asyncClose, asyncTruncate, asyncSync 
+**    
+**     The operations above add an entry to the global write-op list. They
+**     prepare the entry, acquire the async.queueMutex momentarily while
+**     list pointers are  manipulated to insert the new entry, then release
+**     the mutex and signal the writer thread to wake up in case it happens
+**     to be asleep.
+**
+**    
+**         asyncRead, asyncFileSize.
+**
+**     Read operations. Both of these read from both the underlying file
+**     first then adjust their result based on pending writes in the 
+**     write-op queue.   So async.queueMutex is held for the duration
+**     of these operations to prevent other threads from changing the
+**     queue in mid operation.
+**    
+**
+**         asyncLock, asyncUnlock, asyncCheckReservedLock
+**    
+**     These primitives implement in-process locking using a hash table
+**     on the file name.  Files are locked correctly for connections coming
+**     from the same process.  But other processes cannot see these locks
+**     and will therefore not honor them.
+**
+**
+** The writer thread:
+**
+**     The async.writerMutex is used to make sure only there is only
+**     a single writer thread running at a time.
+**
+**     Inside the writer thread is a loop that works like this:
+**
+**         WHILE (write-op list is not empty)
+**             Do IO operation at head of write-op list
+**             Remove entry from head of write-op list
+**         END WHILE
+**
+**     The async.queueMutex is always held during the <write-op list is 
+**     not empty> test, and when the entry is removed from the head
+**     of the write-op list. Sometimes it is held for the interim
+**     period (while the IO is performed), and sometimes it is
+**     relinquished. It is relinquished if (a) the IO op is an
+**     ASYNC_CLOSE or (b) when the file handle was opened, two of
+**     the underlying systems handles were opened on the same
+**     file-system entry.
+**
+**     If condition (b) above is true, then one file-handle 
+**     (AsyncFile.pBaseRead) is used exclusively by sqlite threads to read the
+**     file, the other (AsyncFile.pBaseWrite) by sqlite3_async_flush() 
+**     threads to perform write() operations. This means that read 
+**     operations are not blocked by asynchronous writes (although 
+**     asynchronous writes may still be blocked by reads).
+**
+**     This assumes that the OS keeps two handles open on the same file
+**     properly in sync. That is, any read operation that starts after a
+**     write operation on the same file system entry has completed returns
+**     data consistent with the write. We also assume that if one thread 
+**     reads a file while another is writing it all bytes other than the
+**     ones actually being written contain valid data.
+**
+**     If the above assumptions are not true, set the preprocessor symbol
+**     SQLITE_ASYNC_TWO_FILEHANDLES to 0.
+*/
+
+#ifndef SQLITE_ASYNC_TWO_FILEHANDLES
+/* #define SQLITE_ASYNC_TWO_FILEHANDLES 0 */
+#define SQLITE_ASYNC_TWO_FILEHANDLES 1
+#endif
+
+/*
+** State information is held in the static variable "async" defined
+** as the following structure.
+**
+** Both async.ioError and async.nFile are protected by async.queueMutex.
+*/
+static struct TestAsyncStaticData {
+  pthread_mutex_t lockMutex;   /* For access to aLock hash table */
+  pthread_mutex_t queueMutex;  /* Mutex for access to write operation queue */
+  pthread_mutex_t writerMutex; /* Prevents multiple writer threads */
+  pthread_cond_t queueSignal;  /* For waking up sleeping writer thread */
+  pthread_cond_t emptySignal;  /* Notify when the write queue is empty */
+  AsyncWrite *pQueueFirst;     /* Next write operation to be processed */
+  AsyncWrite *pQueueLast;      /* Last write operation on the list */
+  Hash aLock;                  /* Files locked */
+  volatile int ioDelay;             /* Extra delay between write operations */
+  volatile int writerHaltWhenIdle;  /* Writer thread halts when queue empty */
+  volatile int writerHaltNow;       /* Writer thread halts after next op */
+  int ioError;                 /* True if an IO error has occured */
+  int nFile;                   /* Number of open files (from sqlite pov) */
+} async = {
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_COND_INITIALIZER,
+  PTHREAD_COND_INITIALIZER,
+};
+
+/* Possible values of AsyncWrite.op */
+#define ASYNC_NOOP          0
+#define ASYNC_WRITE         1
+#define ASYNC_SYNC          2
+#define ASYNC_TRUNCATE      3
+#define ASYNC_CLOSE         4
+#define ASYNC_DELETE        5
+#define ASYNC_OPENEXCLUSIVE 6
+#define ASYNC_UNLOCK        7
+
+/* Names of opcodes.  Used for debugging only.
+** Make sure these stay in sync with the macros above!
+*/
+static const char *azOpcodeName[] = {
+  "NOOP", "WRITE", "SYNC", "TRUNCATE", "CLOSE", "DELETE", "OPENEX", "UNLOCK"
+};
+
+/*
+** Entries on the write-op queue are instances of the AsyncWrite
+** structure, defined here.
+**
+** The interpretation of the iOffset and nByte variables varies depending 
+** on the value of AsyncWrite.op:
+**
+** ASYNC_NOOP:
+**     No values used.
+**
+** ASYNC_WRITE:
+**     iOffset -> Offset in file to write to.
+**     nByte   -> Number of bytes of data to write (pointed to by zBuf).
+**
+** ASYNC_SYNC:
+**     nByte   -> flags to pass to sqlite3OsSync().
+**
+** ASYNC_TRUNCATE:
+**     iOffset -> Size to truncate file to.
+**     nByte   -> Unused.
+**
+** ASYNC_CLOSE:
+**     iOffset -> Unused.
+**     nByte   -> Unused.
+**
+** ASYNC_DELETE:
+**     iOffset -> Contains the "syncDir" flag.
+**     nByte   -> Number of bytes of zBuf points to (file name).
+**
+** ASYNC_OPENEXCLUSIVE:
+**     iOffset -> Value of "delflag".
+**     nByte   -> Number of bytes of zBuf points to (file name).
+**
+** ASYNC_UNLOCK:
+**     nByte   -> Argument to sqlite3OsUnlock().
+**
+**
+** For an ASYNC_WRITE operation, zBuf points to the data to write to the file. 
+** This space is sqlite3_malloc()d along with the AsyncWrite structure in a
+** single blob, so is deleted when sqlite3_free() is called on the parent 
+** structure.
+*/
+struct AsyncWrite {
+  AsyncFileData *pFileData;    /* File to write data to or sync */
+  int op;                      /* One of ASYNC_xxx etc. */
+  i64 iOffset;        /* See above */
+  int nByte;          /* See above */
+  char *zBuf;         /* Data to write to file (or NULL if op!=ASYNC_WRITE) */
+  AsyncWrite *pNext;  /* Next write operation (to any file) */
+};
+
+/*
+** An instance of this structure is created for each distinct open file 
+** (i.e. if two handles are opened on the one file, only one of these
+** structures is allocated) and stored in the async.aLock hash table. The
+** keys for async.aLock are the full pathnames of the opened files.
+**
+** AsyncLock.pList points to the head of a linked list of AsyncFileLock
+** structures, one for each handle currently open on the file.
+**
+** If the opened file is not a main-database (the SQLITE_OPEN_MAIN_DB is
+** not passed to the sqlite3OsOpen() call), or if ENABLE_FILE_LOCKING is 
+** not defined at compile time, variables AsyncLock.pFile and 
+** AsyncLock.eLock are never used. Otherwise, pFile is a file handle
+** opened on the file in question and used to obtain the file-system 
+** locks required by database connections within this process.
+**
+** See comments above the asyncLock() function for more details on 
+** the implementation of database locking used by this backend.
+*/
+struct AsyncLock {
+  sqlite3_file *pFile;
+  int eLock;
+  AsyncFileLock *pList;
+};
+
+/*
+** An instance of the following structure is allocated along with each
+** AsyncFileData structure (see AsyncFileData.lock), but is only used if the
+** file was opened with the SQLITE_OPEN_MAIN_DB.
+*/
+struct AsyncFileLock {
+  int eLock;                /* Internally visible lock state (sqlite pov) */
+  int eAsyncLock;           /* Lock-state with write-queue unlock */
+  AsyncFileLock *pNext;
+};
+
+/* 
+** The AsyncFile structure is a subclass of sqlite3_file used for 
+** asynchronous IO. 
+**
+** All of the actual data for the structure is stored in the structure
+** pointed to by AsyncFile.pData, which is allocated as part of the
+** sqlite3OsOpen() using sqlite3_malloc(). The reason for this is that the
+** lifetime of the AsyncFile structure is ended by the caller after OsClose()
+** is called, but the data in AsyncFileData may be required by the
+** writer thread after that point.
+*/
+struct AsyncFile {
+  sqlite3_io_methods *pMethod;
+  AsyncFileData *pData;
+};
+struct AsyncFileData {
+  char *zName;               /* Underlying OS filename - used for debugging */
+  int nName;                 /* Number of characters in zName */
+  sqlite3_file *pBaseRead;   /* Read handle to the underlying Os file */
+  sqlite3_file *pBaseWrite;  /* Write handle to the underlying Os file */
+  AsyncFileLock lock;
+  AsyncWrite close;
+};
+
+/*
+** The following async_XXX functions are debugging wrappers around the
+** corresponding pthread_XXX functions:
+**
+**     pthread_mutex_lock();
+**     pthread_mutex_unlock();
+**     pthread_mutex_trylock();
+**     pthread_cond_wait();
+**
+** It is illegal to pass any mutex other than those stored in the
+** following global variables of these functions.
+**
+**     async.queueMutex
+**     async.writerMutex
+**     async.lockMutex
+**
+** If NDEBUG is defined, these wrappers do nothing except call the 
+** corresponding pthreads function. If NDEBUG is not defined, then the
+** following variables are used to store the thread-id (as returned
+** by pthread_self()) currently holding the mutex, or 0 otherwise:
+**
+**     asyncdebug.queueMutexHolder
+**     asyncdebug.writerMutexHolder
+**     asyncdebug.lockMutexHolder
+**
+** These variables are used by some assert() statements that verify
+** the statements made in the "Deadlock Prevention" notes earlier
+** in this file.
+*/
+#ifndef NDEBUG
+
+static struct TestAsyncDebugData {
+  pthread_t lockMutexHolder;
+  pthread_t queueMutexHolder;
+  pthread_t writerMutexHolder;
+} asyncdebug = {0, 0, 0};
+
+/*
+** Wrapper around pthread_mutex_lock(). Checks that we have not violated
+** the anti-deadlock rules (see "Deadlock prevention" above).
+*/
+static int async_mutex_lock(pthread_mutex_t *pMutex){
+  int iIdx;
+  int rc;
+  pthread_mutex_t *aMutex = (pthread_mutex_t *)(&async);
+  pthread_t *aHolder = (pthread_t *)(&asyncdebug);
+
+  /* The code in this 'ifndef NDEBUG' block depends on a certain alignment
+   * of the variables in TestAsyncStaticData and TestAsyncDebugData. The
+   * following assert() statements check that this has not been changed.
+   *
+   * Really, these only need to be run once at startup time.
+   */
+  assert(&(aMutex[0])==&async.lockMutex);
+  assert(&(aMutex[1])==&async.queueMutex);
+  assert(&(aMutex[2])==&async.writerMutex);
+  assert(&(aHolder[0])==&asyncdebug.lockMutexHolder);
+  assert(&(aHolder[1])==&asyncdebug.queueMutexHolder);
+  assert(&(aHolder[2])==&asyncdebug.writerMutexHolder);
+
+  assert( pthread_self()!=0 );
+
+  for(iIdx=0; iIdx<3; iIdx++){
+    if( pMutex==&aMutex[iIdx] ) break;
+
+    /* This is the key assert(). Here we are checking that if the caller
+     * is trying to block on async.writerMutex, neither of the other two
+     * mutex are held. If the caller is trying to block on async.queueMutex,
+     * lockMutex is not held.
+     */
+    assert(!pthread_equal(aHolder[iIdx], pthread_self()));
+  }
+  assert(iIdx<3);
+
+  rc = pthread_mutex_lock(pMutex);
+  if( rc==0 ){
+    assert(aHolder[iIdx]==0);
+    aHolder[iIdx] = pthread_self();
+  }
+  return rc;
+}
+
+/*
+** Wrapper around pthread_mutex_unlock().
+*/
+static int async_mutex_unlock(pthread_mutex_t *pMutex){
+  int iIdx;
+  int rc;
+  pthread_mutex_t *aMutex = (pthread_mutex_t *)(&async);
+  pthread_t *aHolder = (pthread_t *)(&asyncdebug);
+
+  for(iIdx=0; iIdx<3; iIdx++){
+    if( pMutex==&aMutex[iIdx] ) break;
+  }
+  assert(iIdx<3);
+
+  assert(pthread_equal(aHolder[iIdx], pthread_self()));
+  aHolder[iIdx] = 0;
+  rc = pthread_mutex_unlock(pMutex);
+  assert(rc==0);
+
+  return 0;
+}
+
+/*
+** Wrapper around pthread_mutex_trylock().
+*/
+static int async_mutex_trylock(pthread_mutex_t *pMutex){
+  int iIdx;
+  int rc;
+  pthread_mutex_t *aMutex = (pthread_mutex_t *)(&async);
+  pthread_t *aHolder = (pthread_t *)(&asyncdebug);
+
+  for(iIdx=0; iIdx<3; iIdx++){
+    if( pMutex==&aMutex[iIdx] ) break;
+  }
+  assert(iIdx<3);
+
+  rc = pthread_mutex_trylock(pMutex);
+  if( rc==0 ){
+    assert(aHolder[iIdx]==0);
+    aHolder[iIdx] = pthread_self();
+  }
+  return rc;
+}
+
+/*
+** Wrapper around pthread_cond_wait().
+*/
+static int async_cond_wait(pthread_cond_t *pCond, pthread_mutex_t *pMutex){
+  int iIdx;
+  int rc;
+  pthread_mutex_t *aMutex = (pthread_mutex_t *)(&async);
+  pthread_t *aHolder = (pthread_t *)(&asyncdebug);
+
+  for(iIdx=0; iIdx<3; iIdx++){
+    if( pMutex==&aMutex[iIdx] ) break;
+  }
+  assert(iIdx<3);
+
+  assert(pthread_equal(aHolder[iIdx],pthread_self()));
+  aHolder[iIdx] = 0;
+  rc = pthread_cond_wait(pCond, pMutex);
+  if( rc==0 ){
+    aHolder[iIdx] = pthread_self();
+  }
+  return rc;
+}
+
+/* Call our async_XX wrappers instead of selected pthread_XX functions */
+#define pthread_mutex_lock    async_mutex_lock
+#define pthread_mutex_unlock  async_mutex_unlock
+#define pthread_mutex_trylock async_mutex_trylock
+#define pthread_cond_wait     async_cond_wait
+
+#endif   /* !defined(NDEBUG) */
+
+/*
+** Add an entry to the end of the global write-op list. pWrite should point 
+** to an AsyncWrite structure allocated using sqlite3_malloc().  The writer
+** thread will call sqlite3_free() to free the structure after the specified
+** operation has been completed.
+**
+** Once an AsyncWrite structure has been added to the list, it becomes the
+** property of the writer thread and must not be read or modified by the
+** caller.  
+*/
+static void addAsyncWrite(AsyncWrite *pWrite){
+  /* We must hold the queue mutex in order to modify the queue pointers */
+  pthread_mutex_lock(&async.queueMutex);
+
+  /* Add the record to the end of the write-op queue */
+  assert( !pWrite->pNext );
+  if( async.pQueueLast ){
+    assert( async.pQueueFirst );
+    async.pQueueLast->pNext = pWrite;
+  }else{
+    async.pQueueFirst = pWrite;
+  }
+  async.pQueueLast = pWrite;
+  ASYNC_TRACE(("PUSH %p (%s %s %d)\n", pWrite, azOpcodeName[pWrite->op],
+         pWrite->pFileData ? pWrite->pFileData->zName : "-", pWrite->iOffset));
+
+  if( pWrite->op==ASYNC_CLOSE ){
+    async.nFile--;
+  }
+
+  /* Drop the queue mutex */
+  pthread_mutex_unlock(&async.queueMutex);
+
+  /* The writer thread might have been idle because there was nothing
+  ** on the write-op queue for it to do.  So wake it up. */
+  pthread_cond_signal(&async.queueSignal);
+}
+
+/*
+** Increment async.nFile in a thread-safe manner.
+*/
+static void incrOpenFileCount(){
+  /* We must hold the queue mutex in order to modify async.nFile */
+  pthread_mutex_lock(&async.queueMutex);
+  if( async.nFile==0 ){
+    async.ioError = SQLITE_OK;
+  }
+  async.nFile++;
+  pthread_mutex_unlock(&async.queueMutex);
+}
+
+/*
+** This is a utility function to allocate and populate a new AsyncWrite
+** structure and insert it (via addAsyncWrite() ) into the global list.
+*/
+static int addNewAsyncWrite(
+  AsyncFileData *pFileData, 
+  int op, 
+  i64 iOffset, 
+  int nByte,
+  const char *zByte
+){
+  AsyncWrite *p;
+  if( op!=ASYNC_CLOSE && async.ioError ){
+    return async.ioError;
+  }
+  p = sqlite3_malloc(sizeof(AsyncWrite) + (zByte?nByte:0));
+  if( !p ){
+    /* The upper layer does not expect operations like OsWrite() to
+    ** return SQLITE_NOMEM. This is partly because under normal conditions
+    ** SQLite is required to do rollback without calling malloc(). So
+    ** if malloc() fails here, treat it as an I/O error. The above
+    ** layer knows how to handle that.
+    */
+    return SQLITE_IOERR;
+  }
+  p->op = op;
+  p->iOffset = iOffset;
+  p->nByte = nByte;
+  p->pFileData = pFileData;
+  p->pNext = 0;
+  if( zByte ){
+    p->zBuf = (char *)&p[1];
+    memcpy(p->zBuf, zByte, nByte);
+  }else{
+    p->zBuf = 0;
+  }
+  addAsyncWrite(p);
+  return SQLITE_OK;
+}
+
+/*
+** Close the file. This just adds an entry to the write-op list, the file is
+** not actually closed.
+*/
+static int asyncClose(sqlite3_file *pFile){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+
+  /* Unlock the file, if it is locked */
+  pthread_mutex_lock(&async.lockMutex);
+  p->lock.eLock = 0;
+  pthread_mutex_unlock(&async.lockMutex);
+
+  addAsyncWrite(&p->close);
+  return SQLITE_OK;
+}
+
+/*
+** Implementation of sqlite3OsWrite() for asynchronous files. Instead of 
+** writing to the underlying file, this function adds an entry to the end of
+** the global AsyncWrite list. Either SQLITE_OK or SQLITE_NOMEM may be
+** returned.
+*/
+static int asyncWrite(sqlite3_file *pFile, const void *pBuf, int amt, i64 iOff){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  return addNewAsyncWrite(p, ASYNC_WRITE, iOff, amt, pBuf);
+}
+
+/*
+** Read data from the file. First we read from the filesystem, then adjust 
+** the contents of the buffer based on ASYNC_WRITE operations in the 
+** write-op queue.
+**
+** This method holds the mutex from start to finish.
+*/
+static int asyncRead(sqlite3_file *pFile, void *zOut, int iAmt, i64 iOffset){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  int rc = SQLITE_OK;
+  i64 filesize;
+  int nRead;
+  sqlite3_file *pBase = p->pBaseRead;
+
+  /* Grab the write queue mutex for the duration of the call */
+  pthread_mutex_lock(&async.queueMutex);
+
+  /* If an I/O error has previously occurred in this virtual file 
+  ** system, then all subsequent operations fail.
+  */
+  if( async.ioError!=SQLITE_OK ){
+    rc = async.ioError;
+    goto asyncread_out;
+  }
+
+  if( pBase->pMethods ){
+    rc = sqlite3OsFileSize(pBase, &filesize);
+    if( rc!=SQLITE_OK ){
+      goto asyncread_out;
+    }
+    nRead = MIN(filesize - iOffset, iAmt);
+    if( nRead>0 ){
+      rc = sqlite3OsRead(pBase, zOut, nRead, iOffset);
+      ASYNC_TRACE(("READ %s %d bytes at %d\n", p->zName, nRead, iOffset));
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    AsyncWrite *pWrite;
+    char *zName = p->zName;
+
+    for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){
+      if( pWrite->op==ASYNC_WRITE && pWrite->pFileData->zName==zName ){
+        int iBeginOut = (pWrite->iOffset-iOffset);
+        int iBeginIn = -iBeginOut;
+        int nCopy;
+
+        if( iBeginIn<0 ) iBeginIn = 0;
+        if( iBeginOut<0 ) iBeginOut = 0;
+        nCopy = MIN(pWrite->nByte-iBeginIn, iAmt-iBeginOut);
+
+        if( nCopy>0 ){
+          memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], nCopy);
+          ASYNC_TRACE(("OVERREAD %d bytes at %d\n", nCopy, iBeginOut+iOffset));
+        }
+      }
+    }
+  }
+
+asyncread_out:
+  pthread_mutex_unlock(&async.queueMutex);
+  return rc;
+}
+
+/*
+** Truncate the file to nByte bytes in length. This just adds an entry to 
+** the write-op list, no IO actually takes place.
+*/
+static int asyncTruncate(sqlite3_file *pFile, i64 nByte){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  return addNewAsyncWrite(p, ASYNC_TRUNCATE, nByte, 0, 0);
+}
+
+/*
+** Sync the file. This just adds an entry to the write-op list, the 
+** sync() is done later by sqlite3_async_flush().
+*/
+static int asyncSync(sqlite3_file *pFile, int flags){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  return addNewAsyncWrite(p, ASYNC_SYNC, 0, flags, 0);
+}
+
+/*
+** Read the size of the file. First we read the size of the file system 
+** entry, then adjust for any ASYNC_WRITE or ASYNC_TRUNCATE operations 
+** currently in the write-op list. 
+**
+** This method holds the mutex from start to finish.
+*/
+int asyncFileSize(sqlite3_file *pFile, i64 *piSize){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  int rc = SQLITE_OK;
+  i64 s = 0;
+  sqlite3_file *pBase;
+
+  pthread_mutex_lock(&async.queueMutex);
+
+  /* Read the filesystem size from the base file. If pBaseRead is NULL, this
+  ** means the file hasn't been opened yet. In this case all relevant data 
+  ** must be in the write-op queue anyway, so we can omit reading from the
+  ** file-system.
+  */
+  pBase = p->pBaseRead;
+  if( pBase->pMethods ){
+    rc = sqlite3OsFileSize(pBase, &s);
+  }
+
+  if( rc==SQLITE_OK ){
+    AsyncWrite *pWrite;
+    for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){
+      if( pWrite->op==ASYNC_DELETE && strcmp(p->zName, pWrite->zBuf)==0 ){
+        s = 0;
+      }else if( pWrite->pFileData && pWrite->pFileData->zName==p->zName){
+        switch( pWrite->op ){
+          case ASYNC_WRITE:
+            s = MAX(pWrite->iOffset + (i64)(pWrite->nByte), s);
+            break;
+          case ASYNC_TRUNCATE:
+            s = MIN(s, pWrite->iOffset);
+            break;
+        }
+      }
+    }
+    *piSize = s;
+  }
+  pthread_mutex_unlock(&async.queueMutex);
+  return rc;
+}
+
+/*
+** Lock or unlock the actual file-system entry.
+*/
+static int getFileLock(AsyncLock *pLock){
+  int rc = SQLITE_OK;
+  AsyncFileLock *pIter;
+  int eRequired = 0;
+
+  if( pLock->pFile ){
+    for(pIter=pLock->pList; pIter; pIter=pIter->pNext){
+      assert(pIter->eAsyncLock>=pIter->eLock);
+      if( pIter->eAsyncLock>eRequired ){
+        eRequired = pIter->eAsyncLock;
+        assert(eRequired>=0 && eRequired<=SQLITE_LOCK_EXCLUSIVE);
+      }
+    }
+
+    if( eRequired>pLock->eLock ){
+      rc = sqlite3OsLock(pLock->pFile, eRequired);
+      if( rc==SQLITE_OK ){
+        pLock->eLock = eRequired;
+      }
+    }
+    else if( eRequired<pLock->eLock && eRequired<=SQLITE_LOCK_SHARED ){
+      rc = sqlite3OsUnlock(pLock->pFile, eRequired);
+      if( rc==SQLITE_OK ){
+        pLock->eLock = eRequired;
+      }
+    }
+  }
+
+  return rc;
+}
+
+/*
+** The following two methods - asyncLock() and asyncUnlock() - are used
+** to obtain and release locks on database files opened with the
+** asynchronous backend.
+*/
+static int asyncLock(sqlite3_file *pFile, int eLock){
+  int rc = SQLITE_OK;
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+
+  pthread_mutex_lock(&async.lockMutex);
+  if( p->lock.eLock<eLock ){
+    AsyncLock *pLock;
+    AsyncFileLock *pIter;
+    pLock = (AsyncLock *)sqlite3HashFind(&async.aLock, p->zName, p->nName);
+    assert(pLock && pLock->pList);
+    for(pIter=pLock->pList; pIter; pIter=pIter->pNext){
+      if( pIter!=&p->lock && (
+        (eLock==SQLITE_LOCK_EXCLUSIVE && pIter->eLock>=SQLITE_LOCK_SHARED) ||
+        (eLock==SQLITE_LOCK_PENDING && pIter->eLock>=SQLITE_LOCK_RESERVED) ||
+        (eLock==SQLITE_LOCK_RESERVED && pIter->eLock>=SQLITE_LOCK_RESERVED) ||
+        (eLock==SQLITE_LOCK_SHARED && pIter->eLock>=SQLITE_LOCK_PENDING)
+      )){
+        rc = SQLITE_BUSY;
+      }
+    }
+    if( rc==SQLITE_OK ){
+      p->lock.eLock = eLock;
+      p->lock.eAsyncLock = MAX(p->lock.eAsyncLock, eLock);
+    }
+    assert(p->lock.eAsyncLock>=p->lock.eLock);
+    if( rc==SQLITE_OK ){
+      rc = getFileLock(pLock);
+    }
+  }
+  pthread_mutex_unlock(&async.lockMutex);
+
+  ASYNC_TRACE(("LOCK %d (%s) rc=%d\n", eLock, p->zName, rc));
+  return rc;
+}
+static int asyncUnlock(sqlite3_file *pFile, int eLock){
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+  AsyncFileLock *pLock = &p->lock;
+  pthread_mutex_lock(&async.lockMutex);
+  pLock->eLock = MIN(pLock->eLock, eLock);
+  pthread_mutex_unlock(&async.lockMutex);
+  return addNewAsyncWrite(p, ASYNC_UNLOCK, 0, eLock, 0);
+}
+
+/*
+** This function is called when the pager layer first opens a database file
+** and is checking for a hot-journal.
+*/
+static int asyncCheckReservedLock(sqlite3_file *pFile){
+  int ret = 0;
+  AsyncFileLock *pIter;
+  AsyncLock *pLock;
+  AsyncFileData *p = ((AsyncFile *)pFile)->pData;
+
+  pthread_mutex_lock(&async.lockMutex);
+  pLock = (AsyncLock *)sqlite3HashFind(&async.aLock, p->zName, p->nName);
+  for(pIter=pLock->pList; pIter; pIter=pIter->pNext){
+    if( pIter->eLock>=SQLITE_LOCK_RESERVED ){
+      ret = 1;
+    }
+  }
+  pthread_mutex_unlock(&async.lockMutex);
+
+  ASYNC_TRACE(("CHECK-LOCK %d (%s)\n", ret, p->zName));
+  return ret;
+}
+
+/* 
+** This is a no-op, as the asynchronous backend does not support locking.
+*/
+static int asyncFileControl(sqlite3_file *id, int op, void *pArg){
+  switch( op ){
+    case SQLITE_FCNTL_LOCKSTATE: {
+      pthread_mutex_lock(&async.lockMutex);
+      *(int*)pArg = ((AsyncFile*)id)->pData->lock.eLock;
+      pthread_mutex_unlock(&async.lockMutex);
+      return SQLITE_OK;
+    }
+  }
+  return SQLITE_ERROR;
+}
+
+/* 
+** Return the device characteristics and sector-size of the device. It
+** is not tricky to implement these correctly, as this backend might 
+** not have an open file handle at this point.
+*/
+static int asyncSectorSize(sqlite3_file *pFile){
+  return 512;
+}
+static int asyncDeviceCharacteristics(sqlite3_file *pFile){
+  return 0;
+}
+
+static int unlinkAsyncFile(AsyncFileData *pData){
+  AsyncLock *pLock;
+  AsyncFileLock **ppIter;
+  int rc = SQLITE_OK;
+
+  pLock = sqlite3HashFind(&async.aLock, pData->zName, pData->nName);
+  for(ppIter=&pLock->pList; *ppIter; ppIter=&((*ppIter)->pNext)){
+    if( (*ppIter)==&pData->lock ){
+      *ppIter = pData->lock.pNext;
+      break;
+    }
+  }
+  if( !pLock->pList ){
+    if( pLock->pFile ){
+      sqlite3OsClose(pLock->pFile);
+    }
+    sqlite3_free(pLock);
+    sqlite3HashInsert(&async.aLock, pData->zName, pData->nName, 0);
+    if( !sqliteHashFirst(&async.aLock) ){
+      sqlite3HashClear(&async.aLock);
+    }
+  }else{
+    rc = getFileLock(pLock);
+  }
+
+  return rc;
+}
+
+/*
+** Open a file.
+*/
+static int asyncOpen(
+  sqlite3_vfs *pAsyncVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  static sqlite3_io_methods async_methods = {
+    1,                               /* iVersion */
+    asyncClose,                      /* xClose */
+    asyncRead,                       /* xRead */
+    asyncWrite,                      /* xWrite */
+    asyncTruncate,                   /* xTruncate */
+    asyncSync,                       /* xSync */
+    asyncFileSize,                   /* xFileSize */
+    asyncLock,                       /* xLock */
+    asyncUnlock,                     /* xUnlock */
+    asyncCheckReservedLock,          /* xCheckReservedLock */
+    asyncFileControl,                /* xFileControl */
+    asyncSectorSize,                 /* xSectorSize */
+    asyncDeviceCharacteristics       /* xDeviceCharacteristics */
+  };
+
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  AsyncFile *p = (AsyncFile *)pFile;
+  int nName = strlen(zName)+1;
+  int rc = SQLITE_OK;
+  int nByte;
+  AsyncFileData *pData;
+  AsyncLock *pLock = 0;
+  int isExclusive = (flags&SQLITE_OPEN_EXCLUSIVE);
+
+  nByte = (
+    sizeof(AsyncFileData) +        /* AsyncFileData structure */
+    2 * pVfs->szOsFile +           /* AsyncFileData.pBaseRead and pBaseWrite */
+    nName                          /* AsyncFileData.zName */
+  ); 
+  pData = sqlite3_malloc(nByte);
+  if( !pData ){
+    return SQLITE_NOMEM;
+  }
+  memset(pData, 0, nByte);
+  pData->zName = (char *)&pData[1];
+  pData->nName = nName;
+  pData->pBaseRead = (sqlite3_file *)&pData->zName[nName];
+  pData->pBaseWrite = (sqlite3_file *)&pData->zName[nName+pVfs->szOsFile];
+  pData->close.pFileData = pData;
+  pData->close.op = ASYNC_CLOSE;
+  memcpy(pData->zName, zName, nName);
+
+  if( !isExclusive ){
+    rc = sqlite3OsOpen(pVfs, zName, pData->pBaseRead, flags, pOutFlags);
+    if( rc==SQLITE_OK && ((*pOutFlags)&SQLITE_OPEN_READWRITE) ){
+      rc = sqlite3OsOpen(pVfs, zName, pData->pBaseWrite, flags, 0);
+    }
+  }
+
+  pthread_mutex_lock(&async.lockMutex);
+
+  if( rc==SQLITE_OK ){
+    pLock = sqlite3HashFind(&async.aLock, pData->zName, pData->nName);
+    if( !pLock ){
+      pLock = sqlite3MallocZero(pVfs->szOsFile + sizeof(AsyncLock));
+      if( pLock ){
+        AsyncLock *pDelete;
+#ifdef ENABLE_FILE_LOCKING
+        if( flags&SQLITE_OPEN_MAIN_DB ){
+          pLock->pFile = (sqlite3_file *)&pLock[1];
+          rc = sqlite3OsOpen(pVfs, zName, pLock->pFile, flags, 0);
+          if( rc!=SQLITE_OK ){
+            sqlite3_free(pLock);
+            pLock = 0;
+          }
+        }
+#endif
+        pDelete = sqlite3HashInsert(
+          &async.aLock, pData->zName, pData->nName, (void *)pLock
+        );
+        if( pDelete ){
+          rc = SQLITE_NOMEM;
+          sqlite3_free(pLock);
+        }
+      }else{
+        rc = SQLITE_NOMEM;
+      }
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    HashElem *pElem;
+    p->pMethod = &async_methods;
+    p->pData = pData;
+
+    /* Link AsyncFileData.lock into the linked list of 
+    ** AsyncFileLock structures for this file.
+    */
+    pData->lock.pNext = pLock->pList;
+    pLock->pList = &pData->lock;
+
+    pElem = sqlite3HashFindElem(&async.aLock, pData->zName, pData->nName);
+    pData->zName = (char *)sqliteHashKey(pElem);
+  }else{
+    sqlite3OsClose(pData->pBaseRead);
+    sqlite3OsClose(pData->pBaseWrite);
+    sqlite3_free(pData);
+  }
+
+  pthread_mutex_unlock(&async.lockMutex);
+
+  if( rc==SQLITE_OK ){
+    incrOpenFileCount();
+  }
+
+  if( rc==SQLITE_OK && isExclusive ){
+    rc = addNewAsyncWrite(pData, ASYNC_OPENEXCLUSIVE, (i64)flags, 0, 0);
+    if( rc==SQLITE_OK ){
+      if( pOutFlags ) *pOutFlags = flags;
+    }else{
+      pthread_mutex_lock(&async.lockMutex);
+      unlinkAsyncFile(pData);
+      pthread_mutex_unlock(&async.lockMutex);
+      sqlite3_free(pData);
+    }
+  }
+  return rc;
+}
+
+/*
+** Implementation of sqlite3OsDelete. Add an entry to the end of the 
+** write-op queue to perform the delete.
+*/
+static int asyncDelete(sqlite3_vfs *pAsyncVfs, const char *z, int syncDir){
+  return addNewAsyncWrite(0, ASYNC_DELETE, syncDir, strlen(z)+1, z);
+}
+
+/*
+** Implementation of sqlite3OsAccess. This method holds the mutex from
+** start to finish.
+*/
+static int asyncAccess(sqlite3_vfs *pAsyncVfs, const char *zName, int flags){
+  int ret;
+  AsyncWrite *p;
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+
+  assert(flags==SQLITE_ACCESS_READWRITE 
+      || flags==SQLITE_ACCESS_READ 
+      || flags==SQLITE_ACCESS_EXISTS 
+  );
+
+  pthread_mutex_lock(&async.queueMutex);
+  ret = sqlite3OsAccess(pVfs, zName, flags);
+  if( flags==SQLITE_ACCESS_EXISTS ){
+    for(p=async.pQueueFirst; p; p = p->pNext){
+      if( p->op==ASYNC_DELETE && 0==strcmp(p->zBuf, zName) ){
+        ret = 0;
+      }else if( p->op==ASYNC_OPENEXCLUSIVE 
+             && 0==strcmp(p->pFileData->zName, zName) 
+      ){
+        ret = 1;
+      }
+    }
+  }
+  ASYNC_TRACE(("ACCESS(%s): %s = %d\n", 
+    flags==SQLITE_ACCESS_READWRITE?"read-write":
+    flags==SQLITE_ACCESS_READ?"read":"exists"
+    , zName, ret)
+  );
+  pthread_mutex_unlock(&async.queueMutex);
+  return ret;
+}
+
+static int asyncGetTempname(sqlite3_vfs *pAsyncVfs, int nBufOut, char *zBufOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);
+}
+
+/*
+** Fill in zPathOut with the full path to the file identified by zPath.
+*/
+static int asyncFullPathname(
+  sqlite3_vfs *pAsyncVfs, 
+  const char *zPath, 
+  int nPathOut,
+  char *zPathOut
+){
+  int rc;
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  rc = sqlite3OsFullPathname(pVfs, zPath, nPathOut, zPathOut);
+
+  /* Because of the way intra-process file locking works, this backend
+  ** needs to return a canonical path. The following block assumes the
+  ** file-system uses unix style paths. 
+  */
+  if( rc==SQLITE_OK ){
+    int iIn;
+    int iOut = 0;
+    int nPathOut = strlen(zPathOut);
+
+    for(iIn=0; iIn<nPathOut; iIn++){
+
+      /* Replace any occurences of "//" with "/" */
+      if( iIn<=(nPathOut-2) && zPathOut[iIn]=='/' && zPathOut[iIn+1]=='/'
+      ){
+        continue;
+      }
+
+      /* Replace any occurences of "/./" with "/" */
+      if( iIn<=(nPathOut-3) 
+       && zPathOut[iIn]=='/' && zPathOut[iIn+1]=='.' && zPathOut[iIn+2]=='/'
+      ){
+        iIn++;
+        continue;
+      }
+
+      /* Replace any occurences of "<path-component>/../" with "" */
+      if( iOut>0 && iIn<=(nPathOut-4) 
+       && zPathOut[iIn]=='/' && zPathOut[iIn+1]=='.' 
+       && zPathOut[iIn+2]=='.' && zPathOut[iIn+3]=='/'
+      ){
+        iIn += 3;
+        iOut--;
+        for( ; iOut>0 && zPathOut[iOut-1]!='/'; iOut--);
+        continue;
+      }
+
+      zPathOut[iOut++] = zPathOut[iIn];
+    }
+    zPathOut[iOut] = '\0';
+  }
+
+  return rc;
+}
+static void *asyncDlOpen(sqlite3_vfs *pAsyncVfs, const char *zPath){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xDlOpen(pVfs, zPath);
+}
+static void asyncDlError(sqlite3_vfs *pAsyncVfs, int nByte, char *zErrMsg){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  pVfs->xDlError(pVfs, nByte, zErrMsg);
+}
+static void *asyncDlSym(
+  sqlite3_vfs *pAsyncVfs, 
+  void *pHandle, 
+  const char *zSymbol
+){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xDlSym(pVfs, pHandle, zSymbol);
+}
+static void asyncDlClose(sqlite3_vfs *pAsyncVfs, void *pHandle){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  pVfs->xDlClose(pVfs, pHandle);
+}
+static int asyncRandomness(sqlite3_vfs *pAsyncVfs, int nByte, char *zBufOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xRandomness(pVfs, nByte, zBufOut);
+}
+static int asyncSleep(sqlite3_vfs *pAsyncVfs, int nMicro){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xSleep(pVfs, nMicro);
+}
+static int asyncCurrentTime(sqlite3_vfs *pAsyncVfs, double *pTimeOut){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
+  return pVfs->xCurrentTime(pVfs, pTimeOut);
+}
+
+static sqlite3_vfs async_vfs = {
+  1,                    /* iVersion */
+  sizeof(AsyncFile),    /* szOsFile */
+  0,                    /* mxPathname */
+  0,                    /* pNext */
+  "async",              /* zName */
+  0,                    /* pAppData */
+  asyncOpen,            /* xOpen */
+  asyncDelete,          /* xDelete */
+  asyncAccess,          /* xAccess */
+  asyncGetTempname,     /* xGetTempName */
+  asyncFullPathname,    /* xFullPathname */
+  asyncDlOpen,          /* xDlOpen */
+  asyncDlError,         /* xDlError */
+  asyncDlSym,           /* xDlSym */
+  asyncDlClose,         /* xDlClose */
+  asyncRandomness,      /* xDlError */
+  asyncSleep,           /* xDlSym */
+  asyncCurrentTime      /* xDlClose */
+};
+
+/*
+** Call this routine to enable or disable the
+** asynchronous IO features implemented in this file. 
+**
+** This routine is not even remotely threadsafe.  Do not call
+** this routine while any SQLite database connections are open.
+*/
+static void asyncEnable(int enable){
+  if( enable ){
+    if( !async_vfs.pAppData ){
+      static int hashTableInit = 0;
+      async_vfs.pAppData = (void *)sqlite3_vfs_find(0);
+      async_vfs.mxPathname = ((sqlite3_vfs *)async_vfs.pAppData)->mxPathname;
+      sqlite3_vfs_register(&async_vfs, 1);
+      if( !hashTableInit ){
+        sqlite3HashInit(&async.aLock, SQLITE_HASH_BINARY, 1);
+        hashTableInit = 1;
+      }
+    }
+  }else{
+    if( async_vfs.pAppData ){
+      sqlite3_vfs_unregister(&async_vfs);
+      async_vfs.pAppData = 0;
+    }
+  }
+}
+
+/* 
+** This procedure runs in a separate thread, reading messages off of the
+** write queue and processing them one by one.  
+**
+** If async.writerHaltNow is true, then this procedure exits
+** after processing a single message.
+**
+** If async.writerHaltWhenIdle is true, then this procedure exits when
+** the write queue is empty.
+**
+** If both of the above variables are false, this procedure runs
+** indefinately, waiting for operations to be added to the write queue
+** and processing them in the order in which they arrive.
+**
+** An artifical delay of async.ioDelay milliseconds is inserted before
+** each write operation in order to simulate the effect of a slow disk.
+**
+** Only one instance of this procedure may be running at a time.
+*/
+static void *asyncWriterThread(void *pIsStarted){
+  sqlite3_vfs *pVfs = (sqlite3_vfs *)(async_vfs.pAppData);
+  AsyncWrite *p = 0;
+  int rc = SQLITE_OK;
+  int holdingMutex = 0;
+
+  if( pthread_mutex_trylock(&async.writerMutex) ){
+    return 0;
+  }
+  (*(int *)pIsStarted) = 1;
+  while( async.writerHaltNow==0 ){
+    int doNotFree = 0;
+    sqlite3_file *pBase = 0;
+
+    if( !holdingMutex ){
+      pthread_mutex_lock(&async.queueMutex);
+    }
+    while( (p = async.pQueueFirst)==0 ){
+      pthread_cond_broadcast(&async.emptySignal);
+      if( async.writerHaltWhenIdle ){
+        pthread_mutex_unlock(&async.queueMutex);
+        break;
+      }else{
+        ASYNC_TRACE(("IDLE\n"));
+        pthread_cond_wait(&async.queueSignal, &async.queueMutex);
+        ASYNC_TRACE(("WAKEUP\n"));
+      }
+    }
+    if( p==0 ) break;
+    holdingMutex = 1;
+
+    /* Right now this thread is holding the mutex on the write-op queue.
+    ** Variable 'p' points to the first entry in the write-op queue. In
+    ** the general case, we hold on to the mutex for the entire body of
+    ** the loop. 
+    **
+    ** However in the cases enumerated below, we relinquish the mutex,
+    ** perform the IO, and then re-request the mutex before removing 'p' from
+    ** the head of the write-op queue. The idea is to increase concurrency with
+    ** sqlite threads.
+    **
+    **     * An ASYNC_CLOSE operation.
+    **     * An ASYNC_OPENEXCLUSIVE operation. For this one, we relinquish 
+    **       the mutex, call the underlying xOpenExclusive() function, then
+    **       re-aquire the mutex before seting the AsyncFile.pBaseRead 
+    **       variable.
+    **     * ASYNC_SYNC and ASYNC_WRITE operations, if 
+    **       SQLITE_ASYNC_TWO_FILEHANDLES was set at compile time and two
+    **       file-handles are open for the particular file being "synced".
+    */
+    if( async.ioError!=SQLITE_OK && p->op!=ASYNC_CLOSE ){
+      p->op = ASYNC_NOOP;
+    }
+    if( p->pFileData ){
+      pBase = p->pFileData->pBaseWrite;
+      if( 
+        p->op==ASYNC_CLOSE || 
+        p->op==ASYNC_OPENEXCLUSIVE ||
+        (pBase->pMethods && (p->op==ASYNC_SYNC || p->op==ASYNC_WRITE) ) 
+      ){
+        pthread_mutex_unlock(&async.queueMutex);
+        holdingMutex = 0;
+      }
+      if( !pBase->pMethods ){
+        pBase = p->pFileData->pBaseRead;
+      }
+    }
+
+    switch( p->op ){
+      case ASYNC_NOOP:
+        break;
+
+      case ASYNC_WRITE:
+        assert( pBase );
+        ASYNC_TRACE(("WRITE %s %d bytes at %d\n",
+                p->pFileData->zName, p->nByte, p->iOffset));
+        rc = sqlite3OsWrite(pBase, (void *)(p->zBuf), p->nByte, p->iOffset);
+        break;
+
+      case ASYNC_SYNC:
+        assert( pBase );
+        ASYNC_TRACE(("SYNC %s\n", p->pFileData->zName));
+        rc = sqlite3OsSync(pBase, p->nByte);
+        break;
+
+      case ASYNC_TRUNCATE:
+        assert( pBase );
+        ASYNC_TRACE(("TRUNCATE %s to %d bytes\n", 
+                p->pFileData->zName, p->iOffset));
+        rc = sqlite3OsTruncate(pBase, p->iOffset);
+        break;
+
+      case ASYNC_CLOSE: {
+        AsyncFileData *pData = p->pFileData;
+        ASYNC_TRACE(("CLOSE %s\n", p->pFileData->zName));
+        sqlite3OsClose(pData->pBaseWrite);
+        sqlite3OsClose(pData->pBaseRead);
+
+        /* Unlink AsyncFileData.lock from the linked list of AsyncFileLock 
+        ** structures for this file. Obtain the async.lockMutex mutex 
+        ** before doing so.
+        */
+        pthread_mutex_lock(&async.lockMutex);
+        rc = unlinkAsyncFile(pData);
+        pthread_mutex_unlock(&async.lockMutex);
+
+        async.pQueueFirst = p->pNext;
+        sqlite3_free(pData);
+        doNotFree = 1;
+        break;
+      }
+
+      case ASYNC_UNLOCK: {
+        AsyncLock *pLock;
+        AsyncFileData *pData = p->pFileData;
+        int eLock = p->nByte;
+        pthread_mutex_lock(&async.lockMutex);
+        pData->lock.eAsyncLock = MIN(
+            pData->lock.eAsyncLock, MAX(pData->lock.eLock, eLock)
+        );
+        assert(pData->lock.eAsyncLock>=pData->lock.eLock);
+        pLock = sqlite3HashFind(&async.aLock, pData->zName, pData->nName);
+        rc = getFileLock(pLock);
+        pthread_mutex_unlock(&async.lockMutex);
+        break;
+      }
+
+      case ASYNC_DELETE:
+        ASYNC_TRACE(("DELETE %s\n", p->zBuf));
+        rc = sqlite3OsDelete(pVfs, p->zBuf, (int)p->iOffset);
+        break;
+
+      case ASYNC_OPENEXCLUSIVE: {
+        int flags = (int)p->iOffset;
+        AsyncFileData *pData = p->pFileData;
+        ASYNC_TRACE(("OPEN %s flags=%d\n", p->zBuf, (int)p->iOffset));
+        assert(pData->pBaseRead->pMethods==0 && pData->pBaseWrite->pMethods==0);
+        rc = sqlite3OsOpen(pVfs, pData->zName, pData->pBaseRead, flags, 0);
+        assert( holdingMutex==0 );
+        pthread_mutex_lock(&async.queueMutex);
+        holdingMutex = 1;
+        break;
+      }
+
+      default: assert(!"Illegal value for AsyncWrite.op");
+    }
+
+    /* If we didn't hang on to the mutex during the IO op, obtain it now
+    ** so that the AsyncWrite structure can be safely removed from the 
+    ** global write-op queue.
+    */
+    if( !holdingMutex ){
+      pthread_mutex_lock(&async.queueMutex);
+      holdingMutex = 1;
+    }
+    /* ASYNC_TRACE(("UNLINK %p\n", p)); */
+    if( p==async.pQueueLast ){
+      async.pQueueLast = 0;
+    }
+    if( !doNotFree ){
+      async.pQueueFirst = p->pNext;
+      sqlite3_free(p);
+    }
+    assert( holdingMutex );
+
+    /* An IO error has occured. We cannot report the error back to the
+    ** connection that requested the I/O since the error happened 
+    ** asynchronously.  The connection has already moved on.  There 
+    ** really is nobody to report the error to.
+    **
+    ** The file for which the error occured may have been a database or
+    ** journal file. Regardless, none of the currently queued operations
+    ** associated with the same database should now be performed. Nor should
+    ** any subsequently requested IO on either a database or journal file 
+    ** handle for the same database be accepted until the main database
+    ** file handle has been closed and reopened.
+    **
+    ** Furthermore, no further IO should be queued or performed on any file
+    ** handle associated with a database that may have been part of a 
+    ** multi-file transaction that included the database associated with 
+    ** the IO error (i.e. a database ATTACHed to the same handle at some 
+    ** point in time).
+    */
+    if( rc!=SQLITE_OK ){
+      async.ioError = rc;
+    }
+
+    if( async.ioError && !async.pQueueFirst ){
+      pthread_mutex_lock(&async.lockMutex);
+      if( 0==sqliteHashFirst(&async.aLock) ){
+        async.ioError = SQLITE_OK;
+      }
+      pthread_mutex_unlock(&async.lockMutex);
+    }
+
+    /* Drop the queue mutex before continuing to the next write operation
+    ** in order to give other threads a chance to work with the write queue.
+    */
+    if( !async.pQueueFirst || !async.ioError ){
+      pthread_mutex_unlock(&async.queueMutex);
+      holdingMutex = 0;
+      if( async.ioDelay>0 ){
+        sqlite3OsSleep(pVfs, async.ioDelay);
+      }else{
+        sched_yield();
+      }
+    }
+  }
+  
+  pthread_mutex_unlock(&async.writerMutex);
+  return 0;
+}
+
+/**************************************************************************
+** The remaining code defines a Tcl interface for testing the asynchronous
+** IO implementation in this file.
+**
+** To adapt the code to a non-TCL environment, delete or comment out
+** the code that follows.
+*/
+
+/*
+** sqlite3async_enable ?YES/NO?
+**
+** Enable or disable the asynchronous I/O backend.  This command is
+** not thread-safe.  Do not call it while any database connections
+** are open.
+*/
+static int testAsyncEnable(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  if( objc!=1 && objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?YES/NO?");
+    return TCL_ERROR;
+  }
+  if( objc==1 ){
+    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(async_vfs.pAppData!=0));
+  }else{
+    int en;
+    if( Tcl_GetBooleanFromObj(interp, objv[1], &en) ) return TCL_ERROR;
+    asyncEnable(en);
+  }
+  return TCL_OK;
+}
+
+/*
+** sqlite3async_halt  "now"|"idle"|"never"
+**
+** Set the conditions at which the writer thread will halt.
+*/
+static int testAsyncHalt(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  const char *zCond;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "\"now\"|\"idle\"|\"never\"");
+    return TCL_ERROR;
+  }
+  zCond = Tcl_GetString(objv[1]);
+  if( strcmp(zCond, "now")==0 ){
+    async.writerHaltNow = 1;
+    pthread_cond_broadcast(&async.queueSignal);
+  }else if( strcmp(zCond, "idle")==0 ){
+    async.writerHaltWhenIdle = 1;
+    async.writerHaltNow = 0;
+    pthread_cond_broadcast(&async.queueSignal);
+  }else if( strcmp(zCond, "never")==0 ){
+    async.writerHaltWhenIdle = 0;
+    async.writerHaltNow = 0;
+  }else{
+    Tcl_AppendResult(interp, 
+      "should be one of: \"now\", \"idle\", or \"never\"", (char*)0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** sqlite3async_delay ?MS?
+**
+** Query or set the number of milliseconds of delay in the writer
+** thread after each write operation.  The default is 0.  By increasing
+** the memory delay we can simulate the effect of slow disk I/O.
+*/
+static int testAsyncDelay(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  if( objc!=1 && objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?MS?");
+    return TCL_ERROR;
+  }
+  if( objc==1 ){
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(async.ioDelay));
+  }else{
+    int ioDelay;
+    if( Tcl_GetIntFromObj(interp, objv[1], &ioDelay) ) return TCL_ERROR;
+    async.ioDelay = ioDelay;
+  }
+  return TCL_OK;
+}
+
+/*
+** sqlite3async_start
+**
+** Start a new writer thread.
+*/
+static int testAsyncStart(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  pthread_t x;
+  int rc;
+  volatile int isStarted = 0;
+  rc = pthread_create(&x, 0, asyncWriterThread, (void *)&isStarted);
+  if( rc ){
+    Tcl_AppendResult(interp, "failed to create the thread", 0);
+    return TCL_ERROR;
+  }
+  pthread_detach(x);
+  while( isStarted==0 ){
+    sched_yield();
+  }
+  return TCL_OK;
+}
+
+/*
+** sqlite3async_wait
+**
+** Wait for the current writer thread to terminate.
+**
+** If the current writer thread is set to run forever then this
+** command would block forever.  To prevent that, an error is returned. 
+*/
+static int testAsyncWait(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int cnt = 10;
+  if( async.writerHaltNow==0 && async.writerHaltWhenIdle==0 ){
+    Tcl_AppendResult(interp, "would block forever", (char*)0);
+    return TCL_ERROR;
+  }
+
+  while( cnt-- && !pthread_mutex_trylock(&async.writerMutex) ){
+    pthread_mutex_unlock(&async.writerMutex);
+    sched_yield();
+  }
+  if( cnt>=0 ){
+    ASYNC_TRACE(("WAIT\n"));
+    pthread_mutex_lock(&async.queueMutex);
+    pthread_cond_broadcast(&async.queueSignal);
+    pthread_mutex_unlock(&async.queueMutex);
+    pthread_mutex_lock(&async.writerMutex);
+    pthread_mutex_unlock(&async.writerMutex);
+  }else{
+    ASYNC_TRACE(("NO-WAIT\n"));
+  }
+  return TCL_OK;
+}
+
+
+#endif  /* OS_UNIX and SQLITE_THREADSAFE */
+
+/*
+** This routine registers the custom TCL commands defined in this
+** module.  This should be the only procedure visible from outside
+** of this module.
+*/
+int Sqlitetestasync_Init(Tcl_Interp *interp){
+#if OS_UNIX && SQLITE_THREADSAFE
+  Tcl_CreateObjCommand(interp,"sqlite3async_enable",testAsyncEnable,0,0);
+  Tcl_CreateObjCommand(interp,"sqlite3async_halt",testAsyncHalt,0,0);
+  Tcl_CreateObjCommand(interp,"sqlite3async_delay",testAsyncDelay,0,0);
+  Tcl_CreateObjCommand(interp,"sqlite3async_start",testAsyncStart,0,0);
+  Tcl_CreateObjCommand(interp,"sqlite3async_wait",testAsyncWait,0,0);
+  Tcl_LinkVar(interp, "sqlite3async_trace",
+      (char*)&sqlite3async_trace, TCL_LINK_INT);
+#endif  /* OS_UNIX and SQLITE_THREADSAFE */
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_autoext.c b/client/src/thirdparty/sqlite-3.4.2/src/test_autoext.c
new file mode 100644
index 0000000..0eaeda0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_autoext.c
@@ -0,0 +1,164 @@
+/*
+** 2006 August 23
+**
+** 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.
+**
+*************************************************************************
+** Test extension for testing the sqlite3_auto_extension() function.
+**
+** $Id: test_autoext.c,v 1.2 2006/12/19 18:57:11 drh Exp $
+*/
+#include "tcl.h"
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+#include "sqlite3ext.h"
+static SQLITE_EXTENSION_INIT1
+
+/*
+** The sqr() SQL function returns the square of its input value.
+*/
+static void sqrFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  double r = sqlite3_value_double(argv[0]);
+  sqlite3_result_double(context, r*r);
+}
+
+/*
+** This is the entry point to register the extension for the sqr() function.
+*/
+static int sqr_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi);
+  sqlite3_create_function(db, "sqr", 1, SQLITE_ANY, 0, sqrFunc, 0, 0);
+  return 0;
+}
+
+/*
+** The cube() SQL function returns the cube of its input value.
+*/
+static void cubeFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  double r = sqlite3_value_double(argv[0]);
+  sqlite3_result_double(context, r*r*r);
+}
+
+/*
+** This is the entry point to register the extension for the cube() function.
+*/
+static int cube_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi);
+  sqlite3_create_function(db, "cube", 1, SQLITE_ANY, 0, cubeFunc, 0, 0);
+  return 0;
+}
+
+/*
+** This is a broken extension entry point
+*/
+static int broken_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  char *zErr;
+  SQLITE_EXTENSION_INIT2(pApi);
+  zErr = sqlite3_mprintf("broken autoext!");
+  *pzErrMsg = zErr;
+  return 1;
+}
+
+/*
+** tclcmd:   sqlite3_auto_extension_sqr
+**
+** Register the "sqr" extension to be loaded automatically.
+*/
+static int autoExtSqrObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_auto_extension((void*)sqr_init);
+  return SQLITE_OK;
+}
+
+/*
+** tclcmd:   sqlite3_auto_extension_cube
+**
+** Register the "cube" extension to be loaded automatically.
+*/
+static int autoExtCubeObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_auto_extension((void*)cube_init);
+  return SQLITE_OK;
+}
+
+/*
+** tclcmd:   sqlite3_auto_extension_broken
+**
+** Register the broken extension to be loaded automatically.
+*/
+static int autoExtBrokenObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_auto_extension((void*)broken_init);
+  return SQLITE_OK;
+}
+
+/*
+** tclcmd:   sqlite3_reset_auto_extension
+**
+** Reset all auto-extensions
+*/
+static int resetAutoExtObjCmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3_reset_auto_extension();
+  return SQLITE_OK;
+}
+
+
+#endif /* SQLITE_OMIT_LOAD_EXTENSION */
+
+/*
+** This procedure registers the TCL procs defined in this file.
+*/
+int Sqlitetest_autoext_Init(Tcl_Interp *interp){
+#ifndef SQLITE_OMIT_LOAD_EXTENSION
+  Tcl_CreateObjCommand(interp, "sqlite3_auto_extension_sqr",
+          autoExtSqrObjCmd, 0, 0);
+  Tcl_CreateObjCommand(interp, "sqlite3_auto_extension_cube",
+          autoExtCubeObjCmd, 0, 0);
+  Tcl_CreateObjCommand(interp, "sqlite3_auto_extension_broken",
+          autoExtBrokenObjCmd, 0, 0);
+  Tcl_CreateObjCommand(interp, "sqlite3_reset_auto_extension",
+          resetAutoExtObjCmd, 0, 0);
+#endif
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_btree.c b/client/src/thirdparty/sqlite-3.4.2/src/test_btree.c
new file mode 100644
index 0000000..3647a5b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_btree.c
@@ -0,0 +1,247 @@
+/*
+** 2007 May 05
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the btree.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test_btree.c,v 1.3 2007/08/17 01:14:39 drh Exp $
+*/
+#include "btreeInt.h"
+#include <tcl.h>
+
+/*
+** Print a disassembly of the given page on standard output.  This routine
+** is used for debugging and testing only.
+*/
+static int btreePageDump(
+  BtShared *pBt,         /* The Btree to be dumped */
+  int pgno,              /* The page to be dumped */
+  int recursive,         /* True to decend into child pages */
+  MemPage *pParent       /* Parent page */
+){
+  int rc;
+  MemPage *pPage;
+  int i, j, c;
+  int nFree;
+  u16 idx;
+  int hdr;
+  int nCell;
+  int isInit;
+  unsigned char *data;
+  char range[20];
+  unsigned char payload[20];
+
+  rc = sqlite3BtreeGetPage(pBt, (Pgno)pgno, &pPage, 0);
+  isInit = pPage->isInit;
+  if( pPage->isInit==0 ){
+    sqlite3BtreeInitPage(pPage, pParent);
+  }
+  if( rc ){
+    return rc;
+  }
+  hdr = pPage->hdrOffset;
+  data = pPage->aData;
+  c = data[hdr];
+  pPage->intKey = (c & (PTF_INTKEY|PTF_LEAFDATA))!=0;
+  pPage->zeroData = (c & PTF_ZERODATA)!=0;
+  pPage->leafData = (c & PTF_LEAFDATA)!=0;
+  pPage->leaf = (c & PTF_LEAF)!=0;
+  pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData));
+  nCell = get2byte(&data[hdr+3]);
+  sqlite3DebugPrintf("PAGE %d:  flags=0x%02x  frag=%d   parent=%d\n", pgno,
+    data[hdr], data[hdr+7], 
+    (pPage->isInit && pPage->pParent) ? pPage->pParent->pgno : 0);
+  assert( hdr == (pgno==1 ? 100 : 0) );
+  idx = hdr + 12 - pPage->leaf*4;
+  for(i=0; i<nCell; i++){
+    CellInfo info;
+    Pgno child;
+    unsigned char *pCell;
+    int sz;
+    int addr;
+
+    addr = get2byte(&data[idx + 2*i]);
+    pCell = &data[addr];
+    sqlite3BtreeParseCellPtr(pPage, pCell, &info);
+    sz = info.nSize;
+    sqlite3_snprintf(sizeof(range),range,"%d..%d", addr, addr+sz-1);
+    if( pPage->leaf ){
+      child = 0;
+    }else{
+      child = get4byte(pCell);
+    }
+    sz = info.nData;
+    if( !pPage->intKey ) sz += info.nKey;
+    if( sz>sizeof(payload)-1 ) sz = sizeof(payload)-1;
+    memcpy(payload, &pCell[info.nHeader], sz);
+    for(j=0; j<sz; j++){
+      if( payload[j]<0x20 || payload[j]>0x7f ) payload[j] = '.';
+    }
+    payload[sz] = 0;
+    sqlite3DebugPrintf(
+      "cell %2d: i=%-10s chld=%-4d nk=%-4lld nd=%-4d payload=%s\n",
+      i, range, child, info.nKey, info.nData, payload
+    );
+  }
+  if( !pPage->leaf ){
+    sqlite3DebugPrintf("right_child: %d\n", get4byte(&data[hdr+8]));
+  }
+  nFree = 0;
+  i = 0;
+  idx = get2byte(&data[hdr+1]);
+  while( idx>0 && idx<pPage->pBt->usableSize ){
+    int sz = get2byte(&data[idx+2]);
+    sqlite3_snprintf(sizeof(range),range,"%d..%d", idx, idx+sz-1);
+    nFree += sz;
+    sqlite3DebugPrintf("freeblock %2d: i=%-10s size=%-4d total=%d\n",
+       i, range, sz, nFree);
+    idx = get2byte(&data[idx]);
+    i++;
+  }
+  if( idx!=0 ){
+    sqlite3DebugPrintf("ERROR: next freeblock index out of range: %d\n", idx);
+  }
+  if( recursive && !pPage->leaf ){
+    for(i=0; i<nCell; i++){
+      unsigned char *pCell = sqlite3BtreeFindCell(pPage, i);
+      btreePageDump(pBt, get4byte(pCell), 1, pPage);
+      idx = get2byte(pCell);
+    }
+    btreePageDump(pBt, get4byte(&data[hdr+8]), 1, pPage);
+  }
+  pPage->isInit = isInit;
+  sqlite3PagerUnref(pPage->pDbPage);
+  fflush(stdout);
+  return SQLITE_OK;
+}
+int sqlite3BtreePageDump(Btree *p, int pgno, int recursive){
+  return btreePageDump(p->pBt, pgno, recursive, 0);
+}
+
+/*
+** Usage: sqlite3_shared_cache_report
+**
+** Return a list of file that are shared and the number of
+** references to each file.
+*/
+int sqlite3BtreeSharedCacheReport(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  extern BtShared *sqlite3SharedCacheList;
+  BtShared *pBt;
+  Tcl_Obj *pRet = Tcl_NewObj();
+  for(pBt=sqlite3SharedCacheList; pBt; pBt=pBt->pNext){
+    const char *zFile = sqlite3PagerFilename(pBt->pPager);
+    Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(zFile, -1));
+    Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(pBt->nRef));
+  }
+  Tcl_SetObjResult(interp, pRet);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Print debugging information about all cursors to standard output.
+*/
+void sqlite3BtreeCursorList(Btree *p){
+  BtCursor *pCur;
+  BtShared *pBt = p->pBt;
+  for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
+    MemPage *pPage = pCur->pPage;
+    char *zMode = pCur->wrFlag ? "rw" : "ro";
+    sqlite3DebugPrintf("CURSOR %p rooted at %4d(%s) currently at %d.%d%s\n",
+       pCur, pCur->pgnoRoot, zMode,
+       pPage ? pPage->pgno : 0, pCur->idx,
+       (pCur->eState==CURSOR_VALID) ? "" : " eof"
+    );
+  }
+}
+
+
+/*
+** Fill aResult[] with information about the entry and page that the
+** cursor is pointing to.
+** 
+**   aResult[0] =  The page number
+**   aResult[1] =  The entry number
+**   aResult[2] =  Total number of entries on this page
+**   aResult[3] =  Cell size (local payload + header)
+**   aResult[4] =  Number of free bytes on this page
+**   aResult[5] =  Number of free blocks on the page
+**   aResult[6] =  Total payload size (local + overflow)
+**   aResult[7] =  Header size in bytes
+**   aResult[8] =  Local payload size
+**   aResult[9] =  Parent page number
+**   aResult[10]=  Page number of the first overflow page
+**
+** This routine is used for testing and debugging only.
+*/
+int sqlite3BtreeCursorInfo(BtCursor *pCur, int *aResult, int upCnt){
+  int cnt, idx;
+  MemPage *pPage = pCur->pPage;
+  BtCursor tmpCur;
+  int rc;
+
+  if( pCur->eState==CURSOR_REQUIRESEEK ){
+    rc = sqlite3BtreeRestoreOrClearCursorPosition(pCur);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+  }
+
+  assert( pPage->isInit );
+  sqlite3BtreeGetTempCursor(pCur, &tmpCur);
+  while( upCnt-- ){
+    sqlite3BtreeMoveToParent(&tmpCur);
+  }
+  pPage = tmpCur.pPage;
+  aResult[0] = sqlite3PagerPagenumber(pPage->pDbPage);
+  assert( aResult[0]==pPage->pgno );
+  aResult[1] = tmpCur.idx;
+  aResult[2] = pPage->nCell;
+  if( tmpCur.idx>=0 && tmpCur.idx<pPage->nCell ){
+    sqlite3BtreeParseCell(tmpCur.pPage, tmpCur.idx, &tmpCur.info);
+    aResult[3] = tmpCur.info.nSize;
+    aResult[6] = tmpCur.info.nData;
+    aResult[7] = tmpCur.info.nHeader;
+    aResult[8] = tmpCur.info.nLocal;
+  }else{
+    aResult[3] = 0;
+    aResult[6] = 0;
+    aResult[7] = 0;
+    aResult[8] = 0;
+  }
+  aResult[4] = pPage->nFree;
+  cnt = 0;
+  idx = get2byte(&pPage->aData[pPage->hdrOffset+1]);
+  while( idx>0 && idx<pPage->pBt->usableSize ){
+    cnt++;
+    idx = get2byte(&pPage->aData[idx]);
+  }
+  aResult[5] = cnt;
+  if( pPage->pParent==0 || sqlite3BtreeIsRootPage(pPage) ){
+    aResult[9] = 0;
+  }else{
+    aResult[9] = pPage->pParent->pgno;
+  }
+  if( tmpCur.info.iOverflow ){
+    aResult[10] = get4byte(&tmpCur.info.pCell[tmpCur.info.iOverflow]);
+  }else{
+    aResult[10] = 0;
+  }
+  sqlite3BtreeReleaseTempCursor(&tmpCur);
+  return SQLITE_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_config.c b/client/src/thirdparty/sqlite-3.4.2/src/test_config.c
new file mode 100644
index 0000000..b47ca89
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_config.c
@@ -0,0 +1,477 @@
+/*
+** 2007 May 7
+**
+** 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 for testing the SQLite system.
+** None of the code in this file goes into a deliverable build.
+** 
+** The focus of this file is providing the TCL testing layer
+** access to compile-time constants.
+**
+** $Id: test_config.c,v 1.19 2008/01/23 12:52:41 drh Exp $
+*/
+
+#include "sqliteLimit.h"
+
+int sqlite3MAX_LENGTH = SQLITE_MAX_LENGTH;
+int sqlite3MAX_COLUMN = SQLITE_MAX_COLUMN;
+int sqlite3MAX_SQL_LENGTH = SQLITE_MAX_SQL_LENGTH;
+int sqlite3MAX_EXPR_DEPTH = SQLITE_MAX_EXPR_DEPTH;
+int sqlite3MAX_COMPOUND_SELECT = SQLITE_MAX_COMPOUND_SELECT;
+int sqlite3MAX_VDBE_OP = SQLITE_MAX_VDBE_OP;
+int sqlite3MAX_FUNCTION_ARG = SQLITE_MAX_FUNCTION_ARG;
+int sqlite3MAX_VARIABLE_NUMBER = SQLITE_MAX_VARIABLE_NUMBER;
+int sqlite3MAX_PAGE_SIZE = SQLITE_MAX_PAGE_SIZE;
+int sqlite3MAX_PAGE_COUNT = SQLITE_MAX_PAGE_COUNT;
+int sqlite3MAX_LIKE_PATTERN_LENGTH = SQLITE_MAX_LIKE_PATTERN_LENGTH;
+
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** This routine sets entries in the global ::sqlite_options() array variable
+** according to the compile-time configuration of the database.  Test
+** procedures use this to determine when tests should be omitted.
+*/
+static void set_options(Tcl_Interp *interp){
+  int rc = 0;
+
+#ifdef SQLITE_32BIT_ROWID
+  Tcl_SetVar2(interp, "sqlite_options", "rowid32", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "rowid32", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_CASE_SENSITIVE_LIKE
+  Tcl_SetVar2(interp, "sqlite_options","casesensitivelike","1",TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options","casesensitivelike","0",TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_DEBUG
+  Tcl_SetVar2(interp, "sqlite_options", "debug", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "debug", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_DISABLE_DIRSYNC
+  Tcl_SetVar2(interp, "sqlite_options", "dirsync", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "dirsync", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_DISABLE_LFS
+  Tcl_SetVar2(interp, "sqlite_options", "lfs", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "lfs", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_MEMDEBUG
+  Tcl_SetVar2(interp, "sqlite_options", "memdebug", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "memdebug", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_MEMORY_SIZE
+  Tcl_SetVar2(interp, "sqlite_options", "mem3", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "mem3", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_ALTERTABLE
+  Tcl_SetVar2(interp, "sqlite_options", "altertable", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "altertable", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_ANALYZE
+  Tcl_SetVar2(interp, "sqlite_options", "analyze", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "analyze", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+  Tcl_SetVar2(interp, "sqlite_options", "atomicwrite", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "atomicwrite", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_ATTACH
+  Tcl_SetVar2(interp, "sqlite_options", "attach", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "attach", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_AUTHORIZATION
+  Tcl_SetVar2(interp, "sqlite_options", "auth", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "auth", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_AUTOINCREMENT
+  Tcl_SetVar2(interp, "sqlite_options", "autoinc", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "autoinc", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  Tcl_SetVar2(interp, "sqlite_options", "autovacuum", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "autovacuum", "1", TCL_GLOBAL_ONLY);
+#endif /* SQLITE_OMIT_AUTOVACUUM */
+#if !defined(SQLITE_DEFAULT_AUTOVACUUM) || SQLITE_DEFAULT_AUTOVACUUM==0
+  Tcl_SetVar2(interp,"sqlite_options","default_autovacuum","0",TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp,"sqlite_options","default_autovacuum","1",TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION
+  Tcl_SetVar2(interp, "sqlite_options", "between_opt", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "between_opt", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_BLOB_LITERAL
+  Tcl_SetVar2(interp, "sqlite_options", "bloblit", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "bloblit", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_CAST
+  Tcl_SetVar2(interp, "sqlite_options", "cast", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "cast", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_CHECK
+  Tcl_SetVar2(interp, "sqlite_options", "check", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "check", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+  Tcl_SetVar2(interp, "sqlite_options", "columnmetadata", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "columnmetadata", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_COMPLETE
+  Tcl_SetVar2(interp, "sqlite_options", "complete", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "complete", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_COMPOUND_SELECT
+  Tcl_SetVar2(interp, "sqlite_options", "compound", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "compound", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_CONFLICT_CLAUSE
+  Tcl_SetVar2(interp, "sqlite_options", "conflict", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "conflict", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#if OS_UNIX
+  Tcl_SetVar2(interp, "sqlite_options", "crashtest", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "crashtest", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_DATETIME_FUNCS
+  Tcl_SetVar2(interp, "sqlite_options", "datetime", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "datetime", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_DISKIO
+  Tcl_SetVar2(interp, "sqlite_options", "diskio", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "diskio", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_EXPLAIN
+  Tcl_SetVar2(interp, "sqlite_options", "explain", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "explain", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_FAULTINJECTOR
+  Tcl_SetVar2(interp, "sqlite_options", "faultinjector", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "faultinjector", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_FLOATING_POINT
+  Tcl_SetVar2(interp, "sqlite_options", "floatingpoint", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "floatingpoint", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_FOREIGN_KEY
+  Tcl_SetVar2(interp, "sqlite_options", "foreignkey", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "foreignkey", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_FTS1
+  Tcl_SetVar2(interp, "sqlite_options", "fts1", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "fts1", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_FTS2
+  Tcl_SetVar2(interp, "sqlite_options", "fts2", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "fts2", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_FTS3
+  Tcl_SetVar2(interp, "sqlite_options", "fts3", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "fts3", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_GLOBALRECOVER
+  Tcl_SetVar2(interp, "sqlite_options", "globalrecover", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "globalrecover", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_ICU
+  Tcl_SetVar2(interp, "sqlite_options", "icu", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "icu", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_INCRBLOB
+  Tcl_SetVar2(interp, "sqlite_options", "incrblob", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "incrblob", "1", TCL_GLOBAL_ONLY);
+#endif /* SQLITE_OMIT_AUTOVACUUM */
+
+#ifdef SQLITE_OMIT_INTEGRITY_CHECK
+  Tcl_SetVar2(interp, "sqlite_options", "integrityck", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "integrityck", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#if defined(SQLITE_DEFAULT_FILE_FORMAT) && SQLITE_DEFAULT_FILE_FORMAT==1
+  Tcl_SetVar2(interp, "sqlite_options", "legacyformat", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "legacyformat", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION
+  Tcl_SetVar2(interp, "sqlite_options", "like_opt", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "like_opt", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_LOAD_EXTENSION
+  Tcl_SetVar2(interp, "sqlite_options", "load_ext", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "load_ext", "1", TCL_GLOBAL_ONLY);
+#endif
+
+Tcl_SetVar2(interp, "sqlite_options", "long_double",
+              sizeof(LONGDOUBLE_TYPE)>sizeof(double) ? "1" : "0",
+              TCL_GLOBAL_ONLY);
+
+#ifdef SQLITE_OMIT_MEMORYDB
+  Tcl_SetVar2(interp, "sqlite_options", "memorydb", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "memorydb", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  Tcl_SetVar2(interp, "sqlite_options", "memorymanage", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "memorymanage", "0", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_OR_OPTIMIZATION
+  Tcl_SetVar2(interp, "sqlite_options", "or_opt", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "or_opt", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_PAGER_PRAGMAS
+  Tcl_SetVar2(interp, "sqlite_options", "pager_pragmas", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "pager_pragmas", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_PARSER
+  Tcl_SetVar2(interp, "sqlite_options", "parser", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "parser", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#if defined(SQLITE_OMIT_PRAGMA) || defined(SQLITE_OMIT_FLAG_PRAGMAS)
+  Tcl_SetVar2(interp, "sqlite_options", "pragma", "0", TCL_GLOBAL_ONLY);
+  Tcl_SetVar2(interp, "sqlite_options", "integrityck", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "pragma", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_PROGRESS_CALLBACK
+  Tcl_SetVar2(interp, "sqlite_options", "progress", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "progress", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_REINDEX
+  Tcl_SetVar2(interp, "sqlite_options", "reindex", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "reindex", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS
+  Tcl_SetVar2(interp, "sqlite_options", "schema_pragmas", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "schema_pragmas", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
+  Tcl_SetVar2(interp, "sqlite_options", "schema_version", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "schema_version", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_SHARED_CACHE
+  Tcl_SetVar2(interp, "sqlite_options", "shared_cache", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "shared_cache", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_SUBQUERY
+  Tcl_SetVar2(interp, "sqlite_options", "subquery", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "subquery", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_TCL_VARIABLE
+  Tcl_SetVar2(interp, "sqlite_options", "tclvar", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "tclvar", "1", TCL_GLOBAL_ONLY);
+#endif
+
+  rc = sqlite3_threadsafe();
+#if SQLITE_THREADSAFE
+  Tcl_SetVar2(interp, "sqlite_options", "threadsafe", "1", TCL_GLOBAL_ONLY);
+  assert( rc );
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "threadsafe", "0", TCL_GLOBAL_ONLY);
+  assert( !rc );
+#endif
+
+#ifdef SQLITE_OMIT_TRACE
+  Tcl_SetVar2(interp, "sqlite_options", "trace", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "trace", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_TRIGGER
+  Tcl_SetVar2(interp, "sqlite_options", "trigger", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "trigger", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_TEMPDB
+  Tcl_SetVar2(interp, "sqlite_options", "tempdb", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "tempdb", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_UTF16
+  Tcl_SetVar2(interp, "sqlite_options", "utf16", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "utf16", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#if defined(SQLITE_OMIT_VACUUM) || defined(SQLITE_OMIT_ATTACH)
+  Tcl_SetVar2(interp, "sqlite_options", "vacuum", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "vacuum", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_VIEW
+  Tcl_SetVar2(interp, "sqlite_options", "view", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "view", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+  Tcl_SetVar2(interp, "sqlite_options", "vtab", "0", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "vtab", "1", TCL_GLOBAL_ONLY);
+#endif
+
+#define LINKVAR(x) \
+    Tcl_LinkVar(interp, "SQLITE_" #x, (char *)&(sqlite3 ## x), TCL_LINK_INT)
+
+  LINKVAR( MAX_LENGTH );
+  LINKVAR( MAX_COLUMN );
+  LINKVAR( MAX_SQL_LENGTH );
+  LINKVAR( MAX_EXPR_DEPTH );
+  LINKVAR( MAX_COMPOUND_SELECT );
+  LINKVAR( MAX_VDBE_OP );
+  LINKVAR( MAX_FUNCTION_ARG );
+  LINKVAR( MAX_VARIABLE_NUMBER );
+  LINKVAR( MAX_PAGE_SIZE );
+  LINKVAR( MAX_PAGE_COUNT );
+  LINKVAR( MAX_LIKE_PATTERN_LENGTH );
+
+  {
+    static int sqlite_default_temp_cache_size = SQLITE_DEFAULT_TEMP_CACHE_SIZE;
+    Tcl_LinkVar(interp, "SQLITE_DEFAULT_TEMP_CACHE_SIZE",
+           (char*)&sqlite_default_temp_cache_size,
+           TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+  {
+    static int sqlite_default_cache_size = SQLITE_DEFAULT_CACHE_SIZE;
+    Tcl_LinkVar(interp, "SQLITE_DEFAULT_CACHE_SIZE",
+           (char*)&sqlite_default_cache_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+  {
+    static int sqlite_default_page_size = SQLITE_DEFAULT_PAGE_SIZE;
+    Tcl_LinkVar(interp, "SQLITE_DEFAULT_PAGE_SIZE",
+           (char*)&sqlite_default_page_size, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+  {
+    static int temp_store = TEMP_STORE;
+    Tcl_LinkVar(interp, "TEMP_STORE",
+           (char*)&temp_store, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+  {
+    static int sqlite_default_file_format = SQLITE_DEFAULT_FILE_FORMAT;
+    Tcl_LinkVar(interp, "SQLITE_DEFAULT_FILE_FORMAT",
+           (char*)&sqlite_default_file_format, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+  {
+    static int sqlite_max_attached = SQLITE_MAX_ATTACHED;
+    Tcl_LinkVar(interp, "SQLITE_MAX_ATTACHED",
+           (char*)&sqlite_max_attached, TCL_LINK_INT|TCL_LINK_READ_ONLY);
+  }
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqliteconfig_Init(Tcl_Interp *interp){
+  set_options(interp);
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_devsym.c b/client/src/thirdparty/sqlite-3.4.2/src/test_devsym.c
new file mode 100644
index 0000000..724b29d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_devsym.c
@@ -0,0 +1,346 @@
+/*
+** 2008 Jan 22
+**
+** 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 that modified the OS layer in order to simulate
+** different device types (by overriding the return values of the 
+** xDeviceCharacteristics() and xSectorSize() methods).
+*/
+#if SQLITE_TEST          /* This file is used for testing only */
+
+#include <sqlite3.h>
+#include "sqliteInt.h"
+
+/*
+** Maximum pathname length supported by the devsym backend.
+*/
+#define DEVSYM_MAX_PATHNAME 512
+
+/*
+** Name used to identify this VFS.
+*/
+#define DEVSYM_VFS_NAME "devsym"
+
+typedef struct devsym_file devsym_file;
+struct devsym_file {
+  sqlite3_file base;
+  sqlite3_file *pReal;
+};
+
+/*
+** Method declarations for devsym_file.
+*/
+static int devsymClose(sqlite3_file*);
+static int devsymRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+static int devsymWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
+static int devsymTruncate(sqlite3_file*, sqlite3_int64 size);
+static int devsymSync(sqlite3_file*, int flags);
+static int devsymFileSize(sqlite3_file*, sqlite3_int64 *pSize);
+static int devsymLock(sqlite3_file*, int);
+static int devsymUnlock(sqlite3_file*, int);
+static int devsymCheckReservedLock(sqlite3_file*);
+static int devsymFileControl(sqlite3_file*, int op, void *pArg);
+static int devsymSectorSize(sqlite3_file*);
+static int devsymDeviceCharacteristics(sqlite3_file*);
+
+/*
+** Method declarations for devsym_vfs.
+*/
+static int devsymOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
+static int devsymDelete(sqlite3_vfs*, const char *zName, int syncDir);
+static int devsymAccess(sqlite3_vfs*, const char *zName, int flags);
+static int devsymGetTempName(sqlite3_vfs*, int nOut, char *zOut);
+static int devsymFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
+static void *devsymDlOpen(sqlite3_vfs*, const char *zFilename);
+static void devsymDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
+static void *devsymDlSym(sqlite3_vfs*,void*, const char *zSymbol);
+static void devsymDlClose(sqlite3_vfs*, void*);
+static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut);
+static int devsymSleep(sqlite3_vfs*, int microseconds);
+static int devsymCurrentTime(sqlite3_vfs*, double*);
+
+static sqlite3_vfs devsym_vfs = {
+  1,                     /* iVersion */
+  sizeof(devsym_file),      /* szOsFile */
+  DEVSYM_MAX_PATHNAME,      /* mxPathname */
+  0,                     /* pNext */
+  DEVSYM_VFS_NAME,          /* zName */
+  0,                     /* pAppData */
+  devsymOpen,               /* xOpen */
+  devsymDelete,             /* xDelete */
+  devsymAccess,             /* xAccess */
+  devsymGetTempName,        /* xGetTempName */
+  devsymFullPathname,       /* xFullPathname */
+  devsymDlOpen,             /* xDlOpen */
+  devsymDlError,            /* xDlError */
+  devsymDlSym,              /* xDlSym */
+  devsymDlClose,            /* xDlClose */
+  devsymRandomness,         /* xRandomness */
+  devsymSleep,              /* xSleep */
+  devsymCurrentTime         /* xCurrentTime */
+};
+
+static sqlite3_io_methods devsym_io_methods = {
+  1,                            /* iVersion */
+  devsymClose,                      /* xClose */
+  devsymRead,                       /* xRead */
+  devsymWrite,                      /* xWrite */
+  devsymTruncate,                   /* xTruncate */
+  devsymSync,                       /* xSync */
+  devsymFileSize,                   /* xFileSize */
+  devsymLock,                       /* xLock */
+  devsymUnlock,                     /* xUnlock */
+  devsymCheckReservedLock,          /* xCheckReservedLock */
+  devsymFileControl,                /* xFileControl */
+  devsymSectorSize,                 /* xSectorSize */
+  devsymDeviceCharacteristics       /* xDeviceCharacteristics */
+};
+
+struct DevsymGlobal {
+  sqlite3_vfs *pVfs;
+  int iDeviceChar;
+  int iSectorSize;
+};
+struct DevsymGlobal g = {0, 0, 512};
+
+/*
+** Close an devsym-file.
+*/
+static int devsymClose(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsClose(p->pReal);
+}
+
+/*
+** Read data from an devsym-file.
+*/
+static int devsymRead(
+  sqlite3_file *pFile, 
+  void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Write data to an devsym-file.
+*/
+static int devsymWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Truncate an devsym-file.
+*/
+static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsTruncate(p->pReal, size);
+}
+
+/*
+** Sync an devsym-file.
+*/
+static int devsymSync(sqlite3_file *pFile, int flags){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsSync(p->pReal, flags);
+}
+
+/*
+** Return the current file-size of an devsym-file.
+*/
+static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsFileSize(p->pReal, pSize);
+}
+
+/*
+** Lock an devsym-file.
+*/
+static int devsymLock(sqlite3_file *pFile, int eLock){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsLock(p->pReal, eLock);
+}
+
+/*
+** Unlock an devsym-file.
+*/
+static int devsymUnlock(sqlite3_file *pFile, int eLock){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsUnlock(p->pReal, eLock);
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on an devsym-file.
+*/
+static int devsymCheckReservedLock(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsCheckReservedLock(p->pReal);
+}
+
+/*
+** File control method. For custom operations on an devsym-file.
+*/
+static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsFileControl(p->pReal, op, pArg);
+}
+
+/*
+** Return the sector-size in bytes for an devsym-file.
+*/
+static int devsymSectorSize(sqlite3_file *pFile){
+  return g.iSectorSize;
+}
+
+/*
+** Return the device characteristic flags supported by an devsym-file.
+*/
+static int devsymDeviceCharacteristics(sqlite3_file *pFile){
+  return g.iDeviceChar;
+}
+
+/*
+** Open an devsym file handle.
+*/
+static int devsymOpen(
+  sqlite3_vfs *pVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  devsym_file *p = (devsym_file *)pFile;
+  pFile->pMethods = &devsym_io_methods;
+  p->pReal = (sqlite3_file *)&p[1];
+  return sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);
+}
+
+/*
+** Delete the file located at zPath. If the dirSync argument is true,
+** ensure the file-system modifications are synced to disk before
+** returning.
+*/
+static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  return sqlite3OsDelete(g.pVfs, zPath, dirSync);
+}
+
+/*
+** Test for access permissions. Return true if the requested permission
+** is available, or false otherwise.
+*/
+static int devsymAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+  return sqlite3OsAccess(g.pVfs, zPath, flags);
+}
+
+/*
+** Populate buffer zBufOut with a pathname suitable for use as a 
+** temporary file. zBufOut is guaranteed to point to a buffer of 
+** at least (DEVSYM_MAX_PATHNAME+1) bytes.
+*/
+static int devsymGetTempName(sqlite3_vfs *pVfs, int nOut, char *zBufOut){
+  return sqlite3OsGetTempname(g.pVfs, nOut, zBufOut);
+}
+
+/*
+** Populate buffer zOut with the full canonical pathname corresponding
+** to the pathname in zPath. zOut is guaranteed to point to a buffer
+** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
+*/
+static int devsymFullPathname(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int nOut, 
+  char *zOut
+){
+  return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);
+}
+
+/*
+** Open the dynamic library located at zPath and return a handle.
+*/
+static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  return sqlite3OsDlOpen(g.pVfs, zPath);
+}
+
+/*
+** Populate the buffer zErrMsg (size nByte bytes) with a human readable
+** utf-8 string describing the most recent error encountered associated 
+** with dynamic libraries.
+*/
+static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+  sqlite3OsDlError(g.pVfs, nByte, zErrMsg);
+}
+
+/*
+** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
+*/
+static void *devsymDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  return sqlite3OsDlSym(g.pVfs, pHandle, zSymbol);
+}
+
+/*
+** Close the dynamic library handle pHandle.
+*/
+static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  sqlite3OsDlClose(g.pVfs, pHandle);
+}
+
+/*
+** Populate the buffer pointed to by zBufOut with nByte bytes of 
+** random data.
+*/
+static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);
+}
+
+/*
+** Sleep for nMicro microseconds. Return the number of microseconds 
+** actually slept.
+*/
+static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){
+  return sqlite3OsSleep(g.pVfs, nMicro);
+}
+
+/*
+** Return the current time as a Julian Day number in *pTimeOut.
+*/
+static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  return sqlite3OsCurrentTime(g.pVfs, pTimeOut);
+}
+
+/*
+** This procedure registers the devsym vfs with SQLite. If the argument is
+** true, the devsym vfs becomes the new default vfs. It is the only publicly
+** available function in this file.
+*/
+void devsym_register(int iDeviceChar, int iSectorSize){
+  if( g.pVfs==0 ){
+    g.pVfs = sqlite3_vfs_find(0);
+    devsym_vfs.szOsFile += g.pVfs->szOsFile;
+    sqlite3_vfs_register(&devsym_vfs, 0);
+  }
+  if( iDeviceChar>=0 ){
+    g.iDeviceChar = iDeviceChar;
+  }
+  if( iSectorSize>=0 ){
+    g.iSectorSize = iSectorSize;
+  }
+}
+
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_hexio.c b/client/src/thirdparty/sqlite-3.4.2/src/test_hexio.c
new file mode 100644
index 0000000..4dc83e9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_hexio.c
@@ -0,0 +1,336 @@
+/*
+** 2007 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.
+**
+*************************************************************************
+** Code for testing all sorts of SQLite interfaces.  This code
+** implements TCL commands for reading and writing the binary
+** database files and displaying the content of those files as
+** hexadecimal.  We could, in theory, use the built-in "binary"
+** command of TCL to do a lot of this, but there are some issues
+** with historical versions of the "binary" command.  So it seems
+** easier and safer to build our own mechanism.
+**
+** $Id: test_hexio.c,v 1.6 2007/10/19 17:47:25 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+
+/*
+** Convert binary to hex.  The input zBuf[] contains N bytes of
+** binary data.  zBuf[] is 2*n+1 bytes long.  Overwrite zBuf[]
+** with a hexadecimal representation of its original binary input.
+*/
+void sqlite3TestBinToHex(unsigned char *zBuf, int N){
+  const unsigned char zHex[] = "0123456789ABCDEF";
+  int i, j;
+  unsigned char c;
+  i = N*2;
+  zBuf[i--] = 0;
+  for(j=N-1; j>=0; j--){
+    c = zBuf[j];
+    zBuf[i--] = zHex[c&0xf];
+    zBuf[i--] = zHex[c>>4];
+  }
+  assert( i==-1 );
+}
+
+/*
+** Convert hex to binary.  The input zIn[] contains N bytes of
+** hexadecimal.  Convert this into binary and write aOut[] with
+** the binary data.  Spaces in the original input are ignored.
+** Return the number of bytes of binary rendered.
+*/
+int sqlite3TestHexToBin(const unsigned char *zIn, int N, unsigned char *aOut){
+  const unsigned char aMap[] = {
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     1, 2, 3, 4, 5, 6, 7, 8,  9,10, 0, 0, 0, 0, 0, 0,
+     0,11,12,13,14,15,16, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0,11,12,13,14,15,16, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
+  };
+  int i, j;
+  int hi=1;
+  unsigned char c;
+
+  for(i=j=0; i<N; i++){
+    c = aMap[zIn[i]];
+    if( c==0 ) continue;
+    if( hi ){
+      aOut[j] = (c-1)<<4;
+      hi = 0;
+    }else{
+      aOut[j++] |= c-1;
+      hi = 1;
+    }
+  }
+  return j;
+}
+
+
+/*
+** Usage:   hexio_read  FILENAME  OFFSET  AMT
+**
+** Read AMT bytes from file FILENAME beginning at OFFSET from the
+** beginning of the file.  Convert that information to hexadecimal
+** and return the resulting HEX string.
+*/
+static int hexio_read(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int offset;
+  int amt, got;
+  const char *zFile;
+  unsigned char *zBuf;
+  FILE *in;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "FILENAME OFFSET AMT");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &offset) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[3], &amt) ) return TCL_ERROR;
+  zFile = Tcl_GetString(objv[1]);
+  zBuf = sqlite3_malloc( amt*2+1 );
+  if( zBuf==0 ){
+    return TCL_ERROR;
+  }
+  in = fopen(zFile, "r");
+  if( in==0 ){
+    Tcl_AppendResult(interp, "cannot open input file ", zFile, 0);
+    return TCL_ERROR;
+  }
+  fseek(in, offset, SEEK_SET);
+  got = fread(zBuf, 1, amt, in);
+  fclose(in);
+  if( got<0 ){
+    got = 0;
+  }
+  sqlite3TestBinToHex(zBuf, got);
+  Tcl_AppendResult(interp, zBuf, 0);
+  sqlite3_free(zBuf);
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   hexio_write  FILENAME  OFFSET  DATA
+**
+** Write DATA into file FILENAME beginning at OFFSET from the
+** beginning of the file.  DATA is expressed in hexadecimal.
+*/
+static int hexio_write(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int offset;
+  int nIn, nOut, written;
+  const char *zFile;
+  const unsigned char *zIn;
+  unsigned char *aOut;
+  FILE *out;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "FILENAME OFFSET HEXDATA");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &offset) ) return TCL_ERROR;
+  zFile = Tcl_GetString(objv[1]);
+  zIn = (const unsigned char *)Tcl_GetStringFromObj(objv[3], &nIn);
+  aOut = sqlite3_malloc( nIn/2 );
+  if( aOut==0 ){
+    return TCL_ERROR;
+  }
+  nOut = sqlite3TestHexToBin(zIn, nIn, aOut);
+  out = fopen(zFile, "r+");
+  if( out==0 ){
+    Tcl_AppendResult(interp, "cannot open output file ", zFile, 0);
+    return TCL_ERROR;
+  }
+  fseek(out, offset, SEEK_SET);
+  written = fwrite(aOut, 1, nOut, out);
+  sqlite3_free(aOut);
+  fclose(out);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(written));
+  return TCL_OK;
+}
+
+/*
+** USAGE:   hexio_get_int   HEXDATA
+**
+** Interpret the HEXDATA argument as a big-endian integer.  Return
+** the value of that integer.  HEXDATA can contain between 2 and 8
+** hexadecimal digits.
+*/
+static int hexio_get_int(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int val;
+  int nIn, nOut;
+  const unsigned char *zIn;
+  unsigned char *aOut;
+  unsigned char aNum[4];
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "HEXDATA");
+    return TCL_ERROR;
+  }
+  zIn = (const unsigned char *)Tcl_GetStringFromObj(objv[1], &nIn);
+  aOut = sqlite3_malloc( nIn/2 );
+  if( aOut==0 ){
+    return TCL_ERROR;
+  }
+  nOut = sqlite3TestHexToBin(zIn, nIn, aOut);
+  if( nOut>=4 ){
+    memcpy(aNum, aOut, 4);
+  }else{
+    memset(aNum, 0, sizeof(aNum));
+    memcpy(&aNum[4-nOut], aOut, nOut);
+  }
+  sqlite3_free(aOut);
+  val = (aNum[0]<<24) | (aNum[1]<<16) | (aNum[2]<<8) | aNum[3];
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(val));
+  return TCL_OK;
+}
+
+
+/*
+** USAGE:   hexio_render_int16   INTEGER
+**
+** Render INTEGER has a 16-bit big-endian integer in hexadecimal.
+*/
+static int hexio_render_int16(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int val;
+  unsigned char aNum[10];
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "INTEGER");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &val) ) return TCL_ERROR;
+  aNum[0] = val>>8;
+  aNum[1] = val;
+  sqlite3TestBinToHex(aNum, 2);
+  Tcl_SetObjResult(interp, Tcl_NewStringObj((char*)aNum, 4));
+  return TCL_OK;
+}
+
+
+/*
+** USAGE:   hexio_render_int32   INTEGER
+**
+** Render INTEGER has a 32-bit big-endian integer in hexadecimal.
+*/
+static int hexio_render_int32(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int val;
+  unsigned char aNum[10];
+
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "INTEGER");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &val) ) return TCL_ERROR;
+  aNum[0] = val>>24;
+  aNum[1] = val>>16;
+  aNum[2] = val>>8;
+  aNum[3] = val;
+  sqlite3TestBinToHex(aNum, 4);
+  Tcl_SetObjResult(interp, Tcl_NewStringObj((char*)aNum, 8));
+  return TCL_OK;
+}
+
+/*
+** USAGE:  utf8_to_utf8  HEX
+**
+** The argument is a UTF8 string represented in hexadecimal.
+** The UTF8 might not be well-formed.  Run this string through
+** sqlite3Utf8to8() convert it back to hex and return the result.
+*/
+static int utf8_to_utf8(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifdef SQLITE_DEBUG
+  int n;
+  int nOut;
+  const unsigned char *zOrig;
+  unsigned char *z;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "HEX");
+    return TCL_ERROR;
+  }
+  zOrig = (unsigned char *)Tcl_GetStringFromObj(objv[1], &n);
+  z = sqlite3_malloc( n+3 );
+  n = sqlite3TestHexToBin(zOrig, n, z);
+  z[n] = 0;
+  nOut = sqlite3Utf8To8(z);
+  sqlite3TestBinToHex(z,nOut);
+  Tcl_AppendResult(interp, (char*)z, 0);
+  sqlite3_free(z);
+#endif
+  return TCL_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest_hexio_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+  } aObjCmd[] = {
+     { "hexio_read",                   hexio_read            },
+     { "hexio_write",                  hexio_write           },
+     { "hexio_get_int",                hexio_get_int         },
+     { "hexio_render_int16",           hexio_render_int16    },
+     { "hexio_render_int32",           hexio_render_int32    },
+     { "utf8_to_utf8",                 utf8_to_utf8          },
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
+  }
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_loadext.c b/client/src/thirdparty/sqlite-3.4.2/src/test_loadext.c
new file mode 100644
index 0000000..1204971
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_loadext.c
@@ -0,0 +1,57 @@
+/*
+** 2006 June 14
+**
+** 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.
+**
+*************************************************************************
+** Test extension for testing the sqlite3_load_extension() function.
+**
+** $Id: test_loadext.c,v 1.1 2006/06/14 10:38:03 danielk1977 Exp $
+*/
+
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+/*
+** The half() SQL function returns half of its input value.
+*/
+static void halfFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3_result_double(context, 0.5*sqlite3_value_double(argv[0]));
+}
+
+/*
+** Extension load function.
+*/
+int testloadext_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi);
+  sqlite3_create_function(db, "half", 1, SQLITE_ANY, 0, halfFunc, 0, 0);
+  return 0;
+}
+
+/*
+** Another extension entry point. This one always fails.
+*/
+int testbrokenext_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  char *zErr;
+  SQLITE_EXTENSION_INIT2(pApi);
+  zErr = sqlite3_mprintf("broken!");
+  *pzErrMsg = zErr;
+  return 1;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_malloc.c b/client/src/thirdparty/sqlite-3.4.2/src/test_malloc.c
new file mode 100644
index 0000000..d581ea3
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_malloc.c
@@ -0,0 +1,513 @@
+/*
+** 2007 August 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.
+**
+*************************************************************************
+**
+** This file contains code used to implement test interfaces to the
+** memory allocation subsystem.
+**
+** $Id: test_malloc.c,v 1.11 2008/01/31 14:43:24 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+/*
+** Transform pointers to text and back again
+*/
+static void pointerToText(void *p, char *z){
+  static const char zHex[] = "0123456789abcdef";
+  int i, k;
+  unsigned int u;
+  sqlite3_uint64 n;
+  if( sizeof(n)==sizeof(p) ){
+    memcpy(&n, &p, sizeof(p));
+  }else if( sizeof(u)==sizeof(p) ){
+    memcpy(&u, &p, sizeof(u));
+    n = u;
+  }else{
+    assert( 0 );
+  }
+  for(i=0, k=sizeof(p)*2-1; i<sizeof(p)*2; i++, k--){
+    z[k] = zHex[n&0xf];
+    n >>= 4;
+  }
+  z[sizeof(p)*2] = 0;
+}
+static int hexToInt(int h){
+  if( h>='0' && h<='9' ){
+    return h - '0';
+  }else if( h>='a' && h<='f' ){
+    return h - 'a' + 10;
+  }else{
+    return -1;
+  }
+}
+static int textToPointer(const char *z, void **pp){
+  sqlite3_uint64 n = 0;
+  int i;
+  unsigned int u;
+  for(i=0; i<sizeof(void*)*2 && z[0]; i++){
+    int v;
+    v = hexToInt(*z++);
+    if( v<0 ) return TCL_ERROR;
+    n = n*16 + v;
+  }
+  if( *z!=0 ) return TCL_ERROR;
+  if( sizeof(n)==sizeof(*pp) ){
+    memcpy(pp, &n, sizeof(n));
+  }else if( sizeof(u)==sizeof(*pp) ){
+    u = (unsigned int)n;
+    memcpy(pp, &u, sizeof(u));
+  }else{
+    assert( 0 );
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_malloc  NBYTES
+**
+** Raw test interface for sqlite3_malloc().
+*/
+static int test_malloc(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int nByte;
+  void *p;
+  char zOut[100];
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "NBYTES");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &nByte) ) return TCL_ERROR;
+  p = sqlite3_malloc((unsigned)nByte);
+  pointerToText(p, zOut);
+  Tcl_AppendResult(interp, zOut, NULL);
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_realloc  PRIOR  NBYTES
+**
+** Raw test interface for sqlite3_realloc().
+*/
+static int test_realloc(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int nByte;
+  void *pPrior, *p;
+  char zOut[100];
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "PRIOR NBYTES");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &nByte) ) return TCL_ERROR;
+  if( textToPointer(Tcl_GetString(objv[1]), &pPrior) ){
+    Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0);
+    return TCL_ERROR;
+  }
+  p = sqlite3_realloc(pPrior, (unsigned)nByte);
+  pointerToText(p, zOut);
+  Tcl_AppendResult(interp, zOut, NULL);
+  return TCL_OK;
+}
+
+
+/*
+** Usage:    sqlite3_free  PRIOR
+**
+** Raw test interface for sqlite3_free().
+*/
+static int test_free(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  void *pPrior;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "PRIOR");
+    return TCL_ERROR;
+  }
+  if( textToPointer(Tcl_GetString(objv[1]), &pPrior) ){
+    Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0);
+    return TCL_ERROR;
+  }
+  sqlite3_free(pPrior);
+  return TCL_OK;
+}
+
+/*
+** These routines are in test_hexio.c
+*/
+int sqlite3TestHexToBin(const char *, int, char *);
+int sqlite3TestBinToHex(char*,int);
+
+/*
+** Usage:    memset  ADDRESS  SIZE  HEX
+**
+** Set a chunk of memory (obtained from malloc, probably) to a
+** specified hex pattern.
+*/
+static int test_memset(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  void *p;
+  int size, n, i;
+  char *zHex;
+  char *zOut;
+  char zBin[100];
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE HEX");
+    return TCL_ERROR;
+  }
+  if( textToPointer(Tcl_GetString(objv[1]), &p) ){
+    Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &size) ){
+    return TCL_ERROR;
+  }
+  if( size<=0 ){
+    Tcl_AppendResult(interp, "size must be positive", (char*)0);
+    return TCL_ERROR;
+  }
+  zHex = Tcl_GetStringFromObj(objv[3], &n);
+  if( n>sizeof(zBin)*2 ) n = sizeof(zBin)*2;
+  n = sqlite3TestHexToBin(zHex, n, zBin);
+  if( n==0 ){
+    Tcl_AppendResult(interp, "no data", (char*)0);
+    return TCL_ERROR;
+  }
+  zOut = p;
+  for(i=0; i<size; i++){
+    zOut[i] = zBin[i%n];
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:    memget  ADDRESS  SIZE
+**
+** Return memory as hexadecimal text.
+*/
+static int test_memget(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  void *p;
+  int size, n;
+  char *zBin;
+  char zHex[100];
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE");
+    return TCL_ERROR;
+  }
+  if( textToPointer(Tcl_GetString(objv[1]), &p) ){
+    Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &size) ){
+    return TCL_ERROR;
+  }
+  if( size<=0 ){
+    Tcl_AppendResult(interp, "size must be positive", (char*)0);
+    return TCL_ERROR;
+  }
+  zBin = p;
+  while( size>0 ){
+    if( size>(sizeof(zHex)-1)/2 ){
+      n = (sizeof(zHex)-1)/2;
+    }else{
+      n = size;
+    }
+    memcpy(zHex, zBin, n);
+    zBin += n;
+    size -= n;
+    sqlite3TestBinToHex(zHex, n);
+    Tcl_AppendResult(interp, zHex, (char*)0);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_memory_used
+**
+** Raw test interface for sqlite3_memory_used().
+*/
+static int test_memory_used(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sqlite3_memory_used()));
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_memory_highwater ?RESETFLAG?
+**
+** Raw test interface for sqlite3_memory_highwater().
+*/
+static int test_memory_highwater(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int resetFlag = 0;
+  if( objc!=1 && objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "?RESET?");
+    return TCL_ERROR;
+  }
+  if( objc==2 ){
+    if( Tcl_GetBooleanFromObj(interp, objv[1], &resetFlag) ) return TCL_ERROR;
+  } 
+  Tcl_SetObjResult(interp, 
+     Tcl_NewWideIntObj(sqlite3_memory_highwater(resetFlag)));
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_memdebug_backtrace DEPTH
+**
+** Set the depth of backtracing.  If SQLITE_MEMDEBUG is not defined
+** then this routine is a no-op.
+*/
+static int test_memdebug_backtrace(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int depth;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DEPT");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &depth) ) return TCL_ERROR;
+#ifdef SQLITE_MEMDEBUG
+  {
+    extern void sqlite3_memdebug_backtrace(int);
+    sqlite3_memdebug_backtrace(depth);
+  }
+#endif
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_memdebug_dump  FILENAME
+**
+** Write a summary of unfreed memory to FILENAME.
+*/
+static int test_memdebug_dump(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
+    return TCL_ERROR;
+  }
+#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE)
+  {
+    extern void sqlite3_memdebug_dump(const char*);
+    sqlite3_memdebug_dump(Tcl_GetString(objv[1]));
+  }
+#endif
+  return TCL_OK;
+}
+
+
+/*
+** Usage:    sqlite3_memdebug_fail  COUNTER  ?OPTIONS?
+**
+** where options are:
+**
+**     -repeat    <count>
+**     -benigncnt <varname>
+**
+** Arrange for a simulated malloc() failure after COUNTER successes.
+** If a repeat count is specified, the fault is repeated that many
+** times.
+**
+** Each call to this routine overrides the prior counter value.
+** This routine returns the number of simulated failures that have
+** happened since the previous call to this routine.
+**
+** To disable simulated failures, use a COUNTER of -1.
+*/
+static int test_memdebug_fail(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int ii;
+  int iFail;
+  int nRepeat = 1;
+  Tcl_Obj *pBenignCnt = 0;
+  int nBenign;
+  int nFail = 0;
+
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "COUNTER ?OPTIONS?");
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[1], &iFail) ) return TCL_ERROR;
+
+  for(ii=2; ii<objc; ii+=2){
+    int nOption;
+    char *zOption = Tcl_GetStringFromObj(objv[ii], &nOption);
+    char *zErr = 0;
+
+    if( nOption>1 && strncmp(zOption, "-repeat", nOption)==0 ){
+      if( ii==(objc-1) ){
+        zErr = "option requires an argument: ";
+      }else{
+        if( Tcl_GetIntFromObj(interp, objv[ii+1], &nRepeat) ){
+          return TCL_ERROR;
+        }
+      }
+    }else if( nOption>1 && strncmp(zOption, "-benigncnt", nOption)==0 ){
+      if( ii==(objc-1) ){
+        zErr = "option requires an argument: ";
+      }else{
+        pBenignCnt = objv[ii+1];
+      }
+    }else{
+      zErr = "unknown option: ";
+    }
+
+    if( zErr ){
+      Tcl_AppendResult(interp, zErr, zOption, 0);
+      return TCL_ERROR;
+    }
+  }
+  
+  nBenign = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES,
+                                 SQLITE_FAULTINJECTOR_MALLOC);
+  nFail = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_FAILURES,
+                               SQLITE_FAULTINJECTOR_MALLOC);
+  sqlite3_test_control(SQLITE_TESTCTRL_FAULT_CONFIG,
+                       SQLITE_FAULTINJECTOR_MALLOC, iFail, nRepeat);
+  if( pBenignCnt ){
+    Tcl_ObjSetVar2(interp, pBenignCnt, 0, Tcl_NewIntObj(nBenign), 0);
+  }
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(nFail));
+  return TCL_OK;
+}
+
+/*
+** Usage:    sqlite3_memdebug_pending
+**
+** Return the number of malloc() calls that will succeed before a 
+** simulated failure occurs. A negative return value indicates that
+** no malloc() failure is scheduled.
+*/
+static int test_memdebug_pending(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  if( objc!=1 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "");
+    return TCL_ERROR;
+  }
+
+#ifdef SQLITE_MEMDEBUG
+  {
+    int nPending = sqlite3_test_control(SQLITE_TESTCTRL_FAULT_PENDING,
+                                        SQLITE_FAULTINJECTOR_MALLOC);
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(nPending));
+  }
+#endif
+  return TCL_OK;
+}
+
+
+/*
+** Usage:    sqlite3_memdebug_settitle TITLE
+**
+** Set a title string stored with each allocation.  The TITLE is
+** typically the name of the test that was running when the
+** allocation occurred.  The TITLE is stored with the allocation
+** and can be used to figure out which tests are leaking memory.
+**
+** Each title overwrite the previous.
+*/
+static int test_memdebug_settitle(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  const char *zTitle;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "TITLE");
+    return TCL_ERROR;
+  }
+  zTitle = Tcl_GetString(objv[1]);
+#ifdef SQLITE_MEMDEBUG
+  {
+    extern int sqlite3_memdebug_settitle(const char*);
+    sqlite3_memdebug_settitle(zTitle);
+  }
+#endif
+  return TCL_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest_malloc_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+  } aObjCmd[] = {
+     { "sqlite3_malloc",             test_malloc                   },
+     { "sqlite3_realloc",            test_realloc                  },
+     { "sqlite3_free",               test_free                     },
+     { "memset",                     test_memset                   },
+     { "memget",                     test_memget                   },
+     { "sqlite3_memory_used",        test_memory_used              },
+     { "sqlite3_memory_highwater",   test_memory_highwater         },
+     { "sqlite3_memdebug_backtrace", test_memdebug_backtrace       },
+     { "sqlite3_memdebug_dump",      test_memdebug_dump            },
+     { "sqlite3_memdebug_fail",      test_memdebug_fail            },
+     { "sqlite3_memdebug_pending",   test_memdebug_pending         },
+     { "sqlite3_memdebug_settitle",  test_memdebug_settitle        },
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
+  }
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_md5.c b/client/src/thirdparty/sqlite-3.4.2/src/test_md5.c
new file mode 100644
index 0000000..792fc85
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_md5.c
@@ -0,0 +1,388 @@
+/*
+** SQLite uses this code for testing only.  It is not a part of
+** the SQLite library.  This file implements two new TCL commands
+** "md5" and "md5file" that compute md5 checksums on arbitrary text
+** and on complete files.  These commands are used by the "testfixture"
+** program to help verify the correct operation of the SQLite library.
+**
+** The original use of these TCL commands was to test the ROLLBACK
+** feature of SQLite.  First compute the MD5-checksum of the database.
+** Then make some changes but rollback the changes rather than commit
+** them.  Compute a second MD5-checksum of the file and verify that the
+** two checksums are the same.  Such is the original use of this code.
+** New uses may have been added since this comment was written.
+*/
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+#include <tcl.h>
+#include <string.h>
+#include "sqlite3.h"
+
+/*
+ * If compiled on a machine that doesn't have a 32-bit integer,
+ * you just set "uint32" to the appropriate datatype for an
+ * unsigned 32-bit integer.  For example:
+ *
+ *       cc -Duint32='unsigned long' md5.c
+ *
+ */
+#ifndef uint32
+#  define uint32 unsigned int
+#endif
+
+struct Context {
+  int isInit;
+  uint32 buf[4];
+  uint32 bits[2];
+  unsigned char in[64];
+};
+typedef struct Context MD5Context;
+
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+static void byteReverse (unsigned char *buf, unsigned longs){
+        uint32 t;
+        do {
+                t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
+                            ((unsigned)buf[1]<<8 | buf[0]);
+                *(uint32 *)buf = t;
+                buf += 4;
+        } while (--longs);
+}
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+static void MD5Transform(uint32 buf[4], const uint32 in[16]){
+        register uint32 a, b, c, d;
+
+        a = buf[0];
+        b = buf[1];
+        c = buf[2];
+        d = buf[3];
+
+        MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
+        MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
+        MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
+        MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
+        MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
+        MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
+        MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
+        MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
+        MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
+        MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
+        MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
+        MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
+        MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
+        MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
+        MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
+        MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
+
+        MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
+        MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
+        MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
+        MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
+        MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
+        MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
+        MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
+        MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
+        MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
+        MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
+        MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
+        MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
+        MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
+        MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
+        MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
+        MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
+
+        MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
+        MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
+        MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
+        MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
+        MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
+        MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
+        MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
+        MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
+        MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
+        MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
+        MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
+        MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
+        MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
+        MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
+        MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
+        MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
+
+        MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
+        MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
+        MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
+        MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
+        MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
+        MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
+        MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
+        MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
+        MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
+        MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
+        MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
+        MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
+        MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
+        MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
+        MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
+        MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
+
+        buf[0] += a;
+        buf[1] += b;
+        buf[2] += c;
+        buf[3] += d;
+}
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+static void MD5Init(MD5Context *ctx){
+        ctx->isInit = 1;
+        ctx->buf[0] = 0x67452301;
+        ctx->buf[1] = 0xefcdab89;
+        ctx->buf[2] = 0x98badcfe;
+        ctx->buf[3] = 0x10325476;
+        ctx->bits[0] = 0;
+        ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+static 
+void MD5Update(MD5Context *pCtx, const unsigned char *buf, unsigned int len){
+        struct Context *ctx = (struct Context *)pCtx;
+        uint32 t;
+
+        /* Update bitcount */
+
+        t = ctx->bits[0];
+        if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
+                ctx->bits[1]++; /* Carry from low to high */
+        ctx->bits[1] += len >> 29;
+
+        t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
+
+        /* Handle any leading odd-sized chunks */
+
+        if ( t ) {
+                unsigned char *p = (unsigned char *)ctx->in + t;
+
+                t = 64-t;
+                if (len < t) {
+                        memcpy(p, buf, len);
+                        return;
+                }
+                memcpy(p, buf, t);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                buf += t;
+                len -= t;
+        }
+
+        /* Process data in 64-byte chunks */
+
+        while (len >= 64) {
+                memcpy(ctx->in, buf, 64);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                buf += 64;
+                len -= 64;
+        }
+
+        /* Handle any remaining bytes of data. */
+
+        memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+static void MD5Final(unsigned char digest[16], MD5Context *pCtx){
+        struct Context *ctx = (struct Context *)pCtx;
+        unsigned count;
+        unsigned char *p;
+
+        /* Compute number of bytes mod 64 */
+        count = (ctx->bits[0] >> 3) & 0x3F;
+
+        /* Set the first char of padding to 0x80.  This is safe since there is
+           always at least one byte free */
+        p = ctx->in + count;
+        *p++ = 0x80;
+
+        /* Bytes of padding needed to make 64 bytes */
+        count = 64 - 1 - count;
+
+        /* Pad out to 56 mod 64 */
+        if (count < 8) {
+                /* Two lots of padding:  Pad the first block to 64 bytes */
+                memset(p, 0, count);
+                byteReverse(ctx->in, 16);
+                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+
+                /* Now fill the next block with 56 bytes */
+                memset(ctx->in, 0, 56);
+        } else {
+                /* Pad block to 56 bytes */
+                memset(p, 0, count-8);
+        }
+        byteReverse(ctx->in, 14);
+
+        /* Append length in bits and transform */
+        ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
+        ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
+
+        MD5Transform(ctx->buf, (uint32 *)ctx->in);
+        byteReverse((unsigned char *)ctx->buf, 4);
+        memcpy(digest, ctx->buf, 16);
+        memset(ctx, 0, sizeof(ctx));    /* In case it is sensitive */
+}
+
+/*
+** Convert a digest into base-16.  digest should be declared as
+** "unsigned char digest[16]" in the calling function.  The MD5
+** digest is stored in the first 16 bytes.  zBuf should
+** be "char zBuf[33]".
+*/
+static void DigestToBase16(unsigned char *digest, char *zBuf){
+  static char const zEncode[] = "0123456789abcdef";
+  int i, j;
+
+  for(j=i=0; i<16; i++){
+    int a = digest[i];
+    zBuf[j++] = zEncode[(a>>4)&0xf];
+    zBuf[j++] = zEncode[a & 0xf];
+  }
+  zBuf[j] = 0;
+}
+
+/*
+** A TCL command for md5.  The argument is the text to be hashed.  The
+** Result is the hash in base64.  
+*/
+static int md5_cmd(void*cd, Tcl_Interp *interp, int argc, const char **argv){
+  MD5Context ctx;
+  unsigned char digest[16];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0], 
+        " TEXT\"", 0);
+    return TCL_ERROR;
+  }
+  MD5Init(&ctx);
+  MD5Update(&ctx, (unsigned char*)argv[1], (unsigned)strlen(argv[1]));
+  MD5Final(digest, &ctx);
+  DigestToBase16(digest, interp->result);
+  return TCL_OK;
+}
+
+/*
+** A TCL command to take the md5 hash of a file.  The argument is the
+** name of the file.
+*/
+static int md5file_cmd(void*cd, Tcl_Interp*interp, int argc, const char **argv){
+  FILE *in;
+  MD5Context ctx;
+  unsigned char digest[16];
+  char zBuf[10240];
+
+  if( argc!=2 ){
+    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0], 
+        " FILENAME\"", 0);
+    return TCL_ERROR;
+  }
+  in = fopen(argv[1],"rb");
+  if( in==0 ){
+    Tcl_AppendResult(interp,"unable to open file \"", argv[1], 
+         "\" for reading", 0);
+    return TCL_ERROR;
+  }
+  MD5Init(&ctx);
+  for(;;){
+    int n;
+    n = fread(zBuf, 1, sizeof(zBuf), in);
+    if( n<=0 ) break;
+    MD5Update(&ctx, (unsigned char*)zBuf, (unsigned)n);
+  }
+  fclose(in);
+  MD5Final(digest, &ctx);
+  DigestToBase16(digest, interp->result);
+  return TCL_OK;
+}
+
+/*
+** Register the two TCL commands above with the TCL interpreter.
+*/
+int Md5_Init(Tcl_Interp *interp){
+  Tcl_CreateCommand(interp, "md5", (Tcl_CmdProc*)md5_cmd, 0, 0);
+  Tcl_CreateCommand(interp, "md5file", (Tcl_CmdProc*)md5file_cmd, 0, 0);
+  return TCL_OK;
+}
+
+/*
+** During testing, the special md5sum() aggregate function is available.
+** inside SQLite.  The following routines implement that function.
+*/
+static void md5step(sqlite3_context *context, int argc, sqlite3_value **argv){
+  MD5Context *p;
+  int i;
+  if( argc<1 ) return;
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  if( p==0 ) return;
+  if( !p->isInit ){
+    MD5Init(p);
+  }
+  for(i=0; i<argc; i++){
+    const char *zData = (char*)sqlite3_value_text(argv[i]);
+    if( zData ){
+      MD5Update(p, (unsigned char*)zData, strlen(zData));
+    }
+  }
+}
+static void md5finalize(sqlite3_context *context){
+  MD5Context *p;
+  unsigned char digest[16];
+  char zBuf[33];
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  MD5Final(digest,p);
+  DigestToBase16(digest, zBuf);
+  sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
+}
+int Md5_Register(sqlite3 *db){
+  return sqlite3_create_function(db, "md5sum", -1, SQLITE_UTF8, 0, 0, 
+                                 md5step, md5finalize);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_onefile.c b/client/src/thirdparty/sqlite-3.4.2/src/test_onefile.c
new file mode 100644
index 0000000..7331cb8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_onefile.c
@@ -0,0 +1,824 @@
+/*
+** 2007 September 14
+**
+** 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.
+**
+*************************************************************************
+**
+** OVERVIEW:
+**
+**   This file contains some example code demonstrating how the SQLite 
+**   vfs feature can be used to have SQLite operate directly on an 
+**   embedded media, without using an intermediate file system.
+**
+**   Because this is only a demo designed to run on a workstation, the
+**   underlying media is simulated using a regular file-system file. The
+**   size of the file is fixed when it is first created (default size 10 MB).
+**   From SQLite's point of view, this space is used to store a single
+**   database file and the journal file. 
+**
+**   Any statement journal created is stored in volatile memory obtained 
+**   from sqlite3_malloc(). Any attempt to create a temporary database file 
+**   will fail (SQLITE_IOERR). To prevent SQLite from attempting this,
+**   it should be configured to store all temporary database files in 
+**   main memory (see pragma "temp_store" or the TEMP_STORE compile time
+**   option).
+**
+** ASSUMPTIONS:
+**
+**   After it has been created, the blob file is accessed using the
+**   following three functions only:
+**
+**       mediaRead();            - Read a 512 byte block from the file.
+**       mediaWrite();           - Write a 512 byte block to the file.
+**       mediaSync();            - Tell the media hardware to sync.
+**
+**   It is assumed that these can be easily implemented by any "real"
+**   media vfs driver adapting this code.
+**
+** FILE FORMAT:
+**
+**   The basic principle is that the "database file" is stored at the
+**   beginning of the 10 MB blob and grows in a forward direction. The 
+**   "journal file" is stored at the end of the 10MB blob and grows
+**   in the reverse direction. If, during a transaction, insufficient
+**   space is available to expand either the journal or database file,
+**   an SQLITE_FULL error is returned. The database file is never allowed
+**   to consume more than 90% of the blob space. If SQLite tries to
+**   create a file larger than this, SQLITE_FULL is returned.
+**
+**   No allowance is made for "wear-leveling", as is required by.
+**   embedded devices in the absence of equivalent hardware features.
+**
+**   The first 512 block byte of the file is reserved for storing the
+**   size of the "database file". It is updated as part of the sync()
+**   operation. On startup, it can only be trusted if no journal file
+**   exists. If a journal-file does exist, then it stores the real size
+**   of the database region. The second and subsequent blocks store the 
+**   actual database content.
+**
+**   The size of the "journal file" is not stored persistently in the 
+**   file. When the system is running, the size of the journal file is
+**   stored in volatile memory. When recovering from a crash, this vfs
+**   reports a very large size for the journal file. The normal journal
+**   header and checksum mechanisms serve to prevent SQLite from 
+**   processing any data that lies past the logical end of the journal.
+**
+**   When SQLite calls OsDelete() to delete the journal file, the final
+**   512 bytes of the blob (the area containing the first journal header)
+**   are zeroed.
+**
+** LOCKING:
+**
+**   File locking is a no-op. Only one connection may be open at any one
+**   time using this demo vfs.
+*/
+
+#include <sqlite3.h>
+#include <assert.h>
+#include <string.h>
+
+/*
+** Maximum pathname length supported by the fs backend.
+*/
+#define BLOCKSIZE 512
+#define BLOBSIZE 10485760
+
+/*
+** Name used to identify this VFS.
+*/
+#define FS_VFS_NAME "fs"
+
+typedef struct fs_real_file fs_real_file;
+struct fs_real_file {
+  sqlite3_file *pFile;
+  const char *zName;
+  int nDatabase;              /* Current size of database region */
+  int nJournal;               /* Current size of journal region */
+  int nBlob;                  /* Total size of allocated blob */
+  int nRef;                   /* Number of pointers to this structure */
+  fs_real_file *pNext;
+  fs_real_file **ppThis;
+};
+
+typedef struct fs_file fs_file;
+struct fs_file {
+  sqlite3_file base;
+  int eType;
+  fs_real_file *pReal;
+};
+
+typedef struct tmp_file tmp_file;
+struct tmp_file {
+  sqlite3_file base;
+  int nSize;
+  int nAlloc;
+  char *zAlloc;
+};
+
+/* Values for fs_file.eType. */
+#define DATABASE_FILE   1
+#define JOURNAL_FILE    2
+
+/*
+** Method declarations for fs_file.
+*/
+static int fsClose(sqlite3_file*);
+static int fsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+static int fsWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
+static int fsTruncate(sqlite3_file*, sqlite3_int64 size);
+static int fsSync(sqlite3_file*, int flags);
+static int fsFileSize(sqlite3_file*, sqlite3_int64 *pSize);
+static int fsLock(sqlite3_file*, int);
+static int fsUnlock(sqlite3_file*, int);
+static int fsCheckReservedLock(sqlite3_file*);
+static int fsFileControl(sqlite3_file*, int op, void *pArg);
+static int fsSectorSize(sqlite3_file*);
+static int fsDeviceCharacteristics(sqlite3_file*);
+
+/*
+** Method declarations for tmp_file.
+*/
+static int tmpClose(sqlite3_file*);
+static int tmpRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+static int tmpWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
+static int tmpTruncate(sqlite3_file*, sqlite3_int64 size);
+static int tmpSync(sqlite3_file*, int flags);
+static int tmpFileSize(sqlite3_file*, sqlite3_int64 *pSize);
+static int tmpLock(sqlite3_file*, int);
+static int tmpUnlock(sqlite3_file*, int);
+static int tmpCheckReservedLock(sqlite3_file*);
+static int tmpFileControl(sqlite3_file*, int op, void *pArg);
+static int tmpSectorSize(sqlite3_file*);
+static int tmpDeviceCharacteristics(sqlite3_file*);
+
+/*
+** Method declarations for fs_vfs.
+*/
+static int fsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
+static int fsDelete(sqlite3_vfs*, const char *zName, int syncDir);
+static int fsAccess(sqlite3_vfs*, const char *zName, int flags);
+static int fsGetTempname(sqlite3_vfs*, int nOut, char *zOut);
+static int fsFullPathname(sqlite3_vfs*, const char *zName, int nOut,char *zOut);
+static void *fsDlOpen(sqlite3_vfs*, const char *zFilename);
+static void fsDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
+static void *fsDlSym(sqlite3_vfs*,void*, const char *zSymbol);
+static void fsDlClose(sqlite3_vfs*, void*);
+static int fsRandomness(sqlite3_vfs*, int nByte, char *zOut);
+static int fsSleep(sqlite3_vfs*, int microseconds);
+static int fsCurrentTime(sqlite3_vfs*, double*);
+
+
+typedef struct fs_vfs_t fs_vfs_t;
+struct fs_vfs_t {
+  sqlite3_vfs base;
+  fs_real_file *pFileList;
+  sqlite3_vfs *pParent;
+};
+
+static fs_vfs_t fs_vfs = {
+  {
+    1,                                          /* iVersion */
+    0,                                          /* szOsFile */
+    0,                                          /* mxPathname */
+    0,                                          /* pNext */
+    FS_VFS_NAME,                                /* zName */
+    0,                                          /* pAppData */
+    fsOpen,                                     /* xOpen */
+    fsDelete,                                   /* xDelete */
+    fsAccess,                                   /* xAccess */
+    fsGetTempname,                              /* xGetTempName */
+    fsFullPathname,                             /* xFullPathname */
+    fsDlOpen,                                   /* xDlOpen */
+    fsDlError,                                  /* xDlError */
+    fsDlSym,                                    /* xDlSym */
+    fsDlClose,                                  /* xDlClose */
+    fsRandomness,                               /* xRandomness */
+    fsSleep,                                    /* xSleep */
+    fsCurrentTime                               /* xCurrentTime */
+  }, 
+  0,                                            /* pFileList */
+  0                                             /* pParent */
+};
+
+static sqlite3_io_methods fs_io_methods = {
+  1,                            /* iVersion */
+  fsClose,                      /* xClose */
+  fsRead,                       /* xRead */
+  fsWrite,                      /* xWrite */
+  fsTruncate,                   /* xTruncate */
+  fsSync,                       /* xSync */
+  fsFileSize,                   /* xFileSize */
+  fsLock,                       /* xLock */
+  fsUnlock,                     /* xUnlock */
+  fsCheckReservedLock,          /* xCheckReservedLock */
+  fsFileControl,                /* xFileControl */
+  fsSectorSize,                 /* xSectorSize */
+  fsDeviceCharacteristics       /* xDeviceCharacteristics */
+};
+
+
+static sqlite3_io_methods tmp_io_methods = {
+  1,                            /* iVersion */
+  tmpClose,                     /* xClose */
+  tmpRead,                      /* xRead */
+  tmpWrite,                     /* xWrite */
+  tmpTruncate,                  /* xTruncate */
+  tmpSync,                      /* xSync */
+  tmpFileSize,                  /* xFileSize */
+  tmpLock,                      /* xLock */
+  tmpUnlock,                    /* xUnlock */
+  tmpCheckReservedLock,         /* xCheckReservedLock */
+  tmpFileControl,               /* xFileControl */
+  tmpSectorSize,                /* xSectorSize */
+  tmpDeviceCharacteristics      /* xDeviceCharacteristics */
+};
+
+/* Useful macros used in several places */
+#define MIN(x,y) ((x)<(y)?(x):(y))
+#define MAX(x,y) ((x)>(y)?(x):(y))
+
+
+/*
+** Close a tmp-file.
+*/
+static int tmpClose(sqlite3_file *pFile){
+  tmp_file *pTmp = (tmp_file *)pFile;
+  sqlite3_free(pTmp->zAlloc);
+  return SQLITE_OK;
+}
+
+/*
+** Read data from a tmp-file.
+*/
+static int tmpRead(
+  sqlite3_file *pFile, 
+  void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  tmp_file *pTmp = (tmp_file *)pFile;
+  if( (iAmt+iOfst)>pTmp->nSize ){
+    return SQLITE_IOERR_SHORT_READ;
+  }
+  memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt);
+  return SQLITE_OK;
+}
+
+/*
+** Write data to a tmp-file.
+*/
+static int tmpWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  tmp_file *pTmp = (tmp_file *)pFile;
+  if( (iAmt+iOfst)>pTmp->nAlloc ){
+    int nNew = 2*(iAmt+iOfst+pTmp->nAlloc);
+    char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew);
+    if( !zNew ){
+      return SQLITE_NOMEM;
+    }
+    pTmp->zAlloc = zNew;
+    pTmp->nAlloc = nNew;
+  }
+  memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt);
+  pTmp->nSize = MAX(pTmp->nSize, iOfst+iAmt);
+  return SQLITE_OK;
+}
+
+/*
+** Truncate a tmp-file.
+*/
+static int tmpTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  tmp_file *pTmp = (tmp_file *)pFile;
+  pTmp->nSize = MIN(pTmp->nSize, size);
+  return SQLITE_OK;
+}
+
+/*
+** Sync a tmp-file.
+*/
+static int tmpSync(sqlite3_file *pFile, int flags){
+  return SQLITE_OK;
+}
+
+/*
+** Return the current file-size of a tmp-file.
+*/
+static int tmpFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  tmp_file *pTmp = (tmp_file *)pFile;
+  *pSize = pTmp->nSize;
+  return SQLITE_OK;
+}
+
+/*
+** Lock a tmp-file.
+*/
+static int tmpLock(sqlite3_file *pFile, int eLock){
+  return SQLITE_OK;
+}
+
+/*
+** Unlock a tmp-file.
+*/
+static int tmpUnlock(sqlite3_file *pFile, int eLock){
+  return SQLITE_OK;
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on a tmp-file.
+*/
+static int tmpCheckReservedLock(sqlite3_file *pFile){
+  return SQLITE_OK;
+}
+
+/*
+** File control method. For custom operations on a tmp-file.
+*/
+static int tmpFileControl(sqlite3_file *pFile, int op, void *pArg){
+  return SQLITE_OK;
+}
+
+/*
+** Return the sector-size in bytes for a tmp-file.
+*/
+static int tmpSectorSize(sqlite3_file *pFile){
+  return 0;
+}
+
+/*
+** Return the device characteristic flags supported by a tmp-file.
+*/
+static int tmpDeviceCharacteristics(sqlite3_file *pFile){
+  return 0;
+}
+
+/*
+** Close an fs-file.
+*/
+static int fsClose(sqlite3_file *pFile){
+  int rc = SQLITE_OK;
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+
+  /* Decrement the real_file ref-count. */
+  pReal->nRef--;
+  assert(pReal->nRef>=0);
+
+  /* When the ref-count reaches 0, destroy the structure */
+  if( pReal->nRef==0 ){
+    *pReal->ppThis = pReal->pNext;
+    if( pReal->pNext ){
+      pReal->pNext->ppThis = pReal->ppThis;
+    }
+    rc = pReal->pFile->pMethods->xClose(pReal->pFile);
+    sqlite3_free(pReal);
+  }
+
+  return rc;
+}
+
+/*
+** Read data from an fs-file.
+*/
+static int fsRead(
+  sqlite3_file *pFile, 
+  void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  int rc = SQLITE_OK;
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+  sqlite3_file *pF = pReal->pFile;
+
+  if( (p->eType==DATABASE_FILE && (iAmt+iOfst)>pReal->nDatabase)
+   || (p->eType==JOURNAL_FILE && (iAmt+iOfst)>pReal->nJournal)
+  ){
+    rc = SQLITE_IOERR_SHORT_READ;
+  }else if( p->eType==DATABASE_FILE ){
+    rc = pF->pMethods->xRead(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
+  }else{
+    /* Journal file. */
+    int iRem = iAmt;
+    int iBuf = 0;
+    int ii = iOfst;
+    while( iRem>0 && rc==SQLITE_OK ){
+      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
+      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
+
+      rc = pF->pMethods->xRead(pF, &((char *)zBuf)[iBuf], iRealAmt, iRealOff);
+      ii += iRealAmt;
+      iBuf += iRealAmt;
+      iRem -= iRealAmt;
+    }
+  }
+
+  return rc;
+}
+
+/*
+** Write data to an fs-file.
+*/
+static int fsWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  int rc = SQLITE_OK;
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+  sqlite3_file *pF = pReal->pFile;
+
+  if( p->eType==DATABASE_FILE ){
+    if( (iAmt+iOfst+BLOCKSIZE)>(pReal->nBlob-pReal->nJournal) ){
+      rc = SQLITE_FULL;
+    }else{
+      rc = pF->pMethods->xWrite(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
+      if( rc==SQLITE_OK ){
+        pReal->nDatabase = MAX(pReal->nDatabase, iAmt+iOfst);
+      }
+    }
+  }else{
+    /* Journal file. */
+    int iRem = iAmt;
+    int iBuf = 0;
+    int ii = iOfst;
+    while( iRem>0 && rc==SQLITE_OK ){
+      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
+      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
+
+      if( iRealOff<(pReal->nDatabase+BLOCKSIZE) ){
+        rc = SQLITE_FULL;
+      }else{
+        rc = pF->pMethods->xWrite(pF, &((char *)zBuf)[iBuf], iRealAmt,iRealOff);
+        ii += iRealAmt;
+        iBuf += iRealAmt;
+        iRem -= iRealAmt;
+      }
+    }
+    if( rc==SQLITE_OK ){
+      pReal->nJournal = MAX(pReal->nJournal, iAmt+iOfst);
+    }
+  }
+
+  return rc;
+}
+
+/*
+** Truncate an fs-file.
+*/
+static int fsTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+  if( p->eType==DATABASE_FILE ){
+    pReal->nDatabase = MIN(pReal->nDatabase, size);
+  }else{
+    pReal->nJournal = MIN(pReal->nJournal, size);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Sync an fs-file.
+*/
+static int fsSync(sqlite3_file *pFile, int flags){
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+  sqlite3_file *pRealFile = pReal->pFile;
+  int rc = SQLITE_OK;
+
+  if( p->eType==DATABASE_FILE ){
+    unsigned char zSize[4];
+    zSize[0] = (pReal->nDatabase&0xFF000000)>>24;
+    zSize[1] = (pReal->nDatabase&0x00FF0000)>>16;
+    zSize[2] = (pReal->nDatabase&0x0000FF00)>>8;
+    zSize[3] = (pReal->nDatabase&0x000000FF);
+    rc = pRealFile->pMethods->xWrite(pRealFile, zSize, 4, 0);
+  }
+  if( rc==SQLITE_OK ){
+    rc = pRealFile->pMethods->xSync(pRealFile, flags&(~SQLITE_SYNC_DATAONLY));
+  }
+
+  return rc;
+}
+
+/*
+** Return the current file-size of an fs-file.
+*/
+static int fsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = p->pReal;
+  if( p->eType==DATABASE_FILE ){
+    *pSize = pReal->nDatabase;
+  }else{
+    *pSize = pReal->nJournal;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Lock an fs-file.
+*/
+static int fsLock(sqlite3_file *pFile, int eLock){
+  return SQLITE_OK;
+}
+
+/*
+** Unlock an fs-file.
+*/
+static int fsUnlock(sqlite3_file *pFile, int eLock){
+  return SQLITE_OK;
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on an fs-file.
+*/
+static int fsCheckReservedLock(sqlite3_file *pFile){
+  return 0;
+}
+
+/*
+** File control method. For custom operations on an fs-file.
+*/
+static int fsFileControl(sqlite3_file *pFile, int op, void *pArg){
+  return SQLITE_OK;
+}
+
+/*
+** Return the sector-size in bytes for an fs-file.
+*/
+static int fsSectorSize(sqlite3_file *pFile){
+  return BLOCKSIZE;
+}
+
+/*
+** Return the device characteristic flags supported by an fs-file.
+*/
+static int fsDeviceCharacteristics(sqlite3_file *pFile){
+  return 0;
+}
+
+/*
+** Open an fs file handle.
+*/
+static int fsOpen(
+  sqlite3_vfs *pVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
+  fs_file *p = (fs_file *)pFile;
+  fs_real_file *pReal = 0;
+  int eType;
+  int nName;
+  int rc = SQLITE_OK;
+
+  if( 0==(flags&(SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_MAIN_JOURNAL)) ){
+    tmp_file *p = (tmp_file *)pFile;
+    memset(p, 0, sizeof(*p));
+    p->base.pMethods = &tmp_io_methods;
+    return SQLITE_OK;
+  }
+
+  eType = ((flags&(SQLITE_OPEN_MAIN_DB))?DATABASE_FILE:JOURNAL_FILE);
+  p->base.pMethods = &fs_io_methods;
+  p->eType = eType;
+
+  assert(strlen("-journal")==8);
+  nName = strlen(zName)-((eType==JOURNAL_FILE)?8:0);
+  pReal=pFsVfs->pFileList; 
+  for(; pReal && strncmp(pReal->zName, zName, nName); pReal=pReal->pNext);
+
+  if( !pReal ){
+    sqlite3_int64 size;
+    sqlite3_file *pRealFile;
+    sqlite3_vfs *pParent = pFsVfs->pParent;
+    assert(eType==DATABASE_FILE);
+
+    pReal = (fs_real_file *)sqlite3_malloc(sizeof(*pReal)+pParent->szOsFile);
+    if( !pReal ){
+      rc = SQLITE_NOMEM;
+      goto open_out;
+    }
+    memset(pReal, 0, sizeof(*pReal)+pParent->szOsFile);
+    pReal->zName = zName;
+    pReal->pFile = (sqlite3_file *)(&pReal[1]);
+
+    rc = pParent->xOpen(pParent, zName, pReal->pFile, flags, pOutFlags);
+    if( rc!=SQLITE_OK ){
+      goto open_out;
+    }
+    pRealFile = pReal->pFile;
+
+    rc = pRealFile->pMethods->xFileSize(pRealFile, &size);
+    if( rc!=SQLITE_OK ){
+      goto open_out;
+    }
+    if( size==0 ){
+      rc = pRealFile->pMethods->xWrite(pRealFile, "\0", 1, BLOBSIZE-1);
+      pReal->nBlob = BLOBSIZE;
+    }else{
+      unsigned char zS[4];
+      pReal->nBlob = size;
+      rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, 0);
+      pReal->nDatabase = (zS[0]<<24)+(zS[1]<<16)+(zS[2]<<8)+zS[3];
+      if( rc==SQLITE_OK ){
+        rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, pReal->nBlob-4);
+        if( zS[0] || zS[1] || zS[2] || zS[3] ){
+          pReal->nJournal = pReal->nBlob;
+        }
+      }
+    }
+
+    if( rc==SQLITE_OK ){
+      pReal->pNext = pFsVfs->pFileList;
+      if( pReal->pNext ){
+        pReal->pNext->ppThis = &pReal->pNext;
+      }
+      pReal->ppThis = &pFsVfs->pFileList;
+      pFsVfs->pFileList = pReal;
+    }
+  }
+
+open_out:
+  if( pReal ){
+    if( rc==SQLITE_OK ){
+      p->pReal = pReal;
+      pReal->nRef++;
+    }else{
+      if( pReal->pFile->pMethods ){
+        pReal->pFile->pMethods->xClose(pReal->pFile);
+      }
+      sqlite3_free(pReal);
+    }
+  }
+  return rc;
+}
+
+/*
+** Delete the file located at zPath. If the dirSync argument is true,
+** ensure the file-system modifications are synced to disk before
+** returning.
+*/
+static int fsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  int rc = SQLITE_OK;
+  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
+  fs_real_file *pReal;
+  sqlite3_file *pF;
+  int nName = strlen(zPath) - 8;
+
+  assert(strlen("-journal")==8);
+  assert(strcmp("-journal", &zPath[nName])==0);
+
+  pReal = pFsVfs->pFileList; 
+  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
+  if( pReal ){
+    pF = pReal->pFile;
+    rc = pF->pMethods->xWrite(pF, "\0\0\0\0", 4, pReal->nBlob-BLOCKSIZE);
+    if( rc==SQLITE_OK ){
+      pReal->nJournal = 0;
+    }
+  }
+  return rc;
+}
+
+/*
+** Test for access permissions. Return true if the requested permission
+** is available, or false otherwise.
+*/
+static int fsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
+  fs_real_file *pReal;
+  int isJournal = 0;
+  int nName = strlen(zPath);
+
+  if( flags!=SQLITE_ACCESS_EXISTS ){
+    sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+    return pParent->xAccess(pParent, zPath, flags);
+  }
+
+  assert(strlen("-journal")==8);
+  if( nName>8 && strcmp("-journal", &zPath[nName-8])==0 ){
+    nName -= 8;
+    isJournal = 1;
+  }
+
+  pReal = pFsVfs->pFileList; 
+  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
+  if( !pReal ) return 0;
+  return ((!isJournal||pReal->nJournal>0)?1:0);
+}
+
+/*
+** Populate buffer zBufOut with a pathname suitable for use as a 
+** temporary file. zBufOut is guaranteed to point to a buffer of 
+** at least (FS_MAX_PATHNAME+1) bytes.
+*/
+static int fsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xGetTempname(pParent, nBufOut, zBufOut);
+}
+
+/*
+** Populate buffer zOut with the full canonical pathname corresponding
+** to the pathname in zPath. zOut is guaranteed to point to a buffer
+** of at least (FS_MAX_PATHNAME+1) bytes.
+*/
+static int fsFullPathname(
+  sqlite3_vfs *pVfs,            /* Pointer to vfs object */
+  const char *zPath,            /* Possibly relative input path */
+  int nOut,                     /* Size of output buffer in bytes */
+  char *zOut                    /* Output buffer */
+){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xFullPathname(pParent, zPath, nOut, zOut);
+}
+
+/*
+** Open the dynamic library located at zPath and return a handle.
+*/
+static void *fsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xDlOpen(pParent, zPath);
+}
+
+/*
+** Populate the buffer zErrMsg (size nByte bytes) with a human readable
+** utf-8 string describing the most recent error encountered associated 
+** with dynamic libraries.
+*/
+static void fsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  pParent->xDlError(pParent, nByte, zErrMsg);
+}
+
+/*
+** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
+*/
+static void *fsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xDlSym(pParent, pHandle, zSymbol);
+}
+
+/*
+** Close the dynamic library handle pHandle.
+*/
+static void fsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  pParent->xDlClose(pParent, pHandle);
+}
+
+/*
+** Populate the buffer pointed to by zBufOut with nByte bytes of 
+** random data.
+*/
+static int fsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xRandomness(pParent, nByte, zBufOut);
+}
+
+/*
+** Sleep for nMicro microseconds. Return the number of microseconds 
+** actually slept.
+*/
+static int fsSleep(sqlite3_vfs *pVfs, int nMicro){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xSleep(pParent, nMicro);
+}
+
+/*
+** Return the current time as a Julian Day number in *pTimeOut.
+*/
+static int fsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
+  return pParent->xCurrentTime(pParent, pTimeOut);
+}
+
+/*
+** This procedure registers the fs vfs with SQLite. If the argument is
+** true, the fs vfs becomes the new default vfs. It is the only publicly
+** available function in this file.
+*/
+int fs_register(){
+  if( fs_vfs.pParent ) return SQLITE_OK;
+  fs_vfs.pParent = sqlite3_vfs_find(0);
+  fs_vfs.base.mxPathname = fs_vfs.pParent->mxPathname;
+  fs_vfs.base.szOsFile = MAX(sizeof(tmp_file), sizeof(fs_file));
+  return sqlite3_vfs_register(&fs_vfs.base, 0);
+}
+
+#ifdef SQLITE_TEST
+  int SqlitetestOnefile_Init() {return fs_register();}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_schema.c b/client/src/thirdparty/sqlite-3.4.2/src/test_schema.c
new file mode 100644
index 0000000..8800520
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_schema.c
@@ -0,0 +1,358 @@
+/*
+** 2006 June 10
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the virtual table interfaces.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** $Id: test_schema.c,v 1.13 2007/08/16 04:30:40 drh Exp $
+*/
+
+/* The code in this file defines a sqlite3 virtual-table module that
+** provides a read-only view of the current database schema. There is one
+** row in the schema table for each column in the database schema.
+*/
+#define SCHEMA \
+"CREATE TABLE x("                                                            \
+  "database,"          /* Name of database (i.e. main, temp etc.) */         \
+  "tablename,"         /* Name of table */                                   \
+  "cid,"               /* Column number (from left-to-right, 0 upward) */    \
+  "name,"              /* Column name */                                     \
+  "type,"              /* Specified type (i.e. VARCHAR(32)) */               \
+  "not_null,"          /* Boolean. True if NOT NULL was specified */         \
+  "dflt_value,"        /* Default value for this column */                   \
+  "pk"                 /* True if this column is part of the primary key */  \
+")"
+
+/* If SQLITE_TEST is defined this code is preprocessed for use as part
+** of the sqlite test binary "testfixture". Otherwise it is preprocessed
+** to be compiled into an sqlite dynamic extension.
+*/
+#ifdef SQLITE_TEST
+  #include "sqliteInt.h"
+  #include "tcl.h"
+#else
+  #include "sqlite3ext.h"
+  SQLITE_EXTENSION_INIT1
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+typedef struct schema_vtab schema_vtab;
+typedef struct schema_cursor schema_cursor;
+
+/* A schema table object */
+struct schema_vtab {
+  sqlite3_vtab base;
+  sqlite3 *db;
+};
+
+/* A schema table cursor object */
+struct schema_cursor {
+  sqlite3_vtab_cursor base;
+  sqlite3_stmt *pDbList;
+  sqlite3_stmt *pTableList;
+  sqlite3_stmt *pColumnList;
+  int rowid;
+};
+
+/*
+** Table destructor for the schema module.
+*/
+static int schemaDestroy(sqlite3_vtab *pVtab){
+  sqlite3_free(pVtab);
+  return 0;
+}
+
+/*
+** Table constructor for the schema module.
+*/
+static int schemaCreate(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  int rc = SQLITE_NOMEM;
+  schema_vtab *pVtab = sqlite3_malloc(sizeof(schema_vtab));
+  if( pVtab ){
+    memset(pVtab, 0, sizeof(schema_vtab));
+    pVtab->db = db;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    rc = sqlite3_declare_vtab(db, SCHEMA);
+#endif
+  }
+  *ppVtab = (sqlite3_vtab *)pVtab;
+  return rc;
+}
+
+/*
+** Open a new cursor on the schema table.
+*/
+static int schemaOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  int rc = SQLITE_NOMEM;
+  schema_cursor *pCur;
+  pCur = sqlite3_malloc(sizeof(schema_cursor));
+  if( pCur ){
+    memset(pCur, 0, sizeof(schema_cursor));
+    *ppCursor = (sqlite3_vtab_cursor *)pCur;
+    rc = SQLITE_OK;
+  }
+  return rc;
+}
+
+/*
+** Close a schema table cursor.
+*/
+static int schemaClose(sqlite3_vtab_cursor *cur){
+  schema_cursor *pCur = (schema_cursor *)cur;
+  sqlite3_finalize(pCur->pDbList);
+  sqlite3_finalize(pCur->pTableList);
+  sqlite3_finalize(pCur->pColumnList);
+  sqlite3_free(pCur);
+  return SQLITE_OK;
+}
+
+/*
+** Retrieve a column of data.
+*/
+static int schemaColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
+  schema_cursor *pCur = (schema_cursor *)cur;
+  switch( i ){
+    case 0:
+      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pDbList, 1));
+      break;
+    case 1:
+      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pTableList, 0));
+      break;
+    default:
+      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pColumnList, i-2));
+      break;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Retrieve the current rowid.
+*/
+static int schemaRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
+  schema_cursor *pCur = (schema_cursor *)cur;
+  *pRowid = pCur->rowid;
+  return SQLITE_OK;
+}
+
+static int finalize(sqlite3_stmt **ppStmt){
+  int rc = sqlite3_finalize(*ppStmt);
+  *ppStmt = 0;
+  return rc;
+}
+
+static int schemaEof(sqlite3_vtab_cursor *cur){
+  schema_cursor *pCur = (schema_cursor *)cur;
+  return (pCur->pDbList ? 0 : 1);
+}
+
+/*
+** Advance the cursor to the next row.
+*/
+static int schemaNext(sqlite3_vtab_cursor *cur){
+  int rc = SQLITE_OK;
+  schema_cursor *pCur = (schema_cursor *)cur;
+  schema_vtab *pVtab = (schema_vtab *)(cur->pVtab);
+  char *zSql = 0;
+
+  while( !pCur->pColumnList || SQLITE_ROW!=sqlite3_step(pCur->pColumnList) ){
+    if( SQLITE_OK!=(rc = finalize(&pCur->pColumnList)) ) goto next_exit;
+
+    while( !pCur->pTableList || SQLITE_ROW!=sqlite3_step(pCur->pTableList) ){
+      if( SQLITE_OK!=(rc = finalize(&pCur->pTableList)) ) goto next_exit;
+
+      assert(pCur->pDbList);
+      while( SQLITE_ROW!=sqlite3_step(pCur->pDbList) ){
+        rc = finalize(&pCur->pDbList);
+        goto next_exit;
+      }
+
+      /* Set zSql to the SQL to pull the list of tables from the 
+      ** sqlite_master (or sqlite_temp_master) table of the database
+      ** identfied by the row pointed to by the SQL statement pCur->pDbList
+      ** (iterating through a "PRAGMA database_list;" statement).
+      */
+      if( sqlite3_column_int(pCur->pDbList, 0)==1 ){
+        zSql = sqlite3_mprintf(
+            "SELECT name FROM sqlite_temp_master WHERE type='table'"
+        );
+      }else{
+        sqlite3_stmt *pDbList = pCur->pDbList;
+        zSql = sqlite3_mprintf(
+            "SELECT name FROM %Q.sqlite_master WHERE type='table'",
+             sqlite3_column_text(pDbList, 1)
+        );
+      }
+      if( !zSql ){
+        rc = SQLITE_NOMEM;
+        goto next_exit;
+      }
+
+      rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pTableList, 0);
+      sqlite3_free(zSql);
+      if( rc!=SQLITE_OK ) goto next_exit;
+    }
+
+    /* Set zSql to the SQL to the table_info pragma for the table currently
+    ** identified by the rows pointed to by statements pCur->pDbList and
+    ** pCur->pTableList.
+    */
+    zSql = sqlite3_mprintf("PRAGMA %Q.table_info(%Q)", 
+        sqlite3_column_text(pCur->pDbList, 1),
+        sqlite3_column_text(pCur->pTableList, 0)
+    );
+
+    if( !zSql ){
+      rc = SQLITE_NOMEM;
+      goto next_exit;
+    }
+    rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pColumnList, 0);
+    sqlite3_free(zSql);
+    if( rc!=SQLITE_OK ) goto next_exit;
+  }
+  pCur->rowid++;
+
+next_exit:
+  /* TODO: Handle rc */
+  return rc;
+}
+
+/*
+** Reset a schema table cursor.
+*/
+static int schemaFilter(
+  sqlite3_vtab_cursor *pVtabCursor, 
+  int idxNum, const char *idxStr,
+  int argc, sqlite3_value **argv
+){
+  int rc;
+  schema_vtab *pVtab = (schema_vtab *)(pVtabCursor->pVtab);
+  schema_cursor *pCur = (schema_cursor *)pVtabCursor;
+  pCur->rowid = 0;
+  finalize(&pCur->pTableList);
+  finalize(&pCur->pColumnList);
+  finalize(&pCur->pDbList);
+  rc = sqlite3_prepare(pVtab->db,"PRAGMA database_list", -1, &pCur->pDbList, 0);
+  return (rc==SQLITE_OK ? schemaNext(pVtabCursor) : rc);
+}
+
+/*
+** Analyse the WHERE condition.
+*/
+static int schemaBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
+  return SQLITE_OK;
+}
+
+/*
+** A virtual table module that merely echos method calls into TCL
+** variables.
+*/
+static sqlite3_module schemaModule = {
+  0,                           /* iVersion */
+  schemaCreate,
+  schemaCreate,
+  schemaBestIndex,
+  schemaDestroy,
+  schemaDestroy,
+  schemaOpen,                  /* xOpen - open a cursor */
+  schemaClose,                 /* xClose - close a cursor */
+  schemaFilter,                /* xFilter - configure scan constraints */
+  schemaNext,                  /* xNext - advance a cursor */
+  schemaEof,                   /* xEof */
+  schemaColumn,                /* xColumn - read data */
+  schemaRowid,                 /* xRowid - read data */
+  0,                           /* xUpdate */
+  0,                           /* xBegin */
+  0,                           /* xSync */
+  0,                           /* xCommit */
+  0,                           /* xRollback */
+  0,                           /* xFindMethod */
+  0,                           /* xRename */
+};
+
+
+#ifdef SQLITE_TEST
+
+/*
+** Decode a pointer to an sqlite3 object.
+*/
+static int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
+  *ppDb = (sqlite3*)sqlite3TextToPtr(zA);
+  return TCL_OK;
+}
+
+/*
+** Register the schema virtual table module.
+*/
+static int register_schema_module(
+  ClientData clientData, /* Not used */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  sqlite3_create_module(db, "schema", &schemaModule, 0);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetestschema_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+     void *clientData;
+  } aObjCmd[] = {
+     { "register_schema_module", register_schema_module, 0 },
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
+        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
+  }
+  return TCL_OK;
+}
+
+#else
+
+/*
+** Extension load function.
+*/
+int sqlite3_extension_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi);
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  sqlite3_create_module(db, "schema", &schemaModule, 0);
+#endif
+  return 0;
+}
+
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_server.c b/client/src/thirdparty/sqlite-3.4.2/src/test_server.c
new file mode 100644
index 0000000..624249f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_server.c
@@ -0,0 +1,491 @@
+/*
+** 2006 January 07
+**
+** 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 demonstration code.  Nothing in this file gets compiled
+** or linked into the SQLite library unless you use a non-standard option:
+**
+**      -DSQLITE_SERVER=1
+**
+** The configure script will never generate a Makefile with the option
+** above.  You will need to manually modify the Makefile if you want to
+** include any of the code from this file in your project.  Or, at your
+** option, you may copy and paste the code from this file and
+** thereby avoiding a recompile of SQLite.
+**
+**
+** This source file demonstrates how to use SQLite to create an SQL database 
+** server thread in a multiple-threaded program.  One or more client threads
+** send messages to the server thread and the server thread processes those
+** messages in the order received and returns the results to the client.
+**
+** One might ask:  "Why bother?  Why not just let each thread connect
+** to the database directly?"  There are a several of reasons to
+** prefer the client/server approach.
+**
+**    (1)  Some systems (ex: Redhat9) have broken threading implementations
+**         that prevent SQLite database connections from being used in
+**         a thread different from the one where they were created.  With
+**         the client/server approach, all database connections are created
+**         and used within the server thread.  Client calls to the database
+**         can be made from multiple threads (though not at the same time!)
+**
+**    (2)  Beginning with SQLite version 3.3.0, when two or more 
+**         connections to the same database occur within the same thread,
+**         they can optionally share their database cache.  This reduces
+**         I/O and memory requirements.  Cache shared is controlled using
+**         the sqlite3_enable_shared_cache() API.
+**
+**    (3)  Database connections on a shared cache use table-level locking
+**         instead of file-level locking for improved concurrency.
+**
+**    (4)  Database connections on a shared cache can by optionally
+**         set to READ UNCOMMITTED isolation.  (The default isolation for
+**         SQLite is SERIALIZABLE.)  When this occurs, readers will
+**         never be blocked by a writer and writers will not be
+**         blocked by readers.  There can still only be a single writer
+**         at a time, but multiple readers can simultaneously exist with
+**         that writer.  This is a huge increase in concurrency.
+**
+** To summarize the rational for using a client/server approach: prior
+** to SQLite version 3.3.0 it probably was not worth the trouble.  But
+** with SQLite version 3.3.0 and beyond you can get significant performance
+** and concurrency improvements and memory usage reductions by going
+** client/server.
+**
+** Note:  The extra features of version 3.3.0 described by points (2)
+** through (4) above are only available if you compile without the
+** option -DSQLITE_OMIT_SHARED_CACHE. 
+**
+** Here is how the client/server approach works:  The database server
+** thread is started on this procedure:
+**
+**       void *sqlite3_server(void *NotUsed);
+**
+** The sqlite_server procedure runs as long as the g.serverHalt variable
+** is false.  A mutex is used to make sure no more than one server runs
+** at a time.  The server waits for messages to arrive on a message
+** queue and processes the messages in order.
+**
+** Two convenience routines are provided for starting and stopping the
+** server thread:
+**
+**       void sqlite3_server_start(void);
+**       void sqlite3_server_stop(void);
+**
+** Both of the convenience routines return immediately.  Neither will
+** ever give an error.  If a server is already started or already halted,
+** then the routines are effectively no-ops.
+**
+** Clients use the following interfaces:
+**
+**       sqlite3_client_open
+**       sqlite3_client_prepare
+**       sqlite3_client_step
+**       sqlite3_client_reset
+**       sqlite3_client_finalize
+**       sqlite3_client_close
+**
+** These interfaces work exactly like the standard core SQLite interfaces
+** having the same names without the "_client_" infix.  Many other SQLite
+** interfaces can be used directly without having to send messages to the
+** server as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.
+** The following interfaces fall into this second category:
+**
+**       sqlite3_bind_*
+**       sqlite3_changes
+**       sqlite3_clear_bindings
+**       sqlite3_column_*
+**       sqlite3_complete
+**       sqlite3_create_collation
+**       sqlite3_create_function
+**       sqlite3_data_count
+**       sqlite3_db_handle
+**       sqlite3_errcode
+**       sqlite3_errmsg
+**       sqlite3_last_insert_rowid
+**       sqlite3_total_changes
+**       sqlite3_transfer_bindings
+**
+** A single SQLite connection (an sqlite3* object) or an SQLite statement
+** (an sqlite3_stmt* object) should only be passed to a single interface
+** function at a time.  The connections and statements can be passed from
+** any thread to any of the functions listed in the second group above as
+** long as the same connection is not in use by two threads at once and
+** as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.  Additional
+** information about the SQLITE_ENABLE_MEMORY_MANAGEMENT constraint is
+** below.
+**
+** The busy handler for all database connections should remain turned
+** off.  That means that any lock contention will cause the associated
+** sqlite3_client_step() call to return immediately with an SQLITE_BUSY
+** error code.  If a busy handler is enabled and lock contention occurs,
+** then the entire server thread will block.  This will cause not only
+** the requesting client to block but every other database client as
+** well.  It is possible to enhance the code below so that lock
+** contention will cause the message to be placed back on the top of
+** the queue to be tried again later.  But such enhanced processing is
+** not included here, in order to keep the example simple.
+**
+** This example code assumes the use of pthreads.  Pthreads
+** implementations are available for windows.  (See, for example
+** http://sourceware.org/pthreads-win32/announcement.html.)  Or, you
+** can translate the locking and thread synchronization code to use
+** windows primitives easily enough.  The details are left as an
+** exercise to the reader.
+**
+**** Restrictions Associated With SQLITE_ENABLE_MEMORY_MANAGEMENT ****
+**
+** If you compile with SQLITE_ENABLE_MEMORY_MANAGEMENT defined, then
+** SQLite includes code that tracks how much memory is being used by
+** each thread.  These memory counts can become confused if memory
+** is allocated by one thread and then freed by another.  For that
+** reason, when SQLITE_ENABLE_MEMORY_MANAGEMENT is used, all operations
+** that might allocate or free memory should be performanced in the same
+** thread that originally created the database connection.  In that case,
+** many of the operations that are listed above as safe to be performed
+** in separate threads would need to be sent over to the server to be
+** done there.  If SQLITE_ENABLE_MEMORY_MANAGEMENT is defined, then
+** the following functions can be used safely from different threads
+** without messing up the allocation counts:
+**
+**       sqlite3_bind_parameter_name
+**       sqlite3_bind_parameter_index
+**       sqlite3_changes
+**       sqlite3_column_blob
+**       sqlite3_column_count
+**       sqlite3_complete
+**       sqlite3_data_count
+**       sqlite3_db_handle
+**       sqlite3_errcode
+**       sqlite3_errmsg
+**       sqlite3_last_insert_rowid
+**       sqlite3_total_changes
+**
+** The remaining functions are not thread-safe when memory management
+** is enabled.  So one would have to define some new interface routines
+** along the following lines:
+**
+**       sqlite3_client_bind_*
+**       sqlite3_client_clear_bindings
+**       sqlite3_client_column_*
+**       sqlite3_client_create_collation
+**       sqlite3_client_create_function
+**       sqlite3_client_transfer_bindings
+**
+** The example code in this file is intended for use with memory
+** management turned off.  So the implementation of these additional
+** client interfaces is left as an exercise to the reader.
+**
+** It may seem surprising to the reader that the list of safe functions
+** above does not include things like sqlite3_bind_int() or
+** sqlite3_column_int().  But those routines might, in fact, allocate
+** or deallocate memory.  In the case of sqlite3_bind_int(), if the
+** parameter was previously bound to a string that string might need
+** to be deallocated before the new integer value is inserted.  In
+** the case of sqlite3_column_int(), the value of the column might be
+** a UTF-16 string which will need to be converted to UTF-8 then into
+** an integer.
+*/
+
+/* Include this to get the definition of SQLITE_THREADSAFE, in the
+** case that default values are used.
+*/
+#include "sqliteInt.h"
+
+/*
+** Only compile the code in this file on UNIX with a SQLITE_THREADSAFE build
+** and only if the SQLITE_SERVER macro is defined.
+*/
+#if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE)
+#if defined(OS_UNIX) && OS_UNIX && SQLITE_THREADSAFE
+
+/*
+** We require only pthreads and the public interface of SQLite.
+*/
+#include <pthread.h>
+#include "sqlite3.h"
+
+/*
+** Messages are passed from client to server and back again as 
+** instances of the following structure.
+*/
+typedef struct SqlMessage SqlMessage;
+struct SqlMessage {
+  int op;                      /* Opcode for the message */
+  sqlite3 *pDb;                /* The SQLite connection */
+  sqlite3_stmt *pStmt;         /* A specific statement */
+  int errCode;                 /* Error code returned */
+  const char *zIn;             /* Input filename or SQL statement */
+  int nByte;                   /* Size of the zIn parameter for prepare() */
+  const char *zOut;            /* Tail of the SQL statement */
+  SqlMessage *pNext;           /* Next message in the queue */
+  SqlMessage *pPrev;           /* Previous message in the queue */
+  pthread_mutex_t clientMutex; /* Hold this mutex to access the message */
+  pthread_cond_t clientWakeup; /* Signal to wake up the client */
+};
+
+/*
+** Legal values for SqlMessage.op
+*/
+#define MSG_Open       1  /* sqlite3_open(zIn, &pDb) */
+#define MSG_Prepare    2  /* sqlite3_prepare(pDb, zIn, nByte, &pStmt, &zOut) */
+#define MSG_Step       3  /* sqlite3_step(pStmt) */
+#define MSG_Reset      4  /* sqlite3_reset(pStmt) */
+#define MSG_Finalize   5  /* sqlite3_finalize(pStmt) */
+#define MSG_Close      6  /* sqlite3_close(pDb) */
+#define MSG_Done       7  /* Server has finished with this message */
+
+
+/*
+** State information about the server is stored in a static variable
+** named "g" as follows:
+*/
+static struct ServerState {
+  pthread_mutex_t queueMutex;   /* Hold this mutex to access the msg queue */
+  pthread_mutex_t serverMutex;  /* Held by the server while it is running */
+  pthread_cond_t serverWakeup;  /* Signal this condvar to wake up the server */
+  volatile int serverHalt;      /* Server halts itself when true */
+  SqlMessage *pQueueHead;       /* Head of the message queue */
+  SqlMessage *pQueueTail;       /* Tail of the message queue */
+} g = {
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_MUTEX_INITIALIZER,
+  PTHREAD_COND_INITIALIZER,
+};
+
+/*
+** Send a message to the server.  Block until we get a reply.
+**
+** The mutex and condition variable in the message are uninitialized
+** when this routine is called.  This routine takes care of 
+** initializing them and destroying them when it has finished.
+*/
+static void sendToServer(SqlMessage *pMsg){
+  /* Initialize the mutex and condition variable on the message
+  */
+  pthread_mutex_init(&pMsg->clientMutex, 0);
+  pthread_cond_init(&pMsg->clientWakeup, 0);
+
+  /* Add the message to the head of the server's message queue.
+  */
+  pthread_mutex_lock(&g.queueMutex);
+  pMsg->pNext = g.pQueueHead;
+  if( g.pQueueHead==0 ){
+    g.pQueueTail = pMsg;
+  }else{
+    g.pQueueHead->pPrev = pMsg;
+  }
+  pMsg->pPrev = 0;
+  g.pQueueHead = pMsg;
+  pthread_mutex_unlock(&g.queueMutex);
+
+  /* Signal the server that the new message has be queued, then
+  ** block waiting for the server to process the message.
+  */
+  pthread_mutex_lock(&pMsg->clientMutex);
+  pthread_cond_signal(&g.serverWakeup);
+  while( pMsg->op!=MSG_Done ){
+    pthread_cond_wait(&pMsg->clientWakeup, &pMsg->clientMutex);
+  }
+  pthread_mutex_unlock(&pMsg->clientMutex);
+
+  /* Destroy the mutex and condition variable of the message.
+  */
+  pthread_mutex_destroy(&pMsg->clientMutex);
+  pthread_cond_destroy(&pMsg->clientWakeup);
+}
+
+/*
+** The following 6 routines are client-side implementations of the
+** core SQLite interfaces:
+**
+**        sqlite3_open
+**        sqlite3_prepare
+**        sqlite3_step
+**        sqlite3_reset
+**        sqlite3_finalize
+**        sqlite3_close
+**
+** Clients should use the following client-side routines instead of 
+** the core routines above.
+**
+**        sqlite3_client_open
+**        sqlite3_client_prepare
+**        sqlite3_client_step
+**        sqlite3_client_reset
+**        sqlite3_client_finalize
+**        sqlite3_client_close
+**
+** Each of these routines creates a message for the desired operation,
+** sends that message to the server, waits for the server to process
+** then message and return a response.
+*/
+int sqlite3_client_open(const char *zDatabaseName, sqlite3 **ppDb){
+  SqlMessage msg;
+  msg.op = MSG_Open;
+  msg.zIn = zDatabaseName;
+  sendToServer(&msg);
+  *ppDb = msg.pDb;
+  return msg.errCode;
+}
+int sqlite3_client_prepare(
+  sqlite3 *pDb,
+  const char *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const char **pzTail
+){
+  SqlMessage msg;
+  msg.op = MSG_Prepare;
+  msg.pDb = pDb;
+  msg.zIn = zSql;
+  msg.nByte = nByte;
+  sendToServer(&msg);
+  *ppStmt = msg.pStmt;
+  if( pzTail ) *pzTail = msg.zOut;
+  return msg.errCode;
+}
+int sqlite3_client_step(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Step;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_reset(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Reset;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_finalize(sqlite3_stmt *pStmt){
+  SqlMessage msg;
+  msg.op = MSG_Finalize;
+  msg.pStmt = pStmt;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+int sqlite3_client_close(sqlite3 *pDb){
+  SqlMessage msg;
+  msg.op = MSG_Close;
+  msg.pDb = pDb;
+  sendToServer(&msg);
+  return msg.errCode;
+}
+
+/*
+** This routine implements the server.  To start the server, first
+** make sure g.serverHalt is false, then create a new detached thread
+** on this procedure.  See the sqlite3_server_start() routine below
+** for an example.  This procedure loops until g.serverHalt becomes
+** true.
+*/
+void *sqlite3_server(void *NotUsed){
+  if( pthread_mutex_trylock(&g.serverMutex) ){
+    return 0;  /* Another server is already running */
+  }
+  sqlite3_enable_shared_cache(1);
+  while( !g.serverHalt ){
+    SqlMessage *pMsg;
+
+    /* Remove the last message from the message queue.
+    */
+    pthread_mutex_lock(&g.queueMutex);
+    while( g.pQueueTail==0 && g.serverHalt==0 ){
+      pthread_cond_wait(&g.serverWakeup, &g.queueMutex);
+    }
+    pMsg = g.pQueueTail;
+    if( pMsg ){
+      if( pMsg->pPrev ){
+        pMsg->pPrev->pNext = 0;
+      }else{
+        g.pQueueHead = 0;
+      }
+      g.pQueueTail = pMsg->pPrev;
+    }
+    pthread_mutex_unlock(&g.queueMutex);
+    if( pMsg==0 ) break;
+
+    /* Process the message just removed
+    */
+    pthread_mutex_lock(&pMsg->clientMutex);
+    switch( pMsg->op ){
+      case MSG_Open: {
+        pMsg->errCode = sqlite3_open(pMsg->zIn, &pMsg->pDb);
+        break;
+      }
+      case MSG_Prepare: {
+        pMsg->errCode = sqlite3_prepare(pMsg->pDb, pMsg->zIn, pMsg->nByte,
+                                        &pMsg->pStmt, &pMsg->zOut);
+        break;
+      }
+      case MSG_Step: {
+        pMsg->errCode = sqlite3_step(pMsg->pStmt);
+        break;
+      }
+      case MSG_Reset: {
+        pMsg->errCode = sqlite3_reset(pMsg->pStmt);
+        break;
+      }
+      case MSG_Finalize: {
+        pMsg->errCode = sqlite3_finalize(pMsg->pStmt);
+        break;
+      }
+      case MSG_Close: {
+        pMsg->errCode = sqlite3_close(pMsg->pDb);
+        break;
+      }
+    }
+
+    /* Signal the client that the message has been processed.
+    */
+    pMsg->op = MSG_Done;
+    pthread_mutex_unlock(&pMsg->clientMutex);
+    pthread_cond_signal(&pMsg->clientWakeup);
+  }
+  sqlite3_thread_cleanup();
+  pthread_mutex_unlock(&g.serverMutex);
+  return 0;
+}
+
+/*
+** Start a server thread if one is not already running.  If there
+** is aleady a server thread running, the new thread will quickly
+** die and this routine is effectively a no-op.
+*/
+void sqlite3_server_start(void){
+  pthread_t x;
+  int rc;
+  g.serverHalt = 0;
+  rc = pthread_create(&x, 0, sqlite3_server, 0);
+  if( rc==0 ){
+    pthread_detach(x);
+  }
+}
+
+/*
+** If a server thread is running, then stop it.  If no server is
+** running, this routine is effectively a no-op.
+**
+** This routine waits until the server has actually stopped before
+** returning.
+*/
+void sqlite3_server_stop(void){
+  g.serverHalt = 1;
+  pthread_cond_broadcast(&g.serverWakeup);
+  pthread_mutex_lock(&g.serverMutex);
+  pthread_mutex_unlock(&g.serverMutex);
+}
+
+#endif /* defined(OS_UNIX) && OS_UNIX && SQLITE_THREADSAFE */
+#endif /* defined(SQLITE_SERVER) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_tclvar.c b/client/src/thirdparty/sqlite-3.4.2/src/test_tclvar.c
new file mode 100644
index 0000000..63f262d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_tclvar.c
@@ -0,0 +1,327 @@
+/*
+** 2006 June 13
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the virtual table interfaces.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+**
+** The emphasis of this file is a virtual table that provides
+** access to TCL variables.
+**
+** $Id: test_tclvar.c,v 1.14 2007/08/21 10:44:16 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+
+typedef struct tclvar_vtab tclvar_vtab;
+typedef struct tclvar_cursor tclvar_cursor;
+
+/* 
+** A tclvar virtual-table object 
+*/
+struct tclvar_vtab {
+  sqlite3_vtab base;
+  Tcl_Interp *interp;
+};
+
+/* A tclvar cursor object */
+struct tclvar_cursor {
+  sqlite3_vtab_cursor base;
+
+  Tcl_Obj *pList1;     /* Result of [info vars ?pattern?] */
+  Tcl_Obj *pList2;     /* Result of [array names [lindex $pList1 $i1]] */
+  int i1;              /* Current item in pList1 */
+  int i2;              /* Current item (if any) in pList2 */
+};
+
+/* Methods for the tclvar module */
+static int tclvarConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  tclvar_vtab *pVtab;
+  static const char zSchema[] = 
+     "CREATE TABLE whatever(name TEXT, arrayname TEXT, value TEXT)";
+  pVtab = sqlite3MallocZero( sizeof(*pVtab) );
+  if( pVtab==0 ) return SQLITE_NOMEM;
+  *ppVtab = &pVtab->base;
+  pVtab->interp = (Tcl_Interp *)pAux;
+  sqlite3_declare_vtab(db, zSchema);
+  return SQLITE_OK;
+}
+/* Note that for this virtual table, the xCreate and xConnect
+** methods are identical. */
+
+static int tclvarDisconnect(sqlite3_vtab *pVtab){
+  sqlite3_free(pVtab);
+  return SQLITE_OK;
+}
+/* The xDisconnect and xDestroy methods are also the same */
+
+/*
+** Open a new tclvar cursor.
+*/
+static int tclvarOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  tclvar_cursor *pCur;
+  pCur = sqlite3MallocZero(sizeof(tclvar_cursor));
+  *ppCursor = &pCur->base;
+  return SQLITE_OK;
+}
+
+/*
+** Close a tclvar cursor.
+*/
+static int tclvarClose(sqlite3_vtab_cursor *cur){
+  tclvar_cursor *pCur = (tclvar_cursor *)cur;
+  if( pCur->pList1 ){
+    Tcl_DecrRefCount(pCur->pList1);
+  }
+  if( pCur->pList2 ){
+    Tcl_DecrRefCount(pCur->pList2);
+  }
+  sqlite3_free(pCur);
+  return SQLITE_OK;
+}
+
+/*
+** Returns 1 if data is ready, or 0 if not.
+*/
+static int next2(Tcl_Interp *interp, tclvar_cursor *pCur, Tcl_Obj *pObj){
+  Tcl_Obj *p;
+
+  if( pObj ){
+    if( !pCur->pList2 ){
+      p = Tcl_NewStringObj("array names", -1);
+      Tcl_IncrRefCount(p);
+      Tcl_ListObjAppendElement(0, p, pObj);
+      Tcl_EvalObjEx(interp, p, TCL_EVAL_GLOBAL);
+      Tcl_DecrRefCount(p);
+      pCur->pList2 = Tcl_GetObjResult(interp);
+      Tcl_IncrRefCount(pCur->pList2);
+      assert( pCur->i2==0 );
+    }else{
+      int n = 0;
+      pCur->i2++;
+      Tcl_ListObjLength(0, pCur->pList2, &n);
+      if( pCur->i2>=n ){
+        Tcl_DecrRefCount(pCur->pList2);
+        pCur->pList2 = 0;
+        pCur->i2 = 0;
+        return 0;
+      }
+    }
+  }
+
+  return 1;
+}
+
+static int tclvarNext(sqlite3_vtab_cursor *cur){
+  Tcl_Obj *pObj;
+  int n = 0;
+  int ok = 0;
+
+  tclvar_cursor *pCur = (tclvar_cursor *)cur;
+  Tcl_Interp *interp = ((tclvar_vtab *)(cur->pVtab))->interp;
+
+  Tcl_ListObjLength(0, pCur->pList1, &n);
+  while( !ok && pCur->i1<n ){
+    Tcl_ListObjIndex(0, pCur->pList1, pCur->i1, &pObj);
+    ok = next2(interp, pCur, pObj);
+    if( !ok ){
+      pCur->i1++;
+    }
+  }
+
+  return 0;
+}
+
+static int tclvarFilter(
+  sqlite3_vtab_cursor *pVtabCursor, 
+  int idxNum, const char *idxStr,
+  int argc, sqlite3_value **argv
+){
+  tclvar_cursor *pCur = (tclvar_cursor *)pVtabCursor;
+  Tcl_Interp *interp = ((tclvar_vtab *)(pVtabCursor->pVtab))->interp;
+
+  Tcl_Obj *p = Tcl_NewStringObj("info vars", -1);
+  Tcl_IncrRefCount(p);
+
+  assert( argc==0 || argc==1 );
+  if( argc==1 ){
+    Tcl_Obj *pArg = Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1);
+    Tcl_ListObjAppendElement(0, p, pArg);
+  }
+  Tcl_EvalObjEx(interp, p, TCL_EVAL_GLOBAL);
+  pCur->pList1 = Tcl_GetObjResult(interp);
+  Tcl_IncrRefCount(pCur->pList1);
+  assert( pCur->i1==0 && pCur->i2==0 && pCur->pList2==0 );
+
+  Tcl_DecrRefCount(p);
+  return tclvarNext(pVtabCursor);
+}
+
+static int tclvarColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
+  Tcl_Obj *p1;
+  Tcl_Obj *p2;
+  const char *z1; 
+  const char *z2 = "";
+  tclvar_cursor *pCur = (tclvar_cursor*)cur;
+  Tcl_Interp *interp = ((tclvar_vtab *)cur->pVtab)->interp;
+
+  Tcl_ListObjIndex(interp, pCur->pList1, pCur->i1, &p1);
+  Tcl_ListObjIndex(interp, pCur->pList2, pCur->i2, &p2);
+  z1 = Tcl_GetString(p1);
+  if( p2 ){
+    z2 = Tcl_GetString(p2);
+  }
+  switch (i) {
+    case 0: {
+      sqlite3_result_text(ctx, z1, -1, SQLITE_TRANSIENT);
+      break;
+    }
+    case 1: {
+      sqlite3_result_text(ctx, z2, -1, SQLITE_TRANSIENT);
+      break;
+    }
+    case 2: {
+      Tcl_Obj *pVal = Tcl_GetVar2Ex(interp, z1, *z2?z2:0, TCL_GLOBAL_ONLY);
+      sqlite3_result_text(ctx, Tcl_GetString(pVal), -1, SQLITE_TRANSIENT);
+      break;
+    }
+  }
+  return SQLITE_OK;
+}
+
+static int tclvarRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
+  *pRowid = 0;
+  return SQLITE_OK;
+}
+
+static int tclvarEof(sqlite3_vtab_cursor *cur){
+  tclvar_cursor *pCur = (tclvar_cursor*)cur;
+  return (pCur->pList2?0:1);
+}
+
+static int tclvarBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
+  int ii;
+
+  for(ii=0; ii<pIdxInfo->nConstraint; ii++){
+    struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];
+    if( pCons->iColumn==0 && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){
+      struct sqlite3_index_constraint_usage *pUsage;
+      pUsage = &pIdxInfo->aConstraintUsage[ii];
+      pUsage->omit = 0;
+      pUsage->argvIndex = 1;
+      return SQLITE_OK;
+    }
+  }
+
+  for(ii=0; ii<pIdxInfo->nConstraint; ii++){
+    struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];
+    if( pCons->iColumn==0 && pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
+      struct sqlite3_index_constraint_usage *pUsage;
+      pUsage = &pIdxInfo->aConstraintUsage[ii];
+      pUsage->omit = 1;
+      pUsage->argvIndex = 1;
+      return SQLITE_OK;
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+/*
+** A virtual table module that provides read-only access to a
+** Tcl global variable namespace.
+*/
+static sqlite3_module tclvarModule = {
+  0,                         /* iVersion */
+  tclvarConnect,
+  tclvarConnect,
+  tclvarBestIndex,
+  tclvarDisconnect, 
+  tclvarDisconnect,
+  tclvarOpen,                  /* xOpen - open a cursor */
+  tclvarClose,                 /* xClose - close a cursor */
+  tclvarFilter,                /* xFilter - configure scan constraints */
+  tclvarNext,                  /* xNext - advance a cursor */
+  tclvarEof,                   /* xEof - check for end of scan */
+  tclvarColumn,                /* xColumn - read data */
+  tclvarRowid,                 /* xRowid - read data */
+  0,                           /* xUpdate */
+  0,                           /* xBegin */
+  0,                           /* xSync */
+  0,                           /* xCommit */
+  0,                           /* xRollback */
+  0,                           /* xFindMethod */
+  0,                           /* xRename */
+};
+
+/*
+** Decode a pointer to an sqlite3 object.
+*/
+static int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
+  *ppDb = (sqlite3*)sqlite3TextToPtr(zA);
+  return TCL_OK;
+}
+
+
+/*
+** Register the echo virtual table module.
+*/
+static int register_tclvar_module(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  if( objc!=2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  sqlite3_create_module(db, "tclvar", &tclvarModule, (void *)interp);
+#endif
+  return TCL_OK;
+}
+
+#endif
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetesttclvar_Init(Tcl_Interp *interp){
+  static struct {
+     char *zName;
+     Tcl_ObjCmdProc *xProc;
+     void *clientData;
+  } aObjCmd[] = {
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+     { "register_tclvar_module",   register_tclvar_module, 0 },
+#endif
+  };
+  int i;
+  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
+        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
+  }
+  return TCL_OK;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/test_thread.c b/client/src/thirdparty/sqlite-3.4.2/src/test_thread.c
new file mode 100644
index 0000000..d74470e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/test_thread.c
@@ -0,0 +1,332 @@
+/*
+** 2007 September 9
+**
+** 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 the implementation of some Tcl commands used to
+** test that sqlite3 database handles may be concurrently accessed by 
+** multiple threads. Right now this only works on unix.
+**
+** $Id: test_thread.c,v 1.6 2007/12/13 21:54:11 drh Exp $
+*/
+
+#include "sqliteInt.h"
+#include <tcl.h>
+
+#if SQLITE_THREADSAFE && defined(TCL_THREADS)
+
+#include <errno.h>
+#include <unistd.h>
+
+/*
+** One of these is allocated for each thread created by [sqlthread spawn].
+*/
+typedef struct SqlThread SqlThread;
+struct SqlThread {
+  Tcl_ThreadId parent;     /* Thread id of parent thread */
+  Tcl_Interp *interp;      /* Parent interpreter */
+  char *zScript;           /* The script to execute. */
+  char *zVarname;          /* Varname in parent script */
+};
+
+/*
+** A custom Tcl_Event type used by this module. When the event is
+** handled, script zScript is evaluated in interpreter interp. If
+** the evaluation throws an exception (returns TCL_ERROR), then the
+** error is handled by Tcl_BackgroundError(). If no error occurs,
+** the result is simply discarded.
+*/
+typedef struct EvalEvent EvalEvent;
+struct EvalEvent {
+  Tcl_Event base;          /* Base class of type Tcl_Event */
+  char *zScript;           /* The script to execute. */
+  Tcl_Interp *interp;      /* The interpreter to execute it in. */
+};
+
+static Tcl_ObjCmdProc sqlthread_proc;
+int Sqlitetest1_Init(Tcl_Interp *);
+
+/*
+** Handler for events of type EvalEvent.
+*/
+static int tclScriptEvent(Tcl_Event *evPtr, int flags){
+  int rc;
+  EvalEvent *p = (EvalEvent *)evPtr;
+  rc = Tcl_Eval(p->interp, p->zScript);
+  if( rc!=TCL_OK ){
+    Tcl_BackgroundError(p->interp);
+  }
+  return 1;
+}
+
+/*
+** Register an EvalEvent to evaluate the script pScript in the
+** parent interpreter/thread of SqlThread p.
+*/
+static void postToParent(SqlThread *p, Tcl_Obj *pScript){
+  EvalEvent *pEvent;
+  char *zMsg;
+  int nMsg;
+
+  zMsg = Tcl_GetStringFromObj(pScript, &nMsg); 
+  pEvent = (EvalEvent *)ckalloc(sizeof(EvalEvent)+nMsg+1);
+  pEvent->base.nextPtr = 0;
+  pEvent->base.proc = tclScriptEvent;
+  pEvent->zScript = (char *)&pEvent[1];
+  memcpy(pEvent->zScript, zMsg, nMsg+1);
+  pEvent->interp = p->interp;
+
+  Tcl_ThreadQueueEvent(p->parent, (Tcl_Event *)pEvent, TCL_QUEUE_TAIL);
+  Tcl_ThreadAlert(p->parent);
+}
+
+/*
+** The main function for threads created with [sqlthread spawn].
+*/
+static Tcl_ThreadCreateType tclScriptThread(ClientData pSqlThread){
+  Tcl_Interp *interp;
+  Tcl_Obj *pRes;
+  Tcl_Obj *pList;
+  int rc;
+
+  SqlThread *p = (SqlThread *)pSqlThread;
+
+  interp = Tcl_CreateInterp();
+  Tcl_CreateObjCommand(interp, "sqlthread", sqlthread_proc, pSqlThread, 0);
+  Sqlitetest1_Init(interp);
+
+  rc = Tcl_Eval(interp, p->zScript);
+  pRes = Tcl_GetObjResult(interp);
+  pList = Tcl_NewObj();
+  Tcl_IncrRefCount(pList);
+  Tcl_IncrRefCount(pRes);
+
+  if( rc!=TCL_OK ){
+    Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj("error", -1));
+    Tcl_ListObjAppendElement(interp, pList, pRes);
+    postToParent(p, pList);
+    Tcl_DecrRefCount(pList);
+    pList = Tcl_NewObj();
+  }
+
+  Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj("set", -1));
+  Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(p->zVarname, -1));
+  Tcl_ListObjAppendElement(interp, pList, pRes);
+  postToParent(p, pList);
+
+  ckfree((void *)p);
+  Tcl_DecrRefCount(pList);
+  Tcl_DecrRefCount(pRes);
+  Tcl_DeleteInterp(interp);
+  return;
+}
+
+/*
+** sqlthread spawn VARNAME SCRIPT
+**
+**     Spawn a new thread with its own Tcl interpreter and run the
+**     specified SCRIPT(s) in it. The thread terminates after running
+**     the script. The result of the script is stored in the variable
+**     VARNAME.
+**
+**     The caller can wait for the script to terminate using [vwait VARNAME].
+*/
+static int sqlthread_spawn(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Tcl_ThreadId x;
+  SqlThread *pNew;
+  int rc;
+
+  int nVarname; char *zVarname;
+  int nScript; char *zScript;
+
+  /* Parameters for thread creation */
+  const int nStack = TCL_THREAD_STACK_DEFAULT;
+  const int flags = TCL_THREAD_NOFLAGS;
+
+  assert(objc==4);
+
+  zVarname = Tcl_GetStringFromObj(objv[2], &nVarname);
+  zScript = Tcl_GetStringFromObj(objv[3], &nScript);
+
+  pNew = (SqlThread *)ckalloc(sizeof(SqlThread)+nVarname+nScript+2);
+  pNew->zVarname = (char *)&pNew[1];
+  pNew->zScript = (char *)&pNew->zVarname[nVarname+1];
+  memcpy(pNew->zVarname, zVarname, nVarname+1);
+  memcpy(pNew->zScript, zScript, nScript+1);
+  pNew->parent = Tcl_GetCurrentThread();
+  pNew->interp = interp;
+
+  rc = Tcl_CreateThread(&x, tclScriptThread, (void *)pNew, nStack, flags);
+  if( rc!=TCL_OK ){
+    Tcl_AppendResult(interp, "Error in Tcl_CreateThread()", 0);
+    sqlite3_free(pNew);
+    return TCL_ERROR;
+  }
+
+  return TCL_OK;
+}
+
+/*
+** sqlthread parent SCRIPT
+**
+**     This can be called by spawned threads only. It sends the specified
+**     script back to the parent thread for execution. The result of
+**     evaluating the SCRIPT is returned. The parent thread must enter
+**     the event loop for this to work - otherwise the caller will
+**     block indefinitely.
+**
+**     NOTE: At the moment, this doesn't work. FIXME.
+*/
+static int sqlthread_parent(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  EvalEvent *pEvent;
+  char *zMsg;
+  int nMsg;
+  SqlThread *p = (SqlThread *)clientData;
+
+  assert(objc==3);
+  if( p==0 ){
+    Tcl_AppendResult(interp, "no parent thread", 0);
+    return TCL_ERROR;
+  }
+
+  zMsg = Tcl_GetStringFromObj(objv[2], &nMsg);
+  pEvent = (EvalEvent *)ckalloc(sizeof(EvalEvent)+nMsg+1);
+  pEvent->base.nextPtr = 0;
+  pEvent->base.proc = tclScriptEvent;
+  pEvent->zScript = (char *)&pEvent[1];
+  memcpy(pEvent->zScript, zMsg, nMsg+1);
+  pEvent->interp = p->interp;
+  Tcl_ThreadQueueEvent(p->parent, (Tcl_Event *)pEvent, TCL_QUEUE_TAIL);
+  Tcl_ThreadAlert(p->parent);
+
+  return TCL_OK;
+}
+
+static int xBusy(void *pArg, int nBusy){
+  sqlite3_sleep(50);
+  return 1;             /* Try again... */
+}
+
+/*
+** sqlthread open
+**
+**     Open a database handle and return the string representation of
+**     the pointer value.
+*/
+static int sqlthread_open(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p);
+
+  const char *zFilename;
+  sqlite3 *db;
+  int rc;
+  char zBuf[100];
+  extern void Md5_Register(sqlite3*);
+
+  zFilename = Tcl_GetString(objv[2]);
+  rc = sqlite3_open(zFilename, &db);
+  Md5_Register(db);
+  sqlite3_busy_handler(db, xBusy, 0);
+  
+  if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
+  Tcl_AppendResult(interp, zBuf, 0);
+
+  return TCL_OK;
+}
+
+
+/*
+** sqlthread open
+**
+**     Return the current thread-id (Tcl_GetCurrentThread()) cast to
+**     an integer.
+*/
+static int sqlthread_id(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Tcl_ThreadId id = Tcl_GetCurrentThread();
+  Tcl_SetObjResult(interp, Tcl_NewIntObj((int)id));
+  return TCL_OK;
+}
+
+
+/*
+** Dispatch routine for the sub-commands of [sqlthread].
+*/
+static int sqlthread_proc(
+  ClientData clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  struct SubCommand {
+    char *zName;
+    Tcl_ObjCmdProc *xProc;
+    int nArg;
+    char *zUsage;
+  } aSub[] = {
+    {"parent", sqlthread_parent, 1, "SCRIPT"},
+    {"spawn",  sqlthread_spawn,  2, "VARNAME SCRIPT"},
+    {"open",   sqlthread_open,   1, "DBNAME"},
+    {"id",     sqlthread_id,     0, ""},
+    {0, 0, 0}
+  };
+  struct SubCommand *pSub;
+  int rc;
+  int iIndex;
+
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND");
+    return TCL_ERROR;
+  }
+
+  rc = Tcl_GetIndexFromObjStruct(
+      interp, objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iIndex
+  );
+  if( rc!=TCL_OK ) return rc;
+  pSub = &aSub[iIndex];
+
+  if( objc!=(pSub->nArg+2) ){
+    Tcl_WrongNumArgs(interp, 2, objv, pSub->zUsage);
+    return TCL_ERROR;
+  }
+
+  return pSub->xProc(clientData, interp, objc, objv);
+}
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int SqlitetestThread_Init(Tcl_Interp *interp){
+  Tcl_CreateObjCommand(interp, "sqlthread", sqlthread_proc, 0, 0);
+  return TCL_OK;
+}
+#else
+int SqlitetestThread_Init(Tcl_Interp *interp){
+  return TCL_OK;
+}
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/tokenize.c b/client/src/thirdparty/sqlite-3.4.2/src/tokenize.c
new file mode 100644
index 0000000..a029c4e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/tokenize.c
@@ -0,0 +1,503 @@
+/*
+** 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.
+**
+*************************************************************************
+** An tokenizer for SQL
+**
+** This file contains C code that splits an SQL input string up into
+** individual tokens and sends those tokens one-by-one over to the
+** parser for analysis.
+**
+** $Id: tokenize.c,v 1.138 2008/01/22 23:37:10 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include <stdlib.h>
+
+/*
+** The charMap() macro maps alphabetic characters into their
+** lower-case ASCII equivalent.  On ASCII machines, this is just
+** an upper-to-lower case map.  On EBCDIC machines we also need
+** to adjust the encoding.  Only alphabetic characters and underscores
+** need to be translated.
+*/
+#ifdef SQLITE_ASCII
+# define charMap(X) sqlite3UpperToLower[(unsigned char)X]
+#endif
+#ifdef SQLITE_EBCDIC
+# define charMap(X) ebcdicToAscii[(unsigned char)X]
+const unsigned char ebcdicToAscii[] = {
+/* 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 0x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 1x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 2x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 3x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 4x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 5x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 95,  0,  0,  /* 6x */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 7x */
+   0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* 8x */
+   0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* 9x */
+   0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ax */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Bx */
+   0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* Cx */
+   0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* Dx */
+   0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ex */
+   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Fx */
+};
+#endif
+
+/*
+** The sqlite3KeywordCode function looks up an identifier to determine if
+** it is a keyword.  If it is a keyword, the token code of that keyword is 
+** returned.  If the input is not a keyword, TK_ID is returned.
+**
+** The implementation of this routine was generated by a program,
+** mkkeywordhash.h, located in the tool subdirectory of the distribution.
+** The output of the mkkeywordhash.c program is written into a file
+** named keywordhash.h and then included into this source file by
+** the #include below.
+*/
+#include "keywordhash.h"
+
+
+/*
+** If X is a character that can be used in an identifier then
+** IdChar(X) will be true.  Otherwise it is false.
+**
+** For ASCII, any character with the high-order bit set is
+** allowed in an identifier.  For 7-bit characters, 
+** sqlite3IsIdChar[X] must be 1.
+**
+** For EBCDIC, the rules are more complex but have the same
+** end result.
+**
+** Ticket #1066.  the SQL standard does not allow '$' in the
+** middle of identfiers.  But many SQL implementations do. 
+** SQLite will allow '$' in identifiers for compatibility.
+** But the feature is undocumented.
+*/
+#ifdef SQLITE_ASCII
+const char sqlite3IsAsciiIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
+};
+#define IdChar(C)  (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsAsciiIdChar[c-0x20]))
+#endif
+#ifdef SQLITE_EBCDIC
+const char sqlite3IsEbcdicIdChar[] = {
+/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 4x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,  /* 5x */
+    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,  /* 6x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,  /* 7x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,  /* 8x */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,  /* 9x */
+    1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,  /* Ax */
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* Bx */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Cx */
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Dx */
+    0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Ex */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,  /* Fx */
+};
+#define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
+#endif
+
+
+/*
+** Return the length of the token that begins at z[0]. 
+** Store the token type in *tokenType before returning.
+*/
+static int getToken(const unsigned char *z, int *tokenType){
+  int i, c;
+  switch( *z ){
+    case ' ': case '\t': case '\n': case '\f': case '\r': {
+      for(i=1; isspace(z[i]); i++){}
+      *tokenType = TK_SPACE;
+      return i;
+    }
+    case '-': {
+      if( z[1]=='-' ){
+        for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
+        *tokenType = TK_COMMENT;
+        return i;
+      }
+      *tokenType = TK_MINUS;
+      return 1;
+    }
+    case '(': {
+      *tokenType = TK_LP;
+      return 1;
+    }
+    case ')': {
+      *tokenType = TK_RP;
+      return 1;
+    }
+    case ';': {
+      *tokenType = TK_SEMI;
+      return 1;
+    }
+    case '+': {
+      *tokenType = TK_PLUS;
+      return 1;
+    }
+    case '*': {
+      *tokenType = TK_STAR;
+      return 1;
+    }
+    case '/': {
+      if( z[1]!='*' || z[2]==0 ){
+        *tokenType = TK_SLASH;
+        return 1;
+      }
+      for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
+      if( c ) i++;
+      *tokenType = TK_COMMENT;
+      return i;
+    }
+    case '%': {
+      *tokenType = TK_REM;
+      return 1;
+    }
+    case '=': {
+      *tokenType = TK_EQ;
+      return 1 + (z[1]=='=');
+    }
+    case '<': {
+      if( (c=z[1])=='=' ){
+        *tokenType = TK_LE;
+        return 2;
+      }else if( c=='>' ){
+        *tokenType = TK_NE;
+        return 2;
+      }else if( c=='<' ){
+        *tokenType = TK_LSHIFT;
+        return 2;
+      }else{
+        *tokenType = TK_LT;
+        return 1;
+      }
+    }
+    case '>': {
+      if( (c=z[1])=='=' ){
+        *tokenType = TK_GE;
+        return 2;
+      }else if( c=='>' ){
+        *tokenType = TK_RSHIFT;
+        return 2;
+      }else{
+        *tokenType = TK_GT;
+        return 1;
+      }
+    }
+    case '!': {
+      if( z[1]!='=' ){
+        *tokenType = TK_ILLEGAL;
+        return 2;
+      }else{
+        *tokenType = TK_NE;
+        return 2;
+      }
+    }
+    case '|': {
+      if( z[1]!='|' ){
+        *tokenType = TK_BITOR;
+        return 1;
+      }else{
+        *tokenType = TK_CONCAT;
+        return 2;
+      }
+    }
+    case ',': {
+      *tokenType = TK_COMMA;
+      return 1;
+    }
+    case '&': {
+      *tokenType = TK_BITAND;
+      return 1;
+    }
+    case '~': {
+      *tokenType = TK_BITNOT;
+      return 1;
+    }
+    case '`':
+    case '\'':
+    case '"': {
+      int delim = z[0];
+      for(i=1; (c=z[i])!=0; i++){
+        if( c==delim ){
+          if( z[i+1]==delim ){
+            i++;
+          }else{
+            break;
+          }
+        }
+      }
+      if( c ){
+        *tokenType = TK_STRING;
+        return i+1;
+      }else{
+        *tokenType = TK_ILLEGAL;
+        return i;
+      }
+    }
+    case '.': {
+#ifndef SQLITE_OMIT_FLOATING_POINT
+      if( !isdigit(z[1]) )
+#endif
+      {
+        *tokenType = TK_DOT;
+        return 1;
+      }
+      /* If the next character is a digit, this is a floating point
+      ** number that begins with ".".  Fall thru into the next case */
+    }
+    case '0': case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8': case '9': {
+      *tokenType = TK_INTEGER;
+      for(i=0; isdigit(z[i]); i++){}
+#ifndef SQLITE_OMIT_FLOATING_POINT
+      if( z[i]=='.' ){
+        i++;
+        while( isdigit(z[i]) ){ i++; }
+        *tokenType = TK_FLOAT;
+      }
+      if( (z[i]=='e' || z[i]=='E') &&
+           ( isdigit(z[i+1]) 
+            || ((z[i+1]=='+' || z[i+1]=='-') && isdigit(z[i+2]))
+           )
+      ){
+        i += 2;
+        while( isdigit(z[i]) ){ i++; }
+        *tokenType = TK_FLOAT;
+      }
+#endif
+      while( IdChar(z[i]) ){
+        *tokenType = TK_ILLEGAL;
+        i++;
+      }
+      return i;
+    }
+    case '[': {
+      for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
+      *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
+      return i;
+    }
+    case '?': {
+      *tokenType = TK_VARIABLE;
+      for(i=1; isdigit(z[i]); i++){}
+      return i;
+    }
+    case '#': {
+      for(i=1; isdigit(z[i]); i++){}
+      if( i>1 ){
+        /* Parameters of the form #NNN (where NNN is a number) are used
+        ** internally by sqlite3NestedParse.  */
+        *tokenType = TK_REGISTER;
+        return i;
+      }
+      /* Fall through into the next case if the '#' is not followed by
+      ** a digit. Try to match #AAAA where AAAA is a parameter name. */
+    }
+#ifndef SQLITE_OMIT_TCL_VARIABLE
+    case '$':
+#endif
+    case '@':  /* For compatibility with MS SQL Server */
+    case ':': {
+      int n = 0;
+      *tokenType = TK_VARIABLE;
+      for(i=1; (c=z[i])!=0; i++){
+        if( IdChar(c) ){
+          n++;
+#ifndef SQLITE_OMIT_TCL_VARIABLE
+        }else if( c=='(' && n>0 ){
+          do{
+            i++;
+          }while( (c=z[i])!=0 && !isspace(c) && c!=')' );
+          if( c==')' ){
+            i++;
+          }else{
+            *tokenType = TK_ILLEGAL;
+          }
+          break;
+        }else if( c==':' && z[i+1]==':' ){
+          i++;
+#endif
+        }else{
+          break;
+        }
+      }
+      if( n==0 ) *tokenType = TK_ILLEGAL;
+      return i;
+    }
+#ifndef SQLITE_OMIT_BLOB_LITERAL
+    case 'x': case 'X': {
+      if( z[1]=='\'' ){
+        *tokenType = TK_BLOB;
+        for(i=2; (c=z[i])!=0 && c!='\''; i++){
+          if( !isxdigit(c) ){
+            *tokenType = TK_ILLEGAL;
+          }
+        }
+        if( i%2 || !c ) *tokenType = TK_ILLEGAL;
+        if( c ) i++;
+        return i;
+      }
+      /* Otherwise fall through to the next case */
+    }
+#endif
+    default: {
+      if( !IdChar(*z) ){
+        break;
+      }
+      for(i=1; IdChar(z[i]); i++){}
+      *tokenType = keywordCode((char*)z, i);
+      return i;
+    }
+  }
+  *tokenType = TK_ILLEGAL;
+  return 1;
+}
+int sqlite3GetToken(const unsigned char *z, int *tokenType){
+  return getToken(z, tokenType);
+}
+
+/*
+** Run the parser on the given SQL string.  The parser structure is
+** passed in.  An SQLITE_ status code is returned.  If an error occurs
+** and pzErrMsg!=NULL then an error message might be written into 
+** memory obtained from sqlite3_malloc() and *pzErrMsg made to point to that
+** error message.  Or maybe not.
+*/
+int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
+  int nErr = 0;
+  int i;
+  void *pEngine;
+  int tokenType;
+  int lastTokenParsed = -1;
+  sqlite3 *db = pParse->db;
+
+  if( db->activeVdbeCnt==0 ){
+    db->u1.isInterrupted = 0;
+  }
+  pParse->rc = SQLITE_OK;
+  i = 0;
+  pEngine = sqlite3ParserAlloc((void*(*)(size_t))sqlite3_malloc);
+  if( pEngine==0 ){
+    db->mallocFailed = 1;
+    return SQLITE_NOMEM;
+  }
+  assert( pParse->sLastToken.dyn==0 );
+  assert( pParse->pNewTable==0 );
+  assert( pParse->pNewTrigger==0 );
+  assert( pParse->nVar==0 );
+  assert( pParse->nVarExpr==0 );
+  assert( pParse->nVarExprAlloc==0 );
+  assert( pParse->apVarExpr==0 );
+  pParse->zTail = pParse->zSql = zSql;
+  while( !db->mallocFailed && zSql[i]!=0 ){
+    assert( i>=0 );
+    pParse->sLastToken.z = (u8*)&zSql[i];
+    assert( pParse->sLastToken.dyn==0 );
+    pParse->sLastToken.n = getToken((unsigned char*)&zSql[i],&tokenType);
+    i += pParse->sLastToken.n;
+    if( SQLITE_MAX_SQL_LENGTH>0 && i>SQLITE_MAX_SQL_LENGTH ){
+      pParse->rc = SQLITE_TOOBIG;
+      break;
+    }
+    switch( tokenType ){
+      case TK_SPACE:
+      case TK_COMMENT: {
+        if( db->u1.isInterrupted ){
+          pParse->rc = SQLITE_INTERRUPT;
+          sqlite3SetString(pzErrMsg, "interrupt", (char*)0);
+          goto abort_parse;
+        }
+        break;
+      }
+      case TK_ILLEGAL: {
+        if( pzErrMsg ){
+          sqlite3_free(*pzErrMsg);
+          *pzErrMsg = sqlite3MPrintf(db, "unrecognized token: \"%T\"",
+                          &pParse->sLastToken);
+        }
+        nErr++;
+        goto abort_parse;
+      }
+      case TK_SEMI: {
+        pParse->zTail = &zSql[i];
+        /* Fall thru into the default case */
+      }
+      default: {
+        sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
+        lastTokenParsed = tokenType;
+        if( pParse->rc!=SQLITE_OK ){
+          goto abort_parse;
+        }
+        break;
+      }
+    }
+  }
+abort_parse:
+  if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
+    if( lastTokenParsed!=TK_SEMI ){
+      sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
+      pParse->zTail = &zSql[i];
+    }
+    sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
+  }
+  sqlite3ParserFree(pEngine, sqlite3_free);
+  if( db->mallocFailed ){
+    pParse->rc = SQLITE_NOMEM;
+  }
+  if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
+    sqlite3SetString(&pParse->zErrMsg, sqlite3ErrStr(pParse->rc), (char*)0);
+  }
+  if( pParse->zErrMsg ){
+    if( pzErrMsg && *pzErrMsg==0 ){
+      *pzErrMsg = pParse->zErrMsg;
+    }else{
+      sqlite3_free(pParse->zErrMsg);
+    }
+    pParse->zErrMsg = 0;
+    nErr++;
+  }
+  if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
+    sqlite3VdbeDelete(pParse->pVdbe);
+    pParse->pVdbe = 0;
+  }
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  if( pParse->nested==0 ){
+    sqlite3_free(pParse->aTableLock);
+    pParse->aTableLock = 0;
+    pParse->nTableLock = 0;
+  }
+#endif
+
+  if( !IN_DECLARE_VTAB ){
+    /* If the pParse->declareVtab flag is set, do not delete any table 
+    ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
+    ** will take responsibility for freeing the Table structure.
+    */
+    sqlite3DeleteTable(pParse->pNewTable);
+  }
+
+  sqlite3DeleteTrigger(pParse->pNewTrigger);
+  sqlite3_free(pParse->apVarExpr);
+  if( nErr>0 && (pParse->rc==SQLITE_OK || pParse->rc==SQLITE_DONE) ){
+    pParse->rc = SQLITE_ERROR;
+  }
+  return nErr;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/trigger.c b/client/src/thirdparty/sqlite-3.4.2/src/trigger.c
new file mode 100644
index 0000000..70cf6ab
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/trigger.c
@@ -0,0 +1,851 @@
+/*
+**
+** 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.
+**
+*************************************************************************
+*
+*/
+#include "sqliteInt.h"
+
+#ifndef SQLITE_OMIT_TRIGGER
+/*
+** Delete a linked list of TriggerStep structures.
+*/
+void sqlite3DeleteTriggerStep(TriggerStep *pTriggerStep){
+  while( pTriggerStep ){
+    TriggerStep * pTmp = pTriggerStep;
+    pTriggerStep = pTriggerStep->pNext;
+
+    if( pTmp->target.dyn ) sqlite3_free((char*)pTmp->target.z);
+    sqlite3ExprDelete(pTmp->pWhere);
+    sqlite3ExprListDelete(pTmp->pExprList);
+    sqlite3SelectDelete(pTmp->pSelect);
+    sqlite3IdListDelete(pTmp->pIdList);
+
+    sqlite3_free(pTmp);
+  }
+}
+
+/*
+** This is called by the parser when it sees a CREATE TRIGGER statement
+** up to the point of the BEGIN before the trigger actions.  A Trigger
+** structure is generated based on the information available and stored
+** in pParse->pNewTrigger.  After the trigger actions have been parsed, the
+** sqlite3FinishTrigger() function is called to complete the trigger
+** construction process.
+*/
+void sqlite3BeginTrigger(
+  Parse *pParse,      /* The parse context of the CREATE TRIGGER statement */
+  Token *pName1,      /* The name of the trigger */
+  Token *pName2,      /* The name of the trigger */
+  int tr_tm,          /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
+  int op,             /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
+  IdList *pColumns,   /* column list if this is an UPDATE OF trigger */
+  SrcList *pTableName,/* The name of the table/view the trigger applies to */
+  Expr *pWhen,        /* WHEN clause */
+  int isTemp,         /* True if the TEMPORARY keyword is present */
+  int noErr           /* Suppress errors if the trigger already exists */
+){
+  Trigger *pTrigger = 0;
+  Table *pTab;
+  char *zName = 0;        /* Name of the trigger */
+  sqlite3 *db = pParse->db;
+  int iDb;                /* The database to store the trigger in */
+  Token *pName;           /* The unqualified db name */
+  DbFixer sFix;
+  int iTabDb;
+
+  assert( pName1!=0 );   /* pName1->z might be NULL, but not pName1 itself */
+  assert( pName2!=0 );
+  if( isTemp ){
+    /* If TEMP was specified, then the trigger name may not be qualified. */
+    if( pName2->n>0 ){
+      sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
+      goto trigger_cleanup;
+    }
+    iDb = 1;
+    pName = pName1;
+  }else{
+    /* Figure out the db that the the trigger will be created in */
+    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
+    if( iDb<0 ){
+      goto trigger_cleanup;
+    }
+  }
+
+  /* If the trigger name was unqualified, and the table is a temp table,
+  ** then set iDb to 1 to create the trigger in the temporary database.
+  ** If sqlite3SrcListLookup() returns 0, indicating the table does not
+  ** exist, the error is caught by the block below.
+  */
+  if( !pTableName || db->mallocFailed ){
+    goto trigger_cleanup;
+  }
+  pTab = sqlite3SrcListLookup(pParse, pTableName);
+  if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
+    iDb = 1;
+  }
+
+  /* Ensure the table name matches database name and that the table exists */
+  if( db->mallocFailed ) goto trigger_cleanup;
+  assert( pTableName->nSrc==1 );
+  if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName) && 
+      sqlite3FixSrcList(&sFix, pTableName) ){
+    goto trigger_cleanup;
+  }
+  pTab = sqlite3SrcListLookup(pParse, pTableName);
+  if( !pTab ){
+    /* The table does not exist. */
+    goto trigger_cleanup;
+  }
+  if( IsVirtual(pTab) ){
+    sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
+    goto trigger_cleanup;
+  }
+
+  /* Check that the trigger name is not reserved and that no trigger of the
+  ** specified name exists */
+  zName = sqlite3NameFromToken(db, pName);
+  if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
+    goto trigger_cleanup;
+  }
+  if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash), zName,strlen(zName)) ){
+    if( !noErr ){
+      sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
+    }
+    goto trigger_cleanup;
+  }
+
+  /* Do not create a trigger on a system table */
+  if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
+    sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
+    pParse->nErr++;
+    goto trigger_cleanup;
+  }
+
+  /* INSTEAD of triggers are only for views and views only support INSTEAD
+  ** of triggers.
+  */
+  if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
+    sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", 
+        (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
+    goto trigger_cleanup;
+  }
+  if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
+    sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
+        " trigger on table: %S", pTableName, 0);
+    goto trigger_cleanup;
+  }
+  iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  {
+    int code = SQLITE_CREATE_TRIGGER;
+    const char *zDb = db->aDb[iTabDb].zName;
+    const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
+    if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
+    if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
+      goto trigger_cleanup;
+    }
+    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
+      goto trigger_cleanup;
+    }
+  }
+#endif
+
+  /* INSTEAD OF triggers can only appear on views and BEFORE triggers
+  ** cannot appear on views.  So we might as well translate every
+  ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code
+  ** elsewhere.
+  */
+  if (tr_tm == TK_INSTEAD){
+    tr_tm = TK_BEFORE;
+  }
+
+  /* Build the Trigger object */
+  pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
+  if( pTrigger==0 ) goto trigger_cleanup;
+  pTrigger->name = zName;
+  zName = 0;
+  pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
+  pTrigger->pSchema = db->aDb[iDb].pSchema;
+  pTrigger->pTabSchema = pTab->pSchema;
+  pTrigger->op = op;
+  pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
+  pTrigger->pWhen = sqlite3ExprDup(db, pWhen);
+  pTrigger->pColumns = sqlite3IdListDup(db, pColumns);
+  sqlite3TokenCopy(db, &pTrigger->nameToken,pName);
+  assert( pParse->pNewTrigger==0 );
+  pParse->pNewTrigger = pTrigger;
+
+trigger_cleanup:
+  sqlite3_free(zName);
+  sqlite3SrcListDelete(pTableName);
+  sqlite3IdListDelete(pColumns);
+  sqlite3ExprDelete(pWhen);
+  if( !pParse->pNewTrigger ){
+    sqlite3DeleteTrigger(pTrigger);
+  }else{
+    assert( pParse->pNewTrigger==pTrigger );
+  }
+}
+
+/*
+** This routine is called after all of the trigger actions have been parsed
+** in order to complete the process of building the trigger.
+*/
+void sqlite3FinishTrigger(
+  Parse *pParse,          /* Parser context */
+  TriggerStep *pStepList, /* The triggered program */
+  Token *pAll             /* Token that describes the complete CREATE TRIGGER */
+){
+  Trigger *pTrig = 0;     /* The trigger whose construction is finishing up */
+  sqlite3 *db = pParse->db;  /* The database */
+  DbFixer sFix;
+  int iDb;                   /* Database containing the trigger */
+
+  pTrig = pParse->pNewTrigger;
+  pParse->pNewTrigger = 0;
+  if( pParse->nErr || !pTrig ) goto triggerfinish_cleanup;
+  iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
+  pTrig->step_list = pStepList;
+  while( pStepList ){
+    pStepList->pTrig = pTrig;
+    pStepList = pStepList->pNext;
+  }
+  if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", &pTrig->nameToken) 
+          && sqlite3FixTriggerStep(&sFix, pTrig->step_list) ){
+    goto triggerfinish_cleanup;
+  }
+
+  /* if we are not initializing, and this trigger is not on a TEMP table, 
+  ** build the sqlite_master entry
+  */
+  if( !db->init.busy ){
+    Vdbe *v;
+    char *z;
+
+    /* Make an entry in the sqlite_master table */
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) goto triggerfinish_cleanup;
+    sqlite3BeginWriteOperation(pParse, 0, iDb);
+    z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
+    sqlite3NestedParse(pParse,
+       "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
+       db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pTrig->name,
+       pTrig->table, z);
+    sqlite3_free(z);
+    sqlite3ChangeCookie(pParse, iDb);
+    sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 0, 0, sqlite3MPrintf(
+        db, "type='trigger' AND name='%q'", pTrig->name), P4_DYNAMIC
+    );
+  }
+
+  if( db->init.busy ){
+    int n;
+    Table *pTab;
+    Trigger *pDel;
+    pDel = sqlite3HashInsert(&db->aDb[iDb].pSchema->trigHash, 
+                     pTrig->name, strlen(pTrig->name), pTrig);
+    if( pDel ){
+      assert( pDel==pTrig );
+      db->mallocFailed = 1;
+      goto triggerfinish_cleanup;
+    }
+    n = strlen(pTrig->table) + 1;
+    pTab = sqlite3HashFind(&pTrig->pTabSchema->tblHash, pTrig->table, n);
+    assert( pTab!=0 );
+    pTrig->pNext = pTab->pTrigger;
+    pTab->pTrigger = pTrig;
+    pTrig = 0;
+  }
+
+triggerfinish_cleanup:
+  sqlite3DeleteTrigger(pTrig);
+  assert( !pParse->pNewTrigger );
+  sqlite3DeleteTriggerStep(pStepList);
+}
+
+/*
+** Make a copy of all components of the given trigger step.  This has
+** the effect of copying all Expr.token.z values into memory obtained
+** from sqlite3_malloc().  As initially created, the Expr.token.z values
+** all point to the input string that was fed to the parser.  But that
+** string is ephemeral - it will go away as soon as the sqlite3_exec()
+** call that started the parser exits.  This routine makes a persistent
+** copy of all the Expr.token.z strings so that the TriggerStep structure
+** will be valid even after the sqlite3_exec() call returns.
+*/
+static void sqlitePersistTriggerStep(sqlite3 *db, TriggerStep *p){
+  if( p->target.z ){
+    p->target.z = (u8*)sqlite3DbStrNDup(db, (char*)p->target.z, p->target.n);
+    p->target.dyn = 1;
+  }
+  if( p->pSelect ){
+    Select *pNew = sqlite3SelectDup(db, p->pSelect);
+    sqlite3SelectDelete(p->pSelect);
+    p->pSelect = pNew;
+  }
+  if( p->pWhere ){
+    Expr *pNew = sqlite3ExprDup(db, p->pWhere);
+    sqlite3ExprDelete(p->pWhere);
+    p->pWhere = pNew;
+  }
+  if( p->pExprList ){
+    ExprList *pNew = sqlite3ExprListDup(db, p->pExprList);
+    sqlite3ExprListDelete(p->pExprList);
+    p->pExprList = pNew;
+  }
+  if( p->pIdList ){
+    IdList *pNew = sqlite3IdListDup(db, p->pIdList);
+    sqlite3IdListDelete(p->pIdList);
+    p->pIdList = pNew;
+  }
+}
+
+/*
+** Turn a SELECT statement (that the pSelect parameter points to) into
+** a trigger step.  Return a pointer to a TriggerStep structure.
+**
+** The parser calls this routine when it finds a SELECT statement in
+** body of a TRIGGER.  
+*/
+TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){
+  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
+  if( pTriggerStep==0 ) {
+    sqlite3SelectDelete(pSelect);
+    return 0;
+  }
+
+  pTriggerStep->op = TK_SELECT;
+  pTriggerStep->pSelect = pSelect;
+  pTriggerStep->orconf = OE_Default;
+  sqlitePersistTriggerStep(db, pTriggerStep);
+
+  return pTriggerStep;
+}
+
+/*
+** Build a trigger step out of an INSERT statement.  Return a pointer
+** to the new trigger step.
+**
+** The parser calls this routine when it sees an INSERT inside the
+** body of a trigger.
+*/
+TriggerStep *sqlite3TriggerInsertStep(
+  sqlite3 *db,        /* The database connection */
+  Token *pTableName,  /* Name of the table into which we insert */
+  IdList *pColumn,    /* List of columns in pTableName to insert into */
+  ExprList *pEList,   /* The VALUE clause: a list of values to be inserted */
+  Select *pSelect,    /* A SELECT statement that supplies values */
+  int orconf          /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
+){
+  TriggerStep *pTriggerStep;
+
+  assert(pEList == 0 || pSelect == 0);
+  assert(pEList != 0 || pSelect != 0 || db->mallocFailed);
+
+  pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
+  if( pTriggerStep ){
+    pTriggerStep->op = TK_INSERT;
+    pTriggerStep->pSelect = pSelect;
+    pTriggerStep->target  = *pTableName;
+    pTriggerStep->pIdList = pColumn;
+    pTriggerStep->pExprList = pEList;
+    pTriggerStep->orconf = orconf;
+    sqlitePersistTriggerStep(db, pTriggerStep);
+  }else{
+    sqlite3IdListDelete(pColumn);
+    sqlite3ExprListDelete(pEList);
+    sqlite3SelectDelete(pSelect);
+  }
+
+  return pTriggerStep;
+}
+
+/*
+** Construct a trigger step that implements an UPDATE statement and return
+** a pointer to that trigger step.  The parser calls this routine when it
+** sees an UPDATE statement inside the body of a CREATE TRIGGER.
+*/
+TriggerStep *sqlite3TriggerUpdateStep(
+  sqlite3 *db,         /* The database connection */
+  Token *pTableName,   /* Name of the table to be updated */
+  ExprList *pEList,    /* The SET clause: list of column and new values */
+  Expr *pWhere,        /* The WHERE clause */
+  int orconf           /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
+){
+  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
+  if( pTriggerStep==0 ){
+     sqlite3ExprListDelete(pEList);
+     sqlite3ExprDelete(pWhere);
+     return 0;
+  }
+
+  pTriggerStep->op = TK_UPDATE;
+  pTriggerStep->target  = *pTableName;
+  pTriggerStep->pExprList = pEList;
+  pTriggerStep->pWhere = pWhere;
+  pTriggerStep->orconf = orconf;
+  sqlitePersistTriggerStep(db, pTriggerStep);
+
+  return pTriggerStep;
+}
+
+/*
+** Construct a trigger step that implements a DELETE statement and return
+** a pointer to that trigger step.  The parser calls this routine when it
+** sees a DELETE statement inside the body of a CREATE TRIGGER.
+*/
+TriggerStep *sqlite3TriggerDeleteStep(
+  sqlite3 *db,            /* Database connection */
+  Token *pTableName,      /* The table from which rows are deleted */
+  Expr *pWhere            /* The WHERE clause */
+){
+  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
+  if( pTriggerStep==0 ){
+    sqlite3ExprDelete(pWhere);
+    return 0;
+  }
+
+  pTriggerStep->op = TK_DELETE;
+  pTriggerStep->target  = *pTableName;
+  pTriggerStep->pWhere = pWhere;
+  pTriggerStep->orconf = OE_Default;
+  sqlitePersistTriggerStep(db, pTriggerStep);
+
+  return pTriggerStep;
+}
+
+/* 
+** Recursively delete a Trigger structure
+*/
+void sqlite3DeleteTrigger(Trigger *pTrigger){
+  if( pTrigger==0 ) return;
+  sqlite3DeleteTriggerStep(pTrigger->step_list);
+  sqlite3_free(pTrigger->name);
+  sqlite3_free(pTrigger->table);
+  sqlite3ExprDelete(pTrigger->pWhen);
+  sqlite3IdListDelete(pTrigger->pColumns);
+  if( pTrigger->nameToken.dyn ) sqlite3_free((char*)pTrigger->nameToken.z);
+  sqlite3_free(pTrigger);
+}
+
+/*
+** This function is called to drop a trigger from the database schema. 
+**
+** This may be called directly from the parser and therefore identifies
+** the trigger by name.  The sqlite3DropTriggerPtr() routine does the
+** same job as this routine except it takes a pointer to the trigger
+** instead of the trigger name.
+**/
+void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
+  Trigger *pTrigger = 0;
+  int i;
+  const char *zDb;
+  const char *zName;
+  int nName;
+  sqlite3 *db = pParse->db;
+
+  if( db->mallocFailed ) goto drop_trigger_cleanup;
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    goto drop_trigger_cleanup;
+  }
+
+  assert( pName->nSrc==1 );
+  zDb = pName->a[0].zDatabase;
+  zName = pName->a[0].zName;
+  nName = strlen(zName);
+  for(i=OMIT_TEMPDB; i<db->nDb; i++){
+    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
+    if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
+    pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
+    if( pTrigger ) break;
+  }
+  if( !pTrigger ){
+    if( !noErr ){
+      sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
+    }
+    goto drop_trigger_cleanup;
+  }
+  sqlite3DropTriggerPtr(pParse, pTrigger);
+
+drop_trigger_cleanup:
+  sqlite3SrcListDelete(pName);
+}
+
+/*
+** Return a pointer to the Table structure for the table that a trigger
+** is set on.
+*/
+static Table *tableOfTrigger(Trigger *pTrigger){
+  int n = strlen(pTrigger->table) + 1;
+  return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table, n);
+}
+
+
+/*
+** Drop a trigger given a pointer to that trigger. 
+*/
+void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
+  Table   *pTable;
+  Vdbe *v;
+  sqlite3 *db = pParse->db;
+  int iDb;
+
+  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
+  assert( iDb>=0 && iDb<db->nDb );
+  pTable = tableOfTrigger(pTrigger);
+  assert( pTable );
+  assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  {
+    int code = SQLITE_DROP_TRIGGER;
+    const char *zDb = db->aDb[iDb].zName;
+    const char *zTab = SCHEMA_TABLE(iDb);
+    if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
+    if( sqlite3AuthCheck(pParse, code, pTrigger->name, pTable->zName, zDb) ||
+      sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
+      return;
+    }
+  }
+#endif
+
+  /* Generate code to destroy the database record of the trigger.
+  */
+  assert( pTable!=0 );
+  if( (v = sqlite3GetVdbe(pParse))!=0 ){
+    int base;
+    static const VdbeOpList dropTrigger[] = {
+      { OP_Rewind,     0, ADDR(9),  0},
+      { OP_String8,    0, 1,        0}, /* 1 */
+      { OP_Column,     0, 1,        2},
+      { OP_Ne,         2, ADDR(8),  1},
+      { OP_String8,    0, 1,        0}, /* 4: "trigger" */
+      { OP_Column,     0, 0,        2},
+      { OP_Ne,         2, ADDR(8),  1},
+      { OP_Delete,     0, 0,        0},
+      { OP_Next,       0, ADDR(1),  0}, /* 8 */
+    };
+
+    sqlite3BeginWriteOperation(pParse, 0, iDb);
+    sqlite3OpenMasterTable(pParse, iDb);
+    base = sqlite3VdbeAddOpList(v,  ArraySize(dropTrigger), dropTrigger);
+    sqlite3VdbeChangeP4(v, base+1, pTrigger->name, 0);
+    sqlite3VdbeChangeP4(v, base+4, "trigger", P4_STATIC);
+    sqlite3ChangeCookie(pParse, iDb);
+    sqlite3VdbeAddOp2(v, OP_Close, 0, 0);
+    sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->name, 0);
+  }
+}
+
+/*
+** Remove a trigger from the hash tables of the sqlite* pointer.
+*/
+void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
+  Trigger *pTrigger;
+  int nName = strlen(zName);
+  pTrigger = sqlite3HashInsert(&(db->aDb[iDb].pSchema->trigHash),
+                               zName, nName, 0);
+  if( pTrigger ){
+    Table *pTable = tableOfTrigger(pTrigger);
+    assert( pTable!=0 );
+    if( pTable->pTrigger == pTrigger ){
+      pTable->pTrigger = pTrigger->pNext;
+    }else{
+      Trigger *cc = pTable->pTrigger;
+      while( cc ){ 
+        if( cc->pNext == pTrigger ){
+          cc->pNext = cc->pNext->pNext;
+          break;
+        }
+        cc = cc->pNext;
+      }
+      assert(cc);
+    }
+    sqlite3DeleteTrigger(pTrigger);
+    db->flags |= SQLITE_InternChanges;
+  }
+}
+
+/*
+** pEList is the SET clause of an UPDATE statement.  Each entry
+** in pEList is of the format <id>=<expr>.  If any of the entries
+** in pEList have an <id> which matches an identifier in pIdList,
+** then return TRUE.  If pIdList==NULL, then it is considered a
+** wildcard that matches anything.  Likewise if pEList==NULL then
+** it matches anything so always return true.  Return false only
+** if there is no match.
+*/
+static int checkColumnOverLap(IdList *pIdList, ExprList *pEList){
+  int e;
+  if( !pIdList || !pEList ) return 1;
+  for(e=0; e<pEList->nExpr; e++){
+    if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
+  }
+  return 0; 
+}
+
+/*
+** Return a bit vector to indicate what kind of triggers exist for operation
+** "op" on table pTab.  If pChanges is not NULL then it is a list of columns
+** that are being updated.  Triggers only match if the ON clause of the
+** trigger definition overlaps the set of columns being updated.
+**
+** The returned bit vector is some combination of TRIGGER_BEFORE and
+** TRIGGER_AFTER.
+*/
+int sqlite3TriggersExist(
+  Parse *pParse,          /* Used to check for recursive triggers */
+  Table *pTab,            /* The table the contains the triggers */
+  int op,                 /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
+  ExprList *pChanges      /* Columns that change in an UPDATE statement */
+){
+  Trigger *pTrigger;
+  int mask = 0;
+
+  pTrigger = IsVirtual(pTab) ? 0 : pTab->pTrigger;
+  while( pTrigger ){
+    if( pTrigger->op==op && checkColumnOverLap(pTrigger->pColumns, pChanges) ){
+      mask |= pTrigger->tr_tm;
+    }
+    pTrigger = pTrigger->pNext;
+  }
+  return mask;
+}
+
+/*
+** Convert the pStep->target token into a SrcList and return a pointer
+** to that SrcList.
+**
+** This routine adds a specific database name, if needed, to the target when
+** forming the SrcList.  This prevents a trigger in one database from
+** referring to a target in another database.  An exception is when the
+** trigger is in TEMP in which case it can refer to any other database it
+** wants.
+*/
+static SrcList *targetSrcList(
+  Parse *pParse,       /* The parsing context */
+  TriggerStep *pStep   /* The trigger containing the target token */
+){
+  Token sDb;           /* Dummy database name token */
+  int iDb;             /* Index of the database to use */
+  SrcList *pSrc;       /* SrcList to be returned */
+
+  iDb = sqlite3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
+  if( iDb==0 || iDb>=2 ){
+    assert( iDb<pParse->db->nDb );
+    sDb.z = (u8*)pParse->db->aDb[iDb].zName;
+    sDb.n = strlen((char*)sDb.z);
+    pSrc = sqlite3SrcListAppend(pParse->db, 0, &sDb, &pStep->target);
+  } else {
+    pSrc = sqlite3SrcListAppend(pParse->db, 0, &pStep->target, 0);
+  }
+  return pSrc;
+}
+
+/*
+** Generate VDBE code for zero or more statements inside the body of a
+** trigger.  
+*/
+static int codeTriggerProgram(
+  Parse *pParse,            /* The parser context */
+  TriggerStep *pStepList,   /* List of statements inside the trigger body */
+  int orconfin              /* Conflict algorithm. (OE_Abort, etc) */  
+){
+  TriggerStep * pTriggerStep = pStepList;
+  int orconf;
+  Vdbe *v = pParse->pVdbe;
+  sqlite3 *db = pParse->db;
+
+  assert( pTriggerStep!=0 );
+  assert( v!=0 );
+  sqlite3VdbeAddOp2(v, OP_ContextPush, 0, 0);
+  VdbeComment((v, "begin trigger %s", pStepList->pTrig->name));
+  while( pTriggerStep ){
+    orconf = (orconfin == OE_Default)?pTriggerStep->orconf:orconfin;
+    pParse->trigStack->orconf = orconf;
+    switch( pTriggerStep->op ){
+      case TK_SELECT: {
+        Select *ss = sqlite3SelectDup(db, pTriggerStep->pSelect);
+        if( ss ){
+          SelectDest dest;
+
+          sqlite3SelectDestInit(&dest, SRT_Discard, 0);
+          sqlite3SelectResolve(pParse, ss, 0);
+          sqlite3Select(pParse, ss, &dest, 0, 0, 0, 0);
+          sqlite3SelectDelete(ss);
+        }
+        break;
+      }
+      case TK_UPDATE: {
+        SrcList *pSrc;
+        pSrc = targetSrcList(pParse, pTriggerStep);
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 0, 0);
+        sqlite3Update(pParse, pSrc,
+                sqlite3ExprListDup(db, pTriggerStep->pExprList), 
+                sqlite3ExprDup(db, pTriggerStep->pWhere), orconf);
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 1, 0);
+        break;
+      }
+      case TK_INSERT: {
+        SrcList *pSrc;
+        pSrc = targetSrcList(pParse, pTriggerStep);
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 0, 0);
+        sqlite3Insert(pParse, pSrc,
+          sqlite3ExprListDup(db, pTriggerStep->pExprList), 
+          sqlite3SelectDup(db, pTriggerStep->pSelect), 
+          sqlite3IdListDup(db, pTriggerStep->pIdList), orconf);
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 1, 0);
+        break;
+      }
+      case TK_DELETE: {
+        SrcList *pSrc;
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 0, 0);
+        pSrc = targetSrcList(pParse, pTriggerStep);
+        sqlite3DeleteFrom(pParse, pSrc, 
+                          sqlite3ExprDup(db, pTriggerStep->pWhere));
+        sqlite3VdbeAddOp2(v, OP_ResetCount, 1, 0);
+        break;
+      }
+      default:
+        assert(0);
+    } 
+    pTriggerStep = pTriggerStep->pNext;
+  }
+  sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0);
+  VdbeComment((v, "end trigger %s", pStepList->pTrig->name));
+
+  return 0;
+}
+
+/*
+** This is called to code FOR EACH ROW triggers.
+**
+** When the code that this function generates is executed, the following 
+** must be true:
+**
+** 1. No cursors may be open in the main database.  (But newIdx and oldIdx
+**    can be indices of cursors in temporary tables.  See below.)
+**
+** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then
+**    a temporary vdbe cursor (index newIdx) must be open and pointing at
+**    a row containing values to be substituted for new.* expressions in the
+**    trigger program(s).
+**
+** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then
+**    a temporary vdbe cursor (index oldIdx) must be open and pointing at
+**    a row containing values to be substituted for old.* expressions in the
+**    trigger program(s).
+**
+** If they are not NULL, the piOldColMask and piNewColMask output variables
+** are set to values that describe the columns used by the trigger program
+** in the OLD.* and NEW.* tables respectively. If column N of the 
+** pseudo-table is read at least once, the corresponding bit of the output
+** mask is set. If a column with an index greater than 32 is read, the
+** output mask is set to the special value 0xffffffff.
+**
+*/
+int sqlite3CodeRowTrigger(
+  Parse *pParse,       /* Parse context */
+  int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
+  ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */
+  int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
+  Table *pTab,         /* The table to code triggers from */
+  int newIdx,          /* The indice of the "new" row to access */
+  int oldIdx,          /* The indice of the "old" row to access */
+  int orconf,          /* ON CONFLICT policy */
+  int ignoreJump,      /* Instruction to jump to for RAISE(IGNORE) */
+  u32 *piOldColMask,   /* OUT: Mask of columns used from the OLD.* table */
+  u32 *piNewColMask    /* OUT: Mask of columns used from the NEW.* table */
+){
+  Trigger *p;
+  sqlite3 *db = pParse->db;
+  TriggerStack trigStackEntry;
+
+  trigStackEntry.oldColMask = 0;
+  trigStackEntry.newColMask = 0;
+
+  assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);
+  assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER );
+
+  assert(newIdx != -1 || oldIdx != -1);
+
+  for(p=pTab->pTrigger; p; p=p->pNext){
+    int fire_this = 0;
+
+    /* Determine whether we should code this trigger */
+    if( 
+      p->op==op && 
+      p->tr_tm==tr_tm && 
+      (p->pSchema==p->pTabSchema || p->pSchema==db->aDb[1].pSchema) &&
+      (op!=TK_UPDATE||!p->pColumns||checkColumnOverLap(p->pColumns,pChanges))
+    ){
+      TriggerStack *pS;      /* Pointer to trigger-stack entry */
+      for(pS=pParse->trigStack; pS && p!=pS->pTrigger; pS=pS->pNext){}
+      if( !pS ){
+        fire_this = 1;
+      }
+#if 0    /* Give no warning for recursive triggers.  Just do not do them */
+      else{
+        sqlite3ErrorMsg(pParse, "recursive triggers not supported (%s)",
+            p->name);
+        return SQLITE_ERROR;
+      }
+#endif
+    }
+ 
+    if( fire_this ){
+      int endTrigger;
+      Expr * whenExpr;
+      AuthContext sContext;
+      NameContext sNC;
+
+#ifndef SQLITE_OMIT_TRACE
+      sqlite3VdbeAddOp4(pParse->pVdbe, OP_Trace, 0, 0, 0,
+                        sqlite3MPrintf(db, "-- TRIGGER %s", p->name),
+                        P4_DYNAMIC);
+#endif
+      memset(&sNC, 0, sizeof(sNC));
+      sNC.pParse = pParse;
+
+      /* Push an entry on to the trigger stack */
+      trigStackEntry.pTrigger = p;
+      trigStackEntry.newIdx = newIdx;
+      trigStackEntry.oldIdx = oldIdx;
+      trigStackEntry.pTab = pTab;
+      trigStackEntry.pNext = pParse->trigStack;
+      trigStackEntry.ignoreJump = ignoreJump;
+      pParse->trigStack = &trigStackEntry;
+      sqlite3AuthContextPush(pParse, &sContext, p->name);
+
+      /* code the WHEN clause */
+      endTrigger = sqlite3VdbeMakeLabel(pParse->pVdbe);
+      whenExpr = sqlite3ExprDup(db, p->pWhen);
+      if( db->mallocFailed || sqlite3ExprResolveNames(&sNC, whenExpr) ){
+        pParse->trigStack = trigStackEntry.pNext;
+        sqlite3ExprDelete(whenExpr);
+        return 1;
+      }
+      sqlite3ExprIfFalse(pParse, whenExpr, endTrigger, SQLITE_JUMPIFNULL);
+      sqlite3ExprDelete(whenExpr);
+
+      codeTriggerProgram(pParse, p->step_list, orconf); 
+
+      /* Pop the entry off the trigger stack */
+      pParse->trigStack = trigStackEntry.pNext;
+      sqlite3AuthContextPop(&sContext);
+
+      sqlite3VdbeResolveLabel(pParse->pVdbe, endTrigger);
+    }
+  }
+  if( piOldColMask ) *piOldColMask |= trigStackEntry.oldColMask;
+  if( piNewColMask ) *piNewColMask |= trigStackEntry.newColMask;
+  return 0;
+}
+#endif /* !defined(SQLITE_OMIT_TRIGGER) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/update.c b/client/src/thirdparty/sqlite-3.4.2/src/update.c
new file mode 100644
index 0000000..fb45563
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/update.c
@@ -0,0 +1,669 @@
+/*
+** 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.
+**
+*************************************************************************
+** This file contains C code routines that are called by the parser
+** to handle UPDATE statements.
+**
+** $Id: update.c,v 1.170 2008/01/19 03:35:59 drh Exp $
+*/
+#include "sqliteInt.h"
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Forward declaration */
+static void updateVirtualTable(
+  Parse *pParse,       /* The parsing context */
+  SrcList *pSrc,       /* The virtual table to be modified */
+  Table *pTab,         /* The virtual table */
+  ExprList *pChanges,  /* The columns to change in the UPDATE statement */
+  Expr *pRowidExpr,    /* Expression used to recompute the rowid */
+  int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */
+  Expr *pWhere         /* WHERE clause of the UPDATE statement */
+);
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+/*
+** The most recently coded instruction was an OP_Column to retrieve the
+** i-th column of table pTab. This routine sets the P4 parameter of the 
+** OP_Column to the default value, if any.
+**
+** The default value of a column is specified by a DEFAULT clause in the 
+** column definition. This was either supplied by the user when the table
+** was created, or added later to the table definition by an ALTER TABLE
+** command. If the latter, then the row-records in the table btree on disk
+** may not contain a value for the column and the default value, taken
+** from the P4 parameter of the OP_Column instruction, is returned instead.
+** If the former, then all row-records are guaranteed to include a value
+** for the column and the P4 value is not required.
+**
+** Column definitions created by an ALTER TABLE command may only have 
+** literal default values specified: a number, null or a string. (If a more
+** complicated default expression value was provided, it is evaluated 
+** when the ALTER TABLE is executed and one of the literal values written
+** into the sqlite_master table.)
+**
+** Therefore, the P4 parameter is only required if the default value for
+** the column is a literal number, string or null. The sqlite3ValueFromExpr()
+** function is capable of transforming these types of expressions into
+** sqlite3_value objects.
+*/
+void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){
+  if( pTab && !pTab->pSelect ){
+    sqlite3_value *pValue;
+    u8 enc = ENC(sqlite3VdbeDb(v));
+    Column *pCol = &pTab->aCol[i];
+    VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
+    assert( i<pTab->nCol );
+    sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, 
+                         pCol->affinity, &pValue);
+    if( pValue ){
+      sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
+    }
+  }
+}
+
+/*
+** Process an UPDATE statement.
+**
+**   UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
+**          \_______/ \________/     \______/       \________________/
+*            onError   pTabList      pChanges             pWhere
+*/
+void sqlite3Update(
+  Parse *pParse,         /* The parser context */
+  SrcList *pTabList,     /* The table in which we should change things */
+  ExprList *pChanges,    /* Things to be changed */
+  Expr *pWhere,          /* The WHERE clause.  May be null */
+  int onError            /* How to handle constraint errors */
+){
+  int i, j;              /* Loop counters */
+  Table *pTab;           /* The table to be updated */
+  int addr = 0;          /* VDBE instruction address of the start of the loop */
+  WhereInfo *pWInfo;     /* Information about the WHERE clause */
+  Vdbe *v;               /* The virtual database engine */
+  Index *pIdx;           /* For looping over indices */
+  int nIdx;              /* Number of indices that need updating */
+  int iCur;              /* VDBE Cursor number of pTab */
+  sqlite3 *db;           /* The database structure */
+  int *aRegIdx = 0;      /* One register assigned to each index to be updated */
+  int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
+                         ** an expression for the i-th column of the table.
+                         ** aXRef[i]==-1 if the i-th column is not changed. */
+  int chngRowid;         /* True if the record number is being changed */
+  Expr *pRowidExpr = 0;  /* Expression defining the new record number */
+  int openAll = 0;       /* True if all indices need to be opened */
+  AuthContext sContext;  /* The authorization context */
+  NameContext sNC;       /* The name-context to resolve expressions in */
+  int iDb;               /* Database containing the table being updated */
+  int j1;                /* Addresses of jump instructions */
+
+#ifndef SQLITE_OMIT_TRIGGER
+  int isView;                  /* Trying to update a view */
+  int triggers_exist = 0;      /* True if any row triggers exist */
+#endif
+  int iBeginAfterTrigger;      /* Address of after trigger program */
+  int iEndAfterTrigger;        /* Exit of after trigger program */
+  int iBeginBeforeTrigger;     /* Address of before trigger program */
+  int iEndBeforeTrigger;       /* Exit of before trigger program */
+  u32 old_col_mask = 0;        /* Mask of OLD.* columns in use */
+  u32 new_col_mask = 0;        /* Mask of NEW.* columns in use */
+
+  int newIdx      = -1;  /* index of trigger "new" temp table       */
+  int oldIdx      = -1;  /* index of trigger "old" temp table       */
+
+  /* Register Allocations */
+  int regRowCount = 0;   /* A count of rows changed */
+  int regOldRowid;       /* The old rowid */
+  int regNewRowid;       /* The new rowid */
+  int regData;           /* New data for the row */
+
+  sContext.pParse = 0;
+  db = pParse->db;
+  if( pParse->nErr || db->mallocFailed ){
+    goto update_cleanup;
+  }
+  assert( pTabList->nSrc==1 );
+
+  /* Locate the table which we want to update. 
+  */
+  pTab = sqlite3SrcListLookup(pParse, pTabList);
+  if( pTab==0 ) goto update_cleanup;
+  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+
+  /* Figure out if we have any triggers and if the table being
+  ** updated is a view
+  */
+#ifndef SQLITE_OMIT_TRIGGER
+  triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges);
+  isView = pTab->pSelect!=0;
+#else
+# define triggers_exist 0
+# define isView 0
+#endif
+#ifdef SQLITE_OMIT_VIEW
+# undef isView
+# define isView 0
+#endif
+
+  if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){
+    goto update_cleanup;
+  }
+  if( sqlite3ViewGetColumnNames(pParse, pTab) ){
+    goto update_cleanup;
+  }
+  aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
+  if( aXRef==0 ) goto update_cleanup;
+  for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
+
+  /* If there are FOR EACH ROW triggers, allocate cursors for the
+  ** special OLD and NEW tables
+  */
+  if( triggers_exist ){
+    newIdx = pParse->nTab++;
+    oldIdx = pParse->nTab++;
+  }
+
+  /* Allocate a cursors for the main database table and for all indices.
+  ** The index cursors might not be used, but if they are used they
+  ** need to occur right after the database cursor.  So go ahead and
+  ** allocate enough space, just in case.
+  */
+  pTabList->a[0].iCursor = iCur = pParse->nTab++;
+  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+    pParse->nTab++;
+  }
+
+  /* Initialize the name-context */
+  memset(&sNC, 0, sizeof(sNC));
+  sNC.pParse = pParse;
+  sNC.pSrcList = pTabList;
+
+  /* Resolve the column names in all the expressions of the
+  ** of the UPDATE statement.  Also find the column index
+  ** for each column to be updated in the pChanges array.  For each
+  ** column to be updated, make sure we have authorization to change
+  ** that column.
+  */
+  chngRowid = 0;
+  for(i=0; i<pChanges->nExpr; i++){
+    if( sqlite3ExprResolveNames(&sNC, pChanges->a[i].pExpr) ){
+      goto update_cleanup;
+    }
+    for(j=0; j<pTab->nCol; j++){
+      if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
+        if( j==pTab->iPKey ){
+          chngRowid = 1;
+          pRowidExpr = pChanges->a[i].pExpr;
+        }
+        aXRef[j] = i;
+        break;
+      }
+    }
+    if( j>=pTab->nCol ){
+      if( sqlite3IsRowid(pChanges->a[i].zName) ){
+        chngRowid = 1;
+        pRowidExpr = pChanges->a[i].pExpr;
+      }else{
+        sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
+        goto update_cleanup;
+      }
+    }
+#ifndef SQLITE_OMIT_AUTHORIZATION
+    {
+      int rc;
+      rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
+                           pTab->aCol[j].zName, db->aDb[iDb].zName);
+      if( rc==SQLITE_DENY ){
+        goto update_cleanup;
+      }else if( rc==SQLITE_IGNORE ){
+        aXRef[j] = -1;
+      }
+    }
+#endif
+  }
+
+  /* Allocate memory for the array aRegIdx[].  There is one entry in the
+  ** array for each index associated with table being updated.  Fill in
+  ** the value with a register number for indices that are to be used
+  ** and with zero for unused indices.
+  */
+  for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
+  if( nIdx>0 ){
+    aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
+    if( aRegIdx==0 ) goto update_cleanup;
+  }
+  for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
+    int reg;
+    if( chngRowid ){
+      reg = ++pParse->nMem;
+    }else{
+      reg = 0;
+      for(i=0; i<pIdx->nColumn; i++){
+        if( aXRef[pIdx->aiColumn[i]]>=0 ){
+          reg = ++pParse->nMem;
+          break;
+        }
+      }
+    }
+    aRegIdx[j] = reg;
+  }
+
+  /* Allocate a block of register used to store the change record
+  ** sent to sqlite3GenerateConstraintChecks().  There are either
+  ** one or two registers for holding the rowid.  One rowid register
+  ** is used if chngRowid is false and two are used if chngRowid is
+  ** true.  Following these are pTab->nCol register holding column
+  ** data.
+  */
+  regOldRowid = regNewRowid = pParse->nMem + 1;
+  pParse->nMem += pTab->nCol + 1;
+  if( chngRowid ){
+    regNewRowid++;
+    pParse->nMem++;
+  }
+  regData = regNewRowid+1;
+ 
+
+  /* Begin generating code.
+  */
+  v = sqlite3GetVdbe(pParse);
+  if( v==0 ) goto update_cleanup;
+  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
+  sqlite3BeginWriteOperation(pParse, 1, iDb);
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  /* Virtual tables must be handled separately */
+  if( IsVirtual(pTab) ){
+    updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
+                       pWhere);
+    pWhere = 0;
+    pTabList = 0;
+    goto update_cleanup;
+  }
+#endif
+
+  /* Resolve the column names in all the expressions in the
+  ** WHERE clause.
+  */
+  if( sqlite3ExprResolveNames(&sNC, pWhere) ){
+    goto update_cleanup;
+  }
+
+  /* Start the view context
+  */
+  if( isView ){
+    sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
+  }
+
+  /* Generate the code for triggers.
+  */
+  if( triggers_exist ){
+    int iGoto;
+
+    /* Create pseudo-tables for NEW and OLD
+    */
+    sqlite3VdbeAddOp2(v, OP_OpenPseudo, oldIdx, 0);
+    sqlite3VdbeAddOp2(v, OP_SetNumColumns, oldIdx, pTab->nCol);
+    sqlite3VdbeAddOp2(v, OP_OpenPseudo, newIdx, 0);
+    sqlite3VdbeAddOp2(v, OP_SetNumColumns, newIdx, pTab->nCol);
+
+    iGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
+    addr = sqlite3VdbeMakeLabel(v);
+    iBeginBeforeTrigger = sqlite3VdbeCurrentAddr(v);
+    if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab,
+          newIdx, oldIdx, onError, addr, &old_col_mask, &new_col_mask) ){
+      goto update_cleanup;
+    }
+    iEndBeforeTrigger = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
+    iBeginAfterTrigger = sqlite3VdbeCurrentAddr(v);
+    if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_AFTER, pTab, 
+          newIdx, oldIdx, onError, addr, &old_col_mask, &new_col_mask) ){
+      goto update_cleanup;
+    }
+    iEndAfterTrigger = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
+    sqlite3VdbeJumpHere(v, iGoto);
+  }
+
+  /* If we are trying to update a view, realize that view into
+  ** a ephemeral table.
+  */
+  if( isView ){
+    Select *pView;
+    SelectDest dest;
+
+    pView = sqlite3SelectDup(db, pTab->pSelect);
+    sqlite3SelectMask(pParse, pView, old_col_mask|new_col_mask);
+    sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
+    sqlite3Select(pParse, pView, &dest, 0, 0, 0, 0);
+    sqlite3SelectDelete(pView);
+  }
+
+  /* Begin the database scan
+  */
+  pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0);
+  if( pWInfo==0 ) goto update_cleanup;
+
+  /* Remember the rowid of every item to be updated.
+  */
+  sqlite3VdbeAddOp2(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid,iCur,regOldRowid);
+  sqlite3VdbeAddOp2(v, OP_FifoWrite, regOldRowid, 0);
+
+  /* End the database scan loop.
+  */
+  sqlite3WhereEnd(pWInfo);
+
+  /* Initialize the count of updated rows
+  */
+  if( db->flags & SQLITE_CountRows && !pParse->trigStack ){
+    regRowCount = ++pParse->nMem;
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
+  }
+
+  if( !isView && !IsVirtual(pTab) ){
+    /* 
+    ** Open every index that needs updating.  Note that if any
+    ** index could potentially invoke a REPLACE conflict resolution 
+    ** action, then we need to open all indices because we might need
+    ** to be deleting some records.
+    */
+    sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); 
+    if( onError==OE_Replace ){
+      openAll = 1;
+    }else{
+      openAll = 0;
+      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+        if( pIdx->onError==OE_Replace ){
+          openAll = 1;
+          break;
+        }
+      }
+    }
+    for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
+      if( openAll || aRegIdx[i]>0 ){
+        KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
+        sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
+                       (char*)pKey, P4_KEYINFO_HANDOFF);
+        assert( pParse->nTab>iCur+i+1 );
+      }
+    }
+  }
+  
+  /* Jump back to this point if a trigger encounters an IGNORE constraint. */
+  if( triggers_exist ){
+    sqlite3VdbeResolveLabel(v, addr);
+  }
+
+  /* Top of the update loop */
+  addr = sqlite3VdbeAddOp2(v, OP_FifoRead, regOldRowid, 0);
+
+  if( triggers_exist ){
+    int regRowid;
+    int regRow;
+    int regCols;
+
+    /* Make cursor iCur point to the record that is being updated.
+    */
+    sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
+
+    /* Generate the OLD table
+    */
+    regRowid = sqlite3GetTempReg(pParse);
+    regRow = sqlite3GetTempReg(pParse);
+    sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regRowid);
+    if( !old_col_mask ){
+      sqlite3VdbeAddOp2(v, OP_Null, 0, regRow);
+    }else{
+      sqlite3VdbeAddOp2(v, OP_RowData, iCur, regRow);
+    }
+    sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, regRow, regRowid);
+
+    /* Generate the NEW table
+    */
+    if( chngRowid ){
+      sqlite3ExprCodeAndCache(pParse, pRowidExpr, regRowid);
+    }else{
+      sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regRowid);
+    }
+    regCols = sqlite3GetTempRange(pParse, pTab->nCol);
+    for(i=0; i<pTab->nCol; i++){
+      if( i==pTab->iPKey ){
+        sqlite3VdbeAddOp2(v, OP_Null, 0, regCols+i);
+        continue;
+      }
+      j = aXRef[i];
+      if( new_col_mask&((u32)1<<i) || new_col_mask==0xffffffff ){
+        if( j<0 ){
+          sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regCols+i);
+          sqlite3ColumnDefault(v, pTab, i);
+        }else{
+          sqlite3ExprCodeAndCache(pParse, pChanges->a[j].pExpr, regCols+i);
+        }
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Null, 0, regCols+i);
+      }
+    }
+    sqlite3VdbeAddOp3(v, OP_MakeRecord, regCols, pTab->nCol, regRow);
+    if( !isView ){
+      sqlite3TableAffinityStr(v, pTab);
+    }
+    sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol);
+    if( pParse->nErr ) goto update_cleanup;
+    sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRow, regRowid);
+    sqlite3ReleaseTempReg(pParse, regRowid);
+    sqlite3ReleaseTempReg(pParse, regRow);
+
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginBeforeTrigger);
+    sqlite3VdbeJumpHere(v, iEndBeforeTrigger);
+  }
+
+  if( !isView && !IsVirtual(pTab) ){
+    /* Loop over every record that needs updating.  We have to load
+    ** the old data for each record to be updated because some columns
+    ** might not change and we will need to copy the old value.
+    ** Also, the old data is needed to delete the old index entries.
+    ** So make the cursor point at the old record.
+    */
+    sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
+
+    /* If the record number will change, push the record number as it
+    ** will be after the update. (The old record number is currently
+    ** on top of the stack.)
+    */
+    if( chngRowid ){
+      sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
+      sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
+    }
+
+    /* Compute new data for this record.  
+    */
+    for(i=0; i<pTab->nCol; i++){
+      if( i==pTab->iPKey ){
+        sqlite3VdbeAddOp2(v, OP_Null, 0, regData+i);
+        continue;
+      }
+      j = aXRef[i];
+      if( j<0 ){
+        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regData+i);
+        sqlite3ColumnDefault(v, pTab, i);
+      }else{
+        sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regData+i);
+      }
+    }
+
+    /* Do constraint checks
+    */
+    sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
+                                    aRegIdx, chngRowid, 1,
+                                    onError, addr);
+
+    /* Delete the old indices for the current record.
+    */
+    j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
+    sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
+
+    /* If changing the record number, delete the old record.
+    */
+    if( chngRowid ){
+      sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
+    }
+    sqlite3VdbeJumpHere(v, j1);
+
+    /* Create the new index entries and the new record.
+    */
+    sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, 
+                             aRegIdx, chngRowid, 1, -1, 0);
+  }
+
+  /* Increment the row counter 
+  */
+  if( db->flags & SQLITE_CountRows && !pParse->trigStack){
+    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
+  }
+
+  /* If there are triggers, close all the cursors after each iteration
+  ** through the loop.  The fire the after triggers.
+  */
+  if( triggers_exist ){
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger);
+    sqlite3VdbeJumpHere(v, iEndAfterTrigger);
+  }
+
+  /* Repeat the above with the next record to be updated, until
+  ** all record selected by the WHERE clause have been updated.
+  */
+  sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
+  sqlite3VdbeJumpHere(v, addr);
+
+  /* Close all tables */
+  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
+    if( openAll || aRegIdx[i]>0 ){
+      sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
+    }
+  }
+  sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
+  if( triggers_exist ){
+    sqlite3VdbeAddOp2(v, OP_Close, newIdx, 0);
+    sqlite3VdbeAddOp2(v, OP_Close, oldIdx, 0);
+  }
+
+  /*
+  ** Return the number of rows that were changed. If this routine is 
+  ** generating code because of a call to sqlite3NestedParse(), do not
+  ** invoke the callback function.
+  */
+  if( db->flags & SQLITE_CountRows && !pParse->trigStack && pParse->nested==0 ){
+    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
+    sqlite3VdbeSetNumCols(v, 1);
+    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", P4_STATIC);
+  }
+
+update_cleanup:
+  sqlite3AuthContextPop(&sContext);
+  sqlite3_free(aRegIdx);
+  sqlite3_free(aXRef);
+  sqlite3SrcListDelete(pTabList);
+  sqlite3ExprListDelete(pChanges);
+  sqlite3ExprDelete(pWhere);
+  return;
+}
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** Generate code for an UPDATE of a virtual table.
+**
+** The strategy is that we create an ephemerial table that contains
+** for each row to be changed:
+**
+**   (A)  The original rowid of that row.
+**   (B)  The revised rowid for the row. (note1)
+**   (C)  The content of every column in the row.
+**
+** Then we loop over this ephemeral table and for each row in
+** the ephermeral table call VUpdate.
+**
+** When finished, drop the ephemeral table.
+**
+** (note1) Actually, if we know in advance that (A) is always the same
+** as (B) we only store (A), then duplicate (A) when pulling
+** it out of the ephemeral table before calling VUpdate.
+*/
+static void updateVirtualTable(
+  Parse *pParse,       /* The parsing context */
+  SrcList *pSrc,       /* The virtual table to be modified */
+  Table *pTab,         /* The virtual table */
+  ExprList *pChanges,  /* The columns to change in the UPDATE statement */
+  Expr *pRowid,        /* Expression used to recompute the rowid */
+  int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */
+  Expr *pWhere         /* WHERE clause of the UPDATE statement */
+){
+  Vdbe *v = pParse->pVdbe;  /* Virtual machine under construction */
+  ExprList *pEList = 0;     /* The result set of the SELECT statement */
+  Select *pSelect = 0;      /* The SELECT statement */
+  Expr *pExpr;              /* Temporary expression */
+  int ephemTab;             /* Table holding the result of the SELECT */
+  int i;                    /* Loop counter */
+  int addr;                 /* Address of top of loop */
+  int iReg;                 /* First register in set passed to OP_VUpdate */
+  sqlite3 *db = pParse->db; /* Database connection */
+  const char *pVtab = (const char*)pTab->pVtab;
+  SelectDest dest;
+
+  /* Construct the SELECT statement that will find the new values for
+  ** all updated rows. 
+  */
+  pEList = sqlite3ExprListAppend(pParse, 0, 
+                                 sqlite3CreateIdExpr(pParse, "_rowid_"), 0);
+  if( pRowid ){
+    pEList = sqlite3ExprListAppend(pParse, pEList,
+                                   sqlite3ExprDup(db, pRowid), 0);
+  }
+  assert( pTab->iPKey<0 );
+  for(i=0; i<pTab->nCol; i++){
+    if( aXRef[i]>=0 ){
+      pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr);
+    }else{
+      pExpr = sqlite3CreateIdExpr(pParse, pTab->aCol[i].zName);
+    }
+    pEList = sqlite3ExprListAppend(pParse, pEList, pExpr, 0);
+  }
+  pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
+  
+  /* Create the ephemeral table into which the update results will
+  ** be stored.
+  */
+  assert( v );
+  ephemTab = pParse->nTab++;
+  sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
+
+  /* fill the ephemeral table 
+  */
+  sqlite3SelectDestInit(&dest, SRT_Table, ephemTab);
+  sqlite3Select(pParse, pSelect, &dest, 0, 0, 0, 0);
+
+  /* Generate code to scan the ephemeral table and call VUpdate. */
+  iReg = ++pParse->nMem;
+  pParse->nMem += pTab->nCol+1;
+  sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
+  addr = sqlite3VdbeCurrentAddr(v);
+  sqlite3VdbeAddOp3(v, OP_Column,  ephemTab, 0, iReg);
+  sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
+  for(i=0; i<pTab->nCol; i++){
+    sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i);
+  }
+  pParse->pVirtualLock = pTab;
+  sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVtab, P4_VTAB);
+  sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr);
+  sqlite3VdbeJumpHere(v, addr-1);
+  sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
+
+  /* Cleanup */
+  sqlite3SelectDelete(pSelect);  
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/utf.c b/client/src/thirdparty/sqlite-3.4.2/src/utf.c
new file mode 100644
index 0000000..b6b3133
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/utf.c
@@ -0,0 +1,545 @@
+/*
+** 2004 April 13
+**
+** 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 routines used to translate between UTF-8, 
+** UTF-16, UTF-16BE, and UTF-16LE.
+**
+** $Id: utf.c,v 1.59 2007/10/03 08:46:45 danielk1977 Exp $
+**
+** Notes on UTF-8:
+**
+**   Byte-0    Byte-1    Byte-2    Byte-3    Value
+**  0xxxxxxx                                 00000000 00000000 0xxxxxxx
+**  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
+**  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx
+**  11110uuu  10uuzzzz  10yyyyyy  10xxxxxx   000uuuuu zzzzyyyy yyxxxxxx
+**
+**
+** Notes on UTF-16:  (with wwww+1==uuuuu)
+**
+**      Word-0               Word-1          Value
+**  110110ww wwzzzzyy   110111yy yyxxxxxx    000uuuuu zzzzyyyy yyxxxxxx
+**  zzzzyyyy yyxxxxxx                        00000000 zzzzyyyy yyxxxxxx
+**
+**
+** BOM or Byte Order Mark:
+**     0xff 0xfe   little-endian utf-16 follows
+**     0xfe 0xff   big-endian utf-16 follows
+**
+*/
+#include "sqliteInt.h"
+#include <assert.h>
+#include "vdbeInt.h"
+
+/*
+** The following constant value is used by the SQLITE_BIGENDIAN and
+** SQLITE_LITTLEENDIAN macros.
+*/
+const int sqlite3one = 1;
+
+/*
+** This lookup table is used to help decode the first byte of
+** a multi-byte UTF8 character.
+*/
+static const unsigned char sqlite3UtfTrans1[] = {
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
+};
+
+
+#define WRITE_UTF8(zOut, c) {                          \
+  if( c<0x00080 ){                                     \
+    *zOut++ = (c&0xFF);                                \
+  }                                                    \
+  else if( c<0x00800 ){                                \
+    *zOut++ = 0xC0 + ((c>>6)&0x1F);                    \
+    *zOut++ = 0x80 + (c & 0x3F);                       \
+  }                                                    \
+  else if( c<0x10000 ){                                \
+    *zOut++ = 0xE0 + ((c>>12)&0x0F);                   \
+    *zOut++ = 0x80 + ((c>>6) & 0x3F);                  \
+    *zOut++ = 0x80 + (c & 0x3F);                       \
+  }else{                                               \
+    *zOut++ = 0xF0 + ((c>>18) & 0x07);                 \
+    *zOut++ = 0x80 + ((c>>12) & 0x3F);                 \
+    *zOut++ = 0x80 + ((c>>6) & 0x3F);                  \
+    *zOut++ = 0x80 + (c & 0x3F);                       \
+  }                                                    \
+}
+
+#define WRITE_UTF16LE(zOut, c) {                                \
+  if( c<=0xFFFF ){                                              \
+    *zOut++ = (c&0x00FF);                                       \
+    *zOut++ = ((c>>8)&0x00FF);                                  \
+  }else{                                                        \
+    *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
+    *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              \
+    *zOut++ = (c&0x00FF);                                       \
+    *zOut++ = (0x00DC + ((c>>8)&0x03));                         \
+  }                                                             \
+}
+
+#define WRITE_UTF16BE(zOut, c) {                                \
+  if( c<=0xFFFF ){                                              \
+    *zOut++ = ((c>>8)&0x00FF);                                  \
+    *zOut++ = (c&0x00FF);                                       \
+  }else{                                                        \
+    *zOut++ = (0x00D8 + (((c-0x10000)>>18)&0x03));              \
+    *zOut++ = (((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
+    *zOut++ = (0x00DC + ((c>>8)&0x03));                         \
+    *zOut++ = (c&0x00FF);                                       \
+  }                                                             \
+}
+
+#define READ_UTF16LE(zIn, c){                                         \
+  c = (*zIn++);                                                       \
+  c += ((*zIn++)<<8);                                                 \
+  if( c>=0xD800 && c<0xE000 ){                                       \
+    int c2 = (*zIn++);                                                \
+    c2 += ((*zIn++)<<8);                                              \
+    c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
+    if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             \
+  }                                                                   \
+}
+
+#define READ_UTF16BE(zIn, c){                                         \
+  c = ((*zIn++)<<8);                                                  \
+  c += (*zIn++);                                                      \
+  if( c>=0xD800 && c<0xE000 ){                                       \
+    int c2 = ((*zIn++)<<8);                                           \
+    c2 += (*zIn++);                                                   \
+    c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
+    if( (c & 0xFFFF0000)==0 ) c = 0xFFFD;                             \
+  }                                                                   \
+}
+
+/*
+** Translate a single UTF-8 character.  Return the unicode value.
+**
+** During translation, assume that the byte that zTerm points
+** is a 0x00.
+**
+** Write a pointer to the next unread byte back into *pzNext.
+**
+** Notes On Invalid UTF-8:
+**
+**  *  This routine never allows a 7-bit character (0x00 through 0x7f) to
+**     be encoded as a multi-byte character.  Any multi-byte character that
+**     attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
+**
+**  *  This routine never allows a UTF16 surrogate value to be encoded.
+**     If a multi-byte character attempts to encode a value between
+**     0xd800 and 0xe000 then it is rendered as 0xfffd.
+**
+**  *  Bytes in the range of 0x80 through 0xbf which occur as the first
+**     byte of a character are interpreted as single-byte characters
+**     and rendered as themselves even though they are technically
+**     invalid characters.
+**
+**  *  This routine accepts an infinite number of different UTF8 encodings
+**     for unicode values 0x80 and greater.  It do not change over-length
+**     encodings to 0xfffd as some systems recommend.
+*/
+int sqlite3Utf8Read(
+  const unsigned char *z,         /* First byte of UTF-8 character */
+  const unsigned char *zTerm,     /* Pretend this byte is 0x00 */
+  const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
+){
+  int c = *(z++);
+  if( c>=0xc0 ){
+    c = sqlite3UtfTrans1[c-0xc0];
+    while( z!=zTerm && (*z & 0xc0)==0x80 ){
+      c = (c<<6) + (0x3f & *(z++));
+    }
+    if( c<0x80
+        || (c&0xFFFFF800)==0xD800
+        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }
+  }
+  *pzNext = z;
+  return c;
+}
+
+
+
+/*
+** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
+** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
+*/ 
+/* #define TRANSLATE_TRACE 1 */
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** This routine transforms the internal text encoding used by pMem to
+** desiredEnc. It is an error if the string is already of the desired
+** encoding, or if *pMem does not contain a string value.
+*/
+int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
+  unsigned char zShort[NBFS]; /* Temporary short output buffer */
+  int len;                    /* Maximum length of output string in bytes */
+  unsigned char *zOut;                  /* Output buffer */
+  unsigned char *zIn;                   /* Input iterator */
+  unsigned char *zTerm;                 /* End of input */
+  unsigned char *z;                     /* Output iterator */
+  unsigned int c;
+
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  assert( pMem->flags&MEM_Str );
+  assert( pMem->enc!=desiredEnc );
+  assert( pMem->enc!=0 );
+  assert( pMem->n>=0 );
+
+#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
+  {
+    char zBuf[100];
+    sqlite3VdbeMemPrettyPrint(pMem, zBuf);
+    fprintf(stderr, "INPUT:  %s\n", zBuf);
+  }
+#endif
+
+  /* If the translation is between UTF-16 little and big endian, then 
+  ** all that is required is to swap the byte order. This case is handled
+  ** differently from the others.
+  */
+  if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
+    u8 temp;
+    int rc;
+    rc = sqlite3VdbeMemMakeWriteable(pMem);
+    if( rc!=SQLITE_OK ){
+      assert( rc==SQLITE_NOMEM );
+      return SQLITE_NOMEM;
+    }
+    zIn = (u8*)pMem->z;
+    zTerm = &zIn[pMem->n];
+    while( zIn<zTerm ){
+      temp = *zIn;
+      *zIn = *(zIn+1);
+      zIn++;
+      *zIn++ = temp;
+    }
+    pMem->enc = desiredEnc;
+    goto translate_out;
+  }
+
+  /* Set len to the maximum number of bytes required in the output buffer. */
+  if( desiredEnc==SQLITE_UTF8 ){
+    /* When converting from UTF-16, the maximum growth results from
+    ** translating a 2-byte character to a 4-byte UTF-8 character.
+    ** A single byte is required for the output string
+    ** nul-terminator.
+    */
+    len = pMem->n * 2 + 1;
+  }else{
+    /* When converting from UTF-8 to UTF-16 the maximum growth is caused
+    ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
+    ** character. Two bytes are required in the output buffer for the
+    ** nul-terminator.
+    */
+    len = pMem->n * 2 + 2;
+  }
+
+  /* Set zIn to point at the start of the input buffer and zTerm to point 1
+  ** byte past the end.
+  **
+  ** Variable zOut is set to point at the output buffer. This may be space
+  ** obtained from sqlite3_malloc(), or Mem.zShort, if it large enough and
+  ** not in use, or the zShort array on the stack (see above).
+  */
+  zIn = (u8*)pMem->z;
+  zTerm = &zIn[pMem->n];
+  if( len>NBFS ){
+    zOut = sqlite3DbMallocRaw(pMem->db, len);
+    if( !zOut ){
+      return SQLITE_NOMEM;
+    }
+  }else{
+    zOut = zShort;
+  }
+  z = zOut;
+
+  if( pMem->enc==SQLITE_UTF8 ){
+    if( desiredEnc==SQLITE_UTF16LE ){
+      /* UTF-8 -> UTF-16 Little-endian */
+      while( zIn<zTerm ){
+        c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
+        WRITE_UTF16LE(z, c);
+      }
+    }else{
+      assert( desiredEnc==SQLITE_UTF16BE );
+      /* UTF-8 -> UTF-16 Big-endian */
+      while( zIn<zTerm ){
+        c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
+        WRITE_UTF16BE(z, c);
+      }
+    }
+    pMem->n = z - zOut;
+    *z++ = 0;
+  }else{
+    assert( desiredEnc==SQLITE_UTF8 );
+    if( pMem->enc==SQLITE_UTF16LE ){
+      /* UTF-16 Little-endian -> UTF-8 */
+      while( zIn<zTerm ){
+        READ_UTF16LE(zIn, c); 
+        WRITE_UTF8(z, c);
+      }
+    }else{
+      /* UTF-16 Little-endian -> UTF-8 */
+      while( zIn<zTerm ){
+        READ_UTF16BE(zIn, c); 
+        WRITE_UTF8(z, c);
+      }
+    }
+    pMem->n = z - zOut;
+  }
+  *z = 0;
+  assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
+
+  sqlite3VdbeMemRelease(pMem);
+  pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
+  pMem->enc = desiredEnc;
+  if( zOut==zShort ){
+    memcpy(pMem->zShort, zOut, len);
+    zOut = (u8*)pMem->zShort;
+    pMem->flags |= (MEM_Term|MEM_Short);
+  }else{
+    pMem->flags |= (MEM_Term|MEM_Dyn);
+  }
+  pMem->z = (char*)zOut;
+
+translate_out:
+#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
+  {
+    char zBuf[100];
+    sqlite3VdbeMemPrettyPrint(pMem, zBuf);
+    fprintf(stderr, "OUTPUT: %s\n", zBuf);
+  }
+#endif
+  return SQLITE_OK;
+}
+
+/*
+** This routine checks for a byte-order mark at the beginning of the 
+** UTF-16 string stored in *pMem. If one is present, it is removed and
+** the encoding of the Mem adjusted. This routine does not do any
+** byte-swapping, it just sets Mem.enc appropriately.
+**
+** The allocation (static, dynamic etc.) and encoding of the Mem may be
+** changed by this function.
+*/
+int sqlite3VdbeMemHandleBom(Mem *pMem){
+  int rc = SQLITE_OK;
+  u8 bom = 0;
+
+  if( pMem->n<0 || pMem->n>1 ){
+    u8 b1 = *(u8 *)pMem->z;
+    u8 b2 = *(((u8 *)pMem->z) + 1);
+    if( b1==0xFE && b2==0xFF ){
+      bom = SQLITE_UTF16BE;
+    }
+    if( b1==0xFF && b2==0xFE ){
+      bom = SQLITE_UTF16LE;
+    }
+  }
+  
+  if( bom ){
+    /* This function is called as soon as a string is stored in a Mem*,
+    ** from within sqlite3VdbeMemSetStr(). At that point it is not possible
+    ** for the string to be stored in Mem.zShort, or for it to be stored
+    ** in dynamic memory with no destructor.
+    */
+    assert( !(pMem->flags&MEM_Short) );
+    assert( !(pMem->flags&MEM_Dyn) || pMem->xDel );
+    if( pMem->flags & MEM_Dyn ){
+      void (*xDel)(void*) = pMem->xDel;
+      char *z = pMem->z;
+      pMem->z = 0;
+      pMem->xDel = 0;
+      rc = sqlite3VdbeMemSetStr(pMem, &z[2], pMem->n-2, bom, 
+          SQLITE_TRANSIENT);
+      xDel(z);
+    }else{
+      rc = sqlite3VdbeMemSetStr(pMem, &pMem->z[2], pMem->n-2, bom, 
+          SQLITE_TRANSIENT);
+    }
+  }
+  return rc;
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
+** return the number of unicode characters in pZ up to (but not including)
+** the first 0x00 byte. If nByte is not less than zero, return the
+** number of unicode characters in the first nByte of pZ (or up to 
+** the first 0x00, whichever comes first).
+*/
+int sqlite3Utf8CharLen(const char *zIn, int nByte){
+  int r = 0;
+  const u8 *z = (const u8*)zIn;
+  const u8 *zTerm;
+  if( nByte>=0 ){
+    zTerm = &z[nByte];
+  }else{
+    zTerm = (const u8*)(-1);
+  }
+  assert( z<=zTerm );
+  while( *z!=0 && z<zTerm ){
+    SQLITE_SKIP_UTF8(z);
+    r++;
+  }
+  return r;
+}
+
+/* This test function is not currently used by the automated test-suite. 
+** Hence it is only available in debug builds.
+*/
+#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
+/*
+** Translate UTF-8 to UTF-8.
+**
+** This has the effect of making sure that the string is well-formed
+** UTF-8.  Miscoded characters are removed.
+**
+** The translation is done in-place (since it is impossible for the
+** correct UTF-8 encoding to be longer than a malformed encoding).
+*/
+int sqlite3Utf8To8(unsigned char *zIn){
+  unsigned char *zOut = zIn;
+  unsigned char *zStart = zIn;
+  unsigned char *zTerm;
+  u32 c;
+
+  while( zIn[0] ){
+    c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
+    if( c!=0xfffd ){
+      WRITE_UTF8(zOut, c);
+    }
+  }
+  *zOut = 0;
+  return zOut - zStart;
+}
+#endif
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** Convert a UTF-16 string in the native encoding into a UTF-8 string.
+** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
+** be freed by the calling function.
+**
+** NULL is returned if there is an allocation error.
+*/
+char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){
+  Mem m;
+  memset(&m, 0, sizeof(m));
+  m.db = db;
+  sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);
+  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
+  if( db->mallocFailed ){
+    sqlite3VdbeMemRelease(&m);
+    m.z = 0;
+  }
+  assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
+  assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
+  return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z);
+}
+
+/*
+** pZ is a UTF-16 encoded unicode string. If nChar is less than zero,
+** return the number of bytes up to (but not including), the first pair
+** of consecutive 0x00 bytes in pZ. If nChar is not less than zero,
+** then return the number of bytes in the first nChar unicode characters
+** in pZ (or up until the first pair of 0x00 bytes, whichever comes first).
+*/
+int sqlite3Utf16ByteLen(const void *zIn, int nChar){
+  unsigned int c = 1;
+  char const *z = zIn;
+  int n = 0;
+  if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
+    /* Using an "if (SQLITE_UTF16NATIVE==SQLITE_UTF16BE)" construct here
+    ** and in other parts of this file means that at one branch will
+    ** not be covered by coverage testing on any single host. But coverage
+    ** will be complete if the tests are run on both a little-endian and 
+    ** big-endian host. Because both the UTF16NATIVE and SQLITE_UTF16BE
+    ** macros are constant at compile time the compiler can determine
+    ** which branch will be followed. It is therefore assumed that no runtime
+    ** penalty is paid for this "if" statement.
+    */
+    while( c && ((nChar<0) || n<nChar) ){
+      READ_UTF16BE(z, c);
+      n++;
+    }
+  }else{
+    while( c && ((nChar<0) || n<nChar) ){
+      READ_UTF16LE(z, c);
+      n++;
+    }
+  }
+  return (z-(char const *)zIn)-((c==0)?2:0);
+}
+
+#if defined(SQLITE_TEST)
+/*
+** This routine is called from the TCL test function "translate_selftest".
+** It checks that the primitives for serializing and deserializing
+** characters in each encoding are inverses of each other.
+*/
+void sqlite3UtfSelfTest(){
+  unsigned int i, t;
+  unsigned char zBuf[20];
+  unsigned char *z;
+  unsigned char *zTerm;
+  int n;
+  unsigned int c;
+
+  for(i=0; i<0x00110000; i++){
+    z = zBuf;
+    WRITE_UTF8(z, i);
+    n = z-zBuf;
+    z[0] = 0;
+    zTerm = z;
+    z = zBuf;
+    c = sqlite3Utf8Read(z, zTerm, (const u8**)&z);
+    t = i;
+    if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
+    if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
+    assert( c==t );
+    assert( (z-zBuf)==n );
+  }
+  for(i=0; i<0x00110000; i++){
+    if( i>=0xD800 && i<0xE000 ) continue;
+    z = zBuf;
+    WRITE_UTF16LE(z, i);
+    n = z-zBuf;
+    z[0] = 0;
+    z = zBuf;
+    READ_UTF16LE(z, c);
+    assert( c==i );
+    assert( (z-zBuf)==n );
+  }
+  for(i=0; i<0x00110000; i++){
+    if( i>=0xD800 && i<0xE000 ) continue;
+    z = zBuf;
+    WRITE_UTF16BE(z, i);
+    n = z-zBuf;
+    z[0] = 0;
+    z = zBuf;
+    READ_UTF16BE(z, c);
+    assert( c==i );
+    assert( (z-zBuf)==n );
+  }
+}
+#endif /* SQLITE_TEST */
+#endif /* SQLITE_OMIT_UTF16 */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/util.c b/client/src/thirdparty/sqlite-3.4.2/src/util.c
new file mode 100644
index 0000000..f8f02a4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/util.c
@@ -0,0 +1,724 @@
+/*
+** 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.
+**
+** $Id: util.c,v 1.216 2008/01/23 03:03:05 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <stdarg.h>
+#include <ctype.h>
+
+
+/*
+** 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 sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
+  if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
+    db->errCode = err_code;
+    if( zFormat ){
+      char *z;
+      va_list ap;
+      va_start(ap, zFormat);
+      z = sqlite3VMPrintf(db, zFormat, ap);
+      va_end(ap);
+      sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3_free);
+    }else{
+      sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
+    }
+  }
+}
+
+/*
+** 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 whilst
+** 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().
+** Function sqlite3Error() should be used during statement execution
+** (sqlite3_step() etc.).
+*/
+void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
+  va_list ap;
+  pParse->nErr++;
+  sqlite3_free(pParse->zErrMsg);
+  va_start(ap, zFormat);
+  pParse->zErrMsg = sqlite3VMPrintf(pParse->db, zFormat, ap);
+  va_end(ap);
+  if( pParse->rc==SQLITE_OK ){
+    pParse->rc = SQLITE_ERROR;
+  }
+}
+
+/*
+** Clear the error message in pParse, if any
+*/
+void sqlite3ErrorClear(Parse *pParse){
+  sqlite3_free(pParse->zErrMsg);
+  pParse->zErrMsg = 0;
+  pParse->nErr = 0;
+}
+
+/*
+** 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.
+**
+** 2002-Feb-14: This routine is extended to remove MS-Access style
+** brackets from around identifers.  For example:  "[a-b-c]" becomes
+** "a-b-c".
+*/
+void sqlite3Dequote(char *z){
+  int quote;
+  int i, j;
+  if( z==0 ) return;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return;
+  }
+  for(i=1, j=0; z[i]; i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        z[j++] = 0;
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+}
+
+/* An array to map all upper-case characters into their corresponding
+** lower-case character. 
+*/
+const unsigned char sqlite3UpperToLower[] = {
+#ifdef SQLITE_ASCII
+      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+     36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+     54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
+    104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
+    122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
+    108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
+    126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
+    144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
+    162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
+    180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
+    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
+    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
+    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
+    252,253,254,255
+#endif
+#ifdef SQLITE_EBCDIC
+      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */
+     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
+     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
+     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
+     64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
+     80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
+     96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
+    112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
+    128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
+    144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
+    160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
+    176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
+    192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
+    208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
+    224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
+    239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
+#endif
+};
+#define UpperToLower sqlite3UpperToLower
+
+/*
+** Some systems have stricmp().  Others have strcasecmp().  Because
+** there is no consistency, we will define our own.
+*/
+int sqlite3StrICmp(const char *zLeft, const char *zRight){
+  register unsigned char *a, *b;
+  a = (unsigned char *)zLeft;
+  b = (unsigned char *)zRight;
+  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
+  return UpperToLower[*a] - UpperToLower[*b];
+}
+int sqlite3StrNICmp(const char *zLeft, const char *zRight, int N){
+  register unsigned char *a, *b;
+  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];
+}
+
+/*
+** Return TRUE if z is a pure numeric string.  Return FALSE if the
+** string contains any character which is not part of a number. If
+** the string is numeric and contains the '.' character, set *realnum
+** to TRUE (otherwise FALSE).
+**
+** An empty string is considered non-numeric.
+*/
+int sqlite3IsNumber(const char *z, int *realnum, u8 enc){
+  int incr = (enc==SQLITE_UTF8?1:2);
+  if( enc==SQLITE_UTF16BE ) z++;
+  if( *z=='-' || *z=='+' ) z += incr;
+  if( !isdigit(*(u8*)z) ){
+    return 0;
+  }
+  z += incr;
+  if( realnum ) *realnum = 0;
+  while( isdigit(*(u8*)z) ){ z += incr; }
+  if( *z=='.' ){
+    z += incr;
+    if( !isdigit(*(u8*)z) ) return 0;
+    while( isdigit(*(u8*)z) ){ z += incr; }
+    if( realnum ) *realnum = 1;
+  }
+  if( *z=='e' || *z=='E' ){
+    z += incr;
+    if( *z=='+' || *z=='-' ) z += incr;
+    if( !isdigit(*(u8*)z) ) return 0;
+    while( isdigit(*(u8*)z) ){ z += incr; }
+    if( realnum ) *realnum = 1;
+  }
+  return *z==0;
+}
+
+/*
+** The string z[] is an ascii representation of a real number.
+** Convert this string to a double.
+**
+** This routine assumes that z[] really is a valid number.  If it
+** is not, the result is undefined.
+**
+** This routine is used instead of the library atof() function because
+** the library atof() might want to use "," as the decimal point instead
+** of "." depending on how locale is set.  But that would cause problems
+** for SQL.  So this routine always uses "." regardless of locale.
+*/
+int sqlite3AtoF(const char *z, double *pResult){
+#ifndef SQLITE_OMIT_FLOATING_POINT
+  int sign = 1;
+  const char *zBegin = z;
+  LONGDOUBLE_TYPE v1 = 0.0;
+  while( isspace(*(u8*)z) ) z++;
+  if( *z=='-' ){
+    sign = -1;
+    z++;
+  }else if( *z=='+' ){
+    z++;
+  }
+  while( isdigit(*(u8*)z) ){
+    v1 = v1*10.0 + (*z - '0');
+    z++;
+  }
+  if( *z=='.' ){
+    LONGDOUBLE_TYPE divisor = 1.0;
+    z++;
+    while( isdigit(*(u8*)z) ){
+      v1 = v1*10.0 + (*z - '0');
+      divisor *= 10.0;
+      z++;
+    }
+    v1 /= divisor;
+  }
+  if( *z=='e' || *z=='E' ){
+    int esign = 1;
+    int eval = 0;
+    LONGDOUBLE_TYPE scale = 1.0;
+    z++;
+    if( *z=='-' ){
+      esign = -1;
+      z++;
+    }else if( *z=='+' ){
+      z++;
+    }
+    while( isdigit(*(u8*)z) ){
+      eval = eval*10 + *z - '0';
+      z++;
+    }
+    while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; }
+    while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; }
+    while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; }
+    while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; }
+    if( esign<0 ){
+      v1 /= scale;
+    }else{
+      v1 *= scale;
+    }
+  }
+  *pResult = sign<0 ? -v1 : v1;
+  return z - zBegin;
+#else
+  return sqlite3Atoi64(z, pResult);
+#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.
+**
+** 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")
+**
+** will return -8.
+*/
+static int compare2pow63(const char *zNum){
+  int c;
+  c = memcmp(zNum,"922337203685477580",18);
+  if( c==0 ){
+    c = zNum[18] - '8';
+  }
+  return c;
+}
+
+
+/*
+** Return TRUE if zNum is a 64-bit signed integer and write
+** the value of the integer into *pNum.  If zNum is not an integer
+** or is an integer that is too large to be expressed with 64 bits,
+** then return false.
+**
+** When this routine was originally written it dealt with only
+** 32-bit numbers.  At that time, it was much faster than the
+** atoi() library routine in RedHat 7.2.
+*/
+int sqlite3Atoi64(const char *zNum, i64 *pNum){
+  i64 v = 0;
+  int neg;
+  int i, c;
+  while( isspace(*(u8*)zNum) ) zNum++;
+  if( *zNum=='-' ){
+    neg = 1;
+    zNum++;
+  }else if( *zNum=='+' ){
+    neg = 0;
+    zNum++;
+  }else{
+    neg = 0;
+  }
+  while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */
+  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
+    v = v*10 + c - '0';
+  }
+  *pNum = neg ? -v : v;
+  if( c!=0 || i==0 || i>19 ){
+    /* zNum is empty or contains non-numeric text or is longer
+    ** than 19 digits (thus guaranting that it is too large) */
+    return 0;
+  }else if( i<19 ){
+    /* Less than 19 digits, so we know that it fits in 64 bits */
+    return 1;
+  }else{
+    /* 19-digit numbers must be no larger than 9223372036854775807 if positive
+    ** or 9223372036854775808 if negative.  Note that 9223372036854665808
+    ** is 2^63. */
+    return compare2pow63(zNum)<neg;
+  }
+}
+
+/*
+** The string zNum represents an integer.  There might be some other
+** information following the integer too, but that part is ignored.
+** If the integer that the prefix of zNum represents will fit in a
+** 64-bit signed integer, return TRUE.  Otherwise return FALSE.
+**
+** This routine returns FALSE for the string -9223372036854775808 even that
+** that number will, in theory fit in a 64-bit integer.  Positive
+** 9223373036854775808 will not fit in 64 bits.  So it seems safer to return
+** false.
+*/
+int sqlite3FitsIn64Bits(const char *zNum, int negFlag){
+  int i, c;
+  int neg = 0;
+  if( *zNum=='-' ){
+    neg = 1;
+    zNum++;
+  }else if( *zNum=='+' ){
+    zNum++;
+  }
+  if( negFlag ) neg = 1-neg;
+  while( *zNum=='0' ){
+    zNum++;   /* Skip leading zeros.  Ticket #2454 */
+  }
+  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){}
+  if( i<19 ){
+    /* Guaranteed to fit if less than 19 digits */
+    return 1;
+  }else if( i>19 ){
+    /* Guaranteed to be too big if greater than 19 digits */
+    return 0;
+  }else{
+    /* Compare against 2^63. */
+    return compare2pow63(zNum)<neg;
+  }
+}
+
+/*
+** If zNum represents an integer that will fit in 32-bits, then set
+** *pValue to that integer and return true.  Otherwise return false.
+**
+** 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++;
+  }
+  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
+  */
+  if( i>10 ){
+    return 0;
+  }
+  if( v-neg>2147483647 ){
+    return 0;
+  }
+  if( neg ){
+    v = -v;
+  }
+  *pValue = (int)v;
+  return 1;
+}
+
+/*
+** 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.
+*/
+int sqlite3PutVarint(unsigned char *p, u64 v){
+  int i, j, n;
+  u8 buf[10];
+  if( v & (((u64)0xff000000)<<32) ){
+    p[8] = v;
+    v >>= 8;
+    for(i=7; i>=0; i--){
+      p[i] = (v & 0x7f) | 0x80;
+      v >>= 7;
+    }
+    return 9;
+  }    
+  n = 0;
+  do{
+    buf[n++] = (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;
+}
+
+/*
+** 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.
+*/
+int sqlite3GetVarint(const unsigned char *p, u64 *v){
+  u32 x;
+  u64 x64;
+  int n;
+  unsigned char c;
+  if( ((c = p[0]) & 0x80)==0 ){
+    *v = c;
+    return 1;
+  }
+  x = c & 0x7f;
+  if( ((c = p[1]) & 0x80)==0 ){
+    *v = (x<<7) | c;
+    return 2;
+  }
+  x = (x<<7) | (c&0x7f);
+  if( ((c = p[2]) & 0x80)==0 ){
+    *v = (x<<7) | c;
+    return 3;
+  }
+  x = (x<<7) | (c&0x7f);
+  if( ((c = p[3]) & 0x80)==0 ){
+    *v = (x<<7) | c;
+    return 4;
+  }
+  x64 = (x<<7) | (c&0x7f);
+  n = 4;
+  do{
+    c = p[n++];
+    if( n==9 ){
+      x64 = (x64<<8) | c;
+      break;
+    }
+    x64 = (x64<<7) | (c&0x7f);
+  }while( (c & 0x80)!=0 );
+  *v = x64;
+  return n;
+}
+
+/*
+** 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.
+*/
+int sqlite3GetVarint32(const unsigned char *p, u32 *v){
+  u32 x;
+  int n;
+  unsigned char c;
+  if( ((signed char*)p)[0]>=0 ){
+    *v = p[0];
+    return 1;
+  }
+  x = p[0] & 0x7f;
+  if( ((signed char*)p)[1]>=0 ){
+    *v = (x<<7) | p[1];
+    return 2;
+  }
+  x = (x<<7) | (p[1] & 0x7f);
+  n = 2;
+  do{
+    x = (x<<7) | ((c = p[n++])&0x7f);
+  }while( (c & 0x80)!=0 && n<9 );
+  *v = x;
+  return n;
+}
+
+/*
+** Return the number of bytes that will be needed to store the given
+** 64-bit integer.
+*/
+int sqlite3VarintLen(u64 v){
+  int i = 0;
+  do{
+    i++;
+    v >>= 7;
+  }while( v!=0 && i<9 );
+  return i;
+}
+
+
+/*
+** Read or write a four-byte big-endian integer value.
+*/
+u32 sqlite3Get4byte(const u8 *p){
+  return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+void sqlite3Put4byte(unsigned char *p, u32 v){
+  p[0] = v>>24;
+  p[1] = v>>16;
+  p[2] = v>>8;
+  p[3] = v;
+}
+
+
+
+#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \
+    || defined(SQLITE_TEST)
+/*
+** Translate a single byte of Hex into an integer.
+*/
+static int hexToInt(int h){
+  if( h>='0' && h<='9' ){
+    return h - '0';
+  }else if( h>='a' && h<='f' ){
+    return h - 'a' + 10;
+  }else{
+    assert( h>='A' && h<='F' );
+    return h - 'A' + 10;
+  }
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */
+
+#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 *)sqlite3DbMallocRaw(db, n/2 + 1);
+  n--;
+  if( zBlob ){
+    for(i=0; i<n; i+=2){
+      zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);
+    }
+    zBlob[i/2] = 0;
+  }
+  return zBlob;
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+
+
+/*
+** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
+** when this routine is called.
+**
+** This routine is called when entering an SQLite API.  The SQLITE_MAGIC_OPEN
+** value indicates that the database connection passed into the API is
+** open and is not being used by another thread.  By changing the value
+** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.
+** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN
+** when the API exits. 
+**
+** This routine is a attempt to detect if two threads use the
+** same sqlite* pointer at the same time.  There is a race 
+** condition so it is possible that the error is not detected.
+** But usually the problem will be seen.  The result will be an
+** error which can be used to debug the application that is
+** using SQLite incorrectly.
+**
+** Ticket #202:  If db->magic is not a valid open value, take care not
+** to modify the db structure at all.  It could be that db is a stale
+** pointer.  In other words, it could be that there has been a prior
+** call to sqlite3_close(db) and db has been deallocated.  And we do
+** not want to write into deallocated memory.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOn(sqlite3 *db){
+  if( db->magic==SQLITE_MAGIC_OPEN ){
+    db->magic = SQLITE_MAGIC_BUSY;
+    return 0;
+  }else if( db->magic==SQLITE_MAGIC_BUSY ){
+    db->magic = SQLITE_MAGIC_ERROR;
+    db->u1.isInterrupted = 1;
+  }
+  return 1;
+}
+#endif
+
+/*
+** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
+** when this routine is called.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOff(sqlite3 *db){
+  if( db->magic==SQLITE_MAGIC_BUSY ){
+    db->magic = SQLITE_MAGIC_OPEN;
+    return 0;
+  }else{
+    db->magic = SQLITE_MAGIC_ERROR;
+    db->u1.isInterrupted = 1;
+    return 1;
+  }
+}
+#endif
+
+/*
+** 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){
+  int magic;
+  if( db==0 ) return 0;
+  magic = db->magic;
+  if( magic!=SQLITE_MAGIC_OPEN &&
+      magic!=SQLITE_MAGIC_BUSY ) return 0;
+  return 1;
+}
+int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
+  int magic;
+  if( db==0 ) return 0;
+  magic = db->magic;
+  if( magic!=SQLITE_MAGIC_SICK &&
+      magic!=SQLITE_MAGIC_OPEN &&
+      magic!=SQLITE_MAGIC_BUSY ) return 0;
+  return 1;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vacuum.c b/client/src/thirdparty/sqlite-3.4.2/src/vacuum.c
new file mode 100644
index 0000000..c6544ac
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vacuum.c
@@ -0,0 +1,263 @@
+/*
+** 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 VACUUM command.
+**
+** Most of the code in this file may be omitted by defining the
+** SQLITE_OMIT_VACUUM macro.
+**
+** $Id: vacuum.c,v 1.76 2008/01/03 00:01:25 drh Exp $
+*/
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+
+#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
+/*
+** Execute zSql on database db. Return an error code.
+*/
+static int execSql(sqlite3 *db, const char *zSql){
+  sqlite3_stmt *pStmt;
+  if( !zSql ){
+    return SQLITE_NOMEM;
+  }
+  if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
+    return sqlite3_errcode(db);
+  }
+  while( SQLITE_ROW==sqlite3_step(pStmt) ){}
+  return sqlite3_finalize(pStmt);
+}
+
+/*
+** Execute zSql on database db. The statement returns exactly
+** one column. Execute this as SQL on the same database.
+*/
+static int execExecSql(sqlite3 *db, const char *zSql){
+  sqlite3_stmt *pStmt;
+  int rc;
+
+  rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ) return rc;
+
+  while( SQLITE_ROW==sqlite3_step(pStmt) ){
+    rc = execSql(db, (char*)sqlite3_column_text(pStmt, 0));
+    if( rc!=SQLITE_OK ){
+      sqlite3_finalize(pStmt);
+      return rc;
+    }
+  }
+
+  return sqlite3_finalize(pStmt);
+}
+
+/*
+** The non-standard VACUUM command is used to clean up the database,
+** collapse free space, etc.  It is modelled after the VACUUM command
+** in PostgreSQL.
+**
+** In version 1.0.x of SQLite, the VACUUM command would call
+** gdbm_reorganize() on all the database tables.  But beginning
+** with 2.0.0, SQLite no longer uses GDBM so this command has
+** become a no-op.
+*/
+void sqlite3Vacuum(Parse *pParse){
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp2(v, OP_Vacuum, 0, 0);
+  }
+  return;
+}
+
+/*
+** This routine implements the OP_Vacuum opcode of the VDBE.
+*/
+int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){
+  int rc = SQLITE_OK;     /* Return code from service routines */
+  Btree *pMain;           /* The database being vacuumed */
+  Btree *pTemp;           /* The temporary database we vacuum into */
+  char *zSql = 0;         /* SQL statements */
+  int saved_flags;        /* Saved value of the db->flags */
+  Db *pDb = 0;            /* Database to detach at end of vacuum */
+
+  /* Save the current value of the write-schema flag before setting it. */
+  saved_flags = db->flags;
+  db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
+
+  if( !db->autoCommit ){
+    sqlite3SetString(pzErrMsg, "cannot VACUUM from within a transaction", 
+       (char*)0);
+    rc = SQLITE_ERROR;
+    goto end_of_vacuum;
+  }
+  pMain = db->aDb[0].pBt;
+
+  /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
+  ** can be set to 'off' for this file, as it is not recovered if a crash
+  ** occurs anyway. The integrity of the database is maintained by a
+  ** (possibly synchronous) transaction opened on the main database before
+  ** sqlite3BtreeCopyFile() is called.
+  **
+  ** An optimisation would be to use a non-journaled pager.
+  */
+  zSql = "ATTACH '' AS vacuum_db;";
+  rc = execSql(db, zSql);
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+  pDb = &db->aDb[db->nDb-1];
+  assert( strcmp(db->aDb[db->nDb-1].zName,"vacuum_db")==0 );
+  pTemp = db->aDb[db->nDb-1].pBt;
+  sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain),
+     sqlite3BtreeGetReserve(pMain));
+  if( db->mallocFailed ){
+    rc = SQLITE_NOMEM;
+    goto end_of_vacuum;
+  }
+  assert( sqlite3BtreeGetPageSize(pTemp)==sqlite3BtreeGetPageSize(pMain) );
+  rc = execSql(db, "PRAGMA vacuum_db.synchronous=OFF");
+  if( rc!=SQLITE_OK ){
+    goto end_of_vacuum;
+  }
+
+#ifndef SQLITE_OMIT_AUTOVACUUM
+  sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
+                                           sqlite3BtreeGetAutoVacuum(pMain));
+#endif
+
+  /* Begin a transaction */
+  rc = execSql(db, "BEGIN EXCLUSIVE;");
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+
+  /* Query the schema of the main database. Create a mirror schema
+  ** in the temporary database.
+  */
+  rc = execExecSql(db, 
+      "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
+      "  FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'"
+      "   AND rootpage>0"
+  );
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+  rc = execExecSql(db, 
+      "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)"
+      "  FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' ");
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+  rc = execExecSql(db, 
+      "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) "
+      "  FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'");
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+
+  /* Loop through the tables in the main database. For each, do
+  ** an "INSERT INTO vacuum_db.xxx SELECT * FROM xxx;" to copy
+  ** the contents to the temporary database.
+  */
+  rc = execExecSql(db, 
+      "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
+      "|| ' SELECT * FROM ' || quote(name) || ';'"
+      "FROM sqlite_master "
+      "WHERE type = 'table' AND name!='sqlite_sequence' "
+      "  AND rootpage>0"
+
+  );
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+
+  /* Copy over the sequence table
+  */
+  rc = execExecSql(db, 
+      "SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
+      "FROM vacuum_db.sqlite_master WHERE name='sqlite_sequence' "
+  );
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+  rc = execExecSql(db, 
+      "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
+      "|| ' SELECT * FROM ' || quote(name) || ';' "
+      "FROM vacuum_db.sqlite_master WHERE name=='sqlite_sequence';"
+  );
+  if( rc!=SQLITE_OK ) goto end_of_vacuum;
+
+
+  /* Copy the triggers, views, and virtual tables from the main database
+  ** over to the temporary database.  None of these objects has any
+  ** associated storage, so all we have to do is copy their entries
+  ** from the SQLITE_MASTER table.
+  */
+  rc = execSql(db,
+      "INSERT INTO vacuum_db.sqlite_master "
+      "  SELECT type, name, tbl_name, rootpage, sql"
+      "    FROM sqlite_master"
+      "   WHERE type='view' OR type='trigger'"
+      "      OR (type='table' AND rootpage=0)"
+  );
+  if( rc ) goto end_of_vacuum;
+
+  /* At this point, unless the main db was completely empty, there is now a
+  ** transaction open on the vacuum database, but not on the main database.
+  ** Open a btree level transaction on the main database. This allows a
+  ** call to sqlite3BtreeCopyFile(). The main database btree level
+  ** transaction is then committed, so the SQL level never knows it was
+  ** opened for writing. This way, the SQL transaction used to create the
+  ** temporary database never needs to be committed.
+  */
+  if( rc==SQLITE_OK ){
+    u32 meta;
+    int i;
+
+    /* This array determines which meta meta values are preserved in the
+    ** vacuum.  Even entries are the meta value number and odd entries
+    ** are an increment to apply to the meta value after the vacuum.
+    ** The increment is used to increase the schema cookie so that other
+    ** connections to the same database will know to reread the schema.
+    */
+    static const unsigned char aCopy[] = {
+       1, 1,    /* Add one to the old schema cookie */
+       3, 0,    /* Preserve the default page cache size */
+       5, 0,    /* Preserve the default text encoding */
+       6, 0,    /* Preserve the user version */
+    };
+
+    assert( 1==sqlite3BtreeIsInTrans(pTemp) );
+    assert( 1==sqlite3BtreeIsInTrans(pMain) );
+
+    /* Copy Btree meta values */
+    for(i=0; i<sizeof(aCopy)/sizeof(aCopy[0]); i+=2){
+      rc = sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
+      if( rc!=SQLITE_OK ) goto end_of_vacuum;
+      rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
+      if( rc!=SQLITE_OK ) goto end_of_vacuum;
+    }
+
+    rc = sqlite3BtreeCopyFile(pMain, pTemp);
+    if( rc!=SQLITE_OK ) goto end_of_vacuum;
+    rc = sqlite3BtreeCommit(pTemp);
+    if( rc!=SQLITE_OK ) goto end_of_vacuum;
+    rc = sqlite3BtreeCommit(pMain);
+  }
+
+end_of_vacuum:
+  /* Restore the original value of db->flags */
+  db->flags = saved_flags;
+
+  /* Currently there is an SQL level transaction open on the vacuum
+  ** database. No locks are held on any other files (since the main file
+  ** was committed at the btree level). So it safe to end the transaction
+  ** by manually setting the autoCommit flag to true and detaching the
+  ** vacuum database. The vacuum_db journal file is deleted when the pager
+  ** is closed by the DETACH.
+  */
+  db->autoCommit = 1;
+
+  if( pDb ){
+    sqlite3BtreeClose(pDb->pBt);
+    pDb->pBt = 0;
+    pDb->pSchema = 0;
+  }
+
+  sqlite3ResetInternalSchema(db, 0);
+
+  return rc;
+}
+#endif  /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbe.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbe.c
new file mode 100644
index 0000000..2901752
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbe.c
@@ -0,0 +1,4816 @@
+/*
+** 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.
+**
+*************************************************************************
+** The code in this file implements execution method of the 
+** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
+** handles housekeeping details such as creating and deleting
+** VDBE instances.  This file is solely interested in executing
+** the VDBE program.
+**
+** In the external interface, an "sqlite3_stmt*" is an opaque pointer
+** to a VDBE.
+**
+** The SQL parser generates a program which is then executed by
+** the VDBE to do the work of the SQL statement.  VDBE programs are 
+** similar in form to assembly language.  The program consists of
+** a linear sequence of operations.  Each operation has an opcode 
+** and 5 operands.  Operands P1, P2, and P3 are integers.  Operand P4 
+** is a null-terminated string.  Operand P5 is an unsigned character.
+** Few opcodes use all 5 operands.
+**
+** Computation results are stored on a set of registers numbered beginning
+** with 1 and going up to Vdbe.nMem.  Each register can store
+** either an integer, a null-terminated string, a floating point
+** number, or the SQL "NULL" value.  An inplicit conversion from one
+** type to the other occurs as necessary.
+** 
+** Most of the code in this file is taken up by the sqlite3VdbeExec()
+** function which does the work of interpreting a VDBE program.
+** But other routines are also provided to help in building up
+** a program instruction by instruction.
+**
+** Various scripts scan this source file in order to generate HTML
+** documentation, headers files, or other derived files.  The formatting
+** of the code in this file is, therefore, important.  See other comments
+** in this file for details.  If in doubt, do not deviate from existing
+** commenting and indentation practices when changing or adding code.
+**
+** $Id: vdbe.c,v 1.708 2008/02/06 14:11:35 drh Exp $
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include "vdbeInt.h"
+
+/*
+** The following global variable is incremented every time a cursor
+** moves, either by the OP_MoveXX, OP_Next, or OP_Prev opcodes.  The test
+** procedures use this information to make sure that indices are
+** working correctly.  This variable has no function other than to
+** help verify the correct operation of the library.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_search_count = 0;
+#endif
+
+/*
+** When this global variable is positive, it gets decremented once before
+** each instruction in the VDBE.  When reaches zero, the u1.isInterrupted
+** field of the sqlite3 structure is set in order to simulate and interrupt.
+**
+** This facility is used for testing purposes only.  It does not function
+** in an ordinary build.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_interrupt_count = 0;
+#endif
+
+/*
+** The next global variable is incremented each type the OP_Sort opcode
+** is executed.  The test procedures use this information to make sure that
+** sorting is occurring or not occuring at appropriate times.   This variable
+** has no function other than to help verify the correct operation of the
+** library.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_sort_count = 0;
+#endif
+
+/*
+** The next global variable records the size of the largest MEM_Blob
+** or MEM_Str that has been used by a VDBE opcode.  The test procedures
+** use this information to make sure that the zero-blob functionality
+** is working correctly.   This variable has no function other than to
+** help verify the correct operation of the library.
+*/
+#ifdef SQLITE_TEST
+int sqlite3_max_blobsize = 0;
+static void updateMaxBlobsize(Mem *p){
+  if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
+    sqlite3_max_blobsize = p->n;
+  }
+}
+#endif
+
+/*
+** Test a register to see if it exceeds the current maximum blob size.
+** If it does, record the new maximum blob size.
+*/
+#ifdef SQLITE_TEST
+# define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)
+#else
+# define UPDATE_MAX_BLOBSIZE(P)
+#endif
+
+/*
+** Release the memory associated with a register.  This
+** leaves the Mem.flags field in an inconsistent state.
+*/
+#define Release(P) if((P)->flags&MEM_Dyn){ sqlite3VdbeMemRelease(P); }
+
+/*
+** Convert the given register into a string if it isn't one
+** already. Return non-zero if a malloc() fails.
+*/
+#define Stringify(P, enc) \
+   if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) \
+     { goto no_mem; }
+
+/*
+** The header of a record consists of a sequence variable-length integers.
+** These integers are almost always small and are encoded as a single byte.
+** The following macro takes advantage this fact to provide a fast decode
+** of the integers in a record header.  It is faster for the common case
+** where the integer is a single byte.  It is a little slower when the
+** integer is two or more bytes.  But overall it is faster.
+**
+** The following expressions are equivalent:
+**
+**     x = sqlite3GetVarint32( A, &B );
+**
+**     x = GetVarint( A, B );
+**
+*/
+#define GetVarint(A,B)  ((B = *(A))<=0x7f ? 1 : sqlite3GetVarint32(A, &B))
+
+/*
+** An ephemeral string value (signified by the MEM_Ephem flag) contains
+** a pointer to a dynamically allocated string where some other entity
+** is responsible for deallocating that string.  Because the register
+** does not control the string, it might be deleted without the register
+** knowing it.
+**
+** This routine converts an ephemeral string into a dynamically allocated
+** string that the register itself controls.  In other words, it
+** converts an MEM_Ephem string into an MEM_Dyn string.
+*/
+#define Deephemeralize(P) \
+   if( ((P)->flags&MEM_Ephem)!=0 \
+       && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
+
+/*
+** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
+** P if required.
+*/
+#define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
+
+/*
+** Argument pMem points at a regiser that will be passed to a
+** user-defined function or returned to the user as the result of a query.
+** The second argument, 'db_enc' is the text encoding used by the vdbe for
+** register variables.  This routine sets the pMem->enc and pMem->type
+** variables used by the sqlite3_value_*() routines.
+*/
+#define storeTypeInfo(A,B) _storeTypeInfo(A)
+static void _storeTypeInfo(Mem *pMem){
+  int flags = pMem->flags;
+  if( flags & MEM_Null ){
+    pMem->type = SQLITE_NULL;
+  }
+  else if( flags & MEM_Int ){
+    pMem->type = SQLITE_INTEGER;
+  }
+  else if( flags & MEM_Real ){
+    pMem->type = SQLITE_FLOAT;
+  }
+  else if( flags & MEM_Str ){
+    pMem->type = SQLITE_TEXT;
+  }else{
+    pMem->type = SQLITE_BLOB;
+  }
+}
+
+/*
+** Properties of opcodes.  The OPFLG_INITIALIZER macro is
+** created by mkopcodeh.awk during compilation.  Data is obtained
+** from the comments following the "case OP_xxxx:" statements in
+** this file.  
+*/
+static unsigned char opcodeProperty[] = OPFLG_INITIALIZER;
+
+/*
+** Return true if an opcode has any of the OPFLG_xxx properties
+** specified by mask.
+*/
+int sqlite3VdbeOpcodeHasProperty(int opcode, int mask){
+  assert( opcode>0 && opcode<sizeof(opcodeProperty) );
+  return (opcodeProperty[opcode]&mask)!=0;
+}
+
+/*
+** Allocate cursor number iCur.  Return a pointer to it.  Return NULL
+** if we run out of memory.
+*/
+static Cursor *allocateCursor(Vdbe *p, int iCur, int iDb){
+  Cursor *pCx;
+  assert( iCur<p->nCursor );
+  if( p->apCsr[iCur] ){
+    sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
+  }
+  p->apCsr[iCur] = pCx = sqlite3MallocZero( sizeof(Cursor) );
+  if( pCx ){
+    pCx->iDb = iDb;
+  }
+  return pCx;
+}
+
+/*
+** Try to convert a value into a numeric representation if we can
+** do so without loss of information.  In other words, if the string
+** looks like a number, convert it into a number.  If it does not
+** look like a number, leave it alone.
+*/
+static void applyNumericAffinity(Mem *pRec){
+  if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
+    int realnum;
+    sqlite3VdbeMemNulTerminate(pRec);
+    if( (pRec->flags&MEM_Str)
+         && sqlite3IsNumber(pRec->z, &realnum, pRec->enc) ){
+      i64 value;
+      sqlite3VdbeChangeEncoding(pRec, SQLITE_UTF8);
+      if( !realnum && sqlite3Atoi64(pRec->z, &value) ){
+        sqlite3VdbeMemRelease(pRec);
+        pRec->u.i = value;
+        pRec->flags = MEM_Int;
+      }else{
+        sqlite3VdbeMemRealify(pRec);
+      }
+    }
+  }
+}
+
+/*
+** Processing is determine by the affinity parameter:
+**
+** SQLITE_AFF_INTEGER:
+** SQLITE_AFF_REAL:
+** SQLITE_AFF_NUMERIC:
+**    Try to convert pRec to an integer representation or a 
+**    floating-point representation if an integer representation
+**    is not possible.  Note that the integer representation is
+**    always preferred, even if the affinity is REAL, because
+**    an integer representation is more space efficient on disk.
+**
+** SQLITE_AFF_TEXT:
+**    Convert pRec to a text representation.
+**
+** SQLITE_AFF_NONE:
+**    No-op.  pRec is unchanged.
+*/
+static void applyAffinity(
+  Mem *pRec,          /* The value to apply affinity to */
+  char affinity,      /* The affinity to be applied */
+  u8 enc              /* Use this text encoding */
+){
+  if( affinity==SQLITE_AFF_TEXT ){
+    /* Only attempt the conversion to TEXT if there is an integer or real
+    ** representation (blob and NULL do not get converted) but no string
+    ** representation.
+    */
+    if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
+      sqlite3VdbeMemStringify(pRec, enc);
+    }
+    pRec->flags &= ~(MEM_Real|MEM_Int);
+  }else if( affinity!=SQLITE_AFF_NONE ){
+    assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
+             || affinity==SQLITE_AFF_NUMERIC );
+    applyNumericAffinity(pRec);
+    if( pRec->flags & MEM_Real ){
+      sqlite3VdbeIntegerAffinity(pRec);
+    }
+  }
+}
+
+/*
+** Try to convert the type of a function argument or a result column
+** into a numeric representation.  Use either INTEGER or REAL whichever
+** is appropriate.  But only do the conversion if it is possible without
+** loss of information and return the revised type of the argument.
+**
+** This is an EXPERIMENTAL api and is subject to change or removal.
+*/
+int sqlite3_value_numeric_type(sqlite3_value *pVal){
+  Mem *pMem = (Mem*)pVal;
+  applyNumericAffinity(pMem);
+  storeTypeInfo(pMem, 0);
+  return pMem->type;
+}
+
+/*
+** Exported version of applyAffinity(). This one works on sqlite3_value*, 
+** not the internal Mem* type.
+*/
+void sqlite3ValueApplyAffinity(
+  sqlite3_value *pVal, 
+  u8 affinity, 
+  u8 enc
+){
+  applyAffinity((Mem *)pVal, affinity, enc);
+}
+
+#ifdef SQLITE_DEBUG
+/*
+** Write a nice string representation of the contents of cell pMem
+** into buffer zBuf, length nBuf.
+*/
+void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
+  char *zCsr = zBuf;
+  int f = pMem->flags;
+
+  static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
+
+  if( f&MEM_Blob ){
+    int i;
+    char c;
+    if( f & MEM_Dyn ){
+      c = 'z';
+      assert( (f & (MEM_Static|MEM_Ephem))==0 );
+    }else if( f & MEM_Static ){
+      c = 't';
+      assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
+    }else if( f & MEM_Ephem ){
+      c = 'e';
+      assert( (f & (MEM_Static|MEM_Dyn))==0 );
+    }else{
+      c = 's';
+    }
+
+    sqlite3_snprintf(100, zCsr, "%c", c);
+    zCsr += strlen(zCsr);
+    sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
+    zCsr += strlen(zCsr);
+    for(i=0; i<16 && i<pMem->n; i++){
+      sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
+      zCsr += strlen(zCsr);
+    }
+    for(i=0; i<16 && i<pMem->n; i++){
+      char z = pMem->z[i];
+      if( z<32 || z>126 ) *zCsr++ = '.';
+      else *zCsr++ = z;
+    }
+
+    sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
+    zCsr += strlen(zCsr);
+    if( f & MEM_Zero ){
+      sqlite3_snprintf(100, zCsr,"+%lldz",pMem->u.i);
+      zCsr += strlen(zCsr);
+    }
+    *zCsr = '\0';
+  }else if( f & MEM_Str ){
+    int j, k;
+    zBuf[0] = ' ';
+    if( f & MEM_Dyn ){
+      zBuf[1] = 'z';
+      assert( (f & (MEM_Static|MEM_Ephem))==0 );
+    }else if( f & MEM_Static ){
+      zBuf[1] = 't';
+      assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
+    }else if( f & MEM_Ephem ){
+      zBuf[1] = 'e';
+      assert( (f & (MEM_Static|MEM_Dyn))==0 );
+    }else{
+      zBuf[1] = 's';
+    }
+    k = 2;
+    sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
+    k += strlen(&zBuf[k]);
+    zBuf[k++] = '[';
+    for(j=0; j<15 && j<pMem->n; j++){
+      u8 c = pMem->z[j];
+      if( c>=0x20 && c<0x7f ){
+        zBuf[k++] = c;
+      }else{
+        zBuf[k++] = '.';
+      }
+    }
+    zBuf[k++] = ']';
+    sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
+    k += strlen(&zBuf[k]);
+    zBuf[k++] = 0;
+  }
+}
+#endif
+
+#ifdef SQLITE_DEBUG
+/*
+** Print the value of a register for tracing purposes:
+*/
+static void memTracePrint(FILE *out, Mem *p){
+  if( p->flags & MEM_Null ){
+    fprintf(out, " NULL");
+  }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
+    fprintf(out, " si:%lld", p->u.i);
+  }else if( p->flags & MEM_Int ){
+    fprintf(out, " i:%lld", p->u.i);
+  }else if( p->flags & MEM_Real ){
+    fprintf(out, " r:%g", p->r);
+  }else{
+    char zBuf[200];
+    sqlite3VdbeMemPrettyPrint(p, zBuf);
+    fprintf(out, " ");
+    fprintf(out, "%s", zBuf);
+  }
+}
+static void registerTrace(FILE *out, int iReg, Mem *p){
+  fprintf(out, "REG[%d] = ", iReg);
+  memTracePrint(out, p);
+  fprintf(out, "\n");
+}
+#endif
+
+#ifdef SQLITE_DEBUG
+#  define REGISTER_TRACE(R,M) if(p->trace&&R>0)registerTrace(p->trace,R,M)
+#else
+#  define REGISTER_TRACE(R,M)
+#endif
+
+
+#ifdef VDBE_PROFILE
+/*
+** The following routine only works on pentium-class processors.
+** It uses the RDTSC opcode to read the cycle count value out of the
+** processor and returns that value.  This can be used for high-res
+** profiling.
+*/
+__inline__ unsigned long long int hwtime(void){
+  unsigned long long int x;
+  __asm__("rdtsc\n\t"
+          "mov %%edx, %%ecx\n\t"
+          :"=A" (x));
+  return x;
+}
+#endif
+
+/*
+** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
+** sqlite3_interrupt() routine has been called.  If it has been, then
+** processing of the VDBE program is interrupted.
+**
+** This macro added to every instruction that does a jump in order to
+** implement a loop.  This test used to be on every single instruction,
+** but that meant we more testing that we needed.  By only testing the
+** flag on jump instructions, we get a (small) speed improvement.
+*/
+#define CHECK_FOR_INTERRUPT \
+   if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
+
+
+/*
+** Execute as much of a VDBE program as we can then return.
+**
+** sqlite3VdbeMakeReady() must be called before this routine in order to
+** close the program with a final OP_Halt and to set up the callbacks
+** and the error message pointer.
+**
+** Whenever a row or result data is available, this routine will either
+** invoke the result callback (if there is one) or return with
+** SQLITE_ROW.
+**
+** If an attempt is made to open a locked database, then this routine
+** will either invoke the busy callback (if there is one) or it will
+** return SQLITE_BUSY.
+**
+** If an error occurs, an error message is written to memory obtained
+** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
+** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
+**
+** If the callback ever returns non-zero, then the program exits
+** immediately.  There will be no error message but the p->rc field is
+** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
+**
+** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
+** routine to return SQLITE_ERROR.
+**
+** Other fatal errors return SQLITE_ERROR.
+**
+** After this routine has finished, sqlite3VdbeFinalize() should be
+** used to clean up the mess that was left behind.
+*/
+int sqlite3VdbeExec(
+  Vdbe *p                    /* The VDBE */
+){
+  int pc;                    /* The program counter */
+  Op *pOp;                   /* Current operation */
+  int rc = SQLITE_OK;        /* Value to return */
+  sqlite3 *db = p->db;       /* The database */
+  u8 encoding = ENC(db);     /* The database encoding */
+  Mem *pIn1, *pIn2, *pIn3;   /* Input operands */
+  Mem *pOut;                 /* Output operand */
+  u8 opProperty;
+#ifdef VDBE_PROFILE
+  unsigned long long start;  /* CPU clock count at start of opcode */
+  int origPc;                /* Program counter at start of opcode */
+#endif
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+  int nProgressOps = 0;      /* Opcodes executed since progress callback. */
+#endif
+
+  assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
+  assert( db->magic==SQLITE_MAGIC_BUSY );
+  sqlite3BtreeMutexArrayEnter(&p->aMutex);
+  if( p->rc==SQLITE_NOMEM ){
+    /* This happens if a malloc() inside a call to sqlite3_column_text() or
+    ** sqlite3_column_text16() failed.  */
+    goto no_mem;
+  }
+  assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
+  p->rc = SQLITE_OK;
+  assert( p->explain==0 );
+  p->pResultSet = 0;
+  db->busyHandler.nBusy = 0;
+  CHECK_FOR_INTERRUPT;
+  sqlite3VdbeIOTraceSql(p);
+#ifdef SQLITE_DEBUG
+  if( p->pc==0 && ((p->db->flags & SQLITE_VdbeListing)!=0
+    || sqlite3OsAccess(db->pVfs, "vdbe_explain", SQLITE_ACCESS_EXISTS))
+  ){
+    int i;
+    printf("VDBE Program Listing:\n");
+    sqlite3VdbePrintSql(p);
+    for(i=0; i<p->nOp; i++){
+      sqlite3VdbePrintOp(stdout, i, &p->aOp[i]);
+    }
+  }
+  if( sqlite3OsAccess(db->pVfs, "vdbe_trace", SQLITE_ACCESS_EXISTS) ){
+    p->trace = stdout;
+  }
+#endif
+  for(pc=p->pc; rc==SQLITE_OK; pc++){
+    assert( pc>=0 && pc<p->nOp );
+    if( db->mallocFailed ) goto no_mem;
+#ifdef VDBE_PROFILE
+    origPc = pc;
+    start = hwtime();
+#endif
+    pOp = &p->aOp[pc];
+
+    /* Only allow tracing if SQLITE_DEBUG is defined.
+    */
+#ifdef SQLITE_DEBUG
+    if( p->trace ){
+      if( pc==0 ){
+        printf("VDBE Execution Trace:\n");
+        sqlite3VdbePrintSql(p);
+      }
+      sqlite3VdbePrintOp(p->trace, pc, pOp);
+    }
+    if( p->trace==0 && pc==0 
+     && sqlite3OsAccess(db->pVfs, "vdbe_sqltrace", SQLITE_ACCESS_EXISTS) ){
+      sqlite3VdbePrintSql(p);
+    }
+#endif
+      
+
+    /* Check to see if we need to simulate an interrupt.  This only happens
+    ** if we have a special test build.
+    */
+#ifdef SQLITE_TEST
+    if( sqlite3_interrupt_count>0 ){
+      sqlite3_interrupt_count--;
+      if( sqlite3_interrupt_count==0 ){
+        sqlite3_interrupt(db);
+      }
+    }
+#endif
+
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+    /* Call the progress callback if it is configured and the required number
+    ** of VDBE ops have been executed (either since this invocation of
+    ** sqlite3VdbeExec() or since last time the progress callback was called).
+    ** If the progress callback returns non-zero, exit the virtual machine with
+    ** a return code SQLITE_ABORT.
+    */
+    if( db->xProgress ){
+      if( db->nProgressOps==nProgressOps ){
+        int prc;
+        if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+        prc =db->xProgress(db->pProgressArg);
+        if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+        if( prc!=0 ){
+          rc = SQLITE_INTERRUPT;
+          goto vdbe_error_halt;
+        }
+        nProgressOps = 0;
+      }
+      nProgressOps++;
+    }
+#endif
+
+    /* Do common setup processing for any opcode that is marked
+    ** with the "out2-prerelease" tag.  Such opcodes have a single
+    ** output which is specified by the P2 parameter.  The P2 register
+    ** is initialized to a NULL.
+    */
+    opProperty = opcodeProperty[pOp->opcode];
+    if( (opProperty & OPFLG_OUT2_PRERELEASE)!=0 ){
+      assert( pOp->p2>0 );
+      assert( pOp->p2<=p->nMem );
+      pOut = &p->aMem[pOp->p2];
+      sqlite3VdbeMemRelease(pOut);
+      pOut->flags = MEM_Null;
+    }else
+ 
+    /* Do common setup for opcodes marked with one of the following
+    ** combinations of properties.
+    **
+    **           in1
+    **           in1 in2
+    **           in1 in2 out3
+    **           in1 in3
+    **
+    ** Variables pIn1, pIn2, and pIn3 are made to point to appropriate
+    ** registers for inputs.  Variable pOut points to the output register.
+    */
+    if( (opProperty & OPFLG_IN1)!=0 ){
+      assert( pOp->p1>0 );
+      assert( pOp->p1<=p->nMem );
+      pIn1 = &p->aMem[pOp->p1];
+      REGISTER_TRACE(pOp->p1, pIn1);
+      if( (opProperty & OPFLG_IN2)!=0 ){
+        assert( pOp->p2>0 );
+        assert( pOp->p2<=p->nMem );
+        pIn2 = &p->aMem[pOp->p2];
+        REGISTER_TRACE(pOp->p2, pIn2);
+        if( (opProperty & OPFLG_OUT3)!=0 ){
+          assert( pOp->p3>0 );
+          assert( pOp->p3<=p->nMem );
+          pOut = &p->aMem[pOp->p3];
+        }
+      }else if( (opProperty & OPFLG_IN3)!=0 ){
+        assert( pOp->p3>0 );
+        assert( pOp->p3<=p->nMem );
+        pIn3 = &p->aMem[pOp->p3];
+        REGISTER_TRACE(pOp->p3, pIn3);
+      }
+    }else if( (opProperty & OPFLG_IN2)!=0 ){
+      assert( pOp->p2>0 );
+      assert( pOp->p2<=p->nMem );
+      pIn2 = &p->aMem[pOp->p2];
+      REGISTER_TRACE(pOp->p2, pIn2);
+    }else if( (opProperty & OPFLG_IN3)!=0 ){
+      assert( pOp->p3>0 );
+      assert( pOp->p3<=p->nMem );
+      pIn3 = &p->aMem[pOp->p3];
+      REGISTER_TRACE(pOp->p3, pIn3);
+    }
+
+    switch( pOp->opcode ){
+
+/*****************************************************************************
+** What follows is a massive switch statement where each case implements a
+** separate instruction in the virtual machine.  If we follow the usual
+** indentation conventions, each case should be indented by 6 spaces.  But
+** that is a lot of wasted space on the left margin.  So the code within
+** the switch statement will break with convention and be flush-left. Another
+** big comment (similar to this one) will mark the point in the code where
+** we transition back to normal indentation.
+**
+** The formatting of each case is important.  The makefile for SQLite
+** generates two C files "opcodes.h" and "opcodes.c" by scanning this
+** file looking for lines that begin with "case OP_".  The opcodes.h files
+** will be filled with #defines that give unique integer values to each
+** opcode and the opcodes.c file is filled with an array of strings where
+** each string is the symbolic name for the corresponding opcode.  If the
+** case statement is followed by a comment of the form "/# same as ... #/"
+** that comment is used to determine the particular value of the opcode.
+**
+** Other keywords in the comment that follows each case are used to
+** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
+** Keywords include: in1, in2, in3, out2_prerelease, out2, out3.  See
+** the mkopcodeh.awk script for additional information.
+**
+** Documentation about VDBE opcodes is generated by scanning this file
+** for lines of that contain "Opcode:".  That line and all subsequent
+** comment lines are used in the generation of the opcode.html documentation
+** file.
+**
+** SUMMARY:
+**
+**     Formatting is important to scripts that scan this file.
+**     Do not deviate from the formatting style currently in use.
+**
+*****************************************************************************/
+
+/* Opcode:  Goto * P2 * * *
+**
+** An unconditional jump to address P2.
+** The next instruction executed will be 
+** the one at index P2 from the beginning of
+** the program.
+*/
+case OP_Goto: {             /* jump */
+  CHECK_FOR_INTERRUPT;
+  pc = pOp->p2 - 1;
+  break;
+}
+
+/* Opcode:  Gosub * P2 * * *
+**
+** Push the current address plus 1 onto the return address stack
+** and then jump to address P2.
+**
+** The return address stack is of limited depth.  If too many
+** OP_Gosub operations occur without intervening OP_Returns, then
+** the return address stack will fill up and processing will abort
+** with a fatal error.
+*/
+case OP_Gosub: {            /* jump */
+  assert( p->returnDepth<sizeof(p->returnStack)/sizeof(p->returnStack[0]) );
+  p->returnStack[p->returnDepth++] = pc+1;
+  pc = pOp->p2 - 1;
+  break;
+}
+
+/* Opcode:  Return * * * * *
+**
+** Jump immediately to the next instruction after the last unreturned
+** OP_Gosub.  If an OP_Return has occurred for all OP_Gosubs, then
+** processing aborts with a fatal error.
+*/
+case OP_Return: {
+  assert( p->returnDepth>0 );
+  p->returnDepth--;
+  pc = p->returnStack[p->returnDepth] - 1;
+  break;
+}
+
+/* Opcode:  Halt P1 P2 * P4 *
+**
+** Exit immediately.  All open cursors, Fifos, etc are closed
+** automatically.
+**
+** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
+** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).
+** For errors, it can be some other value.  If P1!=0 then P2 will determine
+** whether or not to rollback the current transaction.  Do not rollback
+** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
+** then back out all changes that have occurred during this execution of the
+** VDBE, but do not rollback the transaction. 
+**
+** If P4 is not null then it is an error message string.
+**
+** There is an implied "Halt 0 0 0" instruction inserted at the very end of
+** every program.  So a jump past the last instruction of the program
+** is the same as executing Halt.
+*/
+case OP_Halt: {
+  p->rc = pOp->p1;
+  p->pc = pc;
+  p->errorAction = pOp->p2;
+  if( pOp->p4.z ){
+    sqlite3SetString(&p->zErrMsg, pOp->p4.z, (char*)0);
+  }
+  rc = sqlite3VdbeHalt(p);
+  assert( rc==SQLITE_BUSY || rc==SQLITE_OK );
+  if( rc==SQLITE_BUSY ){
+    p->rc = rc = SQLITE_BUSY;
+  }else{
+    rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
+  }
+  goto vdbe_return;
+}
+
+/* Opcode: Integer P1 P2 * * *
+**
+** The 32-bit integer value P1 is written into register P2.
+*/
+case OP_Integer: {         /* out2-prerelease */
+  pOut->flags = MEM_Int;
+  pOut->u.i = pOp->p1;
+  break;
+}
+
+/* Opcode: Int64 * P2 * P4 *
+**
+** P4 is a pointer to a 64-bit integer value.
+** Write that value into register P2.
+*/
+case OP_Int64: {           /* out2-prerelease */
+  assert( pOp->p4.pI64!=0 );
+  pOut->flags = MEM_Int;
+  pOut->u.i = *pOp->p4.pI64;
+  break;
+}
+
+/* Opcode: Real * P2 * P4 *
+**
+** P4 is a pointer to a 64-bit floating point value.
+** Write that value into register P2.
+*/
+case OP_Real: {            /* same as TK_FLOAT, out2-prerelease */
+  pOut->flags = MEM_Real;
+  pOut->r = *pOp->p4.pReal;
+  break;
+}
+
+/* Opcode: String8 * P2 * P4 *
+**
+** P4 points to a nul terminated UTF-8 string. This opcode is transformed 
+** into an OP_String before it is executed for the first time.
+*/
+case OP_String8: {         /* same as TK_STRING, out2-prerelease */
+  assert( pOp->p4.z!=0 );
+  pOp->opcode = OP_String;
+  pOp->p1 = strlen(pOp->p4.z);
+
+#ifndef SQLITE_OMIT_UTF16
+  if( encoding!=SQLITE_UTF8 ){
+    sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
+    if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
+    if( SQLITE_OK!=sqlite3VdbeMemDynamicify(pOut) ) goto no_mem;
+    pOut->flags &= ~(MEM_Dyn);
+    pOut->flags |= MEM_Static;
+    if( pOp->p4type==P4_DYNAMIC ){
+      sqlite3_free(pOp->p4.z);
+    }
+    pOp->p4type = P4_DYNAMIC;
+    pOp->p4.z = pOut->z;
+    pOp->p1 = pOut->n;
+    if( pOp->p1>SQLITE_MAX_LENGTH ){
+      goto too_big;
+    }
+    UPDATE_MAX_BLOBSIZE(pOut);
+    break;
+  }
+#endif
+  if( pOp->p1>SQLITE_MAX_LENGTH ){
+    goto too_big;
+  }
+  /* Fall through to the next case, OP_String */
+}
+  
+/* Opcode: String P1 P2 * P4 *
+**
+** The string value P4 of length P1 (bytes) is stored in register P2.
+*/
+case OP_String: {          /* out2-prerelease */
+  assert( pOp->p4.z!=0 );
+  pOut->flags = MEM_Str|MEM_Static|MEM_Term;
+  pOut->z = pOp->p4.z;
+  pOut->n = pOp->p1;
+  pOut->enc = encoding;
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: Null * P2 * * *
+**
+** Write a NULL into register P2.
+*/
+case OP_Null: {           /* out2-prerelease */
+  break;
+}
+
+
+#ifndef SQLITE_OMIT_BLOB_LITERAL
+/* Opcode: Blob P1 P2 * P4
+**
+** P4 points to a blob of data P1 bytes long.  Store this
+** blob in register P2. This instruction is not coded directly
+** by the compiler. Instead, the compiler layer specifies
+** an OP_HexBlob opcode, with the hex string representation of
+** the blob as P4. This opcode is transformed to an OP_Blob
+** the first time it is executed.
+*/
+case OP_Blob: {                /* out2-prerelease */
+  assert( pOp->p1 <= SQLITE_MAX_LENGTH );
+  sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
+  pOut->enc = encoding;
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+#endif /* SQLITE_OMIT_BLOB_LITERAL */
+
+/* Opcode: Variable P1 P2 * * *
+**
+** The value of variable P1 is written into register P2. A variable is
+** an unknown in the original SQL string as handed to sqlite3_compile().
+** Any occurance of the '?' character in the original SQL is considered
+** a variable.  Variables in the SQL string are number from left to
+** right beginning with 1.  The values of variables are set using the
+** sqlite3_bind() API.
+*/
+case OP_Variable: {           /* out2-prerelease */
+  int j = pOp->p1 - 1;
+  Mem *pVar;
+  assert( j>=0 && j<p->nVar );
+
+  pVar = &p->aVar[j];
+  if( sqlite3VdbeMemTooBig(pVar) ){
+    goto too_big;
+  }
+  sqlite3VdbeMemShallowCopy(pOut, &p->aVar[j], MEM_Static);
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: Move P1 P2 * * *
+**
+** Move the value in register P1 over into register P2.  Register P1
+** is left holding a NULL.  It is an error for P1 and P2 to be the
+** same register.
+*/
+/* Opcode: Copy P1 P2 * * *
+**
+** Make a copy of register P1 into register P2.
+**
+** This instruction makes a deep copy of the value.  A duplicate
+** is made of any string or blob constant.  See also OP_SCopy.
+*/
+/* Opcode: SCopy P1 P2 * * *
+**
+** Make a shallow copy of register P1 into register P2.
+**
+** This instruction makes a shallow copy of the value.  If the value
+** is a string or blob, then the copy is only a pointer to the
+** original and hence if the original changes so will the copy.
+** Worse, if the original is deallocated, the copy becomes invalid.
+** Thus the program must guarantee that the original will not change
+** during the lifetime of the copy.  Use OP_Copy to make a complete
+** copy.
+*/
+case OP_Move:
+case OP_Copy:
+case OP_SCopy: {
+  assert( pOp->p1>0 );
+  assert( pOp->p1<=p->nMem );
+  pIn1 = &p->aMem[pOp->p1];
+  REGISTER_TRACE(pOp->p1, pIn1);
+  assert( pOp->p2>0 );
+  assert( pOp->p2<=p->nMem );
+  pOut = &p->aMem[pOp->p2];
+  assert( pOut!=pIn1 );
+  if( pOp->opcode==OP_Move ){
+    sqlite3VdbeMemMove(pOut, pIn1);
+  }else{
+    sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
+    if( pOp->opcode==OP_Copy ){
+      Deephemeralize(pOut);
+    }
+  }
+  REGISTER_TRACE(pOp->p2, pOut);
+  break;
+}
+
+/* Opcode: ResultRow P1 P2 * * *
+**
+** The registers P1 throught P1+P2-1 contain a single row of
+** results. This opcode causes the sqlite3_step() call to terminate
+** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
+** structure to provide access to the top P1 values as the result
+** row.
+*/
+case OP_ResultRow: {
+  Mem *pMem;
+  int i;
+  assert( p->nResColumn==pOp->p2 );
+  assert( pOp->p1>0 );
+  assert( pOp->p1+pOp->p2<=p->nMem );
+
+  /* Invalidate all ephemeral cursor row caches */
+  p->cacheCtr = (p->cacheCtr + 2)|1;
+
+  /* Make sure the results of the current row are \000 terminated
+  ** and have an assigned type.  The results are deephemeralized as
+  ** as side effect.
+  */
+  pMem = p->pResultSet = &p->aMem[pOp->p1];
+  for(i=0; i<pOp->p2; i++){
+    sqlite3VdbeMemNulTerminate(&pMem[i]);
+    storeTypeInfo(&pMem[i], encoding);
+  }
+
+  /* Return SQLITE_ROW
+  */
+  p->nCallback++;
+  p->pc = pc + 1;
+  rc = SQLITE_ROW;
+  goto vdbe_return;
+}
+
+/* Opcode: Concat P1 P2 P3 * *
+**
+** Add the text in register P1 onto the end of the text in
+** register P2 and store the result in register P3.
+** If either the P1 or P2 text are NULL then store NULL in P3.
+*/
+case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
+  char *zNew;
+  i64 nByte;
+
+  if( (pIn1->flags | pIn2->flags) & MEM_Null ){
+    Release(pOut);
+    pOut->flags = MEM_Null;
+    break;
+  }
+  ExpandBlob(pIn1);
+  Stringify(pIn1, encoding);
+  ExpandBlob(pIn2);
+  Stringify(pIn2, encoding);
+  nByte = pIn1->n + pIn2->n;
+  if( nByte>SQLITE_MAX_LENGTH ){
+    goto too_big;
+  }
+  zNew = sqlite3DbMallocRaw(db, nByte+2);
+  if( zNew==0 ){
+    goto no_mem;
+  }
+  memcpy(zNew, pIn2->z, pIn2->n);
+  memcpy(&zNew[pIn2->n], pIn1->z, pIn1->n);
+  zNew[nByte] = 0;
+  zNew[nByte+1] = 0;
+  Release(pOut);
+  pOut->n = nByte;
+  pOut->flags = MEM_Str|MEM_Dyn|MEM_Term;
+  pOut->xDel = 0;
+  pOut->enc = encoding;
+  pOut->z = zNew;
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: Add P1 P2 P3 * *
+**
+** Add the value in register P1 to the value in register P2
+** and store the result in regiser P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: Multiply P1 P2 P3 * *
+**
+**
+** Multiply the value in regiser P1 by the value in regiser P2
+** and store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: Subtract P1 P2 P3 * *
+**
+** Subtract the value in register P1 from the value in register P2
+** and store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: Divide P1 P2 P3 * *
+**
+** Divide the value in register P1 by the value in register P2
+** and store the result in register P3.  If the value in register P2
+** is zero, then the result is NULL.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: Remainder P1 P2 P3 * *
+**
+** Compute the remainder after integer division of the value in
+** register P1 by the value in register P2 and store the result in P3. 
+** If the value in register P2 is zero the result is NULL.
+** If either operand is NULL, the result is NULL.
+*/
+case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
+case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
+case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
+case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
+case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
+  int flags;
+  flags = pIn1->flags | pIn2->flags;
+  if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
+  if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
+    i64 a, b;
+    a = pIn1->u.i;
+    b = pIn2->u.i;
+    switch( pOp->opcode ){
+      case OP_Add:         b += a;       break;
+      case OP_Subtract:    b -= a;       break;
+      case OP_Multiply:    b *= a;       break;
+      case OP_Divide: {
+        if( a==0 ) goto arithmetic_result_is_null;
+        /* Dividing the largest possible negative 64-bit integer (1<<63) by 
+        ** -1 returns an integer to large to store in a 64-bit data-type. On
+        ** some architectures, the value overflows to (1<<63). On others,
+        ** a SIGFPE is issued. The following statement normalizes this
+        ** behaviour so that all architectures behave as if integer 
+        ** overflow occured.
+        */
+        if( a==-1 && b==(((i64)1)<<63) ) a = 1;
+        b /= a;
+        break;
+      }
+      default: {
+        if( a==0 ) goto arithmetic_result_is_null;
+        if( a==-1 ) a = 1;
+        b %= a;
+        break;
+      }
+    }
+    Release(pOut);
+    pOut->u.i = b;
+    pOut->flags = MEM_Int;
+  }else{
+    double a, b;
+    a = sqlite3VdbeRealValue(pIn1);
+    b = sqlite3VdbeRealValue(pIn2);
+    switch( pOp->opcode ){
+      case OP_Add:         b += a;       break;
+      case OP_Subtract:    b -= a;       break;
+      case OP_Multiply:    b *= a;       break;
+      case OP_Divide: {
+        if( a==0.0 ) goto arithmetic_result_is_null;
+        b /= a;
+        break;
+      }
+      default: {
+        i64 ia = (i64)a;
+        i64 ib = (i64)b;
+        if( ia==0 ) goto arithmetic_result_is_null;
+        if( ia==-1 ) ia = 1;
+        b = ib % ia;
+        break;
+      }
+    }
+    if( sqlite3_isnan(b) ){
+      goto arithmetic_result_is_null;
+    }
+    Release(pOut);
+    pOut->r = b;
+    pOut->flags = MEM_Real;
+    if( (flags & MEM_Real)==0 ){
+      sqlite3VdbeIntegerAffinity(pOut);
+    }
+  }
+  break;
+
+arithmetic_result_is_null:
+  sqlite3VdbeMemSetNull(pOut);
+  break;
+}
+
+/* Opcode: CollSeq * * P4
+**
+** P4 is a pointer to a CollSeq struct. If the next call to a user function
+** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
+** be returned. This is used by the built-in min(), max() and nullif()
+** functions.
+**
+** The interface used by the implementation of the aforementioned functions
+** to retrieve the collation sequence set by this opcode is not available
+** publicly, only to user functions defined in func.c.
+*/
+case OP_CollSeq: {
+  assert( pOp->p4type==P4_COLLSEQ );
+  break;
+}
+
+/* Opcode: Function P1 P2 P3 P4 P5
+**
+** Invoke a user function (P4 is a pointer to a Function structure that
+** defines the function) with P5 arguments taken from register P2 and
+** successors.  The result of the function is stored in register P3.
+**
+** P1 is a 32-bit bitmask indicating whether or not each argument to the 
+** function was determined to be constant at compile time. If the first
+** argument was constant then bit 0 of P1 is set. This is used to determine
+** whether meta data associated with a user function argument using the
+** sqlite3_set_auxdata() API may be safely retained until the next
+** invocation of this opcode.
+**
+** See also: AggStep and AggFinal
+*/
+case OP_Function: {
+  int i;
+  Mem *pArg;
+  sqlite3_context ctx;
+  sqlite3_value **apVal;
+  int n = pOp->p5;
+
+  apVal = p->apArg;
+  assert( apVal || n==0 );
+
+  assert( n==0 || (pOp->p2>0 && pOp->p2+n<=p->nMem) );
+  pArg = &p->aMem[pOp->p2];
+  for(i=0; i<n; i++, pArg++){
+    apVal[i] = pArg;
+    storeTypeInfo(pArg, encoding);
+    REGISTER_TRACE(pOp->p2, pArg);
+  }
+
+  assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
+  if( pOp->p4type==P4_FUNCDEF ){
+    ctx.pFunc = pOp->p4.pFunc;
+    ctx.pVdbeFunc = 0;
+  }else{
+    ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;
+    ctx.pFunc = ctx.pVdbeFunc->pFunc;
+  }
+
+  ctx.s.flags = MEM_Null;
+  ctx.s.z = 0;
+  ctx.s.xDel = 0;
+  ctx.s.db = db;
+  ctx.isError = 0;
+  if( ctx.pFunc->needCollSeq ){
+    assert( pOp>p->aOp );
+    assert( pOp[-1].p4type==P4_COLLSEQ );
+    assert( pOp[-1].opcode==OP_CollSeq );
+    ctx.pColl = pOp[-1].p4.pColl;
+  }
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  (*ctx.pFunc->xFunc)(&ctx, n, apVal);
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+  if( db->mallocFailed ){
+    /* Even though a malloc() has failed, the implementation of the
+    ** user function may have called an sqlite3_result_XXX() function
+    ** to return a value. The following call releases any resources
+    ** associated with such a value.
+    **
+    ** Note: Maybe MemRelease() should be called if sqlite3SafetyOn()
+    ** fails also (the if(...) statement above). But if people are
+    ** misusing sqlite, they have bigger problems than a leaked value.
+    */
+    sqlite3VdbeMemRelease(&ctx.s);
+    goto no_mem;
+  }
+
+  /* If any auxilary data functions have been called by this user function,
+  ** immediately call the destructor for any non-static values.
+  */
+  if( ctx.pVdbeFunc ){
+    sqlite3VdbeDeleteAuxData(ctx.pVdbeFunc, pOp->p1);
+    pOp->p4.pVdbeFunc = ctx.pVdbeFunc;
+    pOp->p4type = P4_VDBEFUNC;
+  }
+
+  /* If the function returned an error, throw an exception */
+  if( ctx.isError ){
+    sqlite3SetString(&p->zErrMsg, sqlite3_value_text(&ctx.s), (char*)0);
+    rc = ctx.isError;
+  }
+
+  /* Copy the result of the function into register P3 */
+  sqlite3VdbeChangeEncoding(&ctx.s, encoding);
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  pOut = &p->aMem[pOp->p3];
+  sqlite3VdbeMemMove(pOut, &ctx.s);
+  if( sqlite3VdbeMemTooBig(pOut) ){
+    goto too_big;
+  }
+  REGISTER_TRACE(pOp->p3, pOut);
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: BitAnd P1 P2 P3 * *
+**
+** Take the bit-wise AND of the values in register P1 and P2 and
+** store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: BitOr P1 P2 P3 * *
+**
+** Take the bit-wise OR of the values in register P1 and P2 and
+** store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: ShiftLeft P1 P2 P3 * *
+**
+** Shift the integer value in register P2 to the left by the
+** number of bits specified by the integer in regiser P1.
+** Store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+/* Opcode: ShiftRight P1 P2 P3 * *
+**
+** Shift the integer value in register P2 to the right by the
+** number of bits specified by the integer in register P1.
+** Store the result in register P3.
+** If either input is NULL, the result is NULL.
+*/
+case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
+case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
+case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
+case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
+  i64 a, b;
+
+  if( (pIn1->flags | pIn2->flags) & MEM_Null ){
+    sqlite3VdbeMemSetNull(pOut);
+    break;
+  }
+  a = sqlite3VdbeIntValue(pIn2);
+  b = sqlite3VdbeIntValue(pIn1);
+  switch( pOp->opcode ){
+    case OP_BitAnd:      a &= b;     break;
+    case OP_BitOr:       a |= b;     break;
+    case OP_ShiftLeft:   a <<= b;    break;
+    default:  assert( pOp->opcode==OP_ShiftRight );
+                         a >>= b;    break;
+  }
+  Release(pOut);
+  pOut->u.i = a;
+  pOut->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: AddImm  P1 P2 * * *
+** 
+** Add the constant P2 the value in register P1.
+** The result is always an integer.
+**
+** To force any register to be an integer, just add 0.
+*/
+case OP_AddImm: {            /* in1 */
+  sqlite3VdbeMemIntegerify(pIn1);
+  pIn1->u.i += pOp->p2;
+  break;
+}
+
+/* Opcode: ForceInt P1 P2 P3 * *
+**
+** Convert value in register P1 into an integer.  If the value 
+** in P1 is not numeric (meaning that is is a NULL or a string that
+** does not look like an integer or floating point number) then
+** jump to P2.  If the value in P1 is numeric then
+** convert it into the least integer that is greater than or equal to its
+** current value if P3==0, or to the least integer that is strictly
+** greater than its current value if P3==1.
+*/
+case OP_ForceInt: {            /* jump, in1 */
+  i64 v;
+  applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
+  if( (pIn1->flags & (MEM_Int|MEM_Real))==0 ){
+    pc = pOp->p2 - 1;
+    break;
+  }
+  if( pIn1->flags & MEM_Int ){
+    v = pIn1->u.i + (pOp->p3!=0);
+  }else{
+    assert( pIn1->flags & MEM_Real );
+    v = (sqlite3_int64)pIn1->r;
+    if( pIn1->r>(double)v ) v++;
+    if( pOp->p3 && pIn1->r==(double)v ) v++;
+  }
+  Release(pIn1);
+  pIn1->u.i = v;
+  pIn1->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: MustBeInt P1 P2 * * *
+** 
+** Force the value in register P1 to be an integer.  If the value
+** in P1 is not an integer and cannot be converted into an integer
+** without data loss, then jump immediately to P2, or if P2==0
+** raise an SQLITE_MISMATCH exception.
+*/
+case OP_MustBeInt: {            /* jump, in1 */
+  applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
+  if( (pIn1->flags & MEM_Int)==0 ){
+    if( pOp->p2==0 ){
+      rc = SQLITE_MISMATCH;
+      goto abort_due_to_error;
+    }else{
+      pc = pOp->p2 - 1;
+    }
+  }else{
+    Release(pIn1);
+    pIn1->flags = MEM_Int;
+  }
+  break;
+}
+
+/* Opcode: RealAffinity P1 * * * *
+**
+** If register P1 holds an integer convert it to a real value.
+**
+** This opcode is used when extracting information from a column that
+** has REAL affinity.  Such column values may still be stored as
+** integers, for space efficiency, but after extraction we want them
+** to have only a real value.
+*/
+case OP_RealAffinity: {                  /* in1 */
+  if( pIn1->flags & MEM_Int ){
+    sqlite3VdbeMemRealify(pIn1);
+  }
+  break;
+}
+
+#ifndef SQLITE_OMIT_CAST
+/* Opcode: ToText P1 * * * *
+**
+** Force the value in register P1 to be text.
+** If the value is numeric, convert it to a string using the
+** equivalent of printf().  Blob values are unchanged and
+** are afterwards simply interpreted as text.
+**
+** A NULL value is not changed by this routine.  It remains NULL.
+*/
+case OP_ToText: {                  /* same as TK_TO_TEXT, in1 */
+  if( pIn1->flags & MEM_Null ) break;
+  assert( MEM_Str==(MEM_Blob>>3) );
+  pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
+  applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
+  rc = ExpandBlob(pIn1);
+  assert( pIn1->flags & MEM_Str );
+  pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob);
+  UPDATE_MAX_BLOBSIZE(pIn1);
+  break;
+}
+
+/* Opcode: ToBlob P1 * * * *
+**
+** Force the value in register P1 to be a BLOB.
+** If the value is numeric, convert it to a string first.
+** Strings are simply reinterpreted as blobs with no change
+** to the underlying data.
+**
+** A NULL value is not changed by this routine.  It remains NULL.
+*/
+case OP_ToBlob: {                  /* same as TK_TO_BLOB, in1 */
+  if( pIn1->flags & MEM_Null ) break;
+  if( (pIn1->flags & MEM_Blob)==0 ){
+    applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
+    assert( pIn1->flags & MEM_Str );
+    pIn1->flags |= MEM_Blob;
+  }
+  pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Str);
+  UPDATE_MAX_BLOBSIZE(pIn1);
+  break;
+}
+
+/* Opcode: ToNumeric P1 * * * *
+**
+** Force the value in register P1 to be numeric (either an
+** integer or a floating-point number.)
+** If the value is text or blob, try to convert it to an using the
+** equivalent of atoi() or atof() and store 0 if no such conversion 
+** is possible.
+**
+** A NULL value is not changed by this routine.  It remains NULL.
+*/
+case OP_ToNumeric: {                  /* same as TK_TO_NUMERIC, in1 */
+  if( (pIn1->flags & (MEM_Null|MEM_Int|MEM_Real))==0 ){
+    sqlite3VdbeMemNumerify(pIn1);
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_CAST */
+
+/* Opcode: ToInt P1 * * * *
+**
+** Force the value in register P1 be an integer.  If
+** The value is currently a real number, drop its fractional part.
+** If the value is text or blob, try to convert it to an integer using the
+** equivalent of atoi() and store 0 if no such conversion is possible.
+**
+** A NULL value is not changed by this routine.  It remains NULL.
+*/
+case OP_ToInt: {                  /* same as TK_TO_INT, in1 */
+  if( (pIn1->flags & MEM_Null)==0 ){
+    sqlite3VdbeMemIntegerify(pIn1);
+  }
+  break;
+}
+
+#ifndef SQLITE_OMIT_CAST
+/* Opcode: ToReal P1 * * * *
+**
+** Force the value in register P1 to be a floating point number.
+** If The value is currently an integer, convert it.
+** If the value is text or blob, try to convert it to an integer using the
+** equivalent of atoi() and store 0.0 if no such conversion is possible.
+**
+** A NULL value is not changed by this routine.  It remains NULL.
+*/
+case OP_ToReal: {                  /* same as TK_TO_REAL, in1 */
+  if( (pIn1->flags & MEM_Null)==0 ){
+    sqlite3VdbeMemRealify(pIn1);
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_CAST */
+
+/* Opcode: Lt P1 P2 P3 P4 P5
+**
+** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
+** jump to address P2.  
+**
+** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
+** reg(P3) is NULL then take the jump.  If the SQLITE_JUMPIFNULL 
+** bit is clear then fall thru if either operand is NULL.
+**
+** If the SQLITE_NULLEQUAL bit of P5 is set then treat NULL operands
+** as being equal to one another.  Normally NULLs are not equal to 
+** anything including other NULLs.
+**
+** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
+** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
+** to coerce both inputs according to this affinity before the
+** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
+** affinity is used. Note that the affinity conversions are stored
+** back into the input registers P1 and P3.  So this opcode can cause
+** persistent changes to registers P1 and P3.
+**
+** Once any conversions have taken place, and neither value is NULL, 
+** the values are compared. If both values are blobs then memcmp() is
+** used to determine the results of the comparison.  If both values
+** are text, then the appropriate collating function specified in
+** P4 is  used to do the comparison.  If P4 is not specified then
+** memcmp() is used to compare text string.  If both values are
+** numeric, then a numeric comparison is used. If the two values
+** are of different types, then numbers are considered less than
+** strings and strings are considered less than blobs.
+**
+** If the SQLITE_STOREP2 bit of P5 is set, then do not jump.  Instead,
+** store a boolean result (either 0, or 1, or NULL) in register P2.
+*/
+/* Opcode: Ne P1 P2 P3 P4 P5
+**
+** This works just like the Lt opcode except that the jump is taken if
+** the operands in registers P1 and P3 are not equal.  See the Lt opcode for
+** additional information.
+*/
+/* Opcode: Eq P1 P2 P3 P4 P5
+**
+** This works just like the Lt opcode except that the jump is taken if
+** the operands in registers P1 and P3 are equal.
+** See the Lt opcode for additional information.
+*/
+/* Opcode: Le P1 P2 P3 P4 P5
+**
+** This works just like the Lt opcode except that the jump is taken if
+** the content of register P3 is less than or equal to the content of
+** register P1.  See the Lt opcode for additional information.
+*/
+/* Opcode: Gt P1 P2 P3 P4 P5
+**
+** This works just like the Lt opcode except that the jump is taken if
+** the content of register P3 is greater than the content of
+** register P1.  See the Lt opcode for additional information.
+*/
+/* Opcode: Ge P1 P2 P3 P4 P5
+**
+** This works just like the Lt opcode except that the jump is taken if
+** the content of register P3 is greater than or equal to the content of
+** register P1.  See the Lt opcode for additional information.
+*/
+case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
+case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
+case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
+case OP_Le:               /* same as TK_LE, jump, in1, in3 */
+case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
+case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
+  int flags;
+  int res;
+  char affinity;
+  Mem x1, x3;
+
+  flags = pIn1->flags|pIn3->flags;
+
+  if( flags&MEM_Null ){
+    if( (pOp->p5 & SQLITE_NULLEQUAL)!=0 ){
+      /*
+      ** When SQLITE_NULLEQUAL set and either operand is NULL
+      ** then both operands are converted to integers prior to being 
+      ** passed down into the normal comparison logic below.  
+      ** NULL operands are converted to zero and non-NULL operands
+      ** are converted to 1.  Thus, for example, with SQLITE_NULLEQUAL
+      ** set,  NULL==NULL is true whereas it would normally NULL.
+      ** Similarly,  NULL!=123 is true.
+      */
+      x1.flags = MEM_Int;
+      x1.u.i = (pIn1->flags & MEM_Null)==0;
+      pIn1 = &x1;
+      x3.flags = MEM_Int;
+      x3.u.i = (pIn3->flags & MEM_Null)==0;
+      pIn3 = &x3;
+    }else{
+      /* If the SQLITE_NULLEQUAL bit is clear and either operand is NULL then
+      ** the result is always NULL.  The jump is taken if the 
+      ** SQLITE_JUMPIFNULL bit is set.
+      */
+      if( pOp->p5 & SQLITE_STOREP2 ){
+        pOut = &p->aMem[pOp->p2];
+        Release(pOut);
+        pOut->flags = MEM_Null;
+        REGISTER_TRACE(pOp->p2, pOut);
+      }else if( pOp->p5 & SQLITE_JUMPIFNULL ){
+        pc = pOp->p2-1;
+      }
+      break;
+    }
+  }
+
+  affinity = pOp->p5 & SQLITE_AFF_MASK;
+  if( affinity ){
+    applyAffinity(pIn1, affinity, encoding);
+    applyAffinity(pIn3, affinity, encoding);
+  }
+
+  assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
+  ExpandBlob(pIn1);
+  ExpandBlob(pIn3);
+  res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
+  switch( pOp->opcode ){
+    case OP_Eq:    res = res==0;     break;
+    case OP_Ne:    res = res!=0;     break;
+    case OP_Lt:    res = res<0;      break;
+    case OP_Le:    res = res<=0;     break;
+    case OP_Gt:    res = res>0;      break;
+    default:       res = res>=0;     break;
+  }
+
+  if( pOp->p5 & SQLITE_STOREP2 ){
+    pOut = &p->aMem[pOp->p2];
+    Release(pOut);
+    pOut->flags = MEM_Int;
+    pOut->u.i = res;
+    REGISTER_TRACE(pOp->p2, pOut);
+  }else if( res ){
+    pc = pOp->p2-1;
+  }
+  break;
+}
+
+/* Opcode: And P1 P2 P3 * *
+**
+** Take the logical AND of the values in registers P1 and P2 and
+** write the result into register P3.
+**
+** If either P1 or P2 is 0 (false) then the result is 0 even if
+** the other input is NULL.  A NULL and true or two NULLs give
+** a NULL output.
+*/
+/* Opcode: Or P1 P2 P3 * *
+**
+** Take the logical OR of the values in register P1 and P2 and
+** store the answer in register P3.
+**
+** If either P1 or P2 is nonzero (true) then the result is 1 (true)
+** even if the other input is NULL.  A NULL and false or two NULLs
+** give a NULL output.
+*/
+case OP_And:              /* same as TK_AND, in1, in2, out3 */
+case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
+  int v1, v2;    /* 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
+
+  if( pIn1->flags & MEM_Null ){
+    v1 = 2;
+  }else{
+    v1 = sqlite3VdbeIntValue(pIn1)!=0;
+  }
+  if( pIn2->flags & MEM_Null ){
+    v2 = 2;
+  }else{
+    v2 = sqlite3VdbeIntValue(pIn2)!=0;
+  }
+  if( pOp->opcode==OP_And ){
+    static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
+    v1 = and_logic[v1*3+v2];
+  }else{
+    static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
+    v1 = or_logic[v1*3+v2];
+  }
+  Release(pOut);
+  if( v1==2 ){
+    pOut->flags = MEM_Null;
+  }else{
+    pOut->u.i = v1;
+    pOut->flags = MEM_Int;
+  }
+  break;
+}
+
+/* Opcode: Not P1 * * * *
+**
+** Interpret the value in register P1 as a boolean value.  Replace it
+** with its complement.  If the value in register P1 is NULL its value
+** is unchanged.
+*/
+case OP_Not: {                /* same as TK_NOT, in1 */
+  if( pIn1->flags & MEM_Null ) break;  /* Do nothing to NULLs */
+  sqlite3VdbeMemIntegerify(pIn1);
+  pIn1->u.i = !pIn1->u.i;
+  assert( pIn1->flags==MEM_Int );
+  break;
+}
+
+/* Opcode: BitNot P1 * * * *
+**
+** Interpret the content of register P1 as an integer.  Replace it
+** with its ones-complement.  If the value is originally NULL, leave
+** it unchanged.
+*/
+case OP_BitNot: {             /* same as TK_BITNOT, in1 */
+  if( pIn1->flags & MEM_Null ) break;  /* Do nothing to NULLs */
+  sqlite3VdbeMemIntegerify(pIn1);
+  pIn1->u.i = ~pIn1->u.i;
+  assert( pIn1->flags==MEM_Int );
+  break;
+}
+
+/* Opcode: If P1 P2 P3 * *
+**
+** Jump to P2 if the value in register P1 is true.  The value is
+** is considered true if it is numeric and non-zero.  If the value
+** in P1 is NULL then take the jump if P3 is true.
+*/
+/* Opcode: IfNot P1 P2 P3 * *
+**
+** Jump to P2 if the value in register P1 is False.  The value is
+** is considered true if it has a numeric value of zero.  If the value
+** in P1 is NULL then take the jump if P3 is true.
+*/
+case OP_If:                 /* jump, in1 */
+case OP_IfNot: {            /* jump, in1 */
+  int c;
+  if( pIn1->flags & MEM_Null ){
+    c = pOp->p3;
+  }else{
+#ifdef SQLITE_OMIT_FLOATING_POINT
+    c = sqlite3VdbeIntValue(pIn1);
+#else
+    c = sqlite3VdbeRealValue(pIn1)!=0.0;
+#endif
+    if( pOp->opcode==OP_IfNot ) c = !c;
+  }
+  if( c ){
+    pc = pOp->p2-1;
+  }
+  break;
+}
+
+/* Opcode: IsNull P1 P2 P3 * *
+**
+** Jump to P2 if the value in register P1 is NULL.  If P3 is greater
+** than zero, then check all values reg(P1), reg(P1+1), 
+** reg(P1+2), ..., reg(P1+P3-1).
+*/
+case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
+  int n = pOp->p3;
+  assert( pOp->p3==0 || pOp->p1>0 );
+  do{
+    if( (pIn1->flags & MEM_Null)!=0 ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+    pIn1++;
+  }while( --n > 0 );
+  break;
+}
+
+/* Opcode: NotNull P1 P2 * * *
+**
+** Jump to P2 if the value in register P1 is not NULL.  
+*/
+case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
+  if( (pIn1->flags & MEM_Null)==0 ){
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: SetNumColumns P1 P2 * * *
+**
+** Before the OP_Column opcode can be executed on a cursor, this
+** opcode must be called to set the number of fields in the table.
+**
+** This opcode sets the number of columns for cursor P1 to P2.
+**
+** If OP_KeyAsData is to be applied to cursor P1, it must be executed
+** before this op-code.
+*/
+case OP_SetNumColumns: {
+  Cursor *pC;
+  assert( (pOp->p1)<p->nCursor );
+  assert( p->apCsr[pOp->p1]!=0 );
+  pC = p->apCsr[pOp->p1];
+  pC->nField = pOp->p2;
+  break;
+}
+
+/* Opcode: Column P1 P2 P3 P4 *
+**
+** Interpret the data that cursor P1 points to as a structure built using
+** the MakeRecord instruction.  (See the MakeRecord opcode for additional
+** information about the format of the data.)  Extract the P2-th column
+** from this record.  If there are less that (P2+1) 
+** values in the record, extract a NULL.
+**
+** The value extracted is stored in register P3.
+**
+** If the KeyAsData opcode has previously executed on this cursor, then the
+** field might be extracted from the key rather than the data.
+**
+** If the column contains fewer than P2 fields, then extract a NULL.  Or,
+** if the P4 argument is a P4_MEM use the value of the P4 argument as
+** the result.
+*/
+case OP_Column: {
+  u32 payloadSize;   /* Number of bytes in the record */
+  int p1 = pOp->p1;  /* P1 value of the opcode */
+  int p2 = pOp->p2;  /* column number to retrieve */
+  Cursor *pC = 0;    /* The VDBE cursor */
+  char *zRec;        /* Pointer to complete record-data */
+  BtCursor *pCrsr;   /* The BTree cursor */
+  u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
+  u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
+  u32 nField;        /* number of fields in the record */
+  int len;           /* The length of the serialized data for the column */
+  int i;             /* Loop counter */
+  char *zData;       /* Part of the record being decoded */
+  Mem *pDest;        /* Where to write the extracted value */
+  Mem sMem;          /* For storing the record being decoded */
+
+  sMem.flags = 0;
+  assert( p1<p->nCursor );
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  pDest = &p->aMem[pOp->p3];
+  sqlite3VdbeMemSetNull(pDest);
+
+  /* This block sets the variable payloadSize to be the total number of
+  ** bytes in the record.
+  **
+  ** zRec is set to be the complete text of the record if it is available.
+  ** The complete record text is always available for pseudo-tables
+  ** If the record is stored in a cursor, the complete record text
+  ** might be available in the  pC->aRow cache.  Or it might not be.
+  ** If the data is unavailable,  zRec is set to NULL.
+  **
+  ** We also compute the number of columns in the record.  For cursors,
+  ** the number of columns is stored in the Cursor.nField element.
+  */
+  pC = p->apCsr[p1];
+  assert( pC!=0 );
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  assert( pC->pVtabCursor==0 );
+#endif
+  if( pC->pCursor!=0 ){
+    /* The record is stored in a B-Tree */
+    rc = sqlite3VdbeCursorMoveto(pC);
+    if( rc ) goto abort_due_to_error;
+    zRec = 0;
+    pCrsr = pC->pCursor;
+    if( pC->nullRow ){
+      payloadSize = 0;
+    }else if( pC->cacheStatus==p->cacheCtr ){
+      payloadSize = pC->payloadSize;
+      zRec = (char*)pC->aRow;
+    }else if( pC->isIndex ){
+      i64 payloadSize64;
+      sqlite3BtreeKeySize(pCrsr, &payloadSize64);
+      payloadSize = payloadSize64;
+    }else{
+      sqlite3BtreeDataSize(pCrsr, &payloadSize);
+    }
+    nField = pC->nField;
+  }else{
+    assert( pC->pseudoTable );
+    /* The record is the sole entry of a pseudo-table */
+    payloadSize = pC->nData;
+    zRec = pC->pData;
+    pC->cacheStatus = CACHE_STALE;
+    assert( payloadSize==0 || zRec!=0 );
+    nField = pC->nField;
+    pCrsr = 0;
+  }
+
+  /* If payloadSize is 0, then just store a NULL */
+  if( payloadSize==0 ){
+    assert( pDest->flags==MEM_Null );
+    goto op_column_out;
+  }
+  if( payloadSize>SQLITE_MAX_LENGTH ){
+    goto too_big;
+  }
+
+  assert( p2<nField );
+
+  /* Read and parse the table header.  Store the results of the parse
+  ** into the record header cache fields of the cursor.
+  */
+  if( pC->cacheStatus==p->cacheCtr ){
+    aType = pC->aType;
+    aOffset = pC->aOffset;
+  }else{
+    u8 *zIdx;        /* Index into header */
+    u8 *zEndHdr;     /* Pointer to first byte after the header */
+    u32 offset;      /* Offset into the data */
+    int szHdrSz;     /* Size of the header size field at start of record */
+    int avail;       /* Number of bytes of available data */
+
+    aType = pC->aType;
+    if( aType==0 ){
+      pC->aType = aType = sqlite3DbMallocRaw(db, 2*nField*sizeof(aType) );
+    }
+    if( aType==0 ){
+      goto no_mem;
+    }
+    pC->aOffset = aOffset = &aType[nField];
+    pC->payloadSize = payloadSize;
+    pC->cacheStatus = p->cacheCtr;
+
+    /* Figure out how many bytes are in the header */
+    if( zRec ){
+      zData = zRec;
+    }else{
+      if( pC->isIndex ){
+        zData = (char*)sqlite3BtreeKeyFetch(pCrsr, &avail);
+      }else{
+        zData = (char*)sqlite3BtreeDataFetch(pCrsr, &avail);
+      }
+      /* If KeyFetch()/DataFetch() managed to get the entire payload,
+      ** save the payload in the pC->aRow cache.  That will save us from
+      ** having to make additional calls to fetch the content portion of
+      ** the record.
+      */
+      if( avail>=payloadSize ){
+        zRec = zData;
+        pC->aRow = (u8*)zData;
+      }else{
+        pC->aRow = 0;
+      }
+    }
+    /* The following assert is true in all cases accept when
+    ** the database file has been corrupted externally.
+    **    assert( zRec!=0 || avail>=payloadSize || avail>=9 ); */
+    szHdrSz = GetVarint((u8*)zData, offset);
+
+    /* The KeyFetch() or DataFetch() above are fast and will get the entire
+    ** record header in most cases.  But they will fail to get the complete
+    ** record header if the record header does not fit on a single page
+    ** in the B-Tree.  When that happens, use sqlite3VdbeMemFromBtree() to
+    ** acquire the complete header text.
+    */
+    if( !zRec && avail<offset ){
+      rc = sqlite3VdbeMemFromBtree(pCrsr, 0, offset, pC->isIndex, &sMem);
+      if( rc!=SQLITE_OK ){
+        goto op_column_out;
+      }
+      zData = sMem.z;
+    }
+    zEndHdr = (u8 *)&zData[offset];
+    zIdx = (u8 *)&zData[szHdrSz];
+
+    /* Scan the header and use it to fill in the aType[] and aOffset[]
+    ** arrays.  aType[i] will contain the type integer for the i-th
+    ** column and aOffset[i] will contain the offset from the beginning
+    ** of the record to the start of the data for the i-th column
+    */
+    for(i=0; i<nField; i++){
+      if( zIdx<zEndHdr ){
+        aOffset[i] = offset;
+        zIdx += GetVarint(zIdx, aType[i]);
+        offset += sqlite3VdbeSerialTypeLen(aType[i]);
+      }else{
+        /* If i is less that nField, then there are less fields in this
+        ** record than SetNumColumns indicated there are columns in the
+        ** table. Set the offset for any extra columns not present in
+        ** the record to 0. This tells code below to store a NULL
+        ** instead of deserializing a value from the record.
+        */
+        aOffset[i] = 0;
+      }
+    }
+    Release(&sMem);
+    sMem.flags = MEM_Null;
+
+    /* If we have read more header data than was contained in the header,
+    ** or if the end of the last field appears to be past the end of the
+    ** record, then we must be dealing with a corrupt database.
+    */
+    if( zIdx>zEndHdr || offset>payloadSize ){
+      rc = SQLITE_CORRUPT_BKPT;
+      goto op_column_out;
+    }
+  }
+
+  /* Get the column information. If aOffset[p2] is non-zero, then 
+  ** deserialize the value from the record. If aOffset[p2] is zero,
+  ** then there are not enough fields in the record to satisfy the
+  ** request.  In this case, set the value NULL or to P4 if P4 is
+  ** a pointer to a Mem object.
+  */
+  if( aOffset[p2] ){
+    assert( rc==SQLITE_OK );
+    if( zRec ){
+      zData = &zRec[aOffset[p2]];
+    }else{
+      len = sqlite3VdbeSerialTypeLen(aType[p2]);
+      rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
+      if( rc!=SQLITE_OK ){
+        goto op_column_out;
+      }
+      zData = sMem.z;
+    }
+    sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);
+    pDest->enc = encoding;
+  }else{
+    if( pOp->p4type==P4_MEM ){
+      sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
+    }else{
+      assert( pDest->flags==MEM_Null );
+    }
+  }
+
+  /* If we dynamically allocated space to hold the data (in the
+  ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
+  ** dynamically allocated space over to the pDest structure.
+  ** This prevents a memory copy.
+  */
+  if( (sMem.flags & MEM_Dyn)!=0 ){
+    assert( pDest->flags & MEM_Ephem );
+    assert( pDest->flags & (MEM_Str|MEM_Blob) );
+    assert( pDest->z==sMem.z );
+    assert( sMem.flags & MEM_Term );
+    pDest->flags &= ~MEM_Ephem;
+    pDest->flags |= MEM_Dyn|MEM_Term;
+  }
+
+  /* pDest->z might be pointing to sMem.zShort[].  Fix that so that we
+  ** can abandon sMem */
+  rc = sqlite3VdbeMemMakeWriteable(pDest);
+
+op_column_out:
+  UPDATE_MAX_BLOBSIZE(pDest);
+  REGISTER_TRACE(pOp->p3, pDest);
+  break;
+}
+
+/* Opcode: MakeRecord P1 P2 P3 P4 *
+**
+** Convert P2 registers beginning with P1 into a single entry
+** suitable for use as a data record in a database table or as a key
+** in an index.  The details of the format are irrelavant as long as
+** the OP_Column opcode can decode the record later and as long as the
+** sqlite3VdbeRecordCompare function will correctly compare two encoded
+** records.  Refer to source code comments for the details of the record
+** format.
+**
+** P4 may be a string that is P1 characters long.  The nth character of the
+** string indicates the column affinity that should be used for the nth
+** field of the index key.
+**
+** The mapping from character to affinity is given by the SQLITE_AFF_
+** macros defined in sqliteInt.h.
+**
+** If P4 is NULL then all index fields have the affinity NONE.
+*/
+case OP_MakeRecord: {
+  /* Assuming the record contains N fields, the record format looks
+  ** like this:
+  **
+  ** ------------------------------------------------------------------------
+  ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 
+  ** ------------------------------------------------------------------------
+  **
+  ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
+  ** and so froth.
+  **
+  ** Each type field is a varint representing the serial type of the 
+  ** corresponding data element (see sqlite3VdbeSerialType()). The
+  ** hdr-size field is also a varint which is the offset from the beginning
+  ** of the record to data0.
+  */
+  u8 *zNewRecord;        /* A buffer to hold the data for the new record */
+  Mem *pRec;             /* The new record */
+  u64 nData = 0;         /* Number of bytes of data space */
+  int nHdr = 0;          /* Number of bytes of header space */
+  u64 nByte = 0;         /* Data space required for this record */
+  int nZero = 0;         /* Number of zero bytes at the end of the record */
+  int nVarint;           /* Number of bytes in a varint */
+  u32 serial_type;       /* Type field */
+  Mem *pData0;           /* First field to be combined into the record */
+  Mem *pLast;            /* Last field of the record */
+  int nField;            /* Number of fields in the record */
+  char *zAffinity;       /* The affinity string for the record */
+  int file_format;       /* File format to use for encoding */
+  int i;                 /* Space used in zNewRecord[] */
+  char zTemp[NBFS];      /* Space to hold small records */
+
+  nField = pOp->p1;
+  zAffinity = pOp->p4.z;
+  assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=p->nMem );
+  pData0 = &p->aMem[nField];
+  nField = pOp->p2;
+  pLast = &pData0[nField-1];
+  file_format = p->minWriteFileFormat;
+
+  /* Loop through the elements that will make up the record to figure
+  ** out how much space is required for the new record.
+  */
+  for(pRec=pData0; pRec<=pLast; pRec++){
+    int len;
+    if( zAffinity ){
+      applyAffinity(pRec, zAffinity[pRec-pData0], encoding);
+    }
+    if( pRec->flags&MEM_Zero && pRec->n>0 ){
+      sqlite3VdbeMemExpandBlob(pRec);
+    }
+    serial_type = sqlite3VdbeSerialType(pRec, file_format);
+    len = sqlite3VdbeSerialTypeLen(serial_type);
+    nData += len;
+    nHdr += sqlite3VarintLen(serial_type);
+    if( pRec->flags & MEM_Zero ){
+      /* Only pure zero-filled BLOBs can be input to this Opcode.
+      ** We do not allow blobs with a prefix and a zero-filled tail. */
+      nZero += pRec->u.i;
+    }else if( len ){
+      nZero = 0;
+    }
+  }
+
+  /* Add the initial header varint and total the size */
+  nHdr += nVarint = sqlite3VarintLen(nHdr);
+  if( nVarint<sqlite3VarintLen(nHdr) ){
+    nHdr++;
+  }
+  nByte = nHdr+nData-nZero;
+  if( nByte>SQLITE_MAX_LENGTH ){
+    goto too_big;
+  }
+
+  /* Allocate space for the new record. */
+  if( nByte>sizeof(zTemp) ){
+    zNewRecord = sqlite3DbMallocRaw(db, nByte);
+    if( !zNewRecord ){
+      goto no_mem;
+    }
+  }else{
+    zNewRecord = (u8*)zTemp;
+  }
+
+  /* Write the record */
+  i = sqlite3PutVarint(zNewRecord, nHdr);
+  for(pRec=pData0; pRec<=pLast; pRec++){
+    serial_type = sqlite3VdbeSerialType(pRec, file_format);
+    i += sqlite3PutVarint(&zNewRecord[i], serial_type);      /* serial type */
+  }
+  for(pRec=pData0; pRec<=pLast; pRec++){  /* serial data */
+    i += sqlite3VdbeSerialPut(&zNewRecord[i], nByte-i, pRec, file_format);
+  }
+  assert( i==nByte );
+
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  pOut = &p->aMem[pOp->p3];
+  Release(pOut);
+  pOut->n = nByte;
+  if( nByte<=sizeof(zTemp) ){
+    assert( zNewRecord==(unsigned char *)zTemp );
+    pOut->z = pOut->zShort;
+    memcpy(pOut->zShort, zTemp, nByte);
+    pOut->flags = MEM_Blob | MEM_Short;
+  }else{
+    assert( zNewRecord!=(unsigned char *)zTemp );
+    pOut->z = (char*)zNewRecord;
+    pOut->flags = MEM_Blob | MEM_Dyn;
+    pOut->xDel = 0;
+  }
+  if( nZero ){
+    pOut->u.i = nZero;
+    pOut->flags |= MEM_Zero;
+  }
+  pOut->enc = SQLITE_UTF8;  /* In case the blob is ever converted to text */
+  REGISTER_TRACE(pOp->p3, pOut);
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: Statement P1 * * * *
+**
+** Begin an individual statement transaction which is part of a larger
+** BEGIN..COMMIT transaction.  This is needed so that the statement
+** can be rolled back after an error without having to roll back the
+** entire transaction.  The statement transaction will automatically
+** commit when the VDBE halts.
+**
+** The statement is begun on the database file with index P1.  The main
+** database file has an index of 0 and the file used for temporary tables
+** has an index of 1.
+*/
+case OP_Statement: {
+  if( db->autoCommit==0 || db->activeVdbeCnt>1 ){
+    int i = pOp->p1;
+    Btree *pBt;
+    assert( i>=0 && i<db->nDb );
+    assert( db->aDb[i].pBt!=0 );
+    pBt = db->aDb[i].pBt;
+    assert( sqlite3BtreeIsInTrans(pBt) );
+    assert( (p->btreeMask & (1<<i))!=0 );
+    if( !sqlite3BtreeIsInStmt(pBt) ){
+      rc = sqlite3BtreeBeginStmt(pBt);
+      p->openedStatement = 1;
+    }
+  }
+  break;
+}
+
+/* Opcode: AutoCommit P1 P2 * * *
+**
+** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
+** back any currently active btree transactions. If there are any active
+** VMs (apart from this one), then the COMMIT or ROLLBACK statement fails.
+**
+** This instruction causes the VM to halt.
+*/
+case OP_AutoCommit: {
+  u8 i = pOp->p1;
+  u8 rollback = pOp->p2;
+
+  assert( i==1 || i==0 );
+  assert( i==1 || rollback==0 );
+
+  assert( db->activeVdbeCnt>0 );  /* At least this one VM is active */
+
+  if( db->activeVdbeCnt>1 && i && !db->autoCommit ){
+    /* If this instruction implements a COMMIT or ROLLBACK, other VMs are
+    ** still running, and a transaction is active, return an error indicating
+    ** that the other VMs must complete first. 
+    */
+    sqlite3SetString(&p->zErrMsg, "cannot ", rollback?"rollback":"commit", 
+        " transaction - SQL statements in progress", (char*)0);
+    rc = SQLITE_ERROR;
+  }else if( i!=db->autoCommit ){
+    if( pOp->p2 ){
+      assert( i==1 );
+      sqlite3RollbackAll(db);
+      db->autoCommit = 1;
+    }else{
+      db->autoCommit = i;
+      if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
+        p->pc = pc;
+        db->autoCommit = 1-i;
+        p->rc = rc = SQLITE_BUSY;
+        goto vdbe_return;
+      }
+    }
+    if( p->rc==SQLITE_OK ){
+      rc = SQLITE_DONE;
+    }else{
+      rc = SQLITE_ERROR;
+    }
+    goto vdbe_return;
+  }else{
+    sqlite3SetString(&p->zErrMsg,
+        (!i)?"cannot start a transaction within a transaction":(
+        (rollback)?"cannot rollback - no transaction is active":
+                   "cannot commit - no transaction is active"), (char*)0);
+         
+    rc = SQLITE_ERROR;
+  }
+  break;
+}
+
+/* Opcode: Transaction P1 P2 * * *
+**
+** Begin a transaction.  The transaction ends when a Commit or Rollback
+** opcode is encountered.  Depending on the ON CONFLICT setting, the
+** transaction might also be rolled back if an error is encountered.
+**
+** P1 is the index of the database file on which the transaction is
+** started.  Index 0 is the main database file and index 1 is the
+** file used for temporary tables.  Indices of 2 or more are used for
+** attached databases.
+**
+** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is
+** obtained on the database file when a write-transaction is started.  No
+** other process can start another write transaction while this transaction is
+** underway.  Starting a write transaction also creates a rollback journal. A
+** write transaction must be started before any changes can be made to the
+** database.  If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
+** on the file.
+**
+** If P2 is zero, then a read-lock is obtained on the database file.
+*/
+case OP_Transaction: {
+  int i = pOp->p1;
+  Btree *pBt;
+
+  assert( i>=0 && i<db->nDb );
+  assert( (p->btreeMask & (1<<i))!=0 );
+  pBt = db->aDb[i].pBt;
+
+  if( pBt ){
+    rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
+    if( rc==SQLITE_BUSY ){
+      p->pc = pc;
+      p->rc = rc = SQLITE_BUSY;
+      goto vdbe_return;
+    }
+    if( rc!=SQLITE_OK && rc!=SQLITE_READONLY /* && rc!=SQLITE_BUSY */ ){
+      goto abort_due_to_error;
+    }
+  }
+  break;
+}
+
+/* Opcode: ReadCookie P1 P2 P3 * *
+**
+** Read cookie number P3 from database P1 and write it into register P2.
+** P3==0 is the schema version.  P3==1 is the database format.
+** P3==2 is the recommended pager cache size, and so forth.  P1==0 is
+** the main database file and P1==1 is the database file used to store
+** temporary tables.
+**
+** If P1 is negative, then this is a request to read the size of a
+** databases free-list. P3 must be set to 1 in this case. The actual
+** database accessed is ((P1+1)*-1). For example, a P1 parameter of -1
+** corresponds to database 0 ("main"), a P1 of -2 is database 1 ("temp").
+**
+** There must be a read-lock on the database (either a transaction
+** must be started or there must be an open cursor) before
+** executing this instruction.
+*/
+case OP_ReadCookie: {               /* out2-prerelease */
+  int iMeta;
+  int iDb = pOp->p1;
+  int iCookie = pOp->p3;
+
+  assert( pOp->p3<SQLITE_N_BTREE_META );
+  if( iDb<0 ){
+    iDb = (-1*(iDb+1));
+    iCookie *= -1;
+  }
+  assert( iDb>=0 && iDb<db->nDb );
+  assert( db->aDb[iDb].pBt!=0 );
+  assert( (p->btreeMask & (1<<iDb))!=0 );
+  /* The indexing of meta values at the schema layer is off by one from
+  ** the indexing in the btree layer.  The btree considers meta[0] to
+  ** be the number of free pages in the database (a read-only value)
+  ** and meta[1] to be the schema cookie.  The schema layer considers
+  ** meta[1] to be the schema cookie.  So we have to shift the index
+  ** by one in the following statement.
+  */
+  rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, 1 + iCookie, (u32 *)&iMeta);
+  pOut->u.i = iMeta;
+  pOut->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: SetCookie P1 P2 P3 * *
+**
+** Write the content of register P3 (interpreted as an integer)
+** into cookie number P2 of database P1.
+** P2==0 is the schema version.  P2==1 is the database format.
+** P2==2 is the recommended pager cache size, and so forth.  P1==0 is
+** the main database file and P1==1 is the database file used to store
+** temporary tables.
+**
+** A transaction must be started before executing this opcode.
+*/
+case OP_SetCookie: {       /* in3 */
+  Db *pDb;
+  assert( pOp->p2<SQLITE_N_BTREE_META );
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( (p->btreeMask & (1<<pOp->p1))!=0 );
+  pDb = &db->aDb[pOp->p1];
+  assert( pDb->pBt!=0 );
+  sqlite3VdbeMemIntegerify(pIn3);
+  /* See note about index shifting on OP_ReadCookie */
+  rc = sqlite3BtreeUpdateMeta(pDb->pBt, 1+pOp->p2, (int)pIn3->u.i);
+  if( pOp->p2==0 ){
+    /* When the schema cookie changes, record the new cookie internally */
+    pDb->pSchema->schema_cookie = pIn3->u.i;
+    db->flags |= SQLITE_InternChanges;
+  }else if( pOp->p2==1 ){
+    /* Record changes in the file format */
+    pDb->pSchema->file_format = pIn3->u.i;
+  }
+  if( pOp->p1==1 ){
+    /* Invalidate all prepared statements whenever the TEMP database
+    ** schema is changed.  Ticket #1644 */
+    sqlite3ExpirePreparedStatements(db);
+  }
+  break;
+}
+
+/* Opcode: VerifyCookie P1 P2 *
+**
+** Check the value of global database parameter number 0 (the
+** schema version) and make sure it is equal to P2.  
+** P1 is the database number which is 0 for the main database file
+** and 1 for the file holding temporary tables and some higher number
+** for auxiliary databases.
+**
+** The cookie changes its value whenever the database schema changes.
+** This operation is used to detect when that the cookie has changed
+** and that the current process needs to reread the schema.
+**
+** Either a transaction needs to have been started or an OP_Open needs
+** to be executed (to establish a read lock) before this opcode is
+** invoked.
+*/
+case OP_VerifyCookie: {
+  int iMeta;
+  Btree *pBt;
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( (p->btreeMask & (1<<pOp->p1))!=0 );
+  pBt = db->aDb[pOp->p1].pBt;
+  if( pBt ){
+    rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&iMeta);
+  }else{
+    rc = SQLITE_OK;
+    iMeta = 0;
+  }
+  if( rc==SQLITE_OK && iMeta!=pOp->p2 ){
+    sqlite3_free(p->zErrMsg);
+    p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
+    /* If the schema-cookie from the database file matches the cookie 
+    ** stored with the in-memory representation of the schema, do
+    ** not reload the schema from the database file.
+    **
+    ** If virtual-tables are in use, this is not just an optimisation.
+    ** Often, v-tables store their data in other SQLite tables, which
+    ** are queried from within xNext() and other v-table methods using
+    ** prepared queries. If such a query is out-of-date, we do not want to
+    ** discard the database schema, as the user code implementing the
+    ** v-table would have to be ready for the sqlite3_vtab structure itself
+    ** to be invalidated whenever sqlite3_step() is called from within 
+    ** a v-table method.
+    */
+    if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
+      sqlite3ResetInternalSchema(db, pOp->p1);
+    }
+
+    sqlite3ExpirePreparedStatements(db);
+    rc = SQLITE_SCHEMA;
+  }
+  break;
+}
+
+/* Opcode: OpenRead P1 P2 P3 P4 P5
+**
+** Open a read-only cursor for the database table whose root page is
+** P2 in a database file.  The database file is determined by P3. 
+** P3==0 means the main database, P3==1 means the database used for 
+** temporary tables, and P3>1 means used the corresponding attached
+** database.  Give the new cursor an identifier of P1.  The P1
+** values need not be contiguous but all P1 values should be small integers.
+** It is an error for P1 to be negative.
+**
+** If P5!=0 then use the content of register P2 as the root page, not
+** the value of P2 itself.
+**
+** There will be a read lock on the database whenever there is an
+** open cursor.  If the database was unlocked prior to this instruction
+** then a read lock is acquired as part of this instruction.  A read
+** lock allows other processes to read the database but prohibits
+** any other process from modifying the database.  The read lock is
+** released when all cursors are closed.  If this instruction attempts
+** to get a read lock but fails, the script terminates with an
+** SQLITE_BUSY error code.
+**
+** The P4 value is a pointer to a KeyInfo structure that defines the
+** content and collating sequence of indices.  P4 is NULL for cursors
+** that are not pointing to indices.
+**
+** See also OpenWrite.
+*/
+/* Opcode: OpenWrite P1 P2 P3 P4 P5
+**
+** Open a read/write cursor named P1 on the table or index whose root
+** page is P2.  Or if P5!=0 use the content of register P2 to find the
+** root page.
+**
+** The P4 value is a pointer to a KeyInfo structure that defines the
+** content and collating sequence of indices.  P4 is NULL for cursors
+** that are not pointing to indices.
+**
+** This instruction works just like OpenRead except that it opens the cursor
+** in read/write mode.  For a given table, there can be one or more read-only
+** cursors or a single read/write cursor but not both.
+**
+** See also OpenRead.
+*/
+case OP_OpenRead:
+case OP_OpenWrite: {
+  int i = pOp->p1;
+  int p2 = pOp->p2;
+  int iDb = pOp->p3;
+  int wrFlag;
+  Btree *pX;
+  Cursor *pCur;
+  Db *pDb;
+  
+  assert( iDb>=0 && iDb<db->nDb );
+  assert( (p->btreeMask & (1<<iDb))!=0 );
+  pDb = &db->aDb[iDb];
+  pX = pDb->pBt;
+  assert( pX!=0 );
+  if( pOp->opcode==OP_OpenWrite ){
+    wrFlag = 1;
+    if( pDb->pSchema->file_format < p->minWriteFileFormat ){
+      p->minWriteFileFormat = pDb->pSchema->file_format;
+    }
+  }else{
+    wrFlag = 0;
+  }
+  if( pOp->p5 ){
+    assert( p2>0 );
+    assert( p2<=p->nMem );
+    pIn2 = &p->aMem[p2];
+    sqlite3VdbeMemIntegerify(pIn2);
+    p2 = pIn2->u.i;
+    assert( p2>=2 );
+  }
+  assert( i>=0 );
+  pCur = allocateCursor(p, i, iDb);
+  if( pCur==0 ) goto no_mem;
+  pCur->nullRow = 1;
+  /* We always provide a key comparison function.  If the table being
+  ** opened is of type INTKEY, the comparision function will be ignored. */
+  rc = sqlite3BtreeCursor(pX, p2, wrFlag,
+           sqlite3VdbeRecordCompare, pOp->p4.p,
+           &pCur->pCursor);
+  if( pOp->p4type==P4_KEYINFO ){
+    pCur->pKeyInfo = pOp->p4.pKeyInfo;
+    pCur->pIncrKey = &pCur->pKeyInfo->incrKey;
+    pCur->pKeyInfo->enc = ENC(p->db);
+  }else{
+    pCur->pKeyInfo = 0;
+    pCur->pIncrKey = &pCur->bogusIncrKey;
+  }
+  switch( rc ){
+    case SQLITE_BUSY: {
+      p->pc = pc;
+      p->rc = rc = SQLITE_BUSY;
+      goto vdbe_return;
+    }
+    case SQLITE_OK: {
+      int flags = sqlite3BtreeFlags(pCur->pCursor);
+      /* Sanity checking.  Only the lower four bits of the flags byte should
+      ** be used.  Bit 3 (mask 0x08) is unpreditable.  The lower 3 bits
+      ** (mask 0x07) should be either 5 (intkey+leafdata for tables) or
+      ** 2 (zerodata for indices).  If these conditions are not met it can
+      ** only mean that we are dealing with a corrupt database file
+      */
+      if( (flags & 0xf0)!=0 || ((flags & 0x07)!=5 && (flags & 0x07)!=2) ){
+        rc = SQLITE_CORRUPT_BKPT;
+        goto abort_due_to_error;
+      }
+      pCur->isTable = (flags & BTREE_INTKEY)!=0;
+      pCur->isIndex = (flags & BTREE_ZERODATA)!=0;
+      /* If P4==0 it means we are expected to open a table.  If P4!=0 then
+      ** we expect to be opening an index.  If this is not what happened,
+      ** then the database is corrupt
+      */
+      if( (pCur->isTable && pOp->p4type==P4_KEYINFO)
+       || (pCur->isIndex && pOp->p4type!=P4_KEYINFO) ){
+        rc = SQLITE_CORRUPT_BKPT;
+        goto abort_due_to_error;
+      }
+      break;
+    }
+    case SQLITE_EMPTY: {
+      pCur->isTable = pOp->p4type!=P4_KEYINFO;
+      pCur->isIndex = !pCur->isTable;
+      rc = SQLITE_OK;
+      break;
+    }
+    default: {
+      goto abort_due_to_error;
+    }
+  }
+  break;
+}
+
+/* Opcode: OpenEphemeral P1 P2 * P4 *
+**
+** Open a new cursor P1 to a transient table.
+** The cursor is always opened read/write even if 
+** the main database is read-only.  The transient or virtual
+** table is deleted automatically when the cursor is closed.
+**
+** P2 is the number of columns in the virtual table.
+** The cursor points to a BTree table if P4==0 and to a BTree index
+** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
+** that defines the format of keys in the index.
+**
+** This opcode was once called OpenTemp.  But that created
+** confusion because the term "temp table", might refer either
+** to a TEMP table at the SQL level, or to a table opened by
+** this opcode.  Then this opcode was call OpenVirtual.  But
+** that created confusion with the whole virtual-table idea.
+*/
+case OP_OpenEphemeral: {
+  int i = pOp->p1;
+  Cursor *pCx;
+  static const int openFlags = 
+      SQLITE_OPEN_READWRITE |
+      SQLITE_OPEN_CREATE |
+      SQLITE_OPEN_EXCLUSIVE |
+      SQLITE_OPEN_DELETEONCLOSE |
+      SQLITE_OPEN_TRANSIENT_DB;
+
+  assert( i>=0 );
+  pCx = allocateCursor(p, i, -1);
+  if( pCx==0 ) goto no_mem;
+  pCx->nullRow = 1;
+  rc = sqlite3BtreeFactory(db, 0, 1, SQLITE_DEFAULT_TEMP_CACHE_SIZE, openFlags,
+                           &pCx->pBt);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3BtreeBeginTrans(pCx->pBt, 1);
+  }
+  if( rc==SQLITE_OK ){
+    /* If a transient index is required, create it by calling
+    ** sqlite3BtreeCreateTable() with the BTREE_ZERODATA flag before
+    ** opening it. If a transient table is required, just use the
+    ** automatically created table with root-page 1 (an INTKEY table).
+    */
+    if( pOp->p4.pKeyInfo ){
+      int pgno;
+      assert( pOp->p4type==P4_KEYINFO );
+      rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_ZERODATA); 
+      if( rc==SQLITE_OK ){
+        assert( pgno==MASTER_ROOT+1 );
+        rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, sqlite3VdbeRecordCompare,
+            pOp->p4.z, &pCx->pCursor);
+        pCx->pKeyInfo = pOp->p4.pKeyInfo;
+        pCx->pKeyInfo->enc = ENC(p->db);
+        pCx->pIncrKey = &pCx->pKeyInfo->incrKey;
+      }
+      pCx->isTable = 0;
+    }else{
+      rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, 0, &pCx->pCursor);
+      pCx->isTable = 1;
+      pCx->pIncrKey = &pCx->bogusIncrKey;
+    }
+  }
+  pCx->nField = pOp->p2;
+  pCx->isIndex = !pCx->isTable;
+  break;
+}
+
+/* Opcode: OpenPseudo P1 * * * *
+**
+** Open a new cursor that points to a fake table that contains a single
+** row of data.  Any attempt to write a second row of data causes the
+** first row to be deleted.  All data is deleted when the cursor is
+** closed.
+**
+** A pseudo-table created by this opcode is useful for holding the
+** NEW or OLD tables in a trigger.  Also used to hold the a single
+** row output from the sorter so that the row can be decomposed into
+** individual columns using the OP_Column opcode.
+*/
+case OP_OpenPseudo: {
+  int i = pOp->p1;
+  Cursor *pCx;
+  assert( i>=0 );
+  pCx = allocateCursor(p, i, -1);
+  if( pCx==0 ) goto no_mem;
+  pCx->nullRow = 1;
+  pCx->pseudoTable = 1;
+  pCx->pIncrKey = &pCx->bogusIncrKey;
+  pCx->isTable = 1;
+  pCx->isIndex = 0;
+  break;
+}
+
+/* Opcode: Close P1 * * * *
+**
+** Close a cursor previously opened as P1.  If P1 is not
+** currently open, this instruction is a no-op.
+*/
+case OP_Close: {
+  int i = pOp->p1;
+  assert( i>=0 && i<p->nCursor );
+  sqlite3VdbeFreeCursor(p, p->apCsr[i]);
+  p->apCsr[i] = 0;
+  break;
+}
+
+/* Opcode: MoveGe P1 P2 P3 * *
+**
+** Use the value in register P3 as a key.  Reposition
+** cursor P1 so that it points to the smallest entry that is greater
+** than or equal to the key in register P3.
+** If there are no records greater than or equal to the key and P2 
+** is not zero, then jump to P2.
+**
+** A special feature of this opcode (and different from the
+** related OP_MoveGt, OP_MoveLt, and OP_MoveLe) is that if P2 is
+** zero and P1 is an SQL table (a b-tree with integer keys) then
+** the seek is deferred until it is actually needed.  It might be
+** the case that the cursor is never accessed.  By deferring the
+** seek, we avoid unnecessary seeks.
+**
+** See also: Found, NotFound, Distinct, MoveLt, MoveGt, MoveLe
+*/
+/* Opcode: MoveGt P1 P2 P3 * *
+**
+** Use the value in register P3 as a key.  Reposition
+** cursor P1 so that it points to the smallest entry that is greater
+** than the key in register P3.
+** If there are no records greater than the key 
+** then jump to P2.
+**
+** See also: Found, NotFound, Distinct, MoveLt, MoveGe, MoveLe
+*/
+/* Opcode: MoveLt P1 P2 P3 * * 
+**
+** Use the value in register P3 as a key.  Reposition
+** cursor P1 so that it points to the largest entry that is less
+** than the key in register P3.
+** If there are no records less than the key
+** then jump to P2.
+**
+** See also: Found, NotFound, Distinct, MoveGt, MoveGe, MoveLe
+*/
+/* Opcode: MoveLe P1 P2 P3 * *
+**
+** Use the value in register P3 as a key.  Reposition
+** cursor P1 so that it points to the largest entry that is less than
+** or equal to the key.
+** If there are no records less than or eqal to the key
+** then jump to P2.
+**
+** See also: Found, NotFound, Distinct, MoveGt, MoveGe, MoveLt
+*/
+case OP_MoveLt:         /* jump, in3 */
+case OP_MoveLe:         /* jump, in3 */
+case OP_MoveGe:         /* jump, in3 */
+case OP_MoveGt: {       /* jump, in3 */
+  int i = pOp->p1;
+  Cursor *pC;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  if( pC->pCursor!=0 ){
+    int res, oc;
+    oc = pOp->opcode;
+    pC->nullRow = 0;
+    *pC->pIncrKey = oc==OP_MoveGt || oc==OP_MoveLe;
+    if( pC->isTable ){
+      i64 iKey = sqlite3VdbeIntValue(pIn3);
+      if( pOp->p2==0 ){
+        assert( pOp->opcode==OP_MoveGe );
+        pC->movetoTarget = iKey;
+        pC->rowidIsValid = 0;
+        pC->deferredMoveto = 1;
+        break;
+      }
+      rc = sqlite3BtreeMoveto(pC->pCursor, 0, (u64)iKey, 0, &res);
+      if( rc!=SQLITE_OK ){
+        goto abort_due_to_error;
+      }
+      pC->lastRowid = iKey;
+      pC->rowidIsValid = res==0;
+    }else{
+      assert( pIn3->flags & MEM_Blob );
+      ExpandBlob(pIn3);
+      rc = sqlite3BtreeMoveto(pC->pCursor, pIn3->z, pIn3->n, 0, &res);
+      if( rc!=SQLITE_OK ){
+        goto abort_due_to_error;
+      }
+      pC->rowidIsValid = 0;
+    }
+    pC->deferredMoveto = 0;
+    pC->cacheStatus = CACHE_STALE;
+    *pC->pIncrKey = 0;
+#ifdef SQLITE_TEST
+    sqlite3_search_count++;
+#endif
+    if( oc==OP_MoveGe || oc==OP_MoveGt ){
+      if( res<0 ){
+        rc = sqlite3BtreeNext(pC->pCursor, &res);
+        if( rc!=SQLITE_OK ) goto abort_due_to_error;
+        pC->rowidIsValid = 0;
+      }else{
+        res = 0;
+      }
+    }else{
+      assert( oc==OP_MoveLt || oc==OP_MoveLe );
+      if( res>=0 ){
+        rc = sqlite3BtreePrevious(pC->pCursor, &res);
+        if( rc!=SQLITE_OK ) goto abort_due_to_error;
+        pC->rowidIsValid = 0;
+      }else{
+        /* res might be negative because the table is empty.  Check to
+        ** see if this is the case.
+        */
+        res = sqlite3BtreeEof(pC->pCursor);
+      }
+    }
+    assert( pOp->p2>0 );
+    if( res ){
+      pc = pOp->p2 - 1;
+    }
+  }
+  break;
+}
+
+/* Opcode: Found P1 P2 P3 * *
+**
+** Register P3 holds a blob constructed by MakeRecord.  P1 is an index.
+** If an entry that matches the value in register p3 exists in P1 then
+** jump to P2.  If the P3 value does not match any entry in P1
+** then fall thru.  The P1 cursor is left pointing at the matching entry
+** if it exists.
+**
+** This instruction is used to implement the IN operator where the
+** left-hand side is a SELECT statement.  P1 may be a true index, or it
+** may be a temporary index that holds the results of the SELECT
+** statement.   This instruction is also used to implement the
+** DISTINCT keyword in SELECT statements.
+**
+** This instruction checks if index P1 contains a record for which 
+** the first N serialised values exactly match the N serialised values
+** in the record in register P3, where N is the total number of values in
+** the P3 record (the P3 record is a prefix of the P1 record). 
+**
+** See also: NotFound, MoveTo, IsUnique, NotExists
+*/
+/* Opcode: NotFound P1 P2 P3 * *
+**
+** Register P3 holds a blob constructed by MakeRecord.  P1 is
+** an index.  If no entry exists in P1 that matches the blob then jump
+** to P2.  If an entry does existing, fall through.  The cursor is left
+** pointing to the entry that matches.
+**
+** See also: Found, MoveTo, NotExists, IsUnique
+*/
+case OP_NotFound:       /* jump, in3 */
+case OP_Found: {        /* jump, in3 */
+  int i = pOp->p1;
+  int alreadyExists = 0;
+  Cursor *pC;
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pC = p->apCsr[i])->pCursor!=0 ){
+    int res;
+    assert( pC->isTable==0 );
+    assert( pIn3->flags & MEM_Blob );
+    if( pOp->opcode==OP_Found ){
+      pC->pKeyInfo->prefixIsEqual = 1;
+    }
+    rc = sqlite3BtreeMoveto(pC->pCursor, pIn3->z, pIn3->n, 0, &res);
+    pC->pKeyInfo->prefixIsEqual = 0;
+    if( rc!=SQLITE_OK ){
+      break;
+    }
+    alreadyExists = (res==0);
+    pC->deferredMoveto = 0;
+    pC->cacheStatus = CACHE_STALE;
+  }
+  if( pOp->opcode==OP_Found ){
+    if( alreadyExists ) pc = pOp->p2 - 1;
+  }else{
+    if( !alreadyExists ) pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: IsUnique P1 P2 P3 P4 *
+**
+** The P3 register contains an integer record number.  Call this
+** record number R.  The P4 register contains an index key created
+** using MakeIdxRec.  Call it K.
+**
+** P1 is an index.  So it has no data and its key consists of a
+** record generated by OP_MakeRecord where the last field is the 
+** rowid of the entry that the index refers to.
+** 
+** This instruction asks if there is an entry in P1 where the
+** fields matches K but the rowid is different from R.
+** If there is no such entry, then there is an immediate
+** jump to P2.  If any entry does exist where the index string
+** matches K but the record number is not R, then the record
+** number for that entry is written into P3 and control
+** falls through to the next instruction.
+**
+** See also: NotFound, NotExists, Found
+*/
+case OP_IsUnique: {        /* jump, in3 */
+  int i = pOp->p1;
+  Cursor *pCx;
+  BtCursor *pCrsr;
+  Mem *pK;
+  i64 R;
+
+  /* Pop the value R off the top of the stack
+  */
+  assert( pOp->p4type==P4_INT32 );
+  assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
+  pK = &p->aMem[pOp->p4.i];
+  sqlite3VdbeMemIntegerify(pIn3);
+  R = pIn3->u.i;
+  assert( (pIn3->flags & MEM_Dyn)==0 );
+  assert( i>=0 && i<p->nCursor );
+  pCx = p->apCsr[i];
+  assert( pCx!=0 );
+  pCrsr = pCx->pCursor;
+  if( pCrsr!=0 ){
+    int res;
+    i64 v;         /* The record number on the P1 entry that matches K */
+    char *zKey;    /* The value of K */
+    int nKey;      /* Number of bytes in K */
+    int len;       /* Number of bytes in K without the rowid at the end */
+    int szRowid;   /* Size of the rowid column at the end of zKey */
+
+    /* Make sure K is a string and make zKey point to K
+    */
+    assert( pK->flags & MEM_Blob );
+    zKey = pK->z;
+    nKey = pK->n;
+
+    szRowid = sqlite3VdbeIdxRowidLen((u8*)zKey);
+    len = nKey-szRowid;
+
+    /* Search for an entry in P1 where all but the last four bytes match K.
+    ** If there is no such entry, jump immediately to P2.
+    */
+    assert( pCx->deferredMoveto==0 );
+    pCx->cacheStatus = CACHE_STALE;
+    rc = sqlite3BtreeMoveto(pCrsr, zKey, len, 0, &res);
+    if( rc!=SQLITE_OK ){
+      goto abort_due_to_error;
+    }
+    if( res<0 ){
+      rc = sqlite3BtreeNext(pCrsr, &res);
+      if( res ){
+        pc = pOp->p2 - 1;
+        break;
+      }
+    }
+    rc = sqlite3VdbeIdxKeyCompare(pCx, len, (u8*)zKey, &res); 
+    if( rc!=SQLITE_OK ) goto abort_due_to_error;
+    if( res>0 ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+
+    /* At this point, pCrsr is pointing to an entry in P1 where all but
+    ** the final entry (the rowid) matches K.  Check to see if the
+    ** final rowid column is different from R.  If it equals R then jump
+    ** immediately to P2.
+    */
+    rc = sqlite3VdbeIdxRowid(pCrsr, &v);
+    if( rc!=SQLITE_OK ){
+      goto abort_due_to_error;
+    }
+    if( v==R ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+
+    /* The final varint of the key is different from R.  Store it back
+    ** into register R3.  (The record number of an entry that violates
+    ** a UNIQUE constraint.)
+    */
+    pIn3->u.i = v;
+    assert( pIn3->flags==MEM_Int );
+  }
+  break;
+}
+
+/* Opcode: NotExists P1 P2 P3 * *
+**
+** Use the content of register P3 as a integer key.  If a record 
+** with that key does not exist in table of P1, then jump to P2. 
+** If the record does exist, then fall thru.  The cursor is left 
+** pointing to the record if it exists.
+**
+** The difference between this operation and NotFound is that this
+** operation assumes the key is an integer and that P1 is a table whereas
+** NotFound assumes key is a blob constructed from MakeRecord and
+** P1 is an index.
+**
+** See also: Found, MoveTo, NotFound, IsUnique
+*/
+case OP_NotExists: {        /* jump, in3 */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
+    int res;
+    u64 iKey;
+    assert( pIn3->flags & MEM_Int );
+    assert( p->apCsr[i]->isTable );
+    iKey = intToKey(pIn3->u.i);
+    rc = sqlite3BtreeMoveto(pCrsr, 0, iKey, 0,&res);
+    pC->lastRowid = pIn3->u.i;
+    pC->rowidIsValid = res==0;
+    pC->nullRow = 0;
+    pC->cacheStatus = CACHE_STALE;
+    /* res might be uninitialized if rc!=SQLITE_OK.  But if rc!=SQLITE_OK
+    ** processing is about to abort so we really do not care whether or not
+    ** the following jump is taken.  (In other words, do not stress over
+    ** the error that valgrind sometimes shows on the next statement when
+    ** running ioerr.test and similar failure-recovery test scripts.) */
+    if( res!=0 ){
+      pc = pOp->p2 - 1;
+      assert( pC->rowidIsValid==0 );
+    }
+  }
+  break;
+}
+
+/* Opcode: Sequence P1 P2 * * *
+**
+** Find the next available sequence number for cursor P1.
+** Write the sequence number into register P2.
+** The sequence number on the cursor is incremented after this
+** instruction.  
+*/
+case OP_Sequence: {           /* out2-prerelease */
+  int i = pOp->p1;
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  pOut->u.i = p->apCsr[i]->seqCount++;
+  pOut->flags = MEM_Int;
+  break;
+}
+
+
+/* Opcode: NewRowid P1 P2 P3 * *
+**
+** Get a new integer record number (a.k.a "rowid") used as the key to a table.
+** The record number is not previously used as a key in the database
+** table that cursor P1 points to.  The new record number is written
+** written to register P2.
+**
+** If P3>0 then P3 is a register that holds the largest previously
+** generated record number.  No new record numbers are allowed to be less
+** than this value.  When this value reaches its maximum, a SQLITE_FULL
+** error is generated.  The P3 register is updated with the generated
+** record number.  This P3 mechanism is used to help implement the
+** AUTOINCREMENT feature.
+*/
+case OP_NewRowid: {           /* out2-prerelease */
+  int i = pOp->p1;
+  i64 v = 0;
+  Cursor *pC;
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pC = p->apCsr[i])->pCursor==0 ){
+    /* The zero initialization above is all that is needed */
+  }else{
+    /* The next rowid or record number (different terms for the same
+    ** thing) is obtained in a two-step algorithm.
+    **
+    ** First we attempt to find the largest existing rowid and add one
+    ** to that.  But if the largest existing rowid is already the maximum
+    ** positive integer, we have to fall through to the second
+    ** probabilistic algorithm
+    **
+    ** The second algorithm is to select a rowid at random and see if
+    ** it already exists in the table.  If it does not exist, we have
+    ** succeeded.  If the random rowid does exist, we select a new one
+    ** and try again, up to 1000 times.
+    **
+    ** For a table with less than 2 billion entries, the probability
+    ** of not finding a unused rowid is about 1.0e-300.  This is a 
+    ** non-zero probability, but it is still vanishingly small and should
+    ** never cause a problem.  You are much, much more likely to have a
+    ** hardware failure than for this algorithm to fail.
+    **
+    ** The analysis in the previous paragraph assumes that you have a good
+    ** source of random numbers.  Is a library function like lrand48()
+    ** good enough?  Maybe. Maybe not. It's hard to know whether there
+    ** might be subtle bugs is some implementations of lrand48() that
+    ** could cause problems. To avoid uncertainty, SQLite uses its own 
+    ** random number generator based on the RC4 algorithm.
+    **
+    ** To promote locality of reference for repetitive inserts, the
+    ** first few attempts at chosing a random rowid pick values just a little
+    ** larger than the previous rowid.  This has been shown experimentally
+    ** to double the speed of the COPY operation.
+    */
+    int res, rx=SQLITE_OK, cnt;
+    i64 x;
+    cnt = 0;
+    if( (sqlite3BtreeFlags(pC->pCursor)&(BTREE_INTKEY|BTREE_ZERODATA)) !=
+          BTREE_INTKEY ){
+      rc = SQLITE_CORRUPT_BKPT;
+      goto abort_due_to_error;
+    }
+    assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_INTKEY)!=0 );
+    assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_ZERODATA)==0 );
+
+#ifdef SQLITE_32BIT_ROWID
+#   define MAX_ROWID 0x7fffffff
+#else
+    /* Some compilers complain about constants of the form 0x7fffffffffffffff.
+    ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
+    ** to provide the constant while making all compilers happy.
+    */
+#   define MAX_ROWID  ( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
+#endif
+
+    if( !pC->useRandomRowid ){
+      if( pC->nextRowidValid ){
+        v = pC->nextRowid;
+      }else{
+        rc = sqlite3BtreeLast(pC->pCursor, &res);
+        if( rc!=SQLITE_OK ){
+          goto abort_due_to_error;
+        }
+        if( res ){
+          v = 1;
+        }else{
+          sqlite3BtreeKeySize(pC->pCursor, &v);
+          v = keyToInt(v);
+          if( v==MAX_ROWID ){
+            pC->useRandomRowid = 1;
+          }else{
+            v++;
+          }
+        }
+      }
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+      if( pOp->p3 ){
+        Mem *pMem;
+        assert( pOp->p3>0 && pOp->p3<=p->nMem ); /* P3 is a valid memory cell */
+        pMem = &p->aMem[pOp->p3];
+	REGISTER_TRACE(pOp->p3, pMem);
+        sqlite3VdbeMemIntegerify(pMem);
+        assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
+        if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
+          rc = SQLITE_FULL;
+          goto abort_due_to_error;
+        }
+        if( v<pMem->u.i+1 ){
+          v = pMem->u.i + 1;
+        }
+        pMem->u.i = v;
+      }
+#endif
+
+      if( v<MAX_ROWID ){
+        pC->nextRowidValid = 1;
+        pC->nextRowid = v+1;
+      }else{
+        pC->nextRowidValid = 0;
+      }
+    }
+    if( pC->useRandomRowid ){
+      assert( pOp->p3==0 );  /* SQLITE_FULL must have occurred prior to this */
+      v = db->priorNewRowid;
+      cnt = 0;
+      do{
+        if( cnt==0 && (v&0xffffff)==v ){
+          v++;
+        }else{
+          sqlite3Randomness(sizeof(v), &v);
+          if( cnt<5 ) v &= 0xffffff;
+        }
+        if( v==0 ) continue;
+        x = intToKey(v);
+        rx = sqlite3BtreeMoveto(pC->pCursor, 0, (u64)x, 0, &res);
+        cnt++;
+      }while( cnt<100 && rx==SQLITE_OK && res==0 );
+      db->priorNewRowid = v;
+      if( rx==SQLITE_OK && res==0 ){
+        rc = SQLITE_FULL;
+        goto abort_due_to_error;
+      }
+    }
+    pC->rowidIsValid = 0;
+    pC->deferredMoveto = 0;
+    pC->cacheStatus = CACHE_STALE;
+  }
+  pOut->flags = MEM_Int;
+  pOut->u.i = v;
+  break;
+}
+
+/* Opcode: Insert P1 P2 P3 P4 P5
+**
+** Write an entry into the table of cursor P1.  A new entry is
+** created if it doesn't already exist or the data for an existing
+** entry is overwritten.  The data is the value stored register
+** number P2. The key is stored in register P3. The key must
+** be an integer.
+**
+** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
+** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
+** then rowid is stored for subsequent return by the
+** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
+**
+** Parameter P4 may point to a string containing the table-name, or
+** may be NULL. If it is not NULL, then the update-hook 
+** (sqlite3.xUpdateCallback) is invoked following a successful insert.
+**
+** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
+** allocated, then ownership of P2 is transferred to the pseudo-cursor
+** and register P2 becomes ephemeral.  If the cursor is changed, the
+** value of register P2 will then change.  Make sure this does not
+** cause any problems.)
+**
+** This instruction only works on tables.  The equivalent instruction
+** for indices is OP_IdxInsert.
+*/
+case OP_Insert: {
+  Mem *pData = &p->aMem[pOp->p2];
+  Mem *pKey = &p->aMem[pOp->p3];
+
+  i64 iKey;   /* The integer ROWID or key for the record to be inserted */
+  int i = pOp->p1;
+  Cursor *pC;
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  assert( pC->pCursor!=0 || pC->pseudoTable );
+  assert( pKey->flags & MEM_Int );
+  assert( pC->isTable );
+  REGISTER_TRACE(pOp->p2, pData);
+  REGISTER_TRACE(pOp->p3, pKey);
+
+  iKey = intToKey(pKey->u.i);
+  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
+  if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = pKey->u.i;
+  if( pC->nextRowidValid && pKey->u.i>=pC->nextRowid ){
+    pC->nextRowidValid = 0;
+  }
+  if( pData->flags & MEM_Null ){
+    pData->z = 0;
+    pData->n = 0;
+  }else{
+    assert( pData->flags & (MEM_Blob|MEM_Str) );
+  }
+  if( pC->pseudoTable ){
+    sqlite3_free(pC->pData);
+    pC->iKey = iKey;
+    pC->nData = pData->n;
+    if( pData->flags & MEM_Dyn ){
+      pC->pData = pData->z;
+      pData->flags &= ~MEM_Dyn;
+      pData->flags |= MEM_Ephem;
+    }else{
+      pC->pData = sqlite3_malloc( pC->nData+2 );
+      if( !pC->pData ) goto no_mem;
+      memcpy(pC->pData, pData->z, pC->nData);
+      pC->pData[pC->nData] = 0;
+      pC->pData[pC->nData+1] = 0;
+    }
+    pC->nullRow = 0;
+  }else{
+    int nZero;
+    if( pData->flags & MEM_Zero ){
+      nZero = pData->u.i;
+    }else{
+      nZero = 0;
+    }
+    rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
+                            pData->z, pData->n, nZero,
+                            pOp->p5 & OPFLAG_APPEND);
+  }
+  
+  pC->rowidIsValid = 0;
+  pC->deferredMoveto = 0;
+  pC->cacheStatus = CACHE_STALE;
+
+  /* Invoke the update-hook if required. */
+  if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
+    const char *zDb = db->aDb[pC->iDb].zName;
+    const char *zTbl = pOp->p4.z;
+    int op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
+    assert( pC->isTable );
+    db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
+    assert( pC->iDb>=0 );
+  }
+  break;
+}
+
+/* Opcode: Delete P1 P2 * P4 *
+**
+** Delete the record at which the P1 cursor is currently pointing.
+**
+** The cursor will be left pointing at either the next or the previous
+** record in the table. If it is left pointing at the next record, then
+** the next Next instruction will be a no-op.  Hence it is OK to delete
+** a record from within an Next loop.
+**
+** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
+** incremented (otherwise not).
+**
+** P1 must not be pseudo-table.  It has to be a real table with
+** multiple rows.
+**
+** If P4 is not NULL, then it is the name of the table that P1 is
+** pointing to.  The update hook will be invoked, if it exists.
+** If P4 is not NULL then the P1 cursor must have been positioned
+** using OP_NotFound prior to invoking this opcode.
+*/
+case OP_Delete: {
+  int i = pOp->p1;
+  i64 iKey;
+  Cursor *pC;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  assert( pC->pCursor!=0 );  /* Only valid for real tables, no pseudotables */
+
+  /* If the update-hook will be invoked, set iKey to the rowid of the
+  ** row being deleted.
+  */
+  if( db->xUpdateCallback && pOp->p4.z ){
+    assert( pC->isTable );
+    assert( pC->rowidIsValid );  /* lastRowid set by previous OP_NotFound */
+    iKey = pC->lastRowid;
+  }
+
+  rc = sqlite3VdbeCursorMoveto(pC);
+  if( rc ) goto abort_due_to_error;
+  rc = sqlite3BtreeDelete(pC->pCursor);
+  pC->nextRowidValid = 0;
+  pC->cacheStatus = CACHE_STALE;
+
+  /* Invoke the update-hook if required. */
+  if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
+    const char *zDb = db->aDb[pC->iDb].zName;
+    const char *zTbl = pOp->p4.z;
+    db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, zTbl, iKey);
+    assert( pC->iDb>=0 );
+  }
+  if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
+  break;
+}
+
+/* Opcode: ResetCount P1 * *
+**
+** This opcode resets the VMs internal change counter to 0. If P1 is true,
+** then the value of the change counter is copied to the database handle
+** change counter (returned by subsequent calls to sqlite3_changes())
+** before it is reset. This is used by trigger programs.
+*/
+case OP_ResetCount: {
+  if( pOp->p1 ){
+    sqlite3VdbeSetChanges(db, p->nChange);
+  }
+  p->nChange = 0;
+  break;
+}
+
+/* Opcode: RowData P1 P2 * * *
+**
+** Write into register P2 the complete row data for cursor P1.
+** There is no interpretation of the data.  
+** It is just copied onto the P2 register exactly as 
+** it is found in the database file.
+**
+** If the P1 cursor must be pointing to a valid row (not a NULL row)
+** of a real table, not a pseudo-table.
+*/
+/* Opcode: RowKey P1 P2 * * *
+**
+** Write into register P2 the complete row key for cursor P1.
+** There is no interpretation of the data.  
+** The key is copied onto the P3 register exactly as 
+** it is found in the database file.
+**
+** If the P1 cursor must be pointing to a valid row (not a NULL row)
+** of a real table, not a pseudo-table.
+*/
+case OP_RowKey:             /* out2-prerelease */
+case OP_RowData: {          /* out2-prerelease */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  u32 n;
+
+  /* Note that RowKey and RowData are really exactly the same instruction */
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC->isTable || pOp->opcode==OP_RowKey );
+  assert( pC->isIndex || pOp->opcode==OP_RowData );
+  assert( pC!=0 );
+  assert( pC->nullRow==0 );
+  assert( pC->pseudoTable==0 );
+  assert( pC->pCursor!=0 );
+  pCrsr = pC->pCursor;
+  rc = sqlite3VdbeCursorMoveto(pC);
+  if( rc ) goto abort_due_to_error;
+  if( pC->isIndex ){
+    i64 n64;
+    assert( !pC->isTable );
+    sqlite3BtreeKeySize(pCrsr, &n64);
+    if( n64>SQLITE_MAX_LENGTH ){
+      goto too_big;
+    }
+    n = n64;
+  }else{
+    sqlite3BtreeDataSize(pCrsr, &n);
+    if( n>SQLITE_MAX_LENGTH ){
+      goto too_big;
+    }
+  }
+  pOut->n = n;
+  if( n<=NBFS ){
+    pOut->flags = MEM_Blob | MEM_Short;
+    pOut->z = pOut->zShort;
+  }else{
+    char *z = sqlite3_malloc( n );
+    if( z==0 ) goto no_mem;
+    pOut->flags = MEM_Blob | MEM_Dyn;
+    pOut->xDel = 0;
+    pOut->z = z;
+  }
+  if( pC->isIndex ){
+    rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z);
+  }else{
+    rc = sqlite3BtreeData(pCrsr, 0, n, pOut->z);
+  }
+  pOut->enc = SQLITE_UTF8;  /* In case the blob is ever cast to text */
+  UPDATE_MAX_BLOBSIZE(pOut);
+  break;
+}
+
+/* Opcode: Rowid P1 P2 * * *
+**
+** Store in register P2 an integer which is the key of the table entry that
+** P1 is currently point to.  If p2==0 then push the integer.
+*/
+case OP_Rowid: {                 /* out2-prerelease */
+  int i = pOp->p1;
+  Cursor *pC;
+  i64 v;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  rc = sqlite3VdbeCursorMoveto(pC);
+  if( rc ) goto abort_due_to_error;
+  if( pC->rowidIsValid ){
+    v = pC->lastRowid;
+  }else if( pC->pseudoTable ){
+    v = keyToInt(pC->iKey);
+  }else if( pC->nullRow ){
+    /* Leave the rowid set to a NULL */
+    break;
+  }else{
+    assert( pC->pCursor!=0 );
+    sqlite3BtreeKeySize(pC->pCursor, &v);
+    v = keyToInt(v);
+  }
+  pOut->u.i = v;
+  pOut->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: NullRow P1 * * * *
+**
+** Move the cursor P1 to a null row.  Any OP_Column operations
+** that occur while the cursor is on the null row will always
+** write a NULL.
+*/
+case OP_NullRow: {
+  int i = pOp->p1;
+  Cursor *pC;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  pC->nullRow = 1;
+  pC->rowidIsValid = 0;
+  break;
+}
+
+/* Opcode: Last P1 P2 * * *
+**
+** The next use of the Rowid or Column or Next instruction for P1 
+** will refer to the last entry in the database table or index.
+** If the table or index is empty and P2>0, then jump immediately to P2.
+** If P2 is 0 or if the table or index is not empty, fall through
+** to the following instruction.
+*/
+case OP_Last: {        /* jump */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  int res;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  pCrsr = pC->pCursor;
+  assert( pCrsr!=0 );
+  rc = sqlite3BtreeLast(pCrsr, &res);
+  pC->nullRow = res;
+  pC->deferredMoveto = 0;
+  pC->cacheStatus = CACHE_STALE;
+  if( res && pOp->p2>0 ){
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+
+/* Opcode: Sort P1 P2 * * *
+**
+** This opcode does exactly the same thing as OP_Rewind except that
+** it increments an undocumented global variable used for testing.
+**
+** Sorting is accomplished by writing records into a sorting index,
+** then rewinding that index and playing it back from beginning to
+** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
+** rewinding so that the global variable will be incremented and
+** regression tests can determine whether or not the optimizer is
+** correctly optimizing out sorts.
+*/
+case OP_Sort: {        /* jump */
+#ifdef SQLITE_TEST
+  sqlite3_sort_count++;
+  sqlite3_search_count--;
+#endif
+  /* Fall through into OP_Rewind */
+}
+/* Opcode: Rewind P1 P2 * * *
+**
+** The next use of the Rowid or Column or Next instruction for P1 
+** will refer to the first entry in the database table or index.
+** If the table or index is empty and P2>0, then jump immediately to P2.
+** If P2 is 0 or if the table or index is not empty, fall through
+** to the following instruction.
+*/
+case OP_Rewind: {        /* jump */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  int res;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = p->apCsr[i];
+  assert( pC!=0 );
+  if( (pCrsr = pC->pCursor)!=0 ){
+    rc = sqlite3BtreeFirst(pCrsr, &res);
+    pC->atFirst = res==0;
+    pC->deferredMoveto = 0;
+    pC->cacheStatus = CACHE_STALE;
+  }else{
+    res = 1;
+  }
+  pC->nullRow = res;
+  assert( pOp->p2>0 && pOp->p2<p->nOp );
+  if( res ){
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: Next P1 P2 * * *
+**
+** Advance cursor P1 so that it points to the next key/data pair in its
+** table or index.  If there are no more key/value pairs then fall through
+** to the following instruction.  But if the cursor advance was successful,
+** jump immediately to P2.
+**
+** The P1 cursor must be for a real table, not a pseudo-table.
+**
+** See also: Prev
+*/
+/* Opcode: Prev P1 P2 * * *
+**
+** Back up cursor P1 so that it points to the previous key/data pair in its
+** table or index.  If there is no previous key/value pairs then fall through
+** to the following instruction.  But if the cursor backup was successful,
+** jump immediately to P2.
+**
+** The P1 cursor must be for a real table, not a pseudo-table.
+*/
+case OP_Prev:          /* jump */
+case OP_Next: {        /* jump */
+  Cursor *pC;
+  BtCursor *pCrsr;
+    int res;
+
+  CHECK_FOR_INTERRUPT;
+  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
+  pC = p->apCsr[pOp->p1];
+  if( pC==0 ){
+    break;  /* See ticket #2273 */
+  }
+  pCrsr = pC->pCursor;
+  assert( pCrsr );
+  if( pC->nullRow ){
+    res = 1;
+  }else{
+    assert( pC->deferredMoveto==0 );
+    rc = pOp->opcode==OP_Next ? sqlite3BtreeNext(pCrsr, &res) :
+                                sqlite3BtreePrevious(pCrsr, &res);
+    pC->nullRow = res;
+    pC->cacheStatus = CACHE_STALE;
+    if( res==0 ){
+      pc = pOp->p2 - 1;
+#ifdef SQLITE_TEST
+      sqlite3_search_count++;
+#endif
+    }
+  }
+  pC->rowidIsValid = 0;
+  break;
+}
+
+/* Opcode: IdxInsert P1 P2 P3 * *
+**
+** Register P2 holds a SQL index key made using the
+** MakeIdxRec instructions.  This opcode writes that key
+** into the index P1.  Data for the entry is nil.
+**
+** P3 is a flag that provides a hint to the b-tree layer that this
+** insert is likely to be an append.
+**
+** This instruction only works for indices.  The equivalent instruction
+** for tables is OP_Insert.
+*/
+case OP_IdxInsert: {        /* in2 */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  assert( pIn2->flags & MEM_Blob );
+  if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
+    assert( pC->isTable==0 );
+    rc = ExpandBlob(pIn2);
+    if( rc==SQLITE_OK ){
+      int nKey = pIn2->n;
+      const char *zKey = pIn2->z;
+      rc = sqlite3BtreeInsert(pCrsr, zKey, nKey, "", 0, 0, pOp->p3);
+      assert( pC->deferredMoveto==0 );
+      pC->cacheStatus = CACHE_STALE;
+    }
+  }
+  break;
+}
+
+/* Opcode: IdxDelete P1 P2 * * *
+**
+** The content of register P2 is an index key built using the either the
+** MakeIdxRec opcode.  Removes that entry from the index.
+*/
+case OP_IdxDelete: {        /* in2 */
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+  assert( pIn2->flags & MEM_Blob );
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
+    int res;
+    rc = sqlite3BtreeMoveto(pCrsr, pIn2->z, pIn2->n, 0, &res);
+    if( rc==SQLITE_OK && res==0 ){
+      rc = sqlite3BtreeDelete(pCrsr);
+    }
+    assert( pC->deferredMoveto==0 );
+    pC->cacheStatus = CACHE_STALE;
+  }
+  break;
+}
+
+/* Opcode: IdxRowid P1 P2 * * *
+**
+** Write into register P2 an integer which is the last entry in the record at
+** the end of the index key pointed to by cursor P1.  This integer should be
+** the rowid of the table entry to which this index entry points.
+**
+** See also: Rowid, MakeIdxRec.
+*/
+case OP_IdxRowid: {              /* out2-prerelease */
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+  Cursor *pC;
+
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
+    i64 rowid;
+
+    assert( pC->deferredMoveto==0 );
+    assert( pC->isTable==0 );
+    if( !pC->nullRow ){
+      rc = sqlite3VdbeIdxRowid(pCrsr, &rowid);
+      if( rc!=SQLITE_OK ){
+        goto abort_due_to_error;
+      }
+      pOut->flags = MEM_Int;
+      pOut->u.i = rowid;
+    }
+  }
+  break;
+}
+
+/* Opcode: IdxGE P1 P2 P3 * P5
+**
+** The value in register P3 is an index entry that omits the ROWID.  Compare
+** this value against the index that P1 is currently pointing to.
+** Ignore the ROWID on the P1 index.
+**
+** If the P1 index entry is greater than or equal to the value in 
+** register P3 then jump to P2.  Otherwise fall through to the next 
+** instruction.
+**
+** If P5 is non-zero then the value in register P3 is temporarily
+** increased by an epsilon prior to the comparison.  This make the opcode work
+** like IdxGT except that if the key from register P3 is a prefix of
+** the key in the cursor, the result is false whereas it would be
+** true with IdxGT.
+*/
+/* Opcode: IdxLT P1 P2 P3 * P5
+**
+** The value in register P3 is an index entry that omits the ROWID.  Compare
+** the this value against the index that P1 is currently pointing to.
+** Ignore the ROWID on the P1 index.
+**
+** If the P1 index entry is less than the register P3 value
+** then jump to P2.  Otherwise fall through to the next instruction.
+**
+** If P5 is non-zero then the
+** index taken from register P3 is temporarily increased by
+** an epsilon prior to the comparison.  This makes the opcode work
+** like IdxLE.
+*/
+case OP_IdxLT:          /* jump, in3 */
+case OP_IdxGE: {        /* jump, in3 */
+  int i= pOp->p1;
+  Cursor *pC;
+
+  assert( i>=0 && i<p->nCursor );
+  assert( p->apCsr[i]!=0 );
+  if( (pC = p->apCsr[i])->pCursor!=0 ){
+    int res;
+ 
+    assert( pIn3->flags & MEM_Blob );  /* Created using OP_MakeRecord */
+    assert( pC->deferredMoveto==0 );
+    ExpandBlob(pIn3);
+    assert( pOp->p5==0 || pOp->p5==1 );
+    *pC->pIncrKey = pOp->p5;
+    rc = sqlite3VdbeIdxKeyCompare(pC, pIn3->n, (u8*)pIn3->z, &res);
+    *pC->pIncrKey = 0;
+    if( rc!=SQLITE_OK ){
+      break;
+    }
+    if( pOp->opcode==OP_IdxLT ){
+      res = -res;
+    }else{
+      assert( pOp->opcode==OP_IdxGE );
+      res++;
+    }
+    if( res>0 ){
+      pc = pOp->p2 - 1 ;
+    }
+  }
+  break;
+}
+
+/* Opcode: Destroy P1 P2 P3 * *
+**
+** Delete an entire database table or index whose root page in the database
+** file is given by P1.
+**
+** The table being destroyed is in the main database file if P3==0.  If
+** P3==1 then the table to be clear is in the auxiliary database file
+** that is used to store tables create using CREATE TEMPORARY TABLE.
+**
+** If AUTOVACUUM is enabled then it is possible that another root page
+** might be moved into the newly deleted root page in order to keep all
+** root pages contiguous at the beginning of the database.  The former
+** value of the root page that moved - its value before the move occurred -
+** is stored in register P2.  If no page 
+** movement was required (because the table being dropped was already 
+** the last one in the database) then a zero is stored in register P2.
+** If AUTOVACUUM is disabled then a zero is stored in register P2.
+**
+** See also: Clear
+*/
+case OP_Destroy: {     /* out2-prerelease */
+  int iMoved;
+  int iCnt;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  Vdbe *pVdbe;
+  iCnt = 0;
+  for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
+    if( pVdbe->magic==VDBE_MAGIC_RUN && pVdbe->inVtabMethod<2 && pVdbe->pc>=0 ){
+      iCnt++;
+    }
+  }
+#else
+  iCnt = db->activeVdbeCnt;
+#endif
+  if( iCnt>1 ){
+    rc = SQLITE_LOCKED;
+    p->errorAction = OE_Abort;
+  }else{
+    int iDb = pOp->p3;
+    assert( iCnt==1 );
+    assert( (p->btreeMask & (1<<iDb))!=0 );
+    rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
+    pOut->flags = MEM_Int;
+    pOut->u.i = iMoved;
+#ifndef SQLITE_OMIT_AUTOVACUUM
+    if( rc==SQLITE_OK && iMoved!=0 ){
+      sqlite3RootPageMoved(&db->aDb[iDb], iMoved, pOp->p1);
+    }
+#endif
+  }
+  break;
+}
+
+/* Opcode: Clear P1 P2 *
+**
+** Delete all contents of the database table or index whose root page
+** in the database file is given by P1.  But, unlike Destroy, do not
+** remove the table or index from the database file.
+**
+** The table being clear is in the main database file if P2==0.  If
+** P2==1 then the table to be clear is in the auxiliary database file
+** that is used to store tables create using CREATE TEMPORARY TABLE.
+**
+** See also: Destroy
+*/
+case OP_Clear: {
+  assert( (p->btreeMask & (1<<pOp->p2))!=0 );
+  rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);
+  break;
+}
+
+/* Opcode: CreateTable P1 P2 * * *
+**
+** Allocate a new table in the main database file if P1==0 or in the
+** auxiliary database file if P1==1 or in an attached database if
+** P1>1.  Write the root page number of the new table into
+** register P2
+**
+** The difference between a table and an index is this:  A table must
+** have a 4-byte integer key and can have arbitrary data.  An index
+** has an arbitrary key but no data.
+**
+** See also: CreateIndex
+*/
+/* Opcode: CreateIndex P1 P2 * * *
+**
+** Allocate a new index in the main database file if P1==0 or in the
+** auxiliary database file if P1==1 or in an attached database if
+** P1>1.  Write the root page number of the new table into
+** register P2.
+**
+** See documentation on OP_CreateTable for additional information.
+*/
+case OP_CreateIndex:            /* out2-prerelease */
+case OP_CreateTable: {          /* out2-prerelease */
+  int pgno;
+  int flags;
+  Db *pDb;
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( (p->btreeMask & (1<<pOp->p1))!=0 );
+  pDb = &db->aDb[pOp->p1];
+  assert( pDb->pBt!=0 );
+  if( pOp->opcode==OP_CreateTable ){
+    /* flags = BTREE_INTKEY; */
+    flags = BTREE_LEAFDATA|BTREE_INTKEY;
+  }else{
+    flags = BTREE_ZERODATA;
+  }
+  rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
+  if( rc==SQLITE_OK ){
+    pOut->u.i = pgno;
+    pOut->flags = MEM_Int;
+  }
+  break;
+}
+
+/* Opcode: ParseSchema P1 P2 * P4 *
+**
+** Read and parse all entries from the SQLITE_MASTER table of database P1
+** that match the WHERE clause P4.  P2 is the "force" flag.   Always do
+** the parsing if P2 is true.  If P2 is false, then this routine is a
+** no-op if the schema is not currently loaded.  In other words, if P2
+** is false, the SQLITE_MASTER table is only parsed if the rest of the
+** schema is already loaded into the symbol table.
+**
+** This opcode invokes the parser to create a new virtual machine,
+** then runs the new virtual machine.  It is thus a reentrant opcode.
+*/
+case OP_ParseSchema: {
+  char *zSql;
+  int iDb = pOp->p1;
+  const char *zMaster;
+  InitData initData;
+
+  assert( iDb>=0 && iDb<db->nDb );
+  if( !pOp->p2 && !DbHasProperty(db, iDb, DB_SchemaLoaded) ){
+    break;
+  }
+  zMaster = SCHEMA_TABLE(iDb);
+  initData.db = db;
+  initData.iDb = pOp->p1;
+  initData.pzErrMsg = &p->zErrMsg;
+  zSql = sqlite3MPrintf(db,
+     "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s",
+     db->aDb[iDb].zName, zMaster, pOp->p4.z);
+  if( zSql==0 ) goto no_mem;
+  (void)sqlite3SafetyOff(db);
+  assert( db->init.busy==0 );
+  db->init.busy = 1;
+  assert( !db->mallocFailed );
+  rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
+  if( rc==SQLITE_ABORT ) rc = initData.rc;
+  sqlite3_free(zSql);
+  db->init.busy = 0;
+  (void)sqlite3SafetyOn(db);
+  if( rc==SQLITE_NOMEM ){
+    goto no_mem;
+  }
+  break;  
+}
+
+#if !defined(SQLITE_OMIT_ANALYZE) && !defined(SQLITE_OMIT_PARSER)
+/* Opcode: LoadAnalysis P1 * * * *
+**
+** Read the sqlite_stat1 table for database P1 and load the content
+** of that table into the internal index hash table.  This will cause
+** the analysis to be used when preparing all subsequent queries.
+*/
+case OP_LoadAnalysis: {
+  int iDb = pOp->p1;
+  assert( iDb>=0 && iDb<db->nDb );
+  rc = sqlite3AnalysisLoad(db, iDb);
+  break;  
+}
+#endif /* !defined(SQLITE_OMIT_ANALYZE) && !defined(SQLITE_OMIT_PARSER)  */
+
+/* Opcode: DropTable P1 * * P4 *
+**
+** Remove the internal (in-memory) data structures that describe
+** the table named P4 in database P1.  This is called after a table
+** is dropped in order to keep the internal representation of the
+** schema consistent with what is on disk.
+*/
+case OP_DropTable: {
+  sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
+  break;
+}
+
+/* Opcode: DropIndex P1 * * P4 *
+**
+** Remove the internal (in-memory) data structures that describe
+** the index named P4 in database P1.  This is called after an index
+** is dropped in order to keep the internal representation of the
+** schema consistent with what is on disk.
+*/
+case OP_DropIndex: {
+  sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
+  break;
+}
+
+/* Opcode: DropTrigger P1 * * P4 *
+**
+** Remove the internal (in-memory) data structures that describe
+** the trigger named P4 in database P1.  This is called after a trigger
+** is dropped in order to keep the internal representation of the
+** schema consistent with what is on disk.
+*/
+case OP_DropTrigger: {
+  sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
+  break;
+}
+
+
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK
+/* Opcode: IntegrityCk P1 P2 P3 * P5
+**
+** Do an analysis of the currently open database.  Store in
+** register P1 the text of an error message describing any problems.
+** If no problems are found, store a NULL in register P1.
+**
+** The register P3 contains the maximum number of allowed errors.
+** At most reg(P3) errors will be reported.
+** In other words, the analysis stops as soon as reg(P1) errors are 
+** seen.  Reg(P1) is updated with the number of errors remaining.
+**
+** The root page numbers of all tables in the database are integer
+** stored in reg(P1), reg(P1+1), reg(P1+2), ....  There are P2 tables
+** total.
+**
+** If P5 is not zero, the check is done on the auxiliary database
+** file, not the main database file.
+**
+** This opcode is used to implement the integrity_check pragma.
+*/
+case OP_IntegrityCk: {
+  int nRoot;      /* Number of tables to check.  (Number of root pages.) */
+  int *aRoot;     /* Array of rootpage numbers for tables to be checked */
+  int j;          /* Loop counter */
+  int nErr;       /* Number of errors reported */
+  char *z;        /* Text of the error report */
+  Mem *pnErr;     /* Register keeping track of errors remaining */
+  
+  nRoot = pOp->p2;
+  assert( nRoot>0 );
+  aRoot = sqlite3_malloc( sizeof(int)*(nRoot+1) );
+  if( aRoot==0 ) goto no_mem;
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  pnErr = &p->aMem[pOp->p3];
+  assert( (pnErr->flags & MEM_Int)!=0 );
+  assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
+  pIn1 = &p->aMem[pOp->p1];
+  for(j=0; j<nRoot; j++){
+    aRoot[j] = sqlite3VdbeIntValue(&pIn1[j]);
+  }
+  aRoot[j] = 0;
+  assert( pOp->p5<db->nDb );
+  assert( (p->btreeMask & (1<<pOp->p5))!=0 );
+  z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
+                                 pnErr->u.i, &nErr);
+  pnErr->u.i -= nErr;
+  sqlite3VdbeMemSetNull(pIn1);
+  if( nErr==0 ){
+    assert( z==0 );
+  }else{
+    pIn1->z = z;
+    pIn1->n = strlen(z);
+    pIn1->flags = MEM_Str | MEM_Dyn | MEM_Term;
+    pIn1->xDel = 0;
+  }
+  pIn1->enc = SQLITE_UTF8;
+  UPDATE_MAX_BLOBSIZE(pIn1);
+  sqlite3VdbeChangeEncoding(pIn1, encoding);
+  sqlite3_free(aRoot);
+  break;
+}
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
+
+/* Opcode: FifoWrite P1 * * * *
+**
+** Write the integer from register P1 into the Fifo.
+*/
+case OP_FifoWrite: {        /* in1 */
+  if( sqlite3VdbeFifoPush(&p->sFifo, sqlite3VdbeIntValue(pIn1))==SQLITE_NOMEM ){
+    goto no_mem;
+  }
+  break;
+}
+
+/* Opcode: FifoRead P1 P2 * * *
+**
+** Attempt to read a single integer from the Fifo.  Store that
+** integer in register P1.
+** 
+** If the Fifo is empty jump to P2.
+*/
+case OP_FifoRead: {         /* jump */
+  CHECK_FOR_INTERRUPT;
+  assert( pOp->p1>0 && pOp->p1<=p->nMem );
+  pOut = &p->aMem[pOp->p1];
+  Release(pOut);
+  pOut->flags = MEM_Int;
+  if( sqlite3VdbeFifoPop(&p->sFifo, &pOut->u.i)==SQLITE_DONE ){
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+#ifndef SQLITE_OMIT_TRIGGER
+/* Opcode: ContextPush * * * 
+**
+** Save the current Vdbe context such that it can be restored by a ContextPop
+** opcode. The context stores the last insert row id, the last statement change
+** count, and the current statement change count.
+*/
+case OP_ContextPush: {
+  int i = p->contextStackTop++;
+  Context *pContext;
+
+  assert( i>=0 );
+  /* FIX ME: This should be allocated as part of the vdbe at compile-time */
+  if( i>=p->contextStackDepth ){
+    p->contextStackDepth = i+1;
+    p->contextStack = sqlite3DbReallocOrFree(db, p->contextStack,
+                                          sizeof(Context)*(i+1));
+    if( p->contextStack==0 ) goto no_mem;
+  }
+  pContext = &p->contextStack[i];
+  pContext->lastRowid = db->lastRowid;
+  pContext->nChange = p->nChange;
+  pContext->sFifo = p->sFifo;
+  sqlite3VdbeFifoInit(&p->sFifo);
+  break;
+}
+
+/* Opcode: ContextPop * * * 
+**
+** Restore the Vdbe context to the state it was in when contextPush was last
+** executed. The context stores the last insert row id, the last statement
+** change count, and the current statement change count.
+*/
+case OP_ContextPop: {
+  Context *pContext = &p->contextStack[--p->contextStackTop];
+  assert( p->contextStackTop>=0 );
+  db->lastRowid = pContext->lastRowid;
+  p->nChange = pContext->nChange;
+  sqlite3VdbeFifoClear(&p->sFifo);
+  p->sFifo = pContext->sFifo;
+  break;
+}
+#endif /* #ifndef SQLITE_OMIT_TRIGGER */
+
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+/* Opcode: MemMax P1 P2 * * *
+**
+** Set the value of register P1 to the maximum of its current value
+** and the value in register P2.
+**
+** This instruction throws an error if the memory cell is not initially
+** an integer.
+*/
+case OP_MemMax: {        /* in1, in2 */
+  sqlite3VdbeMemIntegerify(pIn1);
+  sqlite3VdbeMemIntegerify(pIn2);
+  if( pIn1->u.i<pIn2->u.i){
+    pIn1->u.i = pIn2->u.i;
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_AUTOINCREMENT */
+
+/* Opcode: IfPos P1 P2 * * *
+**
+** If the value of register P1 is 1 or greater, jump to P2.
+**
+** It is illegal to use this instruction on a register that does
+** not contain an integer.  An assertion fault will result if you try.
+*/
+case OP_IfPos: {        /* jump, in1 */
+  assert( pIn1->flags==MEM_Int );
+  if( pIn1->u.i>0 ){
+     pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: IfNeg P1 P2 * * *
+**
+** If the value of register P1 is less than zero, jump to P2. 
+**
+** It is illegal to use this instruction on a register that does
+** not contain an integer.  An assertion fault will result if you try.
+*/
+case OP_IfNeg: {        /* jump, in1 */
+  assert( pIn1->flags==MEM_Int );
+  if( pIn1->u.i<0 ){
+     pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: IfZero P1 P2 * * *
+**
+** If the value of register P1 is exactly 0, jump to P2. 
+**
+** It is illegal to use this instruction on a register that does
+** not contain an integer.  An assertion fault will result if you try.
+*/
+case OP_IfZero: {        /* jump, in1 */
+  assert( pIn1->flags==MEM_Int );
+  if( pIn1->u.i==0 ){
+     pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: AggStep * P2 P3 P4 P5
+**
+** Execute the step function for an aggregate.  The
+** function has P5 arguments.   P4 is a pointer to the FuncDef
+** structure that specifies the function.  Use register
+** P3 as the accumulator.
+**
+** The P5 arguments are taken from register P2 and its
+** successors.
+*/
+case OP_AggStep: {
+  int n = pOp->p5;
+  int i;
+  Mem *pMem, *pRec;
+  sqlite3_context ctx;
+  sqlite3_value **apVal;
+
+  assert( n>=0 );
+  pRec = &p->aMem[pOp->p2];
+  apVal = p->apArg;
+  assert( apVal || n==0 );
+  for(i=0; i<n; i++, pRec++){
+    apVal[i] = pRec;
+    storeTypeInfo(pRec, encoding);
+  }
+  ctx.pFunc = pOp->p4.pFunc;
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  ctx.pMem = pMem = &p->aMem[pOp->p3];
+  pMem->n++;
+  ctx.s.flags = MEM_Null;
+  ctx.s.z = 0;
+  ctx.s.xDel = 0;
+  ctx.s.db = db;
+  ctx.isError = 0;
+  ctx.pColl = 0;
+  if( ctx.pFunc->needCollSeq ){
+    assert( pOp>p->aOp );
+    assert( pOp[-1].p4type==P4_COLLSEQ );
+    assert( pOp[-1].opcode==OP_CollSeq );
+    ctx.pColl = pOp[-1].p4.pColl;
+  }
+  (ctx.pFunc->xStep)(&ctx, n, apVal);
+  if( ctx.isError ){
+    sqlite3SetString(&p->zErrMsg, sqlite3_value_text(&ctx.s), (char*)0);
+    rc = ctx.isError;
+  }
+  sqlite3VdbeMemRelease(&ctx.s);
+  break;
+}
+
+/* Opcode: AggFinal P1 P2 * P4 *
+**
+** Execute the finalizer function for an aggregate.  P1 is
+** the memory location that is the accumulator for the aggregate.
+**
+** P2 is the number of arguments that the step function takes and
+** P4 is a pointer to the FuncDef for this function.  The P2
+** argument is not used by this opcode.  It is only there to disambiguate
+** functions that can take varying numbers of arguments.  The
+** P4 argument is only needed for the degenerate case where
+** the step function was not previously called.
+*/
+case OP_AggFinal: {
+  Mem *pMem;
+  assert( pOp->p1>0 && pOp->p1<=p->nMem );
+  pMem = &p->aMem[pOp->p1];
+  assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
+  rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
+  if( rc==SQLITE_ERROR ){
+    sqlite3SetString(&p->zErrMsg, sqlite3_value_text(pMem), (char*)0);
+  }
+  UPDATE_MAX_BLOBSIZE(pMem);
+  if( sqlite3VdbeMemTooBig(pMem) ){
+    goto too_big;
+  }
+  break;
+}
+
+
+#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
+/* Opcode: Vacuum * * * * *
+**
+** Vacuum the entire database.  This opcode will cause other virtual
+** machines to be created and run.  It may not be called from within
+** a transaction.
+*/
+case OP_Vacuum: {
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse; 
+  rc = sqlite3RunVacuum(&p->zErrMsg, db);
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+  break;
+}
+#endif
+
+#if !defined(SQLITE_OMIT_AUTOVACUUM)
+/* Opcode: IncrVacuum P1 P2 * * *
+**
+** Perform a single step of the incremental vacuum procedure on
+** the P1 database. If the vacuum has finished, jump to instruction
+** P2. Otherwise, fall through to the next instruction.
+*/
+case OP_IncrVacuum: {        /* jump */
+  Btree *pBt;
+
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( (p->btreeMask & (1<<pOp->p1))!=0 );
+  pBt = db->aDb[pOp->p1].pBt;
+  rc = sqlite3BtreeIncrVacuum(pBt);
+  if( rc==SQLITE_DONE ){
+    pc = pOp->p2 - 1;
+    rc = SQLITE_OK;
+  }
+  break;
+}
+#endif
+
+/* Opcode: Expire P1 * * * *
+**
+** Cause precompiled statements to become expired. An expired statement
+** fails with an error code of SQLITE_SCHEMA if it is ever executed 
+** (via sqlite3_step()).
+** 
+** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
+** then only the currently executing statement is affected. 
+*/
+case OP_Expire: {
+  if( !pOp->p1 ){
+    sqlite3ExpirePreparedStatements(db);
+  }else{
+    p->expired = 1;
+  }
+  break;
+}
+
+#ifndef SQLITE_OMIT_SHARED_CACHE
+/* Opcode: TableLock P1 P2 * P4 *
+**
+** Obtain a lock on a particular table. This instruction is only used when
+** the shared-cache feature is enabled. 
+**
+** If P1 is not negative, then it is the index of the database
+** in sqlite3.aDb[] and a read-lock is required. If P1 is negative, a 
+** write-lock is required. In this case the index of the database is the 
+** absolute value of P1 minus one (iDb = abs(P1) - 1;) and a write-lock is
+** required. 
+**
+** P2 contains the root-page of the table to lock.
+**
+** P4 contains a pointer to the name of the table being locked. This is only
+** used to generate an error message if the lock cannot be obtained.
+*/
+case OP_TableLock: {
+  int p1 = pOp->p1; 
+  u8 isWriteLock = (p1<0);
+  if( isWriteLock ){
+    p1 = (-1*p1)-1;
+  }
+  assert( p1>=0 && p1<db->nDb );
+  assert( (p->btreeMask & (1<<p1))!=0 );
+  rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
+  if( rc==SQLITE_LOCKED ){
+    const char *z = pOp->p4.z;
+    sqlite3SetString(&p->zErrMsg, "database table is locked: ", z, (char*)0);
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_SHARED_CACHE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VBegin * * * P4 *
+**
+** P4 a pointer to an sqlite3_vtab structure. Call the xBegin method 
+** for that table.
+*/
+case OP_VBegin: {
+  rc = sqlite3VtabBegin(db, pOp->p4.pVtab);
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VCreate P1 * * P4 *
+**
+** P4 is the name of a virtual table in database P1. Call the xCreate method
+** for that table.
+*/
+case OP_VCreate: {
+  rc = sqlite3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VDestroy P1 * * P4 *
+**
+** P4 is the name of a virtual table in database P1.  Call the xDestroy method
+** of that table.
+*/
+case OP_VDestroy: {
+  p->inVtabMethod = 2;
+  rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
+  p->inVtabMethod = 0;
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VOpen P1 * * P4 *
+**
+** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
+** P1 is a cursor number.  This opcode opens a cursor to the virtual
+** table and stores that cursor in P1.
+*/
+case OP_VOpen: {
+  Cursor *pCur = 0;
+  sqlite3_vtab_cursor *pVtabCursor = 0;
+
+  sqlite3_vtab *pVtab = pOp->p4.pVtab;
+  sqlite3_module *pModule = (sqlite3_module *)pVtab->pModule;
+
+  assert(pVtab && pModule);
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  rc = pModule->xOpen(pVtab, &pVtabCursor);
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+  if( SQLITE_OK==rc ){
+    /* Initialise sqlite3_vtab_cursor base class */
+    pVtabCursor->pVtab = pVtab;
+
+    /* Initialise vdbe cursor object */
+    pCur = allocateCursor(p, pOp->p1, -1);
+    if( pCur ){
+      pCur->pVtabCursor = pVtabCursor;
+      pCur->pModule = pVtabCursor->pVtab->pModule;
+    }else{
+      db->mallocFailed = 1;
+      pModule->xClose(pVtabCursor);
+    }
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VFilter P1 P2 P3 P4 *
+**
+** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
+** the filtered result set is empty.
+**
+** P4 is either NULL or a string that was generated by the xBestIndex
+** method of the module.  The interpretation of the P4 string is left
+** to the module implementation.
+**
+** This opcode invokes the xFilter method on the virtual table specified
+** by P1.  The integer query plan parameter to xFilter is stored in register
+** P3. Register P3+1 stores the argc parameter to be passed to the
+** xFilter method. Registers P3+2..P3+1+argc are the argc additional
+** parametersneath additional parameters which are passed to
+** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
+**
+** A jump is made to P2 if the result set after filtering would be empty.
+*/
+case OP_VFilter: {   /* jump */
+  int nArg;
+  int iQuery;
+  const sqlite3_module *pModule;
+  Mem *pQuery = &p->aMem[pOp->p3];
+  Mem *pArgc = &pQuery[1];
+
+  Cursor *pCur = p->apCsr[pOp->p1];
+
+  REGISTER_TRACE(pOp->p3, pQuery);
+  assert( pCur->pVtabCursor );
+  pModule = pCur->pVtabCursor->pVtab->pModule;
+
+  /* Grab the index number and argc parameters */
+  assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
+  nArg = pArgc->u.i;
+  iQuery = pQuery->u.i;
+
+  /* Invoke the xFilter method */
+  {
+    int res = 0;
+    int i;
+    Mem **apArg = p->apArg;
+    for(i = 0; i<nArg; i++){
+      apArg[i] = &pArgc[i+1];
+      storeTypeInfo(apArg[i], 0);
+    }
+
+    if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+    p->inVtabMethod = 1;
+    rc = pModule->xFilter(pCur->pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
+    p->inVtabMethod = 0;
+    if( rc==SQLITE_OK ){
+      res = pModule->xEof(pCur->pVtabCursor);
+    }
+    if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+
+    if( res ){
+      pc = pOp->p2 - 1;
+    }
+  }
+  pCur->nullRow = 0;
+
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VRowid P1 P2 * * *
+**
+** Store into register P2  the rowid of
+** the virtual-table that the P1 cursor is pointing to.
+*/
+case OP_VRowid: {             /* out2-prerelease */
+  const sqlite3_module *pModule;
+  sqlite_int64 iRow;
+  Cursor *pCur = p->apCsr[pOp->p1];
+
+  assert( pCur->pVtabCursor );
+  if( pCur->nullRow ){
+    break;
+  }
+  pModule = pCur->pVtabCursor->pVtab->pModule;
+  assert( pModule->xRowid );
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  rc = pModule->xRowid(pCur->pVtabCursor, &iRow);
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+  pOut->flags = MEM_Int;
+  pOut->u.i = iRow;
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VColumn P1 P2 P3 * *
+**
+** Store the value of the P2-th column of
+** the row of the virtual-table that the 
+** P1 cursor is pointing to into register P3.
+*/
+case OP_VColumn: {
+  const sqlite3_module *pModule;
+  Mem *pDest;
+  sqlite3_context sContext;
+
+  Cursor *pCur = p->apCsr[pOp->p1];
+  assert( pCur->pVtabCursor );
+  assert( pOp->p3>0 && pOp->p3<=p->nMem );
+  pDest = &p->aMem[pOp->p3];
+  if( pCur->nullRow ){
+    sqlite3VdbeMemSetNull(pDest);
+    break;
+  }
+  pModule = pCur->pVtabCursor->pVtab->pModule;
+  assert( pModule->xColumn );
+  memset(&sContext, 0, sizeof(sContext));
+  sContext.s.flags = MEM_Null;
+  sContext.s.db = db;
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
+
+  /* Copy the result of the function to the P3 register. We
+  ** do this regardless of whether or not an error occured to ensure any
+  ** dynamic allocation in sContext.s (a Mem struct) is  released.
+  */
+  sqlite3VdbeChangeEncoding(&sContext.s, encoding);
+  REGISTER_TRACE(pOp->p3, pDest);
+  sqlite3VdbeMemMove(pDest, &sContext.s);
+  UPDATE_MAX_BLOBSIZE(pDest);
+
+  if( sqlite3SafetyOn(db) ){
+    goto abort_due_to_misuse;
+  }
+  if( sqlite3VdbeMemTooBig(pDest) ){
+    goto too_big;
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VNext P1 P2 * * *
+**
+** Advance virtual table P1 to the next row in its result set and
+** jump to instruction P2.  Or, if the virtual table has reached
+** the end of its result set, then fall through to the next instruction.
+*/
+case OP_VNext: {   /* jump */
+  const sqlite3_module *pModule;
+  int res = 0;
+
+  Cursor *pCur = p->apCsr[pOp->p1];
+  assert( pCur->pVtabCursor );
+  if( pCur->nullRow ){
+    break;
+  }
+  pModule = pCur->pVtabCursor->pVtab->pModule;
+  assert( pModule->xNext );
+
+  /* Invoke the xNext() method of the module. There is no way for the
+  ** underlying implementation to return an error if one occurs during
+  ** xNext(). Instead, if an error occurs, true is returned (indicating that 
+  ** data is available) and the error code returned when xColumn or
+  ** some other method is next invoked on the save virtual table cursor.
+  */
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  p->inVtabMethod = 1;
+  rc = pModule->xNext(pCur->pVtabCursor);
+  p->inVtabMethod = 0;
+  if( rc==SQLITE_OK ){
+    res = pModule->xEof(pCur->pVtabCursor);
+  }
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+
+  if( !res ){
+    /* If there is data, jump to P2 */
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VRename P1 * * P4 *
+**
+** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
+** This opcode invokes the corresponding xRename method. The value
+** in register P1 is passed as the zName argument to the xRename method.
+*/
+case OP_VRename: {
+  sqlite3_vtab *pVtab = pOp->p4.pVtab;
+  Mem *pName = &p->aMem[pOp->p1];
+  assert( pVtab->pModule->xRename );
+  REGISTER_TRACE(pOp->p1, pName);
+
+  Stringify(pName, encoding);
+
+  if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+  sqlite3VtabLock(pVtab);
+  rc = pVtab->pModule->xRename(pVtab, pName->z);
+  sqlite3VtabUnlock(db, pVtab);
+  if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+
+  break;
+}
+#endif
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/* Opcode: VUpdate P1 P2 P3 P4 *
+**
+** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
+** This opcode invokes the corresponding xUpdate method. P2 values
+** are contiguous memory cells starting at P3 to pass to the xUpdate 
+** invocation. The value in register (P3+P2-1) corresponds to the 
+** p2th element of the argv array passed to xUpdate.
+**
+** The xUpdate method will do a DELETE or an INSERT or both.
+** The argv[0] element (which corresponds to memory cell P3)
+** is the rowid of a row to delete.  If argv[0] is NULL then no 
+** deletion occurs.  The argv[1] element is the rowid of the new 
+** row.  This can be NULL to have the virtual table select the new 
+** rowid for itself.  The subsequent elements in the array are 
+** the values of columns in the new row.
+**
+** If P2==1 then no insert is performed.  argv[0] is the rowid of
+** a row to delete.
+**
+** P1 is a boolean flag. If it is set to true and the xUpdate call
+** is successful, then the value returned by sqlite3_last_insert_rowid() 
+** is set to the value of the rowid for the row just inserted.
+*/
+case OP_VUpdate: {
+  sqlite3_vtab *pVtab = pOp->p4.pVtab;
+  sqlite3_module *pModule = (sqlite3_module *)pVtab->pModule;
+  int nArg = pOp->p2;
+  assert( pOp->p4type==P4_VTAB );
+  if( pModule->xUpdate==0 ){
+    sqlite3SetString(&p->zErrMsg, "read-only table", 0);
+    rc = SQLITE_ERROR;
+  }else{
+    int i;
+    sqlite_int64 rowid;
+    Mem **apArg = p->apArg;
+    Mem *pX = &p->aMem[pOp->p3];
+    for(i=0; i<nArg; i++){
+      storeTypeInfo(pX, 0);
+      apArg[i] = pX;
+      pX++;
+    }
+    if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
+    sqlite3VtabLock(pVtab);
+    rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
+    sqlite3VtabUnlock(db, pVtab);
+    if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+    if( pOp->p1 && rc==SQLITE_OK ){
+      assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
+      db->lastRowid = rowid;
+    }
+  }
+  break;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+#ifndef SQLITE_OMIT_TRACE
+/* Opcode: Trace * * * P4 *
+**
+** If tracing is enabled (by the sqlite3_trace()) interface, then
+** the UTF-8 string contained in P4 is emitted on the trace callback.
+*/
+case OP_Trace: {
+  if( pOp->p4.z ){
+    if( db->xTrace ){
+      db->xTrace(db->pTraceArg, pOp->p4.z);
+    }
+#ifdef SQLITE_DEBUG
+    if( (db->flags & SQLITE_SqlTrace)!=0 ){
+      sqlite3DebugPrintf("SQL-trace: %s\n", pOp->p4.z);
+    }
+#endif /* SQLITE_DEBUG */
+  }
+  break;
+}
+#endif
+
+
+/* Opcode: Noop * * * * *
+**
+** Do nothing.  This instruction is often useful as a jump
+** destination.
+*/
+/*
+** The magic Explain opcode are only inserted when explain==2 (which
+** is to say when the EXPLAIN QUERY PLAN syntax is used.)
+** This opcode records information from the optimizer.  It is the
+** the same as a no-op.  This opcodesnever appears in a real VM program.
+*/
+default: {          /* This is really OP_Noop and OP_Explain */
+  break;
+}
+
+/*****************************************************************************
+** The cases of the switch statement above this line should all be indented
+** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
+** readability.  From this point on down, the normal indentation rules are
+** restored.
+*****************************************************************************/
+    }
+
+#ifdef VDBE_PROFILE
+    {
+      long long elapse = hwtime() - start;
+      pOp->cycles += elapse;
+      pOp->cnt++;
+#if 0
+        fprintf(stdout, "%10lld ", elapse);
+        sqlite3VdbePrintOp(stdout, origPc, &p->aOp[origPc]);
+#endif
+    }
+#endif
+
+    /* The following code adds nothing to the actual functionality
+    ** of the program.  It is only here for testing and debugging.
+    ** On the other hand, it does burn CPU cycles every time through
+    ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
+    */
+#ifndef NDEBUG
+    assert( pc>=-1 && pc<p->nOp );
+
+#ifdef SQLITE_DEBUG
+    if( p->trace ){
+      if( rc!=0 ) fprintf(p->trace,"rc=%d\n",rc);
+      if( opProperty & OPFLG_OUT2_PRERELEASE ){
+        registerTrace(p->trace, pOp->p2, pOut);
+      }
+      if( opProperty & OPFLG_OUT3 ){
+        registerTrace(p->trace, pOp->p3, pOut);
+      }
+    }
+#endif  /* SQLITE_DEBUG */
+#endif  /* NDEBUG */
+  }  /* The end of the for(;;) loop the loops through opcodes */
+
+  /* If we reach this point, it means that execution is finished with
+  ** an error of some kind.
+  */
+vdbe_error_halt:
+  assert( rc );
+  p->rc = rc;
+  rc = SQLITE_ERROR;
+  sqlite3VdbeHalt(p);
+
+  /* This is the only way out of this procedure.  We have to
+  ** release the mutexes on btrees that were acquired at the
+  ** top. */
+vdbe_return:
+  sqlite3BtreeMutexArrayLeave(&p->aMutex);
+  return rc;
+
+  /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
+  ** is encountered.
+  */
+too_big:
+  sqlite3SetString(&p->zErrMsg, "string or blob too big", (char*)0);
+  rc = SQLITE_TOOBIG;
+  goto vdbe_error_halt;
+
+  /* Jump to here if a malloc() fails.
+  */
+no_mem:
+  db->mallocFailed = 1;
+  sqlite3SetString(&p->zErrMsg, "out of memory", (char*)0);
+  rc = SQLITE_NOMEM;
+  goto vdbe_error_halt;
+
+  /* Jump to here for an SQLITE_MISUSE error.
+  */
+abort_due_to_misuse:
+  rc = SQLITE_MISUSE;
+  /* Fall thru into abort_due_to_error */
+
+  /* Jump to here for any other kind of fatal error.  The "rc" variable
+  ** should hold the error number.
+  */
+abort_due_to_error:
+  assert( p->zErrMsg==0 );
+  if( db->mallocFailed ) rc = SQLITE_NOMEM;
+  sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(rc), (char*)0);
+  goto vdbe_error_halt;
+
+  /* Jump to here if the sqlite3_interrupt() API sets the interrupt
+  ** flag.
+  */
+abort_due_to_interrupt:
+  assert( db->u1.isInterrupted );
+  rc = SQLITE_INTERRUPT;
+  p->rc = rc;
+  sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(rc), (char*)0);
+  goto vdbe_error_halt;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbe.h b/client/src/thirdparty/sqlite-3.4.2/src/vdbe.h
new file mode 100644
index 0000000..16b19dc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbe.h
@@ -0,0 +1,183 @@
+/*
+** 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.
+**
+*************************************************************************
+** Header file for the Virtual DataBase Engine (VDBE)
+**
+** This header defines the interface to the virtual database engine
+** or VDBE.  The VDBE implements an abstract machine that runs a
+** simple program to access and modify the underlying database.
+**
+** $Id: vdbe.h,v 1.125 2008/01/17 17:27:31 drh Exp $
+*/
+#ifndef _SQLITE_VDBE_H_
+#define _SQLITE_VDBE_H_
+#include <stdio.h>
+
+/*
+** A single VDBE is an opaque structure named "Vdbe".  Only routines
+** in the source file sqliteVdbe.c are allowed to see the insides
+** of this structure.
+*/
+typedef struct Vdbe Vdbe;
+
+/*
+** The names of the following types declared in vdbeInt.h are required
+** for the VdbeOp definition.
+*/
+typedef struct VdbeFunc VdbeFunc;
+typedef struct Mem Mem;
+
+/*
+** A single instruction of the virtual machine has an opcode
+** and as many as three operands.  The instruction is recorded
+** as an instance of the following structure:
+*/
+struct VdbeOp {
+  u8 opcode;          /* What operation to perform */
+  signed char p4type; /* One of the P4_xxx constants for p4 */
+  u8 flags;           /* Flags for internal use */
+  u8 p5;              /* Fifth parameter is an unsigned character */
+  int p1;             /* First operand */
+  int p2;             /* Second parameter (often the jump destination) */
+  int p3;             /* The third parameter */
+  union {             /* forth parameter */
+    int i;                 /* Integer value if p4type==P4_INT32 */
+    void *p;               /* Generic pointer */
+    char *z;               /* Pointer to data for string (char array) types */
+    i64 *pI64;             /* Used when p4type is P4_INT64 */
+    double *pReal;         /* Used when p4type is P4_REAL */
+    FuncDef *pFunc;        /* Used when p4type is P4_FUNCDEF */
+    VdbeFunc *pVdbeFunc;   /* Used when p4type is P4_VDBEFUNC */
+    CollSeq *pColl;        /* Used when p4type is P4_COLLSEQ */
+    Mem *pMem;             /* Used when p4type is P4_MEM */
+    sqlite3_vtab *pVtab;   /* Used when p4type is P4_VTAB */
+    KeyInfo *pKeyInfo;     /* Used when p4type is P4_KEYINFO */
+  } p4;
+#ifdef SQLITE_DEBUG
+  char *zComment;     /* Comment to improve readability */
+#endif
+#ifdef VDBE_PROFILE
+  int cnt;            /* Number of times this instruction was executed */
+  long long cycles;   /* Total time spend executing this instruction */
+#endif
+};
+typedef struct VdbeOp VdbeOp;
+
+/*
+** A smaller version of VdbeOp used for the VdbeAddOpList() function because
+** it takes up less space.
+*/
+struct VdbeOpList {
+  u8 opcode;          /* What operation to perform */
+  signed char p1;     /* First operand */
+  signed char p2;     /* Second parameter (often the jump destination) */
+  signed char p3;     /* Third parameter */
+};
+typedef struct VdbeOpList VdbeOpList;
+
+/*
+** Allowed values of VdbeOp.p3type
+*/
+#define P4_NOTUSED    0   /* The P4 parameter is not used */
+#define P4_DYNAMIC  (-1)  /* Pointer to a string obtained from sqliteMalloc() */
+#define P4_STATIC   (-2)  /* Pointer to a static string */
+#define P4_COLLSEQ  (-4)  /* P4 is a pointer to a CollSeq structure */
+#define P4_FUNCDEF  (-5)  /* P4 is a pointer to a FuncDef structure */
+#define P4_KEYINFO  (-6)  /* P4 is a pointer to a KeyInfo structure */
+#define P4_VDBEFUNC (-7)  /* P4 is a pointer to a VdbeFunc structure */
+#define P4_MEM      (-8)  /* P4 is a pointer to a Mem*    structure */
+#define P4_TRANSIENT (-9) /* P4 is a pointer to a transient string */
+#define P4_VTAB     (-10) /* P4 is a pointer to an sqlite3_vtab structure */
+#define P4_MPRINTF  (-11) /* P4 is a string obtained from sqlite3_mprintf() */
+#define P4_REAL     (-12) /* P4 is a 64-bit floating point value */
+#define P4_INT64    (-13) /* P4 is a 64-bit signed integer */
+#define P4_INT32    (-14) /* P4 is a 32-bit signed integer */
+
+/* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
+** is made.  That copy is freed when the Vdbe is finalized.  But if the
+** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used.  It still
+** gets freed when the Vdbe is finalized so it still should be obtained
+** from a single sqliteMalloc().  But no copy is made and the calling
+** function should *not* try to free the KeyInfo.
+*/
+#define P4_KEYINFO_HANDOFF (-9)
+
+/*
+** The Vdbe.aColName array contains 5n Mem structures, where n is the 
+** number of columns of data returned by the statement.
+*/
+#define COLNAME_NAME     0
+#define COLNAME_DECLTYPE 1
+#define COLNAME_DATABASE 2
+#define COLNAME_TABLE    3
+#define COLNAME_COLUMN   4
+#define COLNAME_N        5      /* Number of COLNAME_xxx symbols */
+
+/*
+** The following macro converts a relative address in the p2 field
+** of a VdbeOp structure into a negative number so that 
+** sqlite3VdbeAddOpList() knows that the address is relative.  Calling
+** the macro again restores the address.
+*/
+#define ADDR(X)  (-1-(X))
+
+/*
+** The makefile scans the vdbe.c source file and creates the "opcodes.h"
+** header file that defines a number for each opcode used by the VDBE.
+*/
+#include "opcodes.h"
+
+/*
+** Prototypes for the VDBE interface.  See comments on the implementation
+** for a description of what each of these routines does.
+*/
+Vdbe *sqlite3VdbeCreate(sqlite3*);
+int sqlite3VdbeAddOp0(Vdbe*,int);
+int sqlite3VdbeAddOp1(Vdbe*,int,int);
+int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
+int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
+int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
+int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
+void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
+void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
+void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
+void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
+void sqlite3VdbeJumpHere(Vdbe*, int addr);
+void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N);
+void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
+void sqlite3VdbeUsesBtree(Vdbe*, int);
+VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
+int sqlite3VdbeMakeLabel(Vdbe*);
+void sqlite3VdbeDelete(Vdbe*);
+void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int);
+int sqlite3VdbeFinalize(Vdbe*);
+void sqlite3VdbeResolveLabel(Vdbe*, int);
+int sqlite3VdbeCurrentAddr(Vdbe*);
+#ifdef SQLITE_DEBUG
+  void sqlite3VdbeTrace(Vdbe*,FILE*);
+#endif
+void sqlite3VdbeResetStepResult(Vdbe*);
+int sqlite3VdbeReset(Vdbe*);
+void sqlite3VdbeSetNumCols(Vdbe*,int);
+int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, int);
+void sqlite3VdbeCountChanges(Vdbe*);
+sqlite3 *sqlite3VdbeDb(Vdbe*);
+void sqlite3VdbeSetSql(Vdbe*, const char *z, int n);
+void sqlite3VdbeSwap(Vdbe*,Vdbe*);
+
+#ifndef NDEBUG
+  void sqlite3VdbeComment(Vdbe*, const char*, ...);
+# define VdbeComment(X)  sqlite3VdbeComment X
+#else
+# define VdbeComment(X)
+#endif
+
+#endif
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbeInt.h b/client/src/thirdparty/sqlite-3.4.2/src/vdbeInt.h
new file mode 100644
index 0000000..407ed49
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbeInt.h
@@ -0,0 +1,422 @@
+/*
+** 2003 September 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 is the header file for information that is private to the
+** VDBE.  This information used to all be at the top of the single
+** source code file "vdbe.c".  When that file became too big (over
+** 6000 lines long) it was split up into several smaller files and
+** this header information was factored out.
+*/
+#ifndef _VDBEINT_H_
+#define _VDBEINT_H_
+
+/*
+** intToKey() and keyToInt() used to transform the rowid.  But with
+** the latest versions of the design they are no-ops.
+*/
+#define keyToInt(X)   (X)
+#define intToKey(X)   (X)
+
+
+/*
+** SQL is translated into a sequence of instructions to be
+** executed by a virtual machine.  Each instruction is an instance
+** of the following structure.
+*/
+typedef struct VdbeOp Op;
+
+/*
+** Boolean values
+*/
+typedef unsigned char Bool;
+
+/*
+** A cursor is a pointer into a single BTree within a database file.
+** The cursor can seek to a BTree entry with a particular key, or
+** loop over all entries of the Btree.  You can also insert new BTree
+** entries or retrieve the key or data from the entry that the cursor
+** is currently pointing to.
+** 
+** Every cursor that the virtual machine has open is represented by an
+** instance of the following structure.
+**
+** If the Cursor.isTriggerRow flag is set it means that this cursor is
+** really a single row that represents the NEW or OLD pseudo-table of
+** a row trigger.  The data for the row is stored in Cursor.pData and
+** the rowid is in Cursor.iKey.
+*/
+struct Cursor {
+  BtCursor *pCursor;    /* The cursor structure of the backend */
+  int iDb;              /* Index of cursor database in db->aDb[] (or -1) */
+  i64 lastRowid;        /* Last rowid from a Next or NextIdx operation */
+  i64 nextRowid;        /* Next rowid returned by OP_NewRowid */
+  Bool zeroed;          /* True if zeroed out and ready for reuse */
+  Bool rowidIsValid;    /* True if lastRowid is valid */
+  Bool atFirst;         /* True if pointing to first entry */
+  Bool useRandomRowid;  /* Generate new record numbers semi-randomly */
+  Bool nullRow;         /* True if pointing to a row with no data */
+  Bool nextRowidValid;  /* True if the nextRowid field is valid */
+  Bool pseudoTable;     /* This is a NEW or OLD pseudo-tables of a trigger */
+  Bool deferredMoveto;  /* A call to sqlite3BtreeMoveto() is needed */
+  Bool isTable;         /* True if a table requiring integer keys */
+  Bool isIndex;         /* True if an index containing keys only - no data */
+  u8 bogusIncrKey;      /* Something for pIncrKey to point to if pKeyInfo==0 */
+  i64 movetoTarget;     /* Argument to the deferred sqlite3BtreeMoveto() */
+  Btree *pBt;           /* Separate file holding temporary table */
+  int nData;            /* Number of bytes in pData */
+  char *pData;          /* Data for a NEW or OLD pseudo-table */
+  i64 iKey;             /* Key for the NEW or OLD pseudo-table row */
+  u8 *pIncrKey;         /* Pointer to pKeyInfo->incrKey */
+  KeyInfo *pKeyInfo;    /* Info about index keys needed by index cursors */
+  int nField;           /* Number of fields in the header */
+  i64 seqCount;         /* Sequence counter */
+  sqlite3_vtab_cursor *pVtabCursor;  /* The cursor for a virtual table */
+  const sqlite3_module *pModule;     /* Module for cursor pVtabCursor */
+
+  /* Cached information about the header for the data record that the
+  ** cursor is currently pointing to.  Only valid if cacheValid is true.
+  ** aRow might point to (ephemeral) data for the current row, or it might
+  ** be NULL.
+  */
+  int cacheStatus;      /* Cache is valid if this matches Vdbe.cacheCtr */
+  int payloadSize;      /* Total number of bytes in the record */
+  u32 *aType;           /* Type values for all entries in the record */
+  u32 *aOffset;         /* Cached offsets to the start of each columns data */
+  u8 *aRow;             /* Data for the current row, if all on one page */
+};
+typedef struct Cursor Cursor;
+
+/*
+** Number of bytes of string storage space available to each stack
+** layer without having to malloc.  NBFS is short for Number of Bytes
+** For Strings.
+*/
+#define NBFS 32
+
+/*
+** A value for Cursor.cacheValid that means the cache is always invalid.
+*/
+#define CACHE_STALE 0
+
+/*
+** Internally, the vdbe manipulates nearly all SQL values as Mem
+** structures. Each Mem struct may cache multiple representations (string,
+** integer etc.) of the same value.  A value (and therefore Mem structure)
+** has the following properties:
+**
+** Each value has a manifest type. The manifest type of the value stored
+** in a Mem struct is returned by the MemType(Mem*) macro. The type is
+** one of SQLITE_NULL, SQLITE_INTEGER, SQLITE_REAL, SQLITE_TEXT or
+** SQLITE_BLOB.
+*/
+struct Mem {
+  union {
+    i64 i;              /* Integer value. Or FuncDef* when flags==MEM_Agg */
+    FuncDef *pDef;      /* Used only when flags==MEM_Agg */
+  } u;
+  double r;           /* Real value */
+  sqlite3 *db;        /* The associated database connection */
+  char *z;            /* String or BLOB value */
+  int n;              /* Number of characters in string value, excluding '\0' */
+  u16 flags;          /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
+  u8  type;           /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
+  u8  enc;            /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
+  void (*xDel)(void *);  /* If not null, call this function to delete Mem.z */
+  char zShort[NBFS];  /* Space for short strings */
+};
+
+/* One or more of the following flags are set to indicate the validOK
+** representations of the value stored in the Mem struct.
+**
+** If the MEM_Null flag is set, then the value is an SQL NULL value.
+** No other flags may be set in this case.
+**
+** If the MEM_Str flag is set then Mem.z points at a string representation.
+** Usually this is encoded in the same unicode encoding as the main
+** database (see below for exceptions). If the MEM_Term flag is also
+** set, then the string is nul terminated. The MEM_Int and MEM_Real 
+** flags may coexist with the MEM_Str flag.
+**
+** Multiple of these values can appear in Mem.flags.  But only one
+** at a time can appear in Mem.type.
+*/
+#define MEM_Null      0x0001   /* Value is NULL */
+#define MEM_Str       0x0002   /* Value is a string */
+#define MEM_Int       0x0004   /* Value is an integer */
+#define MEM_Real      0x0008   /* Value is a real number */
+#define MEM_Blob      0x0010   /* Value is a BLOB */
+
+/* Whenever Mem contains a valid string or blob representation, one of
+** the following flags must be set to determine the memory management
+** policy for Mem.z.  The MEM_Term flag tells us whether or not the
+** string is \000 or \u0000 terminated
+*/
+#define MEM_Term      0x0020   /* String rep is nul terminated */
+#define MEM_Dyn       0x0040   /* Need to call sqliteFree() on Mem.z */
+#define MEM_Static    0x0080   /* Mem.z points to a static string */
+#define MEM_Ephem     0x0100   /* Mem.z points to an ephemeral string */
+#define MEM_Short     0x0200   /* Mem.z points to Mem.zShort */
+#define MEM_Agg       0x0400   /* Mem.z points to an agg function context */
+#define MEM_Zero      0x0800   /* Mem.i contains count of 0s appended to blob */
+
+#ifdef SQLITE_OMIT_INCRBLOB
+  #undef MEM_Zero
+  #define MEM_Zero 0x0000
+#endif
+
+
+/* A VdbeFunc is just a FuncDef (defined in sqliteInt.h) that contains
+** additional information about auxiliary information bound to arguments
+** of the function.  This is used to implement the sqlite3_get_auxdata()
+** and sqlite3_set_auxdata() APIs.  The "auxdata" is some auxiliary data
+** that can be associated with a constant argument to a function.  This
+** allows functions such as "regexp" to compile their constant regular
+** expression argument once and reused the compiled code for multiple
+** invocations.
+*/
+struct VdbeFunc {
+  FuncDef *pFunc;               /* The definition of the function */
+  int nAux;                     /* Number of entries allocated for apAux[] */
+  struct AuxData {
+    void *pAux;                   /* Aux data for the i-th argument */
+    void (*xDelete)(void *);      /* Destructor for the aux data */
+  } apAux[1];                   /* One slot for each function argument */
+};
+
+/*
+** The "context" argument for a installable function.  A pointer to an
+** instance of this structure is the first argument to the routines used
+** implement the SQL functions.
+**
+** There is a typedef for this structure in sqlite.h.  So all routines,
+** even the public interface to SQLite, can use a pointer to this structure.
+** But this file is the only place where the internal details of this
+** structure are known.
+**
+** This structure is defined inside of vdbeInt.h because it uses substructures
+** (Mem) which are only defined there.
+*/
+struct sqlite3_context {
+  FuncDef *pFunc;       /* Pointer to function information.  MUST BE FIRST */
+  VdbeFunc *pVdbeFunc;  /* Auxilary data, if created. */
+  Mem s;                /* The return value is stored here */
+  Mem *pMem;            /* Memory cell used to store aggregate context */
+  int isError;          /* Error code returned by the function. */
+  CollSeq *pColl;       /* Collating sequence */
+};
+
+/*
+** A Set structure is used for quick testing to see if a value
+** is part of a small set.  Sets are used to implement code like
+** this:
+**            x.y IN ('hi','hoo','hum')
+*/
+typedef struct Set Set;
+struct Set {
+  Hash hash;             /* A set is just a hash table */
+  HashElem *prev;        /* Previously accessed hash elemen */
+};
+
+/*
+** A FifoPage structure holds a single page of valves.  Pages are arranged
+** in a list.
+*/
+typedef struct FifoPage FifoPage;
+struct FifoPage {
+  int nSlot;         /* Number of entries aSlot[] */
+  int iWrite;        /* Push the next value into this entry in aSlot[] */
+  int iRead;         /* Read the next value from this entry in aSlot[] */
+  FifoPage *pNext;   /* Next page in the fifo */
+  i64 aSlot[1];      /* One or more slots for rowid values */
+};
+
+/*
+** The Fifo structure is typedef-ed in vdbeInt.h.  But the implementation
+** of that structure is private to this file.
+**
+** The Fifo structure describes the entire fifo.  
+*/
+typedef struct Fifo Fifo;
+struct Fifo {
+  int nEntry;         /* Total number of entries */
+  FifoPage *pFirst;   /* First page on the list */
+  FifoPage *pLast;    /* Last page on the list */
+};
+
+/*
+** A Context stores the last insert rowid, the last statement change count,
+** and the current statement change count (i.e. changes since last statement).
+** The current keylist is also stored in the context.
+** Elements of Context structure type make up the ContextStack, which is
+** updated by the ContextPush and ContextPop opcodes (used by triggers).
+** The context is pushed before executing a trigger a popped when the
+** trigger finishes.
+*/
+typedef struct Context Context;
+struct Context {
+  i64 lastRowid;    /* Last insert rowid (sqlite3.lastRowid) */
+  int nChange;      /* Statement changes (Vdbe.nChanges)     */
+  Fifo sFifo;       /* Records that will participate in a DELETE or UPDATE */
+};
+
+/*
+** An instance of the virtual machine.  This structure contains the complete
+** state of the virtual machine.
+**
+** The "sqlite3_stmt" structure pointer that is returned by sqlite3_compile()
+** is really a pointer to an instance of this structure.
+**
+** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
+** any virtual table method invocations made by the vdbe program. It is
+** set to 2 for xDestroy method calls and 1 for all other methods. This
+** variable is used for two purposes: to allow xDestroy methods to execute
+** "DROP TABLE" statements and to prevent some nasty side effects of
+** malloc failure when SQLite is invoked recursively by a virtual table 
+** method function.
+*/
+struct Vdbe {
+  sqlite3 *db;        /* The whole database */
+  Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
+  int nOp;            /* Number of instructions in the program */
+  int nOpAlloc;       /* Number of slots allocated for aOp[] */
+  Op *aOp;            /* Space to hold the virtual machine's program */
+  int nLabel;         /* Number of labels used */
+  int nLabelAlloc;    /* Number of slots allocated in aLabel[] */
+  int *aLabel;        /* Space to hold the labels */
+  Mem **apArg;        /* Arguments to currently executing user function */
+  Mem *aColName;      /* Column names to return */
+  int nCursor;        /* Number of slots in apCsr[] */
+  Cursor **apCsr;     /* One element of this array for each open cursor */
+  int nVar;           /* Number of entries in aVar[] */
+  Mem *aVar;          /* Values for the OP_Variable opcode. */
+  char **azVar;       /* Name of variables */
+  int okVar;          /* True if azVar[] has been initialized */
+  int magic;              /* Magic number for sanity checking */
+  int nMem;               /* Number of memory locations currently allocated */
+  Mem *aMem;              /* The memory locations */
+  int nCallback;          /* Number of callbacks invoked so far */
+  int cacheCtr;           /* Cursor row cache generation counter */
+  Fifo sFifo;             /* A list of ROWIDs */
+  int contextStackTop;    /* Index of top element in the context stack */
+  int contextStackDepth;  /* The size of the "context" stack */
+  Context *contextStack;  /* Stack used by opcodes ContextPush & ContextPop*/
+  int pc;                 /* The program counter */
+  int rc;                 /* Value to return */
+  unsigned uniqueCnt;     /* Used by OP_MakeRecord when P2!=0 */
+  int errorAction;        /* Recovery action to do in case of an error */
+  int inTempTrans;        /* True if temp database is transactioned */
+  int returnStack[25];    /* Return address stack for OP_Gosub & OP_Return */
+  int returnDepth;        /* Next unused element in returnStack[] */
+  int nResColumn;         /* Number of columns in one row of the result set */
+  char **azResColumn;     /* Values for one row of result */ 
+  char *zErrMsg;          /* Error message written here */
+  Mem *pResultSet;        /* Pointer to an array of results */
+  u8 explain;             /* True if EXPLAIN present on SQL command */
+  u8 changeCntOn;         /* True to update the change-counter */
+  u8 aborted;             /* True if ROLLBACK in another VM causes an abort */
+  u8 expired;             /* True if the VM needs to be recompiled */
+  u8 minWriteFileFormat;  /* Minimum file format for writable database files */
+  u8 inVtabMethod;        /* See comments above */
+  int nChange;            /* Number of db changes made since last reset */
+  i64 startTime;          /* Time when query started - used for profiling */
+  int btreeMask;          /* Bitmask of db->aDb[] entries referenced */
+  BtreeMutexArray aMutex; /* An array of Btree used here and needing locks */
+  int nSql;             /* Number of bytes in zSql */
+  char *zSql;           /* Text of the SQL statement that generated this */
+#ifdef SQLITE_DEBUG
+  FILE *trace;        /* Write an execution trace here, if not NULL */
+#endif
+  int openedStatement;  /* True if this VM has opened a statement journal */
+#ifdef SQLITE_SSE
+  int fetchId;          /* Statement number used by sqlite3_fetch_statement */
+  int lru;              /* Counter used for LRU cache replacement */
+#endif
+};
+
+/*
+** The following are allowed values for Vdbe.magic
+*/
+#define VDBE_MAGIC_INIT     0x26bceaa5    /* Building a VDBE program */
+#define VDBE_MAGIC_RUN      0xbdf20da3    /* VDBE is ready to execute */
+#define VDBE_MAGIC_HALT     0x519c2973    /* VDBE has completed execution */
+#define VDBE_MAGIC_DEAD     0xb606c3c8    /* The VDBE has been deallocated */
+
+/*
+** Function prototypes
+*/
+void sqlite3VdbeFreeCursor(Vdbe *, Cursor*);
+void sqliteVdbePopStack(Vdbe*,int);
+int sqlite3VdbeCursorMoveto(Cursor*);
+#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
+void sqlite3VdbePrintOp(FILE*, int, Op*);
+#endif
+int sqlite3VdbeSerialTypeLen(u32);
+u32 sqlite3VdbeSerialType(Mem*, int);
+int sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
+int sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
+void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
+
+int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
+int sqlite3VdbeIdxKeyCompare(Cursor*,int,const unsigned char*,int*);
+int sqlite3VdbeIdxRowid(BtCursor *, i64 *);
+int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
+int sqlite3VdbeRecordCompare(void*,int,const void*,int, const void*);
+int sqlite3VdbeIdxRowidLen(const u8*);
+int sqlite3VdbeExec(Vdbe*);
+int sqlite3VdbeList(Vdbe*);
+int sqlite3VdbeHalt(Vdbe*);
+int sqlite3VdbeChangeEncoding(Mem *, int);
+int sqlite3VdbeMemTooBig(Mem*);
+int sqlite3VdbeMemCopy(Mem*, const Mem*);
+void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
+void sqlite3VdbeMemMove(Mem*, Mem*);
+int sqlite3VdbeMemNulTerminate(Mem*);
+int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
+void sqlite3VdbeMemSetInt64(Mem*, i64);
+void sqlite3VdbeMemSetDouble(Mem*, double);
+void sqlite3VdbeMemSetNull(Mem*);
+void sqlite3VdbeMemSetZeroBlob(Mem*,int);
+int sqlite3VdbeMemMakeWriteable(Mem*);
+int sqlite3VdbeMemDynamicify(Mem*);
+int sqlite3VdbeMemStringify(Mem*, int);
+i64 sqlite3VdbeIntValue(Mem*);
+int sqlite3VdbeMemIntegerify(Mem*);
+double sqlite3VdbeRealValue(Mem*);
+void sqlite3VdbeIntegerAffinity(Mem*);
+int sqlite3VdbeMemRealify(Mem*);
+int sqlite3VdbeMemNumerify(Mem*);
+int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
+void sqlite3VdbeMemRelease(Mem *p);
+int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
+const char *sqlite3OpcodeName(int);
+int sqlite3VdbeOpcodeHasProperty(int, int);
+
+#ifndef NDEBUG
+  void sqlite3VdbeMemSanity(Mem*);
+#endif
+int sqlite3VdbeMemTranslate(Mem*, u8);
+#ifdef SQLITE_DEBUG
+  void sqlite3VdbePrintSql(Vdbe*);
+  void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
+#endif
+int sqlite3VdbeMemHandleBom(Mem *pMem);
+void sqlite3VdbeFifoInit(Fifo*);
+int sqlite3VdbeFifoPush(Fifo*, i64);
+int sqlite3VdbeFifoPop(Fifo*, i64*);
+void sqlite3VdbeFifoClear(Fifo*);
+
+#ifndef SQLITE_OMIT_INCRBLOB
+  int sqlite3VdbeMemExpandBlob(Mem *);
+#else
+  #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
+#endif
+
+#endif /* !defined(_VDBEINT_H_) */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbeapi.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbeapi.c
new file mode 100644
index 0000000..e756c70
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbeapi.c
@@ -0,0 +1,1066 @@
+/*
+** 2004 May 26
+**
+** 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 use to implement APIs that are part of the
+** VDBE.
+*/
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+
+/*
+** Return TRUE (non-zero) of the statement supplied as an argument needs
+** to be recompiled.  A statement needs to be recompiled whenever the
+** execution environment changes in a way that would alter the program
+** that sqlite3_prepare() generates.  For example, if new functions or
+** collating sequences are registered or if an authorizer function is
+** added or changed.
+*/
+int sqlite3_expired(sqlite3_stmt *pStmt){
+  Vdbe *p = (Vdbe*)pStmt;
+  return p==0 || p->expired;
+}
+
+/*
+** The following routine destroys a virtual machine that is created by
+** the sqlite3_compile() routine. The integer returned is an SQLITE_
+** success/failure code that describes the result of executing the virtual
+** machine.
+**
+** This routine sets the error code and string returned by
+** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
+*/
+int sqlite3_finalize(sqlite3_stmt *pStmt){
+  int rc;
+  if( pStmt==0 ){
+    rc = SQLITE_OK;
+  }else{
+    Vdbe *v = (Vdbe*)pStmt;
+#ifndef SQLITE_MUTEX_NOOP
+    sqlite3_mutex *mutex = v->db->mutex;
+#endif
+    sqlite3_mutex_enter(mutex);
+    rc = sqlite3VdbeFinalize(v);
+    sqlite3_mutex_leave(mutex);
+  }
+  return rc;
+}
+
+/*
+** Terminate the current execution of an SQL statement and reset it
+** back to its starting state so that it can be reused. A success code from
+** the prior execution is returned.
+**
+** This routine sets the error code and string returned by
+** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
+*/
+int sqlite3_reset(sqlite3_stmt *pStmt){
+  int rc;
+  if( pStmt==0 ){
+    rc = SQLITE_OK;
+  }else{
+    Vdbe *v = (Vdbe*)pStmt;
+    sqlite3_mutex_enter(v->db->mutex);
+    rc = sqlite3VdbeReset(v);
+    sqlite3VdbeMakeReady(v, -1, 0, 0, 0);
+    assert( (rc & (v->db->errMask))==rc );
+    sqlite3_mutex_leave(v->db->mutex);
+  }
+  return rc;
+}
+
+/*
+** Set all the parameters in the compiled SQL statement to NULL.
+*/
+int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
+  int i;
+  int rc = SQLITE_OK;
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
+#endif
+  sqlite3_mutex_enter(mutex);
+  for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
+    rc = sqlite3_bind_null(pStmt, i);
+  }
+  sqlite3_mutex_leave(mutex);
+  return rc;
+}
+
+
+/**************************** sqlite3_value_  *******************************
+** The following routines extract information from a Mem or sqlite3_value
+** structure.
+*/
+const void *sqlite3_value_blob(sqlite3_value *pVal){
+  Mem *p = (Mem*)pVal;
+  if( p->flags & (MEM_Blob|MEM_Str) ){
+    sqlite3VdbeMemExpandBlob(p);
+    p->flags &= ~MEM_Str;
+    p->flags |= MEM_Blob;
+    return p->z;
+  }else{
+    return sqlite3_value_text(pVal);
+  }
+}
+int sqlite3_value_bytes(sqlite3_value *pVal){
+  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
+}
+int sqlite3_value_bytes16(sqlite3_value *pVal){
+  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
+}
+double sqlite3_value_double(sqlite3_value *pVal){
+  return sqlite3VdbeRealValue((Mem*)pVal);
+}
+int sqlite3_value_int(sqlite3_value *pVal){
+  return sqlite3VdbeIntValue((Mem*)pVal);
+}
+sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
+  return sqlite3VdbeIntValue((Mem*)pVal);
+}
+const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
+  return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_value_text16(sqlite3_value* pVal){
+  return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
+}
+const void *sqlite3_value_text16be(sqlite3_value *pVal){
+  return sqlite3ValueText(pVal, SQLITE_UTF16BE);
+}
+const void *sqlite3_value_text16le(sqlite3_value *pVal){
+  return sqlite3ValueText(pVal, SQLITE_UTF16LE);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+int sqlite3_value_type(sqlite3_value* pVal){
+  return pVal->type;
+}
+
+/**************************** sqlite3_result_  *******************************
+** The following routines are used by user-defined functions to specify
+** the function result.
+*/
+void sqlite3_result_blob(
+  sqlite3_context *pCtx, 
+  const void *z, 
+  int n, 
+  void (*xDel)(void *)
+){
+  assert( n>=0 );
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
+}
+void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
+}
+void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  pCtx->isError = SQLITE_ERROR;
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
+}
+#ifndef SQLITE_OMIT_UTF16
+void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  pCtx->isError = SQLITE_ERROR;
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
+}
+#endif
+void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
+}
+void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
+}
+void sqlite3_result_null(sqlite3_context *pCtx){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetNull(&pCtx->s);
+}
+void sqlite3_result_text(
+  sqlite3_context *pCtx, 
+  const char *z, 
+  int n,
+  void (*xDel)(void *)
+){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
+}
+#ifndef SQLITE_OMIT_UTF16
+void sqlite3_result_text16(
+  sqlite3_context *pCtx, 
+  const void *z, 
+  int n, 
+  void (*xDel)(void *)
+){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
+}
+void sqlite3_result_text16be(
+  sqlite3_context *pCtx, 
+  const void *z, 
+  int n, 
+  void (*xDel)(void *)
+){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
+}
+void sqlite3_result_text16le(
+  sqlite3_context *pCtx, 
+  const void *z, 
+  int n, 
+  void (*xDel)(void *)
+){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemCopy(&pCtx->s, pValue);
+}
+void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
+}
+void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
+  pCtx->isError = errCode;
+}
+
+/* Force an SQLITE_TOOBIG error. */
+void sqlite3_result_error_toobig(sqlite3_context *pCtx){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetZeroBlob(&pCtx->s, SQLITE_MAX_LENGTH+1);
+}
+
+/* An SQLITE_NOMEM error. */
+void sqlite3_result_error_nomem(sqlite3_context *pCtx){
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  sqlite3VdbeMemSetNull(&pCtx->s);
+  pCtx->isError = SQLITE_NOMEM;
+  pCtx->s.db->mallocFailed = 1;
+}
+
+/*
+** Execute the statement pStmt, either until a row of data is ready, the
+** statement is completely executed or an error occurs.
+**
+** This routine implements the bulk of the logic behind the sqlite_step()
+** API.  The only thing omitted is the automatic recompile if a 
+** schema change has occurred.  That detail is handled by the
+** outer sqlite3_step() wrapper procedure.
+*/
+static int sqlite3Step(Vdbe *p){
+  sqlite3 *db;
+  int rc;
+
+  assert(p);
+  if( p->magic!=VDBE_MAGIC_RUN ){
+    return SQLITE_MISUSE;
+  }
+
+  /* Assert that malloc() has not failed */
+  db = p->db;
+  assert( !db->mallocFailed );
+
+  if( p->aborted ){
+    return SQLITE_ABORT;
+  }
+  if( p->pc<=0 && p->expired ){
+    if( p->rc==SQLITE_OK ){
+      p->rc = SQLITE_SCHEMA;
+    }
+    rc = SQLITE_ERROR;
+    goto end_of_step;
+  }
+  if( sqlite3SafetyOn(db) ){
+    p->rc = SQLITE_MISUSE;
+    return SQLITE_MISUSE;
+  }
+  if( p->pc<0 ){
+    /* If there are no other statements currently running, then
+    ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
+    ** from interrupting a statement that has not yet started.
+    */
+    if( db->activeVdbeCnt==0 ){
+      db->u1.isInterrupted = 0;
+    }
+
+#ifndef SQLITE_OMIT_TRACE
+    if( db->xProfile && !db->init.busy ){
+      double rNow;
+      sqlite3OsCurrentTime(db->pVfs, &rNow);
+      p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;
+    }
+#endif
+
+    db->activeVdbeCnt++;
+    p->pc = 0;
+  }
+#ifndef SQLITE_OMIT_EXPLAIN
+  if( p->explain ){
+    rc = sqlite3VdbeList(p);
+  }else
+#endif /* SQLITE_OMIT_EXPLAIN */
+  {
+    rc = sqlite3VdbeExec(p);
+  }
+
+  if( sqlite3SafetyOff(db) ){
+    rc = SQLITE_MISUSE;
+  }
+
+#ifndef SQLITE_OMIT_TRACE
+  /* Invoke the profile callback if there is one
+  */
+  if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0
+           && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){
+    double rNow;
+    u64 elapseTime;
+
+    sqlite3OsCurrentTime(db->pVfs, &rNow);
+    elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;
+    db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);
+  }
+#endif
+
+  sqlite3Error(p->db, rc, 0);
+  p->rc = sqlite3ApiExit(p->db, p->rc);
+end_of_step:
+  assert( (rc&0xff)==rc );
+  if( p->zSql && (rc&0xff)<SQLITE_ROW ){
+    /* This behavior occurs if sqlite3_prepare_v2() was used to build
+    ** the prepared statement.  Return error codes directly */
+    sqlite3Error(p->db, p->rc, 0);
+    return p->rc;
+  }else{
+    /* This is for legacy sqlite3_prepare() builds and when the code
+    ** is SQLITE_ROW or SQLITE_DONE */
+    return rc;
+  }
+}
+
+/*
+** This is the top-level implementation of sqlite3_step().  Call
+** sqlite3Step() to do most of the work.  If a schema error occurs,
+** call sqlite3Reprepare() and try again.
+*/
+#ifdef SQLITE_OMIT_PARSER
+int sqlite3_step(sqlite3_stmt *pStmt){
+  int rc = SQLITE_MISUSE;
+  if( pStmt ){
+    Vdbe *v;
+    v = (Vdbe*)pStmt;
+    sqlite3_mutex_enter(v->db->mutex);
+    rc = sqlite3Step(v);
+    sqlite3_mutex_leave(v->db->mutex);
+  }
+  return rc;
+}
+#else
+int sqlite3_step(sqlite3_stmt *pStmt){
+  int rc = SQLITE_MISUSE;
+  if( pStmt ){
+    int cnt = 0;
+    Vdbe *v = (Vdbe*)pStmt;
+    sqlite3 *db = v->db;
+    sqlite3_mutex_enter(db->mutex);
+    while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
+           && cnt++ < 5
+           && sqlite3Reprepare(v) ){
+      sqlite3_reset(pStmt);
+      v->expired = 0;
+    }
+    if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){
+      /* This case occurs after failing to recompile an sql statement. 
+      ** The error message from the SQL compiler has already been loaded 
+      ** into the database handle. This block copies the error message 
+      ** from the database handle into the statement and sets the statement
+      ** program counter to 0 to ensure that when the statement is 
+      ** finalized or reset the parser error message is available via
+      ** sqlite3_errmsg() and sqlite3_errcode().
+      */
+      const char *zErr = (const char *)sqlite3_value_text(db->pErr); 
+      sqlite3_free(v->zErrMsg);
+      if( !db->mallocFailed ){
+        v->zErrMsg = sqlite3DbStrDup(db, zErr);
+      } else {
+        v->zErrMsg = 0;
+        v->rc = SQLITE_NOMEM;
+      }
+    }
+    rc = sqlite3ApiExit(db, rc);
+    sqlite3_mutex_leave(db->mutex);
+  }
+  return rc;
+}
+#endif
+
+/*
+** Extract the user data from a sqlite3_context structure and return a
+** pointer to it.
+*/
+void *sqlite3_user_data(sqlite3_context *p){
+  assert( p && p->pFunc );
+  return p->pFunc->pUserData;
+}
+
+/*
+** The following is the implementation of an SQL function that always
+** fails with an error message stating that the function is used in the
+** wrong context.  The sqlite3_overload_function() API might construct
+** SQL function that use this routine so that the functions will exist
+** for name resolution but are actually overloaded by the xFindFunction
+** method of virtual tables.
+*/
+void sqlite3InvalidFunction(
+  sqlite3_context *context,  /* The function calling context */
+  int argc,                  /* Number of arguments to the function */
+  sqlite3_value **argv       /* Value of each argument */
+){
+  const char *zName = context->pFunc->zName;
+  char *zErr;
+  zErr = sqlite3MPrintf(0,
+      "unable to use function %s in the requested context", zName);
+  sqlite3_result_error(context, zErr, -1);
+  sqlite3_free(zErr);
+}
+
+/*
+** Allocate or return the aggregate context for a user function.  A new
+** context is allocated on the first call.  Subsequent calls return the
+** same context that was returned on prior calls.
+*/
+void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
+  Mem *pMem;
+  assert( p && p->pFunc && p->pFunc->xStep );
+  assert( sqlite3_mutex_held(p->s.db->mutex) );
+  pMem = p->pMem;
+  if( (pMem->flags & MEM_Agg)==0 ){
+    if( nByte==0 ){
+      assert( pMem->flags==MEM_Null );
+      pMem->z = 0;
+    }else{
+      pMem->flags = MEM_Agg;
+      pMem->xDel = sqlite3_free;
+      pMem->u.pDef = p->pFunc;
+      pMem->z = sqlite3DbMallocZero(p->s.db, nByte);
+    }
+  }
+  return (void*)pMem->z;
+}
+
+/*
+** Return the auxilary data pointer, if any, for the iArg'th argument to
+** the user-function defined by pCtx.
+*/
+void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
+  VdbeFunc *pVdbeFunc;
+
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  pVdbeFunc = pCtx->pVdbeFunc;
+  if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
+    return 0;
+  }
+  return pVdbeFunc->apAux[iArg].pAux;
+}
+
+/*
+** Set the auxilary data pointer and delete function, for the iArg'th
+** argument to the user-function defined by pCtx. Any previous value is
+** deleted by calling the delete function specified when it was set.
+*/
+void sqlite3_set_auxdata(
+  sqlite3_context *pCtx, 
+  int iArg, 
+  void *pAux, 
+  void (*xDelete)(void*)
+){
+  struct AuxData *pAuxData;
+  VdbeFunc *pVdbeFunc;
+  if( iArg<0 ) goto failed;
+
+  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
+  pVdbeFunc = pCtx->pVdbeFunc;
+  if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
+    int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
+    int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
+    pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
+    if( !pVdbeFunc ){
+      goto failed;
+    }
+    pCtx->pVdbeFunc = pVdbeFunc;
+    memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
+    pVdbeFunc->nAux = iArg+1;
+    pVdbeFunc->pFunc = pCtx->pFunc;
+  }
+
+  pAuxData = &pVdbeFunc->apAux[iArg];
+  if( pAuxData->pAux && pAuxData->xDelete ){
+    pAuxData->xDelete(pAuxData->pAux);
+  }
+  pAuxData->pAux = pAux;
+  pAuxData->xDelete = xDelete;
+  return;
+
+failed:
+  if( xDelete ){
+    xDelete(pAux);
+  }
+}
+
+/*
+** Return the number of times the Step function of a aggregate has been 
+** called.
+**
+** This function is deprecated.  Do not use it for new code.  It is
+** provide only to avoid breaking legacy code.  New aggregate function
+** implementations should keep their own counts within their aggregate
+** context.
+*/
+int sqlite3_aggregate_count(sqlite3_context *p){
+  assert( p && p->pFunc && p->pFunc->xStep );
+  return p->pMem->n;
+}
+
+/*
+** Return the number of columns in the result set for the statement pStmt.
+*/
+int sqlite3_column_count(sqlite3_stmt *pStmt){
+  Vdbe *pVm = (Vdbe *)pStmt;
+  return pVm ? pVm->nResColumn : 0;
+}
+
+/*
+** Return the number of values available from the current row of the
+** currently executing statement pStmt.
+*/
+int sqlite3_data_count(sqlite3_stmt *pStmt){
+  Vdbe *pVm = (Vdbe *)pStmt;
+  if( pVm==0 || pVm->pResultSet==0 ) return 0;
+  return pVm->nResColumn;
+}
+
+
+/*
+** Check to see if column iCol of the given statement is valid.  If
+** it is, return a pointer to the Mem for the value of that column.
+** If iCol is not valid, return a pointer to a Mem which has a value
+** of NULL.
+*/
+static Mem *columnMem(sqlite3_stmt *pStmt, int i){
+  Vdbe *pVm;
+  int vals;
+  Mem *pOut;
+
+  pVm = (Vdbe *)pStmt;
+  if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
+    sqlite3_mutex_enter(pVm->db->mutex);
+    vals = sqlite3_data_count(pStmt);
+    pOut = &pVm->pResultSet[i];
+  }else{
+    static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL };
+    if( pVm->db ){
+      sqlite3_mutex_enter(pVm->db->mutex);
+      sqlite3Error(pVm->db, SQLITE_RANGE, 0);
+    }
+    pOut = (Mem*)&nullMem;
+  }
+  return pOut;
+}
+
+/*
+** This function is called after invoking an sqlite3_value_XXX function on a 
+** column value (i.e. a value returned by evaluating an SQL expression in the
+** select list of a SELECT statement) that may cause a malloc() failure. If 
+** malloc() has failed, the threads mallocFailed flag is cleared and the result
+** code of statement pStmt set to SQLITE_NOMEM.
+**
+** Specifically, this is called from within:
+**
+**     sqlite3_column_int()
+**     sqlite3_column_int64()
+**     sqlite3_column_text()
+**     sqlite3_column_text16()
+**     sqlite3_column_real()
+**     sqlite3_column_bytes()
+**     sqlite3_column_bytes16()
+**
+** But not for sqlite3_column_blob(), which never calls malloc().
+*/
+static void columnMallocFailure(sqlite3_stmt *pStmt)
+{
+  /* If malloc() failed during an encoding conversion within an
+  ** sqlite3_column_XXX API, then set the return code of the statement to
+  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
+  ** and _finalize() will return NOMEM.
+  */
+  Vdbe *p = (Vdbe *)pStmt;
+  if( p ){
+    p->rc = sqlite3ApiExit(p->db, p->rc);
+    sqlite3_mutex_leave(p->db->mutex);
+  }
+}
+
+/**************************** sqlite3_column_  *******************************
+** The following routines are used to access elements of the current row
+** in the result set.
+*/
+const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
+  const void *val;
+  val = sqlite3_value_blob( columnMem(pStmt,i) );
+  /* Even though there is no encoding conversion, value_blob() might
+  ** need to call malloc() to expand the result of a zeroblob() 
+  ** expression. 
+  */
+  columnMallocFailure(pStmt);
+  return val;
+}
+int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
+  int val = sqlite3_value_bytes( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
+  int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
+  double val = sqlite3_value_double( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
+  int val = sqlite3_value_int( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
+  sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
+  const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
+  sqlite3_value *pOut = columnMem(pStmt, i);
+  columnMallocFailure(pStmt);
+  return pOut;
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
+  const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return val;
+}
+#endif /* SQLITE_OMIT_UTF16 */
+int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
+  int iType = sqlite3_value_type( columnMem(pStmt,i) );
+  columnMallocFailure(pStmt);
+  return iType;
+}
+
+/* The following function is experimental and subject to change or
+** removal */
+/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
+**  return sqlite3_value_numeric_type( columnMem(pStmt,i) );
+**}
+*/
+
+/*
+** Convert the N-th element of pStmt->pColName[] into a string using
+** xFunc() then return that string.  If N is out of range, return 0.
+**
+** There are up to 5 names for each column.  useType determines which
+** name is returned.  Here are the names:
+**
+**    0      The column name as it should be displayed for output
+**    1      The datatype name for the column
+**    2      The name of the database that the column derives from
+**    3      The name of the table that the column derives from
+**    4      The name of the table column that the result column derives from
+**
+** If the result is not a simple column reference (if it is an expression
+** or a constant) then useTypes 2, 3, and 4 return NULL.
+*/
+static const void *columnName(
+  sqlite3_stmt *pStmt,
+  int N,
+  const void *(*xFunc)(Mem*),
+  int useType
+){
+  const void *ret = 0;
+  Vdbe *p = (Vdbe *)pStmt;
+  int n;
+  
+
+  if( p!=0 ){
+    n = sqlite3_column_count(pStmt);
+    if( N<n && N>=0 ){
+      N += useType*n;
+      sqlite3_mutex_enter(p->db->mutex);
+      ret = xFunc(&p->aColName[N]);
+
+      /* A malloc may have failed inside of the xFunc() call. If this
+      ** is the case, clear the mallocFailed flag and return NULL.
+      */
+      if( p->db && p->db->mallocFailed ){
+        p->db->mallocFailed = 0;
+        ret = 0;
+      }
+      sqlite3_mutex_leave(p->db->mutex);
+    }
+  }
+  return ret;
+}
+
+/*
+** Return the name of the Nth column of the result set returned by SQL
+** statement pStmt.
+*/
+const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
+}
+#endif
+
+/*
+** Return the column declaration type (if applicable) of the 'i'th column
+** of the result set of SQL statement pStmt.
+*/
+const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+/*
+** Return the name of the database from which a result column derives.
+** NULL is returned if the result column is an expression or constant or
+** anything else which is not an unabiguous reference to a database column.
+*/
+const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** Return the name of the table from which a result column derives.
+** NULL is returned if the result column is an expression or constant or
+** anything else which is not an unabiguous reference to a database column.
+*/
+const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+
+/*
+** Return the name of the table column from which a result column derives.
+** NULL is returned if the result column is an expression or constant or
+** anything else which is not an unabiguous reference to a database column.
+*/
+const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
+}
+#ifndef SQLITE_OMIT_UTF16
+const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
+  return columnName(
+      pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+#endif /* SQLITE_ENABLE_COLUMN_METADATA */
+
+
+/******************************* sqlite3_bind_  ***************************
+** 
+** Routines used to attach values to wildcards in a compiled SQL statement.
+*/
+/*
+** Unbind the value bound to variable i in virtual machine p. This is the 
+** the same as binding a NULL value to the column. If the "i" parameter is
+** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
+**
+** The error code stored in database p->db is overwritten with the return
+** value in any case.
+*/
+static int vdbeUnbind(Vdbe *p, int i){
+  Mem *pVar;
+  if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
+    if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);
+    return SQLITE_MISUSE;
+  }
+  if( i<1 || i>p->nVar ){
+    sqlite3Error(p->db, SQLITE_RANGE, 0);
+    return SQLITE_RANGE;
+  }
+  i--;
+  pVar = &p->aVar[i];
+  sqlite3VdbeMemRelease(pVar);
+  pVar->flags = MEM_Null;
+  sqlite3Error(p->db, SQLITE_OK, 0);
+  return SQLITE_OK;
+}
+
+/*
+** Bind a text or BLOB value.
+*/
+static int bindText(
+  sqlite3_stmt *pStmt,   /* The statement to bind against */
+  int i,                 /* Index of the parameter to bind */
+  const void *zData,     /* Pointer to the data to be bound */
+  int nData,             /* Number of bytes of data to be bound */
+  void (*xDel)(void*),   /* Destructor for the data */
+  int encoding           /* Encoding for the data */
+){
+  Vdbe *p = (Vdbe *)pStmt;
+  Mem *pVar;
+  int rc;
+
+  if( p==0 ){
+    return SQLITE_MISUSE;
+  }
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  if( rc==SQLITE_OK && zData!=0 ){
+    pVar = &p->aVar[i-1];
+    rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
+    if( rc==SQLITE_OK && encoding!=0 ){
+      rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
+    }
+    sqlite3Error(p->db, rc, 0);
+    rc = sqlite3ApiExit(p->db, rc);
+  }
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+
+
+/*
+** Bind a blob value to an SQL statement variable.
+*/
+int sqlite3_bind_blob(
+  sqlite3_stmt *pStmt, 
+  int i, 
+  const void *zData, 
+  int nData, 
+  void (*xDel)(void*)
+){
+  return bindText(pStmt, i, zData, nData, xDel, 0);
+}
+int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
+  int rc;
+  Vdbe *p = (Vdbe *)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  if( rc==SQLITE_OK ){
+    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
+  }
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
+  return sqlite3_bind_int64(p, i, (i64)iValue);
+}
+int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
+  int rc;
+  Vdbe *p = (Vdbe *)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  if( rc==SQLITE_OK ){
+    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
+  }
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
+  int rc;
+  Vdbe *p = (Vdbe*)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+int sqlite3_bind_text( 
+  sqlite3_stmt *pStmt, 
+  int i, 
+  const char *zData, 
+  int nData, 
+  void (*xDel)(void*)
+){
+  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
+}
+#ifndef SQLITE_OMIT_UTF16
+int sqlite3_bind_text16(
+  sqlite3_stmt *pStmt, 
+  int i, 
+  const void *zData, 
+  int nData, 
+  void (*xDel)(void*)
+){
+  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
+  int rc;
+  Vdbe *p = (Vdbe *)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
+  }
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
+  int rc;
+  Vdbe *p = (Vdbe *)pStmt;
+  sqlite3_mutex_enter(p->db->mutex);
+  rc = vdbeUnbind(p, i);
+  if( rc==SQLITE_OK ){
+    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
+  }
+  sqlite3_mutex_leave(p->db->mutex);
+  return rc;
+}
+
+/*
+** Return the number of wildcards that can be potentially bound to.
+** This routine is added to support DBD::SQLite.  
+*/
+int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
+  Vdbe *p = (Vdbe*)pStmt;
+  return p ? p->nVar : 0;
+}
+
+/*
+** Create a mapping from variable numbers to variable names
+** in the Vdbe.azVar[] array, if such a mapping does not already
+** exist.
+*/
+static void createVarMap(Vdbe *p){
+  if( !p->okVar ){
+    sqlite3_mutex_enter(p->db->mutex);
+    if( !p->okVar ){
+      int j;
+      Op *pOp;
+      for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
+        if( pOp->opcode==OP_Variable ){
+          assert( pOp->p1>0 && pOp->p1<=p->nVar );
+          p->azVar[pOp->p1-1] = pOp->p4.z;
+        }
+      }
+      p->okVar = 1;
+    }
+    sqlite3_mutex_leave(p->db->mutex);
+  }
+}
+
+/*
+** Return the name of a wildcard parameter.  Return NULL if the index
+** is out of range or if the wildcard is unnamed.
+**
+** The result is always UTF-8.
+*/
+const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
+  Vdbe *p = (Vdbe*)pStmt;
+  if( p==0 || i<1 || i>p->nVar ){
+    return 0;
+  }
+  createVarMap(p);
+  return p->azVar[i-1];
+}
+
+/*
+** Given a wildcard parameter name, return the index of the variable
+** with that name.  If there is no variable with the given name,
+** return 0.
+*/
+int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
+  Vdbe *p = (Vdbe*)pStmt;
+  int i;
+  if( p==0 ){
+    return 0;
+  }
+  createVarMap(p); 
+  if( zName ){
+    for(i=0; i<p->nVar; i++){
+      const char *z = p->azVar[i];
+      if( z && strcmp(z,zName)==0 ){
+        return i+1;
+      }
+    }
+  }
+  return 0;
+}
+
+/*
+** Transfer all bindings from the first statement over to the second.
+** If the two statements contain a different number of bindings, then
+** an SQLITE_ERROR is returned.
+*/
+int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
+  Vdbe *pFrom = (Vdbe*)pFromStmt;
+  Vdbe *pTo = (Vdbe*)pToStmt;
+  int i, rc = SQLITE_OK;
+  if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
+    || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
+    || pTo->db!=pFrom->db ){
+    return SQLITE_MISUSE;
+  }
+  if( pFrom->nVar!=pTo->nVar ){
+    return SQLITE_ERROR;
+  }
+  sqlite3_mutex_enter(pTo->db->mutex);
+  for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
+    sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
+  }
+  sqlite3_mutex_leave(pTo->db->mutex);
+  assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
+  return rc;
+}
+
+/*
+** Return the sqlite3* database handle to which the prepared statement given
+** in the argument belongs.  This is the same database handle that was
+** the first argument to the sqlite3_prepare() that was used to create
+** the statement in the first place.
+*/
+sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
+  return pStmt ? ((Vdbe*)pStmt)->db : 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbeaux.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbeaux.c
new file mode 100644
index 0000000..c15207b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbeaux.c
@@ -0,0 +1,2314 @@
+/*
+** 2003 September 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 for creating, destroying, and populating
+** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.)  Prior
+** to version 2.8.7, all this code was combined into the vdbe.c source file.
+** But that file was getting too big so this subroutines were split out.
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include "vdbeInt.h"
+
+
+
+/*
+** When debugging the code generator in a symbolic debugger, one can
+** set the sqlite3_vdbe_addop_trace to 1 and all opcodes will be printed
+** as they are added to the instruction stream.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3_vdbe_addop_trace = 0;
+#endif
+
+
+/*
+** Create a new virtual database engine.
+*/
+Vdbe *sqlite3VdbeCreate(sqlite3 *db){
+  Vdbe *p;
+  p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
+  if( p==0 ) return 0;
+  p->db = db;
+  if( db->pVdbe ){
+    db->pVdbe->pPrev = p;
+  }
+  p->pNext = db->pVdbe;
+  p->pPrev = 0;
+  db->pVdbe = p;
+  p->magic = VDBE_MAGIC_INIT;
+  return p;
+}
+
+/*
+** Remember the SQL string for a prepared statement.
+*/
+void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n){
+  if( p==0 ) return;
+  assert( p->zSql==0 );
+  p->zSql = sqlite3DbStrNDup(p->db, z, n);
+}
+
+/*
+** Return the SQL associated with a prepared statement
+*/
+const char *sqlite3_sql(sqlite3_stmt *pStmt){
+  return ((Vdbe *)pStmt)->zSql;
+}
+
+/*
+** Swap all content between two VDBE structures.
+*/
+void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
+  Vdbe tmp, *pTmp;
+  char *zTmp;
+  int nTmp;
+  tmp = *pA;
+  *pA = *pB;
+  *pB = tmp;
+  pTmp = pA->pNext;
+  pA->pNext = pB->pNext;
+  pB->pNext = pTmp;
+  pTmp = pA->pPrev;
+  pA->pPrev = pB->pPrev;
+  pB->pPrev = pTmp;
+  zTmp = pA->zSql;
+  pA->zSql = pB->zSql;
+  pB->zSql = zTmp;
+  nTmp = pA->nSql;
+  pA->nSql = pB->nSql;
+  pB->nSql = nTmp;
+}
+
+#ifdef SQLITE_DEBUG
+/*
+** Turn tracing on or off
+*/
+void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
+  p->trace = trace;
+}
+#endif
+
+/*
+** Resize the Vdbe.aOp array so that it contains at least N
+** elements.
+**
+** If an out-of-memory error occurs while resizing the array,
+** Vdbe.aOp and Vdbe.nOpAlloc remain unchanged (this is so that
+** any opcodes already allocated can be correctly deallocated
+** along with the rest of the Vdbe).
+*/
+static void resizeOpArray(Vdbe *p, int N){
+  VdbeOp *pNew;
+  int oldSize = p->nOpAlloc;
+  pNew = sqlite3DbRealloc(p->db, p->aOp, N*sizeof(Op));
+  if( pNew ){
+    p->nOpAlloc = N;
+    p->aOp = pNew;
+    if( N>oldSize ){
+      memset(&p->aOp[oldSize], 0, (N-oldSize)*sizeof(Op));
+    }
+  }
+}
+
+/*
+** Add a new instruction to the list of instructions current in the
+** VDBE.  Return the address of the new instruction.
+**
+** Parameters:
+**
+**    p               Pointer to the VDBE
+**
+**    op              The opcode for this instruction
+**
+**    p1, p2, p3      Operands
+**
+** Use the sqlite3VdbeResolveLabel() function to fix an address and
+** the sqlite3VdbeChangeP4() function to change the value of the P4
+** operand.
+*/
+int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
+  int i;
+  VdbeOp *pOp;
+
+  i = p->nOp;
+  assert( p->magic==VDBE_MAGIC_INIT );
+  if( p->nOpAlloc<=i ){
+    resizeOpArray(p, p->nOpAlloc*2 + 100);
+    if( p->db->mallocFailed ){
+      return 0;
+    }
+  }
+  p->nOp++;
+  pOp = &p->aOp[i];
+  pOp->opcode = op;
+  pOp->p1 = p1;
+  pOp->p2 = p2;
+  pOp->p3 = p3;
+  pOp->p4.p = 0;
+  pOp->p4type = P4_NOTUSED;
+  p->expired = 0;
+#ifdef SQLITE_DEBUG
+  if( sqlite3_vdbe_addop_trace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]);
+#endif
+  return i;
+}
+int sqlite3VdbeAddOp0(Vdbe *p, int op){
+  return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
+}
+int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
+  return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
+}
+int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
+  return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
+}
+
+
+/*
+** Add an opcode that includes the p4 value as a pointer.
+*/
+int sqlite3VdbeAddOp4(
+  Vdbe *p,            /* Add the opcode to this VM */
+  int op,             /* The new opcode */
+  int p1,             /* The P1 operand */
+  int p2,             /* The P2 operand */
+  int p3,             /* The P3 operand */
+  const char *zP4,    /* The P4 operand */
+  int p4type          /* P4 operand type */
+){
+  int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
+  sqlite3VdbeChangeP4(p, addr, zP4, p4type);
+  return addr;
+}
+
+/*
+** Create a new symbolic label for an instruction that has yet to be
+** coded.  The symbolic label is really just a negative number.  The
+** label can be used as the P2 value of an operation.  Later, when
+** the label is resolved to a specific address, the VDBE will scan
+** through its operation list and change all values of P2 which match
+** the label into the resolved address.
+**
+** The VDBE knows that a P2 value is a label because labels are
+** always negative and P2 values are suppose to be non-negative.
+** Hence, a negative P2 value is a label that has yet to be resolved.
+**
+** Zero is returned if a malloc() fails.
+*/
+int sqlite3VdbeMakeLabel(Vdbe *p){
+  int i;
+  i = p->nLabel++;
+  assert( p->magic==VDBE_MAGIC_INIT );
+  if( i>=p->nLabelAlloc ){
+    p->nLabelAlloc = p->nLabelAlloc*2 + 10;
+    p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
+                                    p->nLabelAlloc*sizeof(p->aLabel[0]));
+  }
+  if( p->aLabel ){
+    p->aLabel[i] = -1;
+  }
+  return -1-i;
+}
+
+/*
+** Resolve label "x" to be the address of the next instruction to
+** be inserted.  The parameter "x" must have been obtained from
+** a prior call to sqlite3VdbeMakeLabel().
+*/
+void sqlite3VdbeResolveLabel(Vdbe *p, int x){
+  int j = -1-x;
+  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( j>=0 && j<p->nLabel );
+  if( p->aLabel ){
+    p->aLabel[j] = p->nOp;
+  }
+}
+
+/*
+** Loop through the program looking for P2 values that are negative
+** on jump instructions.  Each such value is a label.  Resolve the
+** label by setting the P2 value to its correct non-zero value.
+**
+** This routine is called once after all opcodes have been inserted.
+**
+** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument 
+** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by 
+** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array.
+**
+** This routine also does the following optimization:  It scans for
+** instructions that might cause a statement rollback.  Such instructions
+** are:
+**
+**   *  OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
+**   *  OP_Destroy
+**   *  OP_VUpdate
+**   *  OP_VRename
+**
+** If no such instruction is found, then every Statement instruction 
+** is changed to a Noop.  In this way, we avoid creating the statement 
+** journal file unnecessarily.
+*/
+static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
+  int i;
+  int nMaxArgs = 0;
+  Op *pOp;
+  int *aLabel = p->aLabel;
+  int doesStatementRollback = 0;
+  int hasStatementBegin = 0;
+  for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
+    u8 opcode = pOp->opcode;
+
+    if( opcode==OP_Function ){
+      if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
+    }else if( opcode==OP_AggStep 
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+        || opcode==OP_VUpdate
+#endif
+    ){
+      if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
+    }
+    if( opcode==OP_Halt ){
+      if( pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort ){
+        doesStatementRollback = 1;
+      }
+    }else if( opcode==OP_Statement ){
+      hasStatementBegin = 1;
+    }else if( opcode==OP_Destroy ){
+      doesStatementRollback = 1;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    }else if( opcode==OP_VUpdate || opcode==OP_VRename ){
+      doesStatementRollback = 1;
+    }else if( opcode==OP_VFilter ){
+      int n;
+      assert( p->nOp - i >= 3 );
+      assert( pOp[-1].opcode==OP_Integer );
+      n = pOp[-1].p1;
+      if( n>nMaxArgs ) nMaxArgs = n;
+#endif
+    }
+
+    if( sqlite3VdbeOpcodeHasProperty(opcode, OPFLG_JUMP) && pOp->p2<0 ){
+      assert( -1-pOp->p2<p->nLabel );
+      pOp->p2 = aLabel[-1-pOp->p2];
+    }
+  }
+  sqlite3_free(p->aLabel);
+  p->aLabel = 0;
+
+  *pMaxFuncArgs = nMaxArgs;
+
+  /* If we never rollback a statement transaction, then statement
+  ** transactions are not needed.  So change every OP_Statement
+  ** opcode into an OP_Noop.  This avoid a call to sqlite3OsOpenExclusive()
+  ** which can be expensive on some platforms.
+  */
+  if( hasStatementBegin && !doesStatementRollback ){
+    for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
+      if( pOp->opcode==OP_Statement ){
+        pOp->opcode = OP_Noop;
+      }
+    }
+  }
+}
+
+/*
+** Return the address of the next instruction to be inserted.
+*/
+int sqlite3VdbeCurrentAddr(Vdbe *p){
+  assert( p->magic==VDBE_MAGIC_INIT );
+  return p->nOp;
+}
+
+/*
+** Add a whole list of operations to the operation stack.  Return the
+** address of the first operation added.
+*/
+int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
+  int addr;
+  assert( p->magic==VDBE_MAGIC_INIT );
+  if( p->nOp + nOp > p->nOpAlloc ){
+    resizeOpArray(p, p->nOp*2 + nOp);
+  }
+  if( p->db->mallocFailed ){
+    return 0;
+  }
+  addr = p->nOp;
+  if( nOp>0 ){
+    int i;
+    VdbeOpList const *pIn = aOp;
+    for(i=0; i<nOp; i++, pIn++){
+      int p2 = pIn->p2;
+      VdbeOp *pOut = &p->aOp[i+addr];
+      pOut->opcode = pIn->opcode;
+      pOut->p1 = pIn->p1;
+      if( p2<0 && sqlite3VdbeOpcodeHasProperty(pOut->opcode, OPFLG_JUMP) ){
+        pOut->p2 = addr + ADDR(p2);
+      }else{
+        pOut->p2 = p2;
+      }
+      pOut->p3 = pIn->p3;
+      pOut->p4type = P4_NOTUSED;
+      pOut->p4.p = 0;
+      pOut->p5 = 0;
+#ifdef SQLITE_DEBUG
+      if( sqlite3_vdbe_addop_trace ){
+        sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
+      }
+#endif
+    }
+    p->nOp += nOp;
+  }
+  return addr;
+}
+
+/*
+** Change the value of the P1 operand for a specific instruction.
+** This routine is useful when a large program is loaded from a
+** static array using sqlite3VdbeAddOpList but we want to make a
+** few minor changes to the program.
+*/
+void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){
+  assert( p==0 || p->magic==VDBE_MAGIC_INIT );
+  if( p && addr>=0 && p->nOp>addr && p->aOp ){
+    p->aOp[addr].p1 = val;
+  }
+}
+
+/*
+** Change the value of the P2 operand for a specific instruction.
+** This routine is useful for setting a jump destination.
+*/
+void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){
+  assert( p==0 || p->magic==VDBE_MAGIC_INIT );
+  if( p && addr>=0 && p->nOp>addr && p->aOp ){
+    p->aOp[addr].p2 = val;
+  }
+}
+
+/*
+** Change the value of the P3 operand for a specific instruction.
+*/
+void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){
+  assert( p==0 || p->magic==VDBE_MAGIC_INIT );
+  if( p && addr>=0 && p->nOp>addr && p->aOp ){
+    p->aOp[addr].p3 = val;
+  }
+}
+
+/*
+** Change the value of the P5 operand for the most recently
+** added operation.
+*/
+void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
+  assert( p==0 || p->magic==VDBE_MAGIC_INIT );
+  if( p && p->aOp ){
+    assert( p->nOp>0 );
+    p->aOp[p->nOp-1].p5 = val;
+  }
+}
+
+/*
+** Change the P2 operand of instruction addr so that it points to
+** the address of the next instruction to be coded.
+*/
+void sqlite3VdbeJumpHere(Vdbe *p, int addr){
+  sqlite3VdbeChangeP2(p, addr, p->nOp);
+}
+
+
+/*
+** If the input FuncDef structure is ephemeral, then free it.  If
+** the FuncDef is not ephermal, then do nothing.
+*/
+static void freeEphemeralFunction(FuncDef *pDef){
+  if( pDef && (pDef->flags & SQLITE_FUNC_EPHEM)!=0 ){
+    sqlite3_free(pDef);
+  }
+}
+
+/*
+** Delete a P4 value if necessary.
+*/
+static void freeP4(int p4type, void *p3){
+  if( p3 ){
+    switch( p4type ){
+      case P4_REAL:
+      case P4_INT64:
+      case P4_MPRINTF:
+      case P4_DYNAMIC:
+      case P4_KEYINFO:
+      case P4_KEYINFO_HANDOFF: {
+        sqlite3_free(p3);
+        break;
+      }
+      case P4_VDBEFUNC: {
+        VdbeFunc *pVdbeFunc = (VdbeFunc *)p3;
+        freeEphemeralFunction(pVdbeFunc->pFunc);
+        sqlite3VdbeDeleteAuxData(pVdbeFunc, 0);
+        sqlite3_free(pVdbeFunc);
+        break;
+      }
+      case P4_FUNCDEF: {
+        freeEphemeralFunction((FuncDef*)p3);
+        break;
+      }
+      case P4_MEM: {
+        sqlite3ValueFree((sqlite3_value*)p3);
+        break;
+      }
+    }
+  }
+}
+
+
+/*
+** Change N opcodes starting at addr to No-ops.
+*/
+void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){
+  if( p && p->aOp ){
+    VdbeOp *pOp = &p->aOp[addr];
+    while( N-- ){
+      freeP4(pOp->p4type, pOp->p4.p);
+      memset(pOp, 0, sizeof(pOp[0]));
+      pOp->opcode = OP_Noop;
+      pOp++;
+    }
+  }
+}
+
+/*
+** Change the value of the P4 operand for a specific instruction.
+** This routine is useful when a large program is loaded from a
+** static array using sqlite3VdbeAddOpList but we want to make a
+** few minor changes to the program.
+**
+** If n>=0 then the P4 operand is dynamic, meaning that a copy of
+** the string is made into memory obtained from sqlite3_malloc().
+** A value of n==0 means copy bytes of zP4 up to and including the
+** first null byte.  If n>0 then copy n+1 bytes of zP4.
+**
+** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
+** A copy is made of the KeyInfo structure into memory obtained from
+** sqlite3_malloc, to be freed when the Vdbe is finalized.
+** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
+** stored in memory that the caller has obtained from sqlite3_malloc. The 
+** caller should not free the allocation, it will be freed when the Vdbe is
+** finalized.
+** 
+** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
+** to a string or structure that is guaranteed to exist for the lifetime of
+** the Vdbe. In these cases we can just copy the pointer.
+**
+** If addr<0 then change P4 on the most recently inserted instruction.
+*/
+void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
+  Op *pOp;
+  assert( p!=0 );
+  assert( p->magic==VDBE_MAGIC_INIT );
+  if( p->aOp==0 || p->db->mallocFailed ){
+    if (n != P4_KEYINFO) {
+      freeP4(n, (void*)*(char**)&zP4);
+    }
+    return;
+  }
+  assert( addr<p->nOp );
+  if( addr<0 ){
+    addr = p->nOp - 1;
+    if( addr<0 ) return;
+  }
+  pOp = &p->aOp[addr];
+  freeP4(pOp->p4type, pOp->p4.p);
+  pOp->p4.p = 0;
+  if( n==P4_INT32 ){
+    pOp->p4.i = (int)zP4;
+    pOp->p4type = n;
+  }else if( zP4==0 ){
+    pOp->p4.p = 0;
+    pOp->p4type = P4_NOTUSED;
+  }else if( n==P4_KEYINFO ){
+    KeyInfo *pKeyInfo;
+    int nField, nByte;
+
+    nField = ((KeyInfo*)zP4)->nField;
+    nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
+    pKeyInfo = sqlite3_malloc( nByte );
+    pOp->p4.pKeyInfo = pKeyInfo;
+    if( pKeyInfo ){
+      memcpy(pKeyInfo, zP4, nByte);
+      /* In the current implementation, P4_KEYINFO is only ever used on
+      ** KeyInfo structures that have no aSortOrder component.  Elements
+      ** with an aSortOrder always use P4_KEYINFO_HANDOFF.  So we do not
+      ** need to bother with duplicating the aSortOrder. */
+      assert( pKeyInfo->aSortOrder==0 );
+#if 0
+      aSortOrder = pKeyInfo->aSortOrder;
+      if( aSortOrder ){
+        pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField];
+        memcpy(pKeyInfo->aSortOrder, aSortOrder, nField);
+      }
+#endif
+      pOp->p4type = P4_KEYINFO;
+    }else{
+      p->db->mallocFailed = 1;
+      pOp->p4type = P4_NOTUSED;
+    }
+  }else if( n==P4_KEYINFO_HANDOFF ){
+    pOp->p4.p = (void*)zP4;
+    pOp->p4type = P4_KEYINFO;
+  }else if( n<0 ){
+    pOp->p4.p = (void*)zP4;
+    pOp->p4type = n;
+  }else{
+    if( n==0 ) n = strlen(zP4);
+    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
+    pOp->p4type = P4_DYNAMIC;
+  }
+}
+
+#ifndef NDEBUG
+/*
+** Change the comment on the the most recently coded instruction.
+*/
+void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
+  va_list ap;
+  assert( p->nOp>0 || p->aOp==0 );
+  assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
+  if( p->nOp ){
+    char **pz = &p->aOp[p->nOp-1].zComment;
+    va_start(ap, zFormat);
+    sqlite3_free(*pz);
+    *pz = sqlite3VMPrintf(p->db, zFormat, ap);
+    va_end(ap);
+  }
+}
+#endif
+
+/*
+** Return the opcode for a given address.
+*/
+VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
+  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
+  return ((addr>=0 && addr<p->nOp)?(&p->aOp[addr]):0);
+}
+
+#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
+     || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
+/*
+** Compute a string that describes the P4 parameter for an opcode.
+** Use zTemp for any required temporary buffer space.
+*/
+static char *displayP4(Op *pOp, char *zTemp, int nTemp){
+  char *zP4 = zTemp;
+  assert( nTemp>=20 );
+  switch( pOp->p4type ){
+    case P4_KEYINFO: {
+      int i, j;
+      KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
+      sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
+      i = strlen(zTemp);
+      for(j=0; j<pKeyInfo->nField; j++){
+        CollSeq *pColl = pKeyInfo->aColl[j];
+        if( pColl ){
+          int n = strlen(pColl->zName);
+          if( i+n>nTemp-6 ){
+            memcpy(&zTemp[i],",...",4);
+            break;
+          }
+          zTemp[i++] = ',';
+          if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){
+            zTemp[i++] = '-';
+          }
+          memcpy(&zTemp[i], pColl->zName,n+1);
+          i += n;
+        }else if( i+4<nTemp-6 ){
+          memcpy(&zTemp[i],",nil",4);
+          i += 4;
+        }
+      }
+      zTemp[i++] = ')';
+      zTemp[i] = 0;
+      assert( i<nTemp );
+      break;
+    }
+    case P4_COLLSEQ: {
+      CollSeq *pColl = pOp->p4.pColl;
+      sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
+      break;
+    }
+    case P4_FUNCDEF: {
+      FuncDef *pDef = pOp->p4.pFunc;
+      sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
+      break;
+    }
+    case P4_INT64: {
+      sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64);
+      break;
+    }
+    case P4_INT32: {
+      sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i);
+      break;
+    }
+    case P4_REAL: {
+      sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal);
+      break;
+    }
+    case P4_MEM: {
+      Mem *pMem = pOp->p4.pMem;
+      assert( (pMem->flags & MEM_Null)==0 );
+      if( pMem->flags & MEM_Str ){
+        zP4 = pMem->z;
+      }else if( pMem->flags & MEM_Int ){
+        sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
+      }else if( pMem->flags & MEM_Real ){
+        sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->r);
+      }
+      break;
+    }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    case P4_VTAB: {
+      sqlite3_vtab *pVtab = pOp->p4.pVtab;
+      sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
+      break;
+    }
+#endif
+    default: {
+      zP4 = pOp->p4.z;
+      if( zP4==0 ){
+        zP4 = zTemp;
+        zTemp[0] = 0;
+      }
+    }
+  }
+  assert( zP4!=0 );
+  return zP4;
+}
+#endif
+
+/*
+** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
+**
+*/
+void sqlite3VdbeUsesBtree(Vdbe *p, int i){
+  int mask;
+  assert( i>=0 && i<p->db->nDb );
+  assert( i<sizeof(p->btreeMask)*8 );
+  mask = 1<<i;
+  if( (p->btreeMask & mask)==0 ){
+    p->btreeMask |= mask;
+    sqlite3BtreeMutexArrayInsert(&p->aMutex, p->db->aDb[i].pBt);
+  }
+}
+
+
+#if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
+/*
+** Print a single opcode.  This routine is used for debugging only.
+*/
+void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
+  char *zP4;
+  char zPtr[50];
+  static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n";
+  if( pOut==0 ) pOut = stdout;
+  zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
+  fprintf(pOut, zFormat1, pc, 
+      sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
+#ifdef SQLITE_DEBUG
+      pOp->zComment ? pOp->zComment : ""
+#else
+      ""
+#endif
+  );
+  fflush(pOut);
+}
+#endif
+
+/*
+** Release an array of N Mem elements
+*/
+static void releaseMemArray(Mem *p, int N){
+  if( p ){
+    while( N-->0 ){
+      assert( N<2 || p[0].db==p[1].db );
+      sqlite3VdbeMemSetNull(p++);
+    }
+  }
+}
+
+#ifndef SQLITE_OMIT_EXPLAIN
+/*
+** Give a listing of the program in the virtual machine.
+**
+** The interface is the same as sqlite3VdbeExec().  But instead of
+** running the code, it invokes the callback once for each instruction.
+** This feature is used to implement "EXPLAIN".
+**
+** When p->explain==1, each instruction is listed.  When
+** p->explain==2, only OP_Explain instructions are listed and these
+** are shown in a different format.  p->explain==2 is used to implement
+** EXPLAIN QUERY PLAN.
+*/
+int sqlite3VdbeList(
+  Vdbe *p                   /* The VDBE */
+){
+  sqlite3 *db = p->db;
+  int i;
+  int rc = SQLITE_OK;
+  Mem *pMem = p->pResultSet = &p->aMem[1];
+
+  assert( p->explain );
+  if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE;
+  assert( db->magic==SQLITE_MAGIC_BUSY );
+  assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
+
+  /* Even though this opcode does not use dynamic strings for
+  ** the result, result columns may become dynamic if the user calls
+  ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
+  */
+  releaseMemArray(pMem, p->nMem);
+
+  do{
+    i = p->pc++;
+  }while( i<p->nOp && p->explain==2 && p->aOp[i].opcode!=OP_Explain );
+  if( i>=p->nOp ){
+    p->rc = SQLITE_OK;
+    rc = SQLITE_DONE;
+  }else if( db->u1.isInterrupted ){
+    p->rc = SQLITE_INTERRUPT;
+    rc = SQLITE_ERROR;
+    sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(p->rc), (char*)0);
+  }else{
+    Op *pOp = &p->aOp[i];
+    if( p->explain==1 ){
+      pMem->flags = MEM_Int;
+      pMem->type = SQLITE_INTEGER;
+      pMem->u.i = i;                                /* Program counter */
+      pMem++;
+  
+      pMem->flags = MEM_Static|MEM_Str|MEM_Term;
+      pMem->z = (char*)sqlite3OpcodeName(pOp->opcode);  /* Opcode */
+      assert( pMem->z!=0 );
+      pMem->n = strlen(pMem->z);
+      pMem->type = SQLITE_TEXT;
+      pMem->enc = SQLITE_UTF8;
+      pMem++;
+    }
+
+    pMem->flags = MEM_Int;
+    pMem->u.i = pOp->p1;                          /* P1 */
+    pMem->type = SQLITE_INTEGER;
+    pMem++;
+
+    pMem->flags = MEM_Int;
+    pMem->u.i = pOp->p2;                          /* P2 */
+    pMem->type = SQLITE_INTEGER;
+    pMem++;
+
+    if( p->explain==1 ){
+      pMem->flags = MEM_Int;
+      pMem->u.i = pOp->p3;                          /* P3 */
+      pMem->type = SQLITE_INTEGER;
+      pMem++;
+    }
+
+    pMem->flags = MEM_Ephem|MEM_Str|MEM_Term;     /* P4 */
+    pMem->z = displayP4(pOp, pMem->zShort, sizeof(pMem->zShort));
+    assert( pMem->z!=0 );
+    pMem->n = strlen(pMem->z);
+    pMem->type = SQLITE_TEXT;
+    pMem->enc = SQLITE_UTF8;
+    pMem++;
+
+    if( p->explain==1 ){
+      pMem->flags = MEM_Str|MEM_Term|MEM_Short;
+      pMem->n = sprintf(pMem->zShort, "%.2x", pOp->p5);   /* P5 */
+      pMem->z = pMem->zShort;
+      pMem->type = SQLITE_TEXT;
+      pMem->enc = SQLITE_UTF8;
+      pMem++;
+  
+      pMem->flags = MEM_Null;                       /* Comment */
+#ifdef SQLITE_DEBUG
+      if( pOp->zComment ){
+        pMem->flags = MEM_Str|MEM_Term;
+        pMem->z = pOp->zComment;
+        pMem->n = strlen(pMem->z);
+        pMem->enc = SQLITE_UTF8;
+      }
+#endif
+    }
+
+    p->nResColumn = 8 - 5*(p->explain-1);
+    p->rc = SQLITE_OK;
+    rc = SQLITE_ROW;
+  }
+  return rc;
+}
+#endif /* SQLITE_OMIT_EXPLAIN */
+
+#ifdef SQLITE_DEBUG
+/*
+** Print the SQL that was used to generate a VDBE program.
+*/
+void sqlite3VdbePrintSql(Vdbe *p){
+  int nOp = p->nOp;
+  VdbeOp *pOp;
+  if( nOp<1 ) return;
+  pOp = &p->aOp[0];
+  if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
+    const char *z = pOp->p4.z;
+    while( isspace(*(u8*)z) ) z++;
+    printf("SQL: [%s]\n", z);
+  }
+}
+#endif
+
+#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
+/*
+** Print an IOTRACE message showing SQL content.
+*/
+void sqlite3VdbeIOTraceSql(Vdbe *p){
+  int nOp = p->nOp;
+  VdbeOp *pOp;
+  if( sqlite3_io_trace==0 ) return;
+  if( nOp<1 ) return;
+  pOp = &p->aOp[0];
+  if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
+    int i, j;
+    char z[1000];
+    sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
+    for(i=0; isspace((unsigned char)z[i]); i++){}
+    for(j=0; z[i]; i++){
+      if( isspace((unsigned char)z[i]) ){
+        if( z[i-1]!=' ' ){
+          z[j++] = ' ';
+        }
+      }else{
+        z[j++] = z[i];
+      }
+    }
+    z[j] = 0;
+    sqlite3_io_trace("SQL %s\n", z);
+  }
+}
+#endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
+
+
+/*
+** Prepare a virtual machine for execution.  This involves things such
+** as allocating stack space and initializing the program counter.
+** After the VDBE has be prepped, it can be executed by one or more
+** calls to sqlite3VdbeExec().  
+**
+** This is the only way to move a VDBE from VDBE_MAGIC_INIT to
+** VDBE_MAGIC_RUN.
+*/
+void sqlite3VdbeMakeReady(
+  Vdbe *p,                       /* The VDBE */
+  int nVar,                      /* Number of '?' see in the SQL statement */
+  int nMem,                      /* Number of memory cells to allocate */
+  int nCursor,                   /* Number of cursors to allocate */
+  int isExplain                  /* True if the EXPLAIN keywords is present */
+){
+  int n;
+  sqlite3 *db = p->db;
+
+  assert( p!=0 );
+  assert( p->magic==VDBE_MAGIC_INIT );
+
+  /* There should be at least one opcode.
+  */
+  assert( p->nOp>0 );
+
+  /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. This
+   * is because the call to resizeOpArray() below may shrink the
+   * p->aOp[] array to save memory if called when in VDBE_MAGIC_RUN 
+   * state.
+   */
+  p->magic = VDBE_MAGIC_RUN;
+
+  /*
+  ** Allocation space for registers.
+  */
+  if( p->aMem==0 ){
+    int nArg;       /* Maximum number of args passed to a user function. */
+    resolveP2Values(p, &nArg);
+    resizeOpArray(p, p->nOp);
+    assert( nVar>=0 );
+    if( isExplain && nMem<10 ){
+      p->nMem = nMem = 10;
+    }
+    p->aMem = sqlite3DbMallocZero(db,
+        nMem*sizeof(Mem)               /* aMem */
+      + nVar*sizeof(Mem)               /* aVar */
+      + nArg*sizeof(Mem*)              /* apArg */
+      + nVar*sizeof(char*)             /* azVar */
+      + nCursor*sizeof(Cursor*) + 1    /* apCsr */
+    );
+    if( !db->mallocFailed ){
+      p->aMem--;             /* aMem[] goes from 1..nMem */
+      p->nMem = nMem;        /*       not from 0..nMem-1 */
+      p->aVar = &p->aMem[nMem+1];
+      p->nVar = nVar;
+      p->okVar = 0;
+      p->apArg = (Mem**)&p->aVar[nVar];
+      p->azVar = (char**)&p->apArg[nArg];
+      p->apCsr = (Cursor**)&p->azVar[nVar];
+      p->nCursor = nCursor;
+      for(n=0; n<nVar; n++){
+        p->aVar[n].flags = MEM_Null;
+        p->aVar[n].db = db;
+      }
+      for(n=1; n<=nMem; n++){
+        p->aMem[n].flags = MEM_Null;
+        p->aMem[n].db = db;
+      }
+    }
+  }
+#ifdef SQLITE_DEBUG
+  for(n=1; n<p->nMem; n++){
+    assert( p->aMem[n].db==db );
+    assert( p->aMem[n].flags==MEM_Null );
+  }
+#endif
+
+  p->pc = -1;
+  p->rc = SQLITE_OK;
+  p->uniqueCnt = 0;
+  p->returnDepth = 0;
+  p->errorAction = OE_Abort;
+  p->explain |= isExplain;
+  p->magic = VDBE_MAGIC_RUN;
+  p->nChange = 0;
+  p->cacheCtr = 1;
+  p->minWriteFileFormat = 255;
+  p->openedStatement = 0;
+#ifdef VDBE_PROFILE
+  {
+    int i;
+    for(i=0; i<p->nOp; i++){
+      p->aOp[i].cnt = 0;
+      p->aOp[i].cycles = 0;
+    }
+  }
+#endif
+}
+
+/*
+** Close a VDBE cursor and release all the resources that cursor happens
+** to hold.
+*/
+void sqlite3VdbeFreeCursor(Vdbe *p, Cursor *pCx){
+  if( pCx==0 ){
+    return;
+  }
+  if( pCx->pCursor ){
+    sqlite3BtreeCloseCursor(pCx->pCursor);
+  }
+  if( pCx->pBt ){
+    sqlite3BtreeClose(pCx->pBt);
+  }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  if( pCx->pVtabCursor ){
+    sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
+    const sqlite3_module *pModule = pCx->pModule;
+    p->inVtabMethod = 1;
+    (void)sqlite3SafetyOff(p->db);
+    pModule->xClose(pVtabCursor);
+    (void)sqlite3SafetyOn(p->db);
+    p->inVtabMethod = 0;
+  }
+#endif
+  sqlite3_free(pCx->pData);
+  sqlite3_free(pCx->aType);
+  sqlite3_free(pCx);
+}
+
+/*
+** Close all cursors except for VTab cursors that are currently
+** in use.
+*/
+static void closeAllCursorsExceptActiveVtabs(Vdbe *p){
+  int i;
+  if( p->apCsr==0 ) return;
+  for(i=0; i<p->nCursor; i++){
+    Cursor *pC = p->apCsr[i];
+    if( pC && (!p->inVtabMethod || !pC->pVtabCursor) ){
+      sqlite3VdbeFreeCursor(p, pC);
+      p->apCsr[i] = 0;
+    }
+  }
+}
+
+/*
+** Clean up the VM after execution.
+**
+** This routine will automatically close any cursors, lists, and/or
+** sorters that were left open.  It also deletes the values of
+** variables in the aVar[] array.
+*/
+static void Cleanup(Vdbe *p){
+  int i;
+  closeAllCursorsExceptActiveVtabs(p);
+  releaseMemArray(&p->aMem[1], p->nMem);
+  sqlite3VdbeFifoClear(&p->sFifo);
+  if( p->contextStack ){
+    for(i=0; i<p->contextStackTop; i++){
+      sqlite3VdbeFifoClear(&p->contextStack[i].sFifo);
+    }
+    sqlite3_free(p->contextStack);
+  }
+  p->contextStack = 0;
+  p->contextStackDepth = 0;
+  p->contextStackTop = 0;
+  sqlite3_free(p->zErrMsg);
+  p->zErrMsg = 0;
+  p->pResultSet = 0;
+}
+
+/*
+** Set the number of result columns that will be returned by this SQL
+** statement. This is now set at compile time, rather than during
+** execution of the vdbe program so that sqlite3_column_count() can
+** be called on an SQL statement before sqlite3_step().
+*/
+void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
+  Mem *pColName;
+  int n;
+
+  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
+  sqlite3_free(p->aColName);
+  n = nResColumn*COLNAME_N;
+  p->nResColumn = nResColumn;
+  p->aColName = pColName = (Mem*)sqlite3DbMallocZero(p->db, sizeof(Mem)*n );
+  if( p->aColName==0 ) return;
+  while( n-- > 0 ){
+    pColName->flags = MEM_Null;
+    pColName->db = p->db;
+    pColName++;
+  }
+}
+
+/*
+** Set the name of the idx'th column to be returned by the SQL statement.
+** zName must be a pointer to a nul terminated string.
+**
+** This call must be made after a call to sqlite3VdbeSetNumCols().
+**
+** If N==P4_STATIC  it means that zName is a pointer to a constant static
+** string and we can just copy the pointer. If it is P4_DYNAMIC, then 
+** the string is freed using sqlite3_free() when the vdbe is finished with
+** it. Otherwise, N bytes of zName are copied.
+*/
+int sqlite3VdbeSetColName(Vdbe *p, int idx, int var, const char *zName, int N){
+  int rc;
+  Mem *pColName;
+  assert( idx<p->nResColumn );
+  assert( var<COLNAME_N );
+  if( p->db->mallocFailed ) return SQLITE_NOMEM;
+  assert( p->aColName!=0 );
+  pColName = &(p->aColName[idx+var*p->nResColumn]);
+  if( N==P4_DYNAMIC || N==P4_STATIC ){
+    rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC);
+  }else{
+    rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT);
+  }
+  if( rc==SQLITE_OK && N==P4_DYNAMIC ){
+    pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn;
+    pColName->xDel = 0;
+  }
+  return rc;
+}
+
+/*
+** A read or write transaction may or may not be active on database handle
+** db. If a transaction is active, commit it. If there is a
+** write-transaction spanning more than one database file, this routine
+** takes care of the master journal trickery.
+*/
+static int vdbeCommit(sqlite3 *db){
+  int i;
+  int nTrans = 0;  /* Number of databases with an active write-transaction */
+  int rc = SQLITE_OK;
+  int needXcommit = 0;
+
+  /* Before doing anything else, call the xSync() callback for any
+  ** virtual module tables written in this transaction. This has to
+  ** be done before determining whether a master journal file is 
+  ** required, as an xSync() callback may add an attached database
+  ** to the transaction.
+  */
+  rc = sqlite3VtabSync(db, rc);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  /* This loop determines (a) if the commit hook should be invoked and
+  ** (b) how many database files have open write transactions, not 
+  ** including the temp database. (b) is important because if more than 
+  ** one database file has an open write transaction, a master journal
+  ** file is required for an atomic commit.
+  */ 
+  for(i=0; i<db->nDb; i++){ 
+    Btree *pBt = db->aDb[i].pBt;
+    if( sqlite3BtreeIsInTrans(pBt) ){
+      needXcommit = 1;
+      if( i!=1 ) nTrans++;
+    }
+  }
+
+  /* If there are any write-transactions at all, invoke the commit hook */
+  if( needXcommit && db->xCommitCallback ){
+    (void)sqlite3SafetyOff(db);
+    rc = db->xCommitCallback(db->pCommitArg);
+    (void)sqlite3SafetyOn(db);
+    if( rc ){
+      return SQLITE_CONSTRAINT;
+    }
+  }
+
+  /* The simple case - no more than one database file (not counting the
+  ** TEMP database) has a transaction active.   There is no need for the
+  ** master-journal.
+  **
+  ** If the return value of sqlite3BtreeGetFilename() is a zero length
+  ** string, it means the main database is :memory:.  In that case we do
+  ** not support atomic multi-file commits, so use the simple case then
+  ** too.
+  */
+  if( 0==strlen(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){
+    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ 
+      Btree *pBt = db->aDb[i].pBt;
+      if( pBt ){
+        rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
+      }
+    }
+
+    /* Do the commit only if all databases successfully complete phase 1. 
+    ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
+    ** IO error while deleting or truncating a journal file. It is unlikely,
+    ** but could happen. In this case abandon processing and return the error.
+    */
+    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
+      Btree *pBt = db->aDb[i].pBt;
+      if( pBt ){
+        rc = sqlite3BtreeCommitPhaseTwo(pBt);
+      }
+    }
+    if( rc==SQLITE_OK ){
+      sqlite3VtabCommit(db);
+    }
+  }
+
+  /* The complex case - There is a multi-file write-transaction active.
+  ** This requires a master journal file to ensure the transaction is
+  ** committed atomicly.
+  */
+#ifndef SQLITE_OMIT_DISKIO
+  else{
+    sqlite3_vfs *pVfs = db->pVfs;
+    int needSync = 0;
+    char *zMaster = 0;   /* File-name for the master journal */
+    char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
+    sqlite3_file *pMaster = 0;
+    i64 offset = 0;
+
+    /* Select a master journal file name */
+    do {
+      u32 random;
+      sqlite3_free(zMaster);
+      sqlite3Randomness(sizeof(random), &random);
+      zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, random&0x7fffffff);
+      if( !zMaster ){
+        return SQLITE_NOMEM;
+      }
+    }while( sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS) );
+
+    /* Open the master journal. */
+    rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster, 
+        SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
+        SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0
+    );
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(zMaster);
+      return rc;
+    }
+ 
+    /* Write the name of each database file in the transaction into the new
+    ** master journal file. If an error occurs at this point close
+    ** and delete the master journal file. All the individual journal files
+    ** still have 'null' as the master journal pointer, so they will roll
+    ** back independently if a failure occurs.
+    */
+    for(i=0; i<db->nDb; i++){
+      Btree *pBt = db->aDb[i].pBt;
+      if( i==1 ) continue;   /* Ignore the TEMP database */
+      if( sqlite3BtreeIsInTrans(pBt) ){
+        char const *zFile = sqlite3BtreeGetJournalname(pBt);
+        if( zFile[0]==0 ) continue;  /* Ignore :memory: databases */
+        if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
+          needSync = 1;
+        }
+        rc = sqlite3OsWrite(pMaster, zFile, strlen(zFile)+1, offset);
+        offset += strlen(zFile)+1;
+        if( rc!=SQLITE_OK ){
+          sqlite3OsCloseFree(pMaster);
+          sqlite3OsDelete(pVfs, zMaster, 0);
+          sqlite3_free(zMaster);
+          return rc;
+        }
+      }
+    }
+
+    /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
+    ** flag is set this is not required.
+    */
+    zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt);
+    if( (needSync 
+     && (0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL))
+     && (rc=sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))!=SQLITE_OK) ){
+      sqlite3OsCloseFree(pMaster);
+      sqlite3OsDelete(pVfs, zMaster, 0);
+      sqlite3_free(zMaster);
+      return rc;
+    }
+
+    /* Sync all the db files involved in the transaction. The same call
+    ** sets the master journal pointer in each individual journal. If
+    ** an error occurs here, do not delete the master journal file.
+    **
+    ** If the error occurs during the first call to
+    ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
+    ** master journal file will be orphaned. But we cannot delete it,
+    ** in case the master journal file name was written into the journal
+    ** file before the failure occured.
+    */
+    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ 
+      Btree *pBt = db->aDb[i].pBt;
+      if( pBt ){
+        rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
+      }
+    }
+    sqlite3OsCloseFree(pMaster);
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(zMaster);
+      return rc;
+    }
+
+    /* Delete the master journal file. This commits the transaction. After
+    ** doing this the directory is synced again before any individual
+    ** transaction files are deleted.
+    */
+    rc = sqlite3OsDelete(pVfs, zMaster, 1);
+    sqlite3_free(zMaster);
+    zMaster = 0;
+    if( rc ){
+      return rc;
+    }
+
+    /* All files and directories have already been synced, so the following
+    ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
+    ** deleting or truncating journals. If something goes wrong while
+    ** this is happening we don't really care. The integrity of the
+    ** transaction is already guaranteed, but some stray 'cold' journals
+    ** may be lying around. Returning an error code won't help matters.
+    */
+    disable_simulated_io_errors();
+    for(i=0; i<db->nDb; i++){ 
+      Btree *pBt = db->aDb[i].pBt;
+      if( pBt ){
+        sqlite3BtreeCommitPhaseTwo(pBt);
+      }
+    }
+    enable_simulated_io_errors();
+
+    sqlite3VtabCommit(db);
+  }
+#endif
+
+  return rc;
+}
+
+/* 
+** This routine checks that the sqlite3.activeVdbeCnt count variable
+** matches the number of vdbe's in the list sqlite3.pVdbe that are
+** currently active. An assertion fails if the two counts do not match.
+** This is an internal self-check only - it is not an essential processing
+** step.
+**
+** This is a no-op if NDEBUG is defined.
+*/
+#ifndef NDEBUG
+static void checkActiveVdbeCnt(sqlite3 *db){
+  Vdbe *p;
+  int cnt = 0;
+  p = db->pVdbe;
+  while( p ){
+    if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
+      cnt++;
+    }
+    p = p->pNext;
+  }
+  assert( cnt==db->activeVdbeCnt );
+}
+#else
+#define checkActiveVdbeCnt(x)
+#endif
+
+/*
+** For every Btree that in database connection db which 
+** has been modified, "trip" or invalidate each cursor in
+** that Btree might have been modified so that the cursor
+** can never be used again.  This happens when a rollback
+*** occurs.  We have to trip all the other cursors, even
+** cursor from other VMs in different database connections,
+** so that none of them try to use the data at which they
+** were pointing and which now may have been changed due
+** to the rollback.
+**
+** Remember that a rollback can delete tables complete and
+** reorder rootpages.  So it is not sufficient just to save
+** the state of the cursor.  We have to invalidate the cursor
+** so that it is never used again.
+*/
+static void invalidateCursorsOnModifiedBtrees(sqlite3 *db){
+  int i;
+  for(i=0; i<db->nDb; i++){
+    Btree *p = db->aDb[i].pBt;
+    if( p && sqlite3BtreeIsInTrans(p) ){
+      sqlite3BtreeTripAllCursors(p, SQLITE_ABORT);
+    }
+  }
+}
+
+/*
+** This routine is called the when a VDBE tries to halt.  If the VDBE
+** has made changes and is in autocommit mode, then commit those
+** changes.  If a rollback is needed, then do the rollback.
+**
+** This routine is the only way to move the state of a VM from
+** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT.  It is harmless to
+** call this on a VM that is in the SQLITE_MAGIC_HALT state.
+**
+** Return an error code.  If the commit could not complete because of
+** lock contention, return SQLITE_BUSY.  If SQLITE_BUSY is returned, it
+** means the close did not happen and needs to be repeated.
+*/
+int sqlite3VdbeHalt(Vdbe *p){
+  sqlite3 *db = p->db;
+  int i;
+  int (*xFunc)(Btree *pBt) = 0;  /* Function to call on each btree backend */
+  int isSpecialError;            /* Set to true if SQLITE_NOMEM or IOERR */
+
+  /* This function contains the logic that determines if a statement or
+  ** transaction will be committed or rolled back as a result of the
+  ** execution of this virtual machine. 
+  **
+  ** If any of the following errors occur:
+  **
+  **     SQLITE_NOMEM
+  **     SQLITE_IOERR
+  **     SQLITE_FULL
+  **     SQLITE_INTERRUPT
+  **
+  ** Then the internal cache might have been left in an inconsistent
+  ** state.  We need to rollback the statement transaction, if there is
+  ** one, or the complete transaction if there is no statement transaction.
+  */
+
+  if( p->db->mallocFailed ){
+    p->rc = SQLITE_NOMEM;
+  }
+  closeAllCursorsExceptActiveVtabs(p);
+  if( p->magic!=VDBE_MAGIC_RUN ){
+    return SQLITE_OK;
+  }
+  checkActiveVdbeCnt(db);
+
+  /* No commit or rollback needed if the program never started */
+  if( p->pc>=0 ){
+    int mrc;   /* Primary error code from p->rc */
+
+    /* Lock all btrees used by the statement */
+    sqlite3BtreeMutexArrayEnter(&p->aMutex);
+
+    /* Check for one of the special errors */
+    mrc = p->rc & 0xff;
+    isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
+                     || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
+    if( isSpecialError ){
+      /* This loop does static analysis of the query to see which of the
+      ** following three categories it falls into:
+      **
+      **     Read-only
+      **     Query with statement journal
+      **     Query without statement journal
+      **
+      ** We could do something more elegant than this static analysis (i.e.
+      ** store the type of query as part of the compliation phase), but 
+      ** handling malloc() or IO failure is a fairly obscure edge case so 
+      ** this is probably easier. Todo: Might be an opportunity to reduce 
+      ** code size a very small amount though...
+      */
+      int notReadOnly = 0;
+      int isStatement = 0;
+      assert(p->aOp || p->nOp==0);
+      for(i=0; i<p->nOp; i++){ 
+        switch( p->aOp[i].opcode ){
+          case OP_Transaction:
+            notReadOnly |= p->aOp[i].p2;
+            break;
+          case OP_Statement:
+            isStatement = 1;
+            break;
+        }
+      }
+
+   
+      /* If the query was read-only, we need do no rollback at all. Otherwise,
+      ** proceed with the special handling.
+      */
+      if( notReadOnly || mrc!=SQLITE_INTERRUPT ){
+        if( p->rc==SQLITE_IOERR_BLOCKED && isStatement ){
+          xFunc = sqlite3BtreeRollbackStmt;
+          p->rc = SQLITE_BUSY;
+        } else if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && isStatement ){
+          xFunc = sqlite3BtreeRollbackStmt;
+        }else{
+          /* We are forced to roll back the active transaction. Before doing
+          ** so, abort any other statements this handle currently has active.
+          */
+          invalidateCursorsOnModifiedBtrees(db);
+          sqlite3RollbackAll(db);
+          db->autoCommit = 1;
+        }
+      }
+    }
+  
+    /* If the auto-commit flag is set and this is the only active vdbe, then
+    ** we do either a commit or rollback of the current transaction. 
+    **
+    ** Note: This block also runs if one of the special errors handled 
+    ** above has occured. 
+    */
+    if( db->autoCommit && db->activeVdbeCnt==1 ){
+      if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
+        /* The auto-commit flag is true, and the vdbe program was 
+        ** successful or hit an 'OR FAIL' constraint. This means a commit 
+        ** is required.
+        */
+        int rc = vdbeCommit(db);
+        if( rc==SQLITE_BUSY ){
+          sqlite3BtreeMutexArrayLeave(&p->aMutex);
+          return SQLITE_BUSY;
+        }else if( rc!=SQLITE_OK ){
+          p->rc = rc;
+          sqlite3RollbackAll(db);
+        }else{
+          sqlite3CommitInternalChanges(db);
+        }
+      }else{
+        sqlite3RollbackAll(db);
+      }
+    }else if( !xFunc ){
+      if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
+        if( p->openedStatement ){
+          xFunc = sqlite3BtreeCommitStmt;
+        } 
+      }else if( p->errorAction==OE_Abort ){
+        xFunc = sqlite3BtreeRollbackStmt;
+      }else{
+        invalidateCursorsOnModifiedBtrees(db);
+        sqlite3RollbackAll(db);
+        db->autoCommit = 1;
+      }
+    }
+  
+    /* If xFunc is not NULL, then it is one of sqlite3BtreeRollbackStmt or
+    ** sqlite3BtreeCommitStmt. Call it once on each backend. If an error occurs
+    ** and the return code is still SQLITE_OK, set the return code to the new
+    ** error value.
+    */
+    assert(!xFunc ||
+      xFunc==sqlite3BtreeCommitStmt ||
+      xFunc==sqlite3BtreeRollbackStmt
+    );
+    for(i=0; xFunc && i<db->nDb; i++){ 
+      int rc;
+      Btree *pBt = db->aDb[i].pBt;
+      if( pBt ){
+        rc = xFunc(pBt);
+        if( rc && (p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT) ){
+          p->rc = rc;
+          sqlite3SetString(&p->zErrMsg, 0);
+        }
+      }
+    }
+  
+    /* If this was an INSERT, UPDATE or DELETE and the statement was committed, 
+    ** set the change counter. 
+    */
+    if( p->changeCntOn && p->pc>=0 ){
+      if( !xFunc || xFunc==sqlite3BtreeCommitStmt ){
+        sqlite3VdbeSetChanges(db, p->nChange);
+      }else{
+        sqlite3VdbeSetChanges(db, 0);
+      }
+      p->nChange = 0;
+    }
+  
+    /* Rollback or commit any schema changes that occurred. */
+    if( p->rc!=SQLITE_OK && db->flags&SQLITE_InternChanges ){
+      sqlite3ResetInternalSchema(db, 0);
+      db->flags = (db->flags | SQLITE_InternChanges);
+    }
+
+    /* Release the locks */
+    sqlite3BtreeMutexArrayLeave(&p->aMutex);
+  }
+
+  /* We have successfully halted and closed the VM.  Record this fact. */
+  if( p->pc>=0 ){
+    db->activeVdbeCnt--;
+  }
+  p->magic = VDBE_MAGIC_HALT;
+  checkActiveVdbeCnt(db);
+  if( p->db->mallocFailed ){
+    p->rc = SQLITE_NOMEM;
+  }
+  checkActiveVdbeCnt(db);
+
+  return SQLITE_OK;
+}
+
+
+/*
+** Each VDBE holds the result of the most recent sqlite3_step() call
+** in p->rc.  This routine sets that result back to SQLITE_OK.
+*/
+void sqlite3VdbeResetStepResult(Vdbe *p){
+  p->rc = SQLITE_OK;
+}
+
+/*
+** Clean up a VDBE after execution but do not delete the VDBE just yet.
+** Write any error messages into *pzErrMsg.  Return the result code.
+**
+** After this routine is run, the VDBE should be ready to be executed
+** again.
+**
+** To look at it another way, this routine resets the state of the
+** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
+** VDBE_MAGIC_INIT.
+*/
+int sqlite3VdbeReset(Vdbe *p){
+  sqlite3 *db;
+  db = p->db;
+
+  /* If the VM did not run to completion or if it encountered an
+  ** error, then it might not have been halted properly.  So halt
+  ** it now.
+  */
+  (void)sqlite3SafetyOn(db);
+  sqlite3VdbeHalt(p);
+  (void)sqlite3SafetyOff(db);
+
+  /* If the VDBE has be run even partially, then transfer the error code
+  ** and error message from the VDBE into the main database structure.  But
+  ** if the VDBE has just been set to run but has not actually executed any
+  ** instructions yet, leave the main database error information unchanged.
+  */
+  if( p->pc>=0 ){
+    if( p->zErrMsg ){
+      sqlite3ValueSetStr(db->pErr,-1,p->zErrMsg,SQLITE_UTF8,sqlite3_free);
+      db->errCode = p->rc;
+      p->zErrMsg = 0;
+    }else if( p->rc ){
+      sqlite3Error(db, p->rc, 0);
+    }else{
+      sqlite3Error(db, SQLITE_OK, 0);
+    }
+  }else if( p->rc && p->expired ){
+    /* The expired flag was set on the VDBE before the first call
+    ** to sqlite3_step(). For consistency (since sqlite3_step() was
+    ** called), set the database error in this case as well.
+    */
+    sqlite3Error(db, p->rc, 0);
+    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, sqlite3_free);
+    p->zErrMsg = 0;
+  }
+
+  /* Reclaim all memory used by the VDBE
+  */
+  Cleanup(p);
+
+  /* Save profiling information from this VDBE run.
+  */
+#ifdef VDBE_PROFILE
+  {
+    FILE *out = fopen("vdbe_profile.out", "a");
+    if( out ){
+      int i;
+      fprintf(out, "---- ");
+      for(i=0; i<p->nOp; i++){
+        fprintf(out, "%02x", p->aOp[i].opcode);
+      }
+      fprintf(out, "\n");
+      for(i=0; i<p->nOp; i++){
+        fprintf(out, "%6d %10lld %8lld ",
+           p->aOp[i].cnt,
+           p->aOp[i].cycles,
+           p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
+        );
+        sqlite3VdbePrintOp(out, i, &p->aOp[i]);
+      }
+      fclose(out);
+    }
+  }
+#endif
+  p->magic = VDBE_MAGIC_INIT;
+  p->aborted = 0;
+  return p->rc & db->errMask;
+}
+ 
+/*
+** Clean up and delete a VDBE after execution.  Return an integer which is
+** the result code.  Write any error message text into *pzErrMsg.
+*/
+int sqlite3VdbeFinalize(Vdbe *p){
+  int rc = SQLITE_OK;
+  if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
+    rc = sqlite3VdbeReset(p);
+    assert( (rc & p->db->errMask)==rc );
+  }else if( p->magic!=VDBE_MAGIC_INIT ){
+    return SQLITE_MISUSE;
+  }
+  sqlite3VdbeDelete(p);
+  return rc;
+}
+
+/*
+** Call the destructor for each auxdata entry in pVdbeFunc for which
+** the corresponding bit in mask is clear.  Auxdata entries beyond 31
+** are always destroyed.  To destroy all auxdata entries, call this
+** routine with mask==0.
+*/
+void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
+  int i;
+  for(i=0; i<pVdbeFunc->nAux; i++){
+    struct AuxData *pAux = &pVdbeFunc->apAux[i];
+    if( (i>31 || !(mask&(1<<i))) && pAux->pAux ){
+      if( pAux->xDelete ){
+        pAux->xDelete(pAux->pAux);
+      }
+      pAux->pAux = 0;
+    }
+  }
+}
+
+/*
+** Delete an entire VDBE.
+*/
+void sqlite3VdbeDelete(Vdbe *p){
+  int i;
+  if( p==0 ) return;
+  Cleanup(p);
+  if( p->pPrev ){
+    p->pPrev->pNext = p->pNext;
+  }else{
+    assert( p->db->pVdbe==p );
+    p->db->pVdbe = p->pNext;
+  }
+  if( p->pNext ){
+    p->pNext->pPrev = p->pPrev;
+  }
+  if( p->aOp ){
+    Op *pOp = p->aOp;
+    for(i=0; i<p->nOp; i++, pOp++){
+      freeP4(pOp->p4type, pOp->p4.p);
+#ifdef SQLITE_DEBUG
+      sqlite3_free(pOp->zComment);
+#endif     
+    }
+    sqlite3_free(p->aOp);
+  }
+  releaseMemArray(p->aVar, p->nVar);
+  sqlite3_free(p->aLabel);
+  if( p->aMem ){
+    sqlite3_free(&p->aMem[1]);
+  }
+  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
+  sqlite3_free(p->aColName);
+  sqlite3_free(p->zSql);
+  p->magic = VDBE_MAGIC_DEAD;
+  sqlite3_free(p);
+}
+
+/*
+** If a MoveTo operation is pending on the given cursor, then do that
+** MoveTo now.  Return an error code.  If no MoveTo is pending, this
+** routine does nothing and returns SQLITE_OK.
+*/
+int sqlite3VdbeCursorMoveto(Cursor *p){
+  if( p->deferredMoveto ){
+    int res, rc;
+#ifdef SQLITE_TEST
+    extern int sqlite3_search_count;
+#endif
+    assert( p->isTable );
+    rc = sqlite3BtreeMoveto(p->pCursor, 0, p->movetoTarget, 0, &res);
+    if( rc ) return rc;
+    *p->pIncrKey = 0;
+    p->lastRowid = keyToInt(p->movetoTarget);
+    p->rowidIsValid = res==0;
+    if( res<0 ){
+      rc = sqlite3BtreeNext(p->pCursor, &res);
+      if( rc ) return rc;
+    }
+#ifdef SQLITE_TEST
+    sqlite3_search_count++;
+#endif
+    p->deferredMoveto = 0;
+    p->cacheStatus = CACHE_STALE;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** The following functions:
+**
+** sqlite3VdbeSerialType()
+** sqlite3VdbeSerialTypeLen()
+** sqlite3VdbeSerialRead()
+** sqlite3VdbeSerialLen()
+** sqlite3VdbeSerialWrite()
+**
+** encapsulate the code that serializes values for storage in SQLite
+** data and index records. Each serialized value consists of a
+** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
+** integer, stored as a varint.
+**
+** In an SQLite index record, the serial type is stored directly before
+** the blob of data that it corresponds to. In a table record, all serial
+** types are stored at the start of the record, and the blobs of data at
+** the end. Hence these functions allow the caller to handle the
+** serial-type and data blob seperately.
+**
+** The following table describes the various storage classes for data:
+**
+**   serial type        bytes of data      type
+**   --------------     ---------------    ---------------
+**      0                     0            NULL
+**      1                     1            signed integer
+**      2                     2            signed integer
+**      3                     3            signed integer
+**      4                     4            signed integer
+**      5                     6            signed integer
+**      6                     8            signed integer
+**      7                     8            IEEE float
+**      8                     0            Integer constant 0
+**      9                     0            Integer constant 1
+**     10,11                               reserved for expansion
+**    N>=12 and even       (N-12)/2        BLOB
+**    N>=13 and odd        (N-13)/2        text
+**
+** The 8 and 9 types were added in 3.3.0, file format 4.  Prior versions
+** of SQLite will not understand those serial types.
+*/
+
+/*
+** Return the serial-type for the value stored in pMem.
+*/
+u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
+  int flags = pMem->flags;
+  int n;
+
+  if( flags&MEM_Null ){
+    return 0;
+  }
+  if( flags&MEM_Int ){
+    /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
+#   define MAX_6BYTE ((((i64)0x00001000)<<32)-1)
+    i64 i = pMem->u.i;
+    u64 u;
+    if( file_format>=4 && (i&1)==i ){
+      return 8+i;
+    }
+    u = i<0 ? -i : i;
+    if( u<=127 ) return 1;
+    if( u<=32767 ) return 2;
+    if( u<=8388607 ) return 3;
+    if( u<=2147483647 ) return 4;
+    if( u<=MAX_6BYTE ) return 5;
+    return 6;
+  }
+  if( flags&MEM_Real ){
+    return 7;
+  }
+  assert( flags&(MEM_Str|MEM_Blob) );
+  n = pMem->n;
+  if( flags & MEM_Zero ){
+    n += pMem->u.i;
+  }
+  assert( n>=0 );
+  return ((n*2) + 12 + ((flags&MEM_Str)!=0));
+}
+
+/*
+** Return the length of the data corresponding to the supplied serial-type.
+*/
+int sqlite3VdbeSerialTypeLen(u32 serial_type){
+  if( serial_type>=12 ){
+    return (serial_type-12)/2;
+  }else{
+    static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
+    return aSize[serial_type];
+  }
+}
+
+/*
+** If we are on an architecture with mixed-endian floating 
+** points (ex: ARM7) then swap the lower 4 bytes with the 
+** upper 4 bytes.  Return the result.
+**
+** For most architectures, this is a no-op.
+**
+** (later):  It is reported to me that the mixed-endian problem
+** on ARM7 is an issue with GCC, not with the ARM7 chip.  It seems
+** that early versions of GCC stored the two words of a 64-bit
+** float in the wrong order.  And that error has been propagated
+** ever since.  The blame is not necessarily with GCC, though.
+** GCC might have just copying the problem from a prior compiler.
+** I am also told that newer versions of GCC that follow a different
+** ABI get the byte order right.
+**
+** Developers using SQLite on an ARM7 should compile and run their
+** application using -DSQLITE_DEBUG=1 at least once.  With DEBUG
+** enabled, some asserts below will ensure that the byte order of
+** floating point values is correct.
+**
+** (2007-08-30)  Frank van Vugt has studied this problem closely
+** and has send his findings to the SQLite developers.  Frank
+** writes that some Linux kernels offer floating point hardware
+** emulation that uses only 32-bit mantissas instead of a full 
+** 48-bits as required by the IEEE standard.  (This is the
+** CONFIG_FPE_FASTFPE option.)  On such systems, floating point
+** byte swapping becomes very complicated.  To avoid problems,
+** the necessary byte swapping is carried out using a 64-bit integer
+** rather than a 64-bit float.  Frank assures us that the code here
+** works for him.  We, the developers, have no way to independently
+** verify this, but Frank seems to know what he is talking about
+** so we trust him.
+*/
+#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
+static u64 floatSwap(u64 in){
+  union {
+    u64 r;
+    u32 i[2];
+  } u;
+  u32 t;
+
+  u.r = in;
+  t = u.i[0];
+  u.i[0] = u.i[1];
+  u.i[1] = t;
+  return u.r;
+}
+# define swapMixedEndianFloat(X)  X = floatSwap(X)
+#else
+# define swapMixedEndianFloat(X)
+#endif
+
+/*
+** Write the serialized data blob for the value stored in pMem into 
+** buf. It is assumed that the caller has allocated sufficient space.
+** Return the number of bytes written.
+**
+** nBuf is the amount of space left in buf[].  nBuf must always be
+** large enough to hold the entire field.  Except, if the field is
+** a blob with a zero-filled tail, then buf[] might be just the right
+** size to hold everything except for the zero-filled tail.  If buf[]
+** is only big enough to hold the non-zero prefix, then only write that
+** prefix into buf[].  But if buf[] is large enough to hold both the
+** prefix and the tail then write the prefix and set the tail to all
+** zeros.
+**
+** Return the number of bytes actually written into buf[].  The number
+** of bytes in the zero-filled tail is included in the return value only
+** if those bytes were zeroed in buf[].
+*/ 
+int sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
+  u32 serial_type = sqlite3VdbeSerialType(pMem, file_format);
+  int len;
+
+  /* Integer and Real */
+  if( serial_type<=7 && serial_type>0 ){
+    u64 v;
+    int i;
+    if( serial_type==7 ){
+      assert( sizeof(v)==sizeof(pMem->r) );
+      memcpy(&v, &pMem->r, sizeof(v));
+      swapMixedEndianFloat(v);
+    }else{
+      v = pMem->u.i;
+    }
+    len = i = sqlite3VdbeSerialTypeLen(serial_type);
+    assert( len<=nBuf );
+    while( i-- ){
+      buf[i] = (v&0xFF);
+      v >>= 8;
+    }
+    return len;
+  }
+
+  /* String or blob */
+  if( serial_type>=12 ){
+    assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.i:0)
+             == sqlite3VdbeSerialTypeLen(serial_type) );
+    assert( pMem->n<=nBuf );
+    len = pMem->n;
+    memcpy(buf, pMem->z, len);
+    if( pMem->flags & MEM_Zero ){
+      len += pMem->u.i;
+      if( len>nBuf ){
+        len = nBuf;
+      }
+      memset(&buf[pMem->n], 0, len-pMem->n);
+    }
+    return len;
+  }
+
+  /* NULL or constants 0 or 1 */
+  return 0;
+}
+
+/*
+** Deserialize the data blob pointed to by buf as serial type serial_type
+** and store the result in pMem.  Return the number of bytes read.
+*/ 
+int sqlite3VdbeSerialGet(
+  const unsigned char *buf,     /* Buffer to deserialize from */
+  u32 serial_type,              /* Serial type to deserialize */
+  Mem *pMem                     /* Memory cell to write value into */
+){
+  switch( serial_type ){
+    case 10:   /* Reserved for future use */
+    case 11:   /* Reserved for future use */
+    case 0: {  /* NULL */
+      pMem->flags = MEM_Null;
+      break;
+    }
+    case 1: { /* 1-byte signed integer */
+      pMem->u.i = (signed char)buf[0];
+      pMem->flags = MEM_Int;
+      return 1;
+    }
+    case 2: { /* 2-byte signed integer */
+      pMem->u.i = (((signed char)buf[0])<<8) | buf[1];
+      pMem->flags = MEM_Int;
+      return 2;
+    }
+    case 3: { /* 3-byte signed integer */
+      pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2];
+      pMem->flags = MEM_Int;
+      return 3;
+    }
+    case 4: { /* 4-byte signed integer */
+      pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
+      pMem->flags = MEM_Int;
+      return 4;
+    }
+    case 5: { /* 6-byte signed integer */
+      u64 x = (((signed char)buf[0])<<8) | buf[1];
+      u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
+      x = (x<<32) | y;
+      pMem->u.i = *(i64*)&x;
+      pMem->flags = MEM_Int;
+      return 6;
+    }
+    case 6:   /* 8-byte signed integer */
+    case 7: { /* IEEE floating point */
+      u64 x;
+      u32 y;
+#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
+      /* Verify that integers and floating point values use the same
+      ** byte order.  Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
+      ** defined that 64-bit floating point values really are mixed
+      ** endian.
+      */
+      static const u64 t1 = ((u64)0x3ff00000)<<32;
+      static const double r1 = 1.0;
+      u64 t2 = t1;
+      swapMixedEndianFloat(t2);
+      assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
+#endif
+
+      x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
+      y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7];
+      x = (x<<32) | y;
+      if( serial_type==6 ){
+        pMem->u.i = *(i64*)&x;
+        pMem->flags = MEM_Int;
+      }else{
+        assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
+        swapMixedEndianFloat(x);
+        memcpy(&pMem->r, &x, sizeof(x));
+        pMem->flags = MEM_Real;
+      }
+      return 8;
+    }
+    case 8:    /* Integer 0 */
+    case 9: {  /* Integer 1 */
+      pMem->u.i = serial_type-8;
+      pMem->flags = MEM_Int;
+      return 0;
+    }
+    default: {
+      int len = (serial_type-12)/2;
+      pMem->z = (char *)buf;
+      pMem->n = len;
+      pMem->xDel = 0;
+      if( serial_type&0x01 ){
+        pMem->flags = MEM_Str | MEM_Ephem;
+      }else{
+        pMem->flags = MEM_Blob | MEM_Ephem;
+      }
+      return len;
+    }
+  }
+  return 0;
+}
+
+/*
+** The header of a record consists of a sequence variable-length integers.
+** These integers are almost always small and are encoded as a single byte.
+** The following macro takes advantage this fact to provide a fast decode
+** of the integers in a record header.  It is faster for the common case
+** where the integer is a single byte.  It is a little slower when the
+** integer is two or more bytes.  But overall it is faster.
+**
+** The following expressions are equivalent:
+**
+**     x = sqlite3GetVarint32( A, &B );
+**
+**     x = GetVarint( A, B );
+**
+*/
+#define GetVarint(A,B)  ((B = *(A))<=0x7f ? 1 : sqlite3GetVarint32(A, &B))
+
+/*
+** This function compares the two table rows or index records specified by 
+** {nKey1, pKey1} and {nKey2, pKey2}, returning a negative, zero
+** or positive integer if {nKey1, pKey1} is less than, equal to or 
+** greater than {nKey2, pKey2}.  Both Key1 and Key2 must be byte strings
+** composed by the OP_MakeRecord opcode of the VDBE.
+**
+** Key1 and Key2 do not have to contain the same number of fields.
+** But if the lengths differ, Key2 must be the shorter of the two.
+*/
+int sqlite3VdbeRecordCompare(
+  void *userData,
+  int nKey1, const void *pKey1, 
+  int nKey2, const void *pKey2
+){
+  KeyInfo *pKeyInfo = (KeyInfo*)userData;
+  u32 d1, d2;          /* Offset into aKey[] of next data element */
+  u32 idx1, idx2;      /* Offset into aKey[] of next header element */
+  u32 szHdr1, szHdr2;  /* Number of bytes in header */
+  int i = 0;
+  int nField;
+  int rc = 0;
+  const unsigned char *aKey1 = (const unsigned char *)pKey1;
+  const unsigned char *aKey2 = (const unsigned char *)pKey2;
+
+  Mem mem1;
+  Mem mem2;
+  mem1.enc = pKeyInfo->enc;
+  mem1.db = pKeyInfo->db;
+  mem2.enc = pKeyInfo->enc;
+  mem2.db = pKeyInfo->db;
+  
+  idx1 = GetVarint(aKey1, szHdr1);
+  d1 = szHdr1;
+  idx2 = GetVarint(aKey2, szHdr2);
+  d2 = szHdr2;
+  nField = pKeyInfo->nField;
+  while( idx1<szHdr1 && idx2<szHdr2 ){
+    u32 serial_type1;
+    u32 serial_type2;
+
+    /* Read the serial types for the next element in each key. */
+    idx1 += GetVarint( aKey1+idx1, serial_type1 );
+    if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break;
+    idx2 += GetVarint( aKey2+idx2, serial_type2 );
+    if( d2>=nKey2 && sqlite3VdbeSerialTypeLen(serial_type2)>0 ) break;
+
+    /* Extract the values to be compared.
+    */
+    d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
+    d2 += sqlite3VdbeSerialGet(&aKey2[d2], serial_type2, &mem2);
+
+    /* Do the comparison
+    */
+    rc = sqlite3MemCompare(&mem1, &mem2, i<nField ? pKeyInfo->aColl[i] : 0);
+    if( mem1.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem1);
+    if( mem2.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem2);
+    if( rc!=0 ){
+      break;
+    }
+    i++;
+  }
+
+  /* One of the keys ran out of fields, but all the fields up to that point
+  ** were equal. If the incrKey flag is true, then the second key is
+  ** treated as larger.
+  */
+  if( rc==0 ){
+    if( pKeyInfo->incrKey ){
+      rc = -1;
+    }else if( !pKeyInfo->prefixIsEqual ){
+      if( d1<nKey1 ){
+        rc = 1;
+      }else if( d2<nKey2 ){
+        rc = -1;  /* Only occurs on a corrupt database file */
+      }
+    }
+  }else if( pKeyInfo->aSortOrder && i<pKeyInfo->nField
+               && pKeyInfo->aSortOrder[i] ){
+    rc = -rc;
+  }
+
+  return rc;
+}
+
+/*
+** The argument is an index entry composed using the OP_MakeRecord opcode.
+** The last entry in this record should be an integer (specifically
+** an integer rowid).  This routine returns the number of bytes in
+** that integer.
+*/
+int sqlite3VdbeIdxRowidLen(const u8 *aKey){
+  u32 szHdr;        /* Size of the header */
+  u32 typeRowid;    /* Serial type of the rowid */
+
+  sqlite3GetVarint32(aKey, &szHdr);
+  sqlite3GetVarint32(&aKey[szHdr-1], &typeRowid);
+  return sqlite3VdbeSerialTypeLen(typeRowid);
+}
+  
+
+/*
+** pCur points at an index entry created using the OP_MakeRecord opcode.
+** Read the rowid (the last field in the record) and store it in *rowid.
+** Return SQLITE_OK if everything works, or an error code otherwise.
+*/
+int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
+  i64 nCellKey = 0;
+  int rc;
+  u32 szHdr;        /* Size of the header */
+  u32 typeRowid;    /* Serial type of the rowid */
+  u32 lenRowid;     /* Size of the rowid */
+  Mem m, v;
+
+  sqlite3BtreeKeySize(pCur, &nCellKey);
+  if( nCellKey<=0 ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+  rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m);
+  if( rc ){
+    return rc;
+  }
+  sqlite3GetVarint32((u8*)m.z, &szHdr);
+  sqlite3GetVarint32((u8*)&m.z[szHdr-1], &typeRowid);
+  lenRowid = sqlite3VdbeSerialTypeLen(typeRowid);
+  sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
+  *rowid = v.u.i;
+  sqlite3VdbeMemRelease(&m);
+  return SQLITE_OK;
+}
+
+/*
+** Compare the key of the index entry that cursor pC is point to against
+** the key string in pKey (of length nKey).  Write into *pRes a number
+** that is negative, zero, or positive if pC is less than, equal to,
+** or greater than pKey.  Return SQLITE_OK on success.
+**
+** pKey is either created without a rowid or is truncated so that it
+** omits the rowid at the end.  The rowid at the end of the index entry
+** is ignored as well.
+*/
+int sqlite3VdbeIdxKeyCompare(
+  Cursor *pC,                 /* The cursor to compare against */
+  int nKey, const u8 *pKey,   /* The key to compare */
+  int *res                    /* Write the comparison result here */
+){
+  i64 nCellKey = 0;
+  int rc;
+  BtCursor *pCur = pC->pCursor;
+  int lenRowid;
+  Mem m;
+
+  sqlite3BtreeKeySize(pCur, &nCellKey);
+  if( nCellKey<=0 ){
+    *res = 0;
+    return SQLITE_OK;
+  }
+  rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m);
+  if( rc ){
+    return rc;
+  }
+  lenRowid = sqlite3VdbeIdxRowidLen((u8*)m.z);
+  *res = sqlite3VdbeRecordCompare(pC->pKeyInfo, m.n-lenRowid, m.z, nKey, pKey);
+  sqlite3VdbeMemRelease(&m);
+  return SQLITE_OK;
+}
+
+/*
+** This routine sets the value to be returned by subsequent calls to
+** sqlite3_changes() on the database handle 'db'. 
+*/
+void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
+  assert( sqlite3_mutex_held(db->mutex) );
+  db->nChange = nChange;
+  db->nTotalChange += nChange;
+}
+
+/*
+** Set a flag in the vdbe to update the change counter when it is finalised
+** or reset.
+*/
+void sqlite3VdbeCountChanges(Vdbe *v){
+  v->changeCntOn = 1;
+}
+
+/*
+** Mark every prepared statement associated with a database connection
+** as expired.
+**
+** An expired statement means that recompilation of the statement is
+** recommend.  Statements expire when things happen that make their
+** programs obsolete.  Removing user-defined functions or collating
+** sequences, or changing an authorization function are the types of
+** things that make prepared statements obsolete.
+*/
+void sqlite3ExpirePreparedStatements(sqlite3 *db){
+  Vdbe *p;
+  for(p = db->pVdbe; p; p=p->pNext){
+    p->expired = 1;
+  }
+}
+
+/*
+** Return the database associated with the Vdbe.
+*/
+sqlite3 *sqlite3VdbeDb(Vdbe *v){
+  return v->db;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbeblob.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbeblob.c
new file mode 100644
index 0000000..70d5ed8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbeblob.c
@@ -0,0 +1,337 @@
+/*
+** 2007 May 1
+**
+** 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 incremental BLOB I/O.
+**
+** $Id: vdbeblob.c,v 1.20 2008/01/25 15:04:50 drh Exp $
+*/
+
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+
+#ifndef SQLITE_OMIT_INCRBLOB
+
+/*
+** Valid sqlite3_blob* handles point to Incrblob structures.
+*/
+typedef struct Incrblob Incrblob;
+struct Incrblob {
+  int flags;              /* Copy of "flags" passed to sqlite3_blob_open() */
+  int nByte;              /* Size of open blob, in bytes */
+  int iOffset;            /* Byte offset of blob in cursor data */
+  BtCursor *pCsr;         /* Cursor pointing at blob row */
+  sqlite3_stmt *pStmt;    /* Statement holding cursor open */
+  sqlite3 *db;            /* The associated database */
+};
+
+/*
+** Open a blob handle.
+*/
+int sqlite3_blob_open(
+  sqlite3* db,            /* The database connection */
+  const char *zDb,        /* The attached database containing the blob */
+  const char *zTable,     /* The table containing the blob */
+  const char *zColumn,    /* The column containing the blob */
+  sqlite_int64 iRow,      /* The row containing the glob */
+  int flags,              /* True -> read/write access, false -> read-only */
+  sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
+){
+  int nAttempt = 0;
+  int iCol;               /* Index of zColumn in row-record */
+
+  /* This VDBE program seeks a btree cursor to the identified 
+  ** db/table/row entry. The reason for using a vdbe program instead
+  ** of writing code to use the b-tree layer directly is that the
+  ** vdbe program will take advantage of the various transaction,
+  ** locking and error handling infrastructure built into the vdbe.
+  **
+  ** After seeking the cursor, the vdbe executes an OP_ResultRow.
+  ** Code external to the Vdbe then "borrows" the b-tree cursor and
+  ** uses it to implement the blob_read(), blob_write() and 
+  ** blob_bytes() functions.
+  **
+  ** The sqlite3_blob_close() function finalizes the vdbe program,
+  ** which closes the b-tree cursor and (possibly) commits the 
+  ** transaction.
+  */
+  static const VdbeOpList openBlob[] = {
+    {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */
+    {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */
+
+    /* One of the following two instructions is replaced by an
+    ** OP_Noop before exection.
+    */
+    {OP_OpenRead, 0, 0, 0},        /* 2: Open cursor 0 for reading */
+    {OP_OpenWrite, 0, 0, 0},       /* 3: Open cursor 0 for read/write */
+    {OP_SetNumColumns, 0, 0, 0},   /* 4: Num cols for cursor */
+
+    {OP_Variable, 1, 1, 0},        /* 5: Push the rowid to the stack */
+    {OP_NotExists, 0, 10, 1},      /* 6: Seek the cursor */
+    {OP_Column, 0, 0, 1},          /* 7  */
+    {OP_ResultRow, 1, 0, 0},       /* 8  */
+    {OP_Close, 0, 0, 0},           /* 9  */
+    {OP_Halt, 0, 0, 0},            /* 10 */
+  };
+
+  Vdbe *v = 0;
+  int rc = SQLITE_OK;
+  char zErr[128];
+
+  zErr[0] = 0;
+  sqlite3_mutex_enter(db->mutex);
+  do {
+    Parse sParse;
+    Table *pTab;
+
+    memset(&sParse, 0, sizeof(Parse));
+    sParse.db = db;
+
+    rc = sqlite3SafetyOn(db);
+    if( rc!=SQLITE_OK ){
+      sqlite3_mutex_leave(db->mutex);
+      return rc;
+    }
+
+    sqlite3BtreeEnterAll(db);
+    pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
+    if( !pTab ){
+      if( sParse.zErrMsg ){
+        sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);
+      }
+      sqlite3_free(sParse.zErrMsg);
+      rc = SQLITE_ERROR;
+      (void)sqlite3SafetyOff(db);
+      sqlite3BtreeLeaveAll(db);
+      goto blob_open_out;
+    }
+
+    /* Now search pTab for the exact column. */
+    for(iCol=0; iCol < pTab->nCol; iCol++) {
+      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
+        break;
+      }
+    }
+    if( iCol==pTab->nCol ){
+      sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);
+      rc = SQLITE_ERROR;
+      (void)sqlite3SafetyOff(db);
+      sqlite3BtreeLeaveAll(db);
+      goto blob_open_out;
+    }
+
+    /* If the value is being opened for writing, check that the
+    ** column is not indexed. It is against the rules to open an
+    ** indexed column for writing.
+    */
+    if( flags ){
+      Index *pIdx;
+      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+        int j;
+        for(j=0; j<pIdx->nColumn; j++){
+          if( pIdx->aiColumn[j]==iCol ){
+            sqlite3_snprintf(sizeof(zErr), zErr,
+                             "cannot open indexed column for writing");
+            rc = SQLITE_ERROR;
+            (void)sqlite3SafetyOff(db);
+            sqlite3BtreeLeaveAll(db);
+            goto blob_open_out;
+          }
+        }
+      }
+    }
+
+    v = sqlite3VdbeCreate(db);
+    if( v ){
+      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+      sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
+
+      /* Configure the OP_Transaction */
+      sqlite3VdbeChangeP1(v, 0, iDb);
+      sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));
+
+      /* Configure the OP_VerifyCookie */
+      sqlite3VdbeChangeP1(v, 1, iDb);
+      sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
+
+      /* Make sure a mutex is held on the table to be accessed */
+      sqlite3VdbeUsesBtree(v, iDb); 
+
+      /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
+      ** parameter of the other to pTab->tnum. 
+      */
+      sqlite3VdbeChangeToNoop(v, (flags ? 2 : 3), 1);
+      sqlite3VdbeChangeP2(v, (flags ? 3 : 2), pTab->tnum);
+      sqlite3VdbeChangeP3(v, (flags ? 3 : 2), iDb);
+
+      /* Configure the OP_SetNumColumns. Configure the cursor to
+      ** think that the table has one more column than it really
+      ** does. An OP_Column to retrieve this imaginary column will
+      ** always return an SQL NULL. This is useful because it means
+      ** we can invoke OP_Column to fill in the vdbe cursors type 
+      ** and offset cache without causing any IO.
+      */
+      sqlite3VdbeChangeP2(v, 4, pTab->nCol+1);
+      if( !db->mallocFailed ){
+        sqlite3VdbeMakeReady(v, 1, 1, 1, 0);
+      }
+    }
+   
+    sqlite3BtreeLeaveAll(db);
+    rc = sqlite3SafetyOff(db);
+    if( rc!=SQLITE_OK || db->mallocFailed ){
+      goto blob_open_out;
+    }
+
+    sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);
+    rc = sqlite3_step((sqlite3_stmt *)v);
+    if( rc!=SQLITE_ROW ){
+      nAttempt++;
+      rc = sqlite3_finalize((sqlite3_stmt *)v);
+      sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));
+      v = 0;
+    }
+  } while( nAttempt<5 && rc==SQLITE_SCHEMA );
+
+  if( rc==SQLITE_ROW ){
+    /* The row-record has been opened successfully. Check that the
+    ** column in question contains text or a blob. If it contains
+    ** text, it is up to the caller to get the encoding right.
+    */
+    Incrblob *pBlob;
+    u32 type = v->apCsr[0]->aType[iCol];
+
+    if( type<12 ){
+      sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",
+          type==0?"null": type==7?"real": "integer"
+      );
+      rc = SQLITE_ERROR;
+      goto blob_open_out;
+    }
+    pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
+    if( db->mallocFailed ){
+      sqlite3_free(pBlob);
+      goto blob_open_out;
+    }
+    pBlob->flags = flags;
+    pBlob->pCsr =  v->apCsr[0]->pCursor;
+    sqlite3BtreeEnterCursor(pBlob->pCsr);
+    sqlite3BtreeCacheOverflow(pBlob->pCsr);
+    sqlite3BtreeLeaveCursor(pBlob->pCsr);
+    pBlob->pStmt = (sqlite3_stmt *)v;
+    pBlob->iOffset = v->apCsr[0]->aOffset[iCol];
+    pBlob->nByte = sqlite3VdbeSerialTypeLen(type);
+    pBlob->db = db;
+    *ppBlob = (sqlite3_blob *)pBlob;
+    rc = SQLITE_OK;
+  }else if( rc==SQLITE_OK ){
+    sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);
+    rc = SQLITE_ERROR;
+  }
+
+blob_open_out:
+  zErr[sizeof(zErr)-1] = '\0';
+  if( rc!=SQLITE_OK || db->mallocFailed ){
+    sqlite3_finalize((sqlite3_stmt *)v);
+  }
+  sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Close a blob handle that was previously created using
+** sqlite3_blob_open().
+*/
+int sqlite3_blob_close(sqlite3_blob *pBlob){
+  Incrblob *p = (Incrblob *)pBlob;
+  int rc;
+
+  rc = sqlite3_finalize(p->pStmt);
+  sqlite3_free(p);
+  return rc;
+}
+
+/*
+** Perform a read or write operation on a blob
+*/
+static int blobReadWrite(
+  sqlite3_blob *pBlob, 
+  void *z, 
+  int n, 
+  int iOffset, 
+  int (*xCall)(BtCursor*, u32, u32, void*)
+){
+  int rc;
+  Incrblob *p = (Incrblob *)pBlob;
+  Vdbe *v;
+  sqlite3 *db = p->db;  
+
+  /* Request is out of range. Return a transient error. */
+  if( (iOffset+n)>p->nByte ){
+    return SQLITE_ERROR;
+  }
+  sqlite3_mutex_enter(db->mutex);
+
+  /* If there is no statement handle, then the blob-handle has
+  ** already been invalidated. Return SQLITE_ABORT in this case.
+  */
+  v = (Vdbe*)p->pStmt;
+  if( v==0 ){
+    rc = SQLITE_ABORT;
+  }else{
+    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
+    ** returned, clean-up the statement handle.
+    */
+    assert( db == v->db );
+    sqlite3BtreeEnterCursor(p->pCsr);
+    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
+    sqlite3BtreeLeaveCursor(p->pCsr);
+    if( rc==SQLITE_ABORT ){
+      sqlite3VdbeFinalize(v);
+      p->pStmt = 0;
+    }else{
+      db->errCode = rc;
+      v->rc = rc;
+    }
+  }
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Read data from a blob handle.
+*/
+int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
+  return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
+}
+
+/*
+** Write data to a blob handle.
+*/
+int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
+  return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
+}
+
+/*
+** Query a blob handle for the size of the data.
+**
+** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
+** so no mutex is required for access.
+*/
+int sqlite3_blob_bytes(sqlite3_blob *pBlob){
+  Incrblob *p = (Incrblob *)pBlob;
+  return p->nByte;
+}
+
+#endif /* #ifndef SQLITE_OMIT_INCRBLOB */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbefifo.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbefifo.c
new file mode 100644
index 0000000..f03f5c6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbefifo.c
@@ -0,0 +1,114 @@
+/*
+** 2005 June 16
+**
+** 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 implements a FIFO queue of rowids used for processing
+** UPDATE and DELETE statements.
+*/
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+
+/*
+** Allocate a new FifoPage and return a pointer to it.  Return NULL if
+** we run out of memory.  Leave space on the page for nEntry entries.
+*/
+static FifoPage *allocateFifoPage(int nEntry){
+  FifoPage *pPage;
+  if( nEntry>32767 ){
+    nEntry = 32767;
+  }
+  pPage = sqlite3_malloc( sizeof(FifoPage) + sizeof(i64)*(nEntry-1) );
+  if( pPage ){
+    pPage->nSlot = nEntry;
+    pPage->iWrite = 0;
+    pPage->iRead = 0;
+    pPage->pNext = 0;
+  }
+  return pPage;
+}
+
+/*
+** Initialize a Fifo structure.
+*/
+void sqlite3VdbeFifoInit(Fifo *pFifo){
+  memset(pFifo, 0, sizeof(*pFifo));
+}
+
+/*
+** Push a single 64-bit integer value into the Fifo.  Return SQLITE_OK
+** normally.   SQLITE_NOMEM is returned if we are unable to allocate
+** memory.
+*/
+int sqlite3VdbeFifoPush(Fifo *pFifo, i64 val){
+  FifoPage *pPage;
+  pPage = pFifo->pLast;
+  if( pPage==0 ){
+    pPage = pFifo->pLast = pFifo->pFirst = allocateFifoPage(20);
+    if( pPage==0 ){
+      return SQLITE_NOMEM;
+    }
+  }else if( pPage->iWrite>=pPage->nSlot ){
+    pPage->pNext = allocateFifoPage(pFifo->nEntry);
+    if( pPage->pNext==0 ){
+      return SQLITE_NOMEM;
+    }
+    pPage = pFifo->pLast = pPage->pNext;
+  }
+  pPage->aSlot[pPage->iWrite++] = val;
+  pFifo->nEntry++;
+  return SQLITE_OK;
+}
+
+/*
+** Extract a single 64-bit integer value from the Fifo.  The integer
+** extracted is the one least recently inserted.  If the Fifo is empty
+** return SQLITE_DONE.
+*/
+int sqlite3VdbeFifoPop(Fifo *pFifo, i64 *pVal){
+  FifoPage *pPage;
+  if( pFifo->nEntry==0 ){
+    return SQLITE_DONE;
+  }
+  assert( pFifo->nEntry>0 );
+  pPage = pFifo->pFirst;
+  assert( pPage!=0 );
+  assert( pPage->iWrite>pPage->iRead );
+  assert( pPage->iWrite<=pPage->nSlot );
+  assert( pPage->iRead<pPage->nSlot );
+  assert( pPage->iRead>=0 );
+  *pVal = pPage->aSlot[pPage->iRead++];
+  pFifo->nEntry--;
+  if( pPage->iRead>=pPage->iWrite ){
+    pFifo->pFirst = pPage->pNext;
+    sqlite3_free(pPage);
+    if( pFifo->nEntry==0 ){
+      assert( pFifo->pLast==pPage );
+      pFifo->pLast = 0;
+    }else{
+      assert( pFifo->pFirst!=0 );
+    }
+  }else{
+    assert( pFifo->nEntry>0 );
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Delete all information from a Fifo object.   Free all memory held
+** by the Fifo.
+*/
+void sqlite3VdbeFifoClear(Fifo *pFifo){
+  FifoPage *pPage, *pNextPage;
+  for(pPage=pFifo->pFirst; pPage; pPage=pNextPage){
+    pNextPage = pPage->pNext;
+    sqlite3_free(pPage);
+  }
+  sqlite3VdbeFifoInit(pFifo);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vdbemem.c b/client/src/thirdparty/sqlite-3.4.2/src/vdbemem.c
new file mode 100644
index 0000000..fa407b6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vdbemem.c
@@ -0,0 +1,1040 @@
+/*
+** 2004 May 26
+**
+** 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 use to manipulate "Mem" structure.  A "Mem"
+** stores a single value in the VDBE.  Mem is an opaque structure visible
+** only within the VDBE.  Interface routines refer to a Mem using the
+** name sqlite_value
+*/
+#include "sqliteInt.h"
+#include <ctype.h>
+#include "vdbeInt.h"
+
+/*
+** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
+** P if required.
+*/
+#define expandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
+
+/*
+** If pMem is an object with a valid string representation, this routine
+** ensures the internal encoding for the string representation is
+** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
+**
+** If pMem is not a string object, or the encoding of the string
+** representation is already stored using the requested encoding, then this
+** routine is a no-op.
+**
+** SQLITE_OK is returned if the conversion is successful (or not required).
+** SQLITE_NOMEM may be returned if a malloc() fails during conversion
+** between formats.
+*/
+int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
+  int rc;
+  if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
+    return SQLITE_OK;
+  }
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+#ifdef SQLITE_OMIT_UTF16
+  return SQLITE_ERROR;
+#else
+
+  /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
+  ** then the encoding of the value may not have changed.
+  */
+  rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);
+  assert(rc==SQLITE_OK    || rc==SQLITE_NOMEM);
+  assert(rc==SQLITE_OK    || pMem->enc!=desiredEnc);
+  assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
+  return rc;
+#endif
+}
+
+/*
+** Make the given Mem object MEM_Dyn.
+**
+** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
+*/
+int sqlite3VdbeMemDynamicify(Mem *pMem){
+  int n;
+  u8 *z;
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  expandBlob(pMem);
+  if( (pMem->flags & (MEM_Ephem|MEM_Static|MEM_Short))==0 ){
+    return SQLITE_OK;
+  }
+  assert( (pMem->flags & MEM_Dyn)==0 );
+  n = pMem->n;
+  assert( pMem->flags & (MEM_Str|MEM_Blob) );
+  z = sqlite3DbMallocRaw(pMem->db, n+2 );
+  if( z==0 ){
+    return SQLITE_NOMEM;
+  }
+  pMem->flags |= MEM_Dyn|MEM_Term;
+  pMem->xDel = 0;
+  memcpy(z, pMem->z, n );
+  z[n] = 0;
+  z[n+1] = 0;
+  pMem->z = (char*)z;
+  pMem->flags &= ~(MEM_Ephem|MEM_Static|MEM_Short);
+  return SQLITE_OK;
+}
+
+/*
+** If the given Mem* has a zero-filled tail, turn it into an ordinary
+** blob stored in dynamically allocated space.
+*/
+#ifndef SQLITE_OMIT_INCRBLOB
+int sqlite3VdbeMemExpandBlob(Mem *pMem){
+  if( pMem->flags & MEM_Zero ){
+    char *pNew;
+    int nByte;
+    assert( (pMem->flags & MEM_Blob)!=0 );
+    nByte = pMem->n + pMem->u.i;
+    if( nByte<=0 ) nByte = 1;
+    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+    pNew = sqlite3DbMallocRaw(pMem->db, nByte);
+    if( pNew==0 ){
+      return SQLITE_NOMEM;
+    }
+    memcpy(pNew, pMem->z, pMem->n);
+    memset(&pNew[pMem->n], 0, pMem->u.i);
+    sqlite3VdbeMemRelease(pMem);
+    pMem->z = pNew;
+    pMem->n += pMem->u.i;
+    pMem->u.i = 0;
+    pMem->flags &= ~(MEM_Zero|MEM_Static|MEM_Ephem|MEM_Short|MEM_Term);
+    pMem->flags |= MEM_Dyn;
+  }
+  return SQLITE_OK;
+}
+#endif
+
+
+/*
+** Make the given Mem object either MEM_Short or MEM_Dyn so that bytes
+** of the Mem.z[] array can be modified.
+**
+** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
+*/
+int sqlite3VdbeMemMakeWriteable(Mem *pMem){
+  int n;
+  u8 *z;
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  expandBlob(pMem);
+  if( (pMem->flags & (MEM_Ephem|MEM_Static))==0 ){
+    return SQLITE_OK;
+  }
+  assert( (pMem->flags & MEM_Dyn)==0 );
+  assert( pMem->flags & (MEM_Str|MEM_Blob) );
+  if( (n = pMem->n)+2<sizeof(pMem->zShort) ){
+    z = (u8*)pMem->zShort;
+    pMem->flags |= MEM_Short|MEM_Term;
+  }else{
+    z = sqlite3DbMallocRaw(pMem->db, n+2 );
+    if( z==0 ){
+      return SQLITE_NOMEM;
+    }
+    pMem->flags |= MEM_Dyn|MEM_Term;
+    pMem->xDel = 0;
+  }
+  memcpy(z, pMem->z, n );
+  z[n] = 0;
+  z[n+1] = 0;
+  pMem->z = (char*)z;
+  pMem->flags &= ~(MEM_Ephem|MEM_Static);
+  assert(0==(1&(int)pMem->z));
+  return SQLITE_OK;
+}
+
+/*
+** Make sure the given Mem is \u0000 terminated.
+*/
+int sqlite3VdbeMemNulTerminate(Mem *pMem){
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
+    return SQLITE_OK;   /* Nothing to do */
+  }
+  if( pMem->flags & (MEM_Static|MEM_Ephem) ){
+    return sqlite3VdbeMemMakeWriteable(pMem);
+  }else{
+    char *z; 
+    sqlite3VdbeMemExpandBlob(pMem);
+    z = sqlite3DbMallocRaw(pMem->db, pMem->n+2);
+    if( !z ){
+       return SQLITE_NOMEM;
+    }
+    memcpy(z, pMem->z, pMem->n);
+    z[pMem->n] = 0;
+    z[pMem->n+1] = 0;
+    if( pMem->xDel ){
+      pMem->xDel(pMem->z);
+    }else{
+      sqlite3_free(pMem->z);
+    }
+    pMem->xDel = 0;
+    pMem->z = z;
+    pMem->flags |= MEM_Term;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Add MEM_Str to the set of representations for the given Mem.  Numbers
+** are converted using sqlite3_snprintf().  Converting a BLOB to a string
+** is a no-op.
+**
+** Existing representations MEM_Int and MEM_Real are *not* invalidated.
+**
+** A MEM_Null value will never be passed to this function. This function is
+** used for converting values to text for returning to the user (i.e. via
+** sqlite3_value_text()), or for ensuring that values to be used as btree
+** keys are strings. In the former case a NULL pointer is returned the
+** user and the later is an internal programming error.
+*/
+int sqlite3VdbeMemStringify(Mem *pMem, int enc){
+  int rc = SQLITE_OK;
+  int fg = pMem->flags;
+  char *z = pMem->zShort;
+
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  assert( !(fg&MEM_Zero) );
+  assert( !(fg&(MEM_Str|MEM_Blob)) );
+  assert( fg&(MEM_Int|MEM_Real) );
+
+  /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
+  ** string representation of the value. Then, if the required encoding
+  ** is UTF-16le or UTF-16be do a translation.
+  ** 
+  ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
+  */
+  if( fg & MEM_Int ){
+    sqlite3_snprintf(NBFS, z, "%lld", pMem->u.i);
+  }else{
+    assert( fg & MEM_Real );
+    sqlite3_snprintf(NBFS, z, "%!.15g", pMem->r);
+  }
+  pMem->n = strlen(z);
+  pMem->z = z;
+  pMem->enc = SQLITE_UTF8;
+  pMem->flags |= MEM_Str | MEM_Short | MEM_Term;
+  sqlite3VdbeChangeEncoding(pMem, enc);
+  return rc;
+}
+
+/*
+** Memory cell pMem contains the context of an aggregate function.
+** This routine calls the finalize method for that function.  The
+** result of the aggregate is stored back into pMem.
+**
+** Return SQLITE_ERROR if the finalizer reports an error.  SQLITE_OK
+** otherwise.
+*/
+int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
+  int rc = SQLITE_OK;
+  if( pFunc && pFunc->xFinalize ){
+    sqlite3_context ctx;
+    assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
+    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+    ctx.s.flags = MEM_Null;
+    ctx.s.z = pMem->zShort;
+    ctx.s.db = pMem->db;
+    ctx.pMem = pMem;
+    ctx.pFunc = pFunc;
+    ctx.isError = 0;
+    pFunc->xFinalize(&ctx);
+    if( pMem->z && pMem->z!=pMem->zShort ){
+      sqlite3_free( pMem->z );
+    }
+    *pMem = ctx.s;
+    if( pMem->flags & MEM_Short ){
+      pMem->z = pMem->zShort;
+    }
+    rc = (ctx.isError?SQLITE_ERROR:SQLITE_OK);
+  }
+  return rc;
+}
+
+/*
+** Release any memory held by the Mem. This may leave the Mem in an
+** inconsistent state, for example with (Mem.z==0) and
+** (Mem.type==SQLITE_TEXT).
+*/
+void sqlite3VdbeMemRelease(Mem *p){
+  assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
+  if( p->flags & (MEM_Dyn|MEM_Agg) ){
+    if( p->xDel ){
+      if( p->flags & MEM_Agg ){
+        sqlite3VdbeMemFinalize(p, p->u.pDef);
+        assert( (p->flags & MEM_Agg)==0 );
+        sqlite3VdbeMemRelease(p);
+      }else{
+        p->xDel((void *)p->z);
+      }
+    }else{
+      sqlite3_free(p->z);
+    }
+    p->z = 0;
+    p->xDel = 0;
+  }
+}
+
+/*
+** Convert a 64-bit IEEE double into a 64-bit signed integer.
+** If the double is too large, return 0x8000000000000000.
+**
+** Most systems appear to do this simply by assigning
+** variables and without the extra range tests.  But
+** there are reports that windows throws an expection
+** if the floating point value is out of range. (See ticket #2880.)
+** Because we do not completely understand the problem, we will
+** take the conservative approach and always do range tests
+** before attempting the conversion.
+*/
+static i64 doubleToInt64(double r){
+  /*
+  ** Many compilers we encounter do not define constants for the
+  ** minimum and maximum 64-bit integers, or they define them
+  ** inconsistently.  And many do not understand the "LL" notation.
+  ** So we define our own static constants here using nothing
+  ** larger than a 32-bit integer constant.
+  */
+  static const i64 maxInt = (((i64)0x7fffffff)<<32)|0xffffffff;
+  static const i64 minInt = ((i64)0x80000000)<<32;
+
+  if( r<(double)minInt ){
+    return minInt;
+  }else if( r>(double)maxInt ){
+    return minInt;
+  }else{
+    return (i64)r;
+  }
+}
+
+/*
+** Return some kind of integer value which is the best we can do
+** at representing the value that *pMem describes as an integer.
+** If pMem is an integer, then the value is exact.  If pMem is
+** a floating-point then the value returned is the integer part.
+** If pMem is a string or blob, then we make an attempt to convert
+** it into a integer and return that.  If pMem is NULL, return 0.
+**
+** If pMem is a string, its encoding might be changed.
+*/
+i64 sqlite3VdbeIntValue(Mem *pMem){
+  int flags;
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  flags = pMem->flags;
+  if( flags & MEM_Int ){
+    return pMem->u.i;
+  }else if( flags & MEM_Real ){
+    return doubleToInt64(pMem->r);
+  }else if( flags & (MEM_Str|MEM_Blob) ){
+    i64 value;
+    pMem->flags |= MEM_Str;
+    if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
+       || sqlite3VdbeMemNulTerminate(pMem) ){
+      return 0;
+    }
+    assert( pMem->z );
+    sqlite3Atoi64(pMem->z, &value);
+    return value;
+  }else{
+    return 0;
+  }
+}
+
+/*
+** Return the best representation of pMem that we can get into a
+** double.  If pMem is already a double or an integer, return its
+** value.  If it is a string or blob, try to convert it to a double.
+** If it is a NULL, return 0.0.
+*/
+double sqlite3VdbeRealValue(Mem *pMem){
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  if( pMem->flags & MEM_Real ){
+    return pMem->r;
+  }else if( pMem->flags & MEM_Int ){
+    return (double)pMem->u.i;
+  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
+    double val = 0.0;
+    pMem->flags |= MEM_Str;
+    if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
+       || sqlite3VdbeMemNulTerminate(pMem) ){
+      return 0.0;
+    }
+    assert( pMem->z );
+    sqlite3AtoF(pMem->z, &val);
+    return val;
+  }else{
+    return 0.0;
+  }
+}
+
+/*
+** The MEM structure is already a MEM_Real.  Try to also make it a
+** MEM_Int if we can.
+*/
+void sqlite3VdbeIntegerAffinity(Mem *pMem){
+  assert( pMem->flags & MEM_Real );
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+
+  pMem->u.i = doubleToInt64(pMem->r);
+  if( pMem->r==(double)pMem->u.i ){
+    pMem->flags |= MEM_Int;
+  }
+}
+
+/*
+** Convert pMem to type integer.  Invalidate any prior representations.
+*/
+int sqlite3VdbeMemIntegerify(Mem *pMem){
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  pMem->u.i = sqlite3VdbeIntValue(pMem);
+  sqlite3VdbeMemRelease(pMem);
+  pMem->flags = MEM_Int;
+  return SQLITE_OK;
+}
+
+/*
+** Convert pMem so that it is of type MEM_Real.
+** Invalidate any prior representations.
+*/
+int sqlite3VdbeMemRealify(Mem *pMem){
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  pMem->r = sqlite3VdbeRealValue(pMem);
+  sqlite3VdbeMemRelease(pMem);
+  pMem->flags = MEM_Real;
+  return SQLITE_OK;
+}
+
+/*
+** Convert pMem so that it has types MEM_Real or MEM_Int or both.
+** Invalidate any prior representations.
+*/
+int sqlite3VdbeMemNumerify(Mem *pMem){
+  double r1, r2;
+  i64 i;
+  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 );
+  assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  r1 = sqlite3VdbeRealValue(pMem);
+  i = doubleToInt64(r1);
+  r2 = (double)i;
+  if( r1==r2 ){
+    sqlite3VdbeMemIntegerify(pMem);
+  }else{
+    pMem->r = r1;
+    pMem->flags = MEM_Real;
+    sqlite3VdbeMemRelease(pMem);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Delete any previous value and set the value stored in *pMem to NULL.
+*/
+void sqlite3VdbeMemSetNull(Mem *pMem){
+  sqlite3VdbeMemRelease(pMem);
+  pMem->flags = MEM_Null;
+  pMem->type = SQLITE_NULL;
+  pMem->n = 0;
+}
+
+/*
+** Delete any previous value and set the value to be a BLOB of length
+** n containing all zeros.
+*/
+void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
+  sqlite3VdbeMemRelease(pMem);
+  pMem->flags = MEM_Blob|MEM_Zero|MEM_Short;
+  pMem->type = SQLITE_BLOB;
+  pMem->n = 0;
+  if( n<0 ) n = 0;
+  pMem->u.i = n;
+  pMem->z = pMem->zShort;
+  pMem->enc = SQLITE_UTF8;
+}
+
+/*
+** Delete any previous value and set the value stored in *pMem to val,
+** manifest type INTEGER.
+*/
+void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
+  sqlite3VdbeMemRelease(pMem);
+  pMem->u.i = val;
+  pMem->flags = MEM_Int;
+  pMem->type = SQLITE_INTEGER;
+}
+
+/*
+** Delete any previous value and set the value stored in *pMem to val,
+** manifest type REAL.
+*/
+void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
+  if( sqlite3_isnan(val) ){
+    sqlite3VdbeMemSetNull(pMem);
+  }else{
+    sqlite3VdbeMemRelease(pMem);
+    pMem->r = val;
+    pMem->flags = MEM_Real;
+    pMem->type = SQLITE_FLOAT;
+  }
+}
+
+/*
+** Return true if the Mem object contains a TEXT or BLOB that is
+** too large - whose size exceeds SQLITE_MAX_LENGTH.
+*/
+int sqlite3VdbeMemTooBig(Mem *p){
+  if( p->flags & (MEM_Str|MEM_Blob) ){
+    int n = p->n;
+    if( p->flags & MEM_Zero ){
+      n += p->u.i;
+    }
+    return n>SQLITE_MAX_LENGTH;
+  }
+  return 0; 
+}
+
+/*
+** Make an shallow copy of pFrom into pTo.  Prior contents of
+** pTo are freed.  The pFrom->z field is not duplicated.  If
+** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
+** and flags gets srcType (either MEM_Ephem or MEM_Static).
+*/
+void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
+  sqlite3VdbeMemRelease(pTo);
+  memcpy(pTo, pFrom, sizeof(*pFrom)-sizeof(pFrom->zShort));
+  pTo->xDel = 0;
+  if( pTo->flags & (MEM_Str|MEM_Blob) ){
+    pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short|MEM_Ephem);
+    assert( srcType==MEM_Ephem || srcType==MEM_Static );
+    pTo->flags |= srcType;
+  }
+}
+
+/*
+** Make a full copy of pFrom into pTo.  Prior contents of pTo are
+** freed before the copy is made.
+*/
+int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
+  int rc;
+  sqlite3VdbeMemShallowCopy(pTo, pFrom, MEM_Ephem);
+  if( pTo->flags & MEM_Ephem ){
+    rc = sqlite3VdbeMemMakeWriteable(pTo);
+  }else{
+    rc = SQLITE_OK;
+  }
+  return rc;
+}
+
+/*
+** Transfer the contents of pFrom to pTo. Any existing value in pTo is
+** freed. If pFrom contains ephemeral data, a copy is made.
+**
+** pFrom contains an SQL NULL when this routine returns.
+*/
+void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
+  assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
+  assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
+  assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
+  if( pTo->flags & MEM_Dyn ){
+    sqlite3VdbeMemRelease(pTo);
+  }
+  memcpy(pTo, pFrom, sizeof(Mem));
+  if( pFrom->flags & MEM_Short ){
+    pTo->z = pTo->zShort;
+  }
+  pFrom->flags = MEM_Null;
+  pFrom->xDel = 0;
+}
+
+/*
+** Change the value of a Mem to be a string or a BLOB.
+*/
+int sqlite3VdbeMemSetStr(
+  Mem *pMem,          /* Memory cell to set to string value */
+  const char *z,      /* String pointer */
+  int n,              /* Bytes in string, or negative */
+  u8 enc,             /* Encoding of z.  0 for BLOBs */
+  void (*xDel)(void*) /* Destructor function */
+){
+  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+  sqlite3VdbeMemRelease(pMem);
+  if( !z ){
+    pMem->flags = MEM_Null;
+    pMem->type = SQLITE_NULL;
+    return SQLITE_OK;
+  }
+  pMem->z = (char *)z;
+  if( xDel==SQLITE_STATIC ){
+    pMem->flags = MEM_Static;
+  }else if( xDel==SQLITE_TRANSIENT ){
+    pMem->flags = MEM_Ephem;
+  }else{
+    pMem->flags = MEM_Dyn;
+    pMem->xDel = xDel;
+  }
+
+  pMem->enc = enc;
+  pMem->type = enc==0 ? SQLITE_BLOB : SQLITE_TEXT;
+  pMem->n = n;
+
+  assert( enc==0 || enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE 
+      || enc==SQLITE_UTF16BE );
+  switch( enc ){
+    case 0:
+      pMem->flags |= MEM_Blob;
+      pMem->enc = SQLITE_UTF8;
+      break;
+
+    case SQLITE_UTF8:
+      pMem->flags |= MEM_Str;
+      if( n<0 ){
+        pMem->n = strlen(z);
+        pMem->flags |= MEM_Term;
+      }
+      break;
+
+#ifndef SQLITE_OMIT_UTF16
+    case SQLITE_UTF16LE:
+    case SQLITE_UTF16BE:
+      pMem->flags |= MEM_Str;
+      if( pMem->n<0 ){
+        pMem->n = sqlite3Utf16ByteLen(pMem->z,-1);
+        pMem->flags |= MEM_Term;
+      }
+      if( sqlite3VdbeMemHandleBom(pMem) ){
+        return SQLITE_NOMEM;
+      }
+#endif /* SQLITE_OMIT_UTF16 */
+  }
+  if( pMem->flags&MEM_Ephem ){
+    return sqlite3VdbeMemMakeWriteable(pMem);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Compare the values contained by the two memory cells, returning
+** negative, zero or positive if pMem1 is less than, equal to, or greater
+** than pMem2. Sorting order is NULL's first, followed by numbers (integers
+** and reals) sorted numerically, followed by text ordered by the collating
+** sequence pColl and finally blob's ordered by memcmp().
+**
+** Two NULL values are considered equal by this function.
+*/
+int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
+  int rc;
+  int f1, f2;
+  int combined_flags;
+
+  /* Interchange pMem1 and pMem2 if the collating sequence specifies
+  ** DESC order.
+  */
+  f1 = pMem1->flags;
+  f2 = pMem2->flags;
+  combined_flags = f1|f2;
+ 
+  /* If one value is NULL, it is less than the other. If both values
+  ** are NULL, return 0.
+  */
+  if( combined_flags&MEM_Null ){
+    return (f2&MEM_Null) - (f1&MEM_Null);
+  }
+
+  /* If one value is a number and the other is not, the number is less.
+  ** If both are numbers, compare as reals if one is a real, or as integers
+  ** if both values are integers.
+  */
+  if( combined_flags&(MEM_Int|MEM_Real) ){
+    if( !(f1&(MEM_Int|MEM_Real)) ){
+      return 1;
+    }
+    if( !(f2&(MEM_Int|MEM_Real)) ){
+      return -1;
+    }
+    if( (f1 & f2 & MEM_Int)==0 ){
+      double r1, r2;
+      if( (f1&MEM_Real)==0 ){
+        r1 = pMem1->u.i;
+      }else{
+        r1 = pMem1->r;
+      }
+      if( (f2&MEM_Real)==0 ){
+        r2 = pMem2->u.i;
+      }else{
+        r2 = pMem2->r;
+      }
+      if( r1<r2 ) return -1;
+      if( r1>r2 ) return 1;
+      return 0;
+    }else{
+      assert( f1&MEM_Int );
+      assert( f2&MEM_Int );
+      if( pMem1->u.i < pMem2->u.i ) return -1;
+      if( pMem1->u.i > pMem2->u.i ) return 1;
+      return 0;
+    }
+  }
+
+  /* If one value is a string and the other is a blob, the string is less.
+  ** If both are strings, compare using the collating functions.
+  */
+  if( combined_flags&MEM_Str ){
+    if( (f1 & MEM_Str)==0 ){
+      return 1;
+    }
+    if( (f2 & MEM_Str)==0 ){
+      return -1;
+    }
+
+    assert( pMem1->enc==pMem2->enc );
+    assert( pMem1->enc==SQLITE_UTF8 || 
+            pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
+
+    /* The collation sequence must be defined at this point, even if
+    ** the user deletes the collation sequence after the vdbe program is
+    ** compiled (this was not always the case).
+    */
+    assert( !pColl || pColl->xCmp );
+
+    if( pColl ){
+      if( pMem1->enc==pColl->enc ){
+        /* The strings are already in the correct encoding.  Call the
+        ** comparison function directly */
+        return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
+      }else{
+        u8 origEnc = pMem1->enc;
+        const void *v1, *v2;
+        int n1, n2;
+        /* Convert the strings into the encoding that the comparison
+        ** function expects */
+        v1 = sqlite3ValueText((sqlite3_value*)pMem1, pColl->enc);
+        n1 = v1==0 ? 0 : pMem1->n;
+        assert( n1==sqlite3ValueBytes((sqlite3_value*)pMem1, pColl->enc) );
+        v2 = sqlite3ValueText((sqlite3_value*)pMem2, pColl->enc);
+        n2 = v2==0 ? 0 : pMem2->n;
+        assert( n2==sqlite3ValueBytes((sqlite3_value*)pMem2, pColl->enc) );
+        /* Do the comparison */
+        rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
+        /* Convert the strings back into the database encoding */
+        sqlite3ValueText((sqlite3_value*)pMem1, origEnc);
+        sqlite3ValueText((sqlite3_value*)pMem2, origEnc);
+        return rc;
+      }
+    }
+    /* If a NULL pointer was passed as the collate function, fall through
+    ** to the blob case and use memcmp().  */
+  }
+ 
+  /* Both values must be blobs.  Compare using memcmp().  */
+  rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
+  if( rc==0 ){
+    rc = pMem1->n - pMem2->n;
+  }
+  return rc;
+}
+
+/*
+** Move data out of a btree key or data field and into a Mem structure.
+** The data or key is taken from the entry that pCur is currently pointing
+** to.  offset and amt determine what portion of the data or key to retrieve.
+** key is true to get the key or false to get data.  The result is written
+** into the pMem element.
+**
+** The pMem structure is assumed to be uninitialized.  Any prior content
+** is overwritten without being freed.
+**
+** If this routine fails for any reason (malloc returns NULL or unable
+** to read from the disk) then the pMem is left in an inconsistent state.
+*/
+int sqlite3VdbeMemFromBtree(
+  BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
+  int offset,       /* Offset from the start of data to return bytes from. */
+  int amt,          /* Number of bytes to return. */
+  int key,          /* If true, retrieve from the btree key, not data. */
+  Mem *pMem         /* OUT: Return data in this Mem structure. */
+){
+  char *zData;       /* Data from the btree layer */
+  int available = 0; /* Number of bytes available on the local btree page */
+  sqlite3 *db;       /* Database connection */
+
+  db = sqlite3BtreeCursorDb(pCur);
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( key ){
+    zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
+  }else{
+    zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
+  }
+  assert( zData!=0 );
+
+  pMem->db = db;
+  pMem->n = amt;
+  if( offset+amt<=available ){
+    pMem->z = &zData[offset];
+    pMem->flags = MEM_Blob|MEM_Ephem;
+  }else{
+    int rc;
+    if( amt>NBFS-2 ){
+      zData = (char *)sqlite3DbMallocRaw(db, amt+2);
+      if( !zData ){
+        return SQLITE_NOMEM;
+      }
+      pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
+      pMem->xDel = 0;
+    }else{
+      zData = &(pMem->zShort[0]);
+      pMem->flags = MEM_Blob|MEM_Short|MEM_Term;
+    }
+    pMem->z = zData;
+    pMem->enc = 0;
+    pMem->type = SQLITE_BLOB;
+
+    if( key ){
+      rc = sqlite3BtreeKey(pCur, offset, amt, zData);
+    }else{
+      rc = sqlite3BtreeData(pCur, offset, amt, zData);
+    }
+    zData[amt] = 0;
+    zData[amt+1] = 0;
+    if( rc!=SQLITE_OK ){
+      if( amt>NBFS-2 ){
+        assert( zData!=pMem->zShort );
+        assert( pMem->flags & MEM_Dyn );
+        sqlite3_free(zData);
+      } else {
+        assert( zData==pMem->zShort );
+        assert( pMem->flags & MEM_Short );
+      }
+      return rc;
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+#if 0
+/*
+** Perform various checks on the memory cell pMem. An assert() will
+** fail if pMem is internally inconsistent.
+*/
+void sqlite3VdbeMemSanity(Mem *pMem){
+  int flags = pMem->flags;
+  assert( flags!=0 );  /* Must define some type */
+  if( flags & (MEM_Str|MEM_Blob) ){
+    int x = flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
+    assert( x!=0 );            /* Strings must define a string subtype */
+    assert( (x & (x-1))==0 );  /* Only one string subtype can be defined */
+    assert( pMem->z!=0 );      /* Strings must have a value */
+    /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
+    assert( (x & MEM_Short)==0 || pMem->z==pMem->zShort );
+    assert( (x & MEM_Short)!=0 || pMem->z!=pMem->zShort );
+    /* No destructor unless there is MEM_Dyn */
+    assert( pMem->xDel==0 || (pMem->flags & MEM_Dyn)!=0 );
+
+    if( (flags & MEM_Str) ){
+      assert( pMem->enc==SQLITE_UTF8 || 
+              pMem->enc==SQLITE_UTF16BE ||
+              pMem->enc==SQLITE_UTF16LE 
+      );
+      /* If the string is UTF-8 encoded and nul terminated, then pMem->n
+      ** must be the length of the string.  (Later:)  If the database file
+      ** has been corrupted, '\000' characters might have been inserted
+      ** into the middle of the string.  In that case, the strlen() might
+      ** be less.
+      */
+      if( pMem->enc==SQLITE_UTF8 && (flags & MEM_Term) ){ 
+        assert( strlen(pMem->z)<=pMem->n );
+        assert( pMem->z[pMem->n]==0 );
+      }
+    }
+  }else{
+    /* Cannot define a string subtype for non-string objects */
+    assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
+    assert( pMem->xDel==0 );
+  }
+  /* MEM_Null excludes all other types */
+  assert( (pMem->flags&(MEM_Str|MEM_Int|MEM_Real|MEM_Blob))==0
+          || (pMem->flags&MEM_Null)==0 );
+  /* If the MEM is both real and integer, the values are equal */
+  assert( (pMem->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) 
+          || pMem->r==pMem->u.i );
+}
+#endif
+
+/* This function is only available internally, it is not part of the
+** external API. It works in a similar way to sqlite3_value_text(),
+** except the data returned is in the encoding specified by the second
+** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
+** SQLITE_UTF8.
+**
+** (2006-02-16:)  The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
+** If that is the case, then the result must be aligned on an even byte
+** boundary.
+*/
+const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
+  if( !pVal ) return 0;
+
+  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
+  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
+
+  if( pVal->flags&MEM_Null ){
+    return 0;
+  }
+  assert( (MEM_Blob>>3) == MEM_Str );
+  pVal->flags |= (pVal->flags & MEM_Blob)>>3;
+  expandBlob(pVal);
+  if( pVal->flags&MEM_Str ){
+    sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
+    if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&(int)pVal->z) ){
+      assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
+      if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
+        return 0;
+      }
+    }
+    sqlite3VdbeMemNulTerminate(pVal);
+  }else{
+    assert( (pVal->flags&MEM_Blob)==0 );
+    sqlite3VdbeMemStringify(pVal, enc);
+    assert( 0==(1&(int)pVal->z) );
+  }
+  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
+              || pVal->db->mallocFailed );
+  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
+    return pVal->z;
+  }else{
+    return 0;
+  }
+}
+
+/*
+** Create a new sqlite3_value object.
+*/
+sqlite3_value *sqlite3ValueNew(sqlite3 *db){
+  Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
+  if( p ){
+    p->flags = MEM_Null;
+    p->type = SQLITE_NULL;
+    p->db = db;
+  }
+  return p;
+}
+
+/*
+** Create a new sqlite3_value object, containing the value of pExpr.
+**
+** This only works for very simple expressions that consist of one constant
+** token (i.e. "5", "5.1", "'a string'"). If the expression can
+** be converted directly into a value, then the value is allocated and
+** a pointer written to *ppVal. The caller is responsible for deallocating
+** the value by passing it to sqlite3ValueFree() later on. If the expression
+** cannot be converted to a value, then *ppVal is set to NULL.
+*/
+int sqlite3ValueFromExpr(
+  sqlite3 *db,              /* The database connection */
+  Expr *pExpr,              /* The expression to evaluate */
+  u8 enc,                   /* Encoding to use */
+  u8 affinity,              /* Affinity to use */
+  sqlite3_value **ppVal     /* Write the new value here */
+){
+  int op;
+  char *zVal = 0;
+  sqlite3_value *pVal = 0;
+
+  if( !pExpr ){
+    *ppVal = 0;
+    return SQLITE_OK;
+  }
+  op = pExpr->op;
+
+  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
+    zVal = sqlite3StrNDup((char*)pExpr->token.z, pExpr->token.n);
+    pVal = sqlite3ValueNew(db);
+    if( !zVal || !pVal ) goto no_mem;
+    sqlite3Dequote(zVal);
+    sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, sqlite3_free);
+    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
+      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);
+    }else{
+      sqlite3ValueApplyAffinity(pVal, affinity, enc);
+    }
+  }else if( op==TK_UMINUS ) {
+    if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
+      pVal->u.i = -1 * pVal->u.i;
+      pVal->r = -1.0 * pVal->r;
+    }
+  }
+#ifndef SQLITE_OMIT_BLOB_LITERAL
+  else if( op==TK_BLOB ){
+    int nVal;
+    assert( pExpr->token.n>=3 );
+    assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
+    assert( pExpr->token.z[1]=='\'' );
+    assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
+    pVal = sqlite3ValueNew(db);
+    nVal = pExpr->token.n - 3;
+    zVal = (char*)pExpr->token.z + 2;
+    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
+                         0, sqlite3_free);
+  }
+#endif
+
+  *ppVal = pVal;
+  return SQLITE_OK;
+
+no_mem:
+  db->mallocFailed = 1;
+  sqlite3_free(zVal);
+  sqlite3ValueFree(pVal);
+  *ppVal = 0;
+  return SQLITE_NOMEM;
+}
+
+/*
+** Change the string value of an sqlite3_value object
+*/
+void sqlite3ValueSetStr(
+  sqlite3_value *v,     /* Value to be set */
+  int n,                /* Length of string z */
+  const void *z,        /* Text of the new string */
+  u8 enc,               /* Encoding to use */
+  void (*xDel)(void*)   /* Destructor for the string */
+){
+  if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
+}
+
+/*
+** Free an sqlite3_value object
+*/
+void sqlite3ValueFree(sqlite3_value *v){
+  if( !v ) return;
+  sqlite3ValueSetStr(v, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
+  sqlite3_free(v);
+}
+
+/*
+** Return the number of bytes in the sqlite3_value object assuming
+** that it uses the encoding "enc"
+*/
+int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
+  Mem *p = (Mem*)pVal;
+  if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
+    if( p->flags & MEM_Zero ){
+      return p->n+p->u.i;
+    }else{
+      return p->n;
+    }
+  }
+  return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/vtab.c b/client/src/thirdparty/sqlite-3.4.2/src/vtab.c
new file mode 100644
index 0000000..776f36e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/vtab.c
@@ -0,0 +1,798 @@
+/*
+** 2006 June 10
+**
+** 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 help implement virtual tables.
+**
+** $Id: vtab.c,v 1.63 2008/01/23 03:03:05 drh Exp $
+*/
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+#include "sqliteInt.h"
+
+static int createModule(
+  sqlite3 *db,                    /* Database in which module is registered */
+  const char *zName,              /* Name assigned to this module */
+  const sqlite3_module *pModule,  /* The definition of the module */
+  void *pAux,                     /* Context pointer for xCreate/xConnect */
+  void (*xDestroy)(void *)        /* Module destructor function */
+) {
+  int rc, nName;
+  Module *pMod;
+
+  sqlite3_mutex_enter(db->mutex);
+  nName = strlen(zName);
+  pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
+  if( pMod ){
+    char *zCopy = (char *)(&pMod[1]);
+    memcpy(zCopy, zName, nName+1);
+    pMod->zName = zCopy;
+    pMod->pModule = pModule;
+    pMod->pAux = pAux;
+    pMod->xDestroy = xDestroy;
+    pMod = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
+    if( pMod && pMod->xDestroy ){
+      pMod->xDestroy(pMod->pAux);
+    }
+    sqlite3_free(pMod);
+    sqlite3ResetInternalSchema(db, 0);
+  }
+  rc = sqlite3ApiExit(db, SQLITE_OK);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+
+/*
+** External API function used to create a new virtual-table module.
+*/
+int sqlite3_create_module(
+  sqlite3 *db,                    /* Database in which module is registered */
+  const char *zName,              /* Name assigned to this module */
+  const sqlite3_module *pModule,  /* The definition of the module */
+  void *pAux                      /* Context pointer for xCreate/xConnect */
+){
+  return createModule(db, zName, pModule, pAux, 0);
+}
+
+/*
+** External API function used to create a new virtual-table module.
+*/
+int sqlite3_create_module_v2(
+  sqlite3 *db,                    /* Database in which module is registered */
+  const char *zName,              /* Name assigned to this module */
+  const sqlite3_module *pModule,  /* The definition of the module */
+  void *pAux,                     /* Context pointer for xCreate/xConnect */
+  void (*xDestroy)(void *)        /* Module destructor function */
+){
+  return createModule(db, zName, pModule, pAux, xDestroy);
+}
+
+/*
+** Lock the virtual table so that it cannot be disconnected.
+** Locks nest.  Every lock should have a corresponding unlock.
+** If an unlock is omitted, resources leaks will occur.  
+**
+** If a disconnect is attempted while a virtual table is locked,
+** the disconnect is deferred until all locks have been removed.
+*/
+void sqlite3VtabLock(sqlite3_vtab *pVtab){
+  pVtab->nRef++;
+}
+
+/*
+** Unlock a virtual table.  When the last lock is removed,
+** disconnect the virtual table.
+*/
+void sqlite3VtabUnlock(sqlite3 *db, sqlite3_vtab *pVtab){
+  pVtab->nRef--;
+  assert(db);
+  assert( sqlite3SafetyCheckOk(db) );
+  if( pVtab->nRef==0 ){
+    if( db->magic==SQLITE_MAGIC_BUSY ){
+      (void)sqlite3SafetyOff(db);
+      pVtab->pModule->xDisconnect(pVtab);
+      (void)sqlite3SafetyOn(db);
+    } else {
+      pVtab->pModule->xDisconnect(pVtab);
+    }
+  }
+}
+
+/*
+** Clear any and all virtual-table information from the Table record.
+** This routine is called, for example, just before deleting the Table
+** record.
+*/
+void sqlite3VtabClear(Table *p){
+  sqlite3_vtab *pVtab = p->pVtab;
+  if( pVtab ){
+    assert( p->pMod && p->pMod->pModule );
+    sqlite3VtabUnlock(p->pSchema->db, pVtab);
+    p->pVtab = 0;
+  }
+  if( p->azModuleArg ){
+    int i;
+    for(i=0; i<p->nModuleArg; i++){
+      sqlite3_free(p->azModuleArg[i]);
+    }
+    sqlite3_free(p->azModuleArg);
+  }
+}
+
+/*
+** Add a new module argument to pTable->azModuleArg[].
+** The string is not copied - the pointer is stored.  The
+** string will be freed automatically when the table is
+** deleted.
+*/
+static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
+  int i = pTable->nModuleArg++;
+  int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
+  char **azModuleArg;
+  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
+  if( azModuleArg==0 ){
+    int j;
+    for(j=0; j<i; j++){
+      sqlite3_free(pTable->azModuleArg[j]);
+    }
+    sqlite3_free(zArg);
+    sqlite3_free(pTable->azModuleArg);
+    pTable->nModuleArg = 0;
+  }else{
+    azModuleArg[i] = zArg;
+    azModuleArg[i+1] = 0;
+  }
+  pTable->azModuleArg = azModuleArg;
+}
+
+/*
+** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
+** statement.  The module name has been parsed, but the optional list
+** of parameters that follow the module name are still pending.
+*/
+void sqlite3VtabBeginParse(
+  Parse *pParse,        /* Parsing context */
+  Token *pName1,        /* Name of new table, or database name */
+  Token *pName2,        /* Name of new table or NULL */
+  Token *pModuleName    /* Name of the module for the virtual table */
+){
+  int iDb;              /* The database the table is being created in */
+  Table *pTable;        /* The new virtual table */
+  sqlite3 *db;          /* Database connection */
+
+  if( pParse->db->flags & SQLITE_SharedCache ){
+    sqlite3ErrorMsg(pParse, "Cannot use virtual tables in shared-cache mode");
+    return;
+  }
+
+  sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);
+  pTable = pParse->pNewTable;
+  if( pTable==0 || pParse->nErr ) return;
+  assert( 0==pTable->pIndex );
+
+  db = pParse->db;
+  iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
+  assert( iDb>=0 );
+
+  pTable->isVirtual = 1;
+  pTable->nModuleArg = 0;
+  addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
+  addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
+  addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
+  pParse->sNameToken.n = pModuleName->z + pModuleName->n - pName1->z;
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  /* Creating a virtual table invokes the authorization callback twice.
+  ** The first invocation, to obtain permission to INSERT a row into the
+  ** sqlite_master table, has already been made by sqlite3StartTable().
+  ** The second call, to obtain permission to create the table, is made now.
+  */
+  if( pTable->azModuleArg ){
+    sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, 
+            pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
+  }
+#endif
+}
+
+/*
+** This routine takes the module argument that has been accumulating
+** in pParse->zArg[] and appends it to the list of arguments on the
+** virtual table currently under construction in pParse->pTable.
+*/
+static void addArgumentToVtab(Parse *pParse){
+  if( pParse->sArg.z && pParse->pNewTable ){
+    const char *z = (const char*)pParse->sArg.z;
+    int n = pParse->sArg.n;
+    sqlite3 *db = pParse->db;
+    addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
+  }
+}
+
+/*
+** The parser calls this routine after the CREATE VIRTUAL TABLE statement
+** has been completely parsed.
+*/
+void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
+  Table *pTab;        /* The table being constructed */
+  sqlite3 *db;        /* The database connection */
+  char *zModule;      /* The module name of the table: USING modulename */
+  Module *pMod = 0;
+
+  addArgumentToVtab(pParse);
+  pParse->sArg.z = 0;
+
+  /* Lookup the module name. */
+  pTab = pParse->pNewTable;
+  if( pTab==0 ) return;
+  db = pParse->db;
+  if( pTab->nModuleArg<1 ) return;
+  zModule = pTab->azModuleArg[0];
+  pMod = (Module *)sqlite3HashFind(&db->aModule, zModule, strlen(zModule));
+  pTab->pMod = pMod;
+  
+  /* If the CREATE VIRTUAL TABLE statement is being entered for the
+  ** first time (in other words if the virtual table is actually being
+  ** created now instead of just being read out of sqlite_master) then
+  ** do additional initialization work and store the statement text
+  ** in the sqlite_master table.
+  */
+  if( !db->init.busy ){
+    char *zStmt;
+    char *zWhere;
+    int iDb;
+    Vdbe *v;
+
+    /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
+    if( pEnd ){
+      pParse->sNameToken.n = pEnd->z - pParse->sNameToken.z + pEnd->n;
+    }
+    zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
+
+    /* A slot for the record has already been allocated in the 
+    ** SQLITE_MASTER table.  We just need to update that slot with all
+    ** the information we've collected.  
+    **
+    ** The VM register number pParse->regRowid holds the rowid of an
+    ** entry in the sqlite_master table tht was created for this vtab
+    ** by sqlite3StartTable().
+    */
+    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+    sqlite3NestedParse(pParse,
+      "UPDATE %Q.%s "
+         "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
+       "WHERE rowid=#%d",
+      db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
+      pTab->zName,
+      pTab->zName,
+      zStmt,
+      pParse->regRowid
+    );
+    sqlite3_free(zStmt);
+    v = sqlite3GetVdbe(pParse);
+    sqlite3ChangeCookie(pParse, iDb);
+
+    sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
+    zWhere = sqlite3MPrintf(db, "name='%q'", pTab->zName);
+    sqlite3VdbeAddOp4(v, OP_ParseSchema, iDb, 1, 0, zWhere, P4_DYNAMIC);
+    sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0, 
+                         pTab->zName, strlen(pTab->zName) + 1);
+  }
+
+  /* If we are rereading the sqlite_master table create the in-memory
+  ** record of the table. If the module has already been registered,
+  ** also call the xConnect method here.
+  */
+  else {
+    Table *pOld;
+    Schema *pSchema = pTab->pSchema;
+    const char *zName = pTab->zName;
+    int nName = strlen(zName) + 1;
+    pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
+    if( pOld ){
+      db->mallocFailed = 1;
+      assert( pTab==pOld );  /* Malloc must have failed inside HashInsert() */
+      return;
+    }
+    pSchema->db = pParse->db;
+    pParse->pNewTable = 0;
+  }
+}
+
+/*
+** The parser calls this routine when it sees the first token
+** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
+*/
+void sqlite3VtabArgInit(Parse *pParse){
+  addArgumentToVtab(pParse);
+  pParse->sArg.z = 0;
+  pParse->sArg.n = 0;
+}
+
+/*
+** The parser calls this routine for each token after the first token
+** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
+*/
+void sqlite3VtabArgExtend(Parse *pParse, Token *p){
+  Token *pArg = &pParse->sArg;
+  if( pArg->z==0 ){
+    pArg->z = p->z;
+    pArg->n = p->n;
+  }else{
+    assert(pArg->z < p->z);
+    pArg->n = (p->z + p->n - pArg->z);
+  }
+}
+
+/*
+** Invoke a virtual table constructor (either xCreate or xConnect). The
+** pointer to the function to invoke is passed as the fourth parameter
+** to this procedure.
+*/
+static int vtabCallConstructor(
+  sqlite3 *db, 
+  Table *pTab,
+  Module *pMod,
+  int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
+  char **pzErr
+){
+  int rc;
+  int rc2;
+  sqlite3_vtab *pVtab = 0;
+  const char *const*azArg = (const char *const*)pTab->azModuleArg;
+  int nArg = pTab->nModuleArg;
+  char *zErr = 0;
+  char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
+
+  if( !zModuleName ){
+    return SQLITE_NOMEM;
+  }
+
+  assert( !db->pVTab );
+  assert( xConstruct );
+
+  db->pVTab = pTab;
+  rc = sqlite3SafetyOff(db);
+  assert( rc==SQLITE_OK );
+  rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVtab, &zErr);
+  rc2 = sqlite3SafetyOn(db);
+  if( rc==SQLITE_OK && pVtab ){
+    pVtab->pModule = pMod->pModule;
+    pVtab->nRef = 1;
+    pTab->pVtab = pVtab;
+  }
+
+  if( SQLITE_OK!=rc ){
+    if( zErr==0 ){
+      *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
+    }else {
+      *pzErr = sqlite3MPrintf(db, "%s", zErr);
+      sqlite3_free(zErr);
+    }
+  }else if( db->pVTab ){
+    const char *zFormat = "vtable constructor did not declare schema: %s";
+    *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
+    rc = SQLITE_ERROR;
+  } 
+  if( rc==SQLITE_OK ){
+    rc = rc2;
+  }
+  db->pVTab = 0;
+  sqlite3_free(zModuleName);
+
+  /* If everything went according to plan, loop through the columns
+  ** of the table to see if any of them contain the token "hidden".
+  ** If so, set the Column.isHidden flag and remove the token from
+  ** the type string.
+  */
+  if( rc==SQLITE_OK ){
+    int iCol;
+    for(iCol=0; iCol<pTab->nCol; iCol++){
+      char *zType = pTab->aCol[iCol].zType;
+      int nType;
+      int i = 0;
+      if( !zType ) continue;
+      nType = strlen(zType);
+      if( sqlite3StrNICmp("hidden", zType, 6) || (zType[6] && zType[6]!=' ') ){
+        for(i=0; i<nType; i++){
+          if( (0==sqlite3StrNICmp(" hidden", &zType[i], 7))
+           && (zType[i+7]=='\0' || zType[i+7]==' ')
+          ){
+            i++;
+            break;
+          }
+        }
+      }
+      if( i<nType ){
+        int j;
+        int nDel = 6 + (zType[i+6] ? 1 : 0);
+        for(j=i; (j+nDel)<=nType; j++){
+          zType[j] = zType[j+nDel];
+        }
+        if( zType[i]=='\0' && i>0 ){
+          assert(zType[i-1]==' ');
+          zType[i-1] = '\0';
+        }
+        pTab->aCol[iCol].isHidden = 1;
+      }
+    }
+  }
+  return rc;
+}
+
+/*
+** This function is invoked by the parser to call the xConnect() method
+** of the virtual table pTab. If an error occurs, an error code is returned 
+** and an error left in pParse.
+**
+** This call is a no-op if table pTab is not a virtual table.
+*/
+int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
+  Module *pMod;
+  int rc = SQLITE_OK;
+
+  if( !pTab || !pTab->isVirtual || pTab->pVtab ){
+    return SQLITE_OK;
+  }
+
+  pMod = pTab->pMod;
+  if( !pMod ){
+    const char *zModule = pTab->azModuleArg[0];
+    sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
+    rc = SQLITE_ERROR;
+  } else {
+    char *zErr = 0;
+    sqlite3 *db = pParse->db;
+    rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
+    if( rc!=SQLITE_OK ){
+      sqlite3ErrorMsg(pParse, "%s", zErr);
+    }
+    sqlite3_free(zErr);
+  }
+
+  return rc;
+}
+
+/*
+** Add the virtual table pVtab to the array sqlite3.aVTrans[].
+*/
+static int addToVTrans(sqlite3 *db, sqlite3_vtab *pVtab){
+  const int ARRAY_INCR = 5;
+
+  /* Grow the sqlite3.aVTrans array if required */
+  if( (db->nVTrans%ARRAY_INCR)==0 ){
+    sqlite3_vtab **aVTrans;
+    int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
+    aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
+    if( !aVTrans ){
+      return SQLITE_NOMEM;
+    }
+    memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
+    db->aVTrans = aVTrans;
+  }
+
+  /* Add pVtab to the end of sqlite3.aVTrans */
+  db->aVTrans[db->nVTrans++] = pVtab;
+  sqlite3VtabLock(pVtab);
+  return SQLITE_OK;
+}
+
+/*
+** This function is invoked by the vdbe to call the xCreate method
+** of the virtual table named zTab in database iDb. 
+**
+** If an error occurs, *pzErr is set to point an an English language
+** description of the error and an SQLITE_XXX error code is returned.
+** In this case the caller must call sqlite3_free() on *pzErr.
+*/
+int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
+  int rc = SQLITE_OK;
+  Table *pTab;
+  Module *pMod;
+  const char *zModule;
+
+  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
+  assert(pTab && pTab->isVirtual && !pTab->pVtab);
+  pMod = pTab->pMod;
+  zModule = pTab->azModuleArg[0];
+
+  /* If the module has been registered and includes a Create method, 
+  ** invoke it now. If the module has not been registered, return an 
+  ** error. Otherwise, do nothing.
+  */
+  if( !pMod ){
+    *pzErr = sqlite3MPrintf(db, "no such module: %s", zModule);
+    rc = SQLITE_ERROR;
+  }else{
+    rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
+  }
+
+  if( rc==SQLITE_OK && pTab->pVtab ){
+      rc = addToVTrans(db, pTab->pVtab);
+  }
+
+  return rc;
+}
+
+/*
+** This function is used to set the schema of a virtual table.  It is only
+** valid to call this function from within the xCreate() or xConnect() of a
+** virtual table module.
+*/
+int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
+  Parse sParse;
+
+  int rc = SQLITE_OK;
+  Table *pTab;
+  char *zErr = 0;
+
+  sqlite3_mutex_enter(db->mutex);
+  pTab = db->pVTab;
+  if( !pTab ){
+    sqlite3Error(db, SQLITE_MISUSE, 0);
+    sqlite3_mutex_leave(db->mutex);
+    return SQLITE_MISUSE;
+  }
+  assert(pTab->isVirtual && pTab->nCol==0 && pTab->aCol==0);
+
+  memset(&sParse, 0, sizeof(Parse));
+  sParse.declareVtab = 1;
+  sParse.db = db;
+
+  if( 
+      SQLITE_OK == sqlite3RunParser(&sParse, zCreateTable, &zErr) && 
+      sParse.pNewTable && 
+      !sParse.pNewTable->pSelect && 
+      !sParse.pNewTable->isVirtual 
+  ){
+    pTab->aCol = sParse.pNewTable->aCol;
+    pTab->nCol = sParse.pNewTable->nCol;
+    sParse.pNewTable->nCol = 0;
+    sParse.pNewTable->aCol = 0;
+    db->pVTab = 0;
+  } else {
+    sqlite3Error(db, SQLITE_ERROR, zErr);
+    sqlite3_free(zErr);
+    rc = SQLITE_ERROR;
+  }
+  sParse.declareVtab = 0;
+
+  sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
+  sqlite3DeleteTable(sParse.pNewTable);
+  sParse.pNewTable = 0;
+
+  assert( (rc&0xff)==rc );
+  rc = sqlite3ApiExit(db, rc);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** This function is invoked by the vdbe to call the xDestroy method
+** of the virtual table named zTab in database iDb. This occurs
+** when a DROP TABLE is mentioned.
+**
+** This call is a no-op if zTab is not a virtual table.
+*/
+int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab)
+{
+  int rc = SQLITE_OK;
+  Table *pTab;
+
+  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
+  assert(pTab);
+  if( pTab->pVtab ){
+    int (*xDestroy)(sqlite3_vtab *pVTab) = pTab->pMod->pModule->xDestroy;
+    rc = sqlite3SafetyOff(db);
+    assert( rc==SQLITE_OK );
+    if( xDestroy ){
+      rc = xDestroy(pTab->pVtab);
+    }
+    (void)sqlite3SafetyOn(db);
+    if( rc==SQLITE_OK ){
+      pTab->pVtab = 0;
+    }
+  }
+
+  return rc;
+}
+
+/*
+** This function invokes either the xRollback or xCommit method
+** of each of the virtual tables in the sqlite3.aVTrans array. The method
+** called is identified by the second argument, "offset", which is
+** the offset of the method to call in the sqlite3_module structure.
+**
+** The array is cleared after invoking the callbacks. 
+*/
+static void callFinaliser(sqlite3 *db, int offset){
+  int i;
+  if( db->aVTrans ){
+    for(i=0; i<db->nVTrans && db->aVTrans[i]; i++){
+      sqlite3_vtab *pVtab = db->aVTrans[i];
+      int (*x)(sqlite3_vtab *);
+      x = *(int (**)(sqlite3_vtab *))((char *)pVtab->pModule + offset);
+      if( x ) x(pVtab);
+      sqlite3VtabUnlock(db, pVtab);
+    }
+    sqlite3_free(db->aVTrans);
+    db->nVTrans = 0;
+    db->aVTrans = 0;
+  }
+}
+
+/*
+** If argument rc2 is not SQLITE_OK, then return it and do nothing. 
+** Otherwise, invoke the xSync method of all virtual tables in the 
+** sqlite3.aVTrans array. Return the error code for the first error 
+** that occurs, or SQLITE_OK if all xSync operations are successful.
+*/
+int sqlite3VtabSync(sqlite3 *db, int rc2){
+  int i;
+  int rc = SQLITE_OK;
+  int rcsafety;
+  sqlite3_vtab **aVTrans = db->aVTrans;
+  if( rc2!=SQLITE_OK ) return rc2;
+
+  rc = sqlite3SafetyOff(db);
+  db->aVTrans = 0;
+  for(i=0; rc==SQLITE_OK && i<db->nVTrans && aVTrans[i]; i++){
+    sqlite3_vtab *pVtab = aVTrans[i];
+    int (*x)(sqlite3_vtab *);
+    x = pVtab->pModule->xSync;
+    if( x ){
+      rc = x(pVtab);
+    }
+  }
+  db->aVTrans = aVTrans;
+  rcsafety = sqlite3SafetyOn(db);
+
+  if( rc==SQLITE_OK ){
+    rc = rcsafety;
+  }
+  return rc;
+}
+
+/*
+** Invoke the xRollback method of all virtual tables in the 
+** sqlite3.aVTrans array. Then clear the array itself.
+*/
+int sqlite3VtabRollback(sqlite3 *db){
+  callFinaliser(db, (int)(&((sqlite3_module *)0)->xRollback));
+  return SQLITE_OK;
+}
+
+/*
+** Invoke the xCommit method of all virtual tables in the 
+** sqlite3.aVTrans array. Then clear the array itself.
+*/
+int sqlite3VtabCommit(sqlite3 *db){
+  callFinaliser(db, (int)(&((sqlite3_module *)0)->xCommit));
+  return SQLITE_OK;
+}
+
+/*
+** If the virtual table pVtab supports the transaction interface
+** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
+** not currently open, invoke the xBegin method now.
+**
+** If the xBegin call is successful, place the sqlite3_vtab pointer
+** in the sqlite3.aVTrans array.
+*/
+int sqlite3VtabBegin(sqlite3 *db, sqlite3_vtab *pVtab){
+  int rc = SQLITE_OK;
+  const sqlite3_module *pModule;
+
+  /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
+  ** than zero, then this function is being called from within a
+  ** virtual module xSync() callback. It is illegal to write to 
+  ** virtual module tables in this case, so return SQLITE_LOCKED.
+  */
+  if( 0==db->aVTrans && db->nVTrans>0 ){
+    return SQLITE_LOCKED;
+  }
+  if( !pVtab ){
+    return SQLITE_OK;
+  } 
+  pModule = pVtab->pModule;
+
+  if( pModule->xBegin ){
+    int i;
+
+
+    /* If pVtab is already in the aVTrans array, return early */
+    for(i=0; (i<db->nVTrans) && 0!=db->aVTrans[i]; i++){
+      if( db->aVTrans[i]==pVtab ){
+        return SQLITE_OK;
+      }
+    }
+
+    /* Invoke the xBegin method */
+    rc = pModule->xBegin(pVtab);
+    if( rc!=SQLITE_OK ){
+      return rc;
+    }
+
+    rc = addToVTrans(db, pVtab);
+  }
+  return rc;
+}
+
+/*
+** The first parameter (pDef) is a function implementation.  The
+** second parameter (pExpr) is the first argument to this function.
+** If pExpr is a column in a virtual table, then let the virtual
+** table implementation have an opportunity to overload the function.
+**
+** This routine is used to allow virtual table implementations to
+** overload MATCH, LIKE, GLOB, and REGEXP operators.
+**
+** Return either the pDef argument (indicating no change) or a 
+** new FuncDef structure that is marked as ephemeral using the
+** SQLITE_FUNC_EPHEM flag.
+*/
+FuncDef *sqlite3VtabOverloadFunction(
+  sqlite3 *db,    /* Database connection for reporting malloc problems */
+  FuncDef *pDef,  /* Function to possibly overload */
+  int nArg,       /* Number of arguments to the function */
+  Expr *pExpr     /* First argument to the function */
+){
+  Table *pTab;
+  sqlite3_vtab *pVtab;
+  sqlite3_module *pMod;
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
+  void *pArg;
+  FuncDef *pNew;
+  int rc = 0;
+  char *zLowerName;
+  unsigned char *z;
+
+
+  /* Check to see the left operand is a column in a virtual table */
+  if( pExpr==0 ) return pDef;
+  if( pExpr->op!=TK_COLUMN ) return pDef;
+  pTab = pExpr->pTab;
+  if( pTab==0 ) return pDef;
+  if( !pTab->isVirtual ) return pDef;
+  pVtab = pTab->pVtab;
+  assert( pVtab!=0 );
+  assert( pVtab->pModule!=0 );
+  pMod = (sqlite3_module *)pVtab->pModule;
+  if( pMod->xFindFunction==0 ) return pDef;
+ 
+  /* Call the xFindFunction method on the virtual table implementation
+  ** to see if the implementation wants to overload this function 
+  */
+  zLowerName = sqlite3DbStrDup(db, pDef->zName);
+  if( zLowerName ){
+    for(z=(unsigned char*)zLowerName; *z; z++){
+      *z = sqlite3UpperToLower[*z];
+    }
+    rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
+    sqlite3_free(zLowerName);
+  }
+  if( rc==0 ){
+    return pDef;
+  }
+
+  /* Create a new ephemeral function definition for the overloaded
+  ** function */
+  pNew = sqlite3DbMallocZero(db, sizeof(*pNew) + strlen(pDef->zName) );
+  if( pNew==0 ){
+    return pDef;
+  }
+  *pNew = *pDef;
+  memcpy(pNew->zName, pDef->zName, strlen(pDef->zName)+1);
+  pNew->xFunc = xFunc;
+  pNew->pUserData = pArg;
+  pNew->flags |= SQLITE_FUNC_EPHEM;
+  return pNew;
+}
+
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
diff --git a/client/src/thirdparty/sqlite-3.4.2/src/where.c b/client/src/thirdparty/sqlite-3.4.2/src/where.c
new file mode 100644
index 0000000..50bcea2
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/src/where.c
@@ -0,0 +1,2843 @@
+/*
+** 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.
+**
+*************************************************************************
+** This module contains C code that generates VDBE code used to process
+** the WHERE clause of SQL statements.  This module is reponsible for
+** generating the code that loops through a table looking for applicable
+** rows.  Indices are selected and used to speed the search when doing
+** so is applicable.  Because this module is responsible for selecting
+** indices, you might also think of this module as the "query optimizer".
+**
+** $Id: where.c,v 1.286 2008/01/23 12:52:41 drh Exp $
+*/
+#include "sqliteInt.h"
+
+/*
+** The number of bits in a Bitmask.  "BMS" means "BitMask Size".
+*/
+#define BMS  (sizeof(Bitmask)*8)
+
+/*
+** Trace output macros
+*/
+#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
+int sqlite3_where_trace = 0;
+# define WHERETRACE(X)  if(sqlite3_where_trace) sqlite3DebugPrintf X
+#else
+# define WHERETRACE(X)
+#endif
+
+/* Forward reference
+*/
+typedef struct WhereClause WhereClause;
+typedef struct ExprMaskSet ExprMaskSet;
+
+/*
+** The query generator uses an array of instances of this structure to
+** help it analyze the subexpressions of the WHERE clause.  Each WHERE
+** clause subexpression is separated from the others by an AND operator.
+**
+** All WhereTerms are collected into a single WhereClause structure.  
+** The following identity holds:
+**
+**        WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm
+**
+** When a term is of the form:
+**
+**              X <op> <expr>
+**
+** where X is a column name and <op> is one of certain operators,
+** then WhereTerm.leftCursor and WhereTerm.leftColumn record the
+** cursor number and column number for X.  WhereTerm.operator records
+** the <op> using a bitmask encoding defined by WO_xxx below.  The
+** use of a bitmask encoding for the operator allows us to search
+** quickly for terms that match any of several different operators.
+**
+** prereqRight and prereqAll record sets of cursor numbers,
+** but they do so indirectly.  A single ExprMaskSet structure translates
+** cursor number into bits and the translated bit is stored in the prereq
+** fields.  The translation is used in order to maximize the number of
+** bits that will fit in a Bitmask.  The VDBE cursor numbers might be
+** spread out over the non-negative integers.  For example, the cursor
+** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45.  The ExprMaskSet
+** translates these sparse cursor numbers into consecutive integers
+** beginning with 0 in order to make the best possible use of the available
+** bits in the Bitmask.  So, in the example above, the cursor numbers
+** would be mapped into integers 0 through 7.
+*/
+typedef struct WhereTerm WhereTerm;
+struct WhereTerm {
+  Expr *pExpr;            /* Pointer to the subexpression */
+  i16 iParent;            /* Disable pWC->a[iParent] when this term disabled */
+  i16 leftCursor;         /* Cursor number of X in "X <op> <expr>" */
+  i16 leftColumn;         /* Column number of X in "X <op> <expr>" */
+  u16 eOperator;          /* A WO_xx value describing <op> */
+  u8 flags;               /* Bit flags.  See below */
+  u8 nChild;              /* Number of children that must disable us */
+  WhereClause *pWC;       /* The clause this term is part of */
+  Bitmask prereqRight;    /* Bitmask of tables used by pRight */
+  Bitmask prereqAll;      /* Bitmask of tables referenced by p */
+};
+
+/*
+** Allowed values of WhereTerm.flags
+*/
+#define TERM_DYNAMIC    0x01   /* Need to call sqlite3ExprDelete(pExpr) */
+#define TERM_VIRTUAL    0x02   /* Added by the optimizer.  Do not code */
+#define TERM_CODED      0x04   /* This term is already coded */
+#define TERM_COPIED     0x08   /* Has a child */
+#define TERM_OR_OK      0x10   /* Used during OR-clause processing */
+
+/*
+** An instance of the following structure holds all information about a
+** WHERE clause.  Mostly this is a container for one or more WhereTerms.
+*/
+struct WhereClause {
+  Parse *pParse;           /* The parser context */
+  ExprMaskSet *pMaskSet;   /* Mapping of table indices to bitmasks */
+  int nTerm;               /* Number of terms */
+  int nSlot;               /* Number of entries in a[] */
+  WhereTerm *a;            /* Each a[] describes a term of the WHERE cluase */
+  WhereTerm aStatic[10];   /* Initial static space for a[] */
+};
+
+/*
+** An instance of the following structure keeps track of a mapping
+** between VDBE cursor numbers and bits of the bitmasks in WhereTerm.
+**
+** The VDBE cursor numbers are small integers contained in 
+** SrcList_item.iCursor and Expr.iTable fields.  For any given WHERE 
+** clause, the cursor numbers might not begin with 0 and they might
+** contain gaps in the numbering sequence.  But we want to make maximum
+** use of the bits in our bitmasks.  This structure provides a mapping
+** from the sparse cursor numbers into consecutive integers beginning
+** with 0.
+**
+** If ExprMaskSet.ix[A]==B it means that The A-th bit of a Bitmask
+** corresponds VDBE cursor number B.  The A-th bit of a bitmask is 1<<A.
+**
+** For example, if the WHERE clause expression used these VDBE
+** cursors:  4, 5, 8, 29, 57, 73.  Then the  ExprMaskSet structure
+** would map those cursor numbers into bits 0 through 5.
+**
+** Note that the mapping is not necessarily ordered.  In the example
+** above, the mapping might go like this:  4->3, 5->1, 8->2, 29->0,
+** 57->5, 73->4.  Or one of 719 other combinations might be used. It
+** does not really matter.  What is important is that sparse cursor
+** numbers all get mapped into bit numbers that begin with 0 and contain
+** no gaps.
+*/
+struct ExprMaskSet {
+  int n;                        /* Number of assigned cursor values */
+  int ix[sizeof(Bitmask)*8];    /* Cursor assigned to each bit */
+};
+
+
+/*
+** Bitmasks for the operators that indices are able to exploit.  An
+** OR-ed combination of these values can be used when searching for
+** terms in the where clause.
+*/
+#define WO_IN     1
+#define WO_EQ     2
+#define WO_LT     (WO_EQ<<(TK_LT-TK_EQ))
+#define WO_LE     (WO_EQ<<(TK_LE-TK_EQ))
+#define WO_GT     (WO_EQ<<(TK_GT-TK_EQ))
+#define WO_GE     (WO_EQ<<(TK_GE-TK_EQ))
+#define WO_MATCH  64
+#define WO_ISNULL 128
+
+/*
+** Value for flags returned by bestIndex().  
+**
+** The least significant byte is reserved as a mask for WO_ values above.
+** The WhereLevel.flags field is usually set to WO_IN|WO_EQ|WO_ISNULL.
+** But if the table is the right table of a left join, WhereLevel.flags
+** is set to WO_IN|WO_EQ.  The WhereLevel.flags field can then be used as
+** the "op" parameter to findTerm when we are resolving equality constraints.
+** ISNULL constraints will then not be used on the right table of a left
+** join.  Tickets #2177 and #2189.
+*/
+#define WHERE_ROWID_EQ     0x000100   /* rowid=EXPR or rowid IN (...) */
+#define WHERE_ROWID_RANGE  0x000200   /* rowid<EXPR and/or rowid>EXPR */
+#define WHERE_COLUMN_EQ    0x001000   /* x=EXPR or x IN (...) */
+#define WHERE_COLUMN_RANGE 0x002000   /* x<EXPR and/or x>EXPR */
+#define WHERE_COLUMN_IN    0x004000   /* x IN (...) */
+#define WHERE_TOP_LIMIT    0x010000   /* x<EXPR or x<=EXPR constraint */
+#define WHERE_BTM_LIMIT    0x020000   /* x>EXPR or x>=EXPR constraint */
+#define WHERE_IDX_ONLY     0x080000   /* Use index only - omit table */
+#define WHERE_ORDERBY      0x100000   /* Output will appear in correct order */
+#define WHERE_REVERSE      0x200000   /* Scan in reverse order */
+#define WHERE_UNIQUE       0x400000   /* Selects no more than one row */
+#define WHERE_VIRTUALTABLE 0x800000   /* Use virtual-table processing */
+
+/*
+** Initialize a preallocated WhereClause structure.
+*/
+static void whereClauseInit(
+  WhereClause *pWC,        /* The WhereClause to be initialized */
+  Parse *pParse,           /* The parsing context */
+  ExprMaskSet *pMaskSet    /* Mapping from table indices to bitmasks */
+){
+  pWC->pParse = pParse;
+  pWC->pMaskSet = pMaskSet;
+  pWC->nTerm = 0;
+  pWC->nSlot = ArraySize(pWC->aStatic);
+  pWC->a = pWC->aStatic;
+}
+
+/*
+** Deallocate a WhereClause structure.  The WhereClause structure
+** itself is not freed.  This routine is the inverse of whereClauseInit().
+*/
+static void whereClauseClear(WhereClause *pWC){
+  int i;
+  WhereTerm *a;
+  for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){
+    if( a->flags & TERM_DYNAMIC ){
+      sqlite3ExprDelete(a->pExpr);
+    }
+  }
+  if( pWC->a!=pWC->aStatic ){
+    sqlite3_free(pWC->a);
+  }
+}
+
+/*
+** Add a new entries to the WhereClause structure.  Increase the allocated
+** space as necessary.
+**
+** If the flags argument includes TERM_DYNAMIC, then responsibility
+** for freeing the expression p is assumed by the WhereClause object.
+**
+** WARNING:  This routine might reallocate the space used to store
+** WhereTerms.  All pointers to WhereTerms should be invalided after
+** calling this routine.  Such pointers may be reinitialized by referencing
+** the pWC->a[] array.
+*/
+static int whereClauseInsert(WhereClause *pWC, Expr *p, int flags){
+  WhereTerm *pTerm;
+  int idx;
+  if( pWC->nTerm>=pWC->nSlot ){
+    WhereTerm *pOld = pWC->a;
+    pWC->a = sqlite3_malloc( sizeof(pWC->a[0])*pWC->nSlot*2 );
+    if( pWC->a==0 ){
+      pWC->pParse->db->mallocFailed = 1;
+      if( flags & TERM_DYNAMIC ){
+        sqlite3ExprDelete(p);
+      }
+      pWC->a = pOld;
+      return 0;
+    }
+    memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
+    if( pOld!=pWC->aStatic ){
+      sqlite3_free(pOld);
+    }
+    pWC->nSlot *= 2;
+  }
+  pTerm = &pWC->a[idx = pWC->nTerm];
+  pWC->nTerm++;
+  pTerm->pExpr = p;
+  pTerm->flags = flags;
+  pTerm->pWC = pWC;
+  pTerm->iParent = -1;
+  return idx;
+}
+
+/*
+** This routine identifies subexpressions in the WHERE clause where
+** each subexpression is separated by the AND operator or some other
+** operator specified in the op parameter.  The WhereClause structure
+** is filled with pointers to subexpressions.  For example:
+**
+**    WHERE  a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22)
+**           \________/     \_______________/     \________________/
+**            slot[0]            slot[1]               slot[2]
+**
+** The original WHERE clause in pExpr is unaltered.  All this routine
+** does is make slot[] entries point to substructure within pExpr.
+**
+** In the previous sentence and in the diagram, "slot[]" refers to
+** the WhereClause.a[] array.  This array grows as needed to contain
+** all terms of the WHERE clause.
+*/
+static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
+  if( pExpr==0 ) return;
+  if( pExpr->op!=op ){
+    whereClauseInsert(pWC, pExpr, 0);
+  }else{
+    whereSplit(pWC, pExpr->pLeft, op);
+    whereSplit(pWC, pExpr->pRight, op);
+  }
+}
+
+/*
+** Initialize an expression mask set
+*/
+#define initMaskSet(P)  memset(P, 0, sizeof(*P))
+
+/*
+** Return the bitmask for the given cursor number.  Return 0 if
+** iCursor is not in the set.
+*/
+static Bitmask getMask(ExprMaskSet *pMaskSet, int iCursor){
+  int i;
+  for(i=0; i<pMaskSet->n; i++){
+    if( pMaskSet->ix[i]==iCursor ){
+      return ((Bitmask)1)<<i;
+    }
+  }
+  return 0;
+}
+
+/*
+** Create a new mask for cursor iCursor.
+**
+** There is one cursor per table in the FROM clause.  The number of
+** tables in the FROM clause is limited by a test early in the
+** sqlite3WhereBegin() routine.  So we know that the pMaskSet->ix[]
+** array will never overflow.
+*/
+static void createMask(ExprMaskSet *pMaskSet, int iCursor){
+  assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
+  pMaskSet->ix[pMaskSet->n++] = iCursor;
+}
+
+/*
+** This routine walks (recursively) an expression tree and generates
+** a bitmask indicating which tables are used in that expression
+** tree.
+**
+** In order for this routine to work, the calling function must have
+** previously invoked sqlite3ExprResolveNames() on the expression.  See
+** the header comment on that routine for additional information.
+** The sqlite3ExprResolveNames() routines looks for column names and
+** sets their opcodes to TK_COLUMN and their Expr.iTable fields to
+** the VDBE cursor number of the table.  This routine just has to
+** translate the cursor numbers into bitmask values and OR all
+** the bitmasks together.
+*/
+static Bitmask exprListTableUsage(ExprMaskSet*, ExprList*);
+static Bitmask exprSelectTableUsage(ExprMaskSet*, Select*);
+static Bitmask exprTableUsage(ExprMaskSet *pMaskSet, Expr *p){
+  Bitmask mask = 0;
+  if( p==0 ) return 0;
+  if( p->op==TK_COLUMN ){
+    mask = getMask(pMaskSet, p->iTable);
+    return mask;
+  }
+  mask = exprTableUsage(pMaskSet, p->pRight);
+  mask |= exprTableUsage(pMaskSet, p->pLeft);
+  mask |= exprListTableUsage(pMaskSet, p->pList);
+  mask |= exprSelectTableUsage(pMaskSet, p->pSelect);
+  return mask;
+}
+static Bitmask exprListTableUsage(ExprMaskSet *pMaskSet, ExprList *pList){
+  int i;
+  Bitmask mask = 0;
+  if( pList ){
+    for(i=0; i<pList->nExpr; i++){
+      mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
+    }
+  }
+  return mask;
+}
+static Bitmask exprSelectTableUsage(ExprMaskSet *pMaskSet, Select *pS){
+  Bitmask mask = 0;
+  while( pS ){
+    mask |= exprListTableUsage(pMaskSet, pS->pEList);
+    mask |= exprListTableUsage(pMaskSet, pS->pGroupBy);
+    mask |= exprListTableUsage(pMaskSet, pS->pOrderBy);
+    mask |= exprTableUsage(pMaskSet, pS->pWhere);
+    mask |= exprTableUsage(pMaskSet, pS->pHaving);
+    pS = pS->pPrior;
+  }
+  return mask;
+}
+
+/*
+** Return TRUE if the given operator is one of the operators that is
+** allowed for an indexable WHERE clause term.  The allowed operators are
+** "=", "<", ">", "<=", ">=", and "IN".
+*/
+static int allowedOp(int op){
+  assert( TK_GT>TK_EQ && TK_GT<TK_GE );
+  assert( TK_LT>TK_EQ && TK_LT<TK_GE );
+  assert( TK_LE>TK_EQ && TK_LE<TK_GE );
+  assert( TK_GE==TK_EQ+4 );
+  return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL;
+}
+
+/*
+** Swap two objects of type T.
+*/
+#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
+
+/*
+** Commute a comparision operator.  Expressions of the form "X op Y"
+** are converted into "Y op X".
+**
+** If a collation sequence is associated with either the left or right
+** side of the comparison, it remains associated with the same side after
+** the commutation. So "Y collate NOCASE op X" becomes 
+** "X collate NOCASE op Y". This is because any collation sequence on
+** the left hand side of a comparison overrides any collation sequence 
+** attached to the right. For the same reason the EP_ExpCollate flag
+** is not commuted.
+*/
+static void exprCommute(Expr *pExpr){
+  u16 expRight = (pExpr->pRight->flags & EP_ExpCollate);
+  u16 expLeft = (pExpr->pLeft->flags & EP_ExpCollate);
+  assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
+  SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
+  pExpr->pRight->flags = (pExpr->pRight->flags & ~EP_ExpCollate) | expLeft;
+  pExpr->pLeft->flags = (pExpr->pLeft->flags & ~EP_ExpCollate) | expRight;
+  SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
+  if( pExpr->op>=TK_GT ){
+    assert( TK_LT==TK_GT+2 );
+    assert( TK_GE==TK_LE+2 );
+    assert( TK_GT>TK_EQ );
+    assert( TK_GT<TK_LE );
+    assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
+    pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
+  }
+}
+
+/*
+** Translate from TK_xx operator to WO_xx bitmask.
+*/
+static int operatorMask(int op){
+  int c;
+  assert( allowedOp(op) );
+  if( op==TK_IN ){
+    c = WO_IN;
+  }else if( op==TK_ISNULL ){
+    c = WO_ISNULL;
+  }else{
+    c = WO_EQ<<(op-TK_EQ);
+  }
+  assert( op!=TK_ISNULL || c==WO_ISNULL );
+  assert( op!=TK_IN || c==WO_IN );
+  assert( op!=TK_EQ || c==WO_EQ );
+  assert( op!=TK_LT || c==WO_LT );
+  assert( op!=TK_LE || c==WO_LE );
+  assert( op!=TK_GT || c==WO_GT );
+  assert( op!=TK_GE || c==WO_GE );
+  return c;
+}
+
+/*
+** Search for a term in the WHERE clause that is of the form "X <op> <expr>"
+** where X is a reference to the iColumn of table iCur and <op> is one of
+** the WO_xx operator codes specified by the op parameter.
+** Return a pointer to the term.  Return 0 if not found.
+*/
+static WhereTerm *findTerm(
+  WhereClause *pWC,     /* The WHERE clause to be searched */
+  int iCur,             /* Cursor number of LHS */
+  int iColumn,          /* Column number of LHS */
+  Bitmask notReady,     /* RHS must not overlap with this mask */
+  u16 op,               /* Mask of WO_xx values describing operator */
+  Index *pIdx           /* Must be compatible with this index, if not NULL */
+){
+  WhereTerm *pTerm;
+  int k;
+  for(pTerm=pWC->a, k=pWC->nTerm; k; k--, pTerm++){
+    if( pTerm->leftCursor==iCur
+       && (pTerm->prereqRight & notReady)==0
+       && pTerm->leftColumn==iColumn
+       && (pTerm->eOperator & op)!=0
+    ){
+      if( iCur>=0 && pIdx && pTerm->eOperator!=WO_ISNULL ){
+        Expr *pX = pTerm->pExpr;
+        CollSeq *pColl;
+        char idxaff;
+        int j;
+        Parse *pParse = pWC->pParse;
+
+        idxaff = pIdx->pTable->aCol[iColumn].affinity;
+        if( !sqlite3IndexAffinityOk(pX, idxaff) ) continue;
+
+        /* Figure out the collation sequence required from an index for
+        ** it to be useful for optimising expression pX. Store this
+        ** value in variable pColl.
+        */
+        assert(pX->pLeft);
+        pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
+        if( !pColl ){
+          pColl = pParse->db->pDfltColl;
+        }
+
+        for(j=0; j<pIdx->nColumn && pIdx->aiColumn[j]!=iColumn; j++){}
+        assert( j<pIdx->nColumn );
+        if( sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
+      }
+      return pTerm;
+    }
+  }
+  return 0;
+}
+
+/* Forward reference */
+static void exprAnalyze(SrcList*, WhereClause*, int);
+
+/*
+** Call exprAnalyze on all terms in a WHERE clause.  
+**
+**
+*/
+static void exprAnalyzeAll(
+  SrcList *pTabList,       /* the FROM clause */
+  WhereClause *pWC         /* the WHERE clause to be analyzed */
+){
+  int i;
+  for(i=pWC->nTerm-1; i>=0; i--){
+    exprAnalyze(pTabList, pWC, i);
+  }
+}
+
+#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
+/*
+** Check to see if the given expression is a LIKE or GLOB operator that
+** can be optimized using inequality constraints.  Return TRUE if it is
+** so and false if not.
+**
+** In order for the operator to be optimizible, the RHS must be a string
+** literal that does not begin with a wildcard.  
+*/
+static int isLikeOrGlob(
+  sqlite3 *db,      /* The database */
+  Expr *pExpr,      /* Test this expression */
+  int *pnPattern,   /* Number of non-wildcard prefix characters */
+  int *pisComplete  /* True if the only wildcard is % in the last character */
+){
+  const char *z;
+  Expr *pRight, *pLeft;
+  ExprList *pList;
+  int c, cnt;
+  int noCase;
+  char wc[3];
+  CollSeq *pColl;
+
+  if( !sqlite3IsLikeFunction(db, pExpr, &noCase, wc) ){
+    return 0;
+  }
+  pList = pExpr->pList;
+  pRight = pList->a[0].pExpr;
+  if( pRight->op!=TK_STRING ){
+    return 0;
+  }
+  pLeft = pList->a[1].pExpr;
+  if( pLeft->op!=TK_COLUMN ){
+    return 0;
+  }
+  pColl = pLeft->pColl;
+  assert( pColl!=0 || pLeft->iColumn==-1 );
+  if( pColl==0 ){
+    /* No collation is defined for the ROWID.  Use the default. */
+    pColl = db->pDfltColl;
+  }
+  if( (pColl->type!=SQLITE_COLL_BINARY || noCase) &&
+      (pColl->type!=SQLITE_COLL_NOCASE || !noCase) ){
+    return 0;
+  }
+  sqlite3DequoteExpr(db, pRight);
+  z = (char *)pRight->token.z;
+  cnt = 0;
+  if( z ){
+    while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){ cnt++; }
+  }
+  if( cnt==0 || 255==(u8)z[cnt] ){
+    return 0;
+  }
+  *pisComplete = z[cnt]==wc[0] && z[cnt+1]==0;
+  *pnPattern = cnt;
+  return 1;
+}
+#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
+
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** Check to see if the given expression is of the form
+**
+**         column MATCH expr
+**
+** If it is then return TRUE.  If not, return FALSE.
+*/
+static int isMatchOfColumn(
+  Expr *pExpr      /* Test this expression */
+){
+  ExprList *pList;
+
+  if( pExpr->op!=TK_FUNCTION ){
+    return 0;
+  }
+  if( pExpr->token.n!=5 ||
+       sqlite3StrNICmp((const char*)pExpr->token.z,"match",5)!=0 ){
+    return 0;
+  }
+  pList = pExpr->pList;
+  if( pList->nExpr!=2 ){
+    return 0;
+  }
+  if( pList->a[1].pExpr->op != TK_COLUMN ){
+    return 0;
+  }
+  return 1;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+/*
+** If the pBase expression originated in the ON or USING clause of
+** a join, then transfer the appropriate markings over to derived.
+*/
+static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
+  pDerived->flags |= pBase->flags & EP_FromJoin;
+  pDerived->iRightJoinTable = pBase->iRightJoinTable;
+}
+
+#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
+/*
+** Return TRUE if the given term of an OR clause can be converted
+** into an IN clause.  The iCursor and iColumn define the left-hand
+** side of the IN clause.
+**
+** The context is that we have multiple OR-connected equality terms
+** like this:
+**
+**           a=<expr1> OR  a=<expr2> OR b=<expr3>  OR ...
+**
+** The pOrTerm input to this routine corresponds to a single term of
+** this OR clause.  In order for the term to be a condidate for
+** conversion to an IN operator, the following must be true:
+**
+**     *  The left-hand side of the term must be the column which
+**        is identified by iCursor and iColumn.
+**
+**     *  If the right-hand side is also a column, then the affinities
+**        of both right and left sides must be such that no type
+**        conversions are required on the right.  (Ticket #2249)
+**
+** If both of these conditions are true, then return true.  Otherwise
+** return false.
+*/
+static int orTermIsOptCandidate(WhereTerm *pOrTerm, int iCursor, int iColumn){
+  int affLeft, affRight;
+  assert( pOrTerm->eOperator==WO_EQ );
+  if( pOrTerm->leftCursor!=iCursor ){
+    return 0;
+  }
+  if( pOrTerm->leftColumn!=iColumn ){
+    return 0;
+  }
+  affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
+  if( affRight==0 ){
+    return 1;
+  }
+  affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
+  if( affRight!=affLeft ){
+    return 0;
+  }
+  return 1;
+}
+
+/*
+** Return true if the given term of an OR clause can be ignored during
+** a check to make sure all OR terms are candidates for optimization.
+** In other words, return true if a call to the orTermIsOptCandidate()
+** above returned false but it is not necessary to disqualify the
+** optimization.
+**
+** Suppose the original OR phrase was this:
+**
+**           a=4  OR  a=11  OR  a=b
+**
+** During analysis, the third term gets flipped around and duplicate
+** so that we are left with this:
+**
+**           a=4  OR  a=11  OR  a=b  OR  b=a
+**
+** Since the last two terms are duplicates, only one of them
+** has to qualify in order for the whole phrase to qualify.  When
+** this routine is called, we know that pOrTerm did not qualify.
+** This routine merely checks to see if pOrTerm has a duplicate that
+** might qualify.  If there is a duplicate that has not yet been
+** disqualified, then return true.  If there are no duplicates, or
+** the duplicate has also been disqualifed, return false.
+*/
+static int orTermHasOkDuplicate(WhereClause *pOr, WhereTerm *pOrTerm){
+  if( pOrTerm->flags & TERM_COPIED ){
+    /* This is the original term.  The duplicate is to the left had
+    ** has not yet been analyzed and thus has not yet been disqualified. */
+    return 1;
+  }
+  if( (pOrTerm->flags & TERM_VIRTUAL)!=0
+     && (pOr->a[pOrTerm->iParent].flags & TERM_OR_OK)!=0 ){
+    /* This is a duplicate term.  The original qualified so this one
+    ** does not have to. */
+    return 1;
+  }
+  /* This is either a singleton term or else it is a duplicate for
+  ** which the original did not qualify.  Either way we are done for. */
+  return 0;
+}
+#endif /* !SQLITE_OMIT_OR_OPTIMIZATION && !SQLITE_OMIT_SUBQUERY */
+
+/*
+** The input to this routine is an WhereTerm structure with only the
+** "pExpr" field filled in.  The job of this routine is to analyze the
+** subexpression and populate all the other fields of the WhereTerm
+** structure.
+**
+** If the expression is of the form "<expr> <op> X" it gets commuted
+** to the standard form of "X <op> <expr>".  If the expression is of
+** the form "X <op> Y" where both X and Y are columns, then the original
+** expression is unchanged and a new virtual expression of the form
+** "Y <op> X" is added to the WHERE clause and analyzed separately.
+*/
+static void exprAnalyze(
+  SrcList *pSrc,            /* the FROM clause */
+  WhereClause *pWC,         /* the WHERE clause */
+  int idxTerm               /* Index of the term to be analyzed */
+){
+  WhereTerm *pTerm;
+  ExprMaskSet *pMaskSet;
+  Expr *pExpr;
+  Bitmask prereqLeft;
+  Bitmask prereqAll;
+  int nPattern;
+  int isComplete;
+  int op;
+  Parse *pParse = pWC->pParse;
+  sqlite3 *db = pParse->db;
+
+  if( db->mallocFailed ){
+    return;
+  }
+  pTerm = &pWC->a[idxTerm];
+  pMaskSet = pWC->pMaskSet;
+  pExpr = pTerm->pExpr;
+  prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
+  op = pExpr->op;
+  if( op==TK_IN ){
+    assert( pExpr->pRight==0 );
+    pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->pList)
+                          | exprSelectTableUsage(pMaskSet, pExpr->pSelect);
+  }else if( op==TK_ISNULL ){
+    pTerm->prereqRight = 0;
+  }else{
+    pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
+  }
+  prereqAll = exprTableUsage(pMaskSet, pExpr);
+  if( ExprHasProperty(pExpr, EP_FromJoin) ){
+    prereqAll |= getMask(pMaskSet, pExpr->iRightJoinTable);
+  }
+  pTerm->prereqAll = prereqAll;
+  pTerm->leftCursor = -1;
+  pTerm->iParent = -1;
+  pTerm->eOperator = 0;
+  if( allowedOp(op) && (pTerm->prereqRight & prereqLeft)==0 ){
+    Expr *pLeft = pExpr->pLeft;
+    Expr *pRight = pExpr->pRight;
+    if( pLeft->op==TK_COLUMN ){
+      pTerm->leftCursor = pLeft->iTable;
+      pTerm->leftColumn = pLeft->iColumn;
+      pTerm->eOperator = operatorMask(op);
+    }
+    if( pRight && pRight->op==TK_COLUMN ){
+      WhereTerm *pNew;
+      Expr *pDup;
+      if( pTerm->leftCursor>=0 ){
+        int idxNew;
+        pDup = sqlite3ExprDup(db, pExpr);
+        if( db->mallocFailed ){
+          sqlite3ExprDelete(pDup);
+          return;
+        }
+        idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);
+        if( idxNew==0 ) return;
+        pNew = &pWC->a[idxNew];
+        pNew->iParent = idxTerm;
+        pTerm = &pWC->a[idxTerm];
+        pTerm->nChild = 1;
+        pTerm->flags |= TERM_COPIED;
+      }else{
+        pDup = pExpr;
+        pNew = pTerm;
+      }
+      exprCommute(pDup);
+      pLeft = pDup->pLeft;
+      pNew->leftCursor = pLeft->iTable;
+      pNew->leftColumn = pLeft->iColumn;
+      pNew->prereqRight = prereqLeft;
+      pNew->prereqAll = prereqAll;
+      pNew->eOperator = operatorMask(pDup->op);
+    }
+  }
+
+#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION
+  /* If a term is the BETWEEN operator, create two new virtual terms
+  ** that define the range that the BETWEEN implements.
+  */
+  else if( pExpr->op==TK_BETWEEN ){
+    ExprList *pList = pExpr->pList;
+    int i;
+    static const u8 ops[] = {TK_GE, TK_LE};
+    assert( pList!=0 );
+    assert( pList->nExpr==2 );
+    for(i=0; i<2; i++){
+      Expr *pNewExpr;
+      int idxNew;
+      pNewExpr = sqlite3Expr(db, ops[i], sqlite3ExprDup(db, pExpr->pLeft),
+                             sqlite3ExprDup(db, pList->a[i].pExpr), 0);
+      idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
+      exprAnalyze(pSrc, pWC, idxNew);
+      pTerm = &pWC->a[idxTerm];
+      pWC->a[idxNew].iParent = idxTerm;
+    }
+    pTerm->nChild = 2;
+  }
+#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */
+
+#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
+  /* Attempt to convert OR-connected terms into an IN operator so that
+  ** they can make use of indices.  Example:
+  **
+  **      x = expr1  OR  expr2 = x  OR  x = expr3
+  **
+  ** is converted into
+  **
+  **      x IN (expr1,expr2,expr3)
+  **
+  ** This optimization must be omitted if OMIT_SUBQUERY is defined because
+  ** the compiler for the the IN operator is part of sub-queries.
+  */
+  else if( pExpr->op==TK_OR ){
+    int ok;
+    int i, j;
+    int iColumn, iCursor;
+    WhereClause sOr;
+    WhereTerm *pOrTerm;
+
+    assert( (pTerm->flags & TERM_DYNAMIC)==0 );
+    whereClauseInit(&sOr, pWC->pParse, pMaskSet);
+    whereSplit(&sOr, pExpr, TK_OR);
+    exprAnalyzeAll(pSrc, &sOr);
+    assert( sOr.nTerm>=2 );
+    j = 0;
+    do{
+      assert( j<sOr.nTerm );
+      iColumn = sOr.a[j].leftColumn;
+      iCursor = sOr.a[j].leftCursor;
+      ok = iCursor>=0;
+      for(i=sOr.nTerm-1, pOrTerm=sOr.a; i>=0 && ok; i--, pOrTerm++){
+        if( pOrTerm->eOperator!=WO_EQ ){
+          goto or_not_possible;
+        }
+        if( orTermIsOptCandidate(pOrTerm, iCursor, iColumn) ){
+          pOrTerm->flags |= TERM_OR_OK;
+        }else if( orTermHasOkDuplicate(&sOr, pOrTerm) ){
+          pOrTerm->flags &= ~TERM_OR_OK;
+        }else{
+          ok = 0;
+        }
+      }
+    }while( !ok && (sOr.a[j++].flags & TERM_COPIED)!=0 && j<2 );
+    if( ok ){
+      ExprList *pList = 0;
+      Expr *pNew, *pDup;
+      Expr *pLeft = 0;
+      for(i=sOr.nTerm-1, pOrTerm=sOr.a; i>=0 && ok; i--, pOrTerm++){
+        if( (pOrTerm->flags & TERM_OR_OK)==0 ) continue;
+        pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight);
+        pList = sqlite3ExprListAppend(pWC->pParse, pList, pDup, 0);
+        pLeft = pOrTerm->pExpr->pLeft;
+      }
+      assert( pLeft!=0 );
+      pDup = sqlite3ExprDup(db, pLeft);
+      pNew = sqlite3Expr(db, TK_IN, pDup, 0, 0);
+      if( pNew ){
+        int idxNew;
+        transferJoinMarkings(pNew, pExpr);
+        pNew->pList = pList;
+        idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
+        exprAnalyze(pSrc, pWC, idxNew);
+        pTerm = &pWC->a[idxTerm];
+        pWC->a[idxNew].iParent = idxTerm;
+        pTerm->nChild = 1;
+      }else{
+        sqlite3ExprListDelete(pList);
+      }
+    }
+or_not_possible:
+    whereClauseClear(&sOr);
+  }
+#endif /* SQLITE_OMIT_OR_OPTIMIZATION */
+
+#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
+  /* Add constraints to reduce the search space on a LIKE or GLOB
+  ** operator.
+  */
+  if( isLikeOrGlob(db, pExpr, &nPattern, &isComplete) ){
+    Expr *pLeft, *pRight;
+    Expr *pStr1, *pStr2;
+    Expr *pNewExpr1, *pNewExpr2;
+    int idxNew1, idxNew2;
+
+    pLeft = pExpr->pList->a[1].pExpr;
+    pRight = pExpr->pList->a[0].pExpr;
+    pStr1 = sqlite3PExpr(pParse, TK_STRING, 0, 0, 0);
+    if( pStr1 ){
+      sqlite3TokenCopy(db, &pStr1->token, &pRight->token);
+      pStr1->token.n = nPattern;
+      pStr1->flags = EP_Dequoted;
+    }
+    pStr2 = sqlite3ExprDup(db, pStr1);
+    if( !db->mallocFailed ){
+      assert( pStr2->token.dyn );
+      ++*(u8*)&pStr2->token.z[nPattern-1];
+    }
+    pNewExpr1 = sqlite3PExpr(pParse, TK_GE, sqlite3ExprDup(db,pLeft), pStr1, 0);
+    idxNew1 = whereClauseInsert(pWC, pNewExpr1, TERM_VIRTUAL|TERM_DYNAMIC);
+    exprAnalyze(pSrc, pWC, idxNew1);
+    pNewExpr2 = sqlite3PExpr(pParse, TK_LT, sqlite3ExprDup(db,pLeft), pStr2, 0);
+    idxNew2 = whereClauseInsert(pWC, pNewExpr2, TERM_VIRTUAL|TERM_DYNAMIC);
+    exprAnalyze(pSrc, pWC, idxNew2);
+    pTerm = &pWC->a[idxTerm];
+    if( isComplete ){
+      pWC->a[idxNew1].iParent = idxTerm;
+      pWC->a[idxNew2].iParent = idxTerm;
+      pTerm->nChild = 2;
+    }
+  }
+#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  /* Add a WO_MATCH auxiliary term to the constraint set if the
+  ** current expression is of the form:  column MATCH expr.
+  ** This information is used by the xBestIndex methods of
+  ** virtual tables.  The native query optimizer does not attempt
+  ** to do anything with MATCH functions.
+  */
+  if( isMatchOfColumn(pExpr) ){
+    int idxNew;
+    Expr *pRight, *pLeft;
+    WhereTerm *pNewTerm;
+    Bitmask prereqColumn, prereqExpr;
+
+    pRight = pExpr->pList->a[0].pExpr;
+    pLeft = pExpr->pList->a[1].pExpr;
+    prereqExpr = exprTableUsage(pMaskSet, pRight);
+    prereqColumn = exprTableUsage(pMaskSet, pLeft);
+    if( (prereqExpr & prereqColumn)==0 ){
+      Expr *pNewExpr;
+      pNewExpr = sqlite3Expr(db, TK_MATCH, 0, sqlite3ExprDup(db, pRight), 0);
+      idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
+      pNewTerm = &pWC->a[idxNew];
+      pNewTerm->prereqRight = prereqExpr;
+      pNewTerm->leftCursor = pLeft->iTable;
+      pNewTerm->leftColumn = pLeft->iColumn;
+      pNewTerm->eOperator = WO_MATCH;
+      pNewTerm->iParent = idxTerm;
+      pTerm = &pWC->a[idxTerm];
+      pTerm->nChild = 1;
+      pTerm->flags |= TERM_COPIED;
+      pNewTerm->prereqAll = pTerm->prereqAll;
+    }
+  }
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+}
+
+/*
+** Return TRUE if any of the expressions in pList->a[iFirst...] contain
+** a reference to any table other than the iBase table.
+*/
+static int referencesOtherTables(
+  ExprList *pList,          /* Search expressions in ths list */
+  ExprMaskSet *pMaskSet,    /* Mapping from tables to bitmaps */
+  int iFirst,               /* Be searching with the iFirst-th expression */
+  int iBase                 /* Ignore references to this table */
+){
+  Bitmask allowed = ~getMask(pMaskSet, iBase);
+  while( iFirst<pList->nExpr ){
+    if( (exprTableUsage(pMaskSet, pList->a[iFirst++].pExpr)&allowed)!=0 ){
+      return 1;
+    }
+  }
+  return 0;
+}
+
+
+/*
+** This routine decides if pIdx can be used to satisfy the ORDER BY
+** clause.  If it can, it returns 1.  If pIdx cannot satisfy the
+** ORDER BY clause, this routine returns 0.
+**
+** pOrderBy is an ORDER BY clause from a SELECT statement.  pTab is the
+** left-most table in the FROM clause of that same SELECT statement and
+** the table has a cursor number of "base".  pIdx is an index on pTab.
+**
+** nEqCol is the number of columns of pIdx that are used as equality
+** constraints.  Any of these columns may be missing from the ORDER BY
+** clause and the match can still be a success.
+**
+** All terms of the ORDER BY that match against the index must be either
+** ASC or DESC.  (Terms of the ORDER BY clause past the end of a UNIQUE
+** index do not need to satisfy this constraint.)  The *pbRev value is
+** set to 1 if the ORDER BY clause is all DESC and it is set to 0 if
+** the ORDER BY clause is all ASC.
+*/
+static int isSortingIndex(
+  Parse *pParse,          /* Parsing context */
+  ExprMaskSet *pMaskSet,  /* Mapping from table indices to bitmaps */
+  Index *pIdx,            /* The index we are testing */
+  int base,               /* Cursor number for the table to be sorted */
+  ExprList *pOrderBy,     /* The ORDER BY clause */
+  int nEqCol,             /* Number of index columns with == constraints */
+  int *pbRev              /* Set to 1 if ORDER BY is DESC */
+){
+  int i, j;                       /* Loop counters */
+  int sortOrder = 0;              /* XOR of index and ORDER BY sort direction */
+  int nTerm;                      /* Number of ORDER BY terms */
+  struct ExprList_item *pTerm;    /* A term of the ORDER BY clause */
+  sqlite3 *db = pParse->db;
+
+  assert( pOrderBy!=0 );
+  nTerm = pOrderBy->nExpr;
+  assert( nTerm>0 );
+
+  /* Match terms of the ORDER BY clause against columns of
+  ** the index.
+  **
+  ** Note that indices have pIdx->nColumn regular columns plus
+  ** one additional column containing the rowid.  The rowid column
+  ** of the index is also allowed to match against the ORDER BY
+  ** clause.
+  */
+  for(i=j=0, pTerm=pOrderBy->a; j<nTerm && i<=pIdx->nColumn; i++){
+    Expr *pExpr;       /* The expression of the ORDER BY pTerm */
+    CollSeq *pColl;    /* The collating sequence of pExpr */
+    int termSortOrder; /* Sort order for this term */
+    int iColumn;       /* The i-th column of the index.  -1 for rowid */
+    int iSortOrder;    /* 1 for DESC, 0 for ASC on the i-th index term */
+    const char *zColl; /* Name of the collating sequence for i-th index term */
+
+    pExpr = pTerm->pExpr;
+    if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
+      /* Can not use an index sort on anything that is not a column in the
+      ** left-most table of the FROM clause */
+      break;
+    }
+    pColl = sqlite3ExprCollSeq(pParse, pExpr);
+    if( !pColl ){
+      pColl = db->pDfltColl;
+    }
+    if( i<pIdx->nColumn ){
+      iColumn = pIdx->aiColumn[i];
+      if( iColumn==pIdx->pTable->iPKey ){
+        iColumn = -1;
+      }
+      iSortOrder = pIdx->aSortOrder[i];
+      zColl = pIdx->azColl[i];
+    }else{
+      iColumn = -1;
+      iSortOrder = 0;
+      zColl = pColl->zName;
+    }
+    if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
+      /* Term j of the ORDER BY clause does not match column i of the index */
+      if( i<nEqCol ){
+        /* If an index column that is constrained by == fails to match an
+        ** ORDER BY term, that is OK.  Just ignore that column of the index
+        */
+        continue;
+      }else{
+        /* If an index column fails to match and is not constrained by ==
+        ** then the index cannot satisfy the ORDER BY constraint.
+        */
+        return 0;
+      }
+    }
+    assert( pIdx->aSortOrder!=0 );
+    assert( pTerm->sortOrder==0 || pTerm->sortOrder==1 );
+    assert( iSortOrder==0 || iSortOrder==1 );
+    termSortOrder = iSortOrder ^ pTerm->sortOrder;
+    if( i>nEqCol ){
+      if( termSortOrder!=sortOrder ){
+        /* Indices can only be used if all ORDER BY terms past the
+        ** equality constraints are all either DESC or ASC. */
+        return 0;
+      }
+    }else{
+      sortOrder = termSortOrder;
+    }
+    j++;
+    pTerm++;
+    if( iColumn<0 && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
+      /* If the indexed column is the primary key and everything matches
+      ** so far and none of the ORDER BY terms to the right reference other
+      ** tables in the join, then we are assured that the index can be used 
+      ** to sort because the primary key is unique and so none of the other
+      ** columns will make any difference
+      */
+      j = nTerm;
+    }
+  }
+
+  *pbRev = sortOrder!=0;
+  if( j>=nTerm ){
+    /* All terms of the ORDER BY clause are covered by this index so
+    ** this index can be used for sorting. */
+    return 1;
+  }
+  if( pIdx->onError!=OE_None && i==pIdx->nColumn
+      && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
+    /* All terms of this index match some prefix of the ORDER BY clause
+    ** and the index is UNIQUE and no terms on the tail of the ORDER BY
+    ** clause reference other tables in a join.  If this is all true then
+    ** the order by clause is superfluous. */
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Check table to see if the ORDER BY clause in pOrderBy can be satisfied
+** by sorting in order of ROWID.  Return true if so and set *pbRev to be
+** true for reverse ROWID and false for forward ROWID order.
+*/
+static int sortableByRowid(
+  int base,               /* Cursor number for table to be sorted */
+  ExprList *pOrderBy,     /* The ORDER BY clause */
+  ExprMaskSet *pMaskSet,  /* Mapping from tables to bitmaps */
+  int *pbRev              /* Set to 1 if ORDER BY is DESC */
+){
+  Expr *p;
+
+  assert( pOrderBy!=0 );
+  assert( pOrderBy->nExpr>0 );
+  p = pOrderBy->a[0].pExpr;
+  if( p->op==TK_COLUMN && p->iTable==base && p->iColumn==-1
+    && !referencesOtherTables(pOrderBy, pMaskSet, 1, base) ){
+    *pbRev = pOrderBy->a[0].sortOrder;
+    return 1;
+  }
+  return 0;
+}
+
+/*
+** Prepare a crude estimate of the logarithm of the input value.
+** The results need not be exact.  This is only used for estimating
+** the total cost of performing operatings with O(logN) or O(NlogN)
+** complexity.  Because N is just a guess, it is no great tragedy if
+** logN is a little off.
+*/
+static double estLog(double N){
+  double logN = 1;
+  double x = 10;
+  while( N>x ){
+    logN += 1;
+    x *= 10;
+  }
+  return logN;
+}
+
+/*
+** Two routines for printing the content of an sqlite3_index_info
+** structure.  Used for testing and debugging only.  If neither
+** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines
+** are no-ops.
+*/
+#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_DEBUG)
+static void TRACE_IDX_INPUTS(sqlite3_index_info *p){
+  int i;
+  if( !sqlite3_where_trace ) return;
+  for(i=0; i<p->nConstraint; i++){
+    sqlite3DebugPrintf("  constraint[%d]: col=%d termid=%d op=%d usabled=%d\n",
+       i,
+       p->aConstraint[i].iColumn,
+       p->aConstraint[i].iTermOffset,
+       p->aConstraint[i].op,
+       p->aConstraint[i].usable);
+  }
+  for(i=0; i<p->nOrderBy; i++){
+    sqlite3DebugPrintf("  orderby[%d]: col=%d desc=%d\n",
+       i,
+       p->aOrderBy[i].iColumn,
+       p->aOrderBy[i].desc);
+  }
+}
+static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){
+  int i;
+  if( !sqlite3_where_trace ) return;
+  for(i=0; i<p->nConstraint; i++){
+    sqlite3DebugPrintf("  usage[%d]: argvIdx=%d omit=%d\n",
+       i,
+       p->aConstraintUsage[i].argvIndex,
+       p->aConstraintUsage[i].omit);
+  }
+  sqlite3DebugPrintf("  idxNum=%d\n", p->idxNum);
+  sqlite3DebugPrintf("  idxStr=%s\n", p->idxStr);
+  sqlite3DebugPrintf("  orderByConsumed=%d\n", p->orderByConsumed);
+  sqlite3DebugPrintf("  estimatedCost=%g\n", p->estimatedCost);
+}
+#else
+#define TRACE_IDX_INPUTS(A)
+#define TRACE_IDX_OUTPUTS(A)
+#endif
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** Compute the best index for a virtual table.
+**
+** The best index is computed by the xBestIndex method of the virtual
+** table module.  This routine is really just a wrapper that sets up
+** the sqlite3_index_info structure that is used to communicate with
+** xBestIndex.
+**
+** In a join, this routine might be called multiple times for the
+** same virtual table.  The sqlite3_index_info structure is created
+** and initialized on the first invocation and reused on all subsequent
+** invocations.  The sqlite3_index_info structure is also used when
+** code is generated to access the virtual table.  The whereInfoDelete() 
+** routine takes care of freeing the sqlite3_index_info structure after
+** everybody has finished with it.
+*/
+static double bestVirtualIndex(
+  Parse *pParse,                 /* The parsing context */
+  WhereClause *pWC,              /* The WHERE clause */
+  struct SrcList_item *pSrc,     /* The FROM clause term to search */
+  Bitmask notReady,              /* Mask of cursors that are not available */
+  ExprList *pOrderBy,            /* The order by clause */
+  int orderByUsable,             /* True if we can potential sort */
+  sqlite3_index_info **ppIdxInfo /* Index information passed to xBestIndex */
+){
+  Table *pTab = pSrc->pTab;
+  sqlite3_index_info *pIdxInfo;
+  struct sqlite3_index_constraint *pIdxCons;
+  struct sqlite3_index_orderby *pIdxOrderBy;
+  struct sqlite3_index_constraint_usage *pUsage;
+  WhereTerm *pTerm;
+  int i, j;
+  int nOrderBy;
+  int rc;
+
+  /* If the sqlite3_index_info structure has not been previously
+  ** allocated and initialized for this virtual table, then allocate
+  ** and initialize it now
+  */
+  pIdxInfo = *ppIdxInfo;
+  if( pIdxInfo==0 ){
+    WhereTerm *pTerm;
+    int nTerm;
+    WHERETRACE(("Recomputing index info for %s...\n", pTab->zName));
+
+    /* Count the number of possible WHERE clause constraints referring
+    ** to this virtual table */
+    for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
+      if( pTerm->leftCursor != pSrc->iCursor ) continue;
+      if( pTerm->eOperator==WO_IN ) continue;
+      if( pTerm->eOperator==WO_ISNULL ) continue;
+      nTerm++;
+    }
+
+    /* If the ORDER BY clause contains only columns in the current 
+    ** virtual table then allocate space for the aOrderBy part of
+    ** the sqlite3_index_info structure.
+    */
+    nOrderBy = 0;
+    if( pOrderBy ){
+      for(i=0; i<pOrderBy->nExpr; i++){
+        Expr *pExpr = pOrderBy->a[i].pExpr;
+        if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
+      }
+      if( i==pOrderBy->nExpr ){
+        nOrderBy = pOrderBy->nExpr;
+      }
+    }
+
+    /* Allocate the sqlite3_index_info structure
+    */
+    pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
+                             + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
+                             + sizeof(*pIdxOrderBy)*nOrderBy );
+    if( pIdxInfo==0 ){
+      sqlite3ErrorMsg(pParse, "out of memory");
+      return 0.0;
+    }
+    *ppIdxInfo = pIdxInfo;
+
+    /* Initialize the structure.  The sqlite3_index_info structure contains
+    ** many fields that are declared "const" to prevent xBestIndex from
+    ** changing them.  We have to do some funky casting in order to
+    ** initialize those fields.
+    */
+    pIdxCons = (struct sqlite3_index_constraint*)&pIdxInfo[1];
+    pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm];
+    pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy];
+    *(int*)&pIdxInfo->nConstraint = nTerm;
+    *(int*)&pIdxInfo->nOrderBy = nOrderBy;
+    *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint = pIdxCons;
+    *(struct sqlite3_index_orderby**)&pIdxInfo->aOrderBy = pIdxOrderBy;
+    *(struct sqlite3_index_constraint_usage**)&pIdxInfo->aConstraintUsage =
+                                                                     pUsage;
+
+    for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
+      if( pTerm->leftCursor != pSrc->iCursor ) continue;
+      if( pTerm->eOperator==WO_IN ) continue;
+      if( pTerm->eOperator==WO_ISNULL ) continue;
+      pIdxCons[j].iColumn = pTerm->leftColumn;
+      pIdxCons[j].iTermOffset = i;
+      pIdxCons[j].op = pTerm->eOperator;
+      /* The direct assignment in the previous line is possible only because
+      ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical.  The
+      ** following asserts verify this fact. */
+      assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
+      assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
+      assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
+      assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
+      assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
+      assert( WO_MATCH==SQLITE_INDEX_CONSTRAINT_MATCH );
+      assert( pTerm->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) );
+      j++;
+    }
+    for(i=0; i<nOrderBy; i++){
+      Expr *pExpr = pOrderBy->a[i].pExpr;
+      pIdxOrderBy[i].iColumn = pExpr->iColumn;
+      pIdxOrderBy[i].desc = pOrderBy->a[i].sortOrder;
+    }
+  }
+
+  /* At this point, the sqlite3_index_info structure that pIdxInfo points
+  ** to will have been initialized, either during the current invocation or
+  ** during some prior invocation.  Now we just have to customize the
+  ** details of pIdxInfo for the current invocation and pass it to
+  ** xBestIndex.
+  */
+
+  /* The module name must be defined. Also, by this point there must
+  ** be a pointer to an sqlite3_vtab structure. Otherwise
+  ** sqlite3ViewGetColumnNames() would have picked up the error. 
+  */
+  assert( pTab->azModuleArg && pTab->azModuleArg[0] );
+  assert( pTab->pVtab );
+#if 0
+  if( pTab->pVtab==0 ){
+    sqlite3ErrorMsg(pParse, "undefined module %s for table %s",
+        pTab->azModuleArg[0], pTab->zName);
+    return 0.0;
+  }
+#endif
+
+  /* Set the aConstraint[].usable fields and initialize all 
+  ** output variables to zero.
+  **
+  ** aConstraint[].usable is true for constraints where the right-hand
+  ** side contains only references to tables to the left of the current
+  ** table.  In other words, if the constraint is of the form:
+  **
+  **           column = expr
+  **
+  ** and we are evaluating a join, then the constraint on column is 
+  ** only valid if all tables referenced in expr occur to the left
+  ** of the table containing column.
+  **
+  ** The aConstraints[] array contains entries for all constraints
+  ** on the current table.  That way we only have to compute it once
+  ** even though we might try to pick the best index multiple times.
+  ** For each attempt at picking an index, the order of tables in the
+  ** join might be different so we have to recompute the usable flag
+  ** each time.
+  */
+  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
+  pUsage = pIdxInfo->aConstraintUsage;
+  for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){
+    j = pIdxCons->iTermOffset;
+    pTerm = &pWC->a[j];
+    pIdxCons->usable =  (pTerm->prereqRight & notReady)==0;
+  }
+  memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint);
+  if( pIdxInfo->needToFreeIdxStr ){
+    sqlite3_free(pIdxInfo->idxStr);
+  }
+  pIdxInfo->idxStr = 0;
+  pIdxInfo->idxNum = 0;
+  pIdxInfo->needToFreeIdxStr = 0;
+  pIdxInfo->orderByConsumed = 0;
+  pIdxInfo->estimatedCost = SQLITE_BIG_DBL / 2.0;
+  nOrderBy = pIdxInfo->nOrderBy;
+  if( pIdxInfo->nOrderBy && !orderByUsable ){
+    *(int*)&pIdxInfo->nOrderBy = 0;
+  }
+
+  (void)sqlite3SafetyOff(pParse->db);
+  WHERETRACE(("xBestIndex for %s\n", pTab->zName));
+  TRACE_IDX_INPUTS(pIdxInfo);
+  rc = pTab->pVtab->pModule->xBestIndex(pTab->pVtab, pIdxInfo);
+  TRACE_IDX_OUTPUTS(pIdxInfo);
+  if( rc!=SQLITE_OK ){
+    if( rc==SQLITE_NOMEM ){
+      pParse->db->mallocFailed = 1;
+    }else {
+      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
+    }
+  }
+  (void)sqlite3SafetyOn(pParse->db);
+  *(int*)&pIdxInfo->nOrderBy = nOrderBy;
+
+  return pIdxInfo->estimatedCost;
+}
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+/*
+** Find the best index for accessing a particular table.  Return a pointer
+** to the index, flags that describe how the index should be used, the
+** number of equality constraints, and the "cost" for this index.
+**
+** The lowest cost index wins.  The cost is an estimate of the amount of
+** CPU and disk I/O need to process the request using the selected index.
+** Factors that influence cost include:
+**
+**    *  The estimated number of rows that will be retrieved.  (The
+**       fewer the better.)
+**
+**    *  Whether or not sorting must occur.
+**
+**    *  Whether or not there must be separate lookups in the
+**       index and in the main table.
+**
+*/
+static double bestIndex(
+  Parse *pParse,              /* The parsing context */
+  WhereClause *pWC,           /* The WHERE clause */
+  struct SrcList_item *pSrc,  /* The FROM clause term to search */
+  Bitmask notReady,           /* Mask of cursors that are not available */
+  ExprList *pOrderBy,         /* The order by clause */
+  Index **ppIndex,            /* Make *ppIndex point to the best index */
+  int *pFlags,                /* Put flags describing this choice in *pFlags */
+  int *pnEq                   /* Put the number of == or IN constraints here */
+){
+  WhereTerm *pTerm;
+  Index *bestIdx = 0;         /* Index that gives the lowest cost */
+  double lowestCost;          /* The cost of using bestIdx */
+  int bestFlags = 0;          /* Flags associated with bestIdx */
+  int bestNEq = 0;            /* Best value for nEq */
+  int iCur = pSrc->iCursor;   /* The cursor of the table to be accessed */
+  Index *pProbe;              /* An index we are evaluating */
+  int rev;                    /* True to scan in reverse order */
+  int flags;                  /* Flags associated with pProbe */
+  int nEq;                    /* Number of == or IN constraints */
+  int eqTermMask;             /* Mask of valid equality operators */
+  double cost;                /* Cost of using pProbe */
+
+  WHERETRACE(("bestIndex: tbl=%s notReady=%x\n", pSrc->pTab->zName, notReady));
+  lowestCost = SQLITE_BIG_DBL;
+  pProbe = pSrc->pTab->pIndex;
+
+  /* If the table has no indices and there are no terms in the where
+  ** clause that refer to the ROWID, then we will never be able to do
+  ** anything other than a full table scan on this table.  We might as
+  ** well put it first in the join order.  That way, perhaps it can be
+  ** referenced by other tables in the join.
+  */
+  if( pProbe==0 &&
+     findTerm(pWC, iCur, -1, 0, WO_EQ|WO_IN|WO_LT|WO_LE|WO_GT|WO_GE,0)==0 &&
+     (pOrderBy==0 || !sortableByRowid(iCur, pOrderBy, pWC->pMaskSet, &rev)) ){
+    *pFlags = 0;
+    *ppIndex = 0;
+    *pnEq = 0;
+    return 0.0;
+  }
+
+  /* Check for a rowid=EXPR or rowid IN (...) constraints
+  */
+  pTerm = findTerm(pWC, iCur, -1, notReady, WO_EQ|WO_IN, 0);
+  if( pTerm ){
+    Expr *pExpr;
+    *ppIndex = 0;
+    bestFlags = WHERE_ROWID_EQ;
+    if( pTerm->eOperator & WO_EQ ){
+      /* Rowid== is always the best pick.  Look no further.  Because only
+      ** a single row is generated, output is always in sorted order */
+      *pFlags = WHERE_ROWID_EQ | WHERE_UNIQUE;
+      *pnEq = 1;
+      WHERETRACE(("... best is rowid\n"));
+      return 0.0;
+    }else if( (pExpr = pTerm->pExpr)->pList!=0 ){
+      /* Rowid IN (LIST): cost is NlogN where N is the number of list
+      ** elements.  */
+      lowestCost = pExpr->pList->nExpr;
+      lowestCost *= estLog(lowestCost);
+    }else{
+      /* Rowid IN (SELECT): cost is NlogN where N is the number of rows
+      ** in the result of the inner select.  We have no way to estimate
+      ** that value so make a wild guess. */
+      lowestCost = 200;
+    }
+    WHERETRACE(("... rowid IN cost: %.9g\n", lowestCost));
+  }
+
+  /* Estimate the cost of a table scan.  If we do not know how many
+  ** entries are in the table, use 1 million as a guess.
+  */
+  cost = pProbe ? pProbe->aiRowEst[0] : 1000000;
+  WHERETRACE(("... table scan base cost: %.9g\n", cost));
+  flags = WHERE_ROWID_RANGE;
+
+  /* Check for constraints on a range of rowids in a table scan.
+  */
+  pTerm = findTerm(pWC, iCur, -1, notReady, WO_LT|WO_LE|WO_GT|WO_GE, 0);
+  if( pTerm ){
+    if( findTerm(pWC, iCur, -1, notReady, WO_LT|WO_LE, 0) ){
+      flags |= WHERE_TOP_LIMIT;
+      cost /= 3;  /* Guess that rowid<EXPR eliminates two-thirds or rows */
+    }
+    if( findTerm(pWC, iCur, -1, notReady, WO_GT|WO_GE, 0) ){
+      flags |= WHERE_BTM_LIMIT;
+      cost /= 3;  /* Guess that rowid>EXPR eliminates two-thirds of rows */
+    }
+    WHERETRACE(("... rowid range reduces cost to %.9g\n", cost));
+  }else{
+    flags = 0;
+  }
+
+  /* If the table scan does not satisfy the ORDER BY clause, increase
+  ** the cost by NlogN to cover the expense of sorting. */
+  if( pOrderBy ){
+    if( sortableByRowid(iCur, pOrderBy, pWC->pMaskSet, &rev) ){
+      flags |= WHERE_ORDERBY|WHERE_ROWID_RANGE;
+      if( rev ){
+        flags |= WHERE_REVERSE;
+      }
+    }else{
+      cost += cost*estLog(cost);
+      WHERETRACE(("... sorting increases cost to %.9g\n", cost));
+    }
+  }
+  if( cost<lowestCost ){
+    lowestCost = cost;
+    bestFlags = flags;
+  }
+
+  /* If the pSrc table is the right table of a LEFT JOIN then we may not
+  ** use an index to satisfy IS NULL constraints on that table.  This is
+  ** because columns might end up being NULL if the table does not match -
+  ** a circumstance which the index cannot help us discover.  Ticket #2177.
+  */
+  if( (pSrc->jointype & JT_LEFT)!=0 ){
+    eqTermMask = WO_EQ|WO_IN;
+  }else{
+    eqTermMask = WO_EQ|WO_IN|WO_ISNULL;
+  }
+
+  /* Look at each index.
+  */
+  for(; pProbe; pProbe=pProbe->pNext){
+    int i;                       /* Loop counter */
+    double inMultiplier = 1;
+
+    WHERETRACE(("... index %s:\n", pProbe->zName));
+
+    /* Count the number of columns in the index that are satisfied
+    ** by x=EXPR constraints or x IN (...) constraints.
+    */
+    flags = 0;
+    for(i=0; i<pProbe->nColumn; i++){
+      int j = pProbe->aiColumn[i];
+      pTerm = findTerm(pWC, iCur, j, notReady, eqTermMask, pProbe);
+      if( pTerm==0 ) break;
+      flags |= WHERE_COLUMN_EQ;
+      if( pTerm->eOperator & WO_IN ){
+        Expr *pExpr = pTerm->pExpr;
+        flags |= WHERE_COLUMN_IN;
+        if( pExpr->pSelect!=0 ){
+          inMultiplier *= 25;
+        }else if( pExpr->pList!=0 ){
+          inMultiplier *= pExpr->pList->nExpr + 1;
+        }
+      }
+    }
+    cost = pProbe->aiRowEst[i] * inMultiplier * estLog(inMultiplier);
+    nEq = i;
+    if( pProbe->onError!=OE_None && (flags & WHERE_COLUMN_IN)==0
+         && nEq==pProbe->nColumn ){
+      flags |= WHERE_UNIQUE;
+    }
+    WHERETRACE(("...... nEq=%d inMult=%.9g cost=%.9g\n",nEq,inMultiplier,cost));
+
+    /* Look for range constraints
+    */
+    if( nEq<pProbe->nColumn ){
+      int j = pProbe->aiColumn[nEq];
+      pTerm = findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE|WO_GT|WO_GE, pProbe);
+      if( pTerm ){
+        flags |= WHERE_COLUMN_RANGE;
+        if( findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE, pProbe) ){
+          flags |= WHERE_TOP_LIMIT;
+          cost /= 3;
+        }
+        if( findTerm(pWC, iCur, j, notReady, WO_GT|WO_GE, pProbe) ){
+          flags |= WHERE_BTM_LIMIT;
+          cost /= 3;
+        }
+        WHERETRACE(("...... range reduces cost to %.9g\n", cost));
+      }
+    }
+
+    /* Add the additional cost of sorting if that is a factor.
+    */
+    if( pOrderBy ){
+      if( (flags & WHERE_COLUMN_IN)==0 &&
+           isSortingIndex(pParse,pWC->pMaskSet,pProbe,iCur,pOrderBy,nEq,&rev) ){
+        if( flags==0 ){
+          flags = WHERE_COLUMN_RANGE;
+        }
+        flags |= WHERE_ORDERBY;
+        if( rev ){
+          flags |= WHERE_REVERSE;
+        }
+      }else{
+        cost += cost*estLog(cost);
+        WHERETRACE(("...... orderby increases cost to %.9g\n", cost));
+      }
+    }
+
+    /* Check to see if we can get away with using just the index without
+    ** ever reading the table.  If that is the case, then halve the
+    ** cost of this index.
+    */
+    if( flags && pSrc->colUsed < (((Bitmask)1)<<(BMS-1)) ){
+      Bitmask m = pSrc->colUsed;
+      int j;
+      for(j=0; j<pProbe->nColumn; j++){
+        int x = pProbe->aiColumn[j];
+        if( x<BMS-1 ){
+          m &= ~(((Bitmask)1)<<x);
+        }
+      }
+      if( m==0 ){
+        flags |= WHERE_IDX_ONLY;
+        cost /= 2;
+        WHERETRACE(("...... idx-only reduces cost to %.9g\n", cost));
+      }
+    }
+
+    /* If this index has achieved the lowest cost so far, then use it.
+    */
+    if( flags && cost < lowestCost ){
+      bestIdx = pProbe;
+      lowestCost = cost;
+      bestFlags = flags;
+      bestNEq = nEq;
+    }
+  }
+
+  /* Report the best result
+  */
+  *ppIndex = bestIdx;
+  WHERETRACE(("best index is %s, cost=%.9g, flags=%x, nEq=%d\n",
+        bestIdx ? bestIdx->zName : "(none)", lowestCost, bestFlags, bestNEq));
+  *pFlags = bestFlags | eqTermMask;
+  *pnEq = bestNEq;
+  return lowestCost;
+}
+
+
+/*
+** Disable a term in the WHERE clause.  Except, do not disable the term
+** if it controls a LEFT OUTER JOIN and it did not originate in the ON
+** or USING clause of that join.
+**
+** Consider the term t2.z='ok' in the following queries:
+**
+**   (1)  SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok'
+**   (2)  SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok'
+**   (3)  SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok'
+**
+** The t2.z='ok' is disabled in the in (2) because it originates
+** in the ON clause.  The term is disabled in (3) because it is not part
+** of a LEFT OUTER JOIN.  In (1), the term is not disabled.
+**
+** Disabling a term causes that term to not be tested in the inner loop
+** of the join.  Disabling is an optimization.  When terms are satisfied
+** by indices, we disable them to prevent redundant tests in the inner
+** loop.  We would get the correct results if nothing were ever disabled,
+** but joins might run a little slower.  The trick is to disable as much
+** as we can without disabling too much.  If we disabled in (1), we'd get
+** the wrong answer.  See ticket #813.
+*/
+static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
+  if( pTerm
+      && (pTerm->flags & TERM_CODED)==0
+      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
+  ){
+    pTerm->flags |= TERM_CODED;
+    if( pTerm->iParent>=0 ){
+      WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
+      if( (--pOther->nChild)==0 ){
+        disableTerm(pLevel, pOther);
+      }
+    }
+  }
+}
+
+/*
+** Generate code that builds a probe for an index.
+**
+** There should be nColumn values on the stack.  The index
+** to be probed is pIdx.  Pop the values from the stack and
+** replace them all with a single record that is the index
+** problem.
+*/
+static void buildIndexProbe(
+  Vdbe *v,        /* Generate code into this VM */
+  int nColumn,    /* The number of columns to check for NULL */
+  Index *pIdx,    /* Index that we will be searching */
+  int regSrc,     /* Take values from this register */
+  int regDest     /* Write the result into this register */
+){
+  assert( regSrc>0 );
+  assert( regDest>0 );
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regSrc, nColumn, regDest);
+  sqlite3IndexAffinityStr(v, pIdx);
+}
+
+
+/*
+** Generate code for a single equality term of the WHERE clause.  An equality
+** term can be either X=expr or X IN (...).   pTerm is the term to be 
+** coded.
+**
+** The current value for the constraint is left in register iReg.
+**
+** For a constraint of the form X=expr, the expression is evaluated and its
+** result is left on the stack.  For constraints of the form X IN (...)
+** this routine sets up a loop that will iterate over all values of X.
+*/
+static void codeEqualityTerm(
+  Parse *pParse,      /* The parsing context */
+  WhereTerm *pTerm,   /* The term of the WHERE clause to be coded */
+  WhereLevel *pLevel, /* When level of the FROM clause we are working on */
+  int iReg            /* Leave results in this register */
+){
+  Expr *pX = pTerm->pExpr;
+  Vdbe *v = pParse->pVdbe;
+
+  assert( iReg>0 && iReg<=pParse->nMem );
+  if( pX->op==TK_EQ ){
+    sqlite3ExprCode(pParse, pX->pRight, iReg);
+  }else if( pX->op==TK_ISNULL ){
+    sqlite3VdbeAddOp2(v, OP_Null, 0, iReg);
+#ifndef SQLITE_OMIT_SUBQUERY
+  }else{
+    int eType;
+    int iTab;
+    struct InLoop *pIn;
+
+    assert( pX->op==TK_IN );
+    eType = sqlite3FindInIndex(pParse, pX, 1);
+    iTab = pX->iTable;
+    sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
+    VdbeComment((v, "%.*s", pX->span.n, pX->span.z));
+    if( pLevel->nIn==0 ){
+      pLevel->nxt = sqlite3VdbeMakeLabel(v);
+    }
+    pLevel->nIn++;
+    pLevel->aInLoop = sqlite3DbReallocOrFree(pParse->db, pLevel->aInLoop,
+                                    sizeof(pLevel->aInLoop[0])*pLevel->nIn);
+    pIn = pLevel->aInLoop;
+    if( pIn ){
+      pIn += pLevel->nIn - 1;
+      pIn->iCur = iTab;
+      if( eType==IN_INDEX_ROWID ){
+        pIn->topAddr = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iReg);
+      }else{
+        pIn->topAddr = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg);
+      }
+      sqlite3VdbeAddOp1(v, OP_IsNull, iReg);
+    }else{
+      pLevel->nIn = 0;
+    }
+#endif
+  }
+  disableTerm(pLevel, pTerm);
+}
+
+/*
+** Generate code that will evaluate all == and IN constraints for an
+** index.  The values for all constraints are left on the stack.
+**
+** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c).
+** Suppose the WHERE clause is this:  a==5 AND b IN (1,2,3) AND c>5 AND c<10
+** The index has as many as three equality constraints, but in this
+** example, the third "c" value is an inequality.  So only two 
+** constraints are coded.  This routine will generate code to evaluate
+** a==5 and b IN (1,2,3).  The current values for a and b will be left
+** on the stack - a is the deepest and b the shallowest.
+**
+** In the example above nEq==2.  But this subroutine works for any value
+** of nEq including 0.  If nEq==0, this routine is nearly a no-op.
+** The only thing it does is allocate the pLevel->iMem memory cell.
+**
+** This routine always allocates at least one memory cell and puts
+** the address of that memory cell in pLevel->iMem.  The code that
+** calls this routine will use pLevel->iMem to store the termination
+** key value of the loop.  If one or more IN operators appear, then
+** this routine allocates an additional nEq memory cells for internal
+** use.
+*/
+static int codeAllEqualityTerms(
+  Parse *pParse,        /* Parsing context */
+  WhereLevel *pLevel,   /* Which nested loop of the FROM we are coding */
+  WhereClause *pWC,     /* The WHERE clause */
+  Bitmask notReady,     /* Which parts of FROM have not yet been coded */
+  int nExtraReg         /* Number of extra registers to allocate */
+){
+  int nEq = pLevel->nEq;        /* The number of == or IN constraints to code */
+  Vdbe *v = pParse->pVdbe;      /* The virtual machine under construction */
+  Index *pIdx = pLevel->pIdx;   /* The index being used for this loop */
+  int iCur = pLevel->iTabCur;   /* The cursor of the table */
+  WhereTerm *pTerm;             /* A single constraint term */
+  int j;                        /* Loop counter */
+  int regBase;                  /* Base register */
+
+  /* Figure out how many memory cells we will need then allocate them.
+  ** We always need at least one used to store the loop terminator
+  ** value.  If there are IN operators we'll need one for each == or
+  ** IN constraint.
+  */
+  pLevel->iMem = pParse->nMem + 1;
+  regBase = pParse->nMem + 2;
+  pParse->nMem += pLevel->nEq + 2 + nExtraReg;
+
+  /* Evaluate the equality constraints
+  */
+  assert( pIdx->nColumn>=nEq );
+  for(j=0; j<nEq; j++){
+    int k = pIdx->aiColumn[j];
+    pTerm = findTerm(pWC, iCur, k, notReady, pLevel->flags, pIdx);
+    if( pTerm==0 ) break;
+    assert( (pTerm->flags & TERM_CODED)==0 );
+    codeEqualityTerm(pParse, pTerm, pLevel, regBase+j);
+    if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){
+      sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->brk);
+    }
+  }
+  return regBase;
+}
+
+#if defined(SQLITE_TEST)
+/*
+** The following variable holds a text description of query plan generated
+** by the most recent call to sqlite3WhereBegin().  Each call to WhereBegin
+** overwrites the previous.  This information is used for testing and
+** analysis only.
+*/
+char sqlite3_query_plan[BMS*2*40];  /* Text of the join */
+static int nQPlan = 0;              /* Next free slow in _query_plan[] */
+
+#endif /* SQLITE_TEST */
+
+
+/*
+** Free a WhereInfo structure
+*/
+static void whereInfoFree(WhereInfo *pWInfo){
+  if( pWInfo ){
+    int i;
+    for(i=0; i<pWInfo->nLevel; i++){
+      sqlite3_index_info *pInfo = pWInfo->a[i].pIdxInfo;
+      if( pInfo ){
+        assert( pInfo->needToFreeIdxStr==0 );
+        sqlite3_free(pInfo);
+      }
+    }
+    sqlite3_free(pWInfo);
+  }
+}
+
+
+/*
+** Generate the beginning of the loop used for WHERE clause processing.
+** The return value is a pointer to an opaque structure that contains
+** information needed to terminate the loop.  Later, the calling routine
+** should invoke sqlite3WhereEnd() with the return value of this function
+** in order to complete the WHERE clause processing.
+**
+** If an error occurs, this routine returns NULL.
+**
+** The basic idea is to do a nested loop, one loop for each table in
+** the FROM clause of a select.  (INSERT and UPDATE statements are the
+** same as a SELECT with only a single table in the FROM clause.)  For
+** example, if the SQL is this:
+**
+**       SELECT * FROM t1, t2, t3 WHERE ...;
+**
+** Then the code generated is conceptually like the following:
+**
+**      foreach row1 in t1 do       \    Code generated
+**        foreach row2 in t2 do      |-- by sqlite3WhereBegin()
+**          foreach row3 in t3 do   /
+**            ...
+**          end                     \    Code generated
+**        end                        |-- by sqlite3WhereEnd()
+**      end                         /
+**
+** Note that the loops might not be nested in the order in which they
+** appear in the FROM clause if a different order is better able to make
+** use of indices.  Note also that when the IN operator appears in
+** the WHERE clause, it might result in additional nested loops for
+** scanning through all values on the right-hand side of the IN.
+**
+** There are Btree cursors associated with each table.  t1 uses cursor
+** number pTabList->a[0].iCursor.  t2 uses the cursor pTabList->a[1].iCursor.
+** And so forth.  This routine generates code to open those VDBE cursors
+** and sqlite3WhereEnd() generates the code to close them.
+**
+** The code that sqlite3WhereBegin() generates leaves the cursors named
+** in pTabList pointing at their appropriate entries.  The [...] code
+** can use OP_Column and OP_Rowid opcodes on these cursors to extract
+** data from the various tables of the loop.
+**
+** If the WHERE clause is empty, the foreach loops must each scan their
+** entire tables.  Thus a three-way join is an O(N^3) operation.  But if
+** the tables have indices and there are terms in the WHERE clause that
+** refer to those indices, a complete table scan can be avoided and the
+** code will run much faster.  Most of the work of this routine is checking
+** to see if there are indices that can be used to speed up the loop.
+**
+** Terms of the WHERE clause are also used to limit which rows actually
+** make it to the "..." in the middle of the loop.  After each "foreach",
+** terms of the WHERE clause that use only terms in that loop and outer
+** loops are evaluated and if false a jump is made around all subsequent
+** inner loops (or around the "..." if the test occurs within the inner-
+** most loop)
+**
+** OUTER JOINS
+**
+** An outer join of tables t1 and t2 is conceptally coded as follows:
+**
+**    foreach row1 in t1 do
+**      flag = 0
+**      foreach row2 in t2 do
+**        start:
+**          ...
+**          flag = 1
+**      end
+**      if flag==0 then
+**        move the row2 cursor to a null row
+**        goto start
+**      fi
+**    end
+**
+** ORDER BY CLAUSE PROCESSING
+**
+** *ppOrderBy is a pointer to the ORDER BY clause of a SELECT statement,
+** if there is one.  If there is no ORDER BY clause or if this routine
+** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL.
+**
+** If an index can be used so that the natural output order of the table
+** scan is correct for the ORDER BY clause, then that index is used and
+** *ppOrderBy is set to NULL.  This is an optimization that prevents an
+** unnecessary sort of the result set if an index appropriate for the
+** ORDER BY clause already exists.
+**
+** If the where clause loops cannot be arranged to provide the correct
+** output order, then the *ppOrderBy is unchanged.
+*/
+WhereInfo *sqlite3WhereBegin(
+  Parse *pParse,        /* The parser context */
+  SrcList *pTabList,    /* A list of all tables to be scanned */
+  Expr *pWhere,         /* The WHERE clause */
+  ExprList **ppOrderBy, /* An ORDER BY clause, or NULL */
+  u8 obflag             /* One of ORDERBY_MIN, ORDERBY_MAX or ORDERBY_NORMAL */
+){
+  int i;                     /* Loop counter */
+  WhereInfo *pWInfo;         /* Will become the return value of this function */
+  Vdbe *v = pParse->pVdbe;   /* The virtual database engine */
+  int brk, cont = 0;         /* Addresses used during code generation */
+  Bitmask notReady;          /* Cursors that are not yet positioned */
+  WhereTerm *pTerm;          /* A single term in the WHERE clause */
+  ExprMaskSet maskSet;       /* The expression mask set */
+  WhereClause wc;            /* The WHERE clause is divided into these terms */
+  struct SrcList_item *pTabItem;  /* A single entry from pTabList */
+  WhereLevel *pLevel;             /* A single level in the pWInfo list */
+  int iFrom;                      /* First unused FROM clause element */
+  int andFlags;              /* AND-ed combination of all wc.a[].flags */
+  sqlite3 *db;               /* Database connection */
+  ExprList *pOrderBy = 0;
+
+  /* The number of tables in the FROM clause is limited by the number of
+  ** bits in a Bitmask 
+  */
+  if( pTabList->nSrc>BMS ){
+    sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
+    return 0;
+  }
+
+  if( ppOrderBy ){
+    pOrderBy = *ppOrderBy;
+  }
+
+  /* Split the WHERE clause into separate subexpressions where each
+  ** subexpression is separated by an AND operator.
+  */
+  initMaskSet(&maskSet);
+  whereClauseInit(&wc, pParse, &maskSet);
+  whereSplit(&wc, pWhere, TK_AND);
+    
+  /* Allocate and initialize the WhereInfo structure that will become the
+  ** return value.
+  */
+  db = pParse->db;
+  pWInfo = sqlite3DbMallocZero(db,  
+                      sizeof(WhereInfo) + pTabList->nSrc*sizeof(WhereLevel));
+  if( db->mallocFailed ){
+    goto whereBeginNoMem;
+  }
+  pWInfo->nLevel = pTabList->nSrc;
+  pWInfo->pParse = pParse;
+  pWInfo->pTabList = pTabList;
+  pWInfo->iBreak = sqlite3VdbeMakeLabel(v);
+
+  /* Special case: a WHERE clause that is constant.  Evaluate the
+  ** expression and either jump over all of the code or fall thru.
+  */
+  if( pWhere && (pTabList->nSrc==0 || sqlite3ExprIsConstantNotJoin(pWhere)) ){
+    sqlite3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLITE_JUMPIFNULL);
+    pWhere = 0;
+  }
+
+  /* Analyze all of the subexpressions.  Note that exprAnalyze() might
+  ** add new virtual terms onto the end of the WHERE clause.  We do not
+  ** want to analyze these virtual terms, so start analyzing at the end
+  ** and work forward so that the added virtual terms are never processed.
+  */
+  for(i=0; i<pTabList->nSrc; i++){
+    createMask(&maskSet, pTabList->a[i].iCursor);
+  }
+  exprAnalyzeAll(pTabList, &wc);
+  if( db->mallocFailed ){
+    goto whereBeginNoMem;
+  }
+
+  /* Chose the best index to use for each table in the FROM clause.
+  **
+  ** This loop fills in the following fields:
+  **
+  **   pWInfo->a[].pIdx      The index to use for this level of the loop.
+  **   pWInfo->a[].flags     WHERE_xxx flags associated with pIdx
+  **   pWInfo->a[].nEq       The number of == and IN constraints
+  **   pWInfo->a[].iFrom     When term of the FROM clause is being coded
+  **   pWInfo->a[].iTabCur   The VDBE cursor for the database table
+  **   pWInfo->a[].iIdxCur   The VDBE cursor for the index
+  **
+  ** This loop also figures out the nesting order of tables in the FROM
+  ** clause.
+  */
+  notReady = ~(Bitmask)0;
+  pTabItem = pTabList->a;
+  pLevel = pWInfo->a;
+  andFlags = ~0;
+  WHERETRACE(("*** Optimizer Start ***\n"));
+  for(i=iFrom=0, pLevel=pWInfo->a; i<pTabList->nSrc; i++, pLevel++){
+    Index *pIdx;                /* Index for FROM table at pTabItem */
+    int flags;                  /* Flags asssociated with pIdx */
+    int nEq;                    /* Number of == or IN constraints */
+    double cost;                /* The cost for pIdx */
+    int j;                      /* For looping over FROM tables */
+    Index *pBest = 0;           /* The best index seen so far */
+    int bestFlags = 0;          /* Flags associated with pBest */
+    int bestNEq = 0;            /* nEq associated with pBest */
+    double lowestCost;          /* Cost of the pBest */
+    int bestJ = 0;              /* The value of j */
+    Bitmask m;                  /* Bitmask value for j or bestJ */
+    int once = 0;               /* True when first table is seen */
+    sqlite3_index_info *pIndex; /* Current virtual index */
+
+    lowestCost = SQLITE_BIG_DBL;
+    for(j=iFrom, pTabItem=&pTabList->a[j]; j<pTabList->nSrc; j++, pTabItem++){
+      int doNotReorder;  /* True if this table should not be reordered */
+
+      doNotReorder =  (pTabItem->jointype & (JT_LEFT|JT_CROSS))!=0;
+      if( once && doNotReorder ) break;
+      m = getMask(&maskSet, pTabItem->iCursor);
+      if( (m & notReady)==0 ){
+        if( j==iFrom ) iFrom++;
+        continue;
+      }
+      assert( pTabItem->pTab );
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      if( IsVirtual(pTabItem->pTab) ){
+        sqlite3_index_info **ppIdxInfo = &pWInfo->a[j].pIdxInfo;
+        cost = bestVirtualIndex(pParse, &wc, pTabItem, notReady,
+                                ppOrderBy ? *ppOrderBy : 0, i==0,
+                                ppIdxInfo);
+        flags = WHERE_VIRTUALTABLE;
+        pIndex = *ppIdxInfo;
+        if( pIndex && pIndex->orderByConsumed ){
+          flags = WHERE_VIRTUALTABLE | WHERE_ORDERBY;
+        }
+        pIdx = 0;
+        nEq = 0;
+        if( (SQLITE_BIG_DBL/2.0)<cost ){
+          /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the
+          ** inital value of lowestCost in this loop. If it is, then
+          ** the (cost<lowestCost) test below will never be true and
+          ** pLevel->pBestIdx never set.
+          */ 
+          cost = (SQLITE_BIG_DBL/2.0);
+        }
+      }else 
+#endif
+      {
+        cost = bestIndex(pParse, &wc, pTabItem, notReady,
+                         (i==0 && ppOrderBy) ? *ppOrderBy : 0,
+                         &pIdx, &flags, &nEq);
+        pIndex = 0;
+      }
+      if( cost<lowestCost ){
+        once = 1;
+        lowestCost = cost;
+        pBest = pIdx;
+        bestFlags = flags;
+        bestNEq = nEq;
+        bestJ = j;
+        pLevel->pBestIdx = pIndex;
+      }
+      if( doNotReorder ) break;
+    }
+    WHERETRACE(("*** Optimizer choose table %d for loop %d\n", bestJ,
+           pLevel-pWInfo->a));
+    if( (bestFlags & WHERE_ORDERBY)!=0 ){
+      *ppOrderBy = 0;
+    }
+    andFlags &= bestFlags;
+    pLevel->flags = bestFlags;
+    pLevel->pIdx = pBest;
+    pLevel->nEq = bestNEq;
+    pLevel->aInLoop = 0;
+    pLevel->nIn = 0;
+    if( pBest ){
+      pLevel->iIdxCur = pParse->nTab++;
+    }else{
+      pLevel->iIdxCur = -1;
+    }
+    notReady &= ~getMask(&maskSet, pTabList->a[bestJ].iCursor);
+    pLevel->iFrom = bestJ;
+  }
+  WHERETRACE(("*** Optimizer Finished ***\n"));
+
+  /* If the total query only selects a single row, then the ORDER BY
+  ** clause is irrelevant.
+  */
+  if( (andFlags & WHERE_UNIQUE)!=0 && ppOrderBy ){
+    *ppOrderBy = 0;
+  }
+
+  /* Open all tables in the pTabList and any indices selected for
+  ** searching those tables.
+  */
+  sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
+  for(i=0, pLevel=pWInfo->a; i<pTabList->nSrc; i++, pLevel++){
+    Table *pTab;     /* Table to open */
+    Index *pIx;      /* Index used to access pTab (if any) */
+    int iDb;         /* Index of database containing table/index */
+    int iIdxCur = pLevel->iIdxCur;
+
+#ifndef SQLITE_OMIT_EXPLAIN
+    if( pParse->explain==2 ){
+      char *zMsg;
+      struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
+      zMsg = sqlite3MPrintf(db, "TABLE %s", pItem->zName);
+      if( pItem->zAlias ){
+        zMsg = sqlite3MPrintf(db, "%z AS %s", zMsg, pItem->zAlias);
+      }
+      if( (pIx = pLevel->pIdx)!=0 ){
+        zMsg = sqlite3MPrintf(db, "%z WITH INDEX %s", zMsg, pIx->zName);
+      }else if( pLevel->flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
+        zMsg = sqlite3MPrintf(db, "%z USING PRIMARY KEY", zMsg);
+      }
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+      else if( pLevel->pBestIdx ){
+        sqlite3_index_info *pBestIdx = pLevel->pBestIdx;
+        zMsg = sqlite3MPrintf(db, "%z VIRTUAL TABLE INDEX %d:%s", zMsg,
+                    pBestIdx->idxNum, pBestIdx->idxStr);
+      }
+#endif
+      if( pLevel->flags & WHERE_ORDERBY ){
+        zMsg = sqlite3MPrintf(db, "%z ORDER BY", zMsg);
+      }
+      sqlite3VdbeAddOp4(v, OP_Explain, i, pLevel->iFrom, 0, zMsg, P4_DYNAMIC);
+    }
+#endif /* SQLITE_OMIT_EXPLAIN */
+    pTabItem = &pTabList->a[pLevel->iFrom];
+    pTab = pTabItem->pTab;
+    iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
+    if( pTab->isEphem || pTab->pSelect ) continue;
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( pLevel->pBestIdx ){
+      int iCur = pTabItem->iCursor;
+      sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0,
+                        (const char*)pTab->pVtab, P4_VTAB);
+    }else
+#endif
+    if( (pLevel->flags & WHERE_IDX_ONLY)==0 ){
+      sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, OP_OpenRead);
+      if( pTab->nCol<(sizeof(Bitmask)*8) ){
+        Bitmask b = pTabItem->colUsed;
+        int n = 0;
+        for(; b; b=b>>1, n++){}
+        sqlite3VdbeChangeP2(v, sqlite3VdbeCurrentAddr(v)-1, n);
+        assert( n<=pTab->nCol );
+      }
+    }else{
+      sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
+    }
+    pLevel->iTabCur = pTabItem->iCursor;
+    if( (pIx = pLevel->pIdx)!=0 ){
+      KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx);
+      assert( pIx->pSchema==pTab->pSchema );
+      sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIx->tnum, iDb,
+                        (char*)pKey, P4_KEYINFO_HANDOFF);
+      VdbeComment((v, "%s", pIx->zName));
+      sqlite3VdbeAddOp2(v, OP_SetNumColumns, iIdxCur, pIx->nColumn+1);
+    }
+    sqlite3CodeVerifySchema(pParse, iDb);
+  }
+  pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
+
+  /* Generate the code to do the search.  Each iteration of the for
+  ** loop below generates code for a single nested loop of the VM
+  ** program.
+  */
+  notReady = ~(Bitmask)0;
+  for(i=0, pLevel=pWInfo->a; i<pTabList->nSrc; i++, pLevel++){
+    int j;
+    int iCur = pTabItem->iCursor;  /* The VDBE cursor for the table */
+    Index *pIdx;       /* The index we will be using */
+    int nxt;           /* Where to jump to continue with the next IN case */
+    int iIdxCur;       /* The VDBE cursor for the index */
+    int omitTable;     /* True if we use the index only */
+    int bRev;          /* True if we need to scan in reverse order */
+
+    pTabItem = &pTabList->a[pLevel->iFrom];
+    iCur = pTabItem->iCursor;
+    pIdx = pLevel->pIdx;
+    iIdxCur = pLevel->iIdxCur;
+    bRev = (pLevel->flags & WHERE_REVERSE)!=0;
+    omitTable = (pLevel->flags & WHERE_IDX_ONLY)!=0;
+
+    /* Create labels for the "break" and "continue" instructions
+    ** for the current loop.  Jump to brk to break out of a loop.
+    ** Jump to cont to go immediately to the next iteration of the
+    ** loop.
+    **
+    ** When there is an IN operator, we also have a "nxt" label that
+    ** means to continue with the next IN value combination.  When
+    ** there are no IN operators in the constraints, the "nxt" label
+    ** is the same as "brk".
+    */
+    brk = pLevel->brk = pLevel->nxt = sqlite3VdbeMakeLabel(v);
+    cont = pLevel->cont = sqlite3VdbeMakeLabel(v);
+
+    /* If this is the right table of a LEFT OUTER JOIN, allocate and
+    ** initialize a memory cell that records if this table matches any
+    ** row of the left table of the join.
+    */
+    if( pLevel->iFrom>0 && (pTabItem[0].jointype & JT_LEFT)!=0 ){
+      pLevel->iLeftJoin = ++pParse->nMem;
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
+      VdbeComment((v, "init LEFT JOIN no-match flag"));
+    }
+
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+    if( pLevel->pBestIdx ){
+      /* Case 0:  The table is a virtual-table.  Use the VFilter and VNext
+      **          to access the data.
+      */
+      int j;
+      int iReg;   /* P3 Value for OP_VFilter */
+      sqlite3_index_info *pBestIdx = pLevel->pBestIdx;
+      int nConstraint = pBestIdx->nConstraint;
+      struct sqlite3_index_constraint_usage *aUsage =
+                                                  pBestIdx->aConstraintUsage;
+      const struct sqlite3_index_constraint *aConstraint =
+                                                  pBestIdx->aConstraint;
+
+      iReg = sqlite3GetTempRange(pParse, nConstraint+2);
+      for(j=1; j<=nConstraint; j++){
+        int k;
+        for(k=0; k<nConstraint; k++){
+          if( aUsage[k].argvIndex==j ){
+            int iTerm = aConstraint[k].iTermOffset;
+            sqlite3ExprCode(pParse, wc.a[iTerm].pExpr->pRight, iReg+j+1);
+            break;
+          }
+        }
+        if( k==nConstraint ) break;
+      }
+      sqlite3VdbeAddOp2(v, OP_Integer, pBestIdx->idxNum, iReg);
+      sqlite3VdbeAddOp2(v, OP_Integer, j-1, iReg+1);
+      sqlite3VdbeAddOp4(v, OP_VFilter, iCur, brk, iReg, pBestIdx->idxStr,
+                        pBestIdx->needToFreeIdxStr ? P4_MPRINTF : P4_STATIC);
+      sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
+      pBestIdx->needToFreeIdxStr = 0;
+      for(j=0; j<pBestIdx->nConstraint; j++){
+        if( aUsage[j].omit ){
+          int iTerm = aConstraint[j].iTermOffset;
+          disableTerm(pLevel, &wc.a[iTerm]);
+        }
+      }
+      pLevel->op = OP_VNext;
+      pLevel->p1 = iCur;
+      pLevel->p2 = sqlite3VdbeCurrentAddr(v);
+    }else
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
+
+    if( pLevel->flags & WHERE_ROWID_EQ ){
+      /* Case 1:  We can directly reference a single row using an
+      **          equality comparison against the ROWID field.  Or
+      **          we reference multiple rows using a "rowid IN (...)"
+      **          construct.
+      */
+      int r1;
+      pTerm = findTerm(&wc, iCur, -1, notReady, WO_EQ|WO_IN, 0);
+      assert( pTerm!=0 );
+      assert( pTerm->pExpr!=0 );
+      assert( pTerm->leftCursor==iCur );
+      assert( omitTable==0 );
+      r1 = sqlite3GetTempReg(pParse);
+      codeEqualityTerm(pParse, pTerm, pLevel, r1);
+      nxt = pLevel->nxt;
+      sqlite3VdbeAddOp3(v, OP_MustBeInt, r1, nxt, 1);
+      sqlite3VdbeAddOp3(v, OP_NotExists, iCur, nxt, r1);
+      VdbeComment((v, "pk"));
+      sqlite3ReleaseTempReg(pParse, r1);
+      pLevel->op = OP_Noop;
+    }else if( pLevel->flags & WHERE_ROWID_RANGE ){
+      /* Case 2:  We have an inequality comparison against the ROWID field.
+      */
+      int testOp = OP_Noop;
+      int start;
+      WhereTerm *pStart, *pEnd;
+
+      assert( omitTable==0 );
+      pStart = findTerm(&wc, iCur, -1, notReady, WO_GT|WO_GE, 0);
+      pEnd = findTerm(&wc, iCur, -1, notReady, WO_LT|WO_LE, 0);
+      if( bRev ){
+        pTerm = pStart;
+        pStart = pEnd;
+        pEnd = pTerm;
+      }
+      if( pStart ){
+        Expr *pX;
+        int r1, regFree1;
+        pX = pStart->pExpr;
+        assert( pX!=0 );
+        assert( pStart->leftCursor==iCur );
+        r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &regFree1);
+        sqlite3VdbeAddOp3(v, OP_ForceInt, r1, brk, 
+                             pX->op==TK_LE || pX->op==TK_GT);
+        sqlite3VdbeAddOp3(v, bRev ? OP_MoveLt : OP_MoveGe, iCur, brk, r1);
+        VdbeComment((v, "pk"));
+        sqlite3ReleaseTempReg(pParse, regFree1);
+        disableTerm(pLevel, pStart);
+      }else{
+        sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, brk);
+      }
+      if( pEnd ){
+        Expr *pX;
+        pX = pEnd->pExpr;
+        assert( pX!=0 );
+        assert( pEnd->leftCursor==iCur );
+        pLevel->iMem = ++pParse->nMem;
+        sqlite3ExprCode(pParse, pX->pRight, pLevel->iMem);
+        if( pX->op==TK_LT || pX->op==TK_GT ){
+          testOp = bRev ? OP_Le : OP_Ge;
+        }else{
+          testOp = bRev ? OP_Lt : OP_Gt;
+        }
+        disableTerm(pLevel, pEnd);
+      }
+      start = sqlite3VdbeCurrentAddr(v);
+      pLevel->op = bRev ? OP_Prev : OP_Next;
+      pLevel->p1 = iCur;
+      pLevel->p2 = start;
+      if( testOp!=OP_Noop ){
+        int r1 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp2(v, OP_Rowid, iCur, r1);
+        /* sqlite3VdbeAddOp2(v, OP_SCopy, pLevel->iMem, 0); */
+        sqlite3VdbeAddOp3(v, testOp, pLevel->iMem, brk, r1);
+        sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
+        sqlite3ReleaseTempReg(pParse, r1);
+      }
+    }else if( pLevel->flags & WHERE_COLUMN_RANGE ){
+      /* Case 3: The WHERE clause term that refers to the right-most
+      **         column of the index is an inequality.  For example, if
+      **         the index is on (x,y,z) and the WHERE clause is of the
+      **         form "x=5 AND y<10" then this case is used.  Only the
+      **         right-most column can be an inequality - the rest must
+      **         use the "==" and "IN" operators.
+      **
+      **         This case is also used when there are no WHERE clause
+      **         constraints but an index is selected anyway, in order
+      **         to force the output order to conform to an ORDER BY.
+      */
+      int start;
+      int nEq = pLevel->nEq;
+      int topEq=0;        /* True if top limit uses ==. False is strictly < */
+      int btmEq=0;        /* True if btm limit uses ==. False if strictly > */
+      int topOp, btmOp;   /* Operators for the top and bottom search bounds */
+      int testOp;
+      int topLimit = (pLevel->flags & WHERE_TOP_LIMIT)!=0;
+      int btmLimit = (pLevel->flags & WHERE_BTM_LIMIT)!=0;
+      int isMinQuery = 0;      /* If this is an optimized SELECT min(x) ... */
+      int regBase;        /* Base register holding constraint values */
+      int r1;             /* Temp register */
+
+      /* Generate code to evaluate all constraint terms using == or IN
+      ** and level the values of those terms on the stack.
+      */
+      regBase = codeAllEqualityTerms(pParse, pLevel, &wc, notReady, 2);
+
+      /* Figure out what comparison operators to use for top and bottom 
+      ** search bounds. For an ascending index, the bottom bound is a > or >=
+      ** operator and the top bound is a < or <= operator.  For a descending
+      ** index the operators are reversed.
+      */
+      if( pIdx->aSortOrder[nEq]==SQLITE_SO_ASC ){
+        topOp = WO_LT|WO_LE;
+        btmOp = WO_GT|WO_GE;
+      }else{
+        topOp = WO_GT|WO_GE;
+        btmOp = WO_LT|WO_LE;
+        SWAP(int, topLimit, btmLimit);
+      }
+
+      /* If this loop satisfies a sort order (pOrderBy) request that 
+      ** was passed to this function to implement a "SELECT min(x) ..." 
+      ** query, then the caller will only allow the loop to run for
+      ** a single iteration. This means that the first row returned
+      ** should not have a NULL value stored in 'x'. If column 'x' is
+      ** the first one after the nEq equality constraints in the index,
+      ** this requires some special handling.
+      */
+      if( (obflag==ORDERBY_MIN)
+       && (pLevel->flags&WHERE_ORDERBY)
+       && (pIdx->nColumn>nEq)
+       && (pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq])
+      ){
+        isMinQuery = 1;
+      }
+
+      /* Generate the termination key.  This is the key value that
+      ** will end the search.  There is no termination key if there
+      ** are no equality terms and no "X<..." term.
+      **
+      ** 2002-Dec-04: On a reverse-order scan, the so-called "termination"
+      ** key computed here really ends up being the start key.
+      */
+      nxt = pLevel->nxt;
+      if( topLimit ){
+        Expr *pX;
+        int k = pIdx->aiColumn[nEq];
+        pTerm = findTerm(&wc, iCur, k, notReady, topOp, pIdx);
+        assert( pTerm!=0 );
+        pX = pTerm->pExpr;
+        assert( (pTerm->flags & TERM_CODED)==0 );
+        sqlite3ExprCode(pParse, pX->pRight, regBase+nEq);
+        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, nxt);
+        topEq = pTerm->eOperator & (WO_LE|WO_GE);
+        disableTerm(pLevel, pTerm);
+        testOp = OP_IdxGE;
+      }else{
+        testOp = nEq>0 ? OP_IdxGE : OP_Noop;
+        topEq = 1;
+      }
+      if( testOp!=OP_Noop || (isMinQuery&&bRev) ){
+        int nCol = nEq + topLimit;
+        if( isMinQuery && !topLimit ){
+          sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nCol);
+          nCol++;
+          topEq = 0;
+        }
+        buildIndexProbe(v, nCol, pIdx, regBase, pLevel->iMem);
+        if( bRev ){
+          int op = topEq ? OP_MoveLe : OP_MoveLt;
+          sqlite3VdbeAddOp3(v, op, iIdxCur, nxt, pLevel->iMem);
+        }
+      }else if( bRev ){
+        sqlite3VdbeAddOp2(v, OP_Last, iIdxCur, brk);
+      }
+   
+      /* Generate the start key.  This is the key that defines the lower
+      ** bound on the search.  There is no start key if there are no
+      ** equality terms and if there is no "X>..." term.  In
+      ** that case, generate a "Rewind" instruction in place of the
+      ** start key search.
+      **
+      ** 2002-Dec-04: In the case of a reverse-order search, the so-called
+      ** "start" key really ends up being used as the termination key.
+      */
+      if( btmLimit ){
+        Expr *pX;
+        int k = pIdx->aiColumn[nEq];
+        pTerm = findTerm(&wc, iCur, k, notReady, btmOp, pIdx);
+        assert( pTerm!=0 );
+        pX = pTerm->pExpr;
+        assert( (pTerm->flags & TERM_CODED)==0 );
+        sqlite3ExprCode(pParse, pX->pRight, regBase+nEq);
+        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, nxt);
+        btmEq = pTerm->eOperator & (WO_LE|WO_GE);
+        disableTerm(pLevel, pTerm);
+      }else{
+        btmEq = 1;
+      }
+      if( nEq>0 || btmLimit || (isMinQuery&&!bRev) ){
+        int nCol = nEq + btmLimit;
+        if( isMinQuery && !btmLimit ){
+          sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nCol);
+          nCol++;
+          btmEq = 0;
+        }
+        if( bRev ){
+          r1 = pLevel->iMem;
+          testOp = OP_IdxLT;
+        }else{
+          r1 = sqlite3GetTempReg(pParse);
+        }
+        buildIndexProbe(v, nCol, pIdx, regBase, r1);
+        if( !bRev ){
+          int op = btmEq ? OP_MoveGe : OP_MoveGt;
+          sqlite3VdbeAddOp3(v, op, iIdxCur, nxt, r1);
+          sqlite3ReleaseTempReg(pParse, r1);
+        }
+      }else if( bRev ){
+        testOp = OP_Noop;
+      }else{
+        sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, brk);
+      }
+
+      /* Generate the the top of the loop.  If there is a termination
+      ** key we have to test for that key and abort at the top of the
+      ** loop.
+      */
+      start = sqlite3VdbeCurrentAddr(v);
+      if( testOp!=OP_Noop ){
+        sqlite3VdbeAddOp3(v, testOp, iIdxCur, nxt, pLevel->iMem);
+        if( (topEq && !bRev) || (!btmEq && bRev) ){
+          sqlite3VdbeChangeP5(v, 1);
+        }
+      }
+      r1 = sqlite3GetTempReg(pParse);
+      if( topLimit | btmLimit ){
+        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, nEq, r1);
+        sqlite3VdbeAddOp2(v, OP_IsNull, r1, cont);
+      }
+      if( !omitTable ){
+        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, r1);
+        sqlite3VdbeAddOp3(v, OP_MoveGe, iCur, 0, r1);  /* Deferred seek */
+      }
+      sqlite3ReleaseTempReg(pParse, r1);
+
+      /* Record the instruction used to terminate the loop.
+      */
+      pLevel->op = bRev ? OP_Prev : OP_Next;
+      pLevel->p1 = iIdxCur;
+      pLevel->p2 = start;
+    }else if( pLevel->flags & WHERE_COLUMN_EQ ){
+      /* Case 4:  There is an index and all terms of the WHERE clause that
+      **          refer to the index using the "==" or "IN" operators.
+      */
+      int start;
+      int nEq = pLevel->nEq;
+      int isMinQuery = 0;      /* If this is an optimized SELECT min(x) ... */
+      int regBase;             /* Base register of array holding constraints */
+      int r1;
+
+      /* Generate code to evaluate all constraint terms using == or IN
+      ** and leave the values of those terms on the stack.
+      */
+      regBase = codeAllEqualityTerms(pParse, pLevel, &wc, notReady, 1);
+      nxt = pLevel->nxt;
+
+      if( (obflag==ORDERBY_MIN)
+       && (pLevel->flags&WHERE_ORDERBY) 
+       && (pIdx->nColumn>nEq)
+       && (pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq])
+      ){
+        isMinQuery = 1;
+        buildIndexProbe(v, nEq, pIdx, regBase, pLevel->iMem);
+        sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
+        r1 = ++pParse->nMem;
+        buildIndexProbe(v, nEq+1, pIdx, regBase, r1);
+      }else{
+        /* Generate a single key that will be used to both start and 
+        ** terminate the search
+        */
+        r1 = pLevel->iMem;
+        buildIndexProbe(v, nEq, pIdx, regBase, r1);
+      }
+
+      /* Generate code (1) to move to the first matching element of the table.
+      ** Then generate code (2) that jumps to "nxt" after the cursor is past
+      ** the last matching element of the table.  The code (1) is executed
+      ** once to initialize the search, the code (2) is executed before each
+      ** iteration of the scan to see if the scan has finished. */
+      if( bRev ){
+        /* Scan in reverse order */
+        int op;
+        if( isMinQuery ){
+          op = OP_MoveLt;
+        }else{
+          op = OP_MoveLe;
+        }
+        sqlite3VdbeAddOp3(v, op, iIdxCur, nxt, r1);
+        start = sqlite3VdbeAddOp3(v, OP_IdxLT, iIdxCur, nxt, pLevel->iMem);
+        pLevel->op = OP_Prev;
+      }else{
+        /* Scan in the forward order */
+        int op;
+        if( isMinQuery ){
+          op = OP_MoveGt;
+        }else{
+          op = OP_MoveGe;
+        }
+        sqlite3VdbeAddOp3(v, op, iIdxCur, nxt, r1);
+        start = sqlite3VdbeAddOp3(v, OP_IdxGE, iIdxCur, nxt, pLevel->iMem);
+        sqlite3VdbeChangeP5(v, 1);
+        pLevel->op = OP_Next;
+      }
+      if( !omitTable ){
+        r1 = sqlite3GetTempReg(pParse);
+        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, r1);
+        sqlite3VdbeAddOp3(v, OP_MoveGe, iCur, 0, r1);  /* Deferred seek */
+        sqlite3ReleaseTempReg(pParse, r1);
+      }
+      pLevel->p1 = iIdxCur;
+      pLevel->p2 = start;
+    }else{
+      /* Case 5:  There is no usable index.  We must do a complete
+      **          scan of the entire table.
+      */
+      assert( omitTable==0 );
+      assert( bRev==0 );
+      pLevel->op = OP_Next;
+      pLevel->p1 = iCur;
+      pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, OP_Rewind, iCur, brk);
+    }
+    notReady &= ~getMask(&maskSet, iCur);
+
+    /* Insert code to test every subexpression that can be completely
+    ** computed using the current set of tables.
+    */
+    for(pTerm=wc.a, j=wc.nTerm; j>0; j--, pTerm++){
+      Expr *pE;
+      if( pTerm->flags & (TERM_VIRTUAL|TERM_CODED) ) continue;
+      if( (pTerm->prereqAll & notReady)!=0 ) continue;
+      pE = pTerm->pExpr;
+      assert( pE!=0 );
+      if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){
+        continue;
+      }
+      sqlite3ExprIfFalse(pParse, pE, cont, SQLITE_JUMPIFNULL);
+      pTerm->flags |= TERM_CODED;
+    }
+
+    /* For a LEFT OUTER JOIN, generate code that will record the fact that
+    ** at least one row of the right table has matched the left table.  
+    */
+    if( pLevel->iLeftJoin ){
+      pLevel->top = sqlite3VdbeCurrentAddr(v);
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
+      VdbeComment((v, "record LEFT JOIN hit"));
+      for(pTerm=wc.a, j=0; j<wc.nTerm; j++, pTerm++){
+        if( pTerm->flags & (TERM_VIRTUAL|TERM_CODED) ) continue;
+        if( (pTerm->prereqAll & notReady)!=0 ) continue;
+        assert( pTerm->pExpr );
+        sqlite3ExprIfFalse(pParse, pTerm->pExpr, cont, SQLITE_JUMPIFNULL);
+        pTerm->flags |= TERM_CODED;
+      }
+    }
+  }
+
+#ifdef SQLITE_TEST  /* For testing and debugging use only */
+  /* Record in the query plan information about the current table
+  ** and the index used to access it (if any).  If the table itself
+  ** is not used, its name is just '{}'.  If no index is used
+  ** the index is listed as "{}".  If the primary key is used the
+  ** index name is '*'.
+  */
+  for(i=0; i<pTabList->nSrc; i++){
+    char *z;
+    int n;
+    pLevel = &pWInfo->a[i];
+    pTabItem = &pTabList->a[pLevel->iFrom];
+    z = pTabItem->zAlias;
+    if( z==0 ) z = pTabItem->pTab->zName;
+    n = strlen(z);
+    if( n+nQPlan < sizeof(sqlite3_query_plan)-10 ){
+      if( pLevel->flags & WHERE_IDX_ONLY ){
+        memcpy(&sqlite3_query_plan[nQPlan], "{}", 2);
+        nQPlan += 2;
+      }else{
+        memcpy(&sqlite3_query_plan[nQPlan], z, n);
+        nQPlan += n;
+      }
+      sqlite3_query_plan[nQPlan++] = ' ';
+    }
+    if( pLevel->flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
+      memcpy(&sqlite3_query_plan[nQPlan], "* ", 2);
+      nQPlan += 2;
+    }else if( pLevel->pIdx==0 ){
+      memcpy(&sqlite3_query_plan[nQPlan], "{} ", 3);
+      nQPlan += 3;
+    }else{
+      n = strlen(pLevel->pIdx->zName);
+      if( n+nQPlan < sizeof(sqlite3_query_plan)-2 ){
+        memcpy(&sqlite3_query_plan[nQPlan], pLevel->pIdx->zName, n);
+        nQPlan += n;
+        sqlite3_query_plan[nQPlan++] = ' ';
+      }
+    }
+  }
+  while( nQPlan>0 && sqlite3_query_plan[nQPlan-1]==' ' ){
+    sqlite3_query_plan[--nQPlan] = 0;
+  }
+  sqlite3_query_plan[nQPlan] = 0;
+  nQPlan = 0;
+#endif /* SQLITE_TEST // Testing and debugging use only */
+
+  /* Record the continuation address in the WhereInfo structure.  Then
+  ** clean up and return.
+  */
+  pWInfo->iContinue = cont;
+  whereClauseClear(&wc);
+  return pWInfo;
+
+  /* Jump here if malloc fails */
+whereBeginNoMem:
+  whereClauseClear(&wc);
+  whereInfoFree(pWInfo);
+  return 0;
+}
+
+/*
+** Generate the end of the WHERE loop.  See comments on 
+** sqlite3WhereBegin() for additional information.
+*/
+void sqlite3WhereEnd(WhereInfo *pWInfo){
+  Vdbe *v = pWInfo->pParse->pVdbe;
+  int i;
+  WhereLevel *pLevel;
+  SrcList *pTabList = pWInfo->pTabList;
+
+  /* Generate loop termination code.
+  */
+  for(i=pTabList->nSrc-1; i>=0; i--){
+    pLevel = &pWInfo->a[i];
+    sqlite3VdbeResolveLabel(v, pLevel->cont);
+    if( pLevel->op!=OP_Noop ){
+      sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
+    }
+    if( pLevel->nIn ){
+      struct InLoop *pIn;
+      int j;
+      sqlite3VdbeResolveLabel(v, pLevel->nxt);
+      for(j=pLevel->nIn, pIn=&pLevel->aInLoop[j-1]; j>0; j--, pIn--){
+        sqlite3VdbeJumpHere(v, pIn->topAddr+1);
+        sqlite3VdbeAddOp2(v, OP_Next, pIn->iCur, pIn->topAddr);
+        sqlite3VdbeJumpHere(v, pIn->topAddr-1);
+      }
+      sqlite3_free(pLevel->aInLoop);
+    }
+    sqlite3VdbeResolveLabel(v, pLevel->brk);
+    if( pLevel->iLeftJoin ){
+      int addr;
+      addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin);
+      sqlite3VdbeAddOp1(v, OP_NullRow, pTabList->a[i].iCursor);
+      if( pLevel->iIdxCur>=0 ){
+        sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
+      }
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->top);
+      sqlite3VdbeJumpHere(v, addr);
+    }
+  }
+
+  /* The "break" point is here, just past the end of the outer loop.
+  ** Set it.
+  */
+  sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
+
+  /* Close all of the cursors that were opened by sqlite3WhereBegin.
+  */
+  for(i=0, pLevel=pWInfo->a; i<pTabList->nSrc; i++, pLevel++){
+    struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
+    Table *pTab = pTabItem->pTab;
+    assert( pTab!=0 );
+    if( pTab->isEphem || pTab->pSelect ) continue;
+    if( (pLevel->flags & WHERE_IDX_ONLY)==0 ){
+      sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
+    }
+    if( pLevel->pIdx!=0 ){
+      sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
+    }
+
+    /* If this scan uses an index, make code substitutions to read data
+    ** from the index in preference to the table. Sometimes, this means
+    ** the table need never be read from. This is a performance boost,
+    ** as the vdbe level waits until the table is read before actually
+    ** seeking the table cursor to the record corresponding to the current
+    ** position in the index.
+    ** 
+    ** Calls to the code generator in between sqlite3WhereBegin and
+    ** sqlite3WhereEnd will have created code that references the table
+    ** directly.  This loop scans all that code looking for opcodes
+    ** that reference the table and converts them into opcodes that
+    ** reference the index.
+    */
+    if( pLevel->pIdx ){
+      int k, j, last;
+      VdbeOp *pOp;
+      Index *pIdx = pLevel->pIdx;
+      int useIndexOnly = pLevel->flags & WHERE_IDX_ONLY;
+
+      assert( pIdx!=0 );
+      pOp = sqlite3VdbeGetOp(v, pWInfo->iTop);
+      last = sqlite3VdbeCurrentAddr(v);
+      for(k=pWInfo->iTop; k<last; k++, pOp++){
+        if( pOp->p1!=pLevel->iTabCur ) continue;
+        if( pOp->opcode==OP_Column ){
+          for(j=0; j<pIdx->nColumn; j++){
+            if( pOp->p2==pIdx->aiColumn[j] ){
+              pOp->p2 = j;
+              pOp->p1 = pLevel->iIdxCur;
+              break;
+            }
+          }
+          assert(!useIndexOnly || j<pIdx->nColumn);
+        }else if( pOp->opcode==OP_Rowid ){
+          pOp->p1 = pLevel->iIdxCur;
+          pOp->opcode = OP_IdxRowid;
+        }else if( pOp->opcode==OP_NullRow && useIndexOnly ){
+          pOp->opcode = OP_Noop;
+        }
+      }
+    }
+  }
+
+  /* Final cleanup
+  */
+  whereInfoFree(pWInfo);
+  return;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tclinstaller.tcl b/client/src/thirdparty/sqlite-3.4.2/tclinstaller.tcl
new file mode 100644
index 0000000..29d343e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tclinstaller.tcl
@@ -0,0 +1,32 @@
+# This script attempts to install SQLite3 so that it can be used
+# by TCL.  Invoke this script with single argument which is the
+# version number of SQLite.  Example:
+#
+#    tclsh tclinstaller.tcl 3.0
+#
+set VERSION [lindex $argv 0]
+set LIBFILE .libs/libtclsqlite3[info sharedlibextension]
+if { ![info exists env(DESTDIR)] } { set env(DESTDIR) "" }
+if { ![info exists env(TCLLIBDIR)] } { set env(TCLLIBDIR) [lindex $auto_path 0] }
+set LIBDIR $env(DESTDIR)$env(TCLLIBDIR)
+set LIBDIR_INSTALL $env(TCLLIBDIR)
+set LIBNAME [file tail $LIBFILE]
+set LIB $LIBDIR/sqlite3/$LIBNAME
+set LIB_INSTALL $LIBDIR_INSTALL/sqlite3/$LIBNAME
+
+file delete -force $LIBDIR/sqlite3
+file mkdir $LIBDIR/sqlite3
+set fd [open $LIBDIR/sqlite3/pkgIndex.tcl w]
+puts $fd "package ifneeded sqlite3 $VERSION \[list load $LIB_INSTALL sqlite3\]"
+close $fd
+
+# We cannot use [file copy] because that will just make a copy of
+# a symbolic link.  We have to open and copy the file for ourselves.
+#
+set in [open $LIBFILE]
+fconfigure $in -translation binary
+set out [open $LIB w]
+fconfigure $out -translation binary
+puts -nonewline $out [read $in]
+close $in
+close $out
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/diffdb.c b/client/src/thirdparty/sqlite-3.4.2/tool/diffdb.c
new file mode 100644
index 0000000..0537d38
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/diffdb.c
@@ -0,0 +1,44 @@
+/*
+** A utility for printing the differences between two SQLite database files.
+*/
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+
+#define PAGESIZE 1024
+static int db1 = -1;
+static int db2 = -1;
+
+int main(int argc, char **argv){
+  int iPg;
+  unsigned char a1[PAGESIZE], a2[PAGESIZE];
+  if( argc!=3 ){
+    fprintf(stderr,"Usage: %s FILENAME FILENAME\n", argv[0]);
+    exit(1);
+  }
+  db1 = open(argv[1], O_RDONLY);
+  if( db1<0 ){
+    fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
+    exit(1);
+  }
+  db2 = open(argv[2], O_RDONLY);
+  if( db2<0 ){
+    fprintf(stderr,"%s: can't open %s\n", argv[0], argv[2]);
+    exit(1);
+  }
+  iPg = 1;
+  while( read(db1, a1, PAGESIZE)==PAGESIZE && read(db2,a2,PAGESIZE)==PAGESIZE ){
+    if( memcmp(a1,a2,PAGESIZE) ){
+      printf("Page %d\n", iPg);
+    }
+    iPg++;
+  }
+  printf("%d pages checked\n", iPg-1);
+  close(db1);
+  close(db2);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/fragck.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/fragck.tcl
new file mode 100644
index 0000000..35e76f4
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/fragck.tcl
@@ -0,0 +1,149 @@
+# Run this TCL script using "testfixture" to get a report that shows
+# the sequence of database pages used by a particular table or index.
+# This information is used for fragmentation analysis.
+#
+
+# Get the name of the database to analyze
+#
+
+if {[llength $argv]!=2} {
+  puts stderr "Usage: $argv0 database-name table-or-index-name"
+  exit 1
+}
+set file_to_analyze [lindex $argv 0]
+if {![file exists $file_to_analyze]} {
+  puts stderr "No such file: $file_to_analyze"
+  exit 1
+}
+if {![file readable $file_to_analyze]} {
+  puts stderr "File is not readable: $file_to_analyze"
+  exit 1
+}
+if {[file size $file_to_analyze]<512} {
+  puts stderr "Empty or malformed database: $file_to_analyze"
+  exit 1
+}
+set objname [lindex $argv 1]
+
+# Open the database
+#
+sqlite3 db [lindex $argv 0]
+set DB [btree_open [lindex $argv 0] 1000 0]
+
+# This proc is a wrapper around the btree_cursor_info command. The
+# second argument is an open btree cursor returned by [btree_cursor].
+# The first argument is the name of an array variable that exists in
+# the scope of the caller. If the third argument is non-zero, then
+# info is returned for the page that lies $up entries upwards in the
+# tree-structure. (i.e. $up==1 returns the parent page, $up==2 the 
+# grandparent etc.)
+#
+# The following entries in that array are filled in with information retrieved
+# using [btree_cursor_info]:
+#
+#   $arrayvar(page_no)             =  The page number
+#   $arrayvar(entry_no)            =  The entry number
+#   $arrayvar(page_entries)        =  Total number of entries on this page
+#   $arrayvar(cell_size)           =  Cell size (local payload + header)
+#   $arrayvar(page_freebytes)      =  Number of free bytes on this page
+#   $arrayvar(page_freeblocks)     =  Number of free blocks on the page
+#   $arrayvar(payload_bytes)       =  Total payload size (local + overflow)
+#   $arrayvar(header_bytes)        =  Header size in bytes
+#   $arrayvar(local_payload_bytes) =  Local payload size
+#   $arrayvar(parent)              =  Parent page number
+# 
+proc cursor_info {arrayvar csr {up 0}} {
+  upvar $arrayvar a
+  foreach [list a(page_no) \
+                a(entry_no) \
+                a(page_entries) \
+                a(cell_size) \
+                a(page_freebytes) \
+                a(page_freeblocks) \
+                a(payload_bytes) \
+                a(header_bytes) \
+                a(local_payload_bytes) \
+                a(parent) \
+                a(first_ovfl) ] [btree_cursor_info $csr $up] break
+}
+
+# Determine the page-size of the database. This global variable is used
+# throughout the script.
+#
+set pageSize [db eval {PRAGMA page_size}]
+
+# Find the root page of table or index to be analyzed.  Also find out
+# if the object is a table or an index.
+#
+if {$objname=="sqlite_master"} {
+  set rootpage 1
+  set type table
+} else {
+  db eval {
+    SELECT rootpage, type FROM sqlite_master
+     WHERE name=$objname
+  } break
+  if {![info exists rootpage]} {
+    puts stderr "no such table or index: $objname"
+    exit 1
+  }
+  if {$type!="table" && $type!="index"} {
+    puts stderr "$objname is something other than a table or index"
+    exit 1
+  }
+  if {![string is integer -strict $rootpage]} {
+    puts stderr "invalid root page for $objname: $rootpage"
+    exit 1
+  } 
+}
+
+# The cursor $csr is pointing to an entry.  Print out information
+# about the page that $up levels above that page that contains
+# the entry.  If $up==0 use the page that contains the entry.
+# 
+# If information about the page has been printed already, then
+# this is a no-op.
+# 
+proc page_info {csr up} {
+  global seen
+  cursor_info ci $csr $up
+  set pg $ci(page_no)
+  if {[info exists seen($pg)]} return
+  set seen($pg) 1
+
+  # Do parent pages first
+  #
+  if {$ci(parent)} {
+    page_info $csr [expr {$up+1}]
+  }
+
+  # Find the depth of this page
+  #
+  set depth 1
+  set i $up
+  while {$ci(parent)} {
+    incr i
+    incr depth
+    cursor_info ci $csr $i
+  }
+
+  # print the results
+  #
+  puts [format {LEVEL %d:  %6d} $depth $pg]
+}  
+
+  
+  
+
+# Loop through the object and print out page numbers
+#
+set csr [btree_cursor $DB $rootpage 0]
+for {btree_first $csr} {![btree_eof $csr]} {btree_next $csr} {
+  page_info $csr 0
+  set i 1
+  foreach pg [btree_ovfl_info $DB $csr] {
+    puts [format {OVFL %3d: %6d} $i $pg]
+    incr i
+  }
+}
+exit 0
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/lemon.c b/client/src/thirdparty/sqlite-3.4.2/tool/lemon.c
new file mode 100644
index 0000000..e613f77
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/lemon.c
@@ -0,0 +1,4822 @@
+/*
+** This file contains all sources (including headers) to the LEMON
+** LALR(1) parser generator.  The sources have been combined into a
+** single file to make it easy to include LEMON in the source tree
+** and Makefile of another program.
+**
+** The author of this program disclaims copyright.
+*/
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#ifndef __WIN32__
+#   if defined(_WIN32) || defined(WIN32)
+#	define __WIN32__
+#   endif
+#endif
+
+#ifdef __WIN32__
+extern int access();
+#else
+#include <unistd.h>
+#endif
+
+/* #define PRIVATE static */
+#define PRIVATE
+
+#ifdef TEST
+#define MAXRHS 5       /* Set low to exercise exception code */
+#else
+#define MAXRHS 1000
+#endif
+
+static char *msort(char*,char**,int(*)(const char*,const char*));
+
+static struct action *Action_new(void);
+static struct action *Action_sort(struct action *);
+
+/********** From the file "build.h" ************************************/
+void FindRulePrecedences();
+void FindFirstSets();
+void FindStates();
+void FindLinks();
+void FindFollowSets();
+void FindActions();
+
+/********* From the file "configlist.h" *********************************/
+void Configlist_init(/* void */);
+struct config *Configlist_add(/* struct rule *, int */);
+struct config *Configlist_addbasis(/* struct rule *, int */);
+void Configlist_closure(/* void */);
+void Configlist_sort(/* void */);
+void Configlist_sortbasis(/* void */);
+struct config *Configlist_return(/* void */);
+struct config *Configlist_basis(/* void */);
+void Configlist_eat(/* struct config * */);
+void Configlist_reset(/* void */);
+
+/********* From the file "error.h" ***************************************/
+void ErrorMsg(const char *, int,const char *, ...);
+
+/****** From the file "option.h" ******************************************/
+struct s_options {
+  enum { OPT_FLAG=1,  OPT_INT,  OPT_DBL,  OPT_STR,
+         OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR} type;
+  char *label;
+  char *arg;
+  char *message;
+};
+int    OptInit(/* char**,struct s_options*,FILE* */);
+int    OptNArgs(/* void */);
+char  *OptArg(/* int */);
+void   OptErr(/* int */);
+void   OptPrint(/* void */);
+
+/******** From the file "parse.h" *****************************************/
+void Parse(/* struct lemon *lemp */);
+
+/********* From the file "plink.h" ***************************************/
+struct plink *Plink_new(/* void */);
+void Plink_add(/* struct plink **, struct config * */);
+void Plink_copy(/* struct plink **, struct plink * */);
+void Plink_delete(/* struct plink * */);
+
+/********** From the file "report.h" *************************************/
+void Reprint(/* struct lemon * */);
+void ReportOutput(/* struct lemon * */);
+void ReportTable(/* struct lemon * */);
+void ReportHeader(/* struct lemon * */);
+void CompressTables(/* struct lemon * */);
+void ResortStates(/* struct lemon * */);
+
+/********** From the file "set.h" ****************************************/
+void  SetSize(/* int N */);             /* All sets will be of size N */
+char *SetNew(/* void */);               /* A new set for element 0..N */
+void  SetFree(/* char* */);             /* Deallocate a set */
+
+int SetAdd(/* char*,int */);            /* Add element to a set */
+int SetUnion(/* char *A,char *B */);    /* A <- A U B, thru element N */
+
+#define SetFind(X,Y) (X[Y])       /* True if Y is in set X */
+
+/********** From the file "struct.h" *************************************/
+/*
+** Principal data structures for the LEMON parser generator.
+*/
+
+typedef enum {LEMON_FALSE=0, LEMON_TRUE} Boolean;
+
+/* Symbols (terminals and nonterminals) of the grammar are stored
+** in the following: */
+struct symbol {
+  char *name;              /* Name of the symbol */
+  int index;               /* Index number for this symbol */
+  enum {
+    TERMINAL,
+    NONTERMINAL,
+    MULTITERMINAL
+  } type;                  /* Symbols are all either TERMINALS or NTs */
+  struct rule *rule;       /* Linked list of rules of this (if an NT) */
+  struct symbol *fallback; /* fallback token in case this token doesn't parse */
+  int prec;                /* Precedence if defined (-1 otherwise) */
+  enum e_assoc {
+    LEFT,
+    RIGHT,
+    NONE,
+    UNK
+  } assoc;                 /* Associativity if predecence is defined */
+  char *firstset;          /* First-set for all rules of this symbol */
+  Boolean lambda;          /* True if NT and can generate an empty string */
+  int useCnt;              /* Number of times used */
+  char *destructor;        /* Code which executes whenever this symbol is
+                           ** popped from the stack during error processing */
+  int destructorln;        /* Line number of destructor code */
+  char *datatype;          /* The data type of information held by this
+                           ** object. Only used if type==NONTERMINAL */
+  int dtnum;               /* The data type number.  In the parser, the value
+                           ** stack is a union.  The .yy%d element of this
+                           ** union is the correct data type for this object */
+  /* The following fields are used by MULTITERMINALs only */
+  int nsubsym;             /* Number of constituent symbols in the MULTI */
+  struct symbol **subsym;  /* Array of constituent symbols */
+};
+
+/* Each production rule in the grammar is stored in the following
+** structure.  */
+struct rule {
+  struct symbol *lhs;      /* Left-hand side of the rule */
+  char *lhsalias;          /* Alias for the LHS (NULL if none) */
+  int lhsStart;            /* True if left-hand side is the start symbol */
+  int ruleline;            /* Line number for the rule */
+  int nrhs;                /* Number of RHS symbols */
+  struct symbol **rhs;     /* The RHS symbols */
+  char **rhsalias;         /* An alias for each RHS symbol (NULL if none) */
+  int line;                /* Line number at which code begins */
+  char *code;              /* The code executed when this rule is reduced */
+  struct symbol *precsym;  /* Precedence symbol for this rule */
+  int index;               /* An index number for this rule */
+  Boolean canReduce;       /* True if this rule is ever reduced */
+  struct rule *nextlhs;    /* Next rule with the same LHS */
+  struct rule *next;       /* Next rule in the global list */
+};
+
+/* A configuration is a production rule of the grammar together with
+** a mark (dot) showing how much of that rule has been processed so far.
+** Configurations also contain a follow-set which is a list of terminal
+** symbols which are allowed to immediately follow the end of the rule.
+** Every configuration is recorded as an instance of the following: */
+struct config {
+  struct rule *rp;         /* The rule upon which the configuration is based */
+  int dot;                 /* The parse point */
+  char *fws;               /* Follow-set for this configuration only */
+  struct plink *fplp;      /* Follow-set forward propagation links */
+  struct plink *bplp;      /* Follow-set backwards propagation links */
+  struct state *stp;       /* Pointer to state which contains this */
+  enum {
+    COMPLETE,              /* The status is used during followset and */
+    INCOMPLETE             /*    shift computations */
+  } status;
+  struct config *next;     /* Next configuration in the state */
+  struct config *bp;       /* The next basis configuration */
+};
+
+/* Every shift or reduce operation is stored as one of the following */
+struct action {
+  struct symbol *sp;       /* The look-ahead symbol */
+  enum e_action {
+    SHIFT,
+    ACCEPT,
+    REDUCE,
+    ERROR,
+    SSCONFLICT,              /* A shift/shift conflict */
+    SRCONFLICT,              /* Was a reduce, but part of a conflict */
+    RRCONFLICT,              /* Was a reduce, but part of a conflict */
+    SH_RESOLVED,             /* Was a shift.  Precedence resolved conflict */
+    RD_RESOLVED,             /* Was reduce.  Precedence resolved conflict */
+    NOT_USED                 /* Deleted by compression */
+  } type;
+  union {
+    struct state *stp;     /* The new state, if a shift */
+    struct rule *rp;       /* The rule, if a reduce */
+  } x;
+  struct action *next;     /* Next action for this state */
+  struct action *collide;  /* Next action with the same hash */
+};
+
+/* Each state of the generated parser's finite state machine
+** is encoded as an instance of the following structure. */
+struct state {
+  struct config *bp;       /* The basis configurations for this state */
+  struct config *cfp;      /* All configurations in this set */
+  int statenum;            /* Sequencial number for this state */
+  struct action *ap;       /* Array of actions for this state */
+  int nTknAct, nNtAct;     /* Number of actions on terminals and nonterminals */
+  int iTknOfst, iNtOfst;   /* yy_action[] offset for terminals and nonterms */
+  int iDflt;               /* Default action */
+};
+#define NO_OFFSET (-2147483647)
+
+/* A followset propagation link indicates that the contents of one
+** configuration followset should be propagated to another whenever
+** the first changes. */
+struct plink {
+  struct config *cfp;      /* The configuration to which linked */
+  struct plink *next;      /* The next propagate link */
+};
+
+/* The state vector for the entire parser generator is recorded as
+** follows.  (LEMON uses no global variables and makes little use of
+** static variables.  Fields in the following structure can be thought
+** of as begin global variables in the program.) */
+struct lemon {
+  struct state **sorted;   /* Table of states sorted by state number */
+  struct rule *rule;       /* List of all rules */
+  int nstate;              /* Number of states */
+  int nrule;               /* Number of rules */
+  int nsymbol;             /* Number of terminal and nonterminal symbols */
+  int nterminal;           /* Number of terminal symbols */
+  struct symbol **symbols; /* Sorted array of pointers to symbols */
+  int errorcnt;            /* Number of errors */
+  struct symbol *errsym;   /* The error symbol */
+  struct symbol *wildcard; /* Token that matches anything */
+  char *name;              /* Name of the generated parser */
+  char *arg;               /* Declaration of the 3th argument to parser */
+  char *tokentype;         /* Type of terminal symbols in the parser stack */
+  char *vartype;           /* The default type of non-terminal symbols */
+  char *start;             /* Name of the start symbol for the grammar */
+  char *stacksize;         /* Size of the parser stack */
+  char *include;           /* Code to put at the start of the C file */
+  int  includeln;          /* Line number for start of include code */
+  char *error;             /* Code to execute when an error is seen */
+  int  errorln;            /* Line number for start of error code */
+  char *overflow;          /* Code to execute on a stack overflow */
+  int  overflowln;         /* Line number for start of overflow code */
+  char *failure;           /* Code to execute on parser failure */
+  int  failureln;          /* Line number for start of failure code */
+  char *accept;            /* Code to execute when the parser excepts */
+  int  acceptln;           /* Line number for the start of accept code */
+  char *extracode;         /* Code appended to the generated file */
+  int  extracodeln;        /* Line number for the start of the extra code */
+  char *tokendest;         /* Code to execute to destroy token data */
+  int  tokendestln;        /* Line number for token destroyer code */
+  char *vardest;           /* Code for the default non-terminal destructor */
+  int  vardestln;          /* Line number for default non-term destructor code*/
+  char *filename;          /* Name of the input file */
+  char *outname;           /* Name of the current output file */
+  char *tokenprefix;       /* A prefix added to token names in the .h file */
+  int nconflict;           /* Number of parsing conflicts */
+  int tablesize;           /* Size of the parse tables */
+  int basisflag;           /* Print only basis configurations */
+  int has_fallback;        /* True if any %fallback is seen in the grammer */
+  char *argv0;             /* Name of the program */
+};
+
+#define MemoryCheck(X) if((X)==0){ \
+  extern void memory_error(); \
+  memory_error(); \
+}
+
+/**************** From the file "table.h" *********************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+
+/* Routines for handling a strings */
+
+char *Strsafe();
+
+void Strsafe_init(/* void */);
+int Strsafe_insert(/* char * */);
+char *Strsafe_find(/* char * */);
+
+/* Routines for handling symbols of the grammar */
+
+struct symbol *Symbol_new();
+int Symbolcmpp(/* struct symbol **, struct symbol ** */);
+void Symbol_init(/* void */);
+int Symbol_insert(/* struct symbol *, char * */);
+struct symbol *Symbol_find(/* char * */);
+struct symbol *Symbol_Nth(/* int */);
+int Symbol_count(/*  */);
+struct symbol **Symbol_arrayof(/*  */);
+
+/* Routines to manage the state table */
+
+int Configcmp(/* struct config *, struct config * */);
+struct state *State_new();
+void State_init(/* void */);
+int State_insert(/* struct state *, struct config * */);
+struct state *State_find(/* struct config * */);
+struct state **State_arrayof(/*  */);
+
+/* Routines used for efficiency in Configlist_add */
+
+void Configtable_init(/* void */);
+int Configtable_insert(/* struct config * */);
+struct config *Configtable_find(/* struct config * */);
+void Configtable_clear(/* int(*)(struct config *) */);
+/****************** From the file "action.c" *******************************/
+/*
+** Routines processing parser actions in the LEMON parser generator.
+*/
+
+/* Allocate a new parser action */
+static struct action *Action_new(void){
+  static struct action *freelist = 0;
+  struct action *new;
+
+  if( freelist==0 ){
+    int i;
+    int amt = 100;
+    freelist = (struct action *)calloc(amt, sizeof(struct action));
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new parser action.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  new = freelist;
+  freelist = freelist->next;
+  return new;
+}
+
+/* Compare two actions for sorting purposes.  Return negative, zero, or
+** positive if the first action is less than, equal to, or greater than
+** the first
+*/
+static int actioncmp(
+  struct action *ap1,
+  struct action *ap2
+){
+  int rc;
+  rc = ap1->sp->index - ap2->sp->index;
+  if( rc==0 ){
+    rc = (int)ap1->type - (int)ap2->type;
+  }
+  if( rc==0 && ap1->type==REDUCE ){
+    rc = ap1->x.rp->index - ap2->x.rp->index;
+  }
+  return rc;
+}
+
+/* Sort parser actions */
+static struct action *Action_sort(
+  struct action *ap
+){
+  ap = (struct action *)msort((char *)ap,(char **)&ap->next,
+                              (int(*)(const char*,const char*))actioncmp);
+  return ap;
+}
+
+void Action_add(app,type,sp,arg)
+struct action **app;
+enum e_action type;
+struct symbol *sp;
+char *arg;
+{
+  struct action *new;
+  new = Action_new();
+  new->next = *app;
+  *app = new;
+  new->type = type;
+  new->sp = sp;
+  if( type==SHIFT ){
+    new->x.stp = (struct state *)arg;
+  }else{
+    new->x.rp = (struct rule *)arg;
+  }
+}
+/********************** New code to implement the "acttab" module ***********/
+/*
+** This module implements routines use to construct the yy_action[] table.
+*/
+
+/*
+** The state of the yy_action table under construction is an instance of
+** the following structure
+*/
+typedef struct acttab acttab;
+struct acttab {
+  int nAction;                 /* Number of used slots in aAction[] */
+  int nActionAlloc;            /* Slots allocated for aAction[] */
+  struct {
+    int lookahead;             /* Value of the lookahead token */
+    int action;                /* Action to take on the given lookahead */
+  } *aAction,                  /* The yy_action[] table under construction */
+    *aLookahead;               /* A single new transaction set */
+  int mnLookahead;             /* Minimum aLookahead[].lookahead */
+  int mnAction;                /* Action associated with mnLookahead */
+  int mxLookahead;             /* Maximum aLookahead[].lookahead */
+  int nLookahead;              /* Used slots in aLookahead[] */
+  int nLookaheadAlloc;         /* Slots allocated in aLookahead[] */
+};
+
+/* Return the number of entries in the yy_action table */
+#define acttab_size(X) ((X)->nAction)
+
+/* The value for the N-th entry in yy_action */
+#define acttab_yyaction(X,N)  ((X)->aAction[N].action)
+
+/* The value for the N-th entry in yy_lookahead */
+#define acttab_yylookahead(X,N)  ((X)->aAction[N].lookahead)
+
+/* Free all memory associated with the given acttab */
+void acttab_free(acttab *p){
+  free( p->aAction );
+  free( p->aLookahead );
+  free( p );
+}
+
+/* Allocate a new acttab structure */
+acttab *acttab_alloc(void){
+  acttab *p = calloc( 1, sizeof(*p) );
+  if( p==0 ){
+    fprintf(stderr,"Unable to allocate memory for a new acttab.");
+    exit(1);
+  }
+  memset(p, 0, sizeof(*p));
+  return p;
+}
+
+/* Add a new action to the current transaction set
+*/
+void acttab_action(acttab *p, int lookahead, int action){
+  if( p->nLookahead>=p->nLookaheadAlloc ){
+    p->nLookaheadAlloc += 25;
+    p->aLookahead = realloc( p->aLookahead,
+                             sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
+    if( p->aLookahead==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+  }
+  if( p->nLookahead==0 ){
+    p->mxLookahead = lookahead;
+    p->mnLookahead = lookahead;
+    p->mnAction = action;
+  }else{
+    if( p->mxLookahead<lookahead ) p->mxLookahead = lookahead;
+    if( p->mnLookahead>lookahead ){
+      p->mnLookahead = lookahead;
+      p->mnAction = action;
+    }
+  }
+  p->aLookahead[p->nLookahead].lookahead = lookahead;
+  p->aLookahead[p->nLookahead].action = action;
+  p->nLookahead++;
+}
+
+/*
+** Add the transaction set built up with prior calls to acttab_action()
+** into the current action table.  Then reset the transaction set back
+** to an empty set in preparation for a new round of acttab_action() calls.
+**
+** Return the offset into the action table of the new transaction.
+*/
+int acttab_insert(acttab *p){
+  int i, j, k, n;
+  assert( p->nLookahead>0 );
+
+  /* Make sure we have enough space to hold the expanded action table
+  ** in the worst case.  The worst case occurs if the transaction set
+  ** must be appended to the current action table
+  */
+  n = p->mxLookahead + 1;
+  if( p->nAction + n >= p->nActionAlloc ){
+    int oldAlloc = p->nActionAlloc;
+    p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
+    p->aAction = realloc( p->aAction,
+                          sizeof(p->aAction[0])*p->nActionAlloc);
+    if( p->aAction==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+    for(i=oldAlloc; i<p->nActionAlloc; i++){
+      p->aAction[i].lookahead = -1;
+      p->aAction[i].action = -1;
+    }
+  }
+
+  /* Scan the existing action table looking for an offset where we can
+  ** insert the current transaction set.  Fall out of the loop when that
+  ** offset is found.  In the worst case, we fall out of the loop when
+  ** i reaches p->nAction, which means we append the new transaction set.
+  **
+  ** i is the index in p->aAction[] where p->mnLookahead is inserted.
+  */
+  for(i=0; i<p->nAction+p->mnLookahead; i++){
+    if( p->aAction[i].lookahead<0 ){
+      for(j=0; j<p->nLookahead; j++){
+        k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+        if( k<0 ) break;
+        if( p->aAction[k].lookahead>=0 ) break;
+      }
+      if( j<p->nLookahead ) continue;
+      for(j=0; j<p->nAction; j++){
+        if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break;
+      }
+      if( j==p->nAction ){
+        break;  /* Fits in empty slots */
+      }
+    }else if( p->aAction[i].lookahead==p->mnLookahead ){
+      if( p->aAction[i].action!=p->mnAction ) continue;
+      for(j=0; j<p->nLookahead; j++){
+        k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+        if( k<0 || k>=p->nAction ) break;
+        if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break;
+        if( p->aLookahead[j].action!=p->aAction[k].action ) break;
+      }
+      if( j<p->nLookahead ) continue;
+      n = 0;
+      for(j=0; j<p->nAction; j++){
+        if( p->aAction[j].lookahead<0 ) continue;
+        if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++;
+      }
+      if( n==p->nLookahead ){
+        break;  /* Same as a prior transaction set */
+      }
+    }
+  }
+  /* Insert transaction set at index i. */
+  for(j=0; j<p->nLookahead; j++){
+    k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+    p->aAction[k] = p->aLookahead[j];
+    if( k>=p->nAction ) p->nAction = k+1;
+  }
+  p->nLookahead = 0;
+
+  /* Return the offset that is added to the lookahead in order to get the
+  ** index into yy_action of the action */
+  return i - p->mnLookahead;
+}
+
+/********************** From the file "build.c" *****************************/
+/*
+** Routines to construction the finite state machine for the LEMON
+** parser generator.
+*/
+
+/* Find a precedence symbol of every rule in the grammar.
+** 
+** Those rules which have a precedence symbol coded in the input
+** grammar using the "[symbol]" construct will already have the
+** rp->precsym field filled.  Other rules take as their precedence
+** symbol the first RHS symbol with a defined precedence.  If there
+** are not RHS symbols with a defined precedence, the precedence
+** symbol field is left blank.
+*/
+void FindRulePrecedences(xp)
+struct lemon *xp;
+{
+  struct rule *rp;
+  for(rp=xp->rule; rp; rp=rp->next){
+    if( rp->precsym==0 ){
+      int i, j;
+      for(i=0; i<rp->nrhs && rp->precsym==0; i++){
+        struct symbol *sp = rp->rhs[i];
+        if( sp->type==MULTITERMINAL ){
+          for(j=0; j<sp->nsubsym; j++){
+            if( sp->subsym[j]->prec>=0 ){
+              rp->precsym = sp->subsym[j];
+              break;
+            }
+          }
+        }else if( sp->prec>=0 ){
+          rp->precsym = rp->rhs[i];
+	}
+      }
+    }
+  }
+  return;
+}
+
+/* Find all nonterminals which will generate the empty string.
+** Then go back and compute the first sets of every nonterminal.
+** The first set is the set of all terminal symbols which can begin
+** a string generated by that nonterminal.
+*/
+void FindFirstSets(lemp)
+struct lemon *lemp;
+{
+  int i, j;
+  struct rule *rp;
+  int progress;
+
+  for(i=0; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->lambda = LEMON_FALSE;
+  }
+  for(i=lemp->nterminal; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->firstset = SetNew();
+  }
+
+  /* First compute all lambdas */
+  do{
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      if( rp->lhs->lambda ) continue;
+      for(i=0; i<rp->nrhs; i++){
+         struct symbol *sp = rp->rhs[i];
+         if( sp->type!=TERMINAL || sp->lambda==LEMON_FALSE ) break;
+      }
+      if( i==rp->nrhs ){
+        rp->lhs->lambda = LEMON_TRUE;
+        progress = 1;
+      }
+    }
+  }while( progress );
+
+  /* Now compute all first sets */
+  do{
+    struct symbol *s1, *s2;
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      s1 = rp->lhs;
+      for(i=0; i<rp->nrhs; i++){
+        s2 = rp->rhs[i];
+        if( s2->type==TERMINAL ){
+          progress += SetAdd(s1->firstset,s2->index);
+          break;
+        }else if( s2->type==MULTITERMINAL ){
+          for(j=0; j<s2->nsubsym; j++){
+            progress += SetAdd(s1->firstset,s2->subsym[j]->index);
+          }
+          break;
+	}else if( s1==s2 ){
+          if( s1->lambda==LEMON_FALSE ) break;
+	}else{
+          progress += SetUnion(s1->firstset,s2->firstset);
+          if( s2->lambda==LEMON_FALSE ) break;
+	}
+      }
+    }
+  }while( progress );
+  return;
+}
+
+/* Compute all LR(0) states for the grammar.  Links
+** are added to between some states so that the LR(1) follow sets
+** can be computed later.
+*/
+PRIVATE struct state *getstate(/* struct lemon * */);  /* forward reference */
+void FindStates(lemp)
+struct lemon *lemp;
+{
+  struct symbol *sp;
+  struct rule *rp;
+
+  Configlist_init();
+
+  /* Find the start symbol */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ){
+      ErrorMsg(lemp->filename,0,
+"The specified start symbol \"%s\" is not \
+in a nonterminal of the grammar.  \"%s\" will be used as the start \
+symbol instead.",lemp->start,lemp->rule->lhs->name);
+      lemp->errorcnt++;
+      sp = lemp->rule->lhs;
+    }
+  }else{
+    sp = lemp->rule->lhs;
+  }
+
+  /* Make sure the start symbol doesn't occur on the right-hand side of
+  ** any rule.  Report an error if it does.  (YACC would generate a new
+  ** start symbol in this case.) */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    int i;
+    for(i=0; i<rp->nrhs; i++){
+      if( rp->rhs[i]==sp ){   /* FIX ME:  Deal with multiterminals */
+        ErrorMsg(lemp->filename,0,
+"The start symbol \"%s\" occurs on the \
+right-hand side of a rule. This will result in a parser which \
+does not work properly.",sp->name);
+        lemp->errorcnt++;
+      }
+    }
+  }
+
+  /* The basis configuration set for the first state
+  ** is all rules which have the start symbol as their
+  ** left-hand side */
+  for(rp=sp->rule; rp; rp=rp->nextlhs){
+    struct config *newcfp;
+    rp->lhsStart = 1;
+    newcfp = Configlist_addbasis(rp,0);
+    SetAdd(newcfp->fws,0);
+  }
+
+  /* Compute the first state.  All other states will be
+  ** computed automatically during the computation of the first one.
+  ** The returned pointer to the first state is not used. */
+  (void)getstate(lemp);
+  return;
+}
+
+/* Return a pointer to a state which is described by the configuration
+** list which has been built from calls to Configlist_add.
+*/
+PRIVATE void buildshifts(/* struct lemon *, struct state * */); /* Forwd ref */
+PRIVATE struct state *getstate(lemp)
+struct lemon *lemp;
+{
+  struct config *cfp, *bp;
+  struct state *stp;
+
+  /* Extract the sorted basis of the new state.  The basis was constructed
+  ** by prior calls to "Configlist_addbasis()". */
+  Configlist_sortbasis();
+  bp = Configlist_basis();
+
+  /* Get a state with the same basis */
+  stp = State_find(bp);
+  if( stp ){
+    /* A state with the same basis already exists!  Copy all the follow-set
+    ** propagation links from the state under construction into the
+    ** preexisting state, then return a pointer to the preexisting state */
+    struct config *x, *y;
+    for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){
+      Plink_copy(&y->bplp,x->bplp);
+      Plink_delete(x->fplp);
+      x->fplp = x->bplp = 0;
+    }
+    cfp = Configlist_return();
+    Configlist_eat(cfp);
+  }else{
+    /* This really is a new state.  Construct all the details */
+    Configlist_closure(lemp);    /* Compute the configuration closure */
+    Configlist_sort();           /* Sort the configuration closure */
+    cfp = Configlist_return();   /* Get a pointer to the config list */
+    stp = State_new();           /* A new state structure */
+    MemoryCheck(stp);
+    stp->bp = bp;                /* Remember the configuration basis */
+    stp->cfp = cfp;              /* Remember the configuration closure */
+    stp->statenum = lemp->nstate++; /* Every state gets a sequence number */
+    stp->ap = 0;                 /* No actions, yet. */
+    State_insert(stp,stp->bp);   /* Add to the state table */
+    buildshifts(lemp,stp);       /* Recursively compute successor states */
+  }
+  return stp;
+}
+
+/*
+** Return true if two symbols are the same.
+*/
+int same_symbol(a,b)
+struct symbol *a;
+struct symbol *b;
+{
+  int i;
+  if( a==b ) return 1;
+  if( a->type!=MULTITERMINAL ) return 0;
+  if( b->type!=MULTITERMINAL ) return 0;
+  if( a->nsubsym!=b->nsubsym ) return 0;
+  for(i=0; i<a->nsubsym; i++){
+    if( a->subsym[i]!=b->subsym[i] ) return 0;
+  }
+  return 1;
+}
+
+/* Construct all successor states to the given state.  A "successor"
+** state is any state which can be reached by a shift action.
+*/
+PRIVATE void buildshifts(lemp,stp)
+struct lemon *lemp;
+struct state *stp;     /* The state from which successors are computed */
+{
+  struct config *cfp;  /* For looping thru the config closure of "stp" */
+  struct config *bcfp; /* For the inner loop on config closure of "stp" */
+  struct config *new;  /* */
+  struct symbol *sp;   /* Symbol following the dot in configuration "cfp" */
+  struct symbol *bsp;  /* Symbol following the dot in configuration "bcfp" */
+  struct state *newstp; /* A pointer to a successor state */
+
+  /* Each configuration becomes complete after it contibutes to a successor
+  ** state.  Initially, all configurations are incomplete */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
+
+  /* Loop through all configurations of the state "stp" */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next){
+    if( cfp->status==COMPLETE ) continue;    /* Already used by inner loop */
+    if( cfp->dot>=cfp->rp->nrhs ) continue;  /* Can't shift this config */
+    Configlist_reset();                      /* Reset the new config set */
+    sp = cfp->rp->rhs[cfp->dot];             /* Symbol after the dot */
+
+    /* For every configuration in the state "stp" which has the symbol "sp"
+    ** following its dot, add the same configuration to the basis set under
+    ** construction but with the dot shifted one symbol to the right. */
+    for(bcfp=cfp; bcfp; bcfp=bcfp->next){
+      if( bcfp->status==COMPLETE ) continue;    /* Already used */
+      if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */
+      bsp = bcfp->rp->rhs[bcfp->dot];           /* Get symbol after dot */
+      if( !same_symbol(bsp,sp) ) continue;      /* Must be same as for "cfp" */
+      bcfp->status = COMPLETE;                  /* Mark this config as used */
+      new = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
+      Plink_add(&new->bplp,bcfp);
+    }
+
+    /* Get a pointer to the state described by the basis configuration set
+    ** constructed in the preceding loop */
+    newstp = getstate(lemp);
+
+    /* The state "newstp" is reached from the state "stp" by a shift action
+    ** on the symbol "sp" */
+    if( sp->type==MULTITERMINAL ){
+      int i;
+      for(i=0; i<sp->nsubsym; i++){
+        Action_add(&stp->ap,SHIFT,sp->subsym[i],(char*)newstp);
+      }
+    }else{
+      Action_add(&stp->ap,SHIFT,sp,(char *)newstp);
+    }
+  }
+}
+
+/*
+** Construct the propagation links
+*/
+void FindLinks(lemp)
+struct lemon *lemp;
+{
+  int i;
+  struct config *cfp, *other;
+  struct state *stp;
+  struct plink *plp;
+
+  /* Housekeeping detail:
+  ** Add to every propagate link a pointer back to the state to
+  ** which the link is attached. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      cfp->stp = stp;
+    }
+  }
+
+  /* Convert all backlinks into forward links.  Only the forward
+  ** links are used in the follow-set computation. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      for(plp=cfp->bplp; plp; plp=plp->next){
+        other = plp->cfp;
+        Plink_add(&other->fplp,cfp);
+      }
+    }
+  }
+}
+
+/* Compute all followsets.
+**
+** A followset is the set of all symbols which can come immediately
+** after a configuration.
+*/
+void FindFollowSets(lemp)
+struct lemon *lemp;
+{
+  int i;
+  struct config *cfp;
+  struct plink *plp;
+  int progress;
+  int change;
+
+  for(i=0; i<lemp->nstate; i++){
+    for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+      cfp->status = INCOMPLETE;
+    }
+  }
+  
+  do{
+    progress = 0;
+    for(i=0; i<lemp->nstate; i++){
+      for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+        if( cfp->status==COMPLETE ) continue;
+        for(plp=cfp->fplp; plp; plp=plp->next){
+          change = SetUnion(plp->cfp->fws,cfp->fws);
+          if( change ){
+            plp->cfp->status = INCOMPLETE;
+            progress = 1;
+	  }
+	}
+        cfp->status = COMPLETE;
+      }
+    }
+  }while( progress );
+}
+
+static int resolve_conflict();
+
+/* Compute the reduce actions, and resolve conflicts.
+*/
+void FindActions(lemp)
+struct lemon *lemp;
+{
+  int i,j;
+  struct config *cfp;
+  struct state *stp;
+  struct symbol *sp;
+  struct rule *rp;
+
+  /* Add all of the reduce actions 
+  ** A reduce action is added for each element of the followset of
+  ** a configuration which has its dot at the extreme right.
+  */
+  for(i=0; i<lemp->nstate; i++){   /* Loop over all states */
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){  /* Loop over all configurations */
+      if( cfp->rp->nrhs==cfp->dot ){        /* Is dot at extreme right? */
+        for(j=0; j<lemp->nterminal; j++){
+          if( SetFind(cfp->fws,j) ){
+            /* Add a reduce action to the state "stp" which will reduce by the
+            ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */
+            Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp);
+          }
+	}
+      }
+    }
+  }
+
+  /* Add the accepting token */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ) sp = lemp->rule->lhs;
+  }else{
+    sp = lemp->rule->lhs;
+  }
+  /* Add to the first state (which is always the starting state of the
+  ** finite state machine) an action to ACCEPT if the lookahead is the
+  ** start nonterminal.  */
+  Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0);
+
+  /* Resolve conflicts */
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap, *nap;
+    struct state *stp;
+    stp = lemp->sorted[i];
+    /* assert( stp->ap ); */
+    stp->ap = Action_sort(stp->ap);
+    for(ap=stp->ap; ap && ap->next; ap=ap->next){
+      for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){
+         /* The two actions "ap" and "nap" have the same lookahead.
+         ** Figure out which one should be used */
+         lemp->nconflict += resolve_conflict(ap,nap,lemp->errsym);
+      }
+    }
+  }
+
+  /* Report an error for each rule that can never be reduced. */
+  for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = LEMON_FALSE;
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap;
+    for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE ) ap->x.rp->canReduce = LEMON_TRUE;
+    }
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    if( rp->canReduce ) continue;
+    ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n");
+    lemp->errorcnt++;
+  }
+}
+
+/* Resolve a conflict between the two given actions.  If the
+** conflict can't be resolve, return non-zero.
+**
+** NO LONGER TRUE:
+**   To resolve a conflict, first look to see if either action
+**   is on an error rule.  In that case, take the action which
+**   is not associated with the error rule.  If neither or both
+**   actions are associated with an error rule, then try to
+**   use precedence to resolve the conflict.
+**
+** If either action is a SHIFT, then it must be apx.  This
+** function won't work if apx->type==REDUCE and apy->type==SHIFT.
+*/
+static int resolve_conflict(apx,apy,errsym)
+struct action *apx;
+struct action *apy;
+struct symbol *errsym;   /* The error symbol (if defined.  NULL otherwise) */
+{
+  struct symbol *spx, *spy;
+  int errcnt = 0;
+  assert( apx->sp==apy->sp );  /* Otherwise there would be no conflict */
+  if( apx->type==SHIFT && apy->type==SHIFT ){
+    apy->type = SSCONFLICT;
+    errcnt++;
+  }
+  if( apx->type==SHIFT && apy->type==REDUCE ){
+    spx = apx->sp;
+    spy = apy->x.rp->precsym;
+    if( spy==0 || spx->prec<0 || spy->prec<0 ){
+      /* Not enough precedence information. */
+      apy->type = SRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){    /* Lower precedence wins */
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = SH_RESOLVED;
+    }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */
+      apy->type = RD_RESOLVED;                             /* associativity */
+    }else if( spx->prec==spy->prec && spx->assoc==LEFT ){  /* to break tie */
+      apx->type = SH_RESOLVED;
+    }else{
+      assert( spx->prec==spy->prec && spx->assoc==NONE );
+      apy->type = SRCONFLICT;
+      errcnt++;
+    }
+  }else if( apx->type==REDUCE && apy->type==REDUCE ){
+    spx = apx->x.rp->precsym;
+    spy = apy->x.rp->precsym;
+    if( spx==0 || spy==0 || spx->prec<0 ||
+    spy->prec<0 || spx->prec==spy->prec ){
+      apy->type = RRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = RD_RESOLVED;
+    }
+  }else{
+    assert( 
+      apx->type==SH_RESOLVED ||
+      apx->type==RD_RESOLVED ||
+      apx->type==SSCONFLICT ||
+      apx->type==SRCONFLICT ||
+      apx->type==RRCONFLICT ||
+      apy->type==SH_RESOLVED ||
+      apy->type==RD_RESOLVED ||
+      apy->type==SSCONFLICT ||
+      apy->type==SRCONFLICT ||
+      apy->type==RRCONFLICT
+    );
+    /* The REDUCE/SHIFT case cannot happen because SHIFTs come before
+    ** REDUCEs on the list.  If we reach this point it must be because
+    ** the parser conflict had already been resolved. */
+  }
+  return errcnt;
+}
+/********************* From the file "configlist.c" *************************/
+/*
+** Routines to processing a configuration list and building a state
+** in the LEMON parser generator.
+*/
+
+static struct config *freelist = 0;      /* List of free configurations */
+static struct config *current = 0;       /* Top of list of configurations */
+static struct config **currentend = 0;   /* Last on list of configs */
+static struct config *basis = 0;         /* Top of list of basis configs */
+static struct config **basisend = 0;     /* End of list of basis configs */
+
+/* Return a pointer to a new configuration */
+PRIVATE struct config *newconfig(){
+  struct config *new;
+  if( freelist==0 ){
+    int i;
+    int amt = 3;
+    freelist = (struct config *)calloc( amt, sizeof(struct config) );
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new configuration.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  new = freelist;
+  freelist = freelist->next;
+  return new;
+}
+
+/* The configuration "old" is no longer used */
+PRIVATE void deleteconfig(old)
+struct config *old;
+{
+  old->next = freelist;
+  freelist = old;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_init(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_init();
+  return;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_reset(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_clear(0);
+  return;
+}
+
+/* Add another configuration to the configuration list */
+struct config *Configlist_add(rp,dot)
+struct rule *rp;    /* The rule */
+int dot;            /* Index into the RHS of the rule where the dot goes */
+{
+  struct config *cfp, model;
+
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Add a basis configuration to the configuration list */
+struct config *Configlist_addbasis(rp,dot)
+struct rule *rp;
+int dot;
+{
+  struct config *cfp, model;
+
+  assert( basisend!=0 );
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    *basisend = cfp;
+    basisend = &cfp->bp;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Compute the closure of the configuration list */
+void Configlist_closure(lemp)
+struct lemon *lemp;
+{
+  struct config *cfp, *newcfp;
+  struct rule *rp, *newrp;
+  struct symbol *sp, *xsp;
+  int i, dot;
+
+  assert( currentend!=0 );
+  for(cfp=current; cfp; cfp=cfp->next){
+    rp = cfp->rp;
+    dot = cfp->dot;
+    if( dot>=rp->nrhs ) continue;
+    sp = rp->rhs[dot];
+    if( sp->type==NONTERMINAL ){
+      if( sp->rule==0 && sp!=lemp->errsym ){
+        ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.",
+          sp->name);
+        lemp->errorcnt++;
+      }
+      for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){
+        newcfp = Configlist_add(newrp,0);
+        for(i=dot+1; i<rp->nrhs; i++){
+          xsp = rp->rhs[i];
+          if( xsp->type==TERMINAL ){
+            SetAdd(newcfp->fws,xsp->index);
+            break;
+          }else if( xsp->type==MULTITERMINAL ){
+            int k;
+            for(k=0; k<xsp->nsubsym; k++){
+              SetAdd(newcfp->fws, xsp->subsym[k]->index);
+            }
+            break;
+	  }else{
+            SetUnion(newcfp->fws,xsp->firstset);
+            if( xsp->lambda==LEMON_FALSE ) break;
+	  }
+	}
+        if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
+      }
+    }
+  }
+  return;
+}
+
+/* Sort the configuration list */
+void Configlist_sort(){
+  current = (struct config *)msort((char *)current,(char **)&(current->next),Configcmp);
+  currentend = 0;
+  return;
+}
+
+/* Sort the basis configuration list */
+void Configlist_sortbasis(){
+  basis = (struct config *)msort((char *)current,(char **)&(current->bp),Configcmp);
+  basisend = 0;
+  return;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_return(){
+  struct config *old;
+  old = current;
+  current = 0;
+  currentend = 0;
+  return old;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_basis(){
+  struct config *old;
+  old = basis;
+  basis = 0;
+  basisend = 0;
+  return old;
+}
+
+/* Free all elements of the given configuration list */
+void Configlist_eat(cfp)
+struct config *cfp;
+{
+  struct config *nextcfp;
+  for(; cfp; cfp=nextcfp){
+    nextcfp = cfp->next;
+    assert( cfp->fplp==0 );
+    assert( cfp->bplp==0 );
+    if( cfp->fws ) SetFree(cfp->fws);
+    deleteconfig(cfp);
+  }
+  return;
+}
+/***************** From the file "error.c" *********************************/
+/*
+** Code for printing error message.
+*/
+
+/* Find a good place to break "msg" so that its length is at least "min"
+** but no more than "max".  Make the point as close to max as possible.
+*/
+static int findbreak(msg,min,max)
+char *msg;
+int min;
+int max;
+{
+  int i,spot;
+  char c;
+  for(i=spot=min; i<=max; i++){
+    c = msg[i];
+    if( c=='\t' ) msg[i] = ' ';
+    if( c=='\n' ){ msg[i] = ' '; spot = i; break; }
+    if( c==0 ){ spot = i; break; }
+    if( c=='-' && i<max-1 ) spot = i+1;
+    if( c==' ' ) spot = i;
+  }
+  return spot;
+}
+
+/*
+** The error message is split across multiple lines if necessary.  The
+** splits occur at a space, if there is a space available near the end
+** of the line.
+*/
+#define ERRMSGSIZE  10000 /* Hope this is big enough.  No way to error check */
+#define LINEWIDTH      79 /* Max width of any output line */
+#define PREFIXLIMIT    30 /* Max width of the prefix on each line */
+void ErrorMsg(const char *filename, int lineno, const char *format, ...){
+  char errmsg[ERRMSGSIZE];
+  char prefix[PREFIXLIMIT+10];
+  int errmsgsize;
+  int prefixsize;
+  int availablewidth;
+  va_list ap;
+  int end, restart, base;
+
+  va_start(ap, format);
+  /* Prepare a prefix to be prepended to every output line */
+  if( lineno>0 ){
+    sprintf(prefix,"%.*s:%d: ",PREFIXLIMIT-10,filename,lineno);
+  }else{
+    sprintf(prefix,"%.*s: ",PREFIXLIMIT-10,filename);
+  }
+  prefixsize = strlen(prefix);
+  availablewidth = LINEWIDTH - prefixsize;
+
+  /* Generate the error message */
+  vsprintf(errmsg,format,ap);
+  va_end(ap);
+  errmsgsize = strlen(errmsg);
+  /* Remove trailing '\n's from the error message. */
+  while( errmsgsize>0 && errmsg[errmsgsize-1]=='\n' ){
+     errmsg[--errmsgsize] = 0;
+  }
+
+  /* Print the error message */
+  base = 0;
+  while( errmsg[base]!=0 ){
+    end = restart = findbreak(&errmsg[base],0,availablewidth);
+    restart += base;
+    while( errmsg[restart]==' ' ) restart++;
+    fprintf(stdout,"%s%.*s\n",prefix,end,&errmsg[base]);
+    base = restart;
+  }
+}
+/**************** From the file "main.c" ************************************/
+/*
+** Main program file for the LEMON parser generator.
+*/
+
+/* Report an out-of-memory condition and abort.  This function
+** is used mostly by the "MemoryCheck" macro in struct.h
+*/
+void memory_error(){
+  fprintf(stderr,"Out of memory.  Aborting...\n");
+  exit(1);
+}
+
+static int nDefine = 0;      /* Number of -D options on the command line */
+static char **azDefine = 0;  /* Name of the -D macros */
+
+/* This routine is called with the argument to each -D command-line option.
+** Add the macro defined to the azDefine array.
+*/
+static void handle_D_option(char *z){
+  char **paz;
+  nDefine++;
+  azDefine = realloc(azDefine, sizeof(azDefine[0])*nDefine);
+  if( azDefine==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  paz = &azDefine[nDefine-1];
+  *paz = malloc( strlen(z)+1 );
+  if( *paz==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  strcpy(*paz, z);
+  for(z=*paz; *z && *z!='='; z++){}
+  *z = 0;
+}
+
+
+/* The main program.  Parse the command line and do it... */
+int main(argc,argv)
+int argc;
+char **argv;
+{
+  static int version = 0;
+  static int rpflag = 0;
+  static int basisflag = 0;
+  static int compress = 0;
+  static int quiet = 0;
+  static int statistics = 0;
+  static int mhflag = 0;
+  static struct s_options options[] = {
+    {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."},
+    {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."},
+    {OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."},
+    {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."},
+    {OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file"},
+    {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."},
+    {OPT_FLAG, "s", (char*)&statistics,
+                                   "Print parser stats to standard output."},
+    {OPT_FLAG, "x", (char*)&version, "Print the version number."},
+    {OPT_FLAG,0,0,0}
+  };
+  int i;
+  struct lemon lem;
+
+  OptInit(argv,options,stderr);
+  if( version ){
+     printf("Lemon version 1.0\n");
+     exit(0); 
+  }
+  if( OptNArgs()!=1 ){
+    fprintf(stderr,"Exactly one filename argument is required.\n");
+    exit(1);
+  }
+  memset(&lem, 0, sizeof(lem));
+  lem.errorcnt = 0;
+
+  /* Initialize the machine */
+  Strsafe_init();
+  Symbol_init();
+  State_init();
+  lem.argv0 = argv[0];
+  lem.filename = OptArg(0);
+  lem.basisflag = basisflag;
+  Symbol_new("$");
+  lem.errsym = Symbol_new("error");
+  lem.errsym->useCnt = 0;
+
+  /* Parse the input file */
+  Parse(&lem);
+  if( lem.errorcnt ) exit(lem.errorcnt);
+  if( lem.nrule==0 ){
+    fprintf(stderr,"Empty grammar.\n");
+    exit(1);
+  }
+
+  /* Count and index the symbols of the grammar */
+  lem.nsymbol = Symbol_count();
+  Symbol_new("{default}");
+  lem.symbols = Symbol_arrayof();
+  for(i=0; i<=lem.nsymbol; i++) lem.symbols[i]->index = i;
+  qsort(lem.symbols,lem.nsymbol+1,sizeof(struct symbol*),
+        (int(*)())Symbolcmpp);
+  for(i=0; i<=lem.nsymbol; i++) lem.symbols[i]->index = i;
+  for(i=1; isupper(lem.symbols[i]->name[0]); i++);
+  lem.nterminal = i;
+
+  /* Generate a reprint of the grammar, if requested on the command line */
+  if( rpflag ){
+    Reprint(&lem);
+  }else{
+    /* Initialize the size for all follow and first sets */
+    SetSize(lem.nterminal+1);
+
+    /* Find the precedence for every production rule (that has one) */
+    FindRulePrecedences(&lem);
+
+    /* Compute the lambda-nonterminals and the first-sets for every
+    ** nonterminal */
+    FindFirstSets(&lem);
+
+    /* Compute all LR(0) states.  Also record follow-set propagation
+    ** links so that the follow-set can be computed later */
+    lem.nstate = 0;
+    FindStates(&lem);
+    lem.sorted = State_arrayof();
+
+    /* Tie up loose ends on the propagation links */
+    FindLinks(&lem);
+
+    /* Compute the follow set of every reducible configuration */
+    FindFollowSets(&lem);
+
+    /* Compute the action tables */
+    FindActions(&lem);
+
+    /* Compress the action tables */
+    if( compress==0 ) CompressTables(&lem);
+
+    /* Reorder and renumber the states so that states with fewer choices
+    ** occur at the end. */
+    ResortStates(&lem);
+
+    /* Generate a report of the parser generated.  (the "y.output" file) */
+    if( !quiet ) ReportOutput(&lem);
+
+    /* Generate the source code for the parser */
+    ReportTable(&lem, mhflag);
+
+    /* Produce a header file for use by the scanner.  (This step is
+    ** omitted if the "-m" option is used because makeheaders will
+    ** generate the file for us.) */
+    if( !mhflag ) ReportHeader(&lem);
+  }
+  if( statistics ){
+    printf("Parser statistics: %d terminals, %d nonterminals, %d rules\n",
+      lem.nterminal, lem.nsymbol - lem.nterminal, lem.nrule);
+    printf("                   %d states, %d parser table entries, %d conflicts\n",
+      lem.nstate, lem.tablesize, lem.nconflict);
+  }
+  if( lem.nconflict ){
+    fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict);
+  }
+  exit(lem.errorcnt + lem.nconflict);
+  return (lem.errorcnt + lem.nconflict);
+}
+/******************** From the file "msort.c" *******************************/
+/*
+** A generic merge-sort program.
+**
+** USAGE:
+** Let "ptr" be a pointer to some structure which is at the head of
+** a null-terminated list.  Then to sort the list call:
+**
+**     ptr = msort(ptr,&(ptr->next),cmpfnc);
+**
+** In the above, "cmpfnc" is a pointer to a function which compares
+** two instances of the structure and returns an integer, as in
+** strcmp.  The second argument is a pointer to the pointer to the
+** second element of the linked list.  This address is used to compute
+** the offset to the "next" field within the structure.  The offset to
+** the "next" field must be constant for all structures in the list.
+**
+** The function returns a new pointer which is the head of the list
+** after sorting.
+**
+** ALGORITHM:
+** Merge-sort.
+*/
+
+/*
+** Return a pointer to the next structure in the linked list.
+*/
+#define NEXT(A) (*(char**)(((unsigned long)A)+offset))
+
+/*
+** Inputs:
+**   a:       A sorted, null-terminated linked list.  (May be null).
+**   b:       A sorted, null-terminated linked list.  (May be null).
+**   cmp:     A pointer to the comparison function.
+**   offset:  Offset in the structure to the "next" field.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   of both a and b.
+**
+** Side effects:
+**   The "next" pointers for elements in the lists a and b are
+**   changed.
+*/
+static char *merge(
+  char *a,
+  char *b,
+  int (*cmp)(const char*,const char*),
+  int offset
+){
+  char *ptr, *head;
+
+  if( a==0 ){
+    head = b;
+  }else if( b==0 ){
+    head = a;
+  }else{
+    if( (*cmp)(a,b)<0 ){
+      ptr = a;
+      a = NEXT(a);
+    }else{
+      ptr = b;
+      b = NEXT(b);
+    }
+    head = ptr;
+    while( a && b ){
+      if( (*cmp)(a,b)<0 ){
+        NEXT(ptr) = a;
+        ptr = a;
+        a = NEXT(a);
+      }else{
+        NEXT(ptr) = b;
+        ptr = b;
+        b = NEXT(b);
+      }
+    }
+    if( a ) NEXT(ptr) = a;
+    else    NEXT(ptr) = b;
+  }
+  return head;
+}
+
+/*
+** Inputs:
+**   list:      Pointer to a singly-linked list of structures.
+**   next:      Pointer to pointer to the second element of the list.
+**   cmp:       A comparison function.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   orginally in list.
+**
+** Side effects:
+**   The "next" pointers for elements in list are changed.
+*/
+#define LISTSIZE 30
+static char *msort(
+  char *list,
+  char **next,
+  int (*cmp)(const char*,const char*)
+){
+  unsigned long offset;
+  char *ep;
+  char *set[LISTSIZE];
+  int i;
+  offset = (unsigned long)next - (unsigned long)list;
+  for(i=0; i<LISTSIZE; i++) set[i] = 0;
+  while( list ){
+    ep = list;
+    list = NEXT(list);
+    NEXT(ep) = 0;
+    for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){
+      ep = merge(ep,set[i],cmp,offset);
+      set[i] = 0;
+    }
+    set[i] = ep;
+  }
+  ep = 0;
+  for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(ep,set[i],cmp,offset);
+  return ep;
+}
+/************************ From the file "option.c" **************************/
+static char **argv;
+static struct s_options *op;
+static FILE *errstream;
+
+#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0)
+
+/*
+** Print the command line with a carrot pointing to the k-th character
+** of the n-th field.
+*/
+static void errline(n,k,err)
+int n;
+int k;
+FILE *err;
+{
+  int spcnt, i;
+  if( argv[0] ) fprintf(err,"%s",argv[0]);
+  spcnt = strlen(argv[0]) + 1;
+  for(i=1; i<n && argv[i]; i++){
+    fprintf(err," %s",argv[i]);
+    spcnt += strlen(argv[i])+1;
+  }
+  spcnt += k;
+  for(; argv[i]; i++) fprintf(err," %s",argv[i]);
+  if( spcnt<20 ){
+    fprintf(err,"\n%*s^-- here\n",spcnt,"");
+  }else{
+    fprintf(err,"\n%*shere --^\n",spcnt-7,"");
+  }
+}
+
+/*
+** Return the index of the N-th non-switch argument.  Return -1
+** if N is out of range.
+*/
+static int argindex(n)
+int n;
+{
+  int i;
+  int dashdash = 0;
+  if( argv!=0 && *argv!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ){
+        if( n==0 ) return i;
+        n--;
+      }
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return -1;
+}
+
+static char emsg[] = "Command line syntax error: ";
+
+/*
+** Process a flag command line argument.
+*/
+static int handleflags(i,err)
+int i;
+FILE *err;
+{
+  int v;
+  int errcnt = 0;
+  int j;
+  for(j=0; op[j].label; j++){
+    if( strncmp(&argv[i][1],op[j].label,strlen(op[j].label))==0 ) break;
+  }
+  v = argv[i][0]=='-' ? 1 : 0;
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }else if( op[j].type==OPT_FLAG ){
+    *((int*)op[j].arg) = v;
+  }else if( op[j].type==OPT_FFLAG ){
+    (*(void(*)())(op[j].arg))(v);
+  }else if( op[j].type==OPT_FSTR ){
+    (*(void(*)())(op[j].arg))(&argv[i][2]);
+  }else{
+    if( err ){
+      fprintf(err,"%smissing argument on switch.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }
+  return errcnt;
+}
+
+/*
+** Process a command line switch which has an argument.
+*/
+static int handleswitch(i,err)
+int i;
+FILE *err;
+{
+  int lv = 0;
+  double dv = 0.0;
+  char *sv = 0, *end;
+  char *cp;
+  int j;
+  int errcnt = 0;
+  cp = strchr(argv[i],'=');
+  assert( cp!=0 );
+  *cp = 0;
+  for(j=0; op[j].label; j++){
+    if( strcmp(argv[i],op[j].label)==0 ) break;
+  }
+  *cp = '=';
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,0,err);
+    }
+    errcnt++;
+  }else{
+    cp++;
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        if( err ){
+          fprintf(err,"%soption requires an argument.\n",emsg);
+          errline(i,0,err);
+        }
+        errcnt++;
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        dv = strtod(cp,&end);
+        if( *end ){
+          if( err ){
+            fprintf(err,"%sillegal character in floating-point argument.\n",emsg);
+            errline(i,((unsigned long)end)-(unsigned long)argv[i],err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        lv = strtol(cp,&end,0);
+        if( *end ){
+          if( err ){
+            fprintf(err,"%sillegal character in integer argument.\n",emsg);
+            errline(i,((unsigned long)end)-(unsigned long)argv[i],err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        sv = cp;
+        break;
+    }
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_DBL:
+        *(double*)(op[j].arg) = dv;
+        break;
+      case OPT_FDBL:
+        (*(void(*)())(op[j].arg))(dv);
+        break;
+      case OPT_INT:
+        *(int*)(op[j].arg) = lv;
+        break;
+      case OPT_FINT:
+        (*(void(*)())(op[j].arg))((int)lv);
+        break;
+      case OPT_STR:
+        *(char**)(op[j].arg) = sv;
+        break;
+      case OPT_FSTR:
+        (*(void(*)())(op[j].arg))(sv);
+        break;
+    }
+  }
+  return errcnt;
+}
+
+int OptInit(a,o,err)
+char **a;
+struct s_options *o;
+FILE *err;
+{
+  int errcnt = 0;
+  argv = a;
+  op = o;
+  errstream = err;
+  if( argv && *argv && op ){
+    int i;
+    for(i=1; argv[i]; i++){
+      if( argv[i][0]=='+' || argv[i][0]=='-' ){
+        errcnt += handleflags(i,err);
+      }else if( strchr(argv[i],'=') ){
+        errcnt += handleswitch(i,err);
+      }
+    }
+  }
+  if( errcnt>0 ){
+    fprintf(err,"Valid command line options for \"%s\" are:\n",*a);
+    OptPrint();
+    exit(1);
+  }
+  return 0;
+}
+
+int OptNArgs(){
+  int cnt = 0;
+  int dashdash = 0;
+  int i;
+  if( argv!=0 && argv[0]!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ) cnt++;
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return cnt;
+}
+
+char *OptArg(n)
+int n;
+{
+  int i;
+  i = argindex(n);
+  return i>=0 ? argv[i] : 0;
+}
+
+void OptErr(n)
+int n;
+{
+  int i;
+  i = argindex(n);
+  if( i>=0 ) errline(i,0,errstream);
+}
+
+void OptPrint(){
+  int i;
+  int max, len;
+  max = 0;
+  for(i=0; op[i].label; i++){
+    len = strlen(op[i].label) + 1;
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        len += 9;       /* length of "<integer>" */
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        len += 6;       /* length of "<real>" */
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        len += 8;       /* length of "<string>" */
+        break;
+    }
+    if( len>max ) max = len;
+  }
+  for(i=0; op[i].label; i++){
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        fprintf(errstream,"  -%-*s  %s\n",max,op[i].label,op[i].message);
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        fprintf(errstream,"  %s=<integer>%*s  %s\n",op[i].label,
+          (int)(max-strlen(op[i].label)-9),"",op[i].message);
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        fprintf(errstream,"  %s=<real>%*s  %s\n",op[i].label,
+          (int)(max-strlen(op[i].label)-6),"",op[i].message);
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        fprintf(errstream,"  %s=<string>%*s  %s\n",op[i].label,
+          (int)(max-strlen(op[i].label)-8),"",op[i].message);
+        break;
+    }
+  }
+}
+/*********************** From the file "parse.c" ****************************/
+/*
+** Input file parser for the LEMON parser generator.
+*/
+
+/* The state of the parser */
+struct pstate {
+  char *filename;       /* Name of the input file */
+  int tokenlineno;      /* Linenumber at which current token starts */
+  int errorcnt;         /* Number of errors so far */
+  char *tokenstart;     /* Text of current token */
+  struct lemon *gp;     /* Global state vector */
+  enum e_state {
+    INITIALIZE,
+    WAITING_FOR_DECL_OR_RULE,
+    WAITING_FOR_DECL_KEYWORD,
+    WAITING_FOR_DECL_ARG,
+    WAITING_FOR_PRECEDENCE_SYMBOL,
+    WAITING_FOR_ARROW,
+    IN_RHS,
+    LHS_ALIAS_1,
+    LHS_ALIAS_2,
+    LHS_ALIAS_3,
+    RHS_ALIAS_1,
+    RHS_ALIAS_2,
+    PRECEDENCE_MARK_1,
+    PRECEDENCE_MARK_2,
+    RESYNC_AFTER_RULE_ERROR,
+    RESYNC_AFTER_DECL_ERROR,
+    WAITING_FOR_DESTRUCTOR_SYMBOL,
+    WAITING_FOR_DATATYPE_SYMBOL,
+    WAITING_FOR_FALLBACK_ID,
+    WAITING_FOR_WILDCARD_ID
+  } state;                   /* The state of the parser */
+  struct symbol *fallback;   /* The fallback token */
+  struct symbol *lhs;        /* Left-hand side of current rule */
+  char *lhsalias;            /* Alias for the LHS */
+  int nrhs;                  /* Number of right-hand side symbols seen */
+  struct symbol *rhs[MAXRHS];  /* RHS symbols */
+  char *alias[MAXRHS];       /* Aliases for each RHS symbol (or NULL) */
+  struct rule *prevrule;     /* Previous rule parsed */
+  char *declkeyword;         /* Keyword of a declaration */
+  char **declargslot;        /* Where the declaration argument should be put */
+  int *decllnslot;           /* Where the declaration linenumber is put */
+  enum e_assoc declassoc;    /* Assign this association to decl arguments */
+  int preccounter;           /* Assign this precedence to decl arguments */
+  struct rule *firstrule;    /* Pointer to first rule in the grammar */
+  struct rule *lastrule;     /* Pointer to the most recently parsed rule */
+};
+
+/* Parse a single token */
+static void parseonetoken(psp)
+struct pstate *psp;
+{
+  char *x;
+  x = Strsafe(psp->tokenstart);     /* Save the token permanently */
+#if 0
+  printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno,
+    x,psp->state);
+#endif
+  switch( psp->state ){
+    case INITIALIZE:
+      psp->prevrule = 0;
+      psp->preccounter = 0;
+      psp->firstrule = psp->lastrule = 0;
+      psp->gp->nrule = 0;
+      /* Fall thru to next case */
+    case WAITING_FOR_DECL_OR_RULE:
+      if( x[0]=='%' ){
+        psp->state = WAITING_FOR_DECL_KEYWORD;
+      }else if( islower(x[0]) ){
+        psp->lhs = Symbol_new(x);
+        psp->nrhs = 0;
+        psp->lhsalias = 0;
+        psp->state = WAITING_FOR_ARROW;
+      }else if( x[0]=='{' ){
+        if( psp->prevrule==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"There is not prior rule opon which to attach the code \
+fragment which begins on this line.");
+          psp->errorcnt++;
+	}else if( psp->prevrule->code!=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"Code fragment beginning on this line is not the first \
+to follow the previous rule.");
+          psp->errorcnt++;
+        }else{
+          psp->prevrule->line = psp->tokenlineno;
+          psp->prevrule->code = &x[1];
+	}
+      }else if( x[0]=='[' ){
+        psp->state = PRECEDENCE_MARK_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Token \"%s\" should be either \"%%\" or a nonterminal name.",
+          x);
+        psp->errorcnt++;
+      }
+      break;
+    case PRECEDENCE_MARK_1:
+      if( !isupper(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "The precedence symbol must be a terminal.");
+        psp->errorcnt++;
+      }else if( psp->prevrule==0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "There is no prior rule to assign precedence \"[%s]\".",x);
+        psp->errorcnt++;
+      }else if( psp->prevrule->precsym!=0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+"Precedence mark on this line is not the first \
+to follow the previous rule.");
+        psp->errorcnt++;
+      }else{
+        psp->prevrule->precsym = Symbol_new(x);
+      }
+      psp->state = PRECEDENCE_MARK_2;
+      break;
+    case PRECEDENCE_MARK_2:
+      if( x[0]!=']' ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"]\" on precedence mark.");
+        psp->errorcnt++;
+      }
+      psp->state = WAITING_FOR_DECL_OR_RULE;
+      break;
+    case WAITING_FOR_ARROW:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else if( x[0]=='(' ){
+        psp->state = LHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Expected to see a \":\" following the LHS symbol \"%s\".",
+          psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_1:
+      if( isalpha(x[0]) ){
+        psp->lhsalias = x;
+        psp->state = LHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the LHS \"%s\"\n",
+          x,psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = LHS_ALIAS_3;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_3:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"->\" following: \"%s(%s)\".",
+           psp->lhs->name,psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case IN_RHS:
+      if( x[0]=='.' ){
+        struct rule *rp;
+        rp = (struct rule *)calloc( sizeof(struct rule) + 
+             sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1);
+        if( rp==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Can't allocate enough memory for this rule.");
+          psp->errorcnt++;
+          psp->prevrule = 0;
+	}else{
+          int i;
+          rp->ruleline = psp->tokenlineno;
+          rp->rhs = (struct symbol**)&rp[1];
+          rp->rhsalias = (char**)&(rp->rhs[psp->nrhs]);
+          for(i=0; i<psp->nrhs; i++){
+            rp->rhs[i] = psp->rhs[i];
+            rp->rhsalias[i] = psp->alias[i];
+	  }
+          rp->lhs = psp->lhs;
+          rp->lhsalias = psp->lhsalias;
+          rp->nrhs = psp->nrhs;
+          rp->code = 0;
+          rp->precsym = 0;
+          rp->index = psp->gp->nrule++;
+          rp->nextlhs = rp->lhs->rule;
+          rp->lhs->rule = rp;
+          rp->next = 0;
+          if( psp->firstrule==0 ){
+            psp->firstrule = psp->lastrule = rp;
+	  }else{
+            psp->lastrule->next = rp;
+            psp->lastrule = rp;
+	  }
+          psp->prevrule = rp;
+	}
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( isalpha(x[0]) ){
+        if( psp->nrhs>=MAXRHS ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Too many symbols on RHS of rule beginning at \"%s\".",
+            x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_RULE_ERROR;
+	}else{
+          psp->rhs[psp->nrhs] = Symbol_new(x);
+          psp->alias[psp->nrhs] = 0;
+          psp->nrhs++;
+	}
+      }else if( (x[0]=='|' || x[0]=='/') && psp->nrhs>0 ){
+        struct symbol *msp = psp->rhs[psp->nrhs-1];
+        if( msp->type!=MULTITERMINAL ){
+          struct symbol *origsp = msp;
+          msp = calloc(1,sizeof(*msp));
+          memset(msp, 0, sizeof(*msp));
+          msp->type = MULTITERMINAL;
+          msp->nsubsym = 1;
+          msp->subsym = calloc(1,sizeof(struct symbol*));
+          msp->subsym[0] = origsp;
+          msp->name = origsp->name;
+          psp->rhs[psp->nrhs-1] = msp;
+        }
+        msp->nsubsym++;
+        msp->subsym = realloc(msp->subsym, sizeof(struct symbol*)*msp->nsubsym);
+        msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]);
+        if( islower(x[1]) || islower(msp->subsym[0]->name[0]) ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Cannot form a compound containing a non-terminal");
+          psp->errorcnt++;
+        }
+      }else if( x[0]=='(' && psp->nrhs>0 ){
+        psp->state = RHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal character on RHS of rule: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_1:
+      if( isalpha(x[0]) ){
+        psp->alias[psp->nrhs-1] = x;
+        psp->state = RHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n",
+          x,psp->rhs[psp->nrhs-1]->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case WAITING_FOR_DECL_KEYWORD:
+      if( isalpha(x[0]) ){
+        psp->declkeyword = x;
+        psp->declargslot = 0;
+        psp->decllnslot = 0;
+        psp->state = WAITING_FOR_DECL_ARG;
+        if( strcmp(x,"name")==0 ){
+          psp->declargslot = &(psp->gp->name);
+	}else if( strcmp(x,"include")==0 ){
+          psp->declargslot = &(psp->gp->include);
+          psp->decllnslot = &psp->gp->includeln;
+	}else if( strcmp(x,"code")==0 ){
+          psp->declargslot = &(psp->gp->extracode);
+          psp->decllnslot = &psp->gp->extracodeln;
+	}else if( strcmp(x,"token_destructor")==0 ){
+          psp->declargslot = &psp->gp->tokendest;
+          psp->decllnslot = &psp->gp->tokendestln;
+	}else if( strcmp(x,"default_destructor")==0 ){
+          psp->declargslot = &psp->gp->vardest;
+          psp->decllnslot = &psp->gp->vardestln;
+	}else if( strcmp(x,"token_prefix")==0 ){
+          psp->declargslot = &psp->gp->tokenprefix;
+	}else if( strcmp(x,"syntax_error")==0 ){
+          psp->declargslot = &(psp->gp->error);
+          psp->decllnslot = &psp->gp->errorln;
+	}else if( strcmp(x,"parse_accept")==0 ){
+          psp->declargslot = &(psp->gp->accept);
+          psp->decllnslot = &psp->gp->acceptln;
+	}else if( strcmp(x,"parse_failure")==0 ){
+          psp->declargslot = &(psp->gp->failure);
+          psp->decllnslot = &psp->gp->failureln;
+	}else if( strcmp(x,"stack_overflow")==0 ){
+          psp->declargslot = &(psp->gp->overflow);
+          psp->decllnslot = &psp->gp->overflowln;
+        }else if( strcmp(x,"extra_argument")==0 ){
+          psp->declargslot = &(psp->gp->arg);
+        }else if( strcmp(x,"token_type")==0 ){
+          psp->declargslot = &(psp->gp->tokentype);
+        }else if( strcmp(x,"default_type")==0 ){
+          psp->declargslot = &(psp->gp->vartype);
+        }else if( strcmp(x,"stack_size")==0 ){
+          psp->declargslot = &(psp->gp->stacksize);
+        }else if( strcmp(x,"start_symbol")==0 ){
+          psp->declargslot = &(psp->gp->start);
+        }else if( strcmp(x,"left")==0 ){
+          psp->preccounter++;
+          psp->declassoc = LEFT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"right")==0 ){
+          psp->preccounter++;
+          psp->declassoc = RIGHT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"nonassoc")==0 ){
+          psp->preccounter++;
+          psp->declassoc = NONE;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+	}else if( strcmp(x,"destructor")==0 ){
+          psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL;
+	}else if( strcmp(x,"type")==0 ){
+          psp->state = WAITING_FOR_DATATYPE_SYMBOL;
+        }else if( strcmp(x,"fallback")==0 ){
+          psp->fallback = 0;
+          psp->state = WAITING_FOR_FALLBACK_ID;
+        }else if( strcmp(x,"wildcard")==0 ){
+          psp->state = WAITING_FOR_WILDCARD_ID;
+        }else{
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Unknown declaration keyword: \"%%%s\".",x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+	}
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal declaration keyword: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_DESTRUCTOR_SYMBOL:
+      if( !isalpha(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %destructor keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        psp->declargslot = &sp->destructor;
+        psp->decllnslot = &sp->destructorln;
+        psp->state = WAITING_FOR_DECL_ARG;
+      }
+      break;
+    case WAITING_FOR_DATATYPE_SYMBOL:
+      if( !isalpha(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %destructor keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        psp->declargslot = &sp->datatype;
+        psp->decllnslot = 0;
+        psp->state = WAITING_FOR_DECL_ARG;
+      }
+      break;
+    case WAITING_FOR_PRECEDENCE_SYMBOL:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( isupper(x[0]) ){
+        struct symbol *sp;
+        sp = Symbol_new(x);
+        if( sp->prec>=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Symbol \"%s\" has already be given a precedence.",x);
+          psp->errorcnt++;
+	}else{
+          sp->prec = psp->preccounter;
+          sp->assoc = psp->declassoc;
+	}
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Can't assign a precedence to \"%s\".",x);
+        psp->errorcnt++;
+      }
+      break;
+    case WAITING_FOR_DECL_ARG:
+      if( (x[0]=='{' || x[0]=='\"' || isalnum(x[0])) ){
+        if( *(psp->declargslot)!=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "The argument \"%s\" to declaration \"%%%s\" is not the first.",
+            x[0]=='\"' ? &x[1] : x,psp->declkeyword);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+	}else{
+          *(psp->declargslot) = (x[0]=='\"' || x[0]=='{') ? &x[1] : x;
+          if( psp->decllnslot ) *psp->decllnslot = psp->tokenlineno;
+          psp->state = WAITING_FOR_DECL_OR_RULE;
+	}
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal argument to %%%s: %s",psp->declkeyword,x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_FALLBACK_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !isupper(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%fallback argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->fallback==0 ){
+          psp->fallback = sp;
+        }else if( sp->fallback ){
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "More than one fallback assigned to token %s", x);
+          psp->errorcnt++;
+        }else{
+          sp->fallback = psp->fallback;
+          psp->gp->has_fallback = 1;
+        }
+      }
+      break;
+    case WAITING_FOR_WILDCARD_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !isupper(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%wildcard argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->gp->wildcard==0 ){
+          psp->gp->wildcard = sp;
+        }else{
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "Extra wildcard to token: %s", x);
+          psp->errorcnt++;
+        }
+      }
+      break;
+    case RESYNC_AFTER_RULE_ERROR:
+/*      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+**      break; */
+    case RESYNC_AFTER_DECL_ERROR:
+      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+      if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD;
+      break;
+  }
+}
+
+/* Run the proprocessor over the input file text.  The global variables
+** azDefine[0] through azDefine[nDefine-1] contains the names of all defined
+** macros.  This routine looks for "%ifdef" and "%ifndef" and "%endif" and
+** comments them out.  Text in between is also commented out as appropriate.
+*/
+static void preprocess_input(char *z){
+  int i, j, k, n;
+  int exclude = 0;
+  int start = 0;
+  int lineno = 1;
+  int start_lineno = 1;
+  for(i=0; z[i]; i++){
+    if( z[i]=='\n' ) lineno++;
+    if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue;
+    if( strncmp(&z[i],"%endif",6)==0 && isspace(z[i+6]) ){
+      if( exclude ){
+        exclude--;
+        if( exclude==0 ){
+          for(j=start; j<i; j++) if( z[j]!='\n' ) z[j] = ' ';
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }else if( (strncmp(&z[i],"%ifdef",6)==0 && isspace(z[i+6]))
+          || (strncmp(&z[i],"%ifndef",7)==0 && isspace(z[i+7])) ){
+      if( exclude ){
+        exclude++;
+      }else{
+        for(j=i+7; isspace(z[j]); j++){}
+        for(n=0; z[j+n] && !isspace(z[j+n]); n++){}
+        exclude = 1;
+        for(k=0; k<nDefine; k++){
+          if( strncmp(azDefine[k],&z[j],n)==0 && strlen(azDefine[k])==n ){
+            exclude = 0;
+            break;
+          }
+        }
+        if( z[i+3]=='n' ) exclude = !exclude;
+        if( exclude ){
+          start = i;
+          start_lineno = lineno;
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }
+  }
+  if( exclude ){
+    fprintf(stderr,"unterminated %%ifdef starting on line %d\n", start_lineno);
+    exit(1);
+  }
+}
+
+/* In spite of its name, this function is really a scanner.  It read
+** in the entire input file (all at once) then tokenizes it.  Each
+** token is passed to the function "parseonetoken" which builds all
+** the appropriate data structures in the global state vector "gp".
+*/
+void Parse(gp)
+struct lemon *gp;
+{
+  struct pstate ps;
+  FILE *fp;
+  char *filebuf;
+  int filesize;
+  int lineno;
+  int c;
+  char *cp, *nextcp;
+  int startline = 0;
+
+  memset(&ps, '\0', sizeof(ps));
+  ps.gp = gp;
+  ps.filename = gp->filename;
+  ps.errorcnt = 0;
+  ps.state = INITIALIZE;
+
+  /* Begin by reading the input file */
+  fp = fopen(ps.filename,"rb");
+  if( fp==0 ){
+    ErrorMsg(ps.filename,0,"Can't open this file for reading.");
+    gp->errorcnt++;
+    return;
+  }
+  fseek(fp,0,2);
+  filesize = ftell(fp);
+  rewind(fp);
+  filebuf = (char *)malloc( filesize+1 );
+  if( filebuf==0 ){
+    ErrorMsg(ps.filename,0,"Can't allocate %d of memory to hold this file.",
+      filesize+1);
+    gp->errorcnt++;
+    return;
+  }
+  if( fread(filebuf,1,filesize,fp)!=filesize ){
+    ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
+      filesize);
+    free(filebuf);
+    gp->errorcnt++;
+    return;
+  }
+  fclose(fp);
+  filebuf[filesize] = 0;
+
+  /* Make an initial pass through the file to handle %ifdef and %ifndef */
+  preprocess_input(filebuf);
+
+  /* Now scan the text of the input file */
+  lineno = 1;
+  for(cp=filebuf; (c= *cp)!=0; ){
+    if( c=='\n' ) lineno++;              /* Keep track of the line number */
+    if( isspace(c) ){ cp++; continue; }  /* Skip all white space */
+    if( c=='/' && cp[1]=='/' ){          /* Skip C++ style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && c!='\n' ) cp++;
+      continue;
+    }
+    if( c=='/' && cp[1]=='*' ){          /* Skip C style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c ) cp++;
+      continue;
+    }
+    ps.tokenstart = cp;                /* Mark the beginning of the token */
+    ps.tokenlineno = lineno;           /* Linenumber on which token begins */
+    if( c=='\"' ){                     /* String literals */
+      cp++;
+      while( (c= *cp)!=0 && c!='\"' ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,startline,
+"String starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( c=='{' ){               /* A block of C code */
+      int level;
+      cp++;
+      for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){
+        if( c=='\n' ) lineno++;
+        else if( c=='{' ) level++;
+        else if( c=='}' ) level--;
+        else if( c=='/' && cp[1]=='*' ){  /* Skip comments */
+          int prevc;
+          cp = &cp[2];
+          prevc = 0;
+          while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){
+            if( c=='\n' ) lineno++;
+            prevc = c;
+            cp++;
+	  }
+	}else if( c=='/' && cp[1]=='/' ){  /* Skip C++ style comments too */
+          cp = &cp[2];
+          while( (c= *cp)!=0 && c!='\n' ) cp++;
+          if( c ) lineno++;
+	}else if( c=='\'' || c=='\"' ){    /* String a character literals */
+          int startchar, prevc;
+          startchar = c;
+          prevc = 0;
+          for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){
+            if( c=='\n' ) lineno++;
+            if( prevc=='\\' ) prevc = 0;
+            else              prevc = c;
+	  }
+	}
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,ps.tokenlineno,
+"C code starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( isalnum(c) ){          /* Identifiers */
+      while( (c= *cp)!=0 && (isalnum(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */
+      cp += 3;
+      nextcp = cp;
+    }else if( (c=='/' || c=='|') && isalpha(cp[1]) ){
+      cp += 2;
+      while( (c = *cp)!=0 && (isalnum(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else{                          /* All other (one character) operators */
+      cp++;
+      nextcp = cp;
+    }
+    c = *cp;
+    *cp = 0;                        /* Null terminate the token */
+    parseonetoken(&ps);             /* Parse the token */
+    *cp = c;                        /* Restore the buffer */
+    cp = nextcp;
+  }
+  free(filebuf);                    /* Release the buffer after parsing */
+  gp->rule = ps.firstrule;
+  gp->errorcnt = ps.errorcnt;
+}
+/*************************** From the file "plink.c" *********************/
+/*
+** Routines processing configuration follow-set propagation links
+** in the LEMON parser generator.
+*/
+static struct plink *plink_freelist = 0;
+
+/* Allocate a new plink */
+struct plink *Plink_new(){
+  struct plink *new;
+
+  if( plink_freelist==0 ){
+    int i;
+    int amt = 100;
+    plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) );
+    if( plink_freelist==0 ){
+      fprintf(stderr,
+      "Unable to allocate memory for a new follow-set propagation link.\n");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1];
+    plink_freelist[amt-1].next = 0;
+  }
+  new = plink_freelist;
+  plink_freelist = plink_freelist->next;
+  return new;
+}
+
+/* Add a plink to a plink list */
+void Plink_add(plpp,cfp)
+struct plink **plpp;
+struct config *cfp;
+{
+  struct plink *new;
+  new = Plink_new();
+  new->next = *plpp;
+  *plpp = new;
+  new->cfp = cfp;
+}
+
+/* Transfer every plink on the list "from" to the list "to" */
+void Plink_copy(to,from)
+struct plink **to;
+struct plink *from;
+{
+  struct plink *nextpl;
+  while( from ){
+    nextpl = from->next;
+    from->next = *to;
+    *to = from;
+    from = nextpl;
+  }
+}
+
+/* Delete every plink on the list */
+void Plink_delete(plp)
+struct plink *plp;
+{
+  struct plink *nextpl;
+
+  while( plp ){
+    nextpl = plp->next;
+    plp->next = plink_freelist;
+    plink_freelist = plp;
+    plp = nextpl;
+  }
+}
+/*********************** From the file "report.c" **************************/
+/*
+** Procedures for generating reports and tables in the LEMON parser generator.
+*/
+
+/* Generate a filename with the given suffix.  Space to hold the
+** name comes from malloc() and must be freed by the calling
+** function.
+*/
+PRIVATE char *file_makename(lemp,suffix)
+struct lemon *lemp;
+char *suffix;
+{
+  char *name;
+  char *cp;
+
+  name = malloc( strlen(lemp->filename) + strlen(suffix) + 5 );
+  if( name==0 ){
+    fprintf(stderr,"Can't allocate space for a filename.\n");
+    exit(1);
+  }
+  strcpy(name,lemp->filename);
+  cp = strrchr(name,'.');
+  if( cp ) *cp = 0;
+  strcat(name,suffix);
+  return name;
+}
+
+/* Open a file with a name based on the name of the input file,
+** but with a different (specified) suffix, and return a pointer
+** to the stream */
+PRIVATE FILE *file_open(lemp,suffix,mode)
+struct lemon *lemp;
+char *suffix;
+char *mode;
+{
+  FILE *fp;
+
+  if( lemp->outname ) free(lemp->outname);
+  lemp->outname = file_makename(lemp, suffix);
+  fp = fopen(lemp->outname,mode);
+  if( fp==0 && *mode=='w' ){
+    fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return fp;
+}
+
+/* Duplicate the input file without comments and without actions 
+** on rules */
+void Reprint(lemp)
+struct lemon *lemp;
+{
+  struct rule *rp;
+  struct symbol *sp;
+  int i, j, maxlen, len, ncolumns, skip;
+  printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename);
+  maxlen = 10;
+  for(i=0; i<lemp->nsymbol; i++){
+    sp = lemp->symbols[i];
+    len = strlen(sp->name);
+    if( len>maxlen ) maxlen = len;
+  }
+  ncolumns = 76/(maxlen+5);
+  if( ncolumns<1 ) ncolumns = 1;
+  skip = (lemp->nsymbol + ncolumns - 1)/ncolumns;
+  for(i=0; i<skip; i++){
+    printf("//");
+    for(j=i; j<lemp->nsymbol; j+=skip){
+      sp = lemp->symbols[j];
+      assert( sp->index==j );
+      printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name);
+    }
+    printf("\n");
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    printf("%s",rp->lhs->name);
+    /*    if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */
+    printf(" ::=");
+    for(i=0; i<rp->nrhs; i++){
+      sp = rp->rhs[i];
+      printf(" %s", sp->name);
+      if( sp->type==MULTITERMINAL ){
+        for(j=1; j<sp->nsubsym; j++){
+          printf("|%s", sp->subsym[j]->name);
+        }
+      }
+      /* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */
+    }
+    printf(".");
+    if( rp->precsym ) printf(" [%s]",rp->precsym->name);
+    /* if( rp->code ) printf("\n    %s",rp->code); */
+    printf("\n");
+  }
+}
+
+void ConfigPrint(fp,cfp)
+FILE *fp;
+struct config *cfp;
+{
+  struct rule *rp;
+  struct symbol *sp;
+  int i, j;
+  rp = cfp->rp;
+  fprintf(fp,"%s ::=",rp->lhs->name);
+  for(i=0; i<=rp->nrhs; i++){
+    if( i==cfp->dot ) fprintf(fp," *");
+    if( i==rp->nrhs ) break;
+    sp = rp->rhs[i];
+    fprintf(fp," %s", sp->name);
+    if( sp->type==MULTITERMINAL ){
+      for(j=1; j<sp->nsubsym; j++){
+        fprintf(fp,"|%s",sp->subsym[j]->name);
+      }
+    }
+  }
+}
+
+/* #define TEST */
+#if 0
+/* Print a set */
+PRIVATE void SetPrint(out,set,lemp)
+FILE *out;
+char *set;
+struct lemon *lemp;
+{
+  int i;
+  char *spacer;
+  spacer = "";
+  fprintf(out,"%12s[","");
+  for(i=0; i<lemp->nterminal; i++){
+    if( SetFind(set,i) ){
+      fprintf(out,"%s%s",spacer,lemp->symbols[i]->name);
+      spacer = " ";
+    }
+  }
+  fprintf(out,"]\n");
+}
+
+/* Print a plink chain */
+PRIVATE void PlinkPrint(out,plp,tag)
+FILE *out;
+struct plink *plp;
+char *tag;
+{
+  while( plp ){
+    fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->statenum);
+    ConfigPrint(out,plp->cfp);
+    fprintf(out,"\n");
+    plp = plp->next;
+  }
+}
+#endif
+
+/* Print an action to the given file descriptor.  Return FALSE if
+** nothing was actually printed.
+*/
+int PrintAction(struct action *ap, FILE *fp, int indent){
+  int result = 1;
+  switch( ap->type ){
+    case SHIFT:
+      fprintf(fp,"%*s shift  %d",indent,ap->sp->name,ap->x.stp->statenum);
+      break;
+    case REDUCE:
+      fprintf(fp,"%*s reduce %d",indent,ap->sp->name,ap->x.rp->index);
+      break;
+    case ACCEPT:
+      fprintf(fp,"%*s accept",indent,ap->sp->name);
+      break;
+    case ERROR:
+      fprintf(fp,"%*s error",indent,ap->sp->name);
+      break;
+    case SRCONFLICT:
+    case RRCONFLICT:
+      fprintf(fp,"%*s reduce %-3d ** Parsing conflict **",
+        indent,ap->sp->name,ap->x.rp->index);
+      break;
+    case SSCONFLICT:
+      fprintf(fp,"%*s shift  %d ** Parsing conflict **", 
+        indent,ap->sp->name,ap->x.stp->statenum);
+      break;
+    case SH_RESOLVED:
+    case RD_RESOLVED:
+    case NOT_USED:
+      result = 0;
+      break;
+  }
+  return result;
+}
+
+/* Generate the "y.output" log file */
+void ReportOutput(lemp)
+struct lemon *lemp;
+{
+  int i;
+  struct state *stp;
+  struct config *cfp;
+  struct action *ap;
+  FILE *fp;
+
+  fp = file_open(lemp,".out","wb");
+  if( fp==0 ) return;
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    fprintf(fp,"State %d:\n",stp->statenum);
+    if( lemp->basisflag ) cfp=stp->bp;
+    else                  cfp=stp->cfp;
+    while( cfp ){
+      char buf[20];
+      if( cfp->dot==cfp->rp->nrhs ){
+        sprintf(buf,"(%d)",cfp->rp->index);
+        fprintf(fp,"    %5s ",buf);
+      }else{
+        fprintf(fp,"          ");
+      }
+      ConfigPrint(fp,cfp);
+      fprintf(fp,"\n");
+#if 0
+      SetPrint(fp,cfp->fws,lemp);
+      PlinkPrint(fp,cfp->fplp,"To  ");
+      PlinkPrint(fp,cfp->bplp,"From");
+#endif
+      if( lemp->basisflag ) cfp=cfp->bp;
+      else                  cfp=cfp->next;
+    }
+    fprintf(fp,"\n");
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( PrintAction(ap,fp,30) ) fprintf(fp,"\n");
+    }
+    fprintf(fp,"\n");
+  }
+  fprintf(fp, "----------------------------------------------------\n");
+  fprintf(fp, "Symbols:\n");
+  for(i=0; i<lemp->nsymbol; i++){
+    int j;
+    struct symbol *sp;
+
+    sp = lemp->symbols[i];
+    fprintf(fp, "  %3d: %s", i, sp->name);
+    if( sp->type==NONTERMINAL ){
+      fprintf(fp, ":");
+      if( sp->lambda ){
+        fprintf(fp, " <lambda>");
+      }
+      for(j=0; j<lemp->nterminal; j++){
+        if( sp->firstset && SetFind(sp->firstset, j) ){
+          fprintf(fp, " %s", lemp->symbols[j]->name);
+        }
+      }
+    }
+    fprintf(fp, "\n");
+  }
+  fclose(fp);
+  return;
+}
+
+/* Search for the file "name" which is in the same directory as
+** the exacutable */
+PRIVATE char *pathsearch(argv0,name,modemask)
+char *argv0;
+char *name;
+int modemask;
+{
+  char *pathlist;
+  char *path,*cp;
+  char c;
+
+#ifdef __WIN32__
+  cp = strrchr(argv0,'\\');
+#else
+  cp = strrchr(argv0,'/');
+#endif
+  if( cp ){
+    c = *cp;
+    *cp = 0;
+    path = (char *)malloc( strlen(argv0) + strlen(name) + 2 );
+    if( path ) sprintf(path,"%s/%s",argv0,name);
+    *cp = c;
+  }else{
+    extern char *getenv();
+    pathlist = getenv("PATH");
+    if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
+    path = (char *)malloc( strlen(pathlist)+strlen(name)+2 );
+    if( path!=0 ){
+      while( *pathlist ){
+        cp = strchr(pathlist,':');
+        if( cp==0 ) cp = &pathlist[strlen(pathlist)];
+        c = *cp;
+        *cp = 0;
+        sprintf(path,"%s/%s",pathlist,name);
+        *cp = c;
+        if( c==0 ) pathlist = "";
+        else pathlist = &cp[1];
+        if( access(path,modemask)==0 ) break;
+      }
+    }
+  }
+  return path;
+}
+
+/* Given an action, compute the integer value for that action
+** which is to be put in the action table of the generated machine.
+** Return negative if no action should be generated.
+*/
+PRIVATE int compute_action(lemp,ap)
+struct lemon *lemp;
+struct action *ap;
+{
+  int act;
+  switch( ap->type ){
+    case SHIFT:  act = ap->x.stp->statenum;            break;
+    case REDUCE: act = ap->x.rp->index + lemp->nstate; break;
+    case ERROR:  act = lemp->nstate + lemp->nrule;     break;
+    case ACCEPT: act = lemp->nstate + lemp->nrule + 1; break;
+    default:     act = -1; break;
+  }
+  return act;
+}
+
+#define LINESIZE 1000
+/* The next cluster of routines are for reading the template file
+** and writing the results to the generated parser */
+/* The first function transfers data from "in" to "out" until
+** a line is seen which begins with "%%".  The line number is
+** tracked.
+**
+** if name!=0, then any word that begin with "Parse" is changed to
+** begin with *name instead.
+*/
+PRIVATE void tplt_xfer(name,in,out,lineno)
+char *name;
+FILE *in;
+FILE *out;
+int *lineno;
+{
+  int i, iStart;
+  char line[LINESIZE];
+  while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){
+    (*lineno)++;
+    iStart = 0;
+    if( name ){
+      for(i=0; line[i]; i++){
+        if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0
+          && (i==0 || !isalpha(line[i-1]))
+        ){
+          if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]);
+          fprintf(out,"%s",name);
+          i += 4;
+          iStart = i+1;
+        }
+      }
+    }
+    fprintf(out,"%s",&line[iStart]);
+  }
+}
+
+/* The next function finds the template file and opens it, returning
+** a pointer to the opened file. */
+PRIVATE FILE *tplt_open(lemp)
+struct lemon *lemp;
+{
+  static char templatename[] = "lempar.c";
+  char buf[1000];
+  FILE *in;
+  char *tpltname;
+  char *cp;
+
+  cp = strrchr(lemp->filename,'.');
+  if( cp ){
+    sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename);
+  }else{
+    sprintf(buf,"%s.lt",lemp->filename);
+  }
+  if( access(buf,004)==0 ){
+    tpltname = buf;
+  }else if( access(templatename,004)==0 ){
+    tpltname = templatename;
+  }else{
+    tpltname = pathsearch(lemp->argv0,templatename,0);
+  }
+  if( tpltname==0 ){
+    fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
+    templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  in = fopen(tpltname,"rb");
+  if( in==0 ){
+    fprintf(stderr,"Can't open the template file \"%s\".\n",templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return in;
+}
+
+/* Print a #line directive line to the output file. */
+PRIVATE void tplt_linedir(out,lineno,filename)
+FILE *out;
+int lineno;
+char *filename;
+{
+  fprintf(out,"#line %d \"",lineno);
+  while( *filename ){
+    if( *filename == '\\' ) putc('\\',out);
+    putc(*filename,out);
+    filename++;
+  }
+  fprintf(out,"\"\n");
+}
+
+/* Print a string to the file and keep the linenumber up to date */
+PRIVATE void tplt_print(out,lemp,str,strln,lineno)
+FILE *out;
+struct lemon *lemp;
+char *str;
+int strln;
+int *lineno;
+{
+  if( str==0 ) return;
+  tplt_linedir(out,strln,lemp->filename);
+  (*lineno)++;
+  while( *str ){
+    if( *str=='\n' ) (*lineno)++;
+    putc(*str,out);
+    str++;
+  }
+  if( str[-1]!='\n' ){
+    putc('\n',out);
+    (*lineno)++;
+  }
+  tplt_linedir(out,*lineno+2,lemp->outname); 
+  (*lineno)+=2;
+  return;
+}
+
+/*
+** The following routine emits code for the destructor for the
+** symbol sp
+*/
+void emit_destructor_code(out,sp,lemp,lineno)
+FILE *out;
+struct symbol *sp;
+struct lemon *lemp;
+int *lineno;
+{
+ char *cp = 0;
+
+ int linecnt = 0;
+ if( sp->type==TERMINAL ){
+   cp = lemp->tokendest;
+   if( cp==0 ) return;
+   tplt_linedir(out,lemp->tokendestln,lemp->filename);
+   fprintf(out,"{");
+ }else if( sp->destructor ){
+   cp = sp->destructor;
+   tplt_linedir(out,sp->destructorln,lemp->filename);
+   fprintf(out,"{");
+ }else if( lemp->vardest ){
+   cp = lemp->vardest;
+   if( cp==0 ) return;
+   tplt_linedir(out,lemp->vardestln,lemp->filename);
+   fprintf(out,"{");
+ }else{
+   assert( 0 );  /* Cannot happen */
+ }
+ for(; *cp; cp++){
+   if( *cp=='$' && cp[1]=='$' ){
+     fprintf(out,"(yypminor->yy%d)",sp->dtnum);
+     cp++;
+     continue;
+   }
+   if( *cp=='\n' ) linecnt++;
+   fputc(*cp,out);
+ }
+ (*lineno) += 3 + linecnt;
+ fprintf(out,"}\n");
+ tplt_linedir(out,*lineno,lemp->outname);
+ return;
+}
+
+/*
+** Return TRUE (non-zero) if the given symbol has a destructor.
+*/
+int has_destructor(sp, lemp)
+struct symbol *sp;
+struct lemon *lemp;
+{
+  int ret;
+  if( sp->type==TERMINAL ){
+    ret = lemp->tokendest!=0;
+  }else{
+    ret = lemp->vardest!=0 || sp->destructor!=0;
+  }
+  return ret;
+}
+
+/*
+** Append text to a dynamically allocated string.  If zText is 0 then
+** reset the string to be empty again.  Always return the complete text
+** of the string (which is overwritten with each call).
+**
+** n bytes of zText are stored.  If n==0 then all of zText up to the first
+** \000 terminator is stored.  zText can contain up to two instances of
+** %d.  The values of p1 and p2 are written into the first and second
+** %d.
+**
+** If n==-1, then the previous character is overwritten.
+*/
+PRIVATE char *append_str(char *zText, int n, int p1, int p2){
+  static char *z = 0;
+  static int alloced = 0;
+  static int used = 0;
+  int c;
+  char zInt[40];
+
+  if( zText==0 ){
+    used = 0;
+    return z;
+  }
+  if( n<=0 ){
+    if( n<0 ){
+      used += n;
+      assert( used>=0 );
+    }
+    n = strlen(zText);
+  }
+  if( n+sizeof(zInt)*2+used >= alloced ){
+    alloced = n + sizeof(zInt)*2 + used + 200;
+    z = realloc(z,  alloced);
+  }
+  if( z==0 ) return "";
+  while( n-- > 0 ){
+    c = *(zText++);
+    if( c=='%' && n>0 && zText[0]=='d' ){
+      sprintf(zInt, "%d", p1);
+      p1 = p2;
+      strcpy(&z[used], zInt);
+      used += strlen(&z[used]);
+      zText++;
+      n--;
+    }else{
+      z[used++] = c;
+    }
+  }
+  z[used] = 0;
+  return z;
+}
+
+/*
+** zCode is a string that is the action associated with a rule.  Expand
+** the symbols in this string so that the refer to elements of the parser
+** stack.
+*/
+PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){
+  char *cp, *xp;
+  int i;
+  char lhsused = 0;    /* True if the LHS element has been used */
+  char used[MAXRHS];   /* True for each RHS element which is used */
+
+  for(i=0; i<rp->nrhs; i++) used[i] = 0;
+  lhsused = 0;
+
+  if( rp->code==0 ){
+    rp->code = "\n";
+    rp->line = rp->ruleline;
+  }
+
+  append_str(0,0,0,0);
+  for(cp=rp->code; *cp; cp++){
+    if( isalpha(*cp) && (cp==rp->code || (!isalnum(cp[-1]) && cp[-1]!='_')) ){
+      char saved;
+      for(xp= &cp[1]; isalnum(*xp) || *xp=='_'; xp++);
+      saved = *xp;
+      *xp = 0;
+      if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
+        append_str("yygotominor.yy%d",0,rp->lhs->dtnum,0);
+        cp = xp;
+        lhsused = 1;
+      }else{
+        for(i=0; i<rp->nrhs; i++){
+          if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
+            if( cp!=rp->code && cp[-1]=='@' ){
+              /* If the argument is of the form @X then substituted
+              ** the token number of X, not the value of X */
+              append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0);
+            }else{
+              struct symbol *sp = rp->rhs[i];
+              int dtnum;
+              if( sp->type==MULTITERMINAL ){
+                dtnum = sp->subsym[0]->dtnum;
+              }else{
+                dtnum = sp->dtnum;
+              }
+              append_str("yymsp[%d].minor.yy%d",0,i-rp->nrhs+1, dtnum);
+            }
+            cp = xp;
+            used[i] = 1;
+            break;
+          }
+        }
+      }
+      *xp = saved;
+    }
+    append_str(cp, 1, 0, 0);
+  } /* End loop */
+
+  /* Check to make sure the LHS has been used */
+  if( rp->lhsalias && !lhsused ){
+    ErrorMsg(lemp->filename,rp->ruleline,
+      "Label \"%s\" for \"%s(%s)\" is never used.",
+        rp->lhsalias,rp->lhs->name,rp->lhsalias);
+    lemp->errorcnt++;
+  }
+
+  /* Generate destructor code for RHS symbols which are not used in the
+  ** reduce code */
+  for(i=0; i<rp->nrhs; i++){
+    if( rp->rhsalias[i] && !used[i] ){
+      ErrorMsg(lemp->filename,rp->ruleline,
+        "Label %s for \"%s(%s)\" is never used.",
+        rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
+      lemp->errorcnt++;
+    }else if( rp->rhsalias[i]==0 ){
+      if( has_destructor(rp->rhs[i],lemp) ){
+        append_str("  yy_destructor(%d,&yymsp[%d].minor);\n", 0,
+           rp->rhs[i]->index,i-rp->nrhs+1);
+      }else{
+        /* No destructor defined for this term */
+      }
+    }
+  }
+  if( rp->code ){
+    cp = append_str(0,0,0,0);
+    rp->code = Strsafe(cp?cp:"");
+  }
+}
+
+/* 
+** Generate code which executes when the rule "rp" is reduced.  Write
+** the code to "out".  Make sure lineno stays up-to-date.
+*/
+PRIVATE void emit_code(out,rp,lemp,lineno)
+FILE *out;
+struct rule *rp;
+struct lemon *lemp;
+int *lineno;
+{
+ char *cp;
+ int linecnt = 0;
+
+ /* Generate code to do the reduce action */
+ if( rp->code ){
+   tplt_linedir(out,rp->line,lemp->filename);
+   fprintf(out,"{%s",rp->code);
+   for(cp=rp->code; *cp; cp++){
+     if( *cp=='\n' ) linecnt++;
+   } /* End loop */
+   (*lineno) += 3 + linecnt;
+   fprintf(out,"}\n");
+   tplt_linedir(out,*lineno,lemp->outname);
+ } /* End if( rp->code ) */
+
+ return;
+}
+
+/*
+** Print the definition of the union used for the parser's data stack.
+** This union contains fields for every possible data type for tokens
+** and nonterminals.  In the process of computing and printing this
+** union, also set the ".dtnum" field of every terminal and nonterminal
+** symbol.
+*/
+void print_stack_union(out,lemp,plineno,mhflag)
+FILE *out;                  /* The output stream */
+struct lemon *lemp;         /* The main info structure for this parser */
+int *plineno;               /* Pointer to the line number */
+int mhflag;                 /* True if generating makeheaders output */
+{
+  int lineno = *plineno;    /* The line number of the output */
+  char **types;             /* A hash table of datatypes */
+  int arraysize;            /* Size of the "types" array */
+  int maxdtlength;          /* Maximum length of any ".datatype" field. */
+  char *stddt;              /* Standardized name for a datatype */
+  int i,j;                  /* Loop counters */
+  int hash;                 /* For hashing the name of a type */
+  char *name;               /* Name of the parser */
+
+  /* Allocate and initialize types[] and allocate stddt[] */
+  arraysize = lemp->nsymbol * 2;
+  types = (char**)calloc( arraysize, sizeof(char*) );
+  for(i=0; i<arraysize; i++) types[i] = 0;
+  maxdtlength = 0;
+  if( lemp->vartype ){
+    maxdtlength = strlen(lemp->vartype);
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    int len;
+    struct symbol *sp = lemp->symbols[i];
+    if( sp->datatype==0 ) continue;
+    len = strlen(sp->datatype);
+    if( len>maxdtlength ) maxdtlength = len;
+  }
+  stddt = (char*)malloc( maxdtlength*2 + 1 );
+  if( types==0 || stddt==0 ){
+    fprintf(stderr,"Out of memory.\n");
+    exit(1);
+  }
+
+  /* Build a hash table of datatypes. The ".dtnum" field of each symbol
+  ** is filled in with the hash index plus 1.  A ".dtnum" value of 0 is
+  ** used for terminal symbols.  If there is no %default_type defined then
+  ** 0 is also used as the .dtnum value for nonterminals which do not specify
+  ** a datatype using the %type directive.
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    char *cp;
+    if( sp==lemp->errsym ){
+      sp->dtnum = arraysize+1;
+      continue;
+    }
+    if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){
+      sp->dtnum = 0;
+      continue;
+    }
+    cp = sp->datatype;
+    if( cp==0 ) cp = lemp->vartype;
+    j = 0;
+    while( isspace(*cp) ) cp++;
+    while( *cp ) stddt[j++] = *cp++;
+    while( j>0 && isspace(stddt[j-1]) ) j--;
+    stddt[j] = 0;
+    hash = 0;
+    for(j=0; stddt[j]; j++){
+      hash = hash*53 + stddt[j];
+    }
+    hash = (hash & 0x7fffffff)%arraysize;
+    while( types[hash] ){
+      if( strcmp(types[hash],stddt)==0 ){
+        sp->dtnum = hash + 1;
+        break;
+      }
+      hash++;
+      if( hash>=arraysize ) hash = 0;
+    }
+    if( types[hash]==0 ){
+      sp->dtnum = hash + 1;
+      types[hash] = (char*)malloc( strlen(stddt)+1 );
+      if( types[hash]==0 ){
+        fprintf(stderr,"Out of memory.\n");
+        exit(1);
+      }
+      strcpy(types[hash],stddt);
+    }
+  }
+
+  /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */
+  name = lemp->name ? lemp->name : "Parse";
+  lineno = *plineno;
+  if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; }
+  fprintf(out,"#define %sTOKENTYPE %s\n",name,
+    lemp->tokentype?lemp->tokentype:"void*");  lineno++;
+  if( mhflag ){ fprintf(out,"#endif\n"); lineno++; }
+  fprintf(out,"typedef union {\n"); lineno++;
+  fprintf(out,"  %sTOKENTYPE yy0;\n",name); lineno++;
+  for(i=0; i<arraysize; i++){
+    if( types[i]==0 ) continue;
+    fprintf(out,"  %s yy%d;\n",types[i],i+1); lineno++;
+    free(types[i]);
+  }
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"  int yy%d;\n",lemp->errsym->dtnum); lineno++;
+  }
+  free(stddt);
+  free(types);
+  fprintf(out,"} YYMINORTYPE;\n"); lineno++;
+  *plineno = lineno;
+}
+
+/*
+** Return the name of a C datatype able to represent values between
+** lwr and upr, inclusive.
+*/
+static const char *minimum_size_type(int lwr, int upr){
+  if( lwr>=0 ){
+    if( upr<=255 ){
+      return "unsigned char";
+    }else if( upr<65535 ){
+      return "unsigned short int";
+    }else{
+      return "unsigned int";
+    }
+  }else if( lwr>=-127 && upr<=127 ){
+    return "signed char";
+  }else if( lwr>=-32767 && upr<32767 ){
+    return "short";
+  }else{
+    return "int";
+  }
+}
+
+/*
+** Each state contains a set of token transaction and a set of
+** nonterminal transactions.  Each of these sets makes an instance
+** of the following structure.  An array of these structures is used
+** to order the creation of entries in the yy_action[] table.
+*/
+struct axset {
+  struct state *stp;   /* A pointer to a state */
+  int isTkn;           /* True to use tokens.  False for non-terminals */
+  int nAction;         /* Number of actions */
+};
+
+/*
+** Compare to axset structures for sorting purposes
+*/
+static int axset_compare(const void *a, const void *b){
+  struct axset *p1 = (struct axset*)a;
+  struct axset *p2 = (struct axset*)b;
+  return p2->nAction - p1->nAction;
+}
+
+/*
+** Write text on "out" that describes the rule "rp".
+*/
+static void writeRuleText(FILE *out, struct rule *rp){
+  int j;
+  fprintf(out,"%s ::=", rp->lhs->name);
+  for(j=0; j<rp->nrhs; j++){
+    struct symbol *sp = rp->rhs[j];
+    fprintf(out," %s", sp->name);
+    if( sp->type==MULTITERMINAL ){
+      int k;
+      for(k=1; k<sp->nsubsym; k++){
+        fprintf(out,"|%s",sp->subsym[k]->name);
+      }
+    }
+  }
+}
+
+
+/* Generate C source code for the parser */
+void ReportTable(lemp, mhflag)
+struct lemon *lemp;
+int mhflag;     /* Output in makeheaders format if true */
+{
+  FILE *out, *in;
+  char line[LINESIZE];
+  int  lineno;
+  struct state *stp;
+  struct action *ap;
+  struct rule *rp;
+  struct acttab *pActtab;
+  int i, j, n;
+  char *name;
+  int mnTknOfst, mxTknOfst;
+  int mnNtOfst, mxNtOfst;
+  struct axset *ax;
+
+  in = tplt_open(lemp);
+  if( in==0 ) return;
+  out = file_open(lemp,".c","wb");
+  if( out==0 ){
+    fclose(in);
+    return;
+  }
+  lineno = 1;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the include code, if any */
+  tplt_print(out,lemp,lemp->include,lemp->includeln,&lineno);
+  if( mhflag ){
+    char *name = file_makename(lemp, ".h");
+    fprintf(out,"#include \"%s\"\n", name); lineno++;
+    free(name);
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate #defines for all tokens */
+  if( mhflag ){
+    char *prefix;
+    fprintf(out,"#if INTERFACE\n"); lineno++;
+    if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+    else                    prefix = "";
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
+      lineno++;
+    }
+    fprintf(out,"#endif\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the defines */
+  fprintf(out,"#define YYCODETYPE %s\n",
+    minimum_size_type(0, lemp->nsymbol+5)); lineno++;
+  fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol+1);  lineno++;
+  fprintf(out,"#define YYACTIONTYPE %s\n",
+    minimum_size_type(0, lemp->nstate+lemp->nrule+5));  lineno++;
+  if( lemp->wildcard ){
+    fprintf(out,"#define YYWILDCARD %d\n",
+       lemp->wildcard->index); lineno++;
+  }
+  print_stack_union(out,lemp,&lineno,mhflag);
+  fprintf(out, "#ifndef YYSTACKDEPTH\n"); lineno++;
+  if( lemp->stacksize ){
+    fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize);  lineno++;
+  }else{
+    fprintf(out,"#define YYSTACKDEPTH 100\n");  lineno++;
+  }
+  fprintf(out, "#endif\n"); lineno++;
+  if( mhflag ){
+    fprintf(out,"#if INTERFACE\n"); lineno++;
+  }
+  name = lemp->name ? lemp->name : "Parse";
+  if( lemp->arg && lemp->arg[0] ){
+    int i;
+    i = strlen(lemp->arg);
+    while( i>=1 && isspace(lemp->arg[i-1]) ) i--;
+    while( i>=1 && (isalnum(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--;
+    fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n",
+                 name,lemp->arg,&lemp->arg[i]);  lineno++;
+    fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n",
+                 name,&lemp->arg[i],&lemp->arg[i]);  lineno++;
+  }else{
+    fprintf(out,"#define %sARG_SDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_PDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_FETCH\n",name); lineno++;
+    fprintf(out,"#define %sARG_STORE\n",name); lineno++;
+  }
+  if( mhflag ){
+    fprintf(out,"#endif\n"); lineno++;
+  }
+  fprintf(out,"#define YYNSTATE %d\n",lemp->nstate);  lineno++;
+  fprintf(out,"#define YYNRULE %d\n",lemp->nrule);  lineno++;
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index);  lineno++;
+    fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum);  lineno++;
+  }
+  if( lemp->has_fallback ){
+    fprintf(out,"#define YYFALLBACK 1\n");  lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the action table and its associates:
+  **
+  **  yy_action[]        A single table containing all actions.
+  **  yy_lookahead[]     A table containing the lookahead for each entry in
+  **                     yy_action.  Used to detect hash collisions.
+  **  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.
+  */
+
+  /* Compute the actions on all states and count them up */
+  ax = calloc(lemp->nstate*2, sizeof(ax[0]));
+  if( ax==0 ){
+    fprintf(stderr,"malloc failed\n");
+    exit(1);
+  }
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    ax[i*2].stp = stp;
+    ax[i*2].isTkn = 1;
+    ax[i*2].nAction = stp->nTknAct;
+    ax[i*2+1].stp = stp;
+    ax[i*2+1].isTkn = 0;
+    ax[i*2+1].nAction = stp->nNtAct;
+  }
+  mxTknOfst = mnTknOfst = 0;
+  mxNtOfst = mnNtOfst = 0;
+
+  /* Compute the action table.  In order to try to keep the size of the
+  ** action table to a minimum, the heuristic of placing the largest action
+  ** sets first is used.
+  */
+  qsort(ax, lemp->nstate*2, sizeof(ax[0]), axset_compare);
+  pActtab = acttab_alloc();
+  for(i=0; i<lemp->nstate*2 && ax[i].nAction>0; i++){
+    stp = ax[i].stp;
+    if( ax[i].isTkn ){
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index>=lemp->nterminal ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iTknOfst = acttab_insert(pActtab);
+      if( stp->iTknOfst<mnTknOfst ) mnTknOfst = stp->iTknOfst;
+      if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst;
+    }else{
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index<lemp->nterminal ) continue;
+        if( ap->sp->index==lemp->nsymbol ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iNtOfst = acttab_insert(pActtab);
+      if( stp->iNtOfst<mnNtOfst ) mnNtOfst = stp->iNtOfst;
+      if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst;
+    }
+  }
+  free(ax);
+
+  /* Output the yy_action table */
+  fprintf(out,"static const YYACTIONTYPE yy_action[] = {\n"); lineno++;
+  n = acttab_size(pActtab);
+  for(i=j=0; i<n; i++){
+    int action = acttab_yyaction(pActtab, i);
+    if( action<0 ) action = lemp->nstate + lemp->nrule + 2;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", action);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_lookahead table */
+  fprintf(out,"static const YYCODETYPE yy_lookahead[] = {\n"); lineno++;
+  for(i=j=0; i<n; i++){
+    int la = acttab_yylookahead(pActtab, i);
+    if( la<0 ) la = lemp->nsymbol;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", la);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_shift_ofst[] table */
+  fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", mnTknOfst-1); lineno++;
+  n = lemp->nstate;
+  while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--;
+  fprintf(out, "#define YY_SHIFT_MAX %d\n", n-1); lineno++;
+  fprintf(out, "static const %s yy_shift_ofst[] = {\n", 
+          minimum_size_type(mnTknOfst-1, mxTknOfst)); lineno++;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iTknOfst;
+    if( ofst==NO_OFFSET ) ofst = mnTknOfst - 1;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_reduce_ofst[] table */
+  fprintf(out, "#define YY_REDUCE_USE_DFLT (%d)\n", mnNtOfst-1); lineno++;
+  n = lemp->nstate;
+  while( n>0 && lemp->sorted[n-1]->iNtOfst==NO_OFFSET ) n--;
+  fprintf(out, "#define YY_REDUCE_MAX %d\n", n-1); lineno++;
+  fprintf(out, "static const %s yy_reduce_ofst[] = {\n", 
+          minimum_size_type(mnNtOfst-1, mxNtOfst)); lineno++;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iNtOfst;
+    if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the default action table */
+  fprintf(out, "static const YYACTIONTYPE yy_default[] = {\n"); lineno++;
+  n = lemp->nstate;
+  for(i=j=0; i<n; i++){
+    stp = lemp->sorted[i];
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", stp->iDflt);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of fallback tokens.
+  */
+  if( lemp->has_fallback ){
+    for(i=0; i<lemp->nterminal; i++){
+      struct symbol *p = lemp->symbols[i];
+      if( p->fallback==0 ){
+        fprintf(out, "    0,  /* %10s => nothing */\n", p->name);
+      }else{
+        fprintf(out, "  %3d,  /* %10s => %s */\n", p->fallback->index,
+          p->name, p->fallback->name);
+      }
+      lineno++;
+    }
+  }
+  tplt_xfer(lemp->name, in, out, &lineno);
+
+  /* Generate a table containing the symbolic name of every symbol
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    sprintf(line,"\"%s\",",lemp->symbols[i]->name);
+    fprintf(out,"  %-15s",line);
+    if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; }
+  }
+  if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate a table containing a text string that describes every
+  ** rule in the rule set of the grammer.  This information is used
+  ** when tracing REDUCE actions.
+  */
+  for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
+    assert( rp->index==i );
+    fprintf(out," /* %3d */ \"", i);
+    writeRuleText(out, rp);
+    fprintf(out,"\",\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes every time a symbol is popped from
+  ** the stack while processing errors or while destroying the parser. 
+  ** (In other words, generate the %destructor actions)
+  */
+  if( lemp->tokendest ){
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type!=TERMINAL ) continue;
+      fprintf(out,"    case %d: /* %s */\n",
+              sp->index, sp->name); lineno++;
+    }
+    for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++);
+    if( i<lemp->nsymbol ){
+      emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+      fprintf(out,"      break;\n"); lineno++;
+    }
+  }
+  if( lemp->vardest ){
+    struct symbol *dflt_sp = 0;
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type==TERMINAL ||
+          sp->index<=0 || sp->destructor!=0 ) continue;
+      fprintf(out,"    case %d: /* %s */\n",
+              sp->index, sp->name); lineno++;
+      dflt_sp = sp;
+    }
+    if( dflt_sp!=0 ){
+      emit_destructor_code(out,dflt_sp,lemp,&lineno);
+      fprintf(out,"      break;\n"); lineno++;
+    }
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
+    fprintf(out,"    case %d: /* %s */\n",
+            sp->index, sp->name); lineno++;
+
+    /* Combine duplicate destructors into a single case */
+    for(j=i+1; j<lemp->nsymbol; j++){
+      struct symbol *sp2 = lemp->symbols[j];
+      if( sp2 && sp2->type!=TERMINAL && sp2->destructor
+          && sp2->dtnum==sp->dtnum
+          && strcmp(sp->destructor,sp2->destructor)==0 ){
+         fprintf(out,"    case %d: /* %s */\n",
+                 sp2->index, sp2->name); lineno++;
+         sp2->destructor = 0;
+      }
+    }
+
+    emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+    fprintf(out,"      break;\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes whenever the parser stack overflows */
+  tplt_print(out,lemp,lemp->overflow,lemp->overflowln,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of rule information 
+  **
+  ** Note: This code depends on the fact that rules are number
+  ** sequentually beginning with 0.
+  */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    fprintf(out,"  { %d, %d },\n",rp->lhs->index,rp->nrhs); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which execution during each REDUCE action */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    translate_code(lemp, rp);
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    struct rule *rp2;
+    if( rp->code==0 ) continue;
+    fprintf(out,"      case %d: /* ", rp->index);
+    writeRuleText(out, rp);
+    fprintf(out, " */\n"); lineno++;
+    for(rp2=rp->next; rp2; rp2=rp2->next){
+      if( rp2->code==rp->code ){
+        fprintf(out,"      case %d: /* ", rp2->index);
+        writeRuleText(out, rp2);
+        fprintf(out," */\n"); lineno++;
+        rp2->code = 0;
+      }
+    }
+    emit_code(out,rp,lemp,&lineno);
+    fprintf(out,"        break;\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes if a parse fails */
+  tplt_print(out,lemp,lemp->failure,lemp->failureln,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when a syntax error occurs */
+  tplt_print(out,lemp,lemp->error,lemp->errorln,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when the parser accepts its input */
+  tplt_print(out,lemp,lemp->accept,lemp->acceptln,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Append any addition code the user desires */
+  tplt_print(out,lemp,lemp->extracode,lemp->extracodeln,&lineno);
+
+  fclose(in);
+  fclose(out);
+  return;
+}
+
+/* Generate a header file for the parser */
+void ReportHeader(lemp)
+struct lemon *lemp;
+{
+  FILE *out, *in;
+  char *prefix;
+  char line[LINESIZE];
+  char pattern[LINESIZE];
+  int i;
+
+  if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+  else                    prefix = "";
+  in = file_open(lemp,".h","rb");
+  if( in ){
+    for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){
+      sprintf(pattern,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
+      if( strcmp(line,pattern) ) break;
+    }
+    fclose(in);
+    if( i==lemp->nterminal ){
+      /* No change in the file.  Don't rewrite it. */
+      return;
+    }
+  }
+  out = file_open(lemp,".h","wb");
+  if( out ){
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
+    }
+    fclose(out);  
+  }
+  return;
+}
+
+/* Reduce the size of the action tables, if possible, by making use
+** of defaults.
+**
+** In this version, we take the most frequent REDUCE action and make
+** it the default.  Except, there is no default if the wildcard token
+** is a possible look-ahead.
+*/
+void CompressTables(lemp)
+struct lemon *lemp;
+{
+  struct state *stp;
+  struct action *ap, *ap2;
+  struct rule *rp, *rp2, *rbest;
+  int nbest, n;
+  int i;
+  int usesWildcard;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    nbest = 0;
+    rbest = 0;
+    usesWildcard = 0;
+
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==SHIFT && ap->sp==lemp->wildcard ){
+        usesWildcard = 1;
+      }
+      if( ap->type!=REDUCE ) continue;
+      rp = ap->x.rp;
+      if( rp->lhsStart ) continue;
+      if( rp==rbest ) continue;
+      n = 1;
+      for(ap2=ap->next; ap2; ap2=ap2->next){
+        if( ap2->type!=REDUCE ) continue;
+        rp2 = ap2->x.rp;
+        if( rp2==rbest ) continue;
+        if( rp2==rp ) n++;
+      }
+      if( n>nbest ){
+        nbest = n;
+        rbest = rp;
+      }
+    }
+ 
+    /* Do not make a default if the number of rules to default
+    ** is not at least 1 or if the wildcard token is a possible
+    ** lookahead.
+    */
+    if( nbest<1 || usesWildcard ) continue;
+
+
+    /* Combine matching REDUCE actions into a single default */
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) break;
+    }
+    assert( ap );
+    ap->sp = Symbol_new("{default}");
+    for(ap=ap->next; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED;
+    }
+    stp->ap = Action_sort(stp->ap);
+  }
+}
+
+
+/*
+** Compare two states for sorting purposes.  The smaller state is the
+** one with the most non-terminal actions.  If they have the same number
+** of non-terminal actions, then the smaller is the one with the most
+** token actions.
+*/
+static int stateResortCompare(const void *a, const void *b){
+  const struct state *pA = *(const struct state**)a;
+  const struct state *pB = *(const struct state**)b;
+  int n;
+
+  n = pB->nNtAct - pA->nNtAct;
+  if( n==0 ){
+    n = pB->nTknAct - pA->nTknAct;
+  }
+  return n;
+}
+
+
+/*
+** Renumber and resort states so that states with fewer choices
+** occur at the end.  Except, keep state 0 as the first state.
+*/
+void ResortStates(lemp)
+struct lemon *lemp;
+{
+  int i;
+  struct state *stp;
+  struct action *ap;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    stp->nTknAct = stp->nNtAct = 0;
+    stp->iDflt = lemp->nstate + lemp->nrule;
+    stp->iTknOfst = NO_OFFSET;
+    stp->iNtOfst = NO_OFFSET;
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( compute_action(lemp,ap)>=0 ){
+        if( ap->sp->index<lemp->nterminal ){
+          stp->nTknAct++;
+        }else if( ap->sp->index<lemp->nsymbol ){
+          stp->nNtAct++;
+        }else{
+          stp->iDflt = compute_action(lemp, ap);
+        }
+      }
+    }
+  }
+  qsort(&lemp->sorted[1], lemp->nstate-1, sizeof(lemp->sorted[0]),
+        stateResortCompare);
+  for(i=0; i<lemp->nstate; i++){
+    lemp->sorted[i]->statenum = i;
+  }
+}
+
+
+/***************** From the file "set.c" ************************************/
+/*
+** Set manipulation routines for the LEMON parser generator.
+*/
+
+static int size = 0;
+
+/* Set the set size */
+void SetSize(n)
+int n;
+{
+  size = n+1;
+}
+
+/* Allocate a new set */
+char *SetNew(){
+  char *s;
+  s = (char*)calloc( size, 1);
+  if( s==0 ){
+    extern void memory_error();
+    memory_error();
+  }
+  return s;
+}
+
+/* Deallocate a set */
+void SetFree(s)
+char *s;
+{
+  free(s);
+}
+
+/* Add a new element to the set.  Return TRUE if the element was added
+** and FALSE if it was already there. */
+int SetAdd(s,e)
+char *s;
+int e;
+{
+  int rv;
+  assert( e>=0 && e<size );
+  rv = s[e];
+  s[e] = 1;
+  return !rv;
+}
+
+/* Add every element of s2 to s1.  Return TRUE if s1 changes. */
+int SetUnion(s1,s2)
+char *s1;
+char *s2;
+{
+  int i, progress;
+  progress = 0;
+  for(i=0; i<size; i++){
+    if( s2[i]==0 ) continue;
+    if( s1[i]==0 ){
+      progress = 1;
+      s1[i] = 1;
+    }
+  }
+  return progress;
+}
+/********************** From the file "table.c" ****************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+
+PRIVATE int strhash(x)
+char *x;
+{
+  int h = 0;
+  while( *x) h = h*13 + *(x++);
+  return h;
+}
+
+/* Works like strdup, sort of.  Save a string in malloced memory, but
+** keep strings in a table so that the same string is not in more
+** than one place.
+*/
+char *Strsafe(y)
+char *y;
+{
+  char *z;
+
+  if( y==0 ) return 0;
+  z = Strsafe_find(y);
+  if( z==0 && (z=malloc( strlen(y)+1 ))!=0 ){
+    strcpy(z,y);
+    Strsafe_insert(z);
+  }
+  MemoryCheck(z);
+  return z;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x1".
+*/
+struct s_x1 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x1node *tbl;  /* The data stored here */
+  struct s_x1node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x1".
+*/
+typedef struct s_x1node {
+  char *data;                  /* The data */
+  struct s_x1node *next;   /* Next entry with the same hash */
+  struct s_x1node **from;  /* Previous link */
+} x1node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x1 *x1a;
+
+/* Allocate a new associative array */
+void Strsafe_init(){
+  if( x1a ) return;
+  x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
+  if( x1a ){
+    x1a->size = 1024;
+    x1a->count = 0;
+    x1a->tbl = (x1node*)malloc( 
+      (sizeof(x1node) + sizeof(x1node*))*1024 );
+    if( x1a->tbl==0 ){
+      free(x1a);
+      x1a = 0;
+    }else{
+      int i;
+      x1a->ht = (x1node**)&(x1a->tbl[1024]);
+      for(i=0; i<1024; i++) x1a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Strsafe_insert(data)
+char *data;
+{
+  x1node *np;
+  int h;
+  int ph;
+
+  if( x1a==0 ) return 0;
+  ph = strhash(data);
+  h = ph & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x1a->count>=x1a->size ){
+    /* Need to make the hash table bigger */
+    int i,size;
+    struct s_x1 array;
+    array.size = size = x1a->size*2;
+    array.count = x1a->count;
+    array.tbl = (x1node*)malloc(
+      (sizeof(x1node) + sizeof(x1node*))*size );
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x1node**)&(array.tbl[size]);
+    for(i=0; i<size; i++) array.ht[i] = 0;
+    for(i=0; i<x1a->count; i++){
+      x1node *oldnp, *newnp;
+      oldnp = &(x1a->tbl[i]);
+      h = strhash(oldnp->data) & (size-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x1a->tbl);
+    *x1a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x1a->size-1);
+  np = &(x1a->tbl[x1a->count++]);
+  np->data = data;
+  if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next);
+  np->next = x1a->ht[h];
+  x1a->ht[h] = np;
+  np->from = &(x1a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+char *Strsafe_find(key)
+char *key;
+{
+  int h;
+  x1node *np;
+
+  if( x1a==0 ) return 0;
+  h = strhash(key) & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return a pointer to the (terminal or nonterminal) symbol "x".
+** Create a new symbol if this is the first time "x" has been seen.
+*/
+struct symbol *Symbol_new(x)
+char *x;
+{
+  struct symbol *sp;
+
+  sp = Symbol_find(x);
+  if( sp==0 ){
+    sp = (struct symbol *)calloc(1, sizeof(struct symbol) );
+    MemoryCheck(sp);
+    sp->name = Strsafe(x);
+    sp->type = isupper(*x) ? TERMINAL : NONTERMINAL;
+    sp->rule = 0;
+    sp->fallback = 0;
+    sp->prec = -1;
+    sp->assoc = UNK;
+    sp->firstset = 0;
+    sp->lambda = LEMON_FALSE;
+    sp->destructor = 0;
+    sp->datatype = 0;
+    sp->useCnt = 0;
+    Symbol_insert(sp,sp->name);
+  }
+  sp->useCnt++;
+  return sp;
+}
+
+/* Compare two symbols for working purposes
+**
+** Symbols that begin with upper case letters (terminals or tokens)
+** must sort before symbols that begin with lower case letters
+** (non-terminals).  Other than that, the order does not matter.
+**
+** We find experimentally that leaving the symbols in their original
+** order (the order they appeared in the grammar file) gives the
+** smallest parser tables in SQLite.
+*/
+int Symbolcmpp(struct symbol **a, struct symbol **b){
+  int i1 = (**a).index + 10000000*((**a).name[0]>'Z');
+  int i2 = (**b).index + 10000000*((**b).name[0]>'Z');
+  return i1-i2;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x2".
+*/
+struct s_x2 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x2node *tbl;  /* The data stored here */
+  struct s_x2node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x2".
+*/
+typedef struct s_x2node {
+  struct symbol *data;                  /* The data */
+  char *key;                   /* The key */
+  struct s_x2node *next;   /* Next entry with the same hash */
+  struct s_x2node **from;  /* Previous link */
+} x2node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x2 *x2a;
+
+/* Allocate a new associative array */
+void Symbol_init(){
+  if( x2a ) return;
+  x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
+  if( x2a ){
+    x2a->size = 128;
+    x2a->count = 0;
+    x2a->tbl = (x2node*)malloc( 
+      (sizeof(x2node) + sizeof(x2node*))*128 );
+    if( x2a->tbl==0 ){
+      free(x2a);
+      x2a = 0;
+    }else{
+      int i;
+      x2a->ht = (x2node**)&(x2a->tbl[128]);
+      for(i=0; i<128; i++) x2a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Symbol_insert(data,key)
+struct symbol *data;
+char *key;
+{
+  x2node *np;
+  int h;
+  int ph;
+
+  if( x2a==0 ) return 0;
+  ph = strhash(key);
+  h = ph & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x2a->count>=x2a->size ){
+    /* Need to make the hash table bigger */
+    int i,size;
+    struct s_x2 array;
+    array.size = size = x2a->size*2;
+    array.count = x2a->count;
+    array.tbl = (x2node*)malloc(
+      (sizeof(x2node) + sizeof(x2node*))*size );
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x2node**)&(array.tbl[size]);
+    for(i=0; i<size; i++) array.ht[i] = 0;
+    for(i=0; i<x2a->count; i++){
+      x2node *oldnp, *newnp;
+      oldnp = &(x2a->tbl[i]);
+      h = strhash(oldnp->key) & (size-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x2a->tbl);
+    *x2a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x2a->size-1);
+  np = &(x2a->tbl[x2a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next);
+  np->next = x2a->ht[h];
+  x2a->ht[h] = np;
+  np->from = &(x2a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct symbol *Symbol_find(key)
+char *key;
+{
+  int h;
+  x2node *np;
+
+  if( x2a==0 ) return 0;
+  h = strhash(key) & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return the n-th data.  Return NULL if n is out of range. */
+struct symbol *Symbol_Nth(n)
+int n;
+{
+  struct symbol *data;
+  if( x2a && n>0 && n<=x2a->count ){
+    data = x2a->tbl[n-1].data;
+  }else{
+    data = 0;
+  }
+  return data;
+}
+
+/* Return the size of the array */
+int Symbol_count()
+{
+  return x2a ? x2a->count : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct symbol **Symbol_arrayof()
+{
+  struct symbol **array;
+  int i,size;
+  if( x2a==0 ) return 0;
+  size = x2a->count;
+  array = (struct symbol **)calloc(size, sizeof(struct symbol *));
+  if( array ){
+    for(i=0; i<size; i++) array[i] = x2a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Compare two configurations */
+int Configcmp(a,b)
+struct config *a;
+struct config *b;
+{
+  int x;
+  x = a->rp->index - b->rp->index;
+  if( x==0 ) x = a->dot - b->dot;
+  return x;
+}
+
+/* Compare two states */
+PRIVATE int statecmp(a,b)
+struct config *a;
+struct config *b;
+{
+  int rc;
+  for(rc=0; rc==0 && a && b;  a=a->bp, b=b->bp){
+    rc = a->rp->index - b->rp->index;
+    if( rc==0 ) rc = a->dot - b->dot;
+  }
+  if( rc==0 ){
+    if( a ) rc = 1;
+    if( b ) rc = -1;
+  }
+  return rc;
+}
+
+/* Hash a state */
+PRIVATE int statehash(a)
+struct config *a;
+{
+  int h=0;
+  while( a ){
+    h = h*571 + a->rp->index*37 + a->dot;
+    a = a->bp;
+  }
+  return h;
+}
+
+/* Allocate a new state structure */
+struct state *State_new()
+{
+  struct state *new;
+  new = (struct state *)calloc(1, sizeof(struct state) );
+  MemoryCheck(new);
+  return new;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x3".
+*/
+struct s_x3 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x3node *tbl;  /* The data stored here */
+  struct s_x3node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x3".
+*/
+typedef struct s_x3node {
+  struct state *data;                  /* The data */
+  struct config *key;                   /* The key */
+  struct s_x3node *next;   /* Next entry with the same hash */
+  struct s_x3node **from;  /* Previous link */
+} x3node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x3 *x3a;
+
+/* Allocate a new associative array */
+void State_init(){
+  if( x3a ) return;
+  x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
+  if( x3a ){
+    x3a->size = 128;
+    x3a->count = 0;
+    x3a->tbl = (x3node*)malloc( 
+      (sizeof(x3node) + sizeof(x3node*))*128 );
+    if( x3a->tbl==0 ){
+      free(x3a);
+      x3a = 0;
+    }else{
+      int i;
+      x3a->ht = (x3node**)&(x3a->tbl[128]);
+      for(i=0; i<128; i++) x3a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int State_insert(data,key)
+struct state *data;
+struct config *key;
+{
+  x3node *np;
+  int h;
+  int ph;
+
+  if( x3a==0 ) return 0;
+  ph = statehash(key);
+  h = ph & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x3a->count>=x3a->size ){
+    /* Need to make the hash table bigger */
+    int i,size;
+    struct s_x3 array;
+    array.size = size = x3a->size*2;
+    array.count = x3a->count;
+    array.tbl = (x3node*)malloc(
+      (sizeof(x3node) + sizeof(x3node*))*size );
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x3node**)&(array.tbl[size]);
+    for(i=0; i<size; i++) array.ht[i] = 0;
+    for(i=0; i<x3a->count; i++){
+      x3node *oldnp, *newnp;
+      oldnp = &(x3a->tbl[i]);
+      h = statehash(oldnp->key) & (size-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x3a->tbl);
+    *x3a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x3a->size-1);
+  np = &(x3a->tbl[x3a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next);
+  np->next = x3a->ht[h];
+  x3a->ht[h] = np;
+  np->from = &(x3a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct state *State_find(key)
+struct config *key;
+{
+  int h;
+  x3node *np;
+
+  if( x3a==0 ) return 0;
+  h = statehash(key) & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct state **State_arrayof()
+{
+  struct state **array;
+  int i,size;
+  if( x3a==0 ) return 0;
+  size = x3a->count;
+  array = (struct state **)malloc( sizeof(struct state *)*size );
+  if( array ){
+    for(i=0; i<size; i++) array[i] = x3a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Hash a configuration */
+PRIVATE int confighash(a)
+struct config *a;
+{
+  int h=0;
+  h = h*571 + a->rp->index*37 + a->dot;
+  return h;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x4".
+*/
+struct s_x4 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x4node *tbl;  /* The data stored here */
+  struct s_x4node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x4".
+*/
+typedef struct s_x4node {
+  struct config *data;                  /* The data */
+  struct s_x4node *next;   /* Next entry with the same hash */
+  struct s_x4node **from;  /* Previous link */
+} x4node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x4 *x4a;
+
+/* Allocate a new associative array */
+void Configtable_init(){
+  if( x4a ) return;
+  x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
+  if( x4a ){
+    x4a->size = 64;
+    x4a->count = 0;
+    x4a->tbl = (x4node*)malloc( 
+      (sizeof(x4node) + sizeof(x4node*))*64 );
+    if( x4a->tbl==0 ){
+      free(x4a);
+      x4a = 0;
+    }else{
+      int i;
+      x4a->ht = (x4node**)&(x4a->tbl[64]);
+      for(i=0; i<64; i++) x4a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Configtable_insert(data)
+struct config *data;
+{
+  x4node *np;
+  int h;
+  int ph;
+
+  if( x4a==0 ) return 0;
+  ph = confighash(data);
+  h = ph & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp(np->data,data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x4a->count>=x4a->size ){
+    /* Need to make the hash table bigger */
+    int i,size;
+    struct s_x4 array;
+    array.size = size = x4a->size*2;
+    array.count = x4a->count;
+    array.tbl = (x4node*)malloc(
+      (sizeof(x4node) + sizeof(x4node*))*size );
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x4node**)&(array.tbl[size]);
+    for(i=0; i<size; i++) array.ht[i] = 0;
+    for(i=0; i<x4a->count; i++){
+      x4node *oldnp, *newnp;
+      oldnp = &(x4a->tbl[i]);
+      h = confighash(oldnp->data) & (size-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x4a->tbl);
+    *x4a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x4a->size-1);
+  np = &(x4a->tbl[x4a->count++]);
+  np->data = data;
+  if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next);
+  np->next = x4a->ht[h];
+  x4a->ht[h] = np;
+  np->from = &(x4a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct config *Configtable_find(key)
+struct config *key;
+{
+  int h;
+  x4node *np;
+
+  if( x4a==0 ) return 0;
+  h = confighash(key) & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp(np->data,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Remove all data from the table.  Pass each data to the function "f"
+** as it is removed.  ("f" may be null to avoid this step.) */
+void Configtable_clear(f)
+int(*f)(/* struct config * */);
+{
+  int i;
+  if( x4a==0 || x4a->count==0 ) return;
+  if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
+  for(i=0; i<x4a->size; i++) x4a->ht[i] = 0;
+  x4a->count = 0;
+  return;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/lempar.c b/client/src/thirdparty/sqlite-3.4.2/tool/lempar.c
new file mode 100644
index 0000000..cca91ad
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/lempar.c
@@ -0,0 +1,769 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is include which follows the "include" declaration
+** in the input file. */
+#include <stdio.h>
+%%
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/* 
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands. 
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+%%
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 terminals
+**                       and nonterminals.  "int" is used otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE which corresponds
+**                       to no legal terminal or nonterminal number.  This
+**                       number is used to fill in empty slots of the hash 
+**                       table.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       have fall-back values which should be used if the
+**                       original value of the token will not parse.
+**    YYACTIONTYPE       is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 rules and
+**                       states combined.  "int" is used otherwise.
+**    ParseTOKENTYPE     is the data type used for minor tokens given 
+**                       directly to the parser from the tokenizer.
+**    YYMINORTYPE        is the data type used for all minor tokens.
+**                       This is typically a union of many types, one of
+**                       which is ParseTOKENTYPE.  The entry in the union
+**                       for base tokens is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    ParseARG_SDECL     A static variable declaration for the %extra_argument
+**    ParseARG_PDECL     A parameter declaration for the %extra_argument
+**    ParseARG_STORE     Code to store %extra_argument into yypParser
+**    ParseARG_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 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
+** functions that take a state number and lookahead value and return an
+** action integer.  
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
+**
+**   N == YYNSTATE+YYNRULE              A syntax error has occurred.
+**
+**   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
+**
+**   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+**      yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.  
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  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.
+*/
+%%
+#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0]))
+
+/* The next table maps tokens into fallback tokens.  If a construct
+** like the following:
+** 
+**      %fallback ID X Y Z.
+**
+** appears in the grammer, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+%%
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+  int stateno;       /* The state-number */
+  int major;         /* The major token value.  This is the code
+                     ** number for the token at this stack level */
+  YYMINORTYPE minor; /* The user-supplied minor token value.  This
+                     ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+  int yyidx;                    /* Index of top element in stack */
+  int yyerrcnt;                 /* Shifts left before out of the error */
+  ParseARG_SDECL                /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+  int yystksz;                  /* Current side of the stack */
+  yyStackEntry *yystack;        /* The parser's stack */
+#else
+  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* 
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL 
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
+  yyTraceFILE = TraceFILE;
+  yyTracePrompt = zTracePrompt;
+  if( yyTraceFILE==0 ) yyTracePrompt = 0;
+  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+static const char *const yyTokenName[] = { 
+%%
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+%%
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.
+*/
+static void yyGrowStack(yyParser *p){
+  int newSize;
+  yyStackEntry *pNew;
+
+  newSize = p->yystksz*2 + 100;
+  pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+  if( pNew ){
+    p->yystack = pNew;
+    p->yystksz = newSize;
+#ifndef NDEBUG
+    if( yyTraceFILE ){
+      fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
+              yyTracePrompt, p->yystksz);
+    }
+#endif
+  }
+}
+#endif
+
+/* 
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to Parse and ParseFree.
+*/
+void *ParseAlloc(void *(*mallocProc)(size_t)){
+  yyParser *pParser;
+  pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
+  if( pParser ){
+    pParser->yyidx = -1;
+#if YYSTACKDEPTH<=0
+    yyGrowStack(pParser);
+#endif
+  }
+  return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol.  The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){
+  switch( yymajor ){
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is 
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are not used
+    ** inside the C code.
+    */
+%%
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static int yy_pop_parser_stack(yyParser *pParser){
+  YYCODETYPE yymajor;
+  yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+  if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+  if( yyTraceFILE && pParser->yyidx>=0 ){
+    fprintf(yyTraceFILE,"%sPopping %s\n",
+      yyTracePrompt,
+      yyTokenName[yytos->major]);
+  }
+#endif
+  yymajor = yytos->major;
+  yy_destructor( yymajor, &yytos->minor);
+  pParser->yyidx--;
+  return yymajor;
+}
+
+/* 
+** Deallocate and destroy a parser.  Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li>  A pointer to the parser.  This should be a pointer
+**       obtained from ParseAlloc.
+** <li>  A pointer to a function used to reclaim memory obtained
+**       from malloc.
+** </ul>
+*/
+void ParseFree(
+  void *p,                    /* The parser to be deleted */
+  void (*freeProc)(void*)     /* Function used to reclaim memory */
+){
+  yyParser *pParser = (yyParser*)p;
+  if( pParser==0 ) return;
+  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+  free(pParser->yystack);
+#endif
+  (*freeProc)((void*)pParser);
+}
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_shift_action(
+  yyParser *pParser,        /* The parser */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+  int stateno = pParser->yystack[pParser->yyidx].stateno;
+ 
+  if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+    return yy_default[stateno];
+  }
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+  if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
+    if( iLookAhead>0 ){
+#ifdef YYFALLBACK
+      int iFallback;            /* Fallback token */
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+        }
+#endif
+        return yy_find_shift_action(pParser, iFallback);
+      }
+#endif
+#ifdef YYWILDCARD
+      {
+        int j = i - iLookAhead + YYWILDCARD;
+        if( j>=0 && j<YY_SZ_ACTTAB && yy_lookahead[j]==YYWILDCARD ){
+#ifndef NDEBUG
+          if( yyTraceFILE ){
+            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+               yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
+          }
+#endif /* NDEBUG */
+          return yy_action[j];
+        }
+      }
+#endif /* YYWILDCARD */
+    }
+    return yy_default[stateno];
+  }else{
+    return yy_action[i];
+  }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_reduce_action(
+  int stateno,              /* Current state number */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+  assert( stateno<=YY_REDUCE_MAX );
+  i = yy_reduce_ofst[stateno];
+  assert( i!=YY_REDUCE_USE_DFLT );
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+  assert( i>=0 && i<YY_SZ_ACTTAB );
+  assert( yy_lookahead[i]==iLookAhead );
+  return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
+   ParseARG_FETCH;
+   yypParser->yyidx--;
+#ifndef NDEBUG
+   if( yyTraceFILE ){
+     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+   }
+#endif
+   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+   /* Here code is inserted which will execute if the parser
+   ** stack every overflows */
+%%
+   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+  yyParser *yypParser,          /* The parser to be shifted */
+  int yyNewState,               /* The new state to shift in */
+  int yyMajor,                  /* The major token to shift in */
+  YYMINORTYPE *yypMinor         /* Pointer ot the minor token to shift in */
+){
+  yyStackEntry *yytos;
+  yypParser->yyidx++;
+#if YYSTACKDEPTH>0 
+  if( yypParser->yyidx>=YYSTACKDEPTH ){
+    yyStackOverflow(yypParser, yypMinor);
+    return;
+  }
+#else
+  if( yypParser->yyidx>=yypParser->yystksz ){
+    yyGrowStack(yypParser);
+    if( yypParser->yyidx>=yypParser->yystksz ){
+      yyStackOverflow(yypParser, yypMinor);
+      return;
+    }
+  }
+#endif
+  yytos = &yypParser->yystack[yypParser->yyidx];
+  yytos->stateno = yyNewState;
+  yytos->major = yyMajor;
+  yytos->minor = *yypMinor;
+#ifndef NDEBUG
+  if( yyTraceFILE && yypParser->yyidx>0 ){
+    int i;
+    fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
+    fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
+    for(i=1; i<=yypParser->yyidx; i++)
+      fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
+    fprintf(yyTraceFILE,"\n");
+  }
+#endif
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
+  unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+%%
+};
+
+static void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+  yyParser *yypParser,         /* The parser */
+  int yyruleno                 /* Number of the rule by which to reduce */
+){
+  int yygoto;                     /* The next state */
+  int yyact;                      /* The next action */
+  YYMINORTYPE yygotominor;        /* The LHS of the rule reduced */
+  yyStackEntry *yymsp;            /* The top of the parser's stack */
+  int yysize;                     /* Amount to pop the stack */
+  ParseARG_FETCH;
+  yymsp = &yypParser->yystack[yypParser->yyidx];
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno>=0 
+        && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+    fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
+      yyRuleName[yyruleno]);
+  }
+#endif /* NDEBUG */
+
+  /* Silence complaints from purify about yygotominor being uninitialized
+  ** in some cases when it is copied into the stack after the following
+  ** switch.  yygotominor is uninitialized when a rule reduces that does
+  ** not set the value of its left-hand side nonterminal.  Leaving the
+  ** value of the nonterminal uninitialized is utterly harmless as long
+  ** as the value is never used.  So really the only thing this code
+  ** accomplishes is to quieten purify.  
+  **
+  ** 2007-01-16:  The wireshark project (www.wireshark.org) reports that
+  ** without this code, their parser segfaults.  I'm not sure what there
+  ** parser is doing to make this happen.  This is the second bug report
+  ** from wireshark this week.  Clearly they are stressing Lemon in ways
+  ** that it has not been previously stressed...  (SQLite ticket #2172)
+  */
+  memset(&yygotominor, 0, sizeof(yygotominor));
+
+
+  switch( yyruleno ){
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+%%
+  };
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
+  yypParser->yyidx -= yysize;
+  yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto);
+  if( yyact < YYNSTATE ){
+#ifdef NDEBUG
+    /* If we are not debugging and the reduce action popped at least
+    ** one element off the stack, then we can push the new element back
+    ** onto the stack here, and skip the stack overflow test in yy_shift().
+    ** That gives a significant speed improvement. */
+    if( yysize ){
+      yypParser->yyidx++;
+      yymsp -= yysize-1;
+      yymsp->stateno = yyact;
+      yymsp->major = yygoto;
+      yymsp->minor = yygotominor;
+    }else
+#endif
+    {
+      yy_shift(yypParser,yyact,yygoto,&yygotominor);
+    }
+  }else{
+    assert( yyact == YYNSTATE + YYNRULE + 1 );
+    yy_accept(yypParser);
+  }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+static void yy_parse_failed(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+  yyParser *yypParser,           /* The parser */
+  int yymajor,                   /* The major type of the error token */
+  YYMINORTYPE yyminor            /* The minor type of the error token */
+){
+  ParseARG_FETCH;
+#define TOKEN (yyminor.yy0)
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void Parse(
+  void *yyp,                   /* The parser */
+  int yymajor,                 /* The major token code number */
+  ParseTOKENTYPE yyminor       /* The value for the token */
+  ParseARG_PDECL               /* Optional %extra_argument parameter */
+){
+  YYMINORTYPE yyminorunion;
+  int yyact;            /* The parser action. */
+  int yyendofinput;     /* True if we are at the end of input */
+#ifdef YYERRORSYMBOL
+  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
+#endif
+  yyParser *yypParser;  /* The parser */
+
+  /* (re)initialize the parser, if necessary */
+  yypParser = (yyParser*)yyp;
+  if( yypParser->yyidx<0 ){
+#if YYSTACKDEPTH<=0
+    if( yypParser->yystksz <=0 ){
+      memset(&yyminorunion, 0, sizeof(yyminorunion));
+      yyStackOverflow(yypParser, &yyminorunion);
+      return;
+    }
+#endif
+    yypParser->yyidx = 0;
+    yypParser->yyerrcnt = -1;
+    yypParser->yystack[0].stateno = 0;
+    yypParser->yystack[0].major = 0;
+  }
+  yyminorunion.yy0 = yyminor;
+  yyendofinput = (yymajor==0);
+  ParseARG_STORE;
+
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
+  }
+#endif
+
+  do{
+    yyact = yy_find_shift_action(yypParser,yymajor);
+    if( yyact<YYNSTATE ){
+      assert( !yyendofinput );  /* Impossible to shift the $ token */
+      yy_shift(yypParser,yyact,yymajor,&yyminorunion);
+      yypParser->yyerrcnt--;
+      yymajor = YYNOCODE;
+    }else if( yyact < YYNSTATE + YYNRULE ){
+      yy_reduce(yypParser,yyact-YYNSTATE);
+    }else{
+      assert( yyact == YY_ERROR_ACTION );
+#ifdef YYERRORSYMBOL
+      int yymx;
+#endif
+#ifndef NDEBUG
+      if( yyTraceFILE ){
+        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+      }
+#endif
+#ifdef YYERRORSYMBOL
+      /* A syntax error has occurred.
+      ** The response to an error depends upon whether or not the
+      ** grammar defines an error token "ERROR".  
+      **
+      ** This is what we do if the grammar does define ERROR:
+      **
+      **  * Call the %syntax_error function.
+      **
+      **  * Begin popping the stack until we enter a state where
+      **    it is legal to shift the error symbol, then shift
+      **    the error symbol.
+      **
+      **  * Set the error count to three.
+      **
+      **  * Begin accepting and shifting new tokens.  No new error
+      **    processing will occur until three tokens have been
+      **    shifted successfully.
+      **
+      */
+      if( yypParser->yyerrcnt<0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yymx = yypParser->yystack[yypParser->yyidx].major;
+      if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+             yyTracePrompt,yyTokenName[yymajor]);
+        }
+#endif
+        yy_destructor(yymajor,&yyminorunion);
+        yymajor = YYNOCODE;
+      }else{
+         while(
+          yypParser->yyidx >= 0 &&
+          yymx != YYERRORSYMBOL &&
+          (yyact = yy_find_reduce_action(
+                        yypParser->yystack[yypParser->yyidx].stateno,
+                        YYERRORSYMBOL)) >= YYNSTATE
+        ){
+          yy_pop_parser_stack(yypParser);
+        }
+        if( yypParser->yyidx < 0 || yymajor==0 ){
+          yy_destructor(yymajor,&yyminorunion);
+          yy_parse_failed(yypParser);
+          yymajor = YYNOCODE;
+        }else if( yymx!=YYERRORSYMBOL ){
+          YYMINORTYPE u2;
+          u2.YYERRSYMDT = 0;
+          yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
+        }
+      }
+      yypParser->yyerrcnt = 3;
+      yyerrorhit = 1;
+#else  /* YYERRORSYMBOL is not defined */
+      /* This is what we do if the grammar does not define ERROR:
+      **
+      **  * Report an error message, and throw away the input token.
+      **
+      **  * If the input token is $, then fail the parse.
+      **
+      ** As before, subsequent error messages are suppressed until
+      ** three input tokens have been successfully shifted.
+      */
+      if( yypParser->yyerrcnt<=0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yypParser->yyerrcnt = 3;
+      yy_destructor(yymajor,&yyminorunion);
+      if( yyendofinput ){
+        yy_parse_failed(yypParser);
+      }
+      yymajor = YYNOCODE;
+#endif
+    }
+  }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
+  return;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/memleak.awk b/client/src/thirdparty/sqlite-3.4.2/tool/memleak.awk
new file mode 100644
index 0000000..928d3b6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/memleak.awk
@@ -0,0 +1,29 @@
+#
+# This script looks for memory leaks by analyzing the output of "sqlite" 
+# when compiled with the SQLITE_DEBUG=2 option.
+#
+/[0-9]+ malloc / {
+  mem[$6] = $0
+}
+/[0-9]+ realloc / {
+  mem[$8] = "";
+  mem[$10] = $0
+}
+/[0-9]+ free / {
+  if (mem[$6]=="") {
+    print "*** free without a malloc at",$6
+  }
+  mem[$6] = "";
+  str[$6] = ""
+}
+/^string at / {
+  addr = $4
+  sub("string at " addr " is ","")
+  str[addr] = $0
+}
+END {
+  for(addr in mem){
+    if( mem[addr]=="" ) continue
+    print mem[addr], str[addr]
+  }
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/memleak2.awk b/client/src/thirdparty/sqlite-3.4.2/tool/memleak2.awk
new file mode 100644
index 0000000..5d81b70
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/memleak2.awk
@@ -0,0 +1,29 @@
+# This AWK script reads the output of testfixture when compiled for memory
+# debugging.  It generates SQL commands that can be fed into an sqlite 
+# instance to determine what memory is never freed.  A typical usage would
+# be as follows:
+#
+#     make -f memleak.mk fulltest 2>mem.out
+#     awk -f ../sqlite/tool/memleak2.awk mem.out | ./sqlite :memory:
+#
+# The job performed by this script is the same as that done by memleak.awk.
+# The difference is that this script uses much less memory when the size
+# of the mem.out file is huge.
+#
+BEGIN {
+  print "CREATE TABLE mem(loc INTEGER PRIMARY KEY, src);"
+}
+/[0-9]+ malloc / {
+  print "INSERT INTO mem VALUES(" strtonum($6) ",'" $0 "');"
+}
+/[0-9]+ realloc / {
+  print "INSERT INTO mem VALUES(" strtonum($10) \
+           ",(SELECT src FROM mem WHERE loc=" strtonum($8) "));"
+  print "DELETE FROM mem WHERE loc=" strtonum($8) ";"
+}
+/[0-9]+ free / {
+  print "DELETE FROM mem WHERE loc=" strtonum($6) ";"
+}
+END {
+  print "SELECT src FROM mem;"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/memleak3.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/memleak3.tcl
new file mode 100644
index 0000000..3c6e9b9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/memleak3.tcl
@@ -0,0 +1,233 @@
+#/bin/sh
+# \
+exec `which tclsh` $0 "$@"
+#
+# 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.
+######################################################################
+
+set doco "
+This script is a tool to help track down memory leaks in the sqlite
+library. The library must be compiled with the preprocessor symbol
+SQLITE_MEMDEBUG set to at least 2. It must be set to 3 to enable stack 
+traces.
+
+To use, run the leaky application and save the standard error output.
+Then, execute this program with the first argument the name of the
+application binary (or interpreter) and the second argument the name of the
+text file that contains the collected stderr output.
+
+If all goes well a summary of unfreed allocations is printed out. If the
+GNU C library is in use and SQLITE_DEBUG is 3 or greater a stack trace is
+printed out for each unmatched allocation.
+
+If the \"-r <n>\" option is passed, then the program stops and prints out
+the state of the heap immediately after the <n>th call to malloc() or
+realloc().
+
+Example:
+
+$ ./testfixture ../sqlite/test/select1.test 2> memtrace.out
+$ tclsh $argv0 ?-r <malloc-number>? ./testfixture memtrace.out
+"
+
+
+proc usage {} {
+  set prg [file tail $::argv0]
+  puts "Usage: $prg ?-r <malloc-number>? <binary file> <mem trace file>"
+  puts ""
+  puts [string trim $::doco]
+  exit -1
+}
+
+proc shift {listvar} {
+  upvar $listvar l
+  set ret [lindex $l 0]
+  set l [lrange $l 1 end]
+  return $ret
+}
+
+# Argument handling. The following vars are set:
+#
+# $exe       - the name of the executable (i.e. "testfixture" or "./sqlite3")
+# $memfile   - the name of the file containing the trace output.
+# $report_at - The malloc number to stop and report at. Or -1 to read 
+#              all of $memfile.
+#
+set report_at -1
+while {[llength $argv]>2} {
+  set arg [shift argv]
+  switch -- $arg {
+    "-r" {
+      set report_at [shift argv]
+    }
+    default {
+      usage
+    }
+  }
+}
+if {[llength $argv]!=2} usage
+set exe [lindex $argv 0]
+set memfile [lindex $argv 1]
+
+# If stack traces are enabled, the 'addr2line' program is called to
+# translate a binary stack address into a human-readable form.
+set addr2line addr2line
+
+# When the SQLITE_MEMDEBUG is set as described above, SQLite prints
+# out a line for each malloc(), realloc() or free() call that the
+# library makes. If SQLITE_MEMDEBUG is 3, then a stack trace is printed
+# out before each malloc() and realloc() line.
+#
+# This program parses each line the SQLite library outputs and updates
+# the following global Tcl variables to reflect the "current" state of
+# the heap used by SQLite.
+#
+set nBytes 0               ;# Total number of bytes currently allocated.
+set nMalloc 0              ;# Total number of malloc()/realloc() calls.
+set nPeak 0                ;# Peak of nBytes.
+set iPeak 0                ;# nMalloc when nPeak was set.
+#
+# More detailed state information is stored in the $memmap array. 
+# Each key in the memmap array is the address of a chunk of memory
+# currently allocated from the heap. The value is a list of the 
+# following form
+# 
+#     {<number-of-bytes> <malloc id> <stack trace>}
+#
+array unset memmap
+
+proc process_input {input_file array_name} {
+  upvar $array_name mem 
+  set input [open $input_file]
+
+  set MALLOC {([[:digit:]]+) malloc ([[:digit:]]+) bytes at 0x([[:xdigit:]]+)}
+  # set STACK {^[[:digit:]]+: STACK: (.*)$}
+  set STACK {^STACK: (.*)$}
+  set FREE {[[:digit:]]+ free ([[:digit:]]+) bytes at 0x([[:xdigit:]]+)}
+  set REALLOC {([[:digit:]]+) realloc ([[:digit:]]+) to ([[:digit:]]+)}
+  append REALLOC { bytes at 0x([[:xdigit:]]+) to 0x([[:xdigit:]]+)}
+
+  set stack ""
+  while { ![eof $input] } {
+    set line [gets $input]
+    if {[regexp $STACK $line dummy stack]} {
+      # Do nothing. The variable $stack now stores the hexadecimal stack dump
+      # for the next malloc() or realloc().
+
+    } elseif { [regexp $MALLOC $line dummy mallocid bytes addr]  } {
+      # If this is a 'malloc' line, set an entry in the mem array. Each entry
+      # is a list of length three, the number of bytes allocated , the malloc
+      # number and the stack dump when it was allocated.
+      set mem($addr) [list $bytes "malloc $mallocid" $stack]
+      set stack ""
+
+      # Increase the current heap usage
+      incr ::nBytes $bytes
+
+      # Increase the number of malloc() calls
+      incr ::nMalloc
+
+      if {$::nBytes > $::nPeak} {
+        set ::nPeak $::nBytes
+        set ::iPeak $::nMalloc
+      }
+
+    } elseif { [regexp $FREE $line dummy bytes addr] } {
+      # If this is a 'free' line, remove the entry from the mem array. If the 
+      # entry does not exist, or is the wrong number of bytes, announce a
+      # problem. This is more likely a bug in the regular expressions for
+      # this script than an SQLite defect.
+      if { [lindex $mem($addr) 0] != $bytes } {
+        error "byte count mismatch"
+      }
+      unset mem($addr) 
+
+      # Decrease the current heap usage
+      incr ::nBytes [expr -1 * $bytes]
+
+    } elseif { [regexp $REALLOC $line dummy mallocid ob b oa a] } {
+      # "free" the old allocation in the internal model:
+      incr ::nBytes [expr -1 * $ob]
+      unset mem($oa);
+
+      # "malloc" the new allocation
+      set mem($a) [list $b "realloc $mallocid" $stack]
+      incr ::nBytes $b
+      set stack ""
+
+      # Increase the number of malloc() calls
+      incr ::nMalloc
+
+      if {$::nBytes > $::nPeak} {
+        set ::nPeak $::nBytes
+        set ::iPeak $::nMalloc
+      }
+
+    } else {
+      # puts "REJECT: $line"
+    }
+
+    if {$::nMalloc==$::report_at} report
+  }
+
+  close $input
+}
+
+proc printstack {stack} {
+  set fcount 10
+  if {[llength $stack]<10} {
+    set fcount [llength $stack]
+  }
+  foreach frame [lrange $stack 1 $fcount] {
+    foreach {f l} [split [exec $::addr2line -f --exe=$::exe $frame] \n] {}
+    puts [format "%-30s %s" $f $l]
+  }
+  if {[llength $stack]>0 } {puts ""}
+}
+
+proc report {} {
+
+  foreach key [array names ::memmap] {
+    set stack [lindex $::memmap($key) 2]
+    set bytes [lindex $::memmap($key) 0]
+    lappend summarymap($stack) $bytes
+  }
+
+  set sorted [list]
+  foreach stack [array names summarymap] {
+    set allocs $summarymap($stack)
+    set sum 0
+    foreach a $allocs {
+      incr sum $a
+    }
+    lappend sorted [list $sum $stack]
+  }
+
+  set sorted [lsort -integer -index 0 $sorted]
+  foreach s $sorted {
+    set sum [lindex $s 0]
+    set stack [lindex $s 1]
+    set allocs $summarymap($stack)
+    puts "$sum bytes in [llength $allocs] chunks ($allocs)"
+    printstack $stack
+  }
+
+  # Print out summary statistics
+  puts "Total allocations            : $::nMalloc"
+  puts "Total outstanding allocations: [array size ::memmap]" 
+  puts "Current heap usage           : $::nBytes bytes"
+  puts "Peak heap usage              : $::nPeak bytes (malloc #$::iPeak)"
+
+  exit
+}
+
+process_input $memfile memmap
+report
+
+
+
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/mkkeywordhash.c b/client/src/thirdparty/sqlite-3.4.2/tool/mkkeywordhash.c
new file mode 100644
index 0000000..3a34224
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/mkkeywordhash.c
@@ -0,0 +1,559 @@
+/*
+** Compile and run this standalone program in order to generate code that
+** implements a function that will translate alphabetic identifiers into
+** parser token codes.
+*/
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+/*
+** A header comment placed at the beginning of generated code.
+*/
+static const char zHdr[] = 
+  "/***** This file contains automatically generated code ******\n"
+  "**\n"
+  "** The code in this file has been automatically generated by\n"
+  "**\n"
+  "**     $Header: /sqlite/sqlite/tool/mkkeywordhash.c,v 1.31 2007/07/30 18:26:20 rse Exp $\n"
+  "**\n"
+  "** The code in this file implements a function that determines whether\n"
+  "** or not a given identifier is really an SQL keyword.  The same thing\n"
+  "** might be implemented more directly using a hand-written hash table.\n"
+  "** But by using this automatically generated code, the size of the code\n"
+  "** is substantially reduced.  This is important for embedded applications\n"
+  "** on platforms with limited memory.\n"
+  "*/\n"
+;
+
+/*
+** All the keywords of the SQL language are stored as in a hash
+** table composed of instances of the following structure.
+*/
+typedef struct Keyword Keyword;
+struct Keyword {
+  char *zName;         /* The keyword name */
+  char *zTokenType;    /* Token value for this keyword */
+  int mask;            /* Code this keyword if non-zero */
+  int id;              /* Unique ID for this record */
+  int hash;            /* Hash on the keyword */
+  int offset;          /* Offset to start of name string */
+  int len;             /* Length of this keyword, not counting final \000 */
+  int prefix;          /* Number of characters in prefix */
+  int longestSuffix;   /* Longest suffix that is a prefix on another word */
+  int iNext;           /* Index in aKeywordTable[] of next with same hash */
+  int substrId;        /* Id to another keyword this keyword is embedded in */
+  int substrOffset;    /* Offset into substrId for start of this keyword */
+};
+
+/*
+** Define masks used to determine which keywords are allowed
+*/
+#ifdef SQLITE_OMIT_ALTERTABLE
+#  define ALTER      0
+#else
+#  define ALTER      0x00000001
+#endif
+#define ALWAYS       0x00000002
+#ifdef SQLITE_OMIT_ANALYZE
+#  define ANALYZE    0
+#else
+#  define ANALYZE    0x00000004
+#endif
+#ifdef SQLITE_OMIT_ATTACH
+#  define ATTACH     0
+#else
+#  define ATTACH     0x00000008
+#endif
+#ifdef SQLITE_OMIT_AUTOINCREMENT
+#  define AUTOINCR   0
+#else
+#  define AUTOINCR   0x00000010
+#endif
+#ifdef SQLITE_OMIT_CAST
+#  define CAST       0
+#else
+#  define CAST       0x00000020
+#endif
+#ifdef SQLITE_OMIT_COMPOUND_SELECT
+#  define COMPOUND   0
+#else
+#  define COMPOUND   0x00000040
+#endif
+#ifdef SQLITE_OMIT_CONFLICT_CLAUSE
+#  define CONFLICT   0
+#else
+#  define CONFLICT   0x00000080
+#endif
+#ifdef SQLITE_OMIT_EXPLAIN
+#  define EXPLAIN    0
+#else
+#  define EXPLAIN    0x00000100
+#endif
+#ifdef SQLITE_OMIT_FOREIGN_KEY
+#  define FKEY       0
+#else
+#  define FKEY       0x00000200
+#endif
+#ifdef SQLITE_OMIT_PRAGMA
+#  define PRAGMA     0
+#else
+#  define PRAGMA     0x00000400
+#endif
+#ifdef SQLITE_OMIT_REINDEX
+#  define REINDEX    0
+#else
+#  define REINDEX    0x00000800
+#endif
+#ifdef SQLITE_OMIT_SUBQUERY
+#  define SUBQUERY   0
+#else
+#  define SUBQUERY   0x00001000
+#endif
+#ifdef SQLITE_OMIT_TRIGGER
+#  define TRIGGER    0
+#else
+#  define TRIGGER    0x00002000
+#endif
+#if defined(SQLITE_OMIT_AUTOVACUUM) && \
+    (defined(SQLITE_OMIT_VACUUM) || defined(SQLITE_OMIT_ATTACH))
+#  define VACUUM     0
+#else
+#  define VACUUM     0x00004000
+#endif
+#ifdef SQLITE_OMIT_VIEW
+#  define VIEW       0
+#else
+#  define VIEW       0x00008000
+#endif
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+#  define VTAB       0
+#else
+#  define VTAB       0x00010000
+#endif
+#ifdef SQLITE_OMIT_AUTOVACUUM
+#  define AUTOVACUUM 0
+#else
+#  define AUTOVACUUM 0x00020000
+#endif
+
+/*
+** These are the keywords
+*/
+static Keyword aKeywordTable[] = {
+  { "ABORT",            "TK_ABORT",        CONFLICT|TRIGGER       },
+  { "ADD",              "TK_ADD",          ALTER                  },
+  { "AFTER",            "TK_AFTER",        TRIGGER                },
+  { "ALL",              "TK_ALL",          ALWAYS                 },
+  { "ALTER",            "TK_ALTER",        ALTER                  },
+  { "ANALYZE",          "TK_ANALYZE",      ANALYZE                },
+  { "AND",              "TK_AND",          ALWAYS                 },
+  { "AS",               "TK_AS",           ALWAYS                 },
+  { "ASC",              "TK_ASC",          ALWAYS                 },
+  { "ATTACH",           "TK_ATTACH",       ATTACH                 },
+  { "AUTOINCREMENT",    "TK_AUTOINCR",     AUTOINCR               },
+  { "BEFORE",           "TK_BEFORE",       TRIGGER                },
+  { "BEGIN",            "TK_BEGIN",        ALWAYS                 },
+  { "BETWEEN",          "TK_BETWEEN",      ALWAYS                 },
+  { "BY",               "TK_BY",           ALWAYS                 },
+  { "CASCADE",          "TK_CASCADE",      FKEY                   },
+  { "CASE",             "TK_CASE",         ALWAYS                 },
+  { "CAST",             "TK_CAST",         CAST                   },
+  { "CHECK",            "TK_CHECK",        ALWAYS                 },
+  { "COLLATE",          "TK_COLLATE",      ALWAYS                 },
+  { "COLUMN",           "TK_COLUMNKW",     ALTER                  },
+  { "COMMIT",           "TK_COMMIT",       ALWAYS                 },
+  { "CONFLICT",         "TK_CONFLICT",     CONFLICT               },
+  { "CONSTRAINT",       "TK_CONSTRAINT",   ALWAYS                 },
+  { "CREATE",           "TK_CREATE",       ALWAYS                 },
+  { "CROSS",            "TK_JOIN_KW",      ALWAYS                 },
+  { "CURRENT_DATE",     "TK_CTIME_KW",     ALWAYS                 },
+  { "CURRENT_TIME",     "TK_CTIME_KW",     ALWAYS                 },
+  { "CURRENT_TIMESTAMP","TK_CTIME_KW",     ALWAYS                 },
+  { "DATABASE",         "TK_DATABASE",     ATTACH                 },
+  { "DEFAULT",          "TK_DEFAULT",      ALWAYS                 },
+  { "DEFERRED",         "TK_DEFERRED",     ALWAYS                 },
+  { "DEFERRABLE",       "TK_DEFERRABLE",   FKEY                   },
+  { "DELETE",           "TK_DELETE",       ALWAYS                 },
+  { "DESC",             "TK_DESC",         ALWAYS                 },
+  { "DETACH",           "TK_DETACH",       ATTACH                 },
+  { "DISTINCT",         "TK_DISTINCT",     ALWAYS                 },
+  { "DROP",             "TK_DROP",         ALWAYS                 },
+  { "END",              "TK_END",          ALWAYS                 },
+  { "EACH",             "TK_EACH",         TRIGGER                },
+  { "ELSE",             "TK_ELSE",         ALWAYS                 },
+  { "ESCAPE",           "TK_ESCAPE",       ALWAYS                 },
+  { "EXCEPT",           "TK_EXCEPT",       COMPOUND               },
+  { "EXCLUSIVE",        "TK_EXCLUSIVE",    ALWAYS                 },
+  { "EXISTS",           "TK_EXISTS",       ALWAYS                 },
+  { "EXPLAIN",          "TK_EXPLAIN",      EXPLAIN                },
+  { "FAIL",             "TK_FAIL",         CONFLICT|TRIGGER       },
+  { "FOR",              "TK_FOR",          TRIGGER                },
+  { "FOREIGN",          "TK_FOREIGN",      FKEY                   },
+  { "FROM",             "TK_FROM",         ALWAYS                 },
+  { "FULL",             "TK_JOIN_KW",      ALWAYS                 },
+  { "GLOB",             "TK_LIKE_KW",      ALWAYS                 },
+  { "GROUP",            "TK_GROUP",        ALWAYS                 },
+  { "HAVING",           "TK_HAVING",       ALWAYS                 },
+  { "IF",               "TK_IF",           ALWAYS                 },
+  { "IGNORE",           "TK_IGNORE",       CONFLICT|TRIGGER       },
+  { "IMMEDIATE",        "TK_IMMEDIATE",    ALWAYS                 },
+  { "IN",               "TK_IN",           ALWAYS                 },
+  { "INDEX",            "TK_INDEX",        ALWAYS                 },
+  { "INITIALLY",        "TK_INITIALLY",    FKEY                   },
+  { "INNER",            "TK_JOIN_KW",      ALWAYS                 },
+  { "INSERT",           "TK_INSERT",       ALWAYS                 },
+  { "INSTEAD",          "TK_INSTEAD",      TRIGGER                },
+  { "INTERSECT",        "TK_INTERSECT",    COMPOUND               },
+  { "INTO",             "TK_INTO",         ALWAYS                 },
+  { "IS",               "TK_IS",           ALWAYS                 },
+  { "ISNULL",           "TK_ISNULL",       ALWAYS                 },
+  { "JOIN",             "TK_JOIN",         ALWAYS                 },
+  { "KEY",              "TK_KEY",          ALWAYS                 },
+  { "LEFT",             "TK_JOIN_KW",      ALWAYS                 },
+  { "LIKE",             "TK_LIKE_KW",      ALWAYS                 },
+  { "LIMIT",            "TK_LIMIT",        ALWAYS                 },
+  { "MATCH",            "TK_MATCH",        ALWAYS                 },
+  { "NATURAL",          "TK_JOIN_KW",      ALWAYS                 },
+  { "NOT",              "TK_NOT",          ALWAYS                 },
+  { "NOTNULL",          "TK_NOTNULL",      ALWAYS                 },
+  { "NULL",             "TK_NULL",         ALWAYS                 },
+  { "OF",               "TK_OF",           ALWAYS                 },
+  { "OFFSET",           "TK_OFFSET",       ALWAYS                 },
+  { "ON",               "TK_ON",           ALWAYS                 },
+  { "OR",               "TK_OR",           ALWAYS                 },
+  { "ORDER",            "TK_ORDER",        ALWAYS                 },
+  { "OUTER",            "TK_JOIN_KW",      ALWAYS                 },
+  { "PLAN",             "TK_PLAN",         EXPLAIN                },
+  { "PRAGMA",           "TK_PRAGMA",       PRAGMA                 },
+  { "PRIMARY",          "TK_PRIMARY",      ALWAYS                 },
+  { "QUERY",            "TK_QUERY",        EXPLAIN                },
+  { "RAISE",            "TK_RAISE",        TRIGGER                },
+  { "REFERENCES",       "TK_REFERENCES",   FKEY                   },
+  { "REGEXP",           "TK_LIKE_KW",      ALWAYS                 },
+  { "REINDEX",          "TK_REINDEX",      REINDEX                },
+  { "RENAME",           "TK_RENAME",       ALTER                  },
+  { "REPLACE",          "TK_REPLACE",      CONFLICT               },
+  { "RESTRICT",         "TK_RESTRICT",     FKEY                   },
+  { "RIGHT",            "TK_JOIN_KW",      ALWAYS                 },
+  { "ROLLBACK",         "TK_ROLLBACK",     ALWAYS                 },
+  { "ROW",              "TK_ROW",          TRIGGER                },
+  { "SELECT",           "TK_SELECT",       ALWAYS                 },
+  { "SET",              "TK_SET",          ALWAYS                 },
+  { "TABLE",            "TK_TABLE",        ALWAYS                 },
+  { "TEMP",             "TK_TEMP",         ALWAYS                 },
+  { "TEMPORARY",        "TK_TEMP",         ALWAYS                 },
+  { "THEN",             "TK_THEN",         ALWAYS                 },
+  { "TO",               "TK_TO",           ALTER                  },
+  { "TRANSACTION",      "TK_TRANSACTION",  ALWAYS                 },
+  { "TRIGGER",          "TK_TRIGGER",      TRIGGER                },
+  { "UNION",            "TK_UNION",        COMPOUND               },
+  { "UNIQUE",           "TK_UNIQUE",       ALWAYS                 },
+  { "UPDATE",           "TK_UPDATE",       ALWAYS                 },
+  { "USING",            "TK_USING",        ALWAYS                 },
+  { "VACUUM",           "TK_VACUUM",       VACUUM                 },
+  { "VALUES",           "TK_VALUES",       ALWAYS                 },
+  { "VIEW",             "TK_VIEW",         VIEW                   },
+  { "VIRTUAL",          "TK_VIRTUAL",      VTAB                   },
+  { "WHEN",             "TK_WHEN",         ALWAYS                 },
+  { "WHERE",            "TK_WHERE",        ALWAYS                 },
+};
+
+/* Number of keywords */
+static int nKeyword = (sizeof(aKeywordTable)/sizeof(aKeywordTable[0]));
+
+/* An array to map all upper-case characters into their corresponding
+** lower-case character. 
+*/
+const unsigned char sqlite3UpperToLower[] = {
+      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+     36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+     54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
+    104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
+    122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
+    108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
+    126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
+    144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
+    162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
+    180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
+    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
+    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
+    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
+    252,253,254,255
+};
+#define UpperToLower sqlite3UpperToLower
+
+/*
+** Comparision function for two Keyword records
+*/
+static int keywordCompare1(const void *a, const void *b){
+  const Keyword *pA = (Keyword*)a;
+  const Keyword *pB = (Keyword*)b;
+  int n = pA->len - pB->len;
+  if( n==0 ){
+    n = strcmp(pA->zName, pB->zName);
+  }
+  return n;
+}
+static int keywordCompare2(const void *a, const void *b){
+  const Keyword *pA = (Keyword*)a;
+  const Keyword *pB = (Keyword*)b;
+  int n = pB->longestSuffix - pA->longestSuffix;
+  if( n==0 ){
+    n = strcmp(pA->zName, pB->zName);
+  }
+  return n;
+}
+static int keywordCompare3(const void *a, const void *b){
+  const Keyword *pA = (Keyword*)a;
+  const Keyword *pB = (Keyword*)b;
+  int n = pA->offset - pB->offset;
+  return n;
+}
+
+/*
+** Return a KeywordTable entry with the given id
+*/
+static Keyword *findById(int id){
+  int i;
+  for(i=0; i<nKeyword; i++){
+    if( aKeywordTable[i].id==id ) break;
+  }
+  return &aKeywordTable[i];
+}
+
+/*
+** This routine does the work.  The generated code is printed on standard
+** output.
+*/
+int main(int argc, char **argv){
+  int i, j, k, h;
+  int bestSize, bestCount;
+  int count;
+  int nChar;
+  int totalLen = 0;
+  int aHash[1000];  /* 1000 is much bigger than nKeyword */
+
+  /* Remove entries from the list of keywords that have mask==0 */
+  for(i=j=0; i<nKeyword; i++){
+    if( aKeywordTable[i].mask==0 ) continue;
+    if( j<i ){
+      aKeywordTable[j] = aKeywordTable[i];
+    }
+    j++;
+  }
+  nKeyword = j;
+
+  /* Fill in the lengths of strings and hashes for all entries. */
+  for(i=0; i<nKeyword; i++){
+    Keyword *p = &aKeywordTable[i];
+    p->len = strlen(p->zName);
+    totalLen += p->len;
+    p->hash = (UpperToLower[(int)p->zName[0]]*4) ^
+              (UpperToLower[(int)p->zName[p->len-1]]*3) ^ p->len;
+    p->id = i+1;
+  }
+
+  /* Sort the table from shortest to longest keyword */
+  qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare1);
+
+  /* Look for short keywords embedded in longer keywords */
+  for(i=nKeyword-2; i>=0; i--){
+    Keyword *p = &aKeywordTable[i];
+    for(j=nKeyword-1; j>i && p->substrId==0; j--){
+      Keyword *pOther = &aKeywordTable[j];
+      if( pOther->substrId ) continue;
+      if( pOther->len<=p->len ) continue;
+      for(k=0; k<=pOther->len-p->len; k++){
+        if( memcmp(p->zName, &pOther->zName[k], p->len)==0 ){
+          p->substrId = pOther->id;
+          p->substrOffset = k;
+          break;
+        }
+      }
+    }
+  }
+
+  /* Compute the longestSuffix value for every word */
+  for(i=0; i<nKeyword; i++){
+    Keyword *p = &aKeywordTable[i];
+    if( p->substrId ) continue;
+    for(j=0; j<nKeyword; j++){
+      Keyword *pOther;
+      if( j==i ) continue;
+      pOther = &aKeywordTable[j];
+      if( pOther->substrId ) continue;
+      for(k=p->longestSuffix+1; k<p->len && k<pOther->len; k++){
+        if( memcmp(&p->zName[p->len-k], pOther->zName, k)==0 ){
+          p->longestSuffix = k;
+        }
+      }
+    }
+  }
+
+  /* Sort the table into reverse order by length */
+  qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare2);
+
+  /* Fill in the offset for all entries */
+  nChar = 0;
+  for(i=0; i<nKeyword; i++){
+    Keyword *p = &aKeywordTable[i];
+    if( p->offset>0 || p->substrId ) continue;
+    p->offset = nChar;
+    nChar += p->len;
+    for(k=p->len-1; k>=1; k--){
+      for(j=i+1; j<nKeyword; j++){
+        Keyword *pOther = &aKeywordTable[j];
+        if( pOther->offset>0 || pOther->substrId ) continue;
+        if( pOther->len<=k ) continue;
+        if( memcmp(&p->zName[p->len-k], pOther->zName, k)==0 ){
+          p = pOther;
+          p->offset = nChar - k;
+          nChar = p->offset + p->len;
+          p->zName += k;
+          p->len -= k;
+          p->prefix = k;
+          j = i;
+          k = p->len;
+        }
+      }
+    }
+  }
+  for(i=0; i<nKeyword; i++){
+    Keyword *p = &aKeywordTable[i];
+    if( p->substrId ){
+      p->offset = findById(p->substrId)->offset + p->substrOffset;
+    }
+  }
+
+  /* Sort the table by offset */
+  qsort(aKeywordTable, nKeyword, sizeof(aKeywordTable[0]), keywordCompare3);
+
+  /* Figure out how big to make the hash table in order to minimize the
+  ** number of collisions */
+  bestSize = nKeyword;
+  bestCount = nKeyword*nKeyword;
+  for(i=nKeyword/2; i<=2*nKeyword; i++){
+    for(j=0; j<i; j++) aHash[j] = 0;
+    for(j=0; j<nKeyword; j++){
+      h = aKeywordTable[j].hash % i;
+      aHash[h] *= 2;
+      aHash[h]++;
+    }
+    for(j=count=0; j<i; j++) count += aHash[j];
+    if( count<bestCount ){
+      bestCount = count;
+      bestSize = i;
+    }
+  }
+
+  /* Compute the hash */
+  for(i=0; i<bestSize; i++) aHash[i] = 0;
+  for(i=0; i<nKeyword; i++){
+    h = aKeywordTable[i].hash % bestSize;
+    aKeywordTable[i].iNext = aHash[h];
+    aHash[h] = i+1;
+  }
+
+  /* Begin generating code */
+  printf("%s", zHdr);
+  printf("/* Hash score: %d */\n", bestCount);
+  printf("static int keywordCode(const char *z, int n){\n");
+  printf("  /* zText[] encodes %d bytes of keywords in %d bytes */\n",
+          totalLen + nKeyword, nChar+1 );
+
+  printf("  static const char zText[%d] =\n", nChar+1);
+  for(i=j=0; i<nKeyword; i++){
+    Keyword *p = &aKeywordTable[i];
+    if( p->substrId ) continue;
+    if( j==0 ) printf("    \"");
+    printf("%s", p->zName);
+    j += p->len;
+    if( j>60 ){
+      printf("\"\n");
+      j = 0;
+    }
+  }
+  printf("%s;\n", j>0 ? "\"" : "  ");
+
+  printf("  static const unsigned char aHash[%d] = {\n", bestSize);
+  for(i=j=0; i<bestSize; i++){
+    if( j==0 ) printf("    ");
+    printf(" %3d,", aHash[i]);
+    j++;
+    if( j>12 ){
+      printf("\n");
+      j = 0;
+    }
+  }
+  printf("%s  };\n", j==0 ? "" : "\n");    
+
+  printf("  static const unsigned char aNext[%d] = {\n", nKeyword);
+  for(i=j=0; i<nKeyword; i++){
+    if( j==0 ) printf("    ");
+    printf(" %3d,", aKeywordTable[i].iNext);
+    j++;
+    if( j>12 ){
+      printf("\n");
+      j = 0;
+    }
+  }
+  printf("%s  };\n", j==0 ? "" : "\n");    
+
+  printf("  static const unsigned char aLen[%d] = {\n", nKeyword);
+  for(i=j=0; i<nKeyword; i++){
+    if( j==0 ) printf("    ");
+    printf(" %3d,", aKeywordTable[i].len+aKeywordTable[i].prefix);
+    j++;
+    if( j>12 ){
+      printf("\n");
+      j = 0;
+    }
+  }
+  printf("%s  };\n", j==0 ? "" : "\n");    
+
+  printf("  static const unsigned short int aOffset[%d] = {\n", nKeyword);
+  for(i=j=0; i<nKeyword; i++){
+    if( j==0 ) printf("    ");
+    printf(" %3d,", aKeywordTable[i].offset);
+    j++;
+    if( j>12 ){
+      printf("\n");
+      j = 0;
+    }
+  }
+  printf("%s  };\n", j==0 ? "" : "\n");
+
+  printf("  static const unsigned char aCode[%d] = {\n", nKeyword);
+  for(i=j=0; i<nKeyword; i++){
+    char *zToken = aKeywordTable[i].zTokenType;
+    if( j==0 ) printf("    ");
+    printf("%s,%*s", zToken, (int)(14-strlen(zToken)), "");
+    j++;
+    if( j>=5 ){
+      printf("\n");
+      j = 0;
+    }
+  }
+  printf("%s  };\n", j==0 ? "" : "\n");
+
+  printf("  int h, i;\n");
+  printf("  if( n<2 ) return TK_ID;\n");
+  printf("  h = ((charMap(z[0])*4) ^\n"
+         "      (charMap(z[n-1])*3) ^\n"
+         "      n) %% %d;\n", bestSize);
+  printf("  for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){\n");
+  printf("    if( aLen[i]==n &&"
+                   " sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){\n");
+  printf("      return aCode[i];\n");
+  printf("    }\n");
+  printf("  }\n");
+  printf("  return TK_ID;\n");
+  printf("}\n");
+  printf("int sqlite3KeywordCode(const unsigned char *z, int n){\n");
+  printf("  return keywordCode((char*)z, n);\n");
+  printf("}\n");
+
+  return 0;
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/mkopts.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/mkopts.tcl
new file mode 100644
index 0000000..e3ddcb9
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/mkopts.tcl
@@ -0,0 +1,51 @@
+#!/usr/bin/tclsh
+#
+# This script is used to generate the array of strings and the enum
+# that appear at the beginning of the C code implementation of a
+# a TCL command and that define the available subcommands for that
+# TCL command.
+
+set prefix {}
+while {![eof stdin]} {
+  set line [gets stdin]
+  if {$line==""} continue
+  regsub -all "\[ \t\n,\]+" [string trim $line] { } line
+  foreach token [split $line { }] {
+    if {![regexp {(([a-zA-Z]+)_)?([_a-zA-Z]+)} $token all px p2 name]} continue
+    lappend namelist [string tolower $name]
+    if {$px!=""} {set prefix $p2}
+  }
+}
+
+puts "  static const char *${prefix}_strs\[\] = \173"
+set col 0
+proc put_item x {
+  global col
+  if {$col==0} {puts -nonewline "   "}
+  if {$col<2} {
+    puts -nonewline [format " %-21s" $x]
+    incr col
+  } else {
+    puts $x
+    set col 0
+  }
+}
+proc finalize {} {
+  global col
+  if {$col>0} {puts {}}
+  set col 0
+}
+
+foreach name [lsort $namelist] {
+  put_item \"$name\",
+}
+put_item 0
+finalize
+puts "  \175;"
+puts "  enum ${prefix}_enum \173"
+foreach name [lsort $namelist] {
+  regsub -all {@} $name {} name
+  put_item ${prefix}_[string toupper $name],
+}
+finalize
+puts "  \175;"
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3c.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3c.tcl
new file mode 100644
index 0000000..e7befd8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3c.tcl
@@ -0,0 +1,278 @@
+#!/usr/bin/tclsh
+#
+# To build a single huge source file holding all of SQLite (or at
+# least the core components - the test harness, shell, and TCL 
+# interface are omitted.) first do
+#
+#      make target_source
+#
+# The make target above moves all of the source code files into
+# a subdirectory named "tsrc".  (This script expects to find the files
+# there and will not work if they are not found.)  There are a few
+# generated C code files that are also added to the tsrc directory.
+# For example, the "parse.c" and "parse.h" files to implement the
+# the parser are derived from "parse.y" using lemon.  And the 
+# "keywordhash.h" files is generated by a program named "mkkeywordhash".
+#
+# After the "tsrc" directory has been created and populated, run
+# this script:
+#
+#      tclsh mksqlite3c.tcl
+#
+# The amalgamated SQLite code will be written into sqlite3.c
+#
+
+# Begin by reading the "sqlite3.h" header file.  Count the number of lines
+# in this file and extract the version number.  That information will be
+# needed in order to generate the header of the amalgamation.
+#
+if {[lsearch $argv --nostatic]>=0} {
+  set addstatic 0
+} else {
+  set addstatic 1
+}
+set in [open tsrc/sqlite3.h]
+set cnt 0
+set VERSION ?????
+while {![eof $in]} {
+  set line [gets $in]
+  if {$line=="" && [eof $in]} break
+  incr cnt
+  regexp {#define\s+SQLITE_VERSION\s+"(.*)"} $line all VERSION
+}
+close $in
+
+# Open the output file and write a header comment at the beginning
+# of the file.
+#
+set out [open sqlite3.c w]
+set today [clock format [clock seconds] -format "%Y-%m-%d %H:%M:%S UTC" -gmt 1]
+puts $out [subst \
+{/******************************************************************************
+** This file is an amalgamation of many separate C source files from SQLite
+** version $VERSION.  By combining all the individual C code files into this 
+** single large file, the entire code can be compiled as a one translation
+** unit.  This allows many compilers to do optimizations that would not be
+** possible if the files were compiled separately.  Performance improvements
+** of 5% are more are commonly seen when SQLite is compiled as a single
+** translation unit.
+**
+** This file is all you need to compile SQLite.  To use SQLite in other
+** programs, you need this file and the "sqlite3.h" header file that defines
+** the programming interface to the SQLite library.  (If you do not have 
+** the "sqlite3.h" header file at hand, you will find a copy in the first
+** $cnt lines past this header comment.)  Additional code files may be
+** needed if you want a wrapper to interface SQLite with your choice of
+** programming language.  The code for the "sqlite3" command-line shell
+** is also in a separate file.  This file contains only code for the core
+** SQLite library.
+**
+** This amalgamation was generated on $today.
+*/
+#define SQLITE_CORE 1
+#define SQLITE_AMALGAMATION 1}]
+if {$addstatic} {
+  puts $out \
+{#ifndef SQLITE_PRIVATE
+# define SQLITE_PRIVATE static
+#endif
+#ifndef SQLITE_API
+# define SQLITE_API
+#endif}
+}
+
+# These are the header files used by SQLite.  The first time any of these 
+# files are seen in a #include statement in the C code, include the complete
+# text of the file in-line.  The file only needs to be included once.
+#
+foreach hdr {
+   btree.h
+   btreeInt.h
+   fts3.h
+   fts3_hash.h
+   fts3_tokenizer.h
+   hash.h
+   keywordhash.h
+   mutex.h
+   opcodes.h
+   os_common.h
+   os.h
+   os_os2.h
+   pager.h
+   parse.h
+   sqlite3ext.h
+   sqlite3.h
+   sqliteInt.h
+   sqliteLimit.h
+   vdbe.h
+   vdbeInt.h
+} {
+  set available_hdr($hdr) 1
+}
+set available_hdr(sqliteInt.h) 0
+
+# 78 stars used for comment formatting.
+set s78 \
+{*****************************************************************************}
+
+# Insert a comment into the code
+#
+proc section_comment {text} {
+  global out s78
+  set n [string length $text]
+  set nstar [expr {60 - $n}]
+  set stars [string range $s78 0 $nstar]
+  puts $out "/************** $text $stars/"
+}
+
+# Read the source file named $filename and write it into the
+# sqlite3.c output file.  If any #include statements are seen,
+# process them approprately.
+#
+proc copy_file {filename} {
+  global seen_hdr available_hdr out addstatic
+  set tail [file tail $filename]
+  section_comment "Begin file $tail"
+  set in [open $filename r]
+  set varpattern {^[a-zA-Z][a-zA-Z_0-9 *]+(sqlite3[_a-zA-Z0-9]+)(\[|;| =)}
+  set declpattern {[a-zA-Z][a-zA-Z_0-9 ]+ \*?(sqlite3[_a-zA-Z0-9]+)\(}
+  if {[file extension $filename]==".h"} {
+    set declpattern " *$declpattern"
+  }
+  set declpattern ^$declpattern
+  while {![eof $in]} {
+    set line [gets $in]
+    if {[regexp {^#\s*include\s+["<]([^">]+)[">]} $line all hdr]} {
+      if {[info exists available_hdr($hdr)]} {
+        if {$available_hdr($hdr)} {
+          if {$hdr!="os_common.h"} {
+            set available_hdr($hdr) 0
+          }
+          section_comment "Include $hdr in the middle of $tail"
+          copy_file tsrc/$hdr
+          section_comment "Continuing where we left off in $tail"
+        }
+      } elseif {![info exists seen_hdr($hdr)]} {
+        set seen_hdr($hdr) 1
+        puts $out $line
+      }
+    } elseif {[regexp {^#ifdef __cplusplus} $line]} {
+      puts $out "#if 0"
+    } elseif {[regexp {^#line} $line]} {
+      # Skip #line directives.
+    } elseif {$addstatic && ![regexp {^(static|typedef)} $line]} {
+      if {[regexp $declpattern $line all funcname]} {
+        # Add the SQLITE_PRIVATE or SQLITE_API keyword before functions.
+        # so that linkage can be modified at compile-time.
+        if {[regexp {^sqlite3_} $funcname]} {
+          puts $out "SQLITE_API $line"
+        } else {
+          puts $out "SQLITE_PRIVATE $line"
+        }
+      } elseif {[regexp $varpattern $line all varname]} {
+        # Add the SQLITE_PRIVATE before variable declarations or
+        # definitions for internal use
+        if {![regexp {^sqlite3_} $varname]} {
+          regsub {^extern } $line {} line
+          puts $out "SQLITE_PRIVATE $line"
+        } elseif {![regexp {^SQLITE_EXTERN} $line]} {
+          puts $out "SQLITE_API $line"
+        } else {
+          puts $out $line
+        }
+      } elseif {[regexp {^void \(\*sqlite3_io_trace\)} $line]} {
+        puts $out "SQLITE_API $line"
+      } else {
+        puts $out $line
+      }
+    } else {
+      puts $out $line
+    }
+  }
+  close $in
+  section_comment "End of $tail"
+}
+
+
+# Process the source files.  Process files containing commonly
+# used subroutines first in order to help the compiler find
+# inlining opportunities.
+#
+foreach file {
+   sqliteInt.h
+
+   date.c
+   os.c
+
+   fault.c
+   mem1.c
+   mem2.c
+   mem3.c
+   mutex.c
+   mutex_os2.c
+   mutex_unix.c
+   mutex_w32.c
+   malloc.c
+   printf.c
+   random.c
+   utf.c
+   util.c
+   hash.c
+   opcodes.c
+
+   os_os2.c
+   os_unix.c
+   os_win.c
+
+   pager.c
+
+   btmutex.c   
+   btree.c
+
+   vdbefifo.c
+   vdbemem.c
+   vdbeaux.c
+   vdbeapi.c
+   vdbe.c
+   vdbeblob.c
+   journal.c
+
+   expr.c
+   alter.c
+   analyze.c
+   attach.c
+   auth.c
+   build.c
+   callback.c
+   delete.c
+   func.c
+   insert.c
+   legacy.c
+   loadext.c
+   pragma.c
+   prepare.c
+   select.c
+   table.c
+   trigger.c
+   update.c
+   vacuum.c
+   vtab.c
+   where.c
+
+   parse.c
+
+   tokenize.c
+   complete.c
+
+   main.c
+
+   fts3.c
+   fts3_hash.c
+   fts3_porter.c
+   fts3_tokenizer.c
+   fts3_tokenizer1.c
+} {
+  copy_file tsrc/$file
+}
+
+close $out
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3internalh.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3internalh.tcl
new file mode 100644
index 0000000..cacd7cb
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/mksqlite3internalh.tcl
@@ -0,0 +1,145 @@
+#!/usr/bin/tclsh
+#
+# To build a single huge source file holding all of SQLite (or at
+# least the core components - the test harness, shell, and TCL 
+# interface are omitted.) first do
+#
+#      make target_source
+#
+# The make target above moves all of the source code files into
+# a subdirectory named "tsrc".  (This script expects to find the files
+# there and will not work if they are not found.)  There are a few
+# generated C code files that are also added to the tsrc directory.
+# For example, the "parse.c" and "parse.h" files to implement the
+# the parser are derived from "parse.y" using lemon.  And the 
+# "keywordhash.h" files is generated by a program named "mkkeywordhash".
+#
+# After the "tsrc" directory has been created and populated, run
+# this script:
+#
+#      tclsh mksqlite3c.tcl
+#
+# The amalgamated SQLite code will be written into sqlite3.c
+#
+
+# Begin by reading the "sqlite3.h" header file.  Count the number of lines
+# in this file and extract the version number.  That information will be
+# needed in order to generate the header of the amalgamation.
+#
+set in [open tsrc/sqlite3.h]
+set cnt 0
+set VERSION ?????
+while {![eof $in]} {
+  set line [gets $in]
+  if {$line=="" && [eof $in]} break
+  incr cnt
+  regexp {#define\s+SQLITE_VERSION\s+"(.*)"} $line all VERSION
+}
+close $in
+
+# Open the output file and write a header comment at the beginning
+# of the file.
+#
+set out [open sqlite3internal.h w]
+set today [clock format [clock seconds] -format "%Y-%m-%d %H:%M:%S UTC" -gmt 1]
+puts $out [subst \
+{/******************************************************************************
+** This file is an amalgamation of many private header files from SQLite
+** version $VERSION. 
+*/}]
+
+# These are the header files used by SQLite.  The first time any of these 
+# files are seen in a #include statement in the C code, include the complete
+# text of the file in-line.  The file only needs to be included once.
+#
+foreach hdr {
+   btree.h
+   btreeInt.h
+   hash.h
+   keywordhash.h
+   opcodes.h
+   os_common.h
+   os.h
+   os_os2.h
+   pager.h
+   parse.h
+   sqlite3ext.h
+   sqlite3.h
+   sqliteInt.h
+   sqliteLimit.h
+   vdbe.h
+   vdbeInt.h
+} {
+  set available_hdr($hdr) 1
+}
+
+# 78 stars used for comment formatting.
+set s78 \
+{*****************************************************************************}
+
+# Insert a comment into the code
+#
+proc section_comment {text} {
+  global out s78
+  set n [string length $text]
+  set nstar [expr {60 - $n}]
+  set stars [string range $s78 0 $nstar]
+  puts $out "/************** $text $stars/"
+}
+
+# Read the source file named $filename and write it into the
+# sqlite3.c output file.  If any #include statements are seen,
+# process them approprately.
+#
+proc copy_file {filename} {
+  global seen_hdr available_hdr out
+  set tail [file tail $filename]
+  section_comment "Begin file $tail"
+  set in [open $filename r]
+  while {![eof $in]} {
+    set line [gets $in]
+    if {[regexp {^#\s*include\s+["<]([^">]+)[">]} $line all hdr]} {
+      if {[info exists available_hdr($hdr)]} {
+        if {$available_hdr($hdr)} {
+          section_comment "Include $hdr in the middle of $tail"
+          copy_file tsrc/$hdr
+          section_comment "Continuing where we left off in $tail"
+        }
+      } elseif {![info exists seen_hdr($hdr)]} {
+        set seen_hdr($hdr) 1
+        puts $out $line
+      }
+    } elseif {[regexp {^#ifdef __cplusplus} $line]} {
+      puts $out "#if 0"
+    } elseif {[regexp {^#line} $line]} {
+      # Skip #line directives.
+    } else {
+      puts $out $line
+    }
+  }
+  close $in
+  section_comment "End of $tail"
+}
+
+
+# Process the source files.  Process files containing commonly
+# used subroutines first in order to help the compiler find
+# inlining opportunities.
+#
+foreach file {
+   sqliteInt.h
+   sqlite3.h
+   btree.h
+   hash.h
+   os.h
+   pager.h
+   parse.h
+   sqlite3ext.h
+   vdbe.h
+} {
+  if {$available_hdr($file)} {
+    copy_file tsrc/$file
+  }
+}
+
+close $out
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/omittest.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/omittest.tcl
new file mode 100644
index 0000000..9fcbfdb
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/omittest.tcl
@@ -0,0 +1,176 @@
+
+set rcsid {$Id: omittest.tcl,v 1.3 2007/09/14 16:20:01 danielk1977 Exp $}
+
+# Documentation for this script. This may be output to stderr
+# if the script is invoked incorrectly.
+set ::USAGE_MESSAGE {
+This Tcl script is used to test the various compile time options 
+available for omitting code (the SQLITE_OMIT_xxx options). It
+should be invoked as follows:
+
+    <script> ?-makefile PATH-TO-MAKEFILE?
+
+The default value for ::MAKEFILE is "../Makefile.linux.gcc".
+
+This script builds the testfixture program and runs the SQLite test suite
+once with each SQLITE_OMIT_ option defined and then once with all options
+defined together. Each run is performed in a seperate directory created
+as a sub-directory of the current directory by the script. The output
+of the build is saved in <sub-directory>/build.log. The output of the
+test-suite is saved in <sub-directory>/test.log.
+
+Almost any SQLite makefile (except those generated by configure - see below)
+should work. The following properties are required:
+
+  * The makefile should support the "testfixture" target.
+  * The makefile should support the "test" target.
+  * The makefile should support the variable "OPTS" as a way to pass
+    options from the make command line to lemon and the C compiler.
+
+More precisely, the following two invocations must be supported:
+
+  make -f $::MAKEFILE testfixture OPTS="-DSQLITE_OMIT_ALTERTABLE=1"
+  make -f $::MAKEFILE test
+
+Makefiles generated by the sqlite configure program cannot be used as
+they do not respect the OPTS variable.
+}
+
+
+# Build a testfixture executable and run quick.test using it. The first
+# parameter is the name of the directory to create and use to run the
+# test in. The second parameter is a list of OMIT symbols to define
+# when doing so. For example:
+#
+#     run_quick_test /tmp/testdir {SQLITE_OMIT_TRIGGER SQLITE_OMIT_VIEW}
+#
+#
+proc run_quick_test {dir omit_symbol_list} {
+  # Compile the value of the OPTS Makefile variable.
+  set opts "-DSQLITE_MEMDEBUG=2 -DSQLITE_DEBUG -DOS_UNIX" 
+  foreach sym $omit_symbol_list {
+    append opts " -D${sym}=1"
+  }
+
+  # Create the directory and do the build. If an error occurs return
+  # early without attempting to run the test suite.
+  file mkdir $dir
+  puts -nonewline "Building $dir..."
+  flush stdout
+  set rc [catch {
+    exec make -C $dir -f $::MAKEFILE testfixture OPTS=$opts >& $dir/build.log
+  }]
+  if {$rc} {
+    puts "No good. See $dir/build.log."
+    return
+  } else {
+    puts "Ok"
+  }
+  
+  # Create an empty file "$dir/sqlite3". This is to trick the makefile out 
+  # of trying to build the sqlite shell. The sqlite shell won't build 
+  # with some of the OMIT options (i.e OMIT_COMPLETE).
+  if {![file exists $dir/sqlite3]} {
+    set wr [open $dir/sqlite3 w]
+    puts $wr "dummy"
+    close $wr
+  }
+
+  # Run the test suite.
+  puts -nonewline "Testing $dir..."
+  flush stdout
+  set rc [catch {
+    exec make -C $dir -f $::MAKEFILE test OPTS=$opts >& $dir/test.log
+  }]
+  if {$rc} {
+    puts "No good. See $dir/test.log."
+  } else {
+    puts "Ok"
+  }
+}
+
+
+# This proc processes the command line options passed to this script.
+# Currently the only option supported is "-makefile", default
+# "../Makefile.linux-gcc". Set the ::MAKEFILE variable to the value of this
+# option.
+#
+proc process_options {argv} {
+  set ::MAKEFILE ../Makefile.linux-gcc              ;# Default value
+  for {set i 0} {$i < [llength $argv]} {incr i} {
+    switch -- [lindex $argv $i] {
+      -makefile {
+        incr i
+        set ::MAKEFILE [lindex $argv $i]
+      }
+  
+      default {
+        puts stderr [string trim $::USAGE_MESSAGE]
+        exit -1
+      }
+    }
+    set ::MAKEFILE [file normalize $::MAKEFILE]
+  }
+}
+
+# Main routine.
+#
+
+proc main {argv} {
+  # List of SQLITE_OMIT_XXX symbols supported by SQLite.
+  set ::SYMBOLS [list                  \
+    SQLITE_OMIT_ALTERTABLE             \
+    SQLITE_OMIT_AUTHORIZATION          \
+    SQLITE_OMIT_AUTOINCREMENT          \
+    SQLITE_OMIT_AUTOVACUUM             \
+    SQLITE_OMIT_BLOB_LITERAL           \
+    SQLITE_OMIT_COMPLETE               \
+    SQLITE_OMIT_COMPOUND_SELECT        \
+    SQLITE_OMIT_CONFLICT_CLAUSE        \
+    SQLITE_OMIT_DATETIME_FUNCS         \
+    SQLITE_OMIT_EXPLAIN                \
+    SQLITE_OMIT_FLOATING_POINT         \
+    SQLITE_OMIT_FOREIGN_KEY            \
+    SQLITE_OMIT_INCRBLOB               \
+    SQLITE_OMIT_INTEGRITY_CHECK        \
+    SQLITE_OMIT_MEMORYDB               \
+    SQLITE_OMIT_PAGER_PRAGMAS          \
+    SQLITE_OMIT_PRAGMA                 \
+    SQLITE_OMIT_PROGRESS_CALLBACK      \
+    SQLITE_OMIT_REINDEX                \
+    SQLITE_OMIT_SCHEMA_PRAGMAS         \
+    SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS \
+    SQLITE_OMIT_SUBQUERY               \
+    SQLITE_OMIT_TCL_VARIABLE           \
+    SQLITE_OMIT_TRIGGER                \
+    SQLITE_OMIT_UTF16                  \
+    SQLITE_OMIT_VACUUM                 \
+    SQLITE_OMIT_VIEW                   \
+    SQLITE_OMIT_VIRTUALTABLE           \
+  ]
+
+  # Process any command line options.
+  process_options $argv
+  
+  # First try a test with all OMIT symbols except SQLITE_OMIT_FLOATING_POINT 
+  # and SQLITE_OMIT_PRAGMA defined. The former doesn't work (causes segfaults)
+  # and the latter is currently incompatible with the test suite (this should
+  # be fixed, but it will be a lot of work).
+  set allsyms [list]
+  foreach s $::SYMBOLS {
+    if {$s!="SQLITE_OMIT_FLOATING_POINT" && $s!="SQLITE_OMIT_PRAGMA"} {
+      lappend allsyms $s
+    }
+  }
+  run_quick_test test_OMIT_EVERYTHING $allsyms
+  
+  # Now try one quick.test with each of the OMIT symbols defined. Included
+  # are the OMIT_FLOATING_POINT and OMIT_PRAGMA symbols, even though we
+  # know they will fail. It's good to be reminded of this from time to time.
+  foreach sym $::SYMBOLS {
+    set dirname "test_[string range $sym 7 end]"
+    run_quick_test $dirname $sym
+  }
+}
+
+main $argv
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/opcodeDoc.awk b/client/src/thirdparty/sqlite-3.4.2/tool/opcodeDoc.awk
new file mode 100644
index 0000000..4920106
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/opcodeDoc.awk
@@ -0,0 +1,23 @@
+#
+# Extract opcode documentation for sqliteVdbe.c and generate HTML
+#
+BEGIN {
+  print "<html><body bgcolor=white>"
+  print "<h1>SQLite Virtual Database Engine Opcodes</h1>"
+  print "<table>"
+}
+/ Opcode: /,/\*\// {
+  if( $2=="Opcode:" ){
+    printf "<tr><td>%s&nbsp;%s&nbsp;%s&nbsp;%s</td>\n<td>\n", $3, $4, $5, $6
+  }else if( $1=="*/" ){
+    printf "</td></tr>\n"
+  }else if( NF>1 ){
+    sub(/^ *\*\* /,"")
+    gsub(/</,"&lt;")
+    gsub(/&/,"&amp;")
+    print
+  }
+}
+END {
+  print "</table></body></html>"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/report1.txt b/client/src/thirdparty/sqlite-3.4.2/tool/report1.txt
new file mode 100644
index 0000000..7820b8c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/report1.txt
@@ -0,0 +1,66 @@
+The SQL database used for ACD contains 113 tables and indices implemented
+in GDBM.  The following are statistics on the sizes of keys and data
+within these tables and indices.
+
+Entries:      962080
+Size:         45573853
+Avg Size:     48
+Key Size:     11045299
+Avg Key Size: 12
+Max Key Size: 99
+
+
+ Size of key              Cummulative
+  and data     Instances  Percentage
+------------  ----------  -----------
+    0..8            266    0%
+    9..12          5485    0%
+   13..16         73633    8%
+   17..24        180918   27%
+   25..32        209823   48%
+   33..40        148995   64%
+   41..48         76304   72%
+   49..56         14346   73%
+   57..64         15725   75%
+   65..80         44916   80%
+   81..96        127815   93%
+   97..112        34769   96%
+  113..128        13314   98%
+  129..144         8098   99%
+  145..160         3355   99%
+  161..176         1159   99%
+  177..192          629   99%
+  193..208          221   99%
+  209..224          210   99%
+  225..240          129   99%
+  241..256           57   99%
+  257..288          496   99%
+  289..320           60   99%
+  321..352           37   99%
+  353..384           46   99%
+  385..416           22   99%
+  417..448           24   99%
+  449..480           26   99%
+  481..512           27   99%
+  513..1024         471   99%
+ 1025..2048         389   99%
+ 2049..4096         182   99%
+ 4097..8192          74   99%
+ 8193..16384         34   99%
+16385..32768         17   99%
+32769..65536          5   99%
+65537..131073         3  100%
+
+
+This information is gathered to help design the new built-in
+backend for sqlite 2.0.  Note in particular that 99% of all
+database entries have a combined key and data size of less than
+144 bytes.  So if a leaf node in the new database is able to
+store 144 bytes of combined key and data, only 1% of the leaves
+will require overflow pages.  Furthermore, note that no key
+is larger than 99 bytes, so if the key will never be on an
+overflow page.
+
+The average combined size of key+data is 48.  Add in 16 bytes of
+overhead for a total of 64.  That means that a 1K page will
+store (on average) about 16 entries.
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/showdb.c b/client/src/thirdparty/sqlite-3.4.2/tool/showdb.c
new file mode 100644
index 0000000..b2ed562
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/showdb.c
@@ -0,0 +1,86 @@
+/*
+** A utility for printing all or part of an SQLite database file.
+*/
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+
+static int pagesize = 1024;
+static int db = -1;
+static int mxPage = 0;
+static int perLine = 32;
+
+static void out_of_memory(void){
+  fprintf(stderr,"Out of memory...\n");
+  exit(1);
+}
+
+static print_page(int iPg){
+  unsigned char *aData;
+  int i, j;
+  aData = malloc(pagesize);
+  if( aData==0 ) out_of_memory();
+  lseek(db, (iPg-1)*pagesize, SEEK_SET);
+  read(db, aData, pagesize);
+  fprintf(stdout, "Page %d:\n", iPg);
+  for(i=0; i<pagesize; i += perLine){
+    fprintf(stdout, " %03x: ",i);
+    for(j=0; j<perLine; j++){
+      fprintf(stdout,"%02x ", aData[i+j]);
+    }
+    for(j=0; j<perLine; j++){
+      fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.');
+    }
+    fprintf(stdout,"\n");
+  }
+  free(aData);
+}
+
+int main(int argc, char **argv){
+  struct stat sbuf;
+  if( argc<2 ){
+    fprintf(stderr,"Usage: %s FILENAME ?PAGE? ...\n", argv[0]);
+    exit(1);
+  }
+  db = open(argv[1], O_RDONLY);
+  if( db<0 ){
+    fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
+    exit(1);
+  }
+  fstat(db, &sbuf);
+  mxPage = sbuf.st_size/pagesize + 1;
+  if( argc==2 ){
+    int i;
+    for(i=1; i<=mxPage; i++) print_page(i);
+  }else{
+    int i;
+    for(i=2; i<argc; i++){
+      int iStart, iEnd;
+      char *zLeft;
+      iStart = strtol(argv[i], &zLeft, 0);
+      if( zLeft && strcmp(zLeft,"..end")==0 ){
+        iEnd = mxPage;
+      }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){
+        iEnd = strtol(&zLeft[2], 0, 0);
+      }else{
+        iEnd = iStart;
+      }
+      if( iStart<1 || iEnd<iStart || iEnd>mxPage ){
+        fprintf(stderr,
+          "Page argument should be LOWER?..UPPER?.  Range 1 to %d\n",
+          mxPage);
+        exit(1);
+      }
+      while( iStart<=iEnd ){
+        print_page(iStart);
+        iStart++;
+      }
+    }
+  }
+  close(db);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/showjournal.c b/client/src/thirdparty/sqlite-3.4.2/tool/showjournal.c
new file mode 100644
index 0000000..ec93c91
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/showjournal.c
@@ -0,0 +1,76 @@
+/*
+** A utility for printing an SQLite database journal.
+*/
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+
+static int pagesize = 1024;
+static int db = -1;
+static int mxPage = 0;
+
+static void out_of_memory(void){
+  fprintf(stderr,"Out of memory...\n");
+  exit(1);
+}
+
+static print_page(int iPg){
+  unsigned char *aData;
+  int i, j;
+  aData = malloc(pagesize);
+  if( aData==0 ) out_of_memory();
+  read(db, aData, pagesize);
+  fprintf(stdout, "Page %d:\n", iPg);
+  for(i=0; i<pagesize; i += 16){
+    fprintf(stdout, " %03x: ",i);
+    for(j=0; j<16; j++){
+      fprintf(stdout,"%02x ", aData[i+j]);
+    }
+    for(j=0; j<16; j++){
+      fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.');
+    }
+    fprintf(stdout,"\n");
+  }
+  free(aData);
+}
+
+int main(int argc, char **argv){
+  struct stat sbuf;
+  unsigned int u;
+  int rc;
+  unsigned char zBuf[10];
+  unsigned char zBuf2[sizeof(u)];
+  if( argc!=2 ){
+    fprintf(stderr,"Usage: %s FILENAME\n", argv[0]);
+    exit(1);
+  }
+  db = open(argv[1], O_RDONLY);
+  if( db<0 ){
+    fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
+    exit(1);
+  }
+  read(db, zBuf, 8);
+  if( zBuf[7]==0xd6 ){
+    read(db, &u, sizeof(u));
+    printf("Records in Journal: %u\n", u);
+    read(db, &u, sizeof(u));
+    printf("Magic Number: 0x%08x\n", u);
+  }
+  read(db, zBuf2, sizeof(zBuf2));
+  u = zBuf2[0]<<24 | zBuf2[1]<<16 | zBuf2[2]<<8 | zBuf2[3];
+  printf("Database Size: %u\n", u);
+  while( read(db, zBuf2, sizeof(zBuf2))==sizeof(zBuf2) ){
+    u = zBuf2[0]<<24 | zBuf2[1]<<16 | zBuf2[2]<<8 | zBuf2[3];
+    print_page(u);
+    if( zBuf[7]==0xd6 ){
+      read(db, &u, sizeof(u));
+      printf("Checksum: 0x%08x\n", u);
+    }
+  }
+  close(db);
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/soak1.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/soak1.tcl
new file mode 100644
index 0000000..7a78b8d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/soak1.tcl
@@ -0,0 +1,103 @@
+#!/usr/bin/tclsh
+#
+# Usage:
+#
+#    tclsh soak1.tcl local-makefile.mk ?target? ?scenario?
+#
+# This generates many variations on local-makefile.mk (by modifing
+# the OPT = lines) and runs them will fulltest, one by one.  The
+# constructed makefiles are named "soak1.mk".
+#
+# If ?target? is provided, that is the makefile target that is run.
+# The default is "fulltest"
+#
+# If ?scenario? is provided, it is the name of a single scenario to
+# be run.   All other scenarios are skipped.
+#
+set localmake [lindex $argv 0]
+set target [lindex $argv 1]
+set scene [lindex $argv 2]
+if {$target==""} {set target fulltest}
+if {$scene==""} {set scene all}
+
+set in [open $localmake]
+set maketxt [read $in]
+close $in
+regsub -all {\\\n} $maketxt {} maketxt
+#set makefilename "soak1-[expr {int(rand()*1000000000)}].mk"
+set makefilename "soak1.mk"
+
+# Generate a makefile
+#
+proc generate_makefile {pattern} {
+  global makefilename maketxt
+  set out [open $makefilename w]
+  set seen_opt 0
+  foreach line [split $maketxt \n] {
+    if {[regexp {^ *#? *OPTS[ =+]} $line]} {
+      if {!$seen_opt} {
+         puts $out "OPTS += -DSQLITE_NO_SYNC=1"
+         foreach x $pattern {
+           puts $out "OPTS += -D$x"
+         }
+         set seen_opt 1
+      }
+    } else {
+      puts $out $line
+    }
+  }
+  close $out
+}
+
+# Run a test
+#
+proc scenario {id title pattern} {
+  global makefilename target scene
+  if {$scene!="all" && $scene!=$id && $scene!=$title} return
+  puts "**************** $title ***************"
+  generate_makefile $pattern
+  exec make -f $makefilename clean >@stdout 2>@stdout
+  exec make -f $makefilename $target >@stdout 2>@stdout
+}
+
+###############################################################################
+# Add new scenarios here
+#
+scenario 0 {Default} {}
+scenario 1 {Debug} {
+  SQLITE_DEBUG=1
+  SQLITE_MEMDEBUG=1
+}
+scenario 2 {Everything} {
+  SQLITE_DEBUG=1
+  SQLITE_MEMDEBUG=1
+  SQLITE_ENABLE_MEMORY_MANAGEMENT=1
+  SQLITE_ENABLE_COLUMN_METADATA=1
+  SQLITE_ENABLE_LOAD_EXTENSION=1 HAVE_DLOPEN=1
+  SQLITE_ENABLE_MEMORY_MANAGEMENT=1
+}
+scenario 3 {Customer-1} {
+  SQLITE_DEBUG=1 SQLITE_MEMDEBUG=1
+  THREADSAFE=1 OS_UNIX=1
+  SQLITE_DISABLE_LFS=1
+  SQLITE_DEFAULT_AUTOVACUUM=1
+  SQLITE_DEFAULT_PAGE_SIZE=1024
+  SQLITE_MAX_PAGE_SIZE=4096
+  SQLITE_DEFAULT_CACHE_SIZE=64
+  SQLITE_DEFAULT_TEMP_CACHE_SIZE=32
+  TEMP_STORE=3
+  SQLITE_OMIT_PROGRESS_CALLBACK=1
+  SQLITE_OMIT_LOAD_EXTENSION=1
+  SQLITE_OMIT_VIRTUALTABLE=1
+  SQLITE_ENABLE_IOTRACE=1
+}
+scenario 4 {Small-Cache} {
+  SQLITE_DEBUG=1 SQLITE_MEMDEBUG=1
+  THREADSAFE=1 OS_UNIX=1
+  SQLITE_DEFAULT_AUTOVACUUM=1
+  SQLITE_DEFAULT_PAGE_SIZE=1024
+  SQLITE_MAX_PAGE_SIZE=2048
+  SQLITE_DEFAULT_CACHE_SIZE=13
+  SQLITE_DEFAULT_TEMP_CACHE_SIZE=11
+  TEMP_STORE=1
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/space_used.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/space_used.tcl
new file mode 100644
index 0000000..2044aa3
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/space_used.tcl
@@ -0,0 +1,111 @@
+# Run this TCL script using "testfixture" in order get a report that shows
+# how much disk space is used by a particular data to actually store data
+# versus how much space is unused.
+#
+
+# Get the name of the database to analyze
+#
+if {[llength $argv]!=1} {
+  puts stderr "Usage: $argv0 database-name"
+  exit 1
+}
+set file_to_analyze [lindex $argv 0]
+
+# Open the database
+#
+sqlite db [lindex $argv 0]
+set DB [btree_open [lindex $argv 0]]
+
+# Output the schema for the generated report
+#
+puts \
+{BEGIN;
+CREATE TABLE space_used(
+   name clob,        -- Name of a table or index in the database file
+   is_index boolean, -- TRUE if it is an index, false for a table
+   payload int,      -- Total amount of data stored in this table or index
+   pri_pages int,    -- Number of primary pages used
+   ovfl_pages int,   -- Number of overflow pages used
+   pri_unused int,   -- Number of unused bytes on primary pages
+   ovfl_unused int   -- Number of unused bytes on overflow pages
+);}
+
+# This query will be used to find the root page number for every index and
+# table in the database.
+#
+set sql {
+  SELECT name, type, rootpage FROM sqlite_master
+  UNION ALL
+  SELECT 'sqlite_master', 'table', 2
+  ORDER BY 1
+}
+
+# Initialize variables used for summary statistics.
+#
+set total_size 0
+set total_primary 0
+set total_overflow 0
+set total_unused_primary 0
+set total_unused_ovfl 0
+
+# Analyze every table in the database, one at a time.
+#
+foreach {name type rootpage} [db eval $sql] {
+  set cursor [btree_cursor $DB $rootpage 0]
+  set go [btree_first $cursor]
+  set size 0
+  catch {unset pg_used}
+  set unused_ovfl 0
+  set n_overflow 0
+  while {$go==0} {
+    set payload [btree_payload_size $cursor]
+    incr size $payload
+    set stat [btree_cursor_dump $cursor]
+    set pgno [lindex $stat 0]
+    set freebytes [lindex $stat 4]
+    set pg_used($pgno) $freebytes
+    if {$payload>238} {
+      set n [expr {($payload-238+1019)/1020}]
+      incr n_overflow $n
+      incr unused_ovfl [expr {$n*1020+238-$payload}]
+    }
+    set go [btree_next $cursor]
+  }
+  btree_close_cursor $cursor
+  set n_primary [llength [array names pg_used]]
+  set unused_primary 0
+  foreach x [array names pg_used] {incr unused_primary $pg_used($x)}
+  regsub -all ' $name '' name
+  puts -nonewline "INSERT INTO space_used VALUES('$name'"
+  puts -nonewline ",[expr {$type=="index"}]"
+  puts ",$size,$n_primary,$n_overflow,$unused_primary,$unused_ovfl);"
+  incr total_size $size
+  incr total_primary $n_primary
+  incr total_overflow $n_overflow
+  incr total_unused_primary $unused_primary
+  incr total_unused_ovfl $unused_ovfl
+}
+
+# Output summary statistics:
+#
+puts "-- Total payload size: $total_size"
+puts "-- Total pages used: $total_primary primary and $total_overflow overflow"
+set file_pgcnt [expr {[file size [lindex $argv 0]]/1024}]
+puts -nonewline "-- Total unused bytes on primary pages: $total_unused_primary"
+if {$total_primary>0} {
+  set upp [expr {$total_unused_primary/$total_primary}]
+  puts " (avg $upp bytes/page)"
+} else {
+  puts ""
+}
+puts -nonewline "-- Total unused bytes on overflow pages: $total_unused_ovfl"
+if {$total_overflow>0} {
+  set upp [expr {$total_unused_ovfl/$total_overflow}]
+  puts " (avg $upp bytes/page)"
+} else {
+  puts ""
+}
+set n_free [expr {$file_pgcnt-$total_primary-$total_overflow}]
+if {$n_free>0} {incr n_free -1}
+puts "-- Total pages on freelist: $n_free"
+puts "COMMIT;"
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/spaceanal.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/spaceanal.tcl
new file mode 100644
index 0000000..3718357
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/spaceanal.tcl
@@ -0,0 +1,863 @@
+# Run this TCL script using "testfixture" in order get a report that shows
+# how much disk space is used by a particular data to actually store data
+# versus how much space is unused.
+#
+
+if {[catch {
+
+# Get the name of the database to analyze
+#
+#set argv $argv0
+if {[llength $argv]!=1} {
+  puts stderr "Usage: $argv0 database-name"
+  exit 1
+}
+set file_to_analyze [lindex $argv 0]
+if {![file exists $file_to_analyze]} {
+  puts stderr "No such file: $file_to_analyze"
+  exit 1
+}
+if {![file readable $file_to_analyze]} {
+  puts stderr "File is not readable: $file_to_analyze"
+  exit 1
+}
+if {[file size $file_to_analyze]<512} {
+  puts stderr "Empty or malformed database: $file_to_analyze"
+  exit 1
+}
+
+# Maximum distance between pages before we consider it a "gap"
+#
+set MAXGAP 3
+
+# Open the database
+#
+sqlite3 db [lindex $argv 0]
+set DB [btree_open [lindex $argv 0] 1000 0]
+
+# In-memory database for collecting statistics. This script loops through
+# the tables and indices in the database being analyzed, adding a row for each
+# to an in-memory database (for which the schema is shown below). It then
+# queries the in-memory db to produce the space-analysis report.
+#
+sqlite3 mem :memory:
+set tabledef\
+{CREATE TABLE space_used(
+   name clob,        -- Name of a table or index in the database file
+   tblname clob,     -- Name of associated table
+   is_index boolean, -- TRUE if it is an index, false for a table
+   nentry int,       -- Number of entries in the BTree
+   leaf_entries int, -- Number of leaf entries
+   payload int,      -- Total amount of data stored in this table or index
+   ovfl_payload int, -- Total amount of data stored on overflow pages
+   ovfl_cnt int,     -- Number of entries that use overflow
+   mx_payload int,   -- Maximum payload size
+   int_pages int,    -- Number of interior pages used
+   leaf_pages int,   -- Number of leaf pages used
+   ovfl_pages int,   -- Number of overflow pages used
+   int_unused int,   -- Number of unused bytes on interior pages
+   leaf_unused int,  -- Number of unused bytes on primary pages
+   ovfl_unused int,  -- Number of unused bytes on overflow pages
+   gap_cnt int       -- Number of gaps in the page layout
+);}
+mem eval $tabledef
+
+proc integerify {real} {
+  if {[string is double -strict $real]} {
+    return [expr {int($real)}]
+  } else {
+    return 0
+  }
+}
+mem function int integerify
+
+# Quote a string for use in an SQL query. Examples:
+#
+# [quote {hello world}]   == {'hello world'}
+# [quote {hello world's}] == {'hello world''s'}
+#
+proc quote {txt} {
+  regsub -all ' $txt '' q
+  return '$q'
+}
+
+# This proc is a wrapper around the btree_cursor_info command. The
+# second argument is an open btree cursor returned by [btree_cursor].
+# The first argument is the name of an array variable that exists in
+# the scope of the caller. If the third argument is non-zero, then
+# info is returned for the page that lies $up entries upwards in the
+# tree-structure. (i.e. $up==1 returns the parent page, $up==2 the 
+# grandparent etc.)
+#
+# The following entries in that array are filled in with information retrieved
+# using [btree_cursor_info]:
+#
+#   $arrayvar(page_no)             =  The page number
+#   $arrayvar(entry_no)            =  The entry number
+#   $arrayvar(page_entries)        =  Total number of entries on this page
+#   $arrayvar(cell_size)           =  Cell size (local payload + header)
+#   $arrayvar(page_freebytes)      =  Number of free bytes on this page
+#   $arrayvar(page_freeblocks)     =  Number of free blocks on the page
+#   $arrayvar(payload_bytes)       =  Total payload size (local + overflow)
+#   $arrayvar(header_bytes)        =  Header size in bytes
+#   $arrayvar(local_payload_bytes) =  Local payload size
+#   $arrayvar(parent)              =  Parent page number
+# 
+proc cursor_info {arrayvar csr {up 0}} {
+  upvar $arrayvar a
+  foreach [list a(page_no) \
+                a(entry_no) \
+                a(page_entries) \
+                a(cell_size) \
+                a(page_freebytes) \
+                a(page_freeblocks) \
+                a(payload_bytes) \
+                a(header_bytes) \
+                a(local_payload_bytes) \
+                a(parent) \
+                a(first_ovfl) ] [btree_cursor_info $csr $up] break
+}
+
+# Determine the page-size of the database. This global variable is used
+# throughout the script.
+#
+set pageSize [db eval {PRAGMA page_size}]
+
+# Analyze every table in the database, one at a time.
+#
+# The following query returns the name and root-page of each table in the
+# database, including the sqlite_master table.
+#
+set sql {
+  SELECT name, rootpage FROM sqlite_master
+   WHERE type='table' AND rootpage>0
+  UNION ALL
+  SELECT 'sqlite_master', 1
+  ORDER BY 1
+}
+set wideZero [expr {10000000000 - 10000000000}]
+foreach {name rootpage} [db eval $sql] {
+  puts stderr "Analyzing table $name..."
+
+  # Code below traverses the table being analyzed (table name $name), using the
+  # btree cursor $cursor. Statistics related to table $name are accumulated in
+  # the following variables:
+  #
+  set total_payload $wideZero        ;# Payload space used by all entries
+  set total_ovfl $wideZero           ;# Payload space on overflow pages
+  set unused_int $wideZero           ;# Unused space on interior nodes
+  set unused_leaf $wideZero          ;# Unused space on leaf nodes
+  set unused_ovfl $wideZero          ;# Unused space on overflow pages
+  set cnt_ovfl $wideZero             ;# Number of entries that use overflows
+  set cnt_leaf_entry $wideZero       ;# Number of leaf entries
+  set cnt_int_entry $wideZero        ;# Number of interor entries
+  set mx_payload $wideZero           ;# Maximum payload size
+  set ovfl_pages $wideZero           ;# Number of overflow pages used
+  set leaf_pages $wideZero           ;# Number of leaf pages
+  set int_pages $wideZero            ;# Number of interior pages
+  set gap_cnt 0                      ;# Number of holes in the page sequence
+  set prev_pgno 0                    ;# Last page number seen
+
+  # As the btree is traversed, the array variable $seen($pgno) is set to 1
+  # the first time page $pgno is encountered.
+  #
+  catch {unset seen}
+
+  # The following loop runs once for each entry in table $name. The table
+  # is traversed using the btree cursor stored in variable $csr
+  #
+  set csr [btree_cursor $DB $rootpage 0]
+  for {btree_first $csr} {![btree_eof $csr]} {btree_next $csr} {
+    incr cnt_leaf_entry
+
+    # Retrieve information about the entry the btree-cursor points to into
+    # the array variable $ci (cursor info).
+    #
+    cursor_info ci $csr
+
+    # Check if the payload of this entry is greater than the current 
+    # $mx_payload statistic for the table. Also increase the $total_payload
+    # statistic.
+    #
+    if {$ci(payload_bytes)>$mx_payload} {set mx_payload $ci(payload_bytes)}
+    incr total_payload $ci(payload_bytes)
+
+    # If this entry uses overflow pages, then update the $cnt_ovfl, 
+    # $total_ovfl, $ovfl_pages and $unused_ovfl statistics.
+    #
+    set ovfl [expr {$ci(payload_bytes)-$ci(local_payload_bytes)}]
+    if {$ovfl} {
+      incr cnt_ovfl
+      incr total_ovfl $ovfl
+      set n [expr {int(ceil($ovfl/($pageSize-4.0)))}]
+      incr ovfl_pages $n
+      incr unused_ovfl [expr {$n*($pageSize-4) - $ovfl}]
+      set pglist [btree_ovfl_info $DB $csr]
+    } else {
+      set pglist {}
+    }
+
+    # If this is the first table entry analyzed for the page, then update
+    # the page-related statistics $leaf_pages and $unused_leaf. Also, if
+    # this page has a parent page that has not been analyzed, retrieve
+    # info for the parent and update statistics for it too.
+    #
+    if {![info exists seen($ci(page_no))]} {
+      set seen($ci(page_no)) 1
+      incr leaf_pages
+      incr unused_leaf $ci(page_freebytes)
+      set pglist "$ci(page_no) $pglist"
+
+      # Now check if the page has a parent that has not been analyzed. If
+      # so, update the $int_pages, $cnt_int_entry and $unused_int statistics
+      # accordingly. Then check if the parent page has a parent that has
+      # not yet been analyzed etc.
+      #
+      # set parent $ci(parent_page_no)
+      for {set up 1} \
+          {$ci(parent)!=0 && ![info exists seen($ci(parent))]} {incr up} \
+      {
+        # Mark the parent as seen.
+        #
+        set seen($ci(parent)) 1
+
+        # Retrieve info for the parent and update statistics.
+        cursor_info ci $csr $up
+        incr int_pages
+        incr cnt_int_entry $ci(page_entries)
+        incr unused_int $ci(page_freebytes)
+
+        # parent pages come before their first child
+        set pglist "$ci(page_no) $pglist"
+      }
+    }
+
+    # Check the page list for fragmentation
+    #
+    foreach pg $pglist {
+      if {$pg!=$prev_pgno+1 && $prev_pgno>0} {
+        incr gap_cnt
+      }
+      set prev_pgno $pg
+    }
+  }
+  btree_close_cursor $csr
+
+  # Handle the special case where a table contains no data. In this case
+  # all statistics are zero, except for the number of leaf pages (1) and
+  # the unused bytes on leaf pages ($pageSize - 8).
+  #
+  # An exception to the above is the sqlite_master table. If it is empty
+  # then all statistics are zero except for the number of leaf pages (1),
+  # and the number of unused bytes on leaf pages ($pageSize - 112).
+  #
+  if {[llength [array names seen]]==0} {
+    set leaf_pages 1
+    if {$rootpage==1} {
+      set unused_leaf [expr {$pageSize-112}]
+    } else {
+      set unused_leaf [expr {$pageSize-8}]
+    }
+  }
+
+  # Insert the statistics for the table analyzed into the in-memory database.
+  #
+  set sql "INSERT INTO space_used VALUES("
+  append sql [quote $name]
+  append sql ",[quote $name]"
+  append sql ",0"
+  append sql ",[expr {$cnt_leaf_entry+$cnt_int_entry}]"
+  append sql ",$cnt_leaf_entry"
+  append sql ",$total_payload"
+  append sql ",$total_ovfl"
+  append sql ",$cnt_ovfl"
+  append sql ",$mx_payload"
+  append sql ",$int_pages"
+  append sql ",$leaf_pages"
+  append sql ",$ovfl_pages"
+  append sql ",$unused_int"
+  append sql ",$unused_leaf"
+  append sql ",$unused_ovfl"
+  append sql ",$gap_cnt"
+  append sql );
+  mem eval $sql
+}
+
+# Analyze every index in the database, one at a time.
+#
+# The query below returns the name, associated table and root-page number 
+# for every index in the database.
+#
+set sql {
+  SELECT name, tbl_name, rootpage FROM sqlite_master WHERE type='index'
+  ORDER BY 2, 1
+}
+foreach {name tbl_name rootpage} [db eval $sql] {
+  puts stderr "Analyzing index $name of table $tbl_name..."
+
+  # Code below traverses the index being analyzed (index name $name), using the
+  # btree cursor $cursor. Statistics related to index $name are accumulated in
+  # the following variables:
+  #
+  set total_payload $wideZero        ;# Payload space used by all entries
+  set total_ovfl $wideZero           ;# Payload space on overflow pages
+  set unused_leaf $wideZero          ;# Unused space on leaf nodes
+  set unused_ovfl $wideZero          ;# Unused space on overflow pages
+  set cnt_ovfl $wideZero             ;# Number of entries that use overflows
+  set cnt_leaf_entry $wideZero       ;# Number of leaf entries
+  set mx_payload $wideZero           ;# Maximum payload size
+  set ovfl_pages $wideZero           ;# Number of overflow pages used
+  set leaf_pages $wideZero           ;# Number of leaf pages
+  set gap_cnt 0                      ;# Number of holes in the page sequence
+  set prev_pgno 0                    ;# Last page number seen
+
+  # As the btree is traversed, the array variable $seen($pgno) is set to 1
+  # the first time page $pgno is encountered.
+  #
+  catch {unset seen}
+
+  # The following loop runs once for each entry in index $name. The index
+  # is traversed using the btree cursor stored in variable $csr
+  #
+  set csr [btree_cursor $DB $rootpage 0]
+  for {btree_first $csr} {![btree_eof $csr]} {btree_next $csr} {
+    incr cnt_leaf_entry
+
+    # Retrieve information about the entry the btree-cursor points to into
+    # the array variable $ci (cursor info).
+    #
+    cursor_info ci $csr
+
+    # Check if the payload of this entry is greater than the current 
+    # $mx_payload statistic for the table. Also increase the $total_payload
+    # statistic.
+    #
+    set payload [btree_keysize $csr]
+    if {$payload>$mx_payload} {set mx_payload $payload}
+    incr total_payload $payload
+
+    # If this entry uses overflow pages, then update the $cnt_ovfl, 
+    # $total_ovfl, $ovfl_pages and $unused_ovfl statistics.
+    #
+    set ovfl [expr {$payload-$ci(local_payload_bytes)}]
+    if {$ovfl} {
+      incr cnt_ovfl
+      incr total_ovfl $ovfl
+      set n [expr {int(ceil($ovfl/($pageSize-4.0)))}]
+      incr ovfl_pages $n
+      incr unused_ovfl [expr {$n*($pageSize-4) - $ovfl}]
+    }
+
+    # If this is the first table entry analyzed for the page, then update
+    # the page-related statistics $leaf_pages and $unused_leaf.
+    #
+    if {![info exists seen($ci(page_no))]} {
+      set seen($ci(page_no)) 1
+      incr leaf_pages
+      incr unused_leaf $ci(page_freebytes)
+      set pg $ci(page_no)
+      if {$prev_pgno>0 && $pg!=$prev_pgno+1} {
+        incr gap_cnt
+      }
+      set prev_pgno $ci(page_no)
+    }
+  }
+  btree_close_cursor $csr
+
+  # Handle the special case where a index contains no data. In this case
+  # all statistics are zero, except for the number of leaf pages (1) and
+  # the unused bytes on leaf pages ($pageSize - 8).
+  #
+  if {[llength [array names seen]]==0} {
+    set leaf_pages 1
+    set unused_leaf [expr {$pageSize-8}]
+  }
+
+  # Insert the statistics for the index analyzed into the in-memory database.
+  #
+  set sql "INSERT INTO space_used VALUES("
+  append sql [quote $name]
+  append sql ",[quote $tbl_name]"
+  append sql ",1"
+  append sql ",$cnt_leaf_entry"
+  append sql ",$cnt_leaf_entry"
+  append sql ",$total_payload"
+  append sql ",$total_ovfl"
+  append sql ",$cnt_ovfl"
+  append sql ",$mx_payload"
+  append sql ",0"
+  append sql ",$leaf_pages"
+  append sql ",$ovfl_pages"
+  append sql ",0"
+  append sql ",$unused_leaf"
+  append sql ",$unused_ovfl"
+  append sql ",$gap_cnt"
+  append sql );
+  mem eval $sql
+}
+
+# Generate a single line of output in the statistics section of the
+# report.
+#
+proc statline {title value {extra {}}} {
+  set len [string length $title]
+  set dots [string range {......................................} $len end]
+  set len [string length $value]
+  set sp2 [string range {          } $len end]
+  if {$extra ne ""} {
+    set extra " $extra"
+  }
+  puts "$title$dots $value$sp2$extra"
+}
+
+# Generate a formatted percentage value for $num/$denom
+#
+proc percent {num denom {of {}}} {
+  if {$denom==0.0} {return ""}
+  set v [expr {$num*100.0/$denom}]
+  set of {}
+  if {$v==100.0 || $v<0.001 || ($v>1.0 && $v<99.0)} {
+    return [format {%5.1f%% %s} $v $of]
+  } elseif {$v<0.1 || $v>99.9} {
+    return [format {%7.3f%% %s} $v $of]
+  } else {
+    return [format {%6.2f%% %s} $v $of]
+  }
+}
+
+proc divide {num denom} {
+  if {$denom==0} {return 0.0}
+  return [format %.2f [expr double($num)/double($denom)]]
+}
+
+# Generate a subreport that covers some subset of the database.
+# the $where clause determines which subset to analyze.
+#
+proc subreport {title where} {
+  global pageSize file_pgcnt
+
+  # Query the in-memory database for the sum of various statistics 
+  # for the subset of tables/indices identified by the WHERE clause in
+  # $where. Note that even if the WHERE clause matches no rows, the
+  # following query returns exactly one row (because it is an aggregate).
+  #
+  # The results of the query are stored directly by SQLite into local 
+  # variables (i.e. $nentry, $nleaf etc.).
+  #
+  mem eval "
+    SELECT
+      int(sum(nentry)) AS nentry,
+      int(sum(leaf_entries)) AS nleaf,
+      int(sum(payload)) AS payload,
+      int(sum(ovfl_payload)) AS ovfl_payload,
+      max(mx_payload) AS mx_payload,
+      int(sum(ovfl_cnt)) as ovfl_cnt,
+      int(sum(leaf_pages)) AS leaf_pages,
+      int(sum(int_pages)) AS int_pages,
+      int(sum(ovfl_pages)) AS ovfl_pages,
+      int(sum(leaf_unused)) AS leaf_unused,
+      int(sum(int_unused)) AS int_unused,
+      int(sum(ovfl_unused)) AS ovfl_unused,
+      int(sum(gap_cnt)) AS gap_cnt
+    FROM space_used WHERE $where" {} {}
+
+  # Output the sub-report title, nicely decorated with * characters.
+  #
+  puts ""
+  set len [string length $title]
+  set stars [string repeat * [expr 65-$len]]
+  puts "*** $title $stars"
+  puts ""
+
+  # Calculate statistics and store the results in TCL variables, as follows:
+  #
+  # total_pages: Database pages consumed.
+  # total_pages_percent: Pages consumed as a percentage of the file.
+  # storage: Bytes consumed.
+  # payload_percent: Payload bytes used as a percentage of $storage.
+  # total_unused: Unused bytes on pages.
+  # avg_payload: Average payload per btree entry.
+  # avg_fanout: Average fanout for internal pages.
+  # avg_unused: Average unused bytes per btree entry.
+  # ovfl_cnt_percent: Percentage of btree entries that use overflow pages.
+  #
+  set total_pages [expr {$leaf_pages+$int_pages+$ovfl_pages}]
+  set total_pages_percent [percent $total_pages $file_pgcnt]
+  set storage [expr {$total_pages*$pageSize}]
+  set payload_percent [percent $payload $storage {of storage consumed}]
+  set total_unused [expr {$ovfl_unused+$int_unused+$leaf_unused}]
+  set avg_payload [divide $payload $nleaf]
+  set avg_unused [divide $total_unused $nleaf]
+  if {$int_pages>0} {
+    # TODO: Is this formula correct?
+    set nTab [mem eval "
+      SELECT count(*) FROM (
+          SELECT DISTINCT tblname FROM space_used WHERE $where AND is_index=0
+      )
+    "]
+    set avg_fanout [mem eval "
+      SELECT (sum(leaf_pages+int_pages)-$nTab)/sum(int_pages) FROM space_used
+          WHERE $where AND is_index = 0
+    "]
+    set avg_fanout [format %.2f $avg_fanout]
+  }
+  set ovfl_cnt_percent [percent $ovfl_cnt $nleaf {of all entries}]
+
+  # Print out the sub-report statistics.
+  #
+  statline {Percentage of total database} $total_pages_percent
+  statline {Number of entries} $nleaf
+  statline {Bytes of storage consumed} $storage
+  statline {Bytes of payload} $payload $payload_percent
+  statline {Average payload per entry} $avg_payload
+  statline {Average unused bytes per entry} $avg_unused
+  if {[info exists avg_fanout]} {
+    statline {Average fanout} $avg_fanout
+  }
+  if {$total_pages>1} {
+    set fragmentation [percent $gap_cnt [expr {$total_pages-1}] {fragmentation}]
+    statline {Fragmentation} $fragmentation
+  }
+  statline {Maximum payload per entry} $mx_payload
+  statline {Entries that use overflow} $ovfl_cnt $ovfl_cnt_percent
+  if {$int_pages>0} {
+    statline {Index pages used} $int_pages
+  }
+  statline {Primary pages used} $leaf_pages
+  statline {Overflow pages used} $ovfl_pages
+  statline {Total pages used} $total_pages
+  if {$int_unused>0} {
+    set int_unused_percent \
+         [percent $int_unused [expr {$int_pages*$pageSize}] {of index space}]
+    statline "Unused bytes on index pages" $int_unused $int_unused_percent
+  }
+  statline "Unused bytes on primary pages" $leaf_unused \
+     [percent $leaf_unused [expr {$leaf_pages*$pageSize}] {of primary space}]
+  statline "Unused bytes on overflow pages" $ovfl_unused \
+     [percent $ovfl_unused [expr {$ovfl_pages*$pageSize}] {of overflow space}]
+  statline "Unused bytes on all pages" $total_unused \
+               [percent $total_unused $storage {of all space}]
+  return 1
+}
+
+# Calculate the overhead in pages caused by auto-vacuum. 
+#
+# This procedure calculates and returns the number of pages used by the 
+# auto-vacuum 'pointer-map'. If the database does not support auto-vacuum,
+# then 0 is returned. The two arguments are the size of the database file in
+# pages and the page size used by the database (in bytes).
+proc autovacuum_overhead {filePages pageSize} {
+
+  # Read the value of meta 4. If non-zero, then the database supports
+  # auto-vacuum. It would be possible to use "PRAGMA auto_vacuum" instead,
+  # but that would not work if the SQLITE_OMIT_PRAGMA macro was defined
+  # when the library was built.
+  set meta4 [lindex [btree_get_meta $::DB] 4]
+
+  # If the database is not an auto-vacuum database or the file consists
+  # of one page only then there is no overhead for auto-vacuum. Return zero.
+  if {0==$meta4 || $filePages==1} {
+    return 0
+  }
+
+  # The number of entries on each pointer map page. The layout of the
+  # database file is one pointer-map page, followed by $ptrsPerPage other
+  # pages, followed by a pointer-map page etc. The first pointer-map page
+  # is the second page of the file overall.
+  set ptrsPerPage [expr double($pageSize/5)]
+
+  # Return the number of pointer map pages in the database.
+  return [expr int(ceil( ($filePages-1.0)/($ptrsPerPage+1.0) ))]
+}
+
+
+# Calculate the summary statistics for the database and store the results
+# in TCL variables. They are output below. Variables are as follows:
+#
+# pageSize:      Size of each page in bytes.
+# file_bytes:    File size in bytes.
+# file_pgcnt:    Number of pages in the file.
+# file_pgcnt2:   Number of pages in the file (calculated).
+# av_pgcnt:      Pages consumed by the auto-vacuum pointer-map.
+# av_percent:    Percentage of the file consumed by auto-vacuum pointer-map.
+# inuse_pgcnt:   Data pages in the file.
+# inuse_percent: Percentage of pages used to store data.
+# free_pgcnt:    Free pages calculated as (<total pages> - <in-use pages>)
+# free_pgcnt2:   Free pages in the file according to the file header.
+# free_percent:  Percentage of file consumed by free pages (calculated).
+# free_percent2: Percentage of file consumed by free pages (header).
+# ntable:        Number of tables in the db.
+# nindex:        Number of indices in the db.
+# nautoindex:    Number of indices created automatically.
+# nmanindex:     Number of indices created manually.
+# user_payload:  Number of bytes of payload in table btrees 
+#                (not including sqlite_master)
+# user_percent:  $user_payload as a percentage of total file size.
+
+set file_bytes  [file size $file_to_analyze]
+set file_pgcnt  [expr {$file_bytes/$pageSize}]
+
+set av_pgcnt    [autovacuum_overhead $file_pgcnt $pageSize]
+set av_percent  [percent $av_pgcnt $file_pgcnt]
+
+set sql {SELECT sum(leaf_pages+int_pages+ovfl_pages) FROM space_used}
+set inuse_pgcnt   [expr int([mem eval $sql])]
+set inuse_percent [percent $inuse_pgcnt $file_pgcnt]
+
+set free_pgcnt    [expr $file_pgcnt-$inuse_pgcnt-$av_pgcnt]
+set free_percent  [percent $free_pgcnt $file_pgcnt]
+set free_pgcnt2   [lindex [btree_get_meta $DB] 0]
+set free_percent2 [percent $free_pgcnt2 $file_pgcnt]
+
+set file_pgcnt2 [expr {$inuse_pgcnt+$free_pgcnt2+$av_pgcnt}]
+
+set ntable [db eval {SELECT count(*)+1 FROM sqlite_master WHERE type='table'}]
+set nindex [db eval {SELECT count(*) FROM sqlite_master WHERE type='index'}]
+set sql {SELECT count(*) FROM sqlite_master WHERE name LIKE 'sqlite_autoindex%'}
+set nautoindex [db eval $sql]
+set nmanindex [expr {$nindex-$nautoindex}]
+
+# set total_payload [mem eval "SELECT sum(payload) FROM space_used"]
+set user_payload [mem one {SELECT int(sum(payload)) FROM space_used
+     WHERE NOT is_index AND name NOT LIKE 'sqlite_master'}]
+set user_percent [percent $user_payload $file_bytes]
+
+# Output the summary statistics calculated above.
+#
+puts "/** Disk-Space Utilization Report For $file_to_analyze"
+catch {
+  puts "*** As of [clock format [clock seconds] -format {%Y-%b-%d %H:%M:%S}]"
+}
+puts ""
+statline {Page size in bytes} $pageSize
+statline {Pages in the whole file (measured)} $file_pgcnt
+statline {Pages in the whole file (calculated)} $file_pgcnt2
+statline {Pages that store data} $inuse_pgcnt $inuse_percent
+statline {Pages on the freelist (per header)} $free_pgcnt2 $free_percent2
+statline {Pages on the freelist (calculated)} $free_pgcnt $free_percent
+statline {Pages of auto-vacuum overhead} $av_pgcnt $av_percent
+statline {Number of tables in the database} $ntable
+statline {Number of indices} $nindex
+statline {Number of named indices} $nmanindex
+statline {Automatically generated indices} $nautoindex
+statline {Size of the file in bytes} $file_bytes
+statline {Bytes of user payload stored} $user_payload $user_percent
+
+# Output table rankings
+#
+puts ""
+puts "*** Page counts for all tables with their indices ********************"
+puts ""
+mem eval {SELECT tblname, count(*) AS cnt, 
+              int(sum(int_pages+leaf_pages+ovfl_pages)) AS size
+          FROM space_used GROUP BY tblname ORDER BY size+0 DESC, tblname} {} {
+  statline [string toupper $tblname] $size [percent $size $file_pgcnt]
+}
+
+# Output subreports
+#
+if {$nindex>0} {
+  subreport {All tables and indices} 1
+}
+subreport {All tables} {NOT is_index}
+if {$nindex>0} {
+  subreport {All indices} {is_index}
+}
+foreach tbl [mem eval {SELECT name FROM space_used WHERE NOT is_index
+                       ORDER BY name}] {
+  regsub ' $tbl '' qn
+  set name [string toupper $tbl]
+  set n [mem eval "SELECT count(*) FROM space_used WHERE tblname='$qn'"]
+  if {$n>1} {
+    subreport "Table $name and all its indices" "tblname='$qn'"
+    subreport "Table $name w/o any indices" "name='$qn'"
+    subreport "Indices of table $name" "tblname='$qn' AND is_index"
+  } else {
+    subreport "Table $name" "name='$qn'"
+  }
+}
+
+# Output instructions on what the numbers above mean.
+#
+puts {
+*** Definitions ******************************************************
+
+Page size in bytes
+
+    The number of bytes in a single page of the database file.  
+    Usually 1024.
+
+Number of pages in the whole file
+}
+puts \
+"    The number of $pageSize-byte pages that go into forming the complete
+    database"
+puts \
+{
+Pages that store data
+
+    The number of pages that store data, either as primary B*Tree pages or
+    as overflow pages.  The number at the right is the data pages divided by
+    the total number of pages in the file.
+
+Pages on the freelist
+
+    The number of pages that are not currently in use but are reserved for
+    future use.  The percentage at the right is the number of freelist pages
+    divided by the total number of pages in the file.
+
+Pages of auto-vacuum overhead
+
+    The number of pages that store data used by the database to facilitate
+    auto-vacuum. This is zero for databases that do not support auto-vacuum.
+
+Number of tables in the database
+
+    The number of tables in the database, including the SQLITE_MASTER table
+    used to store schema information.
+
+Number of indices
+
+    The total number of indices in the database.
+
+Number of named indices
+
+    The number of indices created using an explicit CREATE INDEX statement.
+
+Automatically generated indices
+
+    The number of indices used to implement PRIMARY KEY or UNIQUE constraints
+    on tables.
+
+Size of the file in bytes
+
+    The total amount of disk space used by the entire database files.
+
+Bytes of user payload stored
+
+    The total number of bytes of user payload stored in the database. The
+    schema information in the SQLITE_MASTER table is not counted when
+    computing this number.  The percentage at the right shows the payload
+    divided by the total file size.
+
+Percentage of total database
+
+    The amount of the complete database file that is devoted to storing
+    information described by this category.
+
+Number of entries
+
+    The total number of B-Tree key/value pairs stored under this category.
+
+Bytes of storage consumed
+
+    The total amount of disk space required to store all B-Tree entries
+    under this category.  The is the total number of pages used times
+    the pages size.
+
+Bytes of payload
+
+    The amount of payload stored under this category.  Payload is the data
+    part of table entries and the key part of index entries.  The percentage
+    at the right is the bytes of payload divided by the bytes of storage 
+    consumed.
+
+Average payload per entry
+
+    The average amount of payload on each entry.  This is just the bytes of
+    payload divided by the number of entries.
+
+Average unused bytes per entry
+
+    The average amount of free space remaining on all pages under this
+    category on a per-entry basis.  This is the number of unused bytes on
+    all pages divided by the number of entries.
+
+Fragmentation
+
+    The percentage of pages in the table or index that are not
+    consecutive in the disk file.  Many filesystems are optimized
+    for sequential file access so smaller fragmentation numbers 
+    sometimes result in faster queries, especially for larger
+    database files that do not fit in the disk cache.
+
+Maximum payload per entry
+
+    The largest payload size of any entry.
+
+Entries that use overflow
+
+    The number of entries that user one or more overflow pages.
+
+Total pages used
+
+    This is the number of pages used to hold all information in the current
+    category.  This is the sum of index, primary, and overflow pages.
+
+Index pages used
+
+    This is the number of pages in a table B-tree that hold only key (rowid)
+    information and no data.
+
+Primary pages used
+
+    This is the number of B-tree pages that hold both key and data.
+
+Overflow pages used
+
+    The total number of overflow pages used for this category.
+
+Unused bytes on index pages
+
+    The total number of bytes of unused space on all index pages.  The
+    percentage at the right is the number of unused bytes divided by the
+    total number of bytes on index pages.
+
+Unused bytes on primary pages
+
+    The total number of bytes of unused space on all primary pages.  The
+    percentage at the right is the number of unused bytes divided by the
+    total number of bytes on primary pages.
+
+Unused bytes on overflow pages
+
+    The total number of bytes of unused space on all overflow pages.  The
+    percentage at the right is the number of unused bytes divided by the
+    total number of bytes on overflow pages.
+
+Unused bytes on all pages
+
+    The total number of bytes of unused space on all primary and overflow 
+    pages.  The percentage at the right is the number of unused bytes 
+    divided by the total number of bytes.
+}
+
+# Output a dump of the in-memory database. This can be used for more
+# complex offline analysis.
+#
+puts "**********************************************************************"
+puts "The entire text of this report can be sourced into any SQL database"
+puts "engine for further analysis.  All of the text above is an SQL comment."
+puts "The data used to generate this report follows:"
+puts "*/"
+puts "BEGIN;"
+puts $tabledef
+unset -nocomplain x
+mem eval {SELECT * FROM space_used} x {
+  puts -nonewline "INSERT INTO space_used VALUES"
+  set sep (
+  foreach col $x(*) {
+    set v $x($col)
+    if {$v=="" || ![string is double $v]} {set v [quote $v]}
+    puts -nonewline $sep$v
+    set sep ,
+  }
+  puts ");"
+}
+puts "COMMIT;"
+
+} err]} {
+  puts "ERROR: $err"
+  puts $errorInfo
+  exit 1
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/speedtest.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/speedtest.tcl
new file mode 100644
index 0000000..ef39dc5
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/speedtest.tcl
@@ -0,0 +1,275 @@
+#!/usr/bin/tclsh
+#
+# Run this script using TCLSH to do a speed comparison between
+# various versions of SQLite and PostgreSQL and MySQL
+#
+
+# Run a test
+#
+set cnt 1
+proc runtest {title} {
+  global cnt
+  set sqlfile test$cnt.sql
+  puts "<h2>Test $cnt: $title</h2>"
+  incr cnt
+  set fd [open $sqlfile r]
+  set sql [string trim [read $fd [file size $sqlfile]]]
+  close $fd
+  set sx [split $sql \n]
+  set n [llength $sx]
+  if {$n>8} {
+    set sql {}
+    for {set i 0} {$i<3} {incr i} {append sql [lindex $sx $i]<br>\n}
+    append sql  "<i>... [expr {$n-6}] lines omitted</i><br>\n"
+    for {set i [expr {$n-3}]} {$i<$n} {incr i} {
+      append sql [lindex $sx $i]<br>\n
+    }
+  } else {
+    regsub -all \n [string trim $sql] <br> sql
+  }
+  puts "<blockquote>"
+  puts "$sql"
+  puts "</blockquote><table border=0 cellpadding=0 cellspacing=0>"
+  set format {<tr><td>%s</td><td align="right">&nbsp;&nbsp;&nbsp;%.3f</td></tr>}
+  set delay 1000
+#  exec sync; after $delay;
+#  set t [time "exec psql drh <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format PostgreSQL: $t]
+  exec sync; after $delay;
+  set t [time "exec mysql -f drh <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format MySQL: $t]
+#  set t [time "exec ./sqlite232 s232.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.3.2:} $t]
+#  set t [time "exec ./sqlite-100 s100.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.4 (cache=100):} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite248 s2k.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4.8:} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite248 sns.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4.8 (nosync):} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite2412 s2kb.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4.12:} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite2412 snsb.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4.12 (nosync):} $t]
+#  set t [time "exec ./sqlite-t1 st1.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.4 (test):} $t]
+  puts "</table>"
+}
+
+# Initialize the environment
+#
+expr srand(1)
+catch {exec /bin/sh -c {rm -f s*.db}}
+set fd [open clear.sql w]
+puts $fd {
+  drop table t1;
+  drop table t2;
+}
+close $fd
+catch {exec psql drh <clear.sql}
+catch {exec mysql drh <clear.sql}
+set fd [open 2kinit.sql w]
+puts $fd {
+  PRAGMA default_cache_size=2000;
+  PRAGMA default_synchronous=on;
+}
+close $fd
+exec ./sqlite248 s2k.db <2kinit.sql
+exec ./sqlite2412 s2kb.db <2kinit.sql
+set fd [open nosync-init.sql w]
+puts $fd {
+  PRAGMA default_cache_size=2000;
+  PRAGMA default_synchronous=off;
+}
+close $fd
+exec ./sqlite248 sns.db <nosync-init.sql
+exec ./sqlite2412 snsb.db <nosync-init.sql
+set ones {zero one two three four five six seven eight nine
+          ten eleven twelve thirteen fourteen fifteen sixteen seventeen
+          eighteen nineteen}
+set tens {{} ten twenty thirty forty fifty sixty seventy eighty ninety}
+proc number_name {n} {
+  if {$n>=1000} {
+    set txt "[number_name [expr {$n/1000}]] thousand"
+    set n [expr {$n%1000}]
+  } else {
+    set txt {}
+  }
+  if {$n>=100} {
+    append txt " [lindex $::ones [expr {$n/100}]] hundred"
+    set n [expr {$n%100}]
+  }
+  if {$n>=20} {
+    append txt " [lindex $::tens [expr {$n/10}]]"
+    set n [expr {$n%10}]
+  }
+  if {$n>0} {
+    append txt " [lindex $::ones $n]"
+  }
+  set txt [string trim $txt]
+  if {$txt==""} {set txt zero}
+  return $txt
+}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd "CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100));"
+for {set i 1} {$i<=1000} {incr i} {
+  set r [expr {int(rand()*100000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+close $fd
+runtest {1000 INSERTs}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+puts $fd "CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100));"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t2 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+
+set fd [open test$cnt.sql w]
+for {set i 0} {$i<100} {incr i} {
+  set lwr [expr {$i*100}]
+  set upr [expr {($i+10)*100}]
+  puts $fd "SELECT count(*), avg(b) FROM t2 WHERE b>=$lwr AND b<$upr;"
+}
+close $fd
+runtest {100 SELECTs without an index}
+
+
+
+set fd [open test$cnt.sql w]
+for {set i 1} {$i<=100} {incr i} {
+  puts $fd "SELECT count(*), avg(b) FROM t2 WHERE c LIKE '%[number_name $i]%';"
+}
+close $fd
+runtest {100 SELECTs on a string comparison}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {CREATE INDEX i2a ON t2(a);}
+puts $fd {CREATE INDEX i2b ON t2(b);}
+close $fd
+runtest {Creating an index}
+
+
+
+set fd [open test$cnt.sql w]
+for {set i 0} {$i<5000} {incr i} {
+  set lwr [expr {$i*100}]
+  set upr [expr {($i+1)*100}]
+  puts $fd "SELECT count(*), avg(b) FROM t2 WHERE b>=$lwr AND b<$upr;"
+}
+close $fd
+runtest {5000 SELECTs with an index}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 0} {$i<1000} {incr i} {
+  set lwr [expr {$i*10}]
+  set upr [expr {($i+1)*10}]
+  puts $fd "UPDATE t1 SET b=b*2 WHERE a>=$lwr AND a<$upr;"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {1000 UPDATEs without an index}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "UPDATE t2 SET b=$r WHERE a=$i;"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 UPDATEs with an index}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "UPDATE t2 SET c='[number_name $r]' WHERE a=$i;"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 text UPDATEs with an index}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+puts $fd "INSERT INTO t1 SELECT * FROM t2;"
+puts $fd "INSERT INTO t2 SELECT * FROM t1;"
+puts $fd "COMMIT;"
+close $fd
+runtest {INSERTs from a SELECT}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {DELETE FROM t2 WHERE c LIKE '%fifty%';}
+close $fd
+runtest {DELETE without an index}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {DELETE FROM t2 WHERE a>10 AND a<20000;}
+close $fd
+runtest {DELETE with an index}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {INSERT INTO t2 SELECT * FROM t1;}
+close $fd
+runtest {A big INSERT after a big DELETE}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {BEGIN;}
+puts $fd {DELETE FROM t1;}
+for {set i 1} {$i<=3000} {incr i} {
+  set r [expr {int(rand()*100000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd {COMMIT;}
+close $fd
+runtest {A big DELETE followed by many small INSERTs}
+
+
+
+set fd [open test$cnt.sql w]
+puts $fd {DROP TABLE t1;}
+puts $fd {DROP TABLE t2;}
+close $fd
+runtest {DROP TABLE}
diff --git a/client/src/thirdparty/sqlite-3.4.2/tool/speedtest2.tcl b/client/src/thirdparty/sqlite-3.4.2/tool/speedtest2.tcl
new file mode 100644
index 0000000..4fd632d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/tool/speedtest2.tcl
@@ -0,0 +1,207 @@
+#!/usr/bin/tclsh
+#
+# Run this script using TCLSH to do a speed comparison between
+# various versions of SQLite and PostgreSQL and MySQL
+#
+
+# Run a test
+#
+set cnt 1
+proc runtest {title} {
+  global cnt
+  set sqlfile test$cnt.sql
+  puts "<h2>Test $cnt: $title</h2>"
+  incr cnt
+  set fd [open $sqlfile r]
+  set sql [string trim [read $fd [file size $sqlfile]]]
+  close $fd
+  set sx [split $sql \n]
+  set n [llength $sx]
+  if {$n>8} {
+    set sql {}
+    for {set i 0} {$i<3} {incr i} {append sql [lindex $sx $i]<br>\n}
+    append sql  "<i>... [expr {$n-6}] lines omitted</i><br>\n"
+    for {set i [expr {$n-3}]} {$i<$n} {incr i} {
+      append sql [lindex $sx $i]<br>\n
+    }
+  } else {
+    regsub -all \n [string trim $sql] <br> sql
+  }
+  puts "<blockquote>"
+  puts "$sql"
+  puts "</blockquote><table border=0 cellpadding=0 cellspacing=0>"
+  set format {<tr><td>%s</td><td align="right">&nbsp;&nbsp;&nbsp;%.3f</td></tr>}
+  set delay 1000
+  exec sync; after $delay;
+  set t [time "exec psql drh <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format PostgreSQL: $t]
+  exec sync; after $delay;
+  set t [time "exec mysql -f drh <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format MySQL: $t]
+#  set t [time "exec ./sqlite232 s232.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.3.2:} $t]
+#  set t [time "exec ./sqlite-100 s100.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.4 (cache=100):} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite240 s2k.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4:} $t]
+  exec sync; after $delay;
+  set t [time "exec ./sqlite240 sns.db <$sqlfile" 1]
+  set t [expr {[lindex $t 0]/1000000.0}]
+  puts [format $format {SQLite 2.4 (nosync):} $t]
+#  set t [time "exec ./sqlite-t1 st1.db <$sqlfile" 1]
+#  set t [expr {[lindex $t 0]/1000000.0}]
+#  puts [format $format {SQLite 2.4 (test):} $t]
+  puts "</table>"
+}
+
+# Initialize the environment
+#
+expr srand(1)
+catch {exec /bin/sh -c {rm -f s*.db}}
+set fd [open clear.sql w]
+puts $fd {
+  drop table t1;
+  drop table t2;
+}
+close $fd
+catch {exec psql drh <clear.sql}
+catch {exec mysql drh <clear.sql}
+set fd [open 2kinit.sql w]
+puts $fd {
+  PRAGMA default_cache_size=2000;
+  PRAGMA default_synchronous=on;
+}
+close $fd
+exec ./sqlite240 s2k.db <2kinit.sql
+exec ./sqlite-t1 st1.db <2kinit.sql
+set fd [open nosync-init.sql w]
+puts $fd {
+  PRAGMA default_cache_size=2000;
+  PRAGMA default_synchronous=off;
+}
+close $fd
+exec ./sqlite240 sns.db <nosync-init.sql
+set ones {zero one two three four five six seven eight nine
+          ten eleven twelve thirteen fourteen fifteen sixteen seventeen
+          eighteen nineteen}
+set tens {{} ten twenty thirty forty fifty sixty seventy eighty ninety}
+proc number_name {n} {
+  if {$n>=1000} {
+    set txt "[number_name [expr {$n/1000}]] thousand"
+    set n [expr {$n%1000}]
+  } else {
+    set txt {}
+  }
+  if {$n>=100} {
+    append txt " [lindex $::ones [expr {$n/100}]] hundred"
+    set n [expr {$n%100}]
+  }
+  if {$n>=20} {
+    append txt " [lindex $::tens [expr {$n/10}]]"
+    set n [expr {$n%10}]
+  }
+  if {$n>0} {
+    append txt " [lindex $::ones $n]"
+  }
+  set txt [string trim $txt]
+  if {$txt==""} {set txt zero}
+  return $txt
+}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+puts $fd "CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100));"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "DELETE FROM t1;"
+close $fd
+runtest {DELETE everything}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "DELETE FROM t1;"
+close $fd
+runtest {DELETE everything}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "DELETE FROM t1;"
+close $fd
+runtest {DELETE everything}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "DELETE FROM t1;"
+close $fd
+runtest {DELETE everything}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "BEGIN;"
+for {set i 1} {$i<=25000} {incr i} {
+  set r [expr {int(rand()*500000)}]
+  puts $fd "INSERT INTO t1 VALUES($i,$r,'[number_name $r]');"
+}
+puts $fd "COMMIT;"
+close $fd
+runtest {25000 INSERTs in a transaction}
+
+
+set fd [open test$cnt.sql w]
+puts $fd "DELETE FROM t1;"
+close $fd
+runtest {DELETE everything}
+
+
+set fd [open test$cnt.sql w]
+puts $fd {DROP TABLE t1;}
+close $fd
+runtest {DROP TABLE}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/34to35.tcl b/client/src/thirdparty/sqlite-3.4.2/www/34to35.tcl
new file mode 100644
index 0000000..cb488e7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/34to35.tcl
@@ -0,0 +1,1006 @@
+#
+# Run this TCL script to generate HTML for the goals.html file.
+#
+set rcsid {$Id: 34to35.tcl,v 1.4 2007/10/01 13:54:11 drh Exp $}
+source common.tcl
+header {SQLite Changes From Version 3.4.2 To 3.5.0}
+
+proc CODE {text} {
+  puts "<blockquote><pre>"
+  puts $text
+  puts "</pre></blockquote>"
+}
+proc SYNTAX {text} {
+  puts "<blockquote><pre>"
+  set t2 [string map {& &amp; < &lt; > &gt;} $text]
+  regsub -all "/(\[^\n/\]+)/" $t2 {</b><i>\1</i><b>} t3
+  puts "<b>$t3</b>"
+  puts "</pre></blockquote>"
+}
+proc IMAGE {name {caption {}}} {
+  puts "<center><img src=\"$name\">"
+  if {$caption!=""} {
+    puts "<br>$caption"
+  }
+  puts "</center>"
+}
+proc PARAGRAPH {text} {
+  # regsub -all "/(\[a-zA-Z0-9\]+)/" $text {<i>\1</i>} t2
+  #regsub -all "\\*(\[^\n*\]+)\\*" $text {<tt><b><big>\1</big></b></tt>} t3
+  regsub -all {\[([^]\n]+)\]} $text {[resolve_link \1]} t3
+  puts "<p>[subst -novar -noback $t3]</p>\n"
+}
+proc resolve_link {args} {
+  set a2 [split $args |]
+  set id [string trim [lindex $a2 0]]
+  if {[lindex $a2 1]==""} {
+    set display [string trim [lindex $a2 0]]
+  } else {
+    set display [string trim [lrange $a2 1 end]]
+  }
+  regsub -all {[^a-zA-Z0-9_]} $id {} id
+  return "<a href=\"capi3ref.html#$id\">$display</a>"
+}
+set level(0) 0
+set level(1) 0
+proc HEADING {n name {tag {}}} {
+  if {$tag!=""} {
+    puts "<a name=\"$tag\">"
+  }
+  global level
+  incr level($n)
+  for {set i [expr {$n+1}]} {$i<10} {incr i} {
+    set level($i) 0
+  }
+  if {$n==0} {
+    set num {}
+  } elseif {$n==1} {
+    set num $level(1).0
+  } else {
+    set num $level(1)
+    for {set i 2} {$i<=$n} {incr i} {
+      append num .$level($i)
+    }
+  }
+  incr n 1
+  puts "<h$n>$num $name</h$n>"
+}
+
+HEADING 0 {Moving From SQLite 3.4.2 to 3.5.0}
+
+PARAGRAPH {
+  SQLite version 3.5.0 introduces a new OS interface layer that
+  is incompatible with all prior versions of SQLite.  In addition,
+  a few existing interfaces have been generalized to work across all
+  database connections within a process rather than just all
+  connections within a thread.  The purpose of this article
+  is to describe the changes to 3.5.0 in detail so that users
+  of prior versions of SQLite can judge what, if any, effort will
+  be required to upgrade to newer versions.
+}
+
+HEADING 1 {Overview Of Changes}
+
+PARAGRAPH {
+  A quick enumeration of the changes in SQLite version 3.5.0
+  is provide here.  Subsequent sections will describe these
+  changes in more detail.
+}
+PARAGRAPH {
+  <ol>
+  <li>The OS interface layer has been completely reworked:
+  <ol type="a">
+  <li>The undocumented <b>sqlite3_os_switch()</b> interface has
+      been removed.</li>
+  <li>The <b>SQLITE_ENABLE_REDEF_IO</b> compile-time flag no longer functions.
+      I/O procedures are now always redefinable.</li>
+  <li>Three new objects are defined for specifying I/O procedures:
+      [sqlite3_vfs], [sqlite3_file], and [sqlite3_io_methods].</li>
+  <li>Three new interfaces are used to create alternative OS interfaces:
+      [sqlite3_vfs_register()], [sqlite3_vfs_unregister()], and
+      [sqlite3_vfs_find()].</li>
+  <li>A new interface has been added to provided additional control over
+      the creation of new database connections: [sqlite3_open_v2()].
+      The legacy interfaces of [sqlite3_open()] and
+      [sqlite3_open16()] continue to be fully supported.</li>
+  </ol></li>
+  <li>The optional shared cache and memory management features that
+      were introduced in version 3.3.0 can now be used across multiple
+      threads within the same process.  Formerly, these extensions only
+      applied to database connections operating within a single thread.
+   <ol type="a">
+   <li>The [sqlite3_enable_shared_cache()] interface now applies to all
+       threads within a process, not to just the one thread in which it
+       was run.</li>
+   <li>The [sqlite3_soft_heap_limit()] interface now applies to all threads
+       within a process, not to just the one thread in which it was run.</li>
+   <li>The [sqlite3_release_memory()] interface will now attempt to reduce
+       the memory usages across all database connections in all threads, not
+       just connections in the thread where the interface is called.</li>
+   <li>The [sqlite3_thread_cleanup()] interface has become a no-op.</li>
+   </ol></li>
+  <li>Restrictions on the use of the same database connection by multiple
+      threads have been dropped.  It is now safe for
+      multiple threads to use the same database connection at the same
+      time.</li>
+  <li>There is now a compile-time option that allows an application to
+      define alternative malloc()/free() implementations without having
+      to modify any core SQLite code.</li>
+  <li>There is now a compile-time option that allows an application to
+      define alternative mutex implementations without having
+      to modify any core SQLite code.</li>
+  </ol>
+}
+PARAGRAPH {
+  Of these changes, only 1a and 2a through 2c are incompatibilities
+  in any formal sense.
+  But users who have previously made custom modifications to the
+  SQLite source (for example to add a custom OS layer for embedded
+  hardware) might find that these changes have a larger impact.
+  On the other hand, an important goal of these changes is to make
+  it much easier to customize SQLite for use on different operating
+  systems. 
+}
+
+HEADING 1 {The OS Interface Layer}
+
+PARAGRAPH {
+  If your system defines a custom OS interface for SQLite or if you
+  were using the undocumented <b>sqlite3_os_switch()</b>
+  interface, then you will need to make modifications in order to
+  upgrade to SQLite version 3.5.0.  This may seem painful at first
+  glance.  But as you look more closely, you will probably discover
+  that your changes are made smaller and easier to understand and manage
+  by the new SQLite interface.  It is likely that your changes will
+  now also work seamlessly with the SQLite amalgamation.  You will
+  no longer need to make any changes to the code SQLite source code.
+  All of your changes can be effected by application code and you can
+  link against a standard, unmodified version of the SQLite amalgamation.
+  Furthermore, the OS interface layer, which was formerly undocumented,
+  is now an officially support interface for SQLite.  So you have
+  some assurance that this will be a one-time change and that your
+  new backend will continue to work in future versions of SQLite.
+}
+
+HEADING 2 {The Virtual File System Object}
+
+PARAGRAPH {
+  The new OS interface for SQLite is built around an object named
+  [sqlite3_vfs].  The "vfs" standard for "Virtual File System".
+  The sqlite3_vfs object is basically a structure containing pointers
+  to functions that implement the primitive disk I/O operations that
+  SQLite needs to perform in order to read and write databases.  
+  In this article, we will often refer a sqlite3_vfs objects as a "VFS".
+}
+
+PARAGRAPH {
+  SQLite is able to use multiple VFSes at the same time.  Each
+  individual database connection is associated with just one VFS.
+  But if you have multiple database connections, each connection
+  can be associated with a different VFS.
+}
+
+PARAGRAPH {
+  There is always a default VFS.
+  The legacy interfaces [sqlite3_open()] and [sqlite3_open16()] always
+  use the default VFS.
+  The new interface for creating database connections,
+  [sqlite3_open_v2()], allows you to specify which VFS you want to
+  use by name.
+}
+
+HEADING 3 {Registering New VFS Objects}
+
+PARAGRAPH {
+  Standard builds of SQLite for unix or windows come with a single
+  VFS named "unix" or "win32", as appropriate.  This one VFS is also 
+  the default.  So if you are using the legacy open functions, everything
+  will continue to operate as it has before.  The change is that an application
+  now has the flexibility of adding new VFS modules to implement a
+  customized OS layer.  The [sqlite3_vfs_register()] API can be used
+  to tell SQLite about one or more application-defined VFS modules:
+}
+
+CODE {
+int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
+}
+
+PARAGRAPH {
+  Applications can call sqlite3_vfs_register at any time, though of course
+  a VFS needs to be registered before it can be used.  The first argument
+  is a pointer to a customized VFS object that the application has prepared.
+  The second argument is true to make the new VFS the default VFS so that
+  it will be used by the legacy [sqlite3_open()] and [sqlite3_open16()] APIs.
+  If the new VFS is not the default, then you will probably have to use
+  the new [sqlite3_open_v2()] API to use it.  Note, however, that if
+  a new VFS is the only VFS known to SQLite (if SQLite was compiled without
+  its usual default VFS or if the pre-compiled default VFS was removed
+  using [sqlite3_vfs_unregister()]) then the new VFS automatic becomes the
+  default VFS regardless of the makeDflt argument to [sqlite3_vfs_register()].
+}
+
+PARAGRAPH {
+  Standard builds include the default "unix" or "win32" VFSes.
+  But if you use the -DOS_OTHER=1 compile-time option, then SQLite is
+  built without a default VFS.  In that case, the application must
+  register at least one VFS prior to calling [sqlite3_open()].
+  This is the approach that embedded applications should use.
+  Rather than modifying the SQLite source to to insert an alternative
+  OS layer as was done in prior releases of SQLite, instead compile
+  an unmodified SQLite source file (preferably the amalgamation)
+  with the -DOS_OTHER=1 option, then invoke [sqlite3_vfs_register()]
+  to define the interface to the underlying filesystem prior to
+  creating any database connections.
+}
+
+HEADING 3 {Additional Control Over VFS Objects}
+
+PARAGRAPH {
+  The [sqlite3_vfs_unregister()] API is used to remove an existing
+  VFS from the system.
+}
+
+CODE {
+int sqlite3_vfs_unregister(sqlite3_vfs*);
+}
+
+PARAGRAPH {
+  The [sqlite3_vfs_find()] API is used to locate a particular VFS
+  by name.  Its prototype is as follows:
+}
+
+CODE {
+sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
+}
+
+PARAGRAPH {
+  The argument is the symbolic name for the desired VFS.  If the
+  argument is a NULL pointer, then the default VFS is returned.
+  The function returns a pointer to the [sqlite3_vfs] object that
+  implements the VFS.  Or it returns a NULL pointer if no object
+  could be found that matched the search criteria.
+}
+
+HEADING 3 {Modifications Of Existing VFSes}
+
+PARAGRAPH {
+  Once a VFS has been registered, it should never be modified.  If
+  a change in behavior is required, a new VFS should be registered.
+  The application could, perhaps, use [sqlite3_vfs_find()] to locate
+  the old VFS, make a copy of the old VFS into a new [sqlite3_vfs]
+  object, make the desired modifications to the new VFS, unregister
+  the old VFS, the register the new VFS in its place.  Existing
+  database connections would continue to use the old VFS even after
+  it is unregistered, but new database connections would use the
+  new VFS.
+}  
+
+HEADING 3 {The VFS Object}
+
+PARAGRAPH {
+  A VFS object is an instance of the following structure:
+}
+
+CODE {
+typedef struct sqlite3_vfs sqlite3_vfs;
+struct sqlite3_vfs {
+  int iVersion;            /* Structure version number */
+  int szOsFile;            /* Size of subclassed sqlite3_file */
+  int mxPathname;          /* Maximum file pathname length */
+  sqlite3_vfs *pNext;      /* Next registered VFS */
+  const char *zName;       /* Name of this virtual file system */
+  void *pAppData;          /* Pointer to application-specific data */
+  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
+               int flags, int *pOutFlags);
+  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
+  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags);
+  int (*xGetTempName)(sqlite3_vfs*, char *zOut);
+  int (*xFullPathname)(sqlite3_vfs*, const char *zName, char *zOut);
+  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
+  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
+  void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
+  void (*xDlClose)(sqlite3_vfs*, void*);
+  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
+  int (*xSleep)(sqlite3_vfs*, int microseconds);
+  int (*xCurrentTime)(sqlite3_vfs*, double*);
+  /* New fields may be appended in figure versions.  The iVersion
+  ** value will increment whenever this happens. */
+};
+}
+
+PARAGRAPH {
+  To create a new VFS, an application fills in an instance of this
+  structure with appropriate values and then calls [sqlite3_vfs_register()].
+}
+
+PARAGRAPH {
+  The iVersion field of [sqlite3_vfs] should be 1 for SQLite version 3.5.0.
+  This number may increase in future versions of SQLite if we have to
+  modify the VFS object in some way.  We hope that this never happens,
+  but the provision is made in case it does.
+}
+
+PARAGRAPH {
+  The szOsFile field is the size in bytes of the structure that defines
+  an open file: the [sqlite3_file] object.  This object will be described
+  more fully below.  The point here is that each VFS implementation can
+  define its own [sqlite3_file] object containing whatever information
+  the VFS implementation needs to store about an open file.  SQLite needs
+  to know how big this object is, however, in order to preallocate enough
+  space to hold it.
+}
+
+PARAGRAPH {
+  The mxPathname field is the maximum length of a file pathname that
+  this VFS can use.  SQLite sometimes has to preallocate buffers of
+  this size, so it should be as small as reasonably possible.  Some
+  filesystems permit huge pathnames, but in practice pathnames rarely
+  extend beyond 100 bytes or so.  You do not have to put the longest
+  pathname that the underlying filesystem can handle here.  You only
+  have to put the longest pathname that you want SQLite to be able to
+  handle.  A few hundred is a good value in most cases.
+}
+
+PARAGRAPH {
+  The pNext field is used internally by SQLite.  Specifically, SQLite
+  uses this field to form a linked list of registered VFSes.
+}
+
+PARAGRAPH {
+  The zName field is the symbolic name of the VFS.  This is the name 
+  that the [sqlite3_vfs_find()] compares against when it is looking for
+  a VFS.
+}
+
+PARAGRAPH {
+  The pAppData pointer is unused by the SQLite core.  The pointer is
+  available to store auxiliary information that a VFS information might
+  want to carry around.
+}
+
+PARAGRAPH {
+  The remaining fields of the [sqlite3_vfs] object all store pointer
+  to functions that implement primitive operations.  We call these
+  "methods".  The first methods, xOpen, is used to open files on
+  the underlying storage media.  The result is an [sqlite3_file]
+  object.  There are additional methods, defined by the [sqlite3_file]
+  object itself that are used to read and write and close the file.
+  The additional methods are detailed below.  The filename is in UTF-8.
+  SQLite will guarantee that the zFilename string passed to
+  xOpen() is a full pathname as generated by xFullPathname() and
+  that the string will be valid and unchanged until xClose() is
+  called.  So the [sqlite3_file] can store a pointer to the
+   filename if it needs to remember the filename for some reason.
+   The flags argument to xOpen() is a copy of the flags argument
+   to sqlite3_open_v2().  If sqlite3_open() or sqlite3_open16()
+   is used, then flags is [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
+   If xOpen() opens a file read-only then it sets *pOutFlags to
+   include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be
+   set.
+   SQLite will also add one of the following flags to the xOpen()
+   call, depending on the object being opened:
+   <ul>
+   <li>  [SQLITE_OPEN_MAIN_DB]
+   <li>  [SQLITE_OPEN_MAIN_JOURNAL]
+   <li>  [SQLITE_OPEN_TEMP_DB]
+   <li>  [SQLITE_OPEN_TEMP_JOURNAL]
+   <li>  [SQLITE_OPEN_TRANSIENT_DB]
+   <li>  [SQLITE_OPEN_SUBJOURNAL]
+   <li>  [SQLITE_OPEN_MASTER_JOURNAL]
+   </ul>
+   The file I/O implementation can use the object type flags to
+   changes the way it deals with files.  For example, an application
+   that does not care about crash recovery or rollback, might make
+   the open of a journal file a no-op.  Writes to this journal are
+   also a no-op.  Any attempt to read the journal returns [SQLITE_IOERR].
+   Or the implementation might recognize the a database file will
+   be doing page-aligned sector reads and writes in a random order
+   and set up its I/O subsystem accordingly.
+   SQLite might also add one of the following flags to the xOpen
+   method:
+   <ul>
+   <li> [SQLITE_OPEN_DELETEONCLOSE]
+   <li> [SQLITE_OPEN_EXCLUSIVE]
+   </ul>
+   The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
+   deleted when it is closed.  This will always be set for TEMP 
+   databases and journals and for subjournals.  The 
+   [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
+   for exclusive access.  This flag is set for all files except
+   for the main database file.
+   The [sqlite3_file] structure passed as the third argument to
+   xOpen is allocated by the caller.  xOpen just fills it in.  The
+   caller allocates a minimum of szOsFile bytes for the [sqlite3_file]
+   structure.
+}
+
+PARAGRAPH {
+  The differences between an [SQLITE_OPEN_TEMP_DB] database and an
+  [SQLITE_OPEN_TRANSIENT_DB] database is this:  The [SQLITE_OPEN_TEMP_DB]
+  is used for explicitly declared and named TEMP tables (using the
+  CREATE TEMP TABLE syntax) or for named tables in a temporary database
+  that is created by opening a database with a filename that is an empty
+  string.  An [SQLITE_OPEN_TRANSIENT_DB] holds an database table that
+  SQLite creates automatically in order to evaluate a subquery or
+  ORDER BY or GROUP BY clause.  Both TEMP_DB and TRANSIENT_DB databases
+  are private and are deleted automatically.  TEMP_DB databases last
+  for the duration of the database connection.  TRANSIENT_DB databases
+  last only for the duration of a single SQL statement.
+}
+
+PARAGRAPH {
+  The xDelete method is used delete a file.  The name of the file is
+  given in the second parameter.  The filename will be in UTF-8.
+  The VFS must convert the filename into whatever character representation
+  the underlying operating system expects.  If the syncDir parameter is
+  true, then the xDelete method should not return until the change
+  to the directory contents for the directory containing the
+  deleted file have been synced to disk in order to insure that the
+  file does not "reappear" if a power failure occurs soon after.
+}
+
+PARAGRAPH {
+  The xAccess method is used to check for access permissions on a file.
+  The filename will be UTF-8 encoded.  The flags argument will be
+  [SQLITE_ACCESS_EXISTS] to check for the existence of the file,
+  [SQLITE_ACCESS_READWRITE] to check to see if the file is both readable
+  and writable, or [SQLITE_ACCESS_READ] to check to see if the file is
+  at least readable.  The "file" named by the second parameter might
+  be a directory or folder name.
+}
+
+PARAGRAPH {
+  The xGetTempName method computes the name of a temporary file that
+  SQLite can use.  The name should be written into the buffer given
+  by the second parameter.  SQLite will size that buffer to hold
+  at least mxPathname bytes.  The generated filename should be in UTF-8.
+  To avoid security problems, the generated temporary filename should
+  contain enough randomness to prevent an attacker from guessing the
+  temporary filename in advance.
+}
+
+PARAGRAPH {
+  The xFullPathname method is used to convert a relative pathname
+  into a full pathname.  The resulting full pathname is written into
+  the buffer provided by the third parameter.  SQLite will size the
+  output buffer to at least mxPathname bytes.  Both the input and
+  output names should be in UTF-8.
+}
+
+PARAGRAPH {
+  The xDlOpen, xDlError, xDlSym, and xDlClose methods are all used for
+  accessing shared libraries at run-time.  These methods may be omitted
+  (and their pointers set to zero) if the library is compiled with
+  SQLITE_OMIT_LOAD_EXTENSION or if the [sqlite3_enable_load_extension()]
+  interface is never used to enable dynamic extension loading.  The
+  xDlOpen method opens a shared library or DLL and returns a pointer to
+  a handle.  NULL is returned if the open fails.  If the open fails,
+  the xDlError method can be used to obtain a text error message.
+  The message is written into the zErrMsg buffer of the third parameter
+  which is at least nByte bytes in length.  The xDlSym returns a pointer
+  to a symbol in the shared library.  The name of the symbol is given
+  by the second parameter.  UTF-8 encoding is assumed.  If the symbol
+  is not found a NULL pointer is returned.  The xDlClose routine closes
+  the shared library.
+}
+
+PARAGRAPH {
+  The xRandomness method is used exactly once to initialize the 
+  pseudo-random number generator (PRNG) inside of SQLite.  Only
+  the xRandomness method on the default VFS is used.  The xRandomness
+  methods on other VFSes are never accessed by SQLite.
+  The xRandomness routine requests that nByte bytes of randomness
+  be written into zOut.  The routine returns the actual number of
+  bytes of randomness obtained.  The quality of the randomness so obtained
+  will determine the quality of the randomness generated by built-in 
+  SQLite functions such as random() and randomblob().  SQLite also
+  uses its PRNG to generate temporary file names..  On some platforms
+  (ex: windows) SQLite assumes that temporary file names are unique
+  without actually testing for collisions, so it is important to have
+  good-quality randomness even if the random() and randomblob() 
+  functions are never used.
+}
+
+PARAGRAPH {
+  The xSleep method is used to suspend the calling thread for at
+  least the number of microseconds given.  This method is used to
+  implement the [sqlite3_sleep()] and [sqlite3_busy_timeout()] APIs.
+  In the case of [sqlite3_sleep()] the xSleep method of the default
+  VFS is always used.  If the underlying system does not have a
+  microsecond resolution sleep capability, then the sleep time should
+  be rounded up.  xSleep returns this rounded-up value.
+}
+
+PARAGRAPH {
+  The xCurrentTime method finds the current time and date and writes
+  the result as double-precision floating point value into pointer
+  provided by the second parameter.  The time and date is in
+  coordinated universal time (UTC) and is a fractional julian day number.
+}
+
+HEADING 3 {The Open File Object}
+
+PARAGRAPH {
+  The result of opening a file is an instance of an [sqlite3_file] object.
+  The [sqlite3_file] object is an abstract base class defined as follows:
+}
+
+CODE {
+typedef struct sqlite3_file sqlite3_file;
+struct sqlite3_file {
+  const struct sqlite3_io_methods *pMethods;
+};
+}
+
+PARAGRAPH {
+  Each VFS implementation will subclass the [sqlite3_file] by adding
+  additional fields at the end to hold whatever information the VFS
+  needs to know about an open file.  It does not matter what information
+  is stored as long as the total size of the structure does not exceed
+  the szOsFile value recorded in the [sqlite3_vfs] object.
+}
+
+PARAGRAPH {
+  The [sqlite3_io_methods] object is a structure that contains pointers
+  to methods for reading, writing, and otherwise dealing with files.
+  This object is defined as follows:
+}
+
+CODE {
+typedef struct sqlite3_io_methods sqlite3_io_methods;
+struct sqlite3_io_methods {
+  int iVersion;
+  int (*xClose)(sqlite3_file*);
+  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
+  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
+  int (*xSync)(sqlite3_file*, int flags);
+  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
+  int (*xLock)(sqlite3_file*, int);
+  int (*xUnlock)(sqlite3_file*, int);
+  int (*xCheckReservedLock)(sqlite3_file*);
+  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
+  int (*xSectorSize)(sqlite3_file*);
+  int (*xDeviceCharacteristics)(sqlite3_file*);
+  /* Additional methods may be added in future releases */
+};
+}
+
+PARAGRAPH {
+  The iVersion field of [sqlite3_io_methods] is provided as insurance
+  against future enhancements.  The iVersion value should always be
+  1 for SQLite version 3.5.
+}
+
+PARAGRAPH {
+  The xClose method closes the file.  The space for the [sqlite3_file]
+  structure is deallocated by the caller.  But if the [sqlite3_file]
+  contains pointers to other allocated memory or resources, those
+  allocations should be released by the xClose method.
+}
+
+PARAGRAPH {
+  The xRead method reads iAmt bytes from the file beginning at a byte
+  offset to iOfst.  The data read is stored in the pointer of the
+  second parameter.  xRead returns the [SQLITE_OK] on success,
+  [SQLITE_IOERR_SHORT_READ] if it was not able to read the full number
+  of bytes because it reached end-of-file, or [SQLITE_IOERR_READ] for
+  any other error.
+}
+
+PARAGRAPH {
+  The xWrite method writes iAmt bytes of data from the second parameter
+  into the file beginning at an offset of iOfst bytes.  If the size of
+  the file is less than iOfst bytes prior to the write, then xWrite should
+  ensure that the file is extended with zeros up to iOfst bytes prior
+  to beginning its write.  xWrite continues to extends the file as
+  necessary so that the size of the file is at least iAmt+iOfst bytes 
+  at the conclusion of the xWrite call.  The xWrite method returns
+  [SQLITE_OK] on success.  If the write cannot complete because the
+  underlying storage medium is full, then [SQLITE_FULL] is returned.
+  [SQLITE_IOERR_WRITE] should be returned for any other error.
+}
+
+PARAGRAPH {
+  The xTruncate method truncates a file to be nByte bytes in length.
+  If the file is already nByte bytes or less in length then this
+  method is a no-op.  The xTruncate method returns [SQLITE_OK] on
+  success and [SQLITE_IOERR_TRUNCATE] if anything goes wrong.
+}
+
+PARAGRAPH {
+  The xSync method is used to force previously written data out of
+  operating system cache and into non-volatile memory.  The second
+  parameter is usually [SQLITE_SYNC_NORMAL].  If the second parameter
+  is [SQLITE_SYNC_FULL] then the xSync method should make sure that
+  data has also been flushed through the disk controllers cache.
+  The [SQLITE_SYNC_FULL] parameter is the equivalent of the F_FULLSYNC
+  ioctl() on Mac OS X. The xSync method returns
+  [SQLITE_OK] on success and [SQLITE_IOERR_FSYNC] if anything goes wrong.
+}
+
+PARAGRAPH {
+  The xFileSize() method determines the current size of the file
+  in bytes and writes that value into *pSize.  It returns [SQLITE_OK]
+  on success and [SQLITE_IOERR_FSTAT] if something goes wrong.
+}
+
+PARAGRAPH {
+  The xLock and xUnlock methods are used to set and clear file locks.
+  SQLite supports five levels of file locks, in order:
+  <ul>
+  <li> [SQLITE_LOCK_NONE]
+  <li> [SQLITE_LOCK_SHARED]
+  <li> [SQLITE_LOCK_RESERVED]
+  <li> [SQLITE_LOCK_PENDING]
+  <li> [SQLITE_LOCK_EXCLUSIVE]
+  </ul>
+  The underlying implementation can support some subset of these locking
+  levels as long as it meets the other requirements of this paragraph.
+  The locking level is specified as the second argument to both xLock
+  and xUnlock.  The xLock method increases the locking level to the
+  specified locking level or higher.  The xUnlock method decreases the
+  locking level to no lower than the level specified.  
+  [SQLITE_LOCK_NONE] means that the file is unlocked.  [SQLITE_LOCK_SHARED]
+  gives permission to read the file.  Multiple database connections can
+  hold [SQLITE_LOCK_SHARED] at the same time.
+  [SQLITE_LOCK_RESERVED] is like [SQLITE_LOCK_SHARED] in that its is permission
+  to read the file.  But only a single connection can hold a reserved lock
+  at any point in time.  The [SQLITE_LOCK_PENDING] is also permission to
+  read the file.  Other connections can continue to read the file as well,
+  but no other connection is allowed to escalate a lock from none to shared.
+  [SQLITE_LOCK_EXCLUSIVE] is permission to write on the file.  Only a single
+  connection can hold an exclusive lock and no other connection can hold
+  any lock (other than "none") while one connection is hold an exclusive
+  lock.  The xLock returns [SQLITE_OK] on success, [SQLITE_BUSY] if it
+  is unable to obtain the lock, or [SQLITE_IOERR_RDLOCK] if something else
+  goes wrong.  The xUnlock method returns [SQLITE_OK] on success and
+  [SQLITE_IOERR_UNLOCK] for problems.
+}
+
+PARAGRAPH {
+  The xCheckReservedLock method checks to see if another connection or
+  another process is currently holding a reserved, pending, or exclusive
+  lock on the file.  It returns true or false.
+}
+
+PARAGRAPH {
+  The xFileControl() method is a generic interface that allows custom
+  VFS implementations to directly control an open file using the
+  (new and experimental)
+  [sqlite3_file_control()] interface.  The second "op" argument
+  is an integer opcode.   The third
+  argument is a generic pointer which is intended to be a pointer
+  to a structure that may contain arguments or space in which to
+  write return values.  Potential uses for xFileControl() might be
+  functions to enable blocking locks with timeouts, to change the
+  locking strategy (for example to use dot-file locks), to inquire
+  about the status of a lock, or to break stale locks.  The SQLite
+  core reserves opcodes less than 100 for its own use. 
+  A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
+  Applications that define a custom xFileControl method should use opcodes 
+  greater than 100 to avoid conflicts.
+}
+
+PARAGRAPH {
+  The xSectorSize returns the "sector size" of the underlying
+  non-volatile media.  A "sector" is defined as the smallest unit of
+  storage that can be written without disturbing adjacent storage.
+  On a disk drive the "sector size" has until recently been 512 bytes,
+  though there is a push to increase this value to 4KiB.  SQLite needs
+  to know the sector size so that it can write a full sector at a
+  time, and thus avoid corrupting adjacent storage space if a power
+  lose occurs in the middle of a write.
+}
+
+PARAGRAPH {
+  The xDeviceCharacteristics method returns an integer bit vector that
+  defines any special properties that the underlying storage medium might
+  have that SQLite can use to increase performance.  The allowed return
+  is the bit-wise OR of the following values:
+  <ul>
+  <li> [SQLITE_IOCAP_ATOMIC]
+  <li> [SQLITE_IOCAP_ATOMIC512]
+  <li> [SQLITE_IOCAP_ATOMIC1K]
+  <li> [SQLITE_IOCAP_ATOMIC2K]
+  <li> [SQLITE_IOCAP_ATOMIC4K]
+  <li> [SQLITE_IOCAP_ATOMIC8K]
+  <li> [SQLITE_IOCAP_ATOMIC16K]
+  <li> [SQLITE_IOCAP_ATOMIC32K]
+  <li> [SQLITE_IOCAP_ATOMIC64K]
+  <li> [SQLITE_IOCAP_SAFE_APPEND]
+  <li> [SQLITE_IOCAP_SEQUENTIAL]
+  </ul>
+  The [SQLITE_IOCAP_ATOMIC] bit means that all writes to this device are
+  atomic in the sense that either the entire write occurs or none of it
+  occurs.  The other 
+  [SQLITE_IOCAP_ATOMIC | SQLITE_IOCAP_ATOMIC<i>nnn</i>] values indicate that
+  writes of aligned blocks of the indicated size are atomic.
+  [SQLITE_IOCAP_SAFE_APPEND] means that when extending a file with new
+  data, the new data is written first and then the file size is updated.
+  So if a power failure occurs, there is no chance that the file might have
+  been extended with randomness.  The [SQLITE_IOCAP_SEQUENTIAL] bit means
+  that all writes occur in the order that they are issued and are not
+  reordered by the underlying file system.
+}
+
+HEADING 3 {Checklist For Constructing A New VFS}
+
+PARAGRAPH {
+  The preceding paragraphs contain a lot of information.
+  To ease the task of constructing
+  a new VFS for SQLite we offer the following implementation checklist:
+}
+
+PARAGRAPH {
+  <ol>
+  <li> Define an appropriate subclass of the [sqlite3_file] object.
+  <li> Implement the methods required by the [sqlite3_io_methods] object.
+  <li> Create a static and 
+       constant [sqlite3_io_methods] object containing pointers
+       to the methods from the previous step.
+  <li> Implement the xOpen method that opens a file and populates an
+       [sqlite3_file] object, including setting pMethods to
+       point to the [sqlite3_io_methods] object from the previous step.
+  <li> Implement the other methods required by [sqlite3_vfs].
+  <li> Define a static (but not constant) [sqlite3_vfs] structure that
+       contains pointers to the xOpen method and the other methods and
+       which contains the appropriate values for iVersion, szOsFile,
+       mxPathname, zName, and pAppData.
+  <li> Implement a procedure that calls [sqlite3_vfs_register()] and
+       passes it a pointer to the [sqlite3_vfs] structure from the previous
+       step.  This procedure is probably the only exported symbol in the
+       source file that implements your VFS.
+  </ol>
+}
+
+PARAGRAPH {
+  Within your application, call the procedure implemented in the last
+  step above as part of your initialization process before any
+  database connections are opened.  
+}
+
+HEADING 1 {The Memory Allocation Subsystem}
+
+PARAGRAPH {
+  Beginning with version 3.5, SQLite obtains all of the heap memory it
+  needs using the routines [sqlite3_malloc()], [sqlite3_free()], and
+  [sqlite3_realloc()].  These routines have existed in prior versions
+  of SQLite, but SQLite has previously bypassed these routines and used
+  its own memory allocator.  This all changes in version 3.5.0.
+}
+
+PARAGRAPH {
+  The SQLite source tree actually contains multiple versions of the
+  memory allocator.  The default high-speed version found in the
+  "mem1.c" source file is used for most builds.  But if the SQLITE_MEMDEBUG
+  flag is enabled, a separate memory allocator the "mem2.c" source file
+  is used instead.  The mem2.c allocator implements lots of hooks to
+  do error checking and to simulate memory allocation failures for testing
+  purposes.  Both of these allocators use the malloc()/free() implementation
+  in the standard C library.
+}
+
+PARAGRAPH {
+  Applications are not required to use either of these standard memory
+  allocators.  If SQLite is compiled with SQLITE_OMIT_MEMORY_ALLOCATION
+  then no implementation for the [sqlite3_malloc()], [sqlite3_realloc()],
+  and [sqlite3_free()] functions is provided.  Instead, the application
+  that links against SQLite must provide its own implementation of these
+  functions.  The application provided memory allocator is not required
+  to use the malloc()/free() implementation in the standard C library.
+  An embedded application might provide an alternative memory allocator
+  that uses memory for a fixed memory pool set aside for the exclusive
+  use of SQLite, for example.
+}
+
+PARAGRAPH {
+  Applications that implement their own memory allocator must provide
+  implementation for the usual three allocation functions 
+  [sqlite3_malloc()], [sqlite3_realloc()], and [sqlite3_free()].
+  And they must also implement a fourth function:
+}
+
+CODE {
+int sqlite3_memory_alarm(
+  void(*xCallback)(void *pArg, sqlite3_int64 used, int N),
+  void *pArg,
+  sqlite3_int64 iThreshold
+);
+}
+
+PARAGRAPH {
+ The [sqlite3_memory_alarm] routine is used to register
+ a callback on memory allocation events.
+ This routine registers or clears a callbacks that fires when
+ the amount of memory allocated exceeds iThreshold.  Only
+ a single callback can be registered at a time.  Each call
+ to [sqlite3_memory_alarm()] overwrites the previous callback.
+ The callback is disabled by setting xCallback to a NULL
+ pointer.
+}
+
+PARAGRAPH {
+ The parameters to the callback are the pArg value, the 
+ amount of memory currently in use, and the size of the
+ allocation that provoked the callback.  The callback will
+ presumably invoke [sqlite3_free()] to free up memory space.
+ The callback may invoke [sqlite3_malloc()] or [sqlite3_realloc()]
+ but if it does, no additional callbacks will be invoked by
+ the recursive calls.
+}
+
+PARAGRAPH {
+ The [sqlite3_soft_heap_limit()] interface works by registering
+ a memory alarm at the soft heap limit and invoking 
+ [sqlite3_release_memory()] in the alarm callback.  Application
+ programs should not attempt to use the [sqlite3_memory_alarm()]
+ interface because doing so will interfere with the
+ [sqlite3_soft_heap_limit()] module.  This interface is exposed
+ only so that applications can provide their own
+ alternative implementation when the SQLite core is
+ compiled with SQLITE_OMIT_MEMORY_ALLOCATION.
+}
+
+PARAGRAPH {
+  The built-in memory allocators in SQLite also provide the following
+  additional interfaces:
+}
+
+CODE {
+sqlite3_int64 sqlite3_memory_used(void);
+sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
+}
+
+PARAGRAPH {
+  These interfaces can be used by an application to monitor how
+  much memory SQLite is using.  The [sqlite3_memory_used()] routine
+  returns the number of bytes of memory currently in use and the
+  [sqlite3_memory_highwater()] returns the maximum instantaneous
+  memory usage.  Neither routine includes the overhead associated
+  with the memory allocator.  These routines are provided for use
+  by the application.  SQLite never invokes them itself.  So if
+  the application is providing its own memory allocation subsystem,
+  it can omit these interfaces if desired.
+}
+
+HEADING 1 {The Mutex Subsystem}
+
+PARAGRAPH {
+  SQLite has always been threadsafe in the sense that it is safe to
+  use different SQLite database connections in different threads at the
+  same time.  The constraint was that the same database connection
+  could not be used in two separate threads at once.  SQLite version 3.5.0
+  relaxes this constraint. 
+}
+
+PARAGRAPH {
+  In order to allow multiple threads to use the same database connection
+  at the same time, SQLite must make extensive use of mutexes.  And for
+  this reason a new mutex subsystem as been added.  The mutex subsystem
+  as the following interface:
+}
+
+CODE {
+sqlite3_mutex *sqlite3_mutex_alloc(int);
+void sqlite3_mutex_free(sqlite3_mutex*);
+void sqlite3_mutex_enter(sqlite3_mutex*);
+int sqlite3_mutex_try(sqlite3_mutex*);
+void sqlite3_mutex_leave(sqlite3_mutex*);
+}
+
+PARAGRAPH {
+  Though these routines exist for the use of the SQLite core, 
+  application code is free to use these routines as well, if desired.
+  A mutex is an [sqlite3_mutex] object.  The [sqlite3_mutex_alloc()]
+  routine allocates a new mutex object and returns a pointer to it.
+  The argument to [sqlite3_mutex_alloc()] should be 
+  [SQLITE_MUTEX_FAST] or [SQLITE_MUTEX_RECURSIVE] for non-recursive
+  and recursive mutexes, respectively.  If the underlying system does
+  not provide non-recursive mutexes, then a recursive mutex can be
+  substituted in that case.  The argument to [sqlite3_mutex_alloc()]
+  can also be a constant designating one of several static mutexes:
+  <ul>
+  <li>  [SQLITE_MUTEX_STATIC_MASTER]
+  <li>  [SQLITE_MUTEX_STATIC_MEM]
+  <li>  [SQLITE_MUTEX_STATIC_MEM2]
+  <li>  [SQLITE_MUTEX_STATIC_PRNG]
+  <li>  [SQLITE_MUTEX_STATIC_LRU]
+  </ul>
+  These static mutexes are reserved for use internally by SQLite
+  and should not be used by the application.  The static mutexes
+  are all non-recursive.
+}
+
+PARAGRAPH {
+  The [sqlite3_mutex_free()] routine should be used to deallocate
+  a non-static mutex.  If a static mutex is passed to this routine
+  then the behavior is undefined.
+}
+
+PARAGRAPH {
+  The [sqlite3_mutex_enter()] attempts to enter the mutex and blocks
+  if another threads is already there.  [sqlite3_mutex_try()] attempts
+  to enter and returns [SQLITE_OK] on success or [SQLITE_BUSY] if another
+  thread is already there.  [sqlite3_mutex_leave()] exits a mutex.
+  The mutex is held until the number of exits matches the number of
+  entrances.  If [sqlite3_mutex_leave()] is called on a mutex that 
+  the thread is not currently holding, then the behavior is undefined.
+  If any routine is called for a deallocated mutex, then the behavior
+  is undefined.
+}
+
+PARAGRAPH {
+  The SQLite source code provides multiple implementations of these
+  APIs, suitable for varying environments.  If SQLite is compiled with
+  the SQLITE_THREADSAFE=0 flag then a no-op mutex implementation that 
+  is fast but does no real mutual exclusion is provided.  That 
+  implementation is suitable for use in single-threaded applications
+  or applications that only use SQLite in a single thread.  Other
+  real mutex implementations are provided based on the underlying
+  operating system.
+}
+
+PARAGRAPH {
+  Embedded applications may wish to provide their own mutex implementation.
+  If SQLite is compiled with the -DSQLITE_MUTEX_APPDEF=1 compile-time flag
+  then the SQLite core provides no mutex subsystem and a mutex subsystem
+  that matches the interface described above must be provided by the
+  application that links against SQLite.
+}
+
+HEADING 1 {Other Interface Changes}
+
+PARAGRAPH {
+  Version 3.5.0 of SQLite changes the behavior of a few APIs in ways
+  that are technically incompatible.  However, these APIs are seldom
+  used and even when they are used it is difficult to imagine a
+  scenario where the change might break something.  The changes
+  actually makes these interface much more useful and powerful.
+}
+
+PARAGRAPH {
+  Prior to version 3.5.0, the [sqlite3_enable_shared_cache()] API
+  would enable and disable the shared cache feature for all connections
+  within a single thread - the same thread from which the 
+  sqlite3_enable_shared_cache() routine was called.  Database connections
+  that used the shared cache were restricted to running in the same
+  thread in which they were opened.  Beginning with version 3.5.0,
+  the sqlite3_enable_shared_cache() applies to all database connections
+  in all threads within the process.  Now database connections running
+  in separate threads can share a cache.  And database connections that
+  use shared cache can migrate from one thread to another.
+}
+
+PARAGRAPH {
+  Prior to version 3.5.0 the [sqlite3_soft_heap_limit()] set an upper
+  bound on heap memory usage for all database connections within a
+  single thread.  Each thread could have its own heap limit.  Beginning
+  in version 3.5.0, there is a single heap limit for the entire process.
+  This seems more restrictive (one limit as opposed to many) but in
+  practice it is what most users want.
+}
+
+PARAGRAPH {
+  Prior to version 3.5.0 the [sqlite3_release_memory()] function would
+  try to reclaim memory from all database connections in the same thread
+  as the sqlite3_release_memory() call.  Beginning with version 3.5.0,
+  the sqlite3_release_memory() function will attempt to reclaim memory
+  from all database connections in all threads.
+}
+
+HEADING 1 {Summary}
+
+PARAGRAPH {
+  The transition from SQLite version 3.4.2 to 3.5.0 is a major change.
+  Every source code file in the SQLite core had to be modified, some
+  extensively.  And the change introduced some minor incompatibilities
+  in the C interface.  But we feel that the benefits of the transition
+  from 3.4.2 to 3.5.0 far outweigh the pain of porting.  The new
+  VFS layer is now well-defined and stable and should simplify future
+  customizations.  The VFS layer, and the separable memory allocator
+  and mutex subsystems allow a standard SQLite source code amalgamation
+  to be used in an embedded project without change, greatly simplifying
+  configuration management.  And the resulting system is much more
+  tolerant of highly threaded designs.
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch.fig b/client/src/thirdparty/sqlite-3.4.2/www/arch.fig
new file mode 100644
index 0000000..d127a27
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch.fig
@@ -0,0 +1,64 @@
+#FIG 3.2
+Portrait
+Center
+Inches
+Letter  
+100.00
+Single
+-2
+1200 2
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 8550 3675 9075
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 7200 3675 7725
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 5775 3675 6300
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 3975 3675 4500
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 2625 3675 3150
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 1275 3675 1800
+2 1 0 3 0 7 100 0 -1 0.000 0 0 -1 1 0 2
+	1 1 3.00 75.00 135.00
+	 3675 9900 3675 10425
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 10425 4875 10425 4875 11250 2550 11250 2550 10425
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 9075 4875 9075 4875 9900 2550 9900 2550 9075
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 7725 4875 7725 4875 8550 2550 8550 2550 7725
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 6300 4875 6300 4875 7200 2550 7200 2550 6300
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 4500 4875 4500 4875 5775 2550 5775 2550 4500
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 3150 4875 3150 4875 3975 2550 3975 2550 3150
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 1800 4875 1800 4875 2625 2550 2625 2550 1800
+2 2 0 1 0 11 100 0 20 0.000 0 0 7 0 0 5
+	 2550 450 4875 450 4875 1275 2550 1275 2550 450
+4 1 0 100 0 0 20 0.0000 4 195 1020 3675 750 Interface\001
+4 1 0 100 0 0 14 0.0000 4 195 2040 3675 1125 main.c table.c tclsqlite.c\001
+4 1 0 100 0 0 20 0.0000 4 195 1920 3675 6675 Virtual Machine\001
+4 1 0 100 0 0 14 0.0000 4 150 570 3675 7050 vdbe.c\001
+4 1 0 100 0 0 20 0.0000 4 195 1830 3675 4875 Code Generator\001
+4 1 0 100 0 0 14 0.0000 4 195 1860 3675 5175 build.c delete.c expr.c\001
+4 1 0 100 0 0 14 0.0000 4 195 2115 3675 5400 insert.c select.c update.c\001
+4 1 0 100 0 0 14 0.0000 4 150 705 3675 5625 where.c\001
+4 1 0 100 0 0 20 0.0000 4 195 735 3675 3450 Parser\001
+4 1 0 100 0 0 20 0.0000 4 195 1140 3675 2100 Tokenizer\001
+4 1 0 100 0 0 14 0.0000 4 150 870 3675 2475 tokenize.c\001
+4 1 0 100 0 0 20 0.0000 4 255 1350 3675 9375 Page Cache\001
+4 1 0 100 0 0 14 0.0000 4 150 630 3675 3825 parse.y\001
+4 1 0 100 0 0 14 0.0000 4 150 600 3675 8400 btree.c\001
+4 1 0 100 0 0 14 0.0000 4 150 645 3675 9750 pager.c\001
+4 1 0 100 0 0 20 0.0000 4 195 1620 3675 8025 B-tree Driver\001
+4 1 0 100 0 0 14 0.0000 4 105 345 3675 11100 os.c\001
+4 1 0 100 0 0 20 0.0000 4 195 1470 3675 10725 OS Interface\001
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch.gif b/client/src/thirdparty/sqlite-3.4.2/www/arch.gif
new file mode 100644
index 0000000..43fdf54
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffe4e7bd17f07c96f8c5ac0d30799dacfd504e44121aef09e36848b4def151e6
+size 6487
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch.png b/client/src/thirdparty/sqlite-3.4.2/www/arch.png
new file mode 100644
index 0000000..8d7e509
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95054076662b1751158dd4d539f3d9f5cb86f7cd7d9f5ee5e9c2aac069565382
+size 4447
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch.tcl b/client/src/thirdparty/sqlite-3.4.2/www/arch.tcl
new file mode 100644
index 0000000..d6c8166
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch.tcl
@@ -0,0 +1,221 @@
+#
+# Run this Tcl script to generate the sqlite.html file.
+#
+set rcsid {$Id: arch.tcl,v 1.16 2004/10/10 17:24:54 drh Exp $}
+source common.tcl
+header {Architecture of SQLite}
+puts {
+<h2>The Architecture Of SQLite</h2>
+
+<h3>Introduction</h3>
+
+<table align="right" border="1" cellpadding="15" cellspacing="1">
+<tr><th>Block Diagram Of SQLite</th></tr>
+<tr><td><img src="arch2.gif"></td></tr>
+</table>
+<p>This document describes the architecture of the SQLite library.
+The information here is useful to those who want to understand or
+modify the inner workings of SQLite.
+</p>
+
+<p>
+A block diagram showing the main components of SQLite
+and how they interrelate is shown at the right.  The text that
+follows will provide a quick overview of each of these components.
+</p>
+
+
+<p>
+This document describes SQLite version 3.0.  Version 2.8 and
+earlier are similar but the details differ.
+</p>
+
+<h3>Interface</h3>
+
+<p>Much of the public interface to the SQLite library is implemented by
+functions found in the <b>main.c</b>, <b>legacy.c</b>, and
+<b>vdbeapi.c</b> source files
+though some routines are
+scattered about in other files where they can have access to data 
+structures with file scope.  The
+<b>sqlite3_get_table()</b> routine is implemented in <b>table.c</b>.
+<b>sqlite3_mprintf()</b> is found in <b>printf.c</b>.
+<b>sqlite3_complete()</b> is in <b>tokenize.c</b>.
+The Tcl interface is implemented by <b>tclsqlite.c</b>.  More
+information on the C interface to SQLite is
+<a href="capi3ref.html">available separately</a>.<p>
+
+<p>To avoid name collisions with other software, all external
+symbols in the SQLite library begin with the prefix <b>sqlite3</b>.
+Those symbols that are intended for external use (in other words,
+those symbols which form the API for SQLite) begin
+with <b>sqlite3_</b>.</p>
+
+<h3>Tokenizer</h3>
+
+<p>When a string containing SQL statements is to be executed, the
+interface passes that string to the tokenizer.  The job of the tokenizer
+is to break the original string up into tokens and pass those tokens
+one by one to the parser.  The tokenizer is hand-coded in C in 
+the file <b>tokenize.c</b>.
+
+<p>Note that in this design, the tokenizer calls the parser.  People
+who are familiar with YACC and BISON may be used to doing things the
+other way around -- having the parser call the tokenizer.  The author
+of SQLite 
+has done it both ways and finds things generally work out nicer for
+the tokenizer to call the parser.  YACC has it backwards.</p>
+
+<h3>Parser</h3>
+
+<p>The parser is the piece that assigns meaning to tokens based on
+their context.  The parser for SQLite is generated using the
+<a href="http://www.hwaci.com/sw/lemon/">Lemon</a> LALR(1) parser
+generator.  Lemon does the same job as YACC/BISON, but it uses
+a different input syntax which is less error-prone.
+Lemon also generates a parser which is reentrant and thread-safe.
+And lemon defines the concept of a non-terminal destructor so
+that it does not leak memory when syntax errors are encountered.
+The source file that drives Lemon is found in <b>parse.y</b>.</p>
+
+<p>Because
+lemon is a program not normally found on development machines, the
+complete source code to lemon (just one C file) is included in the
+SQLite distribution in the "tool" subdirectory.  Documentation on
+lemon is found in the "doc" subdirectory of the distribution.
+</p>
+
+<h3>Code Generator</h3>
+
+<p>After the parser assembles tokens into complete SQL statements,
+it calls the code generator to produce virtual machine code that
+will do the work that the SQL statements request.  There are many
+files in the code generator:
+<b>attach.c</b>,
+<b>auth.c</b>,
+<b>build.c</b>,
+<b>delete.c</b>,
+<b>expr.c</b>,
+<b>insert.c</b>,
+<b>pragma.c</b>,
+<b>select.c</b>,
+<b>trigger.c</b>,
+<b>update.c</b>,
+<b>vacuum.c</b>
+and <b>where.c</b>.
+In these files is where most of the serious magic happens.
+<b>expr.c</b> handles code generation for expressions.
+<b>where.c</b> handles code generation for WHERE clauses on
+SELECT, UPDATE and DELETE statements.  The files <b>attach.c</b>,
+<b>delete.c</b>, <b>insert.c</b>, <b>select.c</b>, <b>trigger.c</b>
+<b>update.c</b>, and <b>vacuum.c</b> handle the code generation
+for SQL statements with the same names.  (Each of these files calls routines
+in <b>expr.c</b> and <b>where.c</b> as necessary.)  All other
+SQL statements are coded out of <b>build.c</b>.
+The <b>auth.c</b> file implements the functionality of
+<b>sqlite3_set_authorizer()</b>.</p>
+
+<h3>Virtual Machine</h3>
+
+<p>The program generated by the code generator is executed by
+the virtual machine.  Additional information about the virtual
+machine is <a href="opcode.html">available separately</a>.
+To summarize, the virtual machine implements an abstract computing
+engine specifically designed to manipulate database files.  The
+machine has a stack which is used for intermediate storage.
+Each instruction contains an opcode and
+up to three additional operands.</p>
+
+<p>The virtual machine itself is entirely contained in a single
+source file <b>vdbe.c</b>.  The virtual machine also has
+its own header files: <b>vdbe.h</b> that defines an interface
+between the virtual machine and the rest of the SQLite library and
+<b>vdbeInt.h</b> which defines structure private the virtual machine.
+The <b>vdbeaux.c</b> file contains utilities used by the virtual
+machine and interface modules used by the rest of the library to
+construct VM programs.  The <b>vdbeapi.c</b> file contains external
+interfaces to the virtual machine such as the 
+<b>sqlite3_bind_...</b> family of functions.  Individual values
+(strings, integer, floating point numbers, and BLOBs) are stored
+in an internal object named "Mem" which is implemented by
+<b>vdbemem.c</b>.</p>
+
+<p>
+SQLite implements SQL functions using callbacks to C-language routines.
+Even the built-in SQL functions are implemented this way.  Most of
+the built-in SQL functions (ex: <b>coalesce()</b>, <b>count()</b>,
+<b>substr()</b>, and so forth) can be found in <b>func.c</b>.
+Date and time conversion functions are found in <b>date.c</b>.
+</p>
+
+<h3>B-Tree</h3>
+
+<p>An SQLite database is maintained on disk using a B-tree implementation
+found in the <b>btree.c</b> source file.  A separate B-tree is used for
+each table and index in the database.  All B-trees are stored in the
+same disk file.  Details of the file format are recorded in a large
+comment at the beginning of <b>btree.c</b>.</p>
+
+<p>The interface to the B-tree subsystem is defined by the header file
+<b>btree.h</b>.
+</p>
+
+<h3>Page Cache</h3>
+
+<p>The B-tree module requests information from the disk in fixed-size
+chunks.  The default chunk size is 1024 bytes but can vary between 512
+and 65536 bytes.
+The page cache is responsible for reading, writing, and
+caching these chunks.
+The page cache also provides the rollback and atomic commit abstraction
+and takes care of locking of the database file.  The
+B-tree driver requests particular pages from the page cache and notifies
+the page cache when it wants to modify pages or commit or rollback
+changes and the page cache handles all the messy details of making sure
+the requests are handled quickly, safely, and efficiently.</p>
+
+<p>The code to implement the page cache is contained in the single C
+source file <b>pager.c</b>.  The interface to the page cache subsystem
+is defined by the header file <b>pager.h</b>.
+</p>
+
+<h3>OS Interface</h3>
+
+<p>
+In order to provide portability between POSIX and Win32 operating systems,
+SQLite uses an abstraction layer to interface with the operating system.
+The interface to the OS abstraction layer is defined in
+<b>os.h</b>.  Each supported operating system has its own implementation:
+<b>os_unix.c</b> for Unix, <b>os_win.c</b> for windows, and so forth.
+Each of these operating-specific implements typically has its own
+header file: <b>os_unix.h</b>, <b>os_win.h</b>, etc.
+</p>
+
+<h3>Utilities</h3>
+
+<p>
+Memory allocation and caseless string comparison routines are located
+in <b>util.c</b>.
+Symbol tables used by the parser are maintained by hash tables found
+in <b>hash.c</b>.  The <b>utf.c</b> source file contains Unicode
+conversion subroutines.
+SQLite has its own private implementation of <b>printf()</b> (with
+some extensions) in <b>printf.c</b> and its own random number generator
+in <b>random.c</b>.
+</p>
+
+<h3>Test Code</h3>
+
+<p>
+If you count regression test scripts,
+more than half the total code base of SQLite is devoted to testing.
+There are many <b>assert()</b> statements in the main code files.
+In additional, the source files <b>test1.c</b> through <b>test5.c</b>
+together with <b>md5.c</b> implement extensions used for testing
+purposes only.  The <b>os_test.c</b> backend interface is used to
+simulate power failures to verify the crash-recovery mechanism in
+the pager.
+</p>
+
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch2.fig b/client/src/thirdparty/sqlite-3.4.2/www/arch2.fig
new file mode 100644
index 0000000..70bc5f1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch2.fig
@@ -0,0 +1,123 @@
+#FIG 3.2
+Landscape
+Center
+Inches
+Letter  
+100.00
+Single
+-2
+1200 2
+0 32 #000000
+0 33 #868686
+0 34 #dfefd7
+0 35 #d7efef
+0 36 #efdbef
+0 37 #efdbd7
+0 38 #e7efcf
+0 39 #9e9e9e
+6 3225 3900 4650 6000
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 5475 4575 5475 4575 5925 3225 5925 3225 5475
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 5550 4650 5550 4650 6000 3300 6000 3300 5550
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 4650 4575 4650 4575 5100 3225 5100 3225 4650
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 4725 4650 4725 4650 5175 3300 5175 3300 4725
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 3900 4575 3900 4575 4350 3225 4350 3225 3900
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 3975 4650 3975 4650 4425 3300 4425 3300 3975
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 4350 3900 4650
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 5100 3900 5475
+4 1 0 50 0 2 12 0.0000 4 135 1050 3900 5775 OS Interface\001
+4 1 0 50 0 2 12 0.0000 4 135 615 3900 4200 B-Tree\001
+4 1 0 50 0 2 12 0.0000 4 180 495 3900 4950 Pager\001
+-6
+6 5400 4725 6825 5250
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 4725 6750 4725 6750 5175 5400 5175 5400 4725
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 4800 6825 4800 6825 5250 5475 5250 5475 4800
+4 1 0 50 0 2 12 0.0000 4 135 630 6000 5025 Utilities\001
+-6
+6 5400 5550 6825 6075
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 5550 6750 5550 6750 6000 5400 6000 5400 5550
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 5625 6825 5625 6825 6075 5475 6075 5475 5625
+4 1 0 50 0 2 12 0.0000 4 135 855 6000 5850 Test Code\001
+-6
+6 5400 2775 6825 3750
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 2850 6825 2850 6825 3750 5475 3750 5475 2850
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 2775 6750 2775 6750 3675 5400 3675 5400 2775
+4 1 0 50 0 2 12 0.0000 4 135 420 6075 3150 Code\001
+4 1 0 50 0 2 12 0.0000 4 135 855 6075 3375 Generator\001
+-6
+6 5400 1950 6825 2475
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 1950 6750 1950 6750 2400 5400 2400 5400 1950
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 2025 6825 2025 6825 2475 5475 2475 5475 2025
+4 1 0 50 0 2 12 0.0000 4 135 570 6075 2250 Parser\001
+-6
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 1050 6750 1050 6750 1500 5400 1500 5400 1050
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 1125 6825 1125 6825 1575 5475 1575 5475 1125
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 1050 4575 1050 4575 1500 3225 1500 3225 1050
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 1125 4650 1125 4650 1575 3300 1575 3300 1125
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 1800 4575 1800 4575 2250 3225 2250 3225 1800
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 1875 4650 1875 4650 2325 3300 2325 3300 1875
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 2550 4575 2550 4575 3000 3225 3000 3225 2550
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 2625 4650 2625 4650 3075 3300 3075 3300 2625
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 1500 3900 1800
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 2250 3900 2550
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 3000 3900 3900
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 4575 1950 5400 1350
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 5400 2925 4650 2325
+2 2 0 1 0 34 55 0 20 0.000 0 0 -1 0 0 5
+	 2850 750 4875 750 4875 3375 2850 3375 2850 750
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 6075 1500 6075 1950
+2 3 0 1 0 35 55 0 20 0.000 0 0 -1 0 0 5
+	 2850 3675 4875 3675 4875 6225 2850 6225 2850 3675
+2 2 0 1 0 37 55 0 20 0.000 0 0 -1 0 0 5
+	 5175 750 7200 750 7200 4050 5175 4050 5175 750
+2 2 0 1 0 38 55 0 20 0.000 0 0 -1 0 0 5
+	 5175 4425 7200 4425 7200 6225 5175 6225 5175 4425
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 6075 2475 6075 2775
+4 1 0 50 0 2 12 0.0000 4 135 855 6075 1350 Tokenizer\001
+4 1 0 50 0 1 12 1.5708 4 180 1020 7125 2250 SQL Compiler\001
+4 1 0 50 0 1 12 1.5708 4 135 345 3075 2025 Core\001
+4 1 0 50 0 2 12 0.0000 4 135 1290 3900 2850 Virtual Machine\001
+4 1 0 50 0 2 12 0.0000 4 165 1185 3900 1995 SQL Command\001
+4 1 0 50 0 2 12 0.0000 4 135 855 3900 2183 Processor\001
+4 1 0 50 0 2 14 0.0000 4 150 870 3900 1350 Interface\001
+4 1 0 50 0 1 12 1.5708 4 135 885 7125 5400 Accessories\001
+4 1 0 50 0 1 12 1.5708 4 135 645 3075 4875 Backend\001
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch2.gif b/client/src/thirdparty/sqlite-3.4.2/www/arch2.gif
new file mode 100644
index 0000000..229046f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch2.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de31efa80cf51dd101a850d198193bfd12820b61db5a7662808939ddef96e1ca
+size 6501
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/arch2b.fig b/client/src/thirdparty/sqlite-3.4.2/www/arch2b.fig
new file mode 100644
index 0000000..e8ba8cc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/arch2b.fig
@@ -0,0 +1,125 @@
+#FIG 3.2
+Landscape
+Center
+Inches
+Letter  
+100.00
+Single
+-2
+1200 2
+0 32 #000000
+0 33 #868686
+0 34 #dfefd7
+0 35 #d7efef
+0 36 #efdbef
+0 37 #efdbd7
+0 38 #e7efcf
+0 39 #9e9e9e
+6 3225 3900 4650 6000
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 5475 4575 5475 4575 5925 3225 5925 3225 5475
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 5550 4650 5550 4650 6000 3300 6000 3300 5550
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 4650 4575 4650 4575 5100 3225 5100 3225 4650
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 4725 4650 4725 4650 5175 3300 5175 3300 4725
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 3900 4575 3900 4575 4350 3225 4350 3225 3900
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 3975 4650 3975 4650 4425 3300 4425 3300 3975
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 4350 3900 4650
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 5100 3900 5475
+4 1 0 50 0 2 12 0.0000 4 135 1050 3900 5775 OS Interface\001
+4 1 0 50 0 2 12 0.0000 4 135 615 3900 4200 B-Tree\001
+4 1 0 50 0 2 12 0.0000 4 180 495 3900 4950 Pager\001
+-6
+6 5175 4275 7200 6150
+6 5400 4519 6825 5090
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 4519 6750 4519 6750 5009 5400 5009 5400 4519
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 4601 6825 4601 6825 5090 5475 5090 5475 4601
+4 1 0 50 0 2 12 0.0000 4 135 630 6000 4845 Utilities\001
+-6
+6 5400 5416 6825 5987
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 5416 6750 5416 6750 5906 5400 5906 5400 5416
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 5498 6825 5498 6825 5987 5475 5987 5475 5498
+4 1 0 50 0 2 12 0.0000 4 135 855 6000 5742 Test Code\001
+-6
+2 2 0 1 0 38 55 0 20 0.000 0 0 -1 0 0 5
+	 5175 4275 7200 4275 7200 6150 5175 6150 5175 4275
+4 1 0 50 0 1 12 1.5708 4 135 885 7125 5253 Accessories\001
+-6
+6 5400 2700 6825 3675
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 2775 6825 2775 6825 3675 5475 3675 5475 2775
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 2700 6750 2700 6750 3600 5400 3600 5400 2700
+4 1 0 50 0 2 12 0.0000 4 135 420 6075 3075 Code\001
+4 1 0 50 0 2 12 0.0000 4 135 855 6075 3300 Generator\001
+-6
+6 5400 1875 6825 2400
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 1875 6750 1875 6750 2325 5400 2325 5400 1875
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 1950 6825 1950 6825 2400 5475 2400 5475 1950
+4 1 0 50 0 2 12 0.0000 4 135 570 6075 2175 Parser\001
+-6
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 5400 1050 6750 1050 6750 1500 5400 1500 5400 1050
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 5475 1125 6825 1125 6825 1575 5475 1575 5475 1125
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 1050 4575 1050 4575 1500 3225 1500 3225 1050
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 1125 4650 1125 4650 1575 3300 1575 3300 1125
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 1800 4575 1800 4575 2250 3225 2250 3225 1800
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 1875 4650 1875 4650 2325 3300 2325 3300 1875
+2 2 0 1 0 7 51 0 20 0.000 0 0 -1 0 0 5
+	 3225 2550 4575 2550 4575 3000 3225 3000 3225 2550
+2 2 0 0 0 33 52 0 20 0.000 0 0 -1 0 0 5
+	 3300 2625 4650 2625 4650 3075 3300 3075 3300 2625
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 1500 3900 1800
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 2250 3900 2550
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 3900 3000 3900 3900
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 4575 1950 5400 1350
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 5400 2925 4650 2175
+2 2 0 1 0 34 55 0 20 0.000 0 0 -1 0 0 5
+	 2850 750 4875 750 4875 3375 2850 3375 2850 750
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 6075 1500 6075 1800
+2 3 0 1 0 35 55 0 20 0.000 0 0 -1 0 0 5
+	 2850 3675 4875 3675 4875 6150 2850 6150 2850 3675
+2 2 0 1 0 37 55 0 20 0.000 0 0 -1 0 0 5
+	 5175 750 7200 750 7200 3975 5175 3975 5175 750
+2 1 0 1 0 38 50 0 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 60.00 120.00
+	 6075 2400 6075 2700
+4 1 0 50 0 2 12 0.0000 4 135 855 6075 1350 Tokenizer\001
+4 1 0 50 0 1 12 1.5708 4 180 1020 7125 2250 SQL Compiler\001
+4 1 0 50 0 1 12 1.5708 4 135 345 3075 2025 Core\001
+4 1 0 50 0 2 12 0.0000 4 135 1290 3900 2850 Virtual Machine\001
+4 1 0 50 0 2 12 0.0000 4 165 1185 3900 1995 SQL Command\001
+4 1 0 50 0 2 12 0.0000 4 135 855 3900 2183 Processor\001
+4 1 0 50 0 2 14 0.0000 4 150 870 3900 1350 Interface\001
+4 1 0 50 0 1 12 1.5708 4 135 645 3075 4875 Backend\001
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/audit.tcl b/client/src/thirdparty/sqlite-3.4.2/www/audit.tcl
new file mode 100644
index 0000000..8b30373
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/audit.tcl
@@ -0,0 +1,214 @@
+#
+# Run this Tcl script to generate the audit.html file.
+#
+set rcsid {$Id: audit.tcl,v 1.1 2002/07/13 16:52:35 drh Exp $}
+
+puts {<html>
+<head>
+  <title>SQLite Security Audit Procedure</title>
+</head>
+<body bgcolor=white>
+<h1 align=center>
+SQLite Security Audit Procedure
+</h1>}
+puts "<p align=center>
+(This page was last modified on [lrange $rcsid 3 4] UTC)
+</p>"
+
+puts {
+<p>
+A security audit for SQLite consists of two components.  First, there is
+a check for common errors that often lead to security problems.  Second,
+an attempt is made to construct a proof that SQLite has certain desirable
+security properties.
+</p>
+
+<h2>Part I: Things to check</h2>
+
+<p>
+Scan all source code and check for the following common errors:
+</p>
+
+<ol>
+<li><p>
+Verify that the destination buffer is large enough to hold its result
+in every call to the following routines:
+<ul>
+<li> <b>strcpy()</b> </li>
+<li> <b>strncpy()</b> </li>
+<li> <b>strcat()</b> </li>
+<li> <b>memcpy()</b> </li>
+<li> <b>memset()</b> </li>
+<li> <b>memmove()</b> </li>
+<li> <b>bcopy()</b> </li>
+<li> <b>sprintf()</b> </li>
+<li> <b>scanf()</b> </li>
+</ul>
+</p></li>
+<li><p>
+Verify that pointers returned by subroutines are not NULL before using
+the pointers.  In particular, make sure the return values for the following
+routines are checked before they are used:
+<ul>
+<li> <b>malloc()</b> </li>
+<li> <b>realloc()</b> </li>
+<li> <b>sqliteMalloc()</b> </li>
+<li> <b>sqliteRealloc()</b> </li>
+<li> <b>sqliteStrDup()</b> </li>
+<li> <b>sqliteStrNDup()</b> </li>
+<li> <b>sqliteExpr()</b> </li>
+<li> <b>sqliteExprFunction()</b> </li>
+<li> <b>sqliteExprListAppend()</b> </li>
+<li> <b>sqliteResultSetOfSelect()</b> </li>
+<li> <b>sqliteIdListAppend()</b> </li>
+<li> <b>sqliteSrcListAppend()</b> </li>
+<li> <b>sqliteSelectNew()</b> </li>
+<li> <b>sqliteTableNameToTable()</b> </li>
+<li> <b>sqliteTableTokenToSrcList()</b> </li>
+<li> <b>sqliteWhereBegin()</b> </li>
+<li> <b>sqliteFindTable()</b> </li>
+<li> <b>sqliteFindIndex()</b> </li>
+<li> <b>sqliteTableNameFromToken()</b> </li>
+<li> <b>sqliteGetVdbe()</b> </li>
+<li> <b>sqlite_mprintf()</b> </li>
+<li> <b>sqliteExprDup()</b> </li>
+<li> <b>sqliteExprListDup()</b> </li>
+<li> <b>sqliteSrcListDup()</b> </li>
+<li> <b>sqliteIdListDup()</b> </li>
+<li> <b>sqliteSelectDup()</b> </li>
+<li> <b>sqliteFindFunction()</b> </li>
+<li> <b>sqliteTriggerSelectStep()</b> </li>
+<li> <b>sqliteTriggerInsertStep()</b> </li>
+<li> <b>sqliteTriggerUpdateStep()</b> </li>
+<li> <b>sqliteTriggerDeleteStep()</b> </li>
+</ul>
+</p></li>
+<li><p>
+On all functions and procedures, verify that pointer parameters are not NULL
+before dereferencing those parameters.
+</p></li>
+<li><p>
+Check to make sure that temporary files are opened safely: that the process
+will not overwrite an existing file when opening the temp file and that
+another process is unable to substitute a file for the temp file being
+opened.
+</p></li>
+</ol>
+
+
+
+<h2>Part II: Things to prove</h2>
+
+<p>
+Prove that SQLite exhibits the characteristics outlined below:
+</p>
+
+<ol>
+<li><p>
+The following are preconditions:</p>
+<p><ul>
+<li><b>Z</b> is an arbitrary-length NUL-terminated string.</li>
+<li>An existing SQLite database has been opened.  The return value
+    from the call to <b>sqlite_open()</b> is stored in the variable
+    <b>db</b>.</li>
+<li>The database contains at least one table of the form:
+<blockquote><pre>
+CREATE TABLE t1(a CLOB);
+</pre></blockquote></li>
+<li>There are no user-defined functions other than the standard
+    build-in functions.</li>
+</ul></p>
+<p>The following statement of C code is executed:</p>
+<blockquote><pre>
+sqlite_exec_printf(
+   db,
+   "INSERT INTO t1(a) VALUES('%q');", 
+   0, 0, 0, Z
+);
+</pre></blockquote>
+<p>Prove the following are true for all possible values of string <b>Z</b>:</p>
+<ol type="a">
+<li><p>
+The call to <b>sqlite_exec_printf()</b> will
+return in a length of time that is a polynomial in <b>strlen(Z)</b>.
+It might return an error code but it will not crash.
+</p></li>
+<li><p>
+At most one new row will be inserted into table t1.
+</p></li>
+<li><p>
+No preexisting rows of t1 will be deleted or modified.
+</p></li>
+<li><p>
+No tables other than t1 will be altered in any way.
+</p></li>
+<li><p>
+No preexisting files on the host computers filesystem, other than
+the database file itself, will be deleted or modified.
+</p></li>
+<li><p>
+For some constants <b>K1</b> and <b>K2</b>,
+if at least <b>K1*strlen(Z) + K2</b> bytes of contiguous memory are
+available to <b>malloc()</b>, then the call to <b>sqlite_exec_printf()</b>
+will not return SQLITE_NOMEM.
+</p></li>
+</ol>
+</p></li>
+
+
+<li><p>
+The following are preconditions:
+<p><ul>
+<li><b>Z</b> is an arbitrary-length NUL-terminated string.</li>
+<li>An existing SQLite database has been opened.  The return value
+    from the call to <b>sqlite_open()</b> is stored in the variable
+    <b>db</b>.</li>
+<li>There exists a callback function <b>cb()</b> that appends all
+    information passed in through its parameters into a single
+    data buffer called <b>Y</b>.</li>
+<li>There are no user-defined functions other than the standard
+    build-in functions.</li>
+</ul></p>
+<p>The following statement of C code is executed:</p>
+<blockquote><pre>
+sqlite_exec(db, Z, cb, 0, 0);
+</pre></blockquote>
+<p>Prove the following are true for all possible values of string <b>Z</b>:</p>
+<ol type="a">
+<li><p>
+The call to <b>sqlite_exec()</b> will
+return in a length of time which is a polynomial in <b>strlen(Z)</b>.
+It might return an error code but it will not crash.
+</p></li>
+<li><p>
+After <b>sqlite_exec()</b> returns, the buffer <b>Y</b> will not contain
+any content from any preexisting file on the host computers file system,
+except for the database file.
+</p></li>
+<li><p>
+After the call to <b>sqlite_exec()</b> returns, the database file will
+still be well-formed.  It might not contain the same data, but it will
+still be a properly constructed SQLite database file.
+</p></li>
+<li><p>
+No preexisting files on the host computers filesystem, other than
+the database file itself, will be deleted or modified.
+</p></li>
+<li><p>
+For some constants <b>K1</b> and <b>K2</b>,
+if at least <b>K1*strlen(Z) + K2</b> bytes of contiguous memory are
+available to <b>malloc()</b>, then the call to <b>sqlite_exec()</b>
+will not return SQLITE_NOMEM.
+</p></li>
+</ol>
+</p></li>
+
+</ol>
+}
+puts {
+<p><hr /></p>
+<p><a href="index.html"><img src="/goback.jpg" border=0 />
+Back to the SQLite Home Page</a>
+</p>
+
+</body></html>}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/autoinc.tcl b/client/src/thirdparty/sqlite-3.4.2/www/autoinc.tcl
new file mode 100644
index 0000000..9332adc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/autoinc.tcl
@@ -0,0 +1,109 @@
+#
+# Run this Tcl script to generate the autoinc.html file.
+#
+set rcsid {$Id: }
+source common.tcl
+
+if {[llength $argv]>0} {
+  set outputdir [lindex $argv 0]
+} else {
+  set outputdir ""
+}
+
+header {SQLite Autoincrement}
+puts {
+<h1>SQLite Autoincrement</h1>
+
+<p>
+In SQLite, every row of every table has an integer ROWID.
+The ROWID for each row is unique among all rows in the same table.
+In SQLite version 2.8 the ROWID is a 32-bit signed integer.
+Version 3.0 of SQLite expanded the ROWID to be a 64-bit signed integer.
+</p>
+
+<p>
+You can access the ROWID of an SQLite table using one the special column
+names ROWID, _ROWID_, or OID.
+Except if you declare an ordinary table column to use one of those special
+names, then the use of that name will refer to the declared column not
+to the internal ROWID.
+</p>
+
+<p>
+If a table contains a column of type INTEGER PRIMARY KEY, then that
+column becomes an alias for the ROWID.  You can then access the ROWID
+using any of four different names, the original three names described above
+or the name given to the INTEGER PRIMARY KEY column.  All these names are
+aliases for one another and work equally well in any context.
+</p>
+
+<p>
+When a new row is inserted into an SQLite table, the ROWID can either
+be specified as part of the INSERT statement or it can be assigned
+automatically by the database engine.  To specify a ROWID manually,
+just include it in the list of values to be inserted.  For example:
+</p>
+
+<blockquote><pre>
+CREATE TABLE test1(a INT, b TEXT);
+INSERT INTO test1(rowid, a, b) VALUES(123, 5, 'hello');
+</pre></blockquote>
+
+<p>
+If no ROWID is specified on the insert, an appropriate ROWID is created
+automatically.  The usual algorithm is to give the newly created row
+a ROWID that is one larger than the largest ROWID in the table prior
+to the insert.  If the table is initially empty, then a ROWID of 1 is
+used.  If the largest ROWID is equal to the largest possible integer
+(9223372036854775807 in SQLite version 3.0 and later) then the database
+engine starts picking candidate ROWIDs at random until it finds one
+that is not previously used.
+</p>
+
+<p>
+The normal ROWID selection algorithm described above
+will generate monotonically increasing
+unique ROWIDs as long as you never use the maximum ROWID value and you never
+delete the entry in the table with the largest ROWID. 
+If you ever delete rows or if you ever create a row with the maximum possible
+ROWID, then ROWIDs from previously deleted rows might be reused when creating
+new rows and newly created ROWIDs might not be in strictly accending order.
+</p>
+
+
+<h2>The AUTOINCREMENT Keyword</h2>
+
+<p>
+If a column has the type INTEGER PRIMARY KEY AUTOINCREMENT then a slightly
+different ROWID selection algorithm is used.  
+The ROWID chosen for the new row is one larger than the largest ROWID
+that has ever before existed in that same table.  If the table has never
+before contained any data, then a ROWID of 1 is used.  If the table
+has previously held a row with the largest possible ROWID, then new INSERTs
+are not allowed and any attempt to insert a new row will fail with an
+SQLITE_FULL error.
+</p>
+
+<p>
+SQLite keeps track of the largest ROWID that a table has ever held using
+the special SQLITE_SEQUENCE table.  The SQLITE_SEQUENCE table is created
+and initialized automatically whenever a normal table that contains an
+AUTOINCREMENT column is created.  The content of the SQLITE_SEQUENCE table
+can be modified using ordinary UPDATE, INSERT, and DELETE statements.
+But making modifications to this table will likely perturb the AUTOINCREMENT
+key generation algorithm.  Make sure you know what you are doing before
+you undertake such changes.
+</p>
+
+<p>
+The behavior implemented by the AUTOINCREMENT keyword is subtly different
+from the default behavior.  With AUTOINCREMENT, rows with automatically
+selected ROWIDs are guaranteed to have ROWIDs that have never been used
+before by the same table in the same database.  And the automatically generated
+ROWIDs are guaranteed to be monotonically increasing.  These are important
+properties in certain applications.  But if your application does not
+need these properties, you should probably stay with the default behavior
+since the use of AUTOINCREMENT requires additional work to be done
+as each row is inserted and thus causes INSERTs to run a little slower.
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/c_interface.tcl b/client/src/thirdparty/sqlite-3.4.2/www/c_interface.tcl
new file mode 100644
index 0000000..c784ff0
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/c_interface.tcl
@@ -0,0 +1,1116 @@
+#
+# Run this Tcl script to generate the sqlite.html file.
+#
+set rcsid {$Id: c_interface.tcl,v 1.43 2004/11/19 11:59:24 danielk1977 Exp $}
+source common.tcl
+header {The C language interface to the SQLite library}
+puts {
+<h2>The C language interface to the SQLite library</h2>
+
+<p>The SQLite library is designed to be very easy to use from
+a C or C++ program.  This document gives an overview of the C/C++
+programming interface.</p>
+
+<h3>1.0 The Core API</h3>
+
+<p>The interface to the SQLite library consists of three core functions,
+one opaque data structure, and some constants used as return values.
+The core interface is as follows:</p>
+
+<blockquote><pre>
+typedef struct sqlite sqlite;
+#define SQLITE_OK           0   /* Successful result */
+
+sqlite *sqlite_open(const char *dbname, int mode, char **errmsg);
+
+void sqlite_close(sqlite *db);
+
+int sqlite_exec(
+  sqlite *db,
+  char *sql,
+  int (*xCallback)(void*,int,char**,char**),
+  void *pArg,
+  char **errmsg
+);
+</pre></blockquote>
+
+<p>
+The above is all you really need to know in order to use SQLite
+in your C or C++ programs.  There are other interface functions
+available (and described below) but we will begin by describing
+the core functions shown above.
+</p>
+
+<a name="sqlite_open">
+<h4>1.1 Opening a database</h4>
+
+<p>Use the <b>sqlite_open</b> function to open an existing SQLite
+database or to create a new SQLite database.  The first argument
+is the database name.  The second argument is intended to signal
+whether the database is going to be used for reading and writing
+or just for reading.  But in the current implementation, the
+second argument to <b>sqlite_open</b> is ignored.
+The third argument is a pointer to a string pointer.
+If the third argument is not NULL and an error occurs
+while trying to open the database, then an error message will be
+written to memory obtained from malloc() and *errmsg will be made
+to point to this error message.  The calling function is responsible
+for freeing the memory when it has finished with it.</p>
+
+<p>The name of an SQLite database is the name of a file that will
+contain the database.  If the file does not exist, SQLite attempts
+to create and initialize it.  If the file is read-only (due to
+permission bits or because it is located on read-only media like
+a CD-ROM) then SQLite opens the database for reading only.  The
+entire SQL database is stored in a single file on the disk.  But
+additional temporary files may be created during the execution of
+an SQL command in order to store the database rollback journal or
+temporary and intermediate results of a query.</p>
+
+<p>The return value of the <b>sqlite_open</b> function is a
+pointer to an opaque <b>sqlite</b> structure.  This pointer will
+be the first argument to all subsequent SQLite function calls that
+deal with the same database.  NULL is returned if the open fails
+for any reason.</p>
+
+<a name="sqlite_close">
+<h4>1.2 Closing the database</h4>
+
+<p>To close an SQLite database, call the <b>sqlite_close</b>
+function passing it the sqlite structure pointer that was obtained
+from a prior call to <b>sqlite_open</b>.
+If a transaction is active when the database is closed, the transaction
+is rolled back.</p>
+
+<a name="sqlite_exec">
+<h4>1.3 Executing SQL statements</h4>
+
+<p>The <b>sqlite_exec</b> function is used to process SQL statements
+and queries.  This function requires 5 parameters as follows:</p>
+
+<ol>
+<li><p>A pointer to the sqlite structure obtained from a prior call
+       to <b>sqlite_open</b>.</p></li>
+<li><p>A null-terminated string containing the text of one or more
+       SQL statements and/or queries to be processed.</p></li>
+<li><p>A pointer to a callback function which is invoked once for each
+       row in the result of a query.  This argument may be NULL, in which
+       case no callbacks will ever be invoked.</p></li>
+<li><p>A pointer that is forwarded to become the first argument
+       to the callback function.</p></li>
+<li><p>A pointer to an error string.  Error messages are written to space
+       obtained from malloc() and the error string is made to point to
+       the malloced space.  The calling function is responsible for freeing
+       this space when it has finished with it.
+       This argument may be NULL, in which case error messages are not
+       reported back to the calling function.</p></li>
+</ol>
+
+<p>
+The callback function is used to receive the results of a query.  A
+prototype for the callback function is as follows:</p>
+
+<blockquote><pre>
+int Callback(void *pArg, int argc, char **argv, char **columnNames){
+  return 0;
+}
+</pre></blockquote>
+
+<a name="callback_row_data">
+<p>The first argument to the callback is just a copy of the fourth argument
+to <b>sqlite_exec</b>  This parameter can be used to pass arbitrary
+information through to the callback function from client code.
+The second argument is the number of columns in the query result.
+The third argument is an array of pointers to strings where each string
+is a single column of the result for that record.  Note that the
+callback function reports a NULL value in the database as a NULL pointer,
+which is very different from an empty string.  If the i-th parameter
+is an empty string, we will get:</p>
+<blockquote><pre>
+argv[i][0] == 0
+</pre></blockquote>
+<p>But if the i-th parameter is NULL we will get:</p>
+<blockquote><pre>
+argv[i] == 0
+</pre></blockquote>
+
+<p>The names of the columns are contained in first <i>argc</i>
+entries of the fourth argument.
+If the <a href="pragma.html#pragma_show_datatypes">SHOW_DATATYPES</a> pragma
+is on (it is off by default) then
+the second <i>argc</i> entries in the 4th argument are the datatypes
+for the corresponding columns.
+</p>
+
+<p>If the <a href="pragma.html#pragma_empty_result_callbacks">
+EMPTY_RESULT_CALLBACKS</a> pragma is set to ON and the result of
+a query is an empty set, then the callback is invoked once with the
+third parameter (argv) set to 0.  In other words
+<blockquote><pre>
+argv == 0
+</pre></blockquote>
+The second parameter (argc)
+and the fourth parameter (columnNames) are still valid
+and can be used to determine the number and names of the result
+columns if there had been a result.
+The default behavior is not to invoke the callback at all if the
+result set is empty.</p>
+
+<a name="callback_returns_nonzero">
+<p>The callback function should normally return 0.  If the callback
+function returns non-zero, the query is immediately aborted and 
+<b>sqlite_exec</b> will return SQLITE_ABORT.</p>
+
+<h4>1.4 Error Codes</h4>
+
+<p>
+The <b>sqlite_exec</b> function normally returns SQLITE_OK.  But
+if something goes wrong it can return a different value to indicate
+the type of error.  Here is a complete list of the return codes:
+</p>
+
+<blockquote><pre>
+#define SQLITE_OK           0   /* Successful result */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* An internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite_interrupt() */
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* (Internal Only) Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* Database lock protocol error */
+#define SQLITE_EMPTY       16   /* (Internal Only) Database table is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* Too much data for one row of a table */
+#define SQLITE_CONSTRAINT  19   /* Abort due to contraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_ROW         100  /* sqlite_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite_step() has finished executing */
+</pre></blockquote>
+
+<p>
+The meanings of these various return values are as follows:
+</p>
+
+<blockquote>
+<dl>
+<dt>SQLITE_OK</dt>
+<dd><p>This value is returned if everything worked and there were no errors.
+</p></dd>
+<dt>SQLITE_INTERNAL</dt>
+<dd><p>This value indicates that an internal consistency check within
+the SQLite library failed.  This can only happen if there is a bug in
+the SQLite library.  If you ever get an SQLITE_INTERNAL reply from
+an <b>sqlite_exec</b> call, please report the problem on the SQLite
+mailing list.
+</p></dd>
+<dt>SQLITE_ERROR</dt>
+<dd><p>This return value indicates that there was an error in the SQL
+that was passed into the <b>sqlite_exec</b>.
+</p></dd>
+<dt>SQLITE_PERM</dt>
+<dd><p>This return value says that the access permissions on the database
+file are such that the file cannot be opened.
+</p></dd>
+<dt>SQLITE_ABORT</dt>
+<dd><p>This value is returned if the callback function returns non-zero.
+</p></dd>
+<dt>SQLITE_BUSY</dt>
+<dd><p>This return code indicates that another program or thread has
+the database locked.  SQLite allows two or more threads to read the
+database at the same time, but only one thread can have the database
+open for writing at the same time.  Locking in SQLite is on the
+entire database.</p>
+</p></dd>
+<dt>SQLITE_LOCKED</dt>
+<dd><p>This return code is similar to SQLITE_BUSY in that it indicates
+that the database is locked.  But the source of the lock is a recursive
+call to <b>sqlite_exec</b>.  This return can only occur if you attempt
+to invoke sqlite_exec from within a callback routine of a query
+from a prior invocation of sqlite_exec.  Recursive calls to
+sqlite_exec are allowed as long as they do
+not attempt to write the same table.
+</p></dd>
+<dt>SQLITE_NOMEM</dt>
+<dd><p>This value is returned if a call to <b>malloc</b> fails.
+</p></dd>
+<dt>SQLITE_READONLY</dt>
+<dd><p>This return code indicates that an attempt was made to write to
+a database file that is opened for reading only.
+</p></dd>
+<dt>SQLITE_INTERRUPT</dt>
+<dd><p>This value is returned if a call to <b>sqlite_interrupt</b>
+interrupts a database operation in progress.
+</p></dd>
+<dt>SQLITE_IOERR</dt>
+<dd><p>This value is returned if the operating system informs SQLite
+that it is unable to perform some disk I/O operation.  This could mean
+that there is no more space left on the disk.
+</p></dd>
+<dt>SQLITE_CORRUPT</dt>
+<dd><p>This value is returned if SQLite detects that the database it is
+working on has become corrupted.  Corruption might occur due to a rogue
+process writing to the database file or it might happen due to an 
+perviously undetected logic error in of SQLite. This value is also
+returned if a disk I/O error occurs in such a way that SQLite is forced
+to leave the database file in a corrupted state.  The latter should only
+happen due to a hardware or operating system malfunction.
+</p></dd>
+<dt>SQLITE_FULL</dt>
+<dd><p>This value is returned if an insertion failed because there is
+no space left on the disk, or the database is too big to hold any
+more information.  The latter case should only occur for databases
+that are larger than 2GB in size.
+</p></dd>
+<dt>SQLITE_CANTOPEN</dt>
+<dd><p>This value is returned if the database file could not be opened
+for some reason.
+</p></dd>
+<dt>SQLITE_PROTOCOL</dt>
+<dd><p>This value is returned if some other process is messing with
+file locks and has violated the file locking protocol that SQLite uses
+on its rollback journal files.
+</p></dd>
+<dt>SQLITE_SCHEMA</dt>
+<dd><p>When the database first opened, SQLite reads the database schema
+into memory and uses that schema to parse new SQL statements.  If another
+process changes the schema, the command currently being processed will
+abort because the virtual machine code generated assumed the old
+schema.  This is the return code for such cases.  Retrying the
+command usually will clear the problem.
+</p></dd>
+<dt>SQLITE_TOOBIG</dt>
+<dd><p>SQLite will not store more than about 1 megabyte of data in a single
+row of a single table.  If you attempt to store more than 1 megabyte
+in a single row, this is the return code you get.
+</p></dd>
+<dt>SQLITE_CONSTRAINT</dt>
+<dd><p>This constant is returned if the SQL statement would have violated
+a database constraint.
+</p></dd>
+<dt>SQLITE_MISMATCH</dt>
+<dd><p>This error occurs when there is an attempt to insert non-integer
+data into a column labeled INTEGER PRIMARY KEY.  For most columns, SQLite
+ignores the data type and allows any kind of data to be stored.  But
+an INTEGER PRIMARY KEY column is only allowed to store integer data.
+</p></dd>
+<dt>SQLITE_MISUSE</dt>
+<dd><p>This error might occur if one or more of the SQLite API routines
+is used incorrectly.  Examples of incorrect usage include calling
+<b>sqlite_exec</b> after the database has been closed using
+<b>sqlite_close</b> or 
+calling <b>sqlite_exec</b> with the same
+database pointer simultaneously from two separate threads.
+</p></dd>
+<dt>SQLITE_NOLFS</dt>
+<dd><p>This error means that you have attempts to create or access a file
+database file that is larger that 2GB on a legacy Unix machine that
+lacks large file support.
+</p></dd>
+<dt>SQLITE_AUTH</dt>
+<dd><p>This error indicates that the authorizer callback
+has disallowed the SQL you are attempting to execute.
+</p></dd>
+<dt>SQLITE_ROW</dt>
+<dd><p>This is one of the return codes from the
+<b>sqlite_step</b> routine which is part of the non-callback API.
+It indicates that another row of result data is available.
+</p></dd>
+<dt>SQLITE_DONE</dt>
+<dd><p>This is one of the return codes from the
+<b>sqlite_step</b> routine which is part of the non-callback API.
+It indicates that the SQL statement has been completely executed and
+the <b>sqlite_finalize</b> routine is ready to be called.
+</p></dd>
+</dl>
+</blockquote>
+
+<h3>2.0 Accessing Data Without Using A Callback Function</h3>
+
+<p>
+The <b>sqlite_exec</b> routine described above used to be the only
+way to retrieve data from an SQLite database.  But many programmers found
+it inconvenient to use a callback function to obtain results.  So beginning
+with SQLite version 2.7.7, a second access interface is available that
+does not use callbacks.
+</p>
+
+<p>
+The new interface uses three separate functions to replace the single
+<b>sqlite_exec</b> function.
+</p>
+
+<blockquote><pre>
+typedef struct sqlite_vm sqlite_vm;
+
+int sqlite_compile(
+  sqlite *db,              /* The open database */
+  const char *zSql,        /* SQL statement to be compiled */
+  const char **pzTail,     /* OUT: uncompiled tail of zSql */
+  sqlite_vm **ppVm,        /* OUT: the virtual machine to execute zSql */
+  char **pzErrmsg          /* OUT: Error message. */
+);
+
+int sqlite_step(
+  sqlite_vm *pVm,          /* The virtual machine to execute */
+  int *pN,                 /* OUT: Number of columns in result */
+  const char ***pazValue,  /* OUT: Column data */
+  const char ***pazColName /* OUT: Column names and datatypes */
+);
+
+int sqlite_finalize(
+  sqlite_vm *pVm,          /* The virtual machine to be finalized */
+  char **pzErrMsg          /* OUT: Error message */
+);
+</pre></blockquote>
+
+<p>
+The strategy is to compile a single SQL statement using
+<b>sqlite_compile</b> then invoke <b>sqlite_step</b> multiple times,
+once for each row of output, and finally call <b>sqlite_finalize</b>
+to clean up after the SQL has finished execution.
+</p>
+
+<h4>2.1 Compiling An SQL Statement Into A Virtual Machine</h4>
+
+<p>
+The <b>sqlite_compile</b> "compiles" a single SQL statement (specified
+by the second parameter) and generates a virtual machine that is able
+to execute that statement.  
+As with must interface routines, the first parameter must be a pointer
+to an sqlite structure that was obtained from a prior call to
+<b>sqlite_open</b>.
+
+<p>
+A pointer to the virtual machine is stored in a pointer which is passed
+in as the 4th parameter.
+Space to hold the virtual machine is dynamically allocated.  To avoid
+a memory leak, the calling function must invoke
+<b>sqlite_finalize</b> on the virtual machine after it has finished
+with it.
+The 4th parameter may be set to NULL if an error is encountered during
+compilation.
+</p>
+
+<p>
+If any errors are encountered during compilation, an error message is
+written into memory obtained from <b>malloc</b> and the 5th parameter
+is made to point to that memory.  If the 5th parameter is NULL, then
+no error message is generated.  If the 5th parameter is not NULL, then
+the calling function should dispose of the memory containing the error
+message by calling <b>sqlite_freemem</b>.
+</p>
+
+<p>
+If the 2nd parameter actually contains two or more statements of SQL,
+only the first statement is compiled.  (This is different from the
+behavior of <b>sqlite_exec</b> which executes all SQL statements
+in its input string.)  The 3rd parameter to <b>sqlite_compile</b>
+is made to point to the first character beyond the end of the first
+statement of SQL in the input.  If the 2nd parameter contains only
+a single SQL statement, then the 3rd parameter will be made to point
+to the '\000' terminator at the end of the 2nd parameter.
+</p>
+
+<p>
+On success, <b>sqlite_compile</b> returns SQLITE_OK.
+Otherwise and error code is returned.
+</p>
+
+<h4>2.2 Step-By-Step Execution Of An SQL Statement</h4>
+
+<p>
+After a virtual machine has been generated using <b>sqlite_compile</b>
+it is executed by one or more calls to <b>sqlite_step</b>.  Each
+invocation of <b>sqlite_step</b>, except the last one,
+returns a single row of the result.
+The number of columns in  the result is stored in the integer that
+the 2nd parameter points to.
+The pointer specified by the 3rd parameter is made to point
+to an array of pointers to column values.
+The pointer in the 4th parameter is made to point to an array
+of pointers to column names and datatypes.
+The 2nd through 4th parameters to <b>sqlite_step</b> convey the
+same information as the 2nd through 4th parameters of the
+<b>callback</b> routine when using
+the <b>sqlite_exec</b> interface.  Except, with <b>sqlite_step</b>
+the column datatype information is always included in the in the
+4th parameter regardless of whether or not the
+<a href="pragma.html#pragma_show_datatypes">SHOW_DATATYPES</a> pragma
+is on or off.
+</p>
+
+<p>
+Each invocation of <b>sqlite_step</b> returns an integer code that
+indicates what happened during that step.  This code may be
+SQLITE_BUSY, SQLITE_ROW, SQLITE_DONE, SQLITE_ERROR, or
+SQLITE_MISUSE.
+</p>
+
+<p>
+If the virtual machine is unable to open the database file because
+it is locked by another thread or process, <b>sqlite_step</b>
+will return SQLITE_BUSY.  The calling function should do some other
+activity, or sleep, for a short amount of time to give the lock a
+chance to clear, then invoke <b>sqlite_step</b> again.  This can
+be repeated as many times as desired.
+</p>
+
+<p>
+Whenever another row of result data is available,
+<b>sqlite_step</b> will return SQLITE_ROW.  The row data is
+stored in an array of pointers to strings and the 2nd parameter
+is made to point to this array.
+</p>
+
+<p>
+When all processing is complete, <b>sqlite_step</b> will return
+either SQLITE_DONE or SQLITE_ERROR.  SQLITE_DONE indicates that the
+statement completed successfully and SQLITE_ERROR indicates that there
+was a run-time error.  (The details of the error are obtained from
+<b>sqlite_finalize</b>.)  It is a misuse of the library to attempt
+to call <b>sqlite_step</b> again after it has returned SQLITE_DONE
+or SQLITE_ERROR.
+</p>
+
+<p>
+When <b>sqlite_step</b> returns SQLITE_DONE or SQLITE_ERROR,
+the *pN and *pazColName values are set to the number of columns
+in the result set and to the names of the columns, just as they
+are for an SQLITE_ROW return.  This allows the calling code to
+find the number of result columns and the column names and datatypes
+even if the result set is empty.  The *pazValue parameter is always
+set to NULL when the return codes is SQLITE_DONE or SQLITE_ERROR.
+If the SQL being executed is a statement that does not
+return a result (such as an INSERT or an UPDATE) then *pN will
+be set to zero and *pazColName will be set to NULL.
+</p>
+
+<p>
+If you abuse the library by trying to call <b>sqlite_step</b>
+inappropriately it will attempt return SQLITE_MISUSE.
+This can happen if you call sqlite_step() on the same virtual machine
+at the same
+time from two or more threads or if you call sqlite_step()
+again after it returned SQLITE_DONE or SQLITE_ERROR or if you
+pass in an invalid virtual machine pointer to sqlite_step().
+You should not depend on the SQLITE_MISUSE return code to indicate
+an error.  It is possible that a misuse of the interface will go
+undetected and result in a program crash.  The SQLITE_MISUSE is
+intended as a debugging aid only - to help you detect incorrect
+usage prior to a mishap.  The misuse detection logic is not guaranteed
+to work in every case.
+</p>
+
+<h4>2.3 Deleting A Virtual Machine</h4>
+
+<p>
+Every virtual machine that <b>sqlite_compile</b> creates should
+eventually be handed to <b>sqlite_finalize</b>.  The sqlite_finalize()
+procedure deallocates the memory and other resources that the virtual
+machine uses.  Failure to call sqlite_finalize() will result in 
+resource leaks in your program.
+</p>
+
+<p>
+The <b>sqlite_finalize</b> routine also returns the result code
+that indicates success or failure of the SQL operation that the
+virtual machine carried out.
+The value returned by sqlite_finalize() will be the same as would
+have been returned had the same SQL been executed by <b>sqlite_exec</b>.
+The error message returned will also be the same.
+</p>
+
+<p>
+It is acceptable to call <b>sqlite_finalize</b> on a virtual machine
+before <b>sqlite_step</b> has returned SQLITE_DONE.  Doing so has
+the effect of interrupting the operation in progress.  Partially completed
+changes will be rolled back and the database will be restored to its
+original state (unless an alternative recovery algorithm is selected using
+an ON CONFLICT clause in the SQL being executed.)  The effect is the
+same as if a callback function of <b>sqlite_exec</b> had returned
+non-zero.
+</p>
+
+<p>
+It is also acceptable to call <b>sqlite_finalize</b> on a virtual machine
+that has never been passed to <b>sqlite_step</b> even once.
+</p>
+
+<h3>3.0 The Extended API</h3>
+
+<p>Only the three core routines described in section 1.0 are required to use
+SQLite.  But there are many other functions that provide 
+useful interfaces.  These extended routines are as follows:
+</p>
+
+<blockquote><pre>
+int sqlite_last_insert_rowid(sqlite*);
+
+int sqlite_changes(sqlite*);
+
+int sqlite_get_table(
+  sqlite*,
+  char *sql,
+  char ***result,
+  int *nrow,
+  int *ncolumn,
+  char **errmsg
+);
+
+void sqlite_free_table(char**);
+
+void sqlite_interrupt(sqlite*);
+
+int sqlite_complete(const char *sql);
+
+void sqlite_busy_handler(sqlite*, int (*)(void*,const char*,int), void*);
+
+void sqlite_busy_timeout(sqlite*, int ms);
+
+const char sqlite_version[];
+
+const char sqlite_encoding[];
+
+int sqlite_exec_printf(
+  sqlite*,
+  char *sql,
+  int (*)(void*,int,char**,char**),
+  void*,
+  char **errmsg,
+  ...
+);
+
+int sqlite_exec_vprintf(
+  sqlite*,
+  char *sql,
+  int (*)(void*,int,char**,char**),
+  void*,
+  char **errmsg,
+  va_list
+);
+
+int sqlite_get_table_printf(
+  sqlite*,
+  char *sql,
+  char ***result,
+  int *nrow,
+  int *ncolumn,
+  char **errmsg,
+  ...
+);
+
+int sqlite_get_table_vprintf(
+  sqlite*,
+  char *sql,
+  char ***result,
+  int *nrow,
+  int *ncolumn,
+  char **errmsg,
+  va_list
+);
+
+char *sqlite_mprintf(const char *zFormat, ...);
+
+char *sqlite_vmprintf(const char *zFormat, va_list);
+
+void sqlite_freemem(char*);
+
+void sqlite_progress_handler(sqlite*, int, int (*)(void*), void*);
+
+</pre></blockquote>
+
+<p>All of the above definitions are included in the "sqlite.h"
+header file that comes in the source tree.</p>
+
+<h4>3.1 The ROWID of the most recent insert</h4>
+
+<p>Every row of an SQLite table has a unique integer key.  If the
+table has a column labeled INTEGER PRIMARY KEY, then that column
+serves as the key.  If there is no INTEGER PRIMARY KEY column then
+the key is a unique integer.  The key for a row can be accessed in
+a SELECT statement or used in a WHERE or ORDER BY clause using any
+of the names "ROWID", "OID", or "_ROWID_".</p>
+
+<p>When you do an insert into a table that does not have an INTEGER PRIMARY
+KEY column, or if the table does have an INTEGER PRIMARY KEY but the value
+for that column is not specified in the VALUES clause of the insert, then
+the key is automatically generated.  You can find the value of the key
+for the most recent INSERT statement using the
+<b>sqlite_last_insert_rowid</b> API function.</p>
+
+<h4>3.2 The number of rows that changed</h4>
+
+<p>The <b>sqlite_changes</b> API function returns the number of rows
+that have been inserted, deleted, or modified since the database was
+last quiescent.  A "quiescent" database is one in which there are
+no outstanding calls to <b>sqlite_exec</b> and no VMs created by
+<b>sqlite_compile</b> that have not been finalized by <b>sqlite_finalize</b>.
+In common usage, <b>sqlite_changes</b> returns the number
+of rows inserted, deleted, or modified by the most recent <b>sqlite_exec</b>
+call or since the most recent <b>sqlite_compile</b>.  But if you have
+nested calls to <b>sqlite_exec</b> (that is, if the callback routine
+of one <b>sqlite_exec</b> invokes another <b>sqlite_exec</b>) or if
+you invoke <b>sqlite_compile</b> to create a new VM while there is
+still another VM in existance, then
+the meaning of the number returned by <b>sqlite_changes</b> is more
+complex.
+The number reported includes any changes
+that were later undone by a ROLLBACK or ABORT.  But rows that are
+deleted because of a DROP TABLE are <em>not</em> counted.</p>
+
+<p>SQLite implements the command "<b>DELETE FROM table</b>" (without
+a WHERE clause) by dropping the table then recreating it.  
+This is much faster than deleting the elements of the table individually.
+But it also means that the value returned from <b>sqlite_changes</b>
+will be zero regardless of the number of elements that were originally
+in the table.  If an accurate count of the number of elements deleted
+is necessary, use "<b>DELETE FROM table WHERE 1</b>" instead.</p>
+
+<h4>3.3 Querying into memory obtained from malloc()</h4>
+
+<p>The <b>sqlite_get_table</b> function is a wrapper around
+<b>sqlite_exec</b> that collects all the information from successive
+callbacks and writes it into memory obtained from malloc().  This
+is a convenience function that allows the application to get the
+entire result of a database query with a single function call.</p>
+
+<p>The main result from <b>sqlite_get_table</b> is an array of pointers
+to strings.  There is one element in this array for each column of
+each row in the result.  NULL results are represented by a NULL
+pointer. In addition to the regular data, there is an added row at the 
+beginning of the array that contains the name of each column of the
+result.</p>
+
+<p>As an example, consider the following query:</p>
+
+<blockquote>
+SELECT employee_name, login, host FROM users WHERE login LIKE 'd%';
+</blockquote>
+
+<p>This query will return the name, login and host computer name
+for every employee whose login begins with the letter "d".  If this
+query is submitted to <b>sqlite_get_table</b> the result might
+look like this:</p>
+
+<blockquote>
+nrow = 2<br>
+ncolumn = 3<br>
+result[0] = "employee_name"<br>
+result[1] = "login"<br>
+result[2] = "host"<br>
+result[3] = "dummy"<br>
+result[4] = "No such user"<br>
+result[5] = 0<br>
+result[6] = "D. Richard Hipp"<br>
+result[7] = "drh"<br>
+result[8] = "zadok"
+</blockquote>
+
+<p>Notice that the "host" value for the "dummy" record is NULL so
+the result[] array contains a NULL pointer at that slot.</p>
+
+<p>If the result set of a query is empty, then by default
+<b>sqlite_get_table</b> will set nrow to 0 and leave its
+result parameter is set to NULL.  But if the EMPTY_RESULT_CALLBACKS
+pragma is ON then the result parameter is initialized to the names
+of the columns only.  For example, consider this query which has
+an empty result set:</p>
+
+<blockquote>
+SELECT employee_name, login, host FROM users WHERE employee_name IS NULL;
+</blockquote>
+
+<p>
+The default behavior gives this results:
+</p>
+
+<blockquote>
+nrow = 0<br>
+ncolumn = 0<br>
+result = 0<br>
+</blockquote>
+
+<p>
+But if the EMPTY_RESULT_CALLBACKS pragma is ON, then the following
+is returned:
+</p>
+
+<blockquote>
+nrow = 0<br>
+ncolumn = 3<br>
+result[0] = "employee_name"<br>
+result[1] = "login"<br>
+result[2] = "host"<br>
+</blockquote>
+
+<p>Memory to hold the information returned by <b>sqlite_get_table</b>
+is obtained from malloc().  But the calling function should not try
+to free this information directly.  Instead, pass the complete table
+to <b>sqlite_free_table</b> when the table is no longer needed.
+It is safe to call <b>sqlite_free_table</b> with a NULL pointer such
+as would be returned if the result set is empty.</p>
+
+<p>The <b>sqlite_get_table</b> routine returns the same integer
+result code as <b>sqlite_exec</b>.</p>
+
+<h4>3.4 Interrupting an SQLite operation</h4>
+
+<p>The <b>sqlite_interrupt</b> function can be called from a
+different thread or from a signal handler to cause the current database
+operation to exit at its first opportunity.  When this happens,
+the <b>sqlite_exec</b> routine (or the equivalent) that started
+the database operation will return SQLITE_INTERRUPT.</p>
+
+<h4>3.5 Testing for a complete SQL statement</h4>
+
+<p>The next interface routine to SQLite is a convenience function used
+to test whether or not a string forms a complete SQL statement.
+If the <b>sqlite_complete</b> function returns true when its input
+is a string, then the argument forms a complete SQL statement.
+There are no guarantees that the syntax of that statement is correct,
+but we at least know the statement is complete.  If <b>sqlite_complete</b>
+returns false, then more text is required to complete the SQL statement.</p>
+
+<p>For the purpose of the <b>sqlite_complete</b> function, an SQL
+statement is complete if it ends in a semicolon.</p>
+
+<p>The <b>sqlite</b> command-line utility uses the <b>sqlite_complete</b>
+function to know when it needs to call <b>sqlite_exec</b>.  After each
+line of input is received, <b>sqlite</b> calls <b>sqlite_complete</b>
+on all input in its buffer.  If <b>sqlite_complete</b> returns true, 
+then <b>sqlite_exec</b> is called and the input buffer is reset.  If
+<b>sqlite_complete</b> returns false, then the prompt is changed to
+the continuation prompt and another line of text is read and added to
+the input buffer.</p>
+
+<h4>3.6 Library version string</h4>
+
+<p>The SQLite library exports the string constant named
+<b>sqlite_version</b> which contains the version number of the
+library.  The header file contains a macro SQLITE_VERSION
+with the same information.  If desired, a program can compare
+the SQLITE_VERSION macro against the <b>sqlite_version</b>
+string constant to verify that the version number of the
+header file and the library match.</p> 
+
+<h4>3.7 Library character encoding</h4>
+
+<p>By default, SQLite assumes that all data uses a fixed-size
+8-bit character (iso8859).  But if you give the --enable-utf8 option
+to the configure script, then the library assumes UTF-8 variable
+sized characters.  This makes a difference for the LIKE and GLOB
+operators and the LENGTH() and SUBSTR() functions.  The static
+string <b>sqlite_encoding</b> will be set to either "UTF-8" or
+"iso8859" to indicate how the library was compiled.  In addition,
+the <b>sqlite.h</b> header file will define one of the
+macros <b>SQLITE_UTF8</b> or <b>SQLITE_ISO8859</b>, as appropriate.</p>
+
+<p>Note that the character encoding mechanism used by SQLite cannot
+be changed at run-time.  This is a compile-time option only.  The
+<b>sqlite_encoding</b> character string just tells you how the library
+was compiled.</p>
+
+<h4>3.8 Changing the library's response to locked files</h4>
+
+<p>The <b>sqlite_busy_handler</b> procedure can be used to register
+a busy callback with an open SQLite database.  The busy callback will
+be invoked whenever SQLite tries to access a database that is locked.
+The callback will typically do some other useful work, or perhaps sleep,
+in order to give the lock a chance to clear.  If the callback returns
+non-zero, then SQLite tries again to access the database and the cycle
+repeats.  If the callback returns zero, then SQLite aborts the current
+operation and returns SQLITE_BUSY.</p>
+
+<p>The arguments to <b>sqlite_busy_handler</b> are the opaque
+structure returned from <b>sqlite_open</b>, a pointer to the busy
+callback function, and a generic pointer that will be passed as
+the first argument to the busy callback.  When SQLite invokes the
+busy callback, it sends it three arguments:  the generic pointer
+that was passed in as the third argument to <b>sqlite_busy_handler</b>,
+the name of the database table or index that the library is trying
+to access, and the number of times that the library has attempted to
+access the database table or index.</p>
+
+<p>For the common case where we want the busy callback to sleep,
+the SQLite library provides a convenience routine <b>sqlite_busy_timeout</b>.
+The first argument to <b>sqlite_busy_timeout</b> is a pointer to
+an open SQLite database and the second argument is a number of milliseconds.
+After <b>sqlite_busy_timeout</b> has been executed, the SQLite library
+will wait for the lock to clear for at least the number of milliseconds 
+specified before it returns SQLITE_BUSY.  Specifying zero milliseconds for
+the timeout restores the default behavior.</p>
+
+<h4>3.9 Using the <tt>_printf()</tt> wrapper functions</h4>
+
+<p>The four utility functions</p>
+
+<p>
+<ul>
+<li><b>sqlite_exec_printf()</b></li>
+<li><b>sqlite_exec_vprintf()</b></li>
+<li><b>sqlite_get_table_printf()</b></li>
+<li><b>sqlite_get_table_vprintf()</b></li>
+</ul>
+</p>
+
+<p>implement the same query functionality as <b>sqlite_exec</b>
+and <b>sqlite_get_table</b>.  But instead of taking a complete
+SQL statement as their second argument, the four <b>_printf</b>
+routines take a printf-style format string.  The SQL statement to
+be executed is generated from this format string and from whatever
+additional arguments are attached to the end of the function call.</p>
+
+<p>There are two advantages to using the SQLite printf
+functions instead of <b>sprintf</b>.  First of all, with the
+SQLite printf routines, there is never a danger of overflowing a
+static buffer as there is with <b>sprintf</b>.  The SQLite
+printf routines automatically allocate (and later frees)
+as much memory as is 
+necessary to hold the SQL statements generated.</p>
+
+<p>The second advantage the SQLite printf routines have over
+<b>sprintf</b> are two new formatting options specifically designed
+to support string literals in SQL.  Within the format string,
+the %q formatting option works very much like %s in that it
+reads a null-terminated string from the argument list and inserts
+it into the result.  But %q translates the inserted string by
+making two copies of every single-quote (') character in the
+substituted string.  This has the effect of escaping the end-of-string
+meaning of single-quote within a string literal. The %Q formatting
+option works similar; it translates the single-quotes like %q and
+additionally encloses the resulting string in single-quotes.
+If the argument for the %Q formatting options is a NULL pointer,
+the resulting string is NULL without single quotes.
+</p>
+
+<p>Consider an example.  Suppose you are trying to insert a string
+value into a database table where the string value was obtained from
+user input.  Suppose the string to be inserted is stored in a variable
+named zString.  The code to do the insertion might look like this:</p>
+
+<blockquote><pre>
+sqlite_exec_printf(db,
+  "INSERT INTO table1 VALUES('%s')",
+  0, 0, 0, zString);
+</pre></blockquote>
+
+<p>If the zString variable holds text like "Hello", then this statement
+will work just fine.  But suppose the user enters a string like 
+"Hi y'all!".  The SQL statement generated reads as follows:
+
+<blockquote><pre>
+INSERT INTO table1 VALUES('Hi y'all')
+</pre></blockquote>
+
+<p>This is not valid SQL because of the apostrophy in the word "y'all".
+But if the %q formatting option is used instead of %s, like this:</p>
+
+<blockquote><pre>
+sqlite_exec_printf(db,
+  "INSERT INTO table1 VALUES('%q')",
+  0, 0, 0, zString);
+</pre></blockquote>
+
+<p>Then the generated SQL will look like the following:</p>
+
+<blockquote><pre>
+INSERT INTO table1 VALUES('Hi y''all')
+</pre></blockquote>
+
+<p>Here the apostrophy has been escaped and the SQL statement is well-formed.
+When generating SQL on-the-fly from data that might contain a
+single-quote character ('), it is always a good idea to use the
+SQLite printf routines and the %q formatting option instead of <b>sprintf</b>.
+</p>
+
+<p>If the %Q formatting option is used instead of %q, like this:</p>
+
+<blockquote><pre>
+sqlite_exec_printf(db,
+  "INSERT INTO table1 VALUES(%Q)",
+  0, 0, 0, zString);
+</pre></blockquote>
+
+<p>Then the generated SQL will look like the following:</p>
+
+<blockquote><pre>
+INSERT INTO table1 VALUES('Hi y''all')
+</pre></blockquote>
+
+<p>If the value of the zString variable is NULL, the generated SQL
+will look like the following:</p>
+
+<blockquote><pre>
+INSERT INTO table1 VALUES(NULL)
+</pre></blockquote>
+
+<p>All of the _printf() routines above are built around the following
+two functions:</p>
+
+<blockquote><pre>
+char *sqlite_mprintf(const char *zFormat, ...);
+char *sqlite_vmprintf(const char *zFormat, va_list);
+</pre></blockquote>
+
+<p>The <b>sqlite_mprintf()</b> routine works like the the standard library
+<b>sprintf()</b> except that it writes its results into memory obtained
+from malloc() and returns a pointer to the malloced buffer.  
+<b>sqlite_mprintf()</b> also understands the %q and %Q extensions described
+above.  The <b>sqlite_vmprintf()</b> is a varargs version of the same
+routine.  The string pointer that these routines return should be freed
+by passing it to <b>sqlite_freemem()</b>.
+</p>
+
+<h4>3.10 Performing background jobs during large queries</h3>
+
+<p>The <b>sqlite_progress_handler()</b> routine can be used to register a
+callback routine with an SQLite database to be invoked periodically during long
+running calls to <b>sqlite_exec()</b>, <b>sqlite_step()</b> and the various
+wrapper functions.
+</p>
+
+<p>The callback is invoked every N virtual machine operations, where N is
+supplied as the second argument to <b>sqlite_progress_handler()</b>. The third
+and fourth arguments to <b>sqlite_progress_handler()</b> are a pointer to the
+routine to be invoked and a void pointer to be passed as the first argument to
+it.
+</p>
+
+<p>The time taken to execute each virtual machine operation can vary based on
+many factors.  A typical value for a 1 GHz PC is between half and three million
+per second but may be much higher or lower, depending on the query.  As such it
+is difficult to schedule background operations based on virtual machine
+operations. Instead, it is recommended that a callback be scheduled relatively
+frequently (say every 1000 instructions) and external timer routines used to
+determine whether or not background jobs need to be run.  
+</p>
+
+<a name="cfunc">
+<h3>4.0 Adding New SQL Functions</h3>
+
+<p>Beginning with version 2.4.0, SQLite allows the SQL language to be
+extended with new functions implemented as C code.  The following interface
+is used:
+</p>
+
+<blockquote><pre>
+typedef struct sqlite_func sqlite_func;
+
+int sqlite_create_function(
+  sqlite *db,
+  const char *zName,
+  int nArg,
+  void (*xFunc)(sqlite_func*,int,const char**),
+  void *pUserData
+);
+int sqlite_create_aggregate(
+  sqlite *db,
+  const char *zName,
+  int nArg,
+  void (*xStep)(sqlite_func*,int,const char**),
+  void (*xFinalize)(sqlite_func*),
+  void *pUserData
+);
+
+char *sqlite_set_result_string(sqlite_func*,const char*,int);
+void sqlite_set_result_int(sqlite_func*,int);
+void sqlite_set_result_double(sqlite_func*,double);
+void sqlite_set_result_error(sqlite_func*,const char*,int);
+
+void *sqlite_user_data(sqlite_func*);
+void *sqlite_aggregate_context(sqlite_func*, int nBytes);
+int sqlite_aggregate_count(sqlite_func*);
+</pre></blockquote>
+
+<p>
+The <b>sqlite_create_function()</b> interface is used to create 
+regular functions and <b>sqlite_create_aggregate()</b> is used to
+create new aggregate functions.  In both cases, the <b>db</b>
+parameter is an open SQLite database on which the functions should
+be registered, <b>zName</b> is the name of the new function,
+<b>nArg</b> is the number of arguments, and <b>pUserData</b> is
+a pointer which is passed through unchanged to the C implementation
+of the function.  Both routines return 0 on success and non-zero
+if there are any errors.
+</p>
+
+<p>
+The length of a function name may not exceed 255 characters.
+Any attempt to create a function whose name exceeds 255 characters
+in length will result in an error.
+</p>
+
+<p>
+For regular functions, the <b>xFunc</b> callback is invoked once
+for each function call.  The implementation of xFunc should call
+one of the <b>sqlite_set_result_...</b> interfaces to return its
+result.  The <b>sqlite_user_data()</b> routine can be used to
+retrieve the <b>pUserData</b> pointer that was passed in when the
+function was registered.
+</p>
+
+<p>
+For aggregate functions, the <b>xStep</b> callback is invoked once
+for each row in the result and then <b>xFinalize</b> is invoked at the
+end to compute a final answer.  The xStep routine can use the
+<b>sqlite_aggregate_context()</b> interface to allocate memory that
+will be unique to that particular instance of the SQL function.
+This memory will be automatically deleted after xFinalize is called.
+The <b>sqlite_aggregate_count()</b> routine can be used to find out
+how many rows of data were passed to the aggregate.  The xFinalize
+callback should invoke one of the <b>sqlite_set_result_...</b>
+interfaces to set the final result of the aggregate.
+</p>
+
+<p>
+SQLite now implements all of its built-in functions using this
+interface.  For additional information and examples on how to create
+new SQL functions, review the SQLite source code in the file
+<b>func.c</b>.
+</p>
+
+<h3>5.0 Multi-Threading And SQLite</h3>
+
+<p>
+If SQLite is compiled with the THREADSAFE preprocessor macro set to 1,
+then it is safe to use SQLite from two or more threads of the same process
+at the same time.  But each thread should have its own <b>sqlite*</b>
+pointer returned from <b>sqlite_open</b>.  It is never safe for two
+or more threads to access the same <b>sqlite*</b> pointer at the same time.
+</p>
+
+<p>
+In precompiled SQLite libraries available on the website, the Unix
+versions are compiled with THREADSAFE turned off but the windows
+versions are compiled with THREADSAFE turned on.  If you need something
+different that this you will have to recompile.
+</p>
+
+<p>
+Under Unix, an <b>sqlite*</b> pointer should not be carried across a
+<b>fork()</b> system call into the child process.  The child process
+should open its own copy of the database after the <b>fork()</b>.
+</p>
+
+<h3>6.0 Usage Examples</h3>
+
+<p>For examples of how the SQLite C/C++ interface can be used,
+refer to the source code for the <b>sqlite</b> program in the
+file <b>src/shell.c</b> of the source tree.
+Additional information about sqlite is available at
+<a href="sqlite.html">sqlite.html</a>.
+See also the sources to the Tcl interface for SQLite in
+the source file <b>src/tclsqlite.c</b>.</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/capi3.tcl b/client/src/thirdparty/sqlite-3.4.2/www/capi3.tcl
new file mode 100644
index 0000000..149cf7f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/capi3.tcl
@@ -0,0 +1,516 @@
+set rcsid {$Id: capi3.tcl,v 1.10 2007/04/27 17:16:22 drh Exp $}
+source common.tcl
+header {C/C++ Interface For SQLite Version 3}
+
+proc AddHyperlinks {txt} {
+  regsub -all {([^:alnum:>])(sqlite3_\w+)(\([^\)]*\))} $txt \
+      {\1<a href="capi3ref.html#\2">\2</a>\3} t2
+  puts $t2
+}
+
+AddHyperlinks {
+<h2>C/C++ Interface For SQLite Version 3</h2>
+
+<h3>1.0 Overview</h3>
+
+<p>
+SQLite version 3.0 is a new version of SQLite, derived from
+the SQLite 2.8.13 code base, but with an incompatible file format
+and API.
+SQLite version 3.0 was created to answer demand for the following features:
+</p>
+
+<ul>
+<li>Support for UTF-16.</li>
+<li>User-definable text collating sequences.</li>
+<li>The ability to store BLOBs in indexed columns.</li>
+</ul>
+
+<p>
+It was necessary to move to version 3.0 to implement these features because
+each requires incompatible changes to the database file format.  Other
+incompatible changes, such as a cleanup of the API, were introduced at the
+same time under the theory that it is best to get your incompatible changes
+out of the way all at once.  
+</p>
+
+<p>
+The API for version 3.0 is similar to the version 2.X API,
+but with some important changes.  Most noticeably, the "<tt>sqlite_</tt>"
+prefix that occurs on the beginning of all API functions and data
+structures are changed to "<tt>sqlite3_</tt>".  
+This avoids confusion between the two APIs and allows linking against both
+SQLite 2.X and SQLite 3.0 at the same time.
+</p>
+
+<p>
+There is no agreement on what the C datatype for a UTF-16
+string should be.  Therefore, SQLite uses a generic type of void*
+to refer to UTF-16 strings.  Client software can cast the void* 
+to whatever datatype is appropriate for their system.
+</p>
+
+<h3>2.0 C/C++ Interface</h3>
+
+<p>
+The API for SQLite 3.0 includes 83 separate functions in addition
+to several data structures and #defines.  (A complete
+<a href="capi3ref.html">API reference</a> is provided as a separate document.)
+Fortunately, the interface is not nearly as complex as its size implies.
+Simple programs can still make do with only 3 functions:
+<a href="capi3ref.html#sqlite3_open">sqlite3_open()</a>,
+<a href="capi3ref.html#sqlite3_exec">sqlite3_exec()</a>, and
+<a href="capi3ref.html#sqlite3_close">sqlite3_close()</a>.
+More control over the execution of the database engine is provided
+using
+<a href="capi3ref.html#sqlite3_prepare">sqlite3_prepare()</a>
+to compile an SQLite statement into byte code and
+<a href="capi3ref.html#sqlite3_prepare">sqlite3_step()</a>
+to execute that bytecode.
+A family of routines with names beginning with 
+<a href="capi3ref.html#sqlite3_column_blob">sqlite3_column_</a>
+is used to extract information about the result set of a query.
+Many interface functions come in pairs, with both a UTF-8 and
+UTF-16 version.  And there is a collection of routines
+used to implement user-defined SQL functions and user-defined
+text collating sequences.
+</p>
+
+
+<h4>2.1 Opening and closing a database</h4>
+
+<blockquote><pre>
+   typedef struct sqlite3 sqlite3;
+   int sqlite3_open(const char*, sqlite3**);
+   int sqlite3_open16(const void*, sqlite3**);
+   int sqlite3_close(sqlite3*);
+   const char *sqlite3_errmsg(sqlite3*);
+   const void *sqlite3_errmsg16(sqlite3*);
+   int sqlite3_errcode(sqlite3*);
+</pre></blockquote>
+
+<p>
+The sqlite3_open() routine returns an integer error code rather than
+a pointer to the sqlite3 structure as the version 2 interface did.
+The difference between sqlite3_open()
+and sqlite3_open16() is that sqlite3_open16() takes UTF-16 (in host native
+byte order) for the name of the database file.  If a new database file
+needs to be created, then sqlite3_open16() sets the internal text
+representation to UTF-16 whereas sqlite3_open() sets the text
+representation to UTF-8.
+</p>
+
+<p>
+The opening and/or creating of the database file is deferred until the
+file is actually needed.  This allows options and parameters, such
+as the native text representation and default page size, to be
+set using PRAGMA statements.
+</p>
+
+<p>
+The sqlite3_errcode() routine returns a result code for the most
+recent major API call.  sqlite3_errmsg() returns an English-language
+text error message for the most recent error.  The error message is
+represented in UTF-8 and will be ephemeral - it could disappear on
+the next call to any SQLite API function.  sqlite3_errmsg16() works like
+sqlite3_errmsg() except that it returns the error message represented
+as UTF-16 in host native byte order.
+</p>
+
+<p>
+The error codes for SQLite version 3 are unchanged from version 2.
+They are as follows:
+</p>
+
+<blockquote><pre>
+#define SQLITE_OK           0   /* Successful result */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* An internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite_interrupt() */
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* (Internal Only) Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* Database lock protocol error */
+#define SQLITE_EMPTY       16   /* (Internal Only) Database table is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* Too much data for one row of a table */
+#define SQLITE_CONSTRAINT  19   /* Abort due to contraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_ROW         100  /* sqlite_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite_step() has finished executing */
+</pre></blockquote>
+
+<h4>2.2 Executing SQL statements</h4>
+
+<blockquote><pre>
+   typedef int (*sqlite_callback)(void*,int,char**, char**);
+   int sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void*, char**);
+</pre></blockquote>
+
+<p>
+The sqlite3_exec function works much as it did in SQLite version 2.
+Zero or more SQL statements specified in the second parameter are compiled
+and executed.  Query results are returned to a callback routine.
+See the <a href="capi3ref.html#sqlite3_exec">API reference</a> for additional
+information.
+</p>
+
+<p>
+In SQLite version 3, the sqlite3_exec routine is just a wrapper around
+calls to the prepared statement interface.
+</p>
+
+<blockquote><pre>
+   typedef struct sqlite3_stmt sqlite3_stmt;
+   int sqlite3_prepare(sqlite3*, const char*, int, sqlite3_stmt**, const char**);
+   int sqlite3_prepare16(sqlite3*, const void*, int, sqlite3_stmt**, const void**);
+   int sqlite3_finalize(sqlite3_stmt*);
+   int sqlite3_reset(sqlite3_stmt*);
+</pre></blockquote>
+
+<p>
+The sqlite3_prepare interface compiles a single SQL statement into byte code
+for later execution.  This interface is now the preferred way of accessing
+the database.
+</p>
+
+<p>
+The SQL statement is a UTF-8 string for sqlite3_prepare().
+The sqlite3_prepare16() works the same way except
+that it expects a UTF-16 string as SQL input.
+Only the first SQL statement in the input string is compiled.
+The fourth parameter is filled in with a pointer to the next (uncompiled)
+SQLite statement in the input string, if any.
+The sqlite3_finalize() routine deallocates a prepared SQL statement.
+All prepared statements must be finalized before the database can be
+closed.
+The sqlite3_reset() routine resets a prepared SQL statement so that it
+can be executed again.
+</p>
+
+<p>
+The SQL statement may contain tokens of the form "?" or "?nnn" or ":aaa"
+where "nnn" is an integer and "aaa" is an identifier.
+Such tokens represent unspecified literal values (or "wildcards")
+to be filled in later by the 
+<a href="capi3ref.html#sqlite3_bind_blob">sqlite3_bind</a> interface.
+Each wildcard has an associated number which is its sequence in the
+statement or the "nnn" in the case of a "?nnn" form. 
+It is allowed for the same wildcard
+to occur more than once in the same SQL statement, in which case
+all instance of that wildcard will be filled in with the same value.
+Unbound wildcards have a value of NULL.
+</p>
+
+<blockquote><pre>
+   int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+   int sqlite3_bind_double(sqlite3_stmt*, int, double);
+   int sqlite3_bind_int(sqlite3_stmt*, int, int);
+   int sqlite3_bind_int64(sqlite3_stmt*, int, long long int);
+   int sqlite3_bind_null(sqlite3_stmt*, int);
+   int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+   int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+   int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
+</pre></blockquote>
+
+<p>
+There is an assortment of sqlite3_bind routines used to assign values
+to wildcards in a prepared SQL statement.  Unbound wildcards
+are interpreted as NULLs.  Bindings are not reset by sqlite3_reset().
+But wildcards can be rebound to new values after an sqlite3_reset().
+</p>
+
+<p>
+After an SQL statement has been prepared (and optionally bound), it
+is executed using:
+</p>
+
+<blockquote><pre>
+   int sqlite3_step(sqlite3_stmt*);
+</pre></blockquote>
+
+<p>
+The sqlite3_step() routine return SQLITE_ROW if it is returning a single
+row of the result set, or SQLITE_DONE if execution has completed, either
+normally or due to an error.  It might also return SQLITE_BUSY if it is
+unable to open the database file.  If the return value is SQLITE_ROW, then
+the following routines can be used to extract information about that row
+of the result set:
+</p>
+
+<blockquote><pre>
+   const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
+   int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
+   int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
+   int sqlite3_column_count(sqlite3_stmt*);
+   const char *sqlite3_column_decltype(sqlite3_stmt *, int iCol);
+   const void *sqlite3_column_decltype16(sqlite3_stmt *, int iCol);
+   double sqlite3_column_double(sqlite3_stmt*, int iCol);
+   int sqlite3_column_int(sqlite3_stmt*, int iCol);
+   long long int sqlite3_column_int64(sqlite3_stmt*, int iCol);
+   const char *sqlite3_column_name(sqlite3_stmt*, int iCol);
+   const void *sqlite3_column_name16(sqlite3_stmt*, int iCol);
+   const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
+   const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
+   int sqlite3_column_type(sqlite3_stmt*, int iCol);
+</pre></blockquote>
+
+<p>
+The 
+<a href="capi3ref.html#sqlite3_column_count">sqlite3_column_count()</a>
+function returns the number of columns in
+the results set.  sqlite3_column_count() can be called at any time after
+sqlite3_prepare().  
+<a href="capi3ref.html#sqlite3_data_count">sqlite3_data_count()</a>
+works similarly to
+sqlite3_column_count() except that it only works following sqlite3_step().
+If the previous call to sqlite3_step() returned SQLITE_DONE or an error code,
+then sqlite3_data_count() will return 0 whereas sqlite3_column_count() will
+continue to return the number of columns in the result set.
+</p>
+
+<p>Returned data is examined using the other sqlite3_column_***() functions, 
+all of which take a column number as their second parameter. Columns are
+zero-indexed from left to right. Note that this is different to parameters,
+which are indexed starting at one.
+</p>
+
+<p>
+The sqlite3_column_type() function returns the
+datatype for the value in the Nth column.  The return value is one
+of these:
+</p>
+
+<blockquote><pre>
+   #define SQLITE_INTEGER  1
+   #define SQLITE_FLOAT    2
+   #define SQLITE_TEXT     3
+   #define SQLITE_BLOB     4
+   #define SQLITE_NULL     5
+</pre></blockquote>
+
+<p>
+The sqlite3_column_decltype() routine returns text which is the
+declared type of the column in the CREATE TABLE statement.  For an
+expression, the return type is an empty string.  sqlite3_column_name()
+returns the name of the Nth column.  sqlite3_column_bytes() returns
+the number of bytes in a column that has type BLOB or the number of bytes
+in a TEXT string with UTF-8 encoding.  sqlite3_column_bytes16() returns
+the same value for BLOBs but for TEXT strings returns the number of bytes
+in a UTF-16 encoding.
+sqlite3_column_blob() return BLOB data.  
+sqlite3_column_text() return TEXT data as UTF-8.
+sqlite3_column_text16() return TEXT data as UTF-16.
+sqlite3_column_int() return INTEGER data in the host machines native
+integer format.
+sqlite3_column_int64() returns 64-bit INTEGER data.
+Finally, sqlite3_column_double() return floating point data.
+</p>
+
+<p>
+It is not necessary to retrieve data in the format specify by
+sqlite3_column_type().  If a different format is requested, the data
+is converted automatically.
+</p>
+
+<p>
+Data format conversions can invalidate the pointer returned by
+prior calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
+sqlite3_column_text16().  Pointers might be invalided in the following
+cases:
+</p>
+<ul>
+<li><p>
+The initial content is a BLOB and sqlite3_column_text() 
+or sqlite3_column_text16()
+is called.  A zero-terminator might need to be added to the string.
+</p></li>
+<li><p>
+The initial content is UTF-8 text and sqlite3_column_bytes16() or
+sqlite3_column_text16() is called.  The content must be converted to UTF-16.
+</p></li>
+<li><p>
+The initial content is UTF-16 text and sqlite3_column_bytes() or
+sqlite3_column_text() is called.  The content must be converted to UTF-8.
+</p></li>
+</ul>
+<p>
+Note that conversions between UTF-16be and UTF-16le 
+are always done in place and do
+not invalidate a prior pointer, though of course the content of the buffer
+that the prior pointer points to will have been modified.  Other kinds
+of conversion are done in place when it is possible, but sometime it is
+not possible and in those cases prior pointers are invalidated.  
+</p>
+
+<p>
+The safest and easiest to remember policy is this: assume that any
+result from
+<ul>
+<li>sqlite3_column_blob(),</li>
+<li>sqlite3_column_text(), or</li>
+<li>sqlite3_column_text16()</li>
+</ul>
+is invalided by subsequent calls to 
+<ul>
+<li>sqlite3_column_bytes(),</li>
+<li>sqlite3_column_bytes16(),</li>
+<li>sqlite3_column_text(), or</li>
+<li>sqlite3_column_text16().</li>
+</ul>
+This means that you should always call sqlite3_column_bytes() or
+sqlite3_column_bytes16() <u>before</u> calling sqlite3_column_blob(),
+sqlite3_column_text(), or sqlite3_column_text16().
+</p>
+
+<h4>2.3 User-defined functions</h4>
+
+<p>
+User defined functions can be created using the following routine:
+</p>
+
+<blockquote><pre>
+   typedef struct sqlite3_value sqlite3_value;
+   int sqlite3_create_function(
+     sqlite3 *,
+     const char *zFunctionName,
+     int nArg,
+     int eTextRep,
+     void*,
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+     void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+     void (*xFinal)(sqlite3_context*)
+   );
+   int sqlite3_create_function16(
+     sqlite3*,
+     const void *zFunctionName,
+     int nArg,
+     int eTextRep,
+     void*,
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+     void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+     void (*xFinal)(sqlite3_context*)
+   );
+   #define SQLITE_UTF8     1
+   #define SQLITE_UTF16    2
+   #define SQLITE_UTF16BE  3
+   #define SQLITE_UTF16LE  4
+   #define SQLITE_ANY      5
+</pre></blockquote>
+
+<p>
+The nArg parameter specifies the number of arguments to the function.
+A value of 0 indicates that any number of arguments is allowed.  The
+eTextRep parameter specifies what representation text values are expected
+to be in for arguments to this function.  The value of this parameter should
+be one of the parameters defined above.  SQLite version 3 allows multiple
+implementations of the same function using different text representations.
+The database engine chooses the function that minimization the number
+of text conversions required.
+</p>
+
+<p>
+Normal functions specify only xFunc and leave xStep and xFinal set to NULL.
+Aggregate functions specify xStep and xFinal and leave xFunc set to NULL.
+There is no separate sqlite3_create_aggregate() API.
+</p>
+
+<p>
+The function name is specified in UTF-8.  A separate sqlite3_create_function16()
+API works the same as sqlite_create_function()
+except that the function name is specified in UTF-16 host byte order.
+</p>
+
+<p>
+Notice that the parameters to functions are now pointers to sqlite3_value
+structures instead of pointers to strings as in SQLite version 2.X.
+The following routines are used to extract useful information from these
+"values":
+</p>
+
+<blockquote><pre>
+   const void *sqlite3_value_blob(sqlite3_value*);
+   int sqlite3_value_bytes(sqlite3_value*);
+   int sqlite3_value_bytes16(sqlite3_value*);
+   double sqlite3_value_double(sqlite3_value*);
+   int sqlite3_value_int(sqlite3_value*);
+   long long int sqlite3_value_int64(sqlite3_value*);
+   const unsigned char *sqlite3_value_text(sqlite3_value*);
+   const void *sqlite3_value_text16(sqlite3_value*);
+   int sqlite3_value_type(sqlite3_value*);
+</pre></blockquote>
+
+<p>
+Function implementations use the following APIs to acquire context and
+to report results:
+</p>
+
+<blockquote><pre>
+   void *sqlite3_aggregate_context(sqlite3_context*, int nbyte);
+   void *sqlite3_user_data(sqlite3_context*);
+   void sqlite3_result_blob(sqlite3_context*, const void*, int n, void(*)(void*));
+   void sqlite3_result_double(sqlite3_context*, double);
+   void sqlite3_result_error(sqlite3_context*, const char*, int);
+   void sqlite3_result_error16(sqlite3_context*, const void*, int);
+   void sqlite3_result_int(sqlite3_context*, int);
+   void sqlite3_result_int64(sqlite3_context*, long long int);
+   void sqlite3_result_null(sqlite3_context*);
+   void sqlite3_result_text(sqlite3_context*, const char*, int n, void(*)(void*));
+   void sqlite3_result_text16(sqlite3_context*, const void*, int n, void(*)(void*));
+   void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
+   void *sqlite3_get_auxdata(sqlite3_context*, int);
+   void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*));
+</pre></blockquote>
+
+<h4>2.4 User-defined collating sequences</h4>
+
+<p>
+The following routines are used to implement user-defined
+collating sequences:
+</p>
+
+<blockquote><pre>
+   sqlite3_create_collation(sqlite3*, const char *zName, int eTextRep, void*,
+      int(*xCompare)(void*,int,const void*,int,const void*));
+   sqlite3_create_collation16(sqlite3*, const void *zName, int eTextRep, void*,
+      int(*xCompare)(void*,int,const void*,int,const void*));
+   sqlite3_collation_needed(sqlite3*, void*, 
+      void(*)(void*,sqlite3*,int eTextRep,const char*));
+   sqlite3_collation_needed16(sqlite3*, void*,
+      void(*)(void*,sqlite3*,int eTextRep,const void*));
+</pre></blockquote>
+
+<p>
+The sqlite3_create_collation() function specifies a collating sequence name
+and a comparison function to implement that collating sequence.  The
+comparison function is only used for comparing text values.  The eTextRep
+parameter is one of SQLITE_UTF8, SQLITE_UTF16LE, SQLITE_UTF16BE, or
+SQLITE_ANY to specify which text representation the comparison function works
+with.  Separate comparison functions can exist for the same collating
+sequence for each of the UTF-8, UTF-16LE and UTF-16BE text representations.
+The sqlite3_create_collation16() works like sqlite3_create_collation() except
+that the collation name is specified in UTF-16 host byte order instead of
+in UTF-8.
+</p>
+
+<p>
+The sqlite3_collation_needed() routine registers a callback which the
+database engine will invoke if it encounters an unknown collating sequence.
+The callback can lookup an appropriate comparison function and invoke
+sqlite_3_create_collation() as needed.  The fourth parameter to the callback
+is the name of the collating sequence in UTF-8.  For sqlite3_collation_need16()
+the callback sends the collating sequence name in UTF-16 host byte order.
+</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/capi3ref.tcl b/client/src/thirdparty/sqlite-3.4.2/www/capi3ref.tcl
new file mode 100644
index 0000000..631acef
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/capi3ref.tcl
@@ -0,0 +1,1882 @@
+set rcsid {$Id: capi3ref.tcl,v 1.60 2007/05/19 06:48:43 danielk1977 Exp $}
+source common.tcl
+header {C/C++ Interface For SQLite Version 3}
+puts {
+<h2 class=pdf_section>C/C++ Interface For SQLite Version 3</h2>
+}
+
+proc api {name prototype desc {notused x}} {
+  global apilist specialname
+  if {$name==""} {
+    regsub -all {sqlite3_[a-z0-9_]+\(} $prototype \
+      {[lappend name [string trimright & (]]} x1
+    subst $x1
+  } else {
+    lappend specialname $name
+  }
+  lappend apilist [list $name $prototype $desc]
+}
+
+api {extended-result-codes} {
+#define SQLITE_IOERR_READ       
+#define SQLITE_IOERR_SHORT_READ 
+#define SQLITE_IOERR_WRITE      
+#define SQLITE_IOERR_FSYNC      
+#define SQLITE_IOERR_DIR_FSYNC  
+#define SQLITE_IOERR_TRUNCATE   
+#define SQLITE_IOERR_FSTAT      
+#define SQLITE_IOERR_UNLOCK     
+#define SQLITE_IOERR_RDLOCK     
+...
+} {
+In its default configuration, SQLite API routines return one of 26 integer
+result codes described at result-codes.  However, experience has shown that
+many of these result codes are too course-grained.  They do not provide as
+much information about problems as users might like.  In an effort to
+address this, newer versions of SQLite (version 3.3.8 and later) include
+support for additional result codes that provide more detailed information
+about errors.  The extended result codes are enabled (or disabled) for 
+each database
+connection using the sqlite3_extended_result_codes() API.
+
+Some of the available extended result codes are listed above.
+We expect the number of extended result codes will be expand
+over time.  Software that uses extended result codes should expect
+to see new result codes in future releases of SQLite.
+
+The symbolic name for an extended result code always contains a related
+primary result code as a prefix.  Primary result codes contain a single
+"_" character.  Extended result codes contain two or more "_" characters.
+The numeric value of an extended result code can be converted to its
+corresponding primary result code by masking off the lower 8 bytes.
+
+A complete list of available extended result codes and
+details about the meaning of the various extended result codes can be
+found by consulting the C code, especially the sqlite3.h header
+file and its antecedent sqlite.h.in.  Additional information
+is also available at the SQLite wiki:
+http://www.sqlite.org/cvstrac/wiki?p=ExtendedResultCodes
+}
+
+
+api {result-codes} {
+#define SQLITE_OK           0   /* Successful result */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* An internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite_interrupt() */
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* (Internal Only) Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* Database lock protocol error */
+#define SQLITE_EMPTY       16   /* (Internal Only) Database table is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* Too much data for one row of a table */
+#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_ROW         100  /* sqlite_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite_step() has finished executing */
+} {
+Many SQLite functions return an integer result code from the set shown
+above in order to indicates success or failure.
+
+The result codes above are the only ones returned by SQLite in its
+default configuration.  However, the sqlite3_extended_result_codes()
+API can be used to set a database connectoin to return more detailed
+result codes.  See the documentation on sqlite3_extended_result_codes()
+or extended-result-codes for additional information.
+}
+
+api {} {
+  int sqlite3_extended_result_codes(sqlite3*, int onoff);
+} {
+This routine enables or disabled extended-result-codes feature.
+By default, SQLite API routines return one of only 26 integer
+result codes described at result-codes.  When extended result codes
+are enabled by this routine, the repetoire of result codes can be
+much larger and can (hopefully) provide more detailed information
+about the cause of an error.
+
+The second argument is a boolean value that turns extended result
+codes on and off.  Extended result codes are off by default for
+backwards compatibility with older versions of SQLite.
+}
+
+api {} {
+  const char *sqlite3_libversion(void);
+} {
+  Return a pointer to a string which contains the version number of
+  the library.  The same string is available in the global
+  variable named "sqlite3_version".  This interface is provided since
+  windows is unable to access global variables in DLLs.
+}
+
+api {} {
+  void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
+} {
+  Aggregate functions use this routine to allocate
+  a structure for storing their state.  The first time this routine
+  is called for a particular aggregate, a new structure of size nBytes
+  is allocated, zeroed, and returned.  On subsequent calls (for the
+  same aggregate instance) the same buffer is returned.  The implementation
+  of the aggregate can use the returned buffer to accumulate data.
+
+  The buffer is freed automatically by SQLite when the query that
+  invoked the aggregate function terminates.
+}
+
+api {} {
+  int sqlite3_aggregate_count(sqlite3_context*);
+} {
+  This function is deprecated.   It continues to exist so as not to
+  break any legacy code that might happen to use it.  But it should not
+  be used in any new code.
+
+  In order to encourage people to not use this function, we are not going
+  to tell you what it does.
+}
+
+api {} {
+  int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+  int sqlite3_bind_double(sqlite3_stmt*, int, double);
+  int sqlite3_bind_int(sqlite3_stmt*, int, int);
+  int sqlite3_bind_int64(sqlite3_stmt*, int, long long int);
+  int sqlite3_bind_null(sqlite3_stmt*, int);
+  int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+  int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+  #define SQLITE_STATIC      ((void(*)(void *))0)
+  #define SQLITE_TRANSIENT   ((void(*)(void *))-1)
+} {
+ In the SQL strings input to sqlite3_prepare_v2() and sqlite3_prepare16_v2(),
+ one or more literals can be replace by a parameter "?" or "?NNN"
+ or ":AAA" or "@AAA" or "\$VVV" where NNN is an integer literal,
+ AAA is an alphanumeric identifier and VVV is a variable name according
+ to the syntax rules of the TCL programming language.
+ The values of these parameters (also called "host parameter names")
+ can be set using the sqlite3_bind_*() routines.
+
+ The first argument to the sqlite3_bind_*() routines always is a pointer
+ to the sqlite3_stmt structure returned from sqlite3_prepare_v2().  The second
+ argument is the index of the parameter to be set.  The first parameter has
+ an index of 1. When the same named parameter is used more than once, second
+ and subsequent
+ occurrences have the same index as the first occurrence.  The index for
+ named parameters can be looked up using the
+ sqlite3_bind_parameter_name() API if desired.  The index for "?NNN"
+ parametes is the value of NNN.  The NNN value must be between 1 and 999.
+
+
+ The third argument is the value to bind to the parameter.
+
+ In those
+ routines that have a fourth argument, its value is the number of bytes
+ in the parameter.  To be clear: the value is the number of bytes in the
+ string, not the number of characters.  The number
+ of bytes does not include the zero-terminator at the end of strings.
+ If the fourth parameter is negative, the length of the string is
+ number of bytes up to the first zero terminator.
+
+ The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
+ sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
+ text after SQLite has finished with it.  If the fifth argument is the
+ special value SQLITE_STATIC, then the library assumes that the information
+ is in static, unmanaged space and does not need to be freed.  If the
+ fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its
+ own private copy of the data immediately, before the sqlite3_bind_*()
+ routine returns.
+
+ The sqlite3_bind_*() routines must be called after
+ sqlite3_prepare_v2() or sqlite3_reset() and before sqlite3_step().
+ Bindings are not cleared by the sqlite3_reset() routine.
+ Unbound parameters are interpreted as NULL.
+
+ These routines return SQLITE_OK on success or an error code if
+ anything goes wrong.  SQLITE_RANGE is returned if the parameter
+ index is out of range.  SQLITE_NOMEM is returned if malloc fails.
+ SQLITE_MISUSE is returned if these routines are called on a virtual
+ machine that is the wrong state or which has already been finalized.
+}
+
+api {} {
+  int sqlite3_bind_parameter_count(sqlite3_stmt*);
+} {
+  Return the number of parameters in the precompiled statement given as
+  the argument.
+}
+
+api {} {
+  const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int n);
+} {
+  Return the name of the n-th parameter in the precompiled statement.
+  Parameters of the form ":AAA" or "@AAA" or "\$VVV" have a name which is the
+  string ":AAA" or "@AAA" or "\$VVV".  
+  In other words, the initial ":" or "$" or "@"
+  is included as part of the name.
+  Parameters of the form "?" or "?NNN" have no name.
+
+  The first bound parameter has an index of 1, not 0.
+
+  If the value n is out of range or if the n-th parameter is nameless,
+  then NULL is returned.  The returned string is always in the
+  UTF-8 encoding even if the named parameter was originally specified
+  as UTF-16 in sqlite3_prepare16_v2().
+}
+
+api {} {
+  int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
+} {
+  Return the index of the parameter with the given name.
+  The name must match exactly.
+  If there is no parameter with the given name, return 0.
+  The string zName is always in the UTF-8 encoding.
+}
+
+api {} {
+  int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
+} {
+ This routine identifies a callback function that might be invoked
+ whenever an attempt is made to open a database table 
+ that another thread or process has locked.
+ If the busy callback is NULL, then SQLITE_BUSY is returned immediately
+ upon encountering the lock.
+ If the busy callback is not NULL, then the
+ callback will be invoked with two arguments.  The
+ first argument to the handler is a copy of the void* pointer which
+ is the third argument to this routine.  The second argument to
+ the handler is the number of times that the busy handler has
+ been invoked for this locking event. If the
+ busy callback returns 0, then no additional attempts are made to
+ access the database and SQLITE_BUSY is returned.
+ If the callback returns non-zero, then another attempt is made to open the
+ database for reading and the cycle repeats.
+
+ The presence of a busy handler does not guarantee that
+ it will be invoked when there is lock contention.
+ If SQLite determines that invoking the busy handler could result in
+ a deadlock, it will return SQLITE_BUSY instead.
+ Consider a scenario where one process is holding a read lock that
+ it is trying to promote to a reserved lock and
+ a second process is holding a reserved lock that it is trying
+ to promote to an exclusive lock.  The first process cannot proceed
+ because it is blocked by the second and the second process cannot
+ proceed because it is blocked by the first.  If both processes
+ invoke the busy handlers, neither will make any progress.  Therefore,
+ SQLite returns SQLITE_BUSY for the first process, hoping that this
+ will induce the first process to release its read lock and allow
+ the second process to proceed.
+
+ The default busy callback is NULL.
+
+ Sqlite is re-entrant, so the busy handler may start a new query. 
+ (It is not clear why anyone would every want to do this, but it
+ is allowed, in theory.)  But the busy handler may not close the
+ database.  Closing the database from a busy handler will delete 
+ data structures out from under the executing query and will 
+ probably result in a coredump.
+
+ There can only be a single busy handler defined for each database
+ connection.  Setting a new busy handler clears any previous one.
+ Note that calling sqlite3_busy_timeout() will also set or clear
+ the busy handler.
+}
+
+api {} {
+  int sqlite3_busy_timeout(sqlite3*, int ms);
+} {
+ This routine sets a busy handler that sleeps for a while when a
+ table is locked.  The handler will sleep multiple times until 
+ at least "ms" milliseconds of sleeping have been done.  After
+ "ms" milliseconds of sleeping, the handler returns 0 which
+ causes sqlite3_exec() to return SQLITE_BUSY.
+
+ Calling this routine with an argument less than or equal to zero
+ turns off all busy handlers.
+
+ There can only be a single busy handler for a particular database
+ connection.  If another busy handler was defined  
+ (using sqlite3_busy_handler()) prior to calling
+ this routine, that other busy handler is cleared.
+}
+
+api {} {
+  int sqlite3_changes(sqlite3*);
+} {
+ This function returns the number of database rows that were changed
+ (or inserted or deleted) by the most recently completed
+ INSERT, UPDATE, or DELETE
+ statement.  Only changes that are directly specified by the INSERT,
+ UPDATE, or DELETE statement are counted.  Auxiliary changes caused by
+ triggers are not counted.  Use the sqlite3_total_changes() function
+ to find the total number of changes including changes caused by triggers.
+
+ Within the body of a trigger, the sqlite3_changes() function does work
+ to report the number of rows that were changed for the most recently
+ completed INSERT, UPDATE, or DELETE statement within the trigger body.
+
+ SQLite implements the command "DELETE FROM table" without a WHERE clause
+ by dropping and recreating the table.  (This is much faster than going
+ through and deleting individual elements from the table.)  Because of
+ this optimization, the change count for "DELETE FROM table" will be
+ zero regardless of the number of elements that were originally in the
+ table. To get an accurate count of the number of rows deleted, use
+ "DELETE FROM table WHERE 1" instead.
+}
+
+api {} {
+  int sqlite3_total_changes(sqlite3*);
+} {
+  This function returns the total number of database rows that have
+  be modified, inserted, or deleted since the database connection was
+  created using sqlite3_open().  All changes are counted, including
+  changes by triggers and changes to TEMP and auxiliary databases.
+  Except, changes to the SQLITE_MASTER table (caused by statements 
+  such as CREATE TABLE) are not counted.  Nor are changes counted when
+  an entire table is deleted using DROP TABLE.
+
+  See also the sqlite3_changes() API.
+
+  SQLite implements the command "DELETE FROM table" without a WHERE clause
+  by dropping and recreating the table.  (This is much faster than going
+  through and deleting individual elements form the table.)  Because of
+  this optimization, the change count for "DELETE FROM table" will be
+  zero regardless of the number of elements that were originally in the
+  table. To get an accurate count of the number of rows deleted, use
+  "DELETE FROM table WHERE 1" instead.
+}
+
+api {} {
+  int sqlite3_close(sqlite3*);
+} {
+  Call this function with a pointer to a structure that was previously
+  returned from sqlite3_open() or sqlite3_open16()
+  and the corresponding database will by closed.
+
+  SQLITE_OK is returned if the close is successful.  If there are
+  prepared statements that have not been finalized, then SQLITE_BUSY
+  is returned.  SQLITE_ERROR might be returned if the argument is not
+  a valid connection pointer returned by sqlite3_open() or if the connection
+  pointer has been closed previously.
+}
+
+api {} {
+const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
+int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
+double sqlite3_column_double(sqlite3_stmt*, int iCol);
+int sqlite3_column_int(sqlite3_stmt*, int iCol);
+long long int sqlite3_column_int64(sqlite3_stmt*, int iCol);
+const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
+const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
+int sqlite3_column_type(sqlite3_stmt*, int iCol);
+#define SQLITE_INTEGER  1
+#define SQLITE_FLOAT    2
+#define SQLITE_TEXT     3
+#define SQLITE_BLOB     4
+#define SQLITE_NULL     5
+} {
+ These routines return information about the information
+ in a single column of the current result row of a query.  In every
+ case the first argument is a pointer to the SQL statement that is being
+ executed (the sqlite_stmt* that was returned from sqlite3_prepare_v2()) and
+ the second argument is the index of the column for which information 
+ should be returned.  iCol is zero-indexed.  The left-most column has an
+ index of 0.
+
+ If the SQL statement is not currently point to a valid row, or if the
+ the column index is out of range, the result is undefined.
+
+ The sqlite3_column_type() routine returns the initial data type
+ of the result column.  The returned value is one of SQLITE_INTEGER,
+ SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL.  The value
+ returned by sqlite3_column_type() is only meaningful if no type
+ conversions have occurred as described below.  After a type conversion,
+ the value returned by sqlite3_column_type() is undefined.  Future
+ versions of SQLite may change the behavior of sqlite3_column_type()
+ following a type conversion.
+
+ If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() 
+ routine returns the number of bytes in that BLOB or string.
+ If the result is a UTF-16 string, then sqlite3_column_bytes() converts
+ the string to UTF-8 and then returns the number of bytes.
+ If the result is a numeric value then sqlite3_column_bytes() uses
+ sqlite3_snprintf() to convert that value to a UTF-8 string and returns
+ the number of bytes in that string.
+ The value returned does
+ not include the \\000 terminator at the end of the string.  
+
+ The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
+ but leaves the result in UTF-16 instead of UTF-8.  
+ The \\u0000 terminator is not included in this count.
+
+ These routines attempt to convert the value where appropriate.  For
+ example, if the internal representation is FLOAT and a text result
+ is requested, sqlite3_snprintf() is used internally to do the conversion
+ automatically.  The following table details the conversions that
+ are applied:
+
+<blockquote>
+<table border="1">
+<tr><th>Internal Type</th><th>Requested Type</th><th>Conversion</th></tr>
+<tr><td> NULL    </td><td> INTEGER</td><td>Result is 0</td></tr>
+<tr><td> NULL </td><td>    FLOAT </td><td> Result is 0.0</td></tr>
+<tr><td> NULL </td><td>    TEXT </td><td>  Result is NULL pointer</td></tr>
+<tr><td> NULL </td><td>    BLOB </td><td>  Result is NULL pointer</td></tr>
+<tr><td> INTEGER </td><td> FLOAT </td><td> Convert from integer to float</td></tr>
+<tr><td> INTEGER </td><td> TEXT </td><td>  ASCII rendering of the integer</td></tr>
+<tr><td> INTEGER </td><td> BLOB </td><td>  Same as for INTEGER->TEXT</td></tr>
+<tr><td> FLOAT </td><td>   INTEGER</td><td>Convert from float to integer</td></tr>
+<tr><td> FLOAT </td><td>   TEXT </td><td>  ASCII rendering of the float</td></tr>
+<tr><td> FLOAT </td><td>   BLOB </td><td>  Same as FLOAT->TEXT</td></tr>
+<tr><td> TEXT </td><td>    INTEGER</td><td>Use atoi()</td></tr>
+<tr><td> TEXT </td><td>    FLOAT </td><td> Use atof()</td></tr>
+<tr><td> TEXT </td><td>    BLOB </td><td>  No change</td></tr>
+<tr><td> BLOB </td><td>    INTEGER</td><td>Convert to TEXT then use atoi()</td></tr>
+<tr><td> BLOB </td><td>    FLOAT </td><td> Convert to TEXT then use atof()</td></tr>
+<tr><td> BLOB </td><td>    TEXT </td><td>  Add a \\000 terminator if needed</td></tr>
+</table>
+</blockquote>
+
+  Note that when type conversions occur, pointers returned by prior
+  calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
+  sqlite3_column_text16() may be invalidated. 
+  Type conversions and pointer invalidations might occur
+  in the following cases:
+
+  <ul>
+  <li><p>
+  The initial content is a BLOB and sqlite3_column_text() 
+  or sqlite3_column_text16()
+  is called.  A zero-terminator might need to be added to the string.
+  </p></li>
+  <li><p>
+  The initial content is UTF-8 text and sqlite3_column_bytes16() or
+  sqlite3_column_text16() is called.  The content must be converted to UTF-16.
+  </p></li>
+  <li><p>
+  The initial content is UTF-16 text and sqlite3_column_bytes() or
+  sqlite3_column_text() is called.  The content must be converted to UTF-8.
+  </p></li>
+  </ul>
+
+  Conversions between UTF-16be and UTF-16le 
+  are always done in place and do
+  not invalidate a prior pointer, though of course the content of the buffer
+  that the prior pointer points to will have been modified.  Other kinds
+  of conversion are done in place when it is possible, but sometime it is
+  not possible and in those cases prior pointers are invalidated.  
+
+  The safest and easiest to remember policy is to invoke these routines
+  in one of the following ways:
+
+  <ul>
+  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
+  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
+  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
+  </ul>
+
+  In other words, you should call sqlite3_column_text(), sqlite3_column_blob(),
+  or sqlite3_column_text16() first to force the result into the desired
+  format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to
+  find the size of the result.  Do not mix call to sqlite3_column_text() or
+  sqlite3_column_blob() with calls to sqlite3_column_bytes16().  And do not
+  mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes().
+}
+
+api {} {
+int sqlite3_column_count(sqlite3_stmt *pStmt);
+} {
+ Return the number of columns in the result set returned by the prepared
+ SQL statement. This routine returns 0 if pStmt is an SQL statement
+ that does not return data (for example an UPDATE).
+
+ See also sqlite3_data_count().
+}
+
+api {} {
+const char *sqlite3_column_decltype(sqlite3_stmt *, int i);
+const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+} {
+ The first argument is a prepared SQL statement. If this statement
+ is a SELECT statement, the Nth column of the returned result set 
+ of the SELECT is a table column then the declared type of the table
+ column is returned. If the Nth column of the result set is not a table
+ column, then a NULL pointer is returned. The returned string is 
+ UTF-8 encoded for sqlite3_column_decltype() and UTF-16 encoded
+ for sqlite3_column_decltype16(). For example, in the database schema:
+
+ <blockquote><pre>
+ CREATE TABLE t1(c1 INTEGER);
+ </pre></blockquote>
+
+ And the following statement compiled:
+
+ <blockquote><pre>
+ SELECT c1 + 1, c1 FROM t1;
+ </pre></blockquote>
+
+ Then this routine would return the string "INTEGER" for the second
+ result column (i==1), and a NULL pointer for the first result column
+ (i==0).
+
+ If the following statements were compiled then this routine would
+ return "INTEGER" for the first (only) result column.
+
+ <blockquote><pre>
+ SELECT (SELECT c1) FROM t1;
+ SELECT (SELECT c1 FROM t1);
+ SELECT c1 FROM (SELECT c1 FROM t1);
+ SELECT * FROM (SELECT c1 FROM t1);
+ SELECT * FROM (SELECT * FROM t1);
+ </pre></blockquote>
+}
+
+api {} {
+  int sqlite3_table_column_metadata(
+    sqlite3 *db,                /* Connection handle */
+    const char *zDbName,        /* Database name or NULL */
+    const char *zTableName,     /* Table name */
+    const char *zColumnName,    /* Column name */
+    char const **pzDataType,    /* OUTPUT: Declared data type */
+    char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
+    int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
+    int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
+    int *pAutoinc               /* OUTPUT: True if colums is auto-increment */
+  );
+} {
+ This routine is used to obtain meta information about a specific column of a
+ specific database table accessible using the connection handle passed as the
+ first function argument.
+
+ The column is identified by the second, third and fourth parameters to 
+ this function. The second parameter is either the name of the database
+ (i.e. "main", "temp" or an attached database) containing the specified
+ table or NULL. If it is NULL, then all attached databases are searched
+ for the table using the same algorithm as the database engine uses to 
+ resolve unqualified table references.
+
+ The third and fourth parameters to this function are the table and column 
+ name of the desired column, respectively. Neither of these parameters 
+ may be NULL.
+
+ Meta information is returned by writing to the memory locations passed as
+ the 5th and subsequent parameters to this function. Any of these 
+ arguments may be NULL, in which case the corresponding element of meta 
+ information is ommitted.
+
+<pre>
+ Parameter     Output Type      Description
+ -----------------------------------
+   5th         const char*      Declared data type 
+   6th         const char*      Name of the columns default collation sequence 
+   7th         int              True if the column has a NOT NULL constraint
+   8th         int              True if the column is part of the PRIMARY KEY
+   9th         int              True if the column is AUTOINCREMENT
+</pre>
+
+ The memory pointed to by the character pointers returned for the 
+ declaration type and collation sequence is valid only until the next 
+ call to any sqlite API function.
+
+ This function may load one or more schemas from database files. If an
+ error occurs during this process, or if the requested table or column
+ cannot be found, an SQLITE error code is returned and an error message
+ left in the database handle (to be retrieved using sqlite3_errmsg()).
+ Specifying an SQL view instead of a table as the third argument is also
+ considered an error.
+
+ If the specified column is "rowid", "oid" or "_rowid_" and an 
+ INTEGER PRIMARY KEY column has been explicitly declared, then the output 
+ parameters are set for the explicitly declared column. If there is no
+ explicitly declared IPK column, then the data-type is "INTEGER", the
+ collation sequence "BINARY" and the primary-key flag is set. Both
+ the not-null and auto-increment flags are clear.
+
+ This API is only available if the library was compiled with the
+ SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined.
+}
+
+api {} {
+const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N);
+const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N);
+} {
+If the Nth column returned by statement pStmt is a column reference,
+these functions may be used to access the name of the database (either 
+"main", "temp" or the name of an attached database) that contains
+the column. If the Nth column is not a column reference, NULL is
+returned.
+
+See the description of function sqlite3_column_decltype() for a
+description of exactly which expressions are considered column references.
+
+Function sqlite3_column_database_name() returns a pointer to a UTF-8
+encoded string. sqlite3_column_database_name16() returns a pointer
+to a UTF-16 encoded string. 
+}
+
+api {} {
+const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N);
+const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N);
+} {
+If the Nth column returned by statement pStmt is a column reference,
+these functions may be used to access the schema name of the referenced 
+column in the database schema. If the Nth column is not a column 
+reference, NULL is returned.
+
+See the description of function sqlite3_column_decltype() for a
+description of exactly which expressions are considered column references.
+
+Function sqlite3_column_origin_name() returns a pointer to a UTF-8
+encoded string. sqlite3_column_origin_name16() returns a pointer
+to a UTF-16 encoded string. 
+}
+
+api {} {
+const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N);
+const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N);
+} {
+If the Nth column returned by statement pStmt is a column reference, 
+these functions may be used to access the name of the table that 
+contains the column.  If the Nth column is not a column reference, 
+NULL is returned.
+
+See the description of function sqlite3_column_decltype() for a
+description of exactly which expressions are considered column references.
+
+Function sqlite3_column_table_name() returns a pointer to a UTF-8
+encoded string. sqlite3_column_table_name16() returns a pointer
+to a UTF-16 encoded string. 
+}
+
+api {} {
+const char *sqlite3_column_name(sqlite3_stmt*,int);
+const void *sqlite3_column_name16(sqlite3_stmt*,int);
+} {
+ The first argument is a prepared SQL statement. This function returns
+ the column heading for the Nth column of that statement, where N is the
+ second function argument.  The string returned is UTF-8 for
+ sqlite3_column_name() and UTF-16 for sqlite3_column_name16().
+}
+
+api {} {
+void *sqlite3_commit_hook(sqlite3*, int(*xCallback)(void*), void *pArg);
+} {
+ <i>Experimental</i>
+
+ Register a callback function to be invoked whenever a new transaction
+ is committed.  The pArg argument is passed through to the callback.
+ callback.  If the callback function returns non-zero, then the commit
+ is converted into a rollback.
+
+ If another function was previously registered, its pArg value is returned.
+ Otherwise NULL is returned.
+
+ Registering a NULL function disables the callback.  Only a single commit
+ hook callback can be registered at a time.
+}
+
+api {} {
+int sqlite3_complete(const char *sql);
+int sqlite3_complete16(const void *sql);
+} {
+ These functions return true if the given input string comprises
+ one or more complete SQL statements.
+ The argument must be a nul-terminated UTF-8 string for sqlite3_complete()
+ and a nul-terminated UTF-16 string for sqlite3_complete16().
+
+ These routines do not check to see if the SQL statement is well-formed.
+ They only check to see that the statement is terminated by a semicolon
+ that is not part of a string literal and is not inside
+ the body of a trigger.
+} {}
+
+api {} {
+int sqlite3_create_collation(
+  sqlite3*, 
+  const char *zName, 
+  int pref16, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+int sqlite3_create_collation16(
+  sqlite3*, 
+  const char *zName, 
+  int pref16, 
+  void*,
+  int(*xCompare)(void*,int,const void*,int,const void*)
+);
+#define SQLITE_UTF8     1
+#define SQLITE_UTF16BE  2
+#define SQLITE_UTF16LE  3
+#define SQLITE_UTF16    4
+} {
+ These two functions are used to add new collation sequences to the
+ sqlite3 handle specified as the first argument. 
+
+ The name of the new collation sequence is specified as a UTF-8 string
+ for sqlite3_create_collation() and a UTF-16 string for
+ sqlite3_create_collation16(). In both cases the name is passed as the
+ second function argument.
+
+ The third argument must be one of the constants SQLITE_UTF8,
+ SQLITE_UTF16LE or SQLITE_UTF16BE, indicating that the user-supplied
+ routine expects to be passed pointers to strings encoded using UTF-8,
+ UTF-16 little-endian or UTF-16 big-endian respectively.  The
+ SQLITE_UTF16 constant indicates that text strings are expected in
+ UTF-16 in the native byte order of the host machine.
+
+ A pointer to the user supplied routine must be passed as the fifth
+ argument. If it is NULL, this is the same as deleting the collation
+ sequence (so that SQLite cannot call it anymore). Each time the user
+ supplied function is invoked, it is passed a copy of the void* passed as
+ the fourth argument to sqlite3_create_collation() or
+ sqlite3_create_collation16() as its first argument.
+
+ The remaining arguments to the user-supplied routine are two strings,
+ each represented by a [length, data] pair and encoded in the encoding
+ that was passed as the third argument when the collation sequence was
+ registered. The user routine should return negative, zero or positive if
+ the first string is less than, equal to, or greater than the second
+ string. i.e. (STRING1 - STRING2).
+}
+
+api {} {
+int sqlite3_collation_needed(
+  sqlite3*, 
+  void*, 
+  void(*)(void*,sqlite3*,int eTextRep,const char*)
+);
+int sqlite3_collation_needed16(
+  sqlite3*, 
+  void*,
+  void(*)(void*,sqlite3*,int eTextRep,const void*)
+);
+} {
+ To avoid having to register all collation sequences before a database
+ can be used, a single callback function may be registered with the
+ database handle to be called whenever an undefined collation sequence is
+ required.
+
+ If the function is registered using the sqlite3_collation_needed() API,
+ then it is passed the names of undefined collation sequences as strings
+ encoded in UTF-8. If sqlite3_collation_needed16() is used, the names
+ are passed as UTF-16 in machine native byte order. A call to either
+ function replaces any existing callback.
+
+ When the user-function is invoked, the first argument passed is a copy
+ of the second argument to sqlite3_collation_needed() or
+ sqlite3_collation_needed16(). The second argument is the database
+ handle. The third argument is one of SQLITE_UTF8, SQLITE_UTF16BE or
+ SQLITE_UTF16LE, indicating the most desirable form of the collation
+ sequence function required. The fourth argument is the name of the
+ required collation sequence.
+
+ The collation sequence is returned to SQLite by a collation-needed
+ callback using the sqlite3_create_collation() or
+ sqlite3_create_collation16() APIs, described above.
+}
+
+api {} {
+int sqlite3_create_function(
+  sqlite3 *,
+  const char *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pUserData,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+int sqlite3_create_function16(
+  sqlite3*,
+  const void *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pUserData,
+  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xFinal)(sqlite3_context*)
+);
+#define SQLITE_UTF8     1
+#define SQLITE_UTF16    2
+#define SQLITE_UTF16BE  3
+#define SQLITE_UTF16LE  4
+#define SQLITE_ANY      5
+} {
+ These two functions are used to add SQL functions or aggregates
+ implemented in C. The
+ only difference between these two routines is that the second argument, the
+ name of the (scalar) function or aggregate, is encoded in UTF-8 for
+ sqlite3_create_function() and UTF-16 for sqlite3_create_function16().
+ The length of the name is limited to 255 bytes, exclusive of the 
+ zero-terminator.  Note that the name length limit is in bytes, not
+ characters.  Any attempt to create a function with a longer name
+ will result in an SQLITE_ERROR error.
+ 
+ The first argument is the database handle that the new function or
+ aggregate is to be added to. If a single program uses more than one
+ database handle internally, then user functions or aggregates must 
+ be added individually to each database handle with which they will be
+ used.
+
+ The third argument is the number of arguments that the function or
+ aggregate takes. If this argument is -1 then the function or
+ aggregate may take any number of arguments.  The maximum number
+ of arguments to a new SQL function is 127.  A number larger than
+ 127 for the third argument results in an SQLITE_ERROR error.
+
+ The fourth argument, eTextRep, specifies what type of text arguments
+ this function prefers to receive.  Any function should be able to work
+ work with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
+ more efficient with one representation than another.  Users are allowed
+ to specify separate implementations for the same function which are called
+ depending on the text representation of the arguments.  The the implementation
+ which provides the best match is used.  If there is only a single
+ implementation which does not care what text representation is used,
+ then the fourth argument should be SQLITE_ANY.
+
+ The fifth argument is an arbitrary pointer.  The function implementations
+ can gain access to this pointer using the sqlite_user_data() API.
+
+ The sixth, seventh and  eighth argumens, xFunc, xStep and xFinal, are
+ pointers to user implemented C functions that implement the user
+ function or aggregate. A scalar function requires an implementation of
+ the xFunc callback only, NULL pointers should be passed as the xStep
+ and xFinal arguments. An aggregate function requires an implementation
+ of xStep and xFinal, and NULL should be passed for xFunc. To delete an
+ existing user function or aggregate, pass NULL for all three function
+ callbacks. Specifying an inconstant set of callback values, such as an
+ xFunc and an xFinal, or an xStep but no xFinal, results in an SQLITE_ERROR
+ return.
+}
+
+api {} {
+int sqlite3_data_count(sqlite3_stmt *pStmt);
+} {
+ Return the number of values in the current row of the result set.
+
+ After a call to sqlite3_step() that returns SQLITE_ROW, this routine
+ will return the same value as the sqlite3_column_count() function.
+ After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or
+ error code, or before sqlite3_step() has been called on a 
+ prepared SQL statement, this routine returns zero.
+}
+
+api {} {
+int sqlite3_errcode(sqlite3 *db);
+} {
+ Return the error code for the most recent failed sqlite3_* API call associated
+ with sqlite3 handle 'db'.  If a prior API call failed but the most recent
+ API call succeeded, the return value from this routine is undefined. 
+
+ Calls to many sqlite3_* functions set the error code and string returned
+ by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16()
+ (overwriting the previous values). Note that calls to sqlite3_errcode(),
+ sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the
+ results of future invocations.  Calls to API routines that do not return
+ an error code (examples: sqlite3_data_count() or sqlite3_mprintf()) do
+ not change the error code returned by this routine.
+
+ Assuming no other intervening sqlite3_* API calls are made, the error
+ code returned by this function is associated with the same error as
+ the strings returned by sqlite3_errmsg() and sqlite3_errmsg16().
+} {}
+
+api {} {
+const char *sqlite3_errmsg(sqlite3*);
+const void *sqlite3_errmsg16(sqlite3*);
+} {
+ Return a pointer to a UTF-8 encoded string (sqlite3_errmsg)
+ or a UTF-16 encoded string (sqlite3_errmsg16) describing in English the
+ error condition for the most recent sqlite3_* API call. The returned
+ string is always terminated by an 0x00 byte.
+
+ The string "not an error" is returned when the most recent API call was
+ successful.
+}
+
+api {} {
+int sqlite3_exec(
+  sqlite3*,                     /* An open database */
+  const char *sql,              /* SQL to be executed */
+  sqlite_callback,              /* Callback function */
+  void *,                       /* 1st argument to callback function */
+  char **errmsg                 /* Error msg written here */
+);
+} {
+ A function to executes one or more statements of SQL.
+
+ If one or more of the SQL statements are queries, then
+ the callback function specified by the 3rd argument is
+ invoked once for each row of the query result.  This callback
+ should normally return 0.  If the callback returns a non-zero
+ value then the query is aborted, all subsequent SQL statements
+ are skipped and the sqlite3_exec() function returns the SQLITE_ABORT.
+
+ The 1st argument is an arbitrary pointer that is passed
+ to the callback function as its first argument.
+
+ The 2nd argument to the callback function is the number of
+ columns in the query result.  The 3rd argument to the callback
+ is an array of strings holding the values for each column.
+ The 4th argument to the callback is an array of strings holding
+ the names of each column.
+
+ The callback function may be NULL, even for queries.  A NULL
+ callback is not an error.  It just means that no callback
+ will be invoked.
+
+ If an error occurs while parsing or evaluating the SQL (but
+ not while executing the callback) then an appropriate error
+ message is written into memory obtained from malloc() and
+ *errmsg is made to point to that message.  The calling function
+ is responsible for freeing the memory that holds the error
+ message.   Use sqlite3_free() for this.  If errmsg==NULL,
+ then no error message is ever written.
+
+ The return value is is SQLITE_OK if there are no errors and
+ some other return code if there is an error.  The particular
+ return value depends on the type of error. 
+
+ If the query could not be executed because a database file is
+ locked or busy, then this function returns SQLITE_BUSY.  (This
+ behavior can be modified somewhat using the sqlite3_busy_handler()
+ and sqlite3_busy_timeout() functions.)
+} {}
+
+api {} {
+int sqlite3_finalize(sqlite3_stmt *pStmt);
+} {
+ The sqlite3_finalize() function is called to delete a prepared
+ SQL statement obtained by a previous call to sqlite3_prepare(),
+ sqlite3_prepare_v2(), sqlite3_prepare16(), or sqlite3_prepare16_v2().
+ If the statement was executed successfully, or
+ not executed at all, then SQLITE_OK is returned. If execution of the
+ statement failed then an error code is returned. 
+
+ After sqlite_finalize() has been called, the statement handle is
+ invalidated. Passing it to any other SQLite function may cause a
+ crash.
+
+ All prepared statements must finalized before sqlite3_close() is
+ called or else the close will fail with a return code of SQLITE_BUSY.
+
+ This routine can be called at any point during the execution of the
+ virtual machine.  If the virtual machine has not completed execution
+ when this routine is called, that is like encountering an error or
+ an interrupt.  (See sqlite3_interrupt().)  Incomplete updates may be
+ rolled back and transactions canceled,  depending on the circumstances,
+ and the result code returned will be SQLITE_ABORT.
+}
+
+api {} {
+void *sqlite3_malloc(int);
+void *sqlite3_realloc(void*, int);
+void sqlite3_free(void*);
+} {
+ These routines provide access to the memory allocator used by SQLite.
+ Depending on how SQLite has been compiled and the OS-layer backend,
+ the memory allocator used by SQLite might be the standard system
+ malloc()/realloc()/free(), or it might be something different.  With
+ certain compile-time flags, SQLite will add wrapper logic around the
+ memory allocator to add memory leak and buffer overrun detection.  The
+ OS layer might substitute a completely different memory allocator.
+ Use these APIs to be sure you are always using the correct memory
+ allocator.
+ 
+ The sqlite3_free() API, not the standard free() from the system library,
+ should always be used to free the memory buffer returned by
+ sqlite3_mprintf() or sqlite3_vmprintf() and to free the error message
+ string returned by sqlite3_exec().  Using free() instead of sqlite3_free()
+ might accidentally work on some systems and build configurations but 
+ will fail on others.
+
+ Compatibility Note:  Prior to version 3.4.0, the sqlite3_free API
+ was prototyped to take a <tt>char*</tt> parameter rather than 
+ <tt>void*</tt>.  Like this:
+<blockquote><pre>
+void sqlite3_free(char*);
+</pre></blockquote>
+ The change to using <tt>void*</tt> might cause warnings when 
+ compiling older code against
+ newer libraries, but everything should still work correctly.
+}
+
+api {} {
+int sqlite3_get_table(
+  sqlite3*,              /* An open database */
+  const char *sql,       /* SQL to be executed */
+  char ***resultp,       /* Result written to a char *[]  that this points to */
+  int *nrow,             /* Number of result rows written here */
+  int *ncolumn,          /* Number of result columns written here */
+  char **errmsg          /* Error msg written here */
+);
+void sqlite3_free_table(char **result);
+} {
+ This next routine is really just a wrapper around sqlite3_exec().
+ Instead of invoking a user-supplied callback for each row of the
+ result, this routine remembers each row of the result in memory
+ obtained from malloc(), then returns all of the result after the
+ query has finished. 
+
+ As an example, suppose the query result where this table:
+
+ <pre>
+        Name        | Age
+        -----------------------
+        Alice       | 43
+        Bob         | 28
+        Cindy       | 21
+ </pre>
+
+ If the 3rd argument were &azResult then after the function returns
+ azResult will contain the following data:
+
+ <pre>
+        azResult[0] = "Name";
+        azResult[1] = "Age";
+        azResult[2] = "Alice";
+        azResult[3] = "43";
+        azResult[4] = "Bob";
+        azResult[5] = "28";
+        azResult[6] = "Cindy";
+        azResult[7] = "21";
+ </pre>
+
+ Notice that there is an extra row of data containing the column
+ headers.  But the *nrow return value is still 3.  *ncolumn is
+ set to 2.  In general, the number of values inserted into azResult
+ will be ((*nrow) + 1)*(*ncolumn).
+
+ After the calling function has finished using the result, it should 
+ pass the result data pointer to sqlite3_free_table() in order to 
+ release the memory that was malloc-ed.  Because of the way the 
+ malloc() happens, the calling function must not try to call 
+ malloc() directly.  Only sqlite3_free_table() is able to release 
+ the memory properly and safely.
+
+ The return value of this routine is the same as from sqlite3_exec().
+}
+
+api {sqlite3_interrupt} {
+ void sqlite3_interrupt(sqlite3*);
+} {
+ This function causes any pending database operation to abort and
+ return at its earliest opportunity.  This routine is typically
+ called in response to a user action such as pressing "Cancel"
+ or Ctrl-C where the user wants a long query operation to halt
+ immediately.
+} {}
+
+api {} {
+long long int sqlite3_last_insert_rowid(sqlite3*);
+} {
+ Each entry in an SQLite table has a unique integer key called the "rowid".
+ The rowid is always available as an undeclared column
+ named ROWID, OID, or _ROWID_.
+ If the table has a column of type INTEGER PRIMARY KEY then that column
+ is another an alias for the rowid.
+
+ This routine
+ returns the rowid of the most recent INSERT into the database
+ from the database connection given in the first argument.  If
+ no inserts have ever occurred on this database connection, zero
+ is returned.
+
+ If an INSERT occurs within a trigger, then the rowid of the
+ inserted row is returned by this routine as long as the trigger
+ is running.  But once the trigger terminates, the value returned
+ by this routine reverts to the last value inserted before the
+ trigger fired.
+} {}
+
+api {} {
+char *sqlite3_mprintf(const char*,...);
+char *sqlite3_vmprintf(const char*, va_list);
+} {
+ These routines are variants of the "sprintf()" from the
+ standard C library.  The resulting string is written into memory
+ obtained from malloc() so that there is never a possibility of buffer
+ overflow.  These routines also implement some additional formatting
+ options that are useful for constructing SQL statements.
+
+ The strings returned by these routines should be freed by calling
+ sqlite3_free().
+
+ All of the usual printf formatting options apply.  In addition, there
+ is a "%q" option.  %q works like %s in that it substitutes a null-terminated
+ string from the argument list.  But %q also doubles every '\\'' character.
+ %q is designed for use inside a string literal.  By doubling each '\\''
+ character it escapes that character and allows it to be inserted into
+ the string.
+
+ For example, so some string variable contains text as follows:
+
+ <blockquote><pre>
+  char *zText = "It's a happy day!";
+ </pre></blockquote>
+
+ One can use this text in an SQL statement as follows:
+
+ <blockquote><pre>
+  sqlite3_exec_printf(db, "INSERT INTO table VALUES('%q')",
+       callback1, 0, 0, zText);
+  </pre></blockquote>
+
+ Because the %q format string is used, the '\\'' character in zText
+ is escaped and the SQL generated is as follows:
+
+ <blockquote><pre>
+  INSERT INTO table1 VALUES('It''s a happy day!')
+ </pre></blockquote>
+
+ This is correct.  Had we used %s instead of %q, the generated SQL
+ would have looked like this:
+
+  <blockquote><pre>
+  INSERT INTO table1 VALUES('It's a happy day!');
+  </pre></blockquote>
+
+ This second example is an SQL syntax error.  As a general rule you
+ should always use %q instead of %s when inserting text into a string 
+ literal.
+} {}
+
+api {} {
+char *sqlite3_snprintf(int bufSize, char *buf, const char *zFormat, ...);
+} {
+  This routine works like "sprintf()", writing a formatted string into
+  the buf[].  However, no more than bufSize characters will be written
+  into buf[].  This routine returns a pointer to buf[].  If bufSize is
+  greater than zero, then buf[] is guaranteed to be zero-terminated.
+
+  This routine uses the same extended formatting options as
+  sqlite3_mprintf() and sqlite3_vmprintf().
+
+  Note these differences with the snprintf() function found in many
+  standard libraries:  (1)  sqlite3_snprintf() returns a pointer to the
+  buffer rather than the number of characters written.  (It would,
+  arguably, be more useful to return the number of characters written,
+  but we discovered that after the interface had been published and
+  are unwilling to break backwards compatibility.)  (2)  The order
+  of the bufSize and buf parameter is reversed from snprintf().  
+  And (3) sqlite3_snprintf() always writes a zero-terminator if bufSize
+  is positive.  
+
+  Please do not use the return value of this routine.  We may
+  decide to make the minor compatibility break and change this routine
+  to return the number of characters written rather than a pointer to
+  the buffer in a future minor version increment.
+}
+
+api {} {
+int sqlite3_open(
+  const char *filename,   /* Database filename (UTF-8) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+int sqlite3_open16(
+  const void *filename,   /* Database filename (UTF-16) */
+  sqlite3 **ppDb          /* OUT: SQLite db handle */
+);
+} {
+ Open the sqlite database file "filename".  The "filename" is UTF-8
+ encoded for sqlite3_open() and UTF-16 encoded in the native byte order
+ for sqlite3_open16().  An sqlite3* handle is returned in *ppDb, even
+ if an error occurs. If the database is opened (or created) successfully,
+ then SQLITE_OK is returned. Otherwise an error code is returned. The
+ sqlite3_errmsg() or sqlite3_errmsg16()  routines can be used to obtain
+ an English language description of the error.
+
+ If the database file does not exist, then a new database will be created
+ as needed.
+ The encoding for the database will be UTF-8 if sqlite3_open() is called and
+ UTF-16 if sqlite3_open16 is used.
+
+ Whether or not an error occurs when it is opened, resources associated
+ with the sqlite3* handle should be released by passing it to
+ sqlite3_close() when it is no longer required.
+
+ The returned sqlite3* can only be used in the same thread in which it
+ was created.  It is an error to call sqlite3_open() in one thread then
+ pass the resulting database handle off to another thread to use.  This
+ restriction is due to goofy design decisions (bugs?) in the way some
+ threading implementations interact with file locks.
+
+ Note to windows users:  The encoding used for the filename argument
+ of sqlite3_open() must be UTF-8, not whatever codepage is currently
+ defined.  Filenames containing international characters must be converted
+ to UTF-8 prior to passing them into sqlite3_open().
+}
+
+api {} {
+int sqlite3_prepare_v2(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nBytes,             /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16_v2(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nBytes,             /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+
+/* Legacy Interfaces */
+int sqlite3_prepare(
+  sqlite3 *db,            /* Database handle */
+  const char *zSql,       /* SQL statement, UTF-8 encoded */
+  int nBytes,             /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+int sqlite3_prepare16(
+  sqlite3 *db,            /* Database handle */
+  const void *zSql,       /* SQL statement, UTF-16 encoded */
+  int nBytes,             /* Length of zSql in bytes. */
+  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
+  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
+);
+} {
+ To execute an SQL query, it must first be compiled into a byte-code
+ program using one of these routines. 
+
+ The first argument "db" is an SQLite database handle. The second
+ argument "zSql" is the statement to be compiled, encoded as either
+ UTF-8 or UTF-16.  The sqlite3_prepare_v2()
+ interfaces uses UTF-8 and sqlite3_prepare16_v2()
+ use UTF-16. If the next argument, "nBytes", is less
+ than zero, then zSql is read up to the first nul terminator.  If
+ "nBytes" is not less than zero, then it is the length of the string zSql
+ in bytes (not characters).
+
+ *pzTail is made to point to the first byte past the end of the first
+ SQL statement in zSql.  This routine only compiles the first statement
+ in zSql, so *pzTail is left pointing to what remains uncompiled.
+
+ *ppStmt is left pointing to a compiled SQL statement that can be
+ executed using sqlite3_step().  Or if there is an error, *ppStmt may be
+ set to NULL.  If the input text contained no SQL (if the input is and
+ empty string or a comment) then *ppStmt is set to NULL.  The calling
+ procedure is responsible for deleting this compiled SQL statement
+ using sqlite3_finalize() after it has finished with it.
+
+ On success, SQLITE_OK is returned.  Otherwise an error code is returned.
+
+ The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
+ recommended for all new programs. The two older interfaces are retained
+ for backwards compatibility, but their use is discouraged.
+ In the "v2" interfaces, the prepared statement
+ that is returned (the sqlite3_stmt object) contains a copy of the original
+ SQL. This causes the sqlite3_step() interface to behave a differently in
+ two ways:
+
+ <ol>
+ <li>
+ If the database schema changes, instead of returning SQLITE_SCHEMA as it
+ always used to do, sqlite3_step() will automatically recompile the SQL
+ statement and try to run it again.  If the schema has changed in a way
+ that makes the statement no longer valid, sqlite3_step() will still
+ return SQLITE_SCHEMA.  But unlike the legacy behavior, SQLITE_SCHEMA is
+ now a fatal error.  Calling sqlite3_prepare_v2() again will not make the
+ error go away.  Note: use sqlite3_errmsg() to find the text of the parsing
+ error that results in an SQLITE_SCHEMA return.
+ </li>
+
+ <li>
+ When an error occurs, 
+ sqlite3_step() will return one of the detailed result-codes
+ like SQLITE_IOERR or SQLITE_FULL or SQLITE_SCHEMA directly. The
+ legacy behavior was that sqlite3_step() would only return a generic
+ SQLITE_ERROR code and you would have to make a second call to
+ sqlite3_reset() in order to find the underlying cause of the problem.
+ With the "v2" prepare interfaces, the underlying reason for the error is
+ returned directly.
+ </li>
+ </ol>
+}
+
+api {} {
+void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
+} {
+ <i>Experimental</i>
+
+ This routine configures a callback function - the progress callback - that
+ is invoked periodically during long running calls to sqlite3_exec(),
+ sqlite3_step() and sqlite3_get_table().
+ An example use for this API is to keep
+ a GUI updated during a large query.
+
+ The progress callback is invoked once for every N virtual machine opcodes,
+ where N is the second argument to this function. The progress callback
+ itself is identified by the third argument to this function. The fourth
+ argument to this function is a void pointer passed to the progress callback
+ function each time it is invoked.
+
+ If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results 
+ in less than N opcodes being executed, then the progress callback is not
+ invoked.
+ 
+ To remove the progress callback altogether, pass NULL as the third
+ argument to this function.
+
+ If the progress callback returns a result other than 0, then the current 
+ query is immediately terminated and any database changes rolled back. If the
+ query was part of a larger transaction, then the transaction is not rolled
+ back and remains active. The sqlite3_exec() call returns SQLITE_ABORT. 
+
+}
+
+api {} {
+int sqlite3_reset(sqlite3_stmt *pStmt);
+} {
+ The sqlite3_reset() function is called to reset a prepared SQL
+ statement obtained by a previous call to 
+ sqlite3_prepare_v2() or
+ sqlite3_prepare16_v2() back to it's initial state, ready to be re-executed.
+ Any SQL statement variables that had values bound to them using
+ the sqlite3_bind_*() API retain their values.
+}
+
+api {} {
+void sqlite3_result_blob(sqlite3_context*, const void*, int n, void(*)(void*));
+void sqlite3_result_double(sqlite3_context*, double);
+void sqlite3_result_error(sqlite3_context*, const char*, int);
+void sqlite3_result_error16(sqlite3_context*, const void*, int);
+void sqlite3_result_int(sqlite3_context*, int);
+void sqlite3_result_int64(sqlite3_context*, long long int);
+void sqlite3_result_null(sqlite3_context*);
+void sqlite3_result_text(sqlite3_context*, const char*, int n, void(*)(void*));
+void sqlite3_result_text16(sqlite3_context*, const void*, int n, void(*)(void*));
+void sqlite3_result_text16be(sqlite3_context*, const void*, int n, void(*)(void*));
+void sqlite3_result_text16le(sqlite3_context*, const void*, int n, void(*)(void*));
+void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
+} {
+ User-defined functions invoke these routines in order to
+ set their return value.  The sqlite3_result_value() routine is used
+ to return an exact copy of one of the arguments to the function.
+
+ The operation of these routines is very similar to the operation of
+ sqlite3_bind_blob() and its cousins.  Refer to the documentation there
+ for additional information.
+}
+
+api {} {
+int sqlite3_set_authorizer(
+  sqlite3*,
+  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
+  void *pUserData
+);
+#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
+#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
+#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
+#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
+#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
+#define SQLITE_DELETE                9   /* Table Name      NULL            */
+#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
+#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
+#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
+#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
+#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
+#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
+#define SQLITE_INSERT               18   /* Table Name      NULL            */
+#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
+#define SQLITE_READ                 20   /* Table Name      Column Name     */
+#define SQLITE_SELECT               21   /* NULL            NULL            */
+#define SQLITE_TRANSACTION          22   /* NULL            NULL            */
+#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
+#define SQLITE_ATTACH               24   /* Filename        NULL            */
+#define SQLITE_DETACH               25   /* Database Name   NULL            */
+#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
+#define SQLITE_REINDEX              27   /* Index Name      NULL            */
+#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
+#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
+#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
+#define SQLITE_FUNCTION             31   /* Function Name   NULL            */
+
+#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
+#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
+} {
+ This routine registers a callback with the SQLite library.  The
+ callback is invoked by sqlite3_prepare_v2() to authorize various
+ operations against the database.  The callback should
+ return SQLITE_OK if access is allowed, SQLITE_DENY if the entire
+ SQL statement should be aborted with an error and SQLITE_IGNORE
+ if the operation should be treated as a no-op.
+
+ Each database connection have at most one authorizer registered
+ at a time one time.  Each call
+ to sqlite3_set_authorizer() overrides the previous authorizer.
+ Setting the callback to NULL disables the authorizer.
+
+ The second argument to the access authorization function will be one
+ of the defined constants shown.  These values signify what kind of operation
+ is to be authorized.  The 3rd and 4th arguments to the authorization
+ function will be arguments or NULL depending on which of the 
+ codes is used as the second argument.  For example, if the the
+ 2nd argument code is SQLITE_READ then the 3rd argument will be the name
+ of the table that is being read from and the 4th argument will be the
+ name of the column that is being read from.  Or if the 2nd argument
+ is SQLITE_FUNCTION then the 3rd argument will be the name of the
+ function that is being invoked and the 4th argument will be NULL.
+
+ The 5th argument is the name
+ of the database ("main", "temp", etc.) where applicable.  The 6th argument
+ is the name of the inner-most trigger or view that is responsible for
+ the access attempt or NULL if this access attempt is directly from 
+ input SQL code.
+
+ The return value of the authorization callback function should be one of the
+ constants SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE.  A return of
+ SQLITE_OK means that the operation is permitted and that 
+ sqlite3_prepare_v2() can proceed as normal.
+ A return of SQLITE_DENY means that the sqlite3_prepare_v2()
+ should fail with an error.  A return of SQLITE_IGNORE causes the 
+ sqlite3_prepare_v2() to continue as normal but the requested 
+ operation is silently converted into a no-op.  A return of SQLITE_IGNORE
+ in response to an SQLITE_READ or SQLITE_FUNCTION causes the column
+ being read or the function being invoked to return a NULL.
+
+ The intent of this routine is to allow applications to safely execute
+ user-entered SQL.  An appropriate callback can deny the user-entered
+ SQL access certain operations (ex: anything that changes the database)
+ or to deny access to certain tables or columns within the database.
+
+ SQLite is not reentrant through the authorization callback function.
+ The authorization callback function should not attempt to invoke
+ any other SQLite APIs for the same database connection.  If the
+ authorization callback function invokes some other SQLite API, an
+ SQLITE_MISUSE error or a segmentation fault may result.
+}
+
+api {} {
+int sqlite3_step(sqlite3_stmt*);
+} {
+ After an SQL query has been prepared with a call to either
+ sqlite3_prepare_v2() or sqlite3_prepare16_v2() or to one of
+ the legacy interfaces sqlite3_prepare() or sqlite3_prepare16(),
+ then this function must be
+ called one or more times to execute the statement.
+
+ The details of the behavior of this sqlite3_step() interface depend
+ on whether the statement was prepared using the newer "v2" interface
+ sqlite3_prepare_v2() and sqlite3_prepare16_v2() or the older legacy
+ interface sqlite3_prepare() and sqlite3_prepare16().  The use of the
+ new "v2" interface is recommended for new applications but the legacy
+ interface will continue to be supported.
+
+ In the lagacy interface, the return value will be either SQLITE_BUSY, 
+ SQLITE_DONE, SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE.  With the "v2"
+ interface, any of the other SQLite result-codes might be returned as
+ well.
+
+ SQLITE_BUSY means that the database engine attempted to open
+ a locked database and there is no busy callback registered.
+ Call sqlite3_step() again to retry the open.
+
+ SQLITE_DONE means that the statement has finished executing
+ successfully.  sqlite3_step() should not be called again on this virtual
+ machine without first calling sqlite3_reset() to reset the virtual
+ machine back to its initial state.
+
+ If the SQL statement being executed returns any data, then 
+ SQLITE_ROW is returned each time a new row of data is ready
+ for processing by the caller. The values may be accessed using
+ the sqlite3_column_int(), sqlite3_column_text(), and similar functions.
+ sqlite3_step() is called again to retrieve the next row of data.
+ 
+ SQLITE_ERROR means that a run-time error (such as a constraint
+ violation) has occurred.  sqlite3_step() should not be called again on
+ the VM. More information may be found by calling sqlite3_errmsg().
+ A more specific error code (example: SQLITE_INTERRUPT, SQLITE_SCHEMA,
+ SQLITE_CORRUPT, and so forth) can be obtained by calling
+ sqlite3_reset() on the prepared statement.  In the "v2" interface,
+ the more specific error code is returned directly by sqlite3_step().
+
+ SQLITE_MISUSE means that the this routine was called inappropriately.
+ Perhaps it was called on a virtual machine that had already been
+ finalized or on one that had previously returned SQLITE_ERROR or
+ SQLITE_DONE.  Or it could be the case that a database connection
+ is being used by a different thread than the one it was created it.
+
+ <b>Goofy Interface Alert:</b>
+ In the legacy interface, 
+ the sqlite3_step() API always returns a generic error code,
+ SQLITE_ERROR, following any error other than SQLITE_BUSY and SQLITE_MISUSE.
+ You must call sqlite3_reset() (or sqlite3_finalize()) in order to find
+ one of the specific result-codes that better describes the error.
+ We admit that this is a goofy design.  The problem has been fixed
+ with the "v2" interface.  If you prepare all of your SQL statements
+ using either sqlite3_prepare_v2() or sqlite3_prepare16_v2() instead
+ of the legacy sqlite3_prepare() and sqlite3_prepare16(), then the 
+ more specific result-codes are returned directly by sqlite3_step().
+ The use of the "v2" interface is recommended.
+}
+
+api {} {
+void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
+} {
+ Register a function that is called each time an SQL statement is evaluated.
+ The callback function is invoked on the first call to sqlite3_step() after
+ calls to sqlite3_prepare_v2() or sqlite3_reset().
+ This function can be used (for example) to generate
+ a log file of all SQL executed against a database.  This can be
+ useful when debugging an application that uses SQLite.
+}
+
+api {} {
+void *sqlite3_user_data(sqlite3_context*);
+} {
+ The pUserData argument to the sqlite3_create_function() and
+ sqlite3_create_function16() routines used to register user functions
+ is available to the implementation of the function using this
+ call.
+}
+
+api {} {
+const void *sqlite3_value_blob(sqlite3_value*);
+int sqlite3_value_bytes(sqlite3_value*);
+int sqlite3_value_bytes16(sqlite3_value*);
+double sqlite3_value_double(sqlite3_value*);
+int sqlite3_value_int(sqlite3_value*);
+long long int sqlite3_value_int64(sqlite3_value*);
+const unsigned char *sqlite3_value_text(sqlite3_value*);
+const void *sqlite3_value_text16(sqlite3_value*);
+const void *sqlite3_value_text16be(sqlite3_value*);
+const void *sqlite3_value_text16le(sqlite3_value*);
+int sqlite3_value_type(sqlite3_value*);
+} {
+ This group of routines returns information about arguments to
+ a user-defined function.  Function implementations use these routines
+ to access their arguments.  These routines are the same as the
+ sqlite3_column_... routines except that these routines take a single
+ sqlite3_value* pointer instead of an sqlite3_stmt* and an integer
+ column number.
+
+ See the documentation under sqlite3_column_blob for additional
+ information.
+
+ Please pay particular attention to the fact that the pointer that
+ is returned from sqlite3_value_blob(), sqlite3_value_text(), or
+ sqlite3_value_text16() can be invalidated by a subsequent call to
+ sqlite3_value_bytes(), sqlite3_value_bytes16(), sqlite_value_text(),
+ or sqlite3_value_text16().  
+}
+
+api {} {
+  int sqlite3_sleep(int);
+} {
+ Sleep for a little while. The second parameter is the number of
+ miliseconds to sleep for. 
+
+ If the operating system does not support sleep requests with 
+ milisecond time resolution, then the time will be rounded up to 
+ the nearest second. The number of miliseconds of sleep actually 
+ requested from the operating system is returned.
+}
+
+api {} {
+  int sqlite3_expired(sqlite3_stmt*);
+} {
+ Return TRUE (non-zero) if the statement supplied as an argument needs
+ to be recompiled.  A statement needs to be recompiled whenever the
+ execution environment changes in a way that would alter the program
+ that sqlite3_prepare() generates.  For example, if new functions or
+ collating sequences are registered or if an authorizer function is
+ added or changed.
+}
+
+api {} {
+  int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
+} {
+ Move all bindings from the first prepared statement over to the second.
+ This routine is useful, for example, if the first prepared statement
+ fails with an SQLITE_SCHEMA error.  The same SQL can be prepared into
+ the second prepared statement then all of the bindings transfered over
+ to the second statement before the first statement is finalized.
+}
+
+api {} {
+  int sqlite3_global_recover();
+} {
+ This function used to be involved in recovering from out-of-memory
+ errors.  But as of SQLite version 3.3.0, out-of-memory recovery is
+ automatic and this routine now does nothing.  THe interface is retained
+ to avoid link errors with legacy code.
+}
+
+api {} {
+  int sqlite3_get_autocommit(sqlite3*);
+} {
+ Test to see whether or not the database connection is in autocommit
+ mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on
+ by default.  Autocommit is disabled by a BEGIN statement and reenabled
+ by the next COMMIT or ROLLBACK.
+}
+
+api {} {
+  int sqlite3_clear_bindings(sqlite3_stmt*);
+} {
+ Set all the parameters in the compiled SQL statement back to NULL.
+}
+
+api {} {
+  sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
+} {
+ Return the sqlite3* database handle to which the prepared statement given
+ in the argument belongs.  This is the same database handle that was
+ the first argument to the sqlite3_prepare() that was used to create
+ the statement in the first place.
+}
+
+api {} {
+  void *sqlite3_update_hook(
+    sqlite3*, 
+    void(*)(void *,int ,char const *,char const *,sqlite_int64),
+    void*
+  );
+} {
+ Register a callback function with the database connection identified by the 
+ first argument to be invoked whenever a row is updated, inserted or deleted.
+ Any callback set by a previous call to this function for the same 
+ database connection is overridden.
+
+ The second argument is a pointer to the function to invoke when a 
+ row is updated, inserted or deleted. The first argument to the callback is
+ a copy of the third argument to sqlite3_update_hook. The second callback 
+ argument is one of SQLITE_INSERT, SQLITE_DELETE or SQLITE_UPDATE, depending
+ on the operation that caused the callback to be invoked. The third and 
+ fourth arguments to the callback contain pointers to the database and 
+ table name containing the affected row. The final callback parameter is 
+ the rowid of the row. In the case of an update, this is the rowid after 
+ the update takes place.
+
+ The update hook is not invoked when internal system tables are
+ modified (i.e. sqlite_master and sqlite_sequence).
+
+ If another function was previously registered, its pArg value is returned.
+ Otherwise NULL is returned.
+
+ See also: sqlite3_commit_hook(), sqlite3_rollback_hook()
+}
+
+api {} {
+  void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
+} {
+ Register a callback to be invoked whenever a transaction is rolled
+ back. 
+
+ The new callback function overrides any existing rollback-hook
+ callback. If there was an existing callback, then it's pArg value 
+ (the third argument to sqlite3_rollback_hook() when it was registered) 
+ is returned. Otherwise, NULL is returned.
+
+ For the purposes of this API, a transaction is said to have been 
+ rolled back if an explicit "ROLLBACK" statement is executed, or
+ an error or constraint causes an implicit rollback to occur. The 
+ callback is not invoked if a transaction is automatically rolled
+ back because the database connection is closed.
+}
+
+api {} {
+  int sqlite3_enable_shared_cache(int);
+} {
+  This routine enables or disables the sharing of the database cache
+  and schema data structures between connections to the same database.
+  Sharing is enabled if the argument is true and disabled if the argument
+  is false.
+
+  Cache sharing is enabled and disabled on a thread-by-thread basis.
+  Each call to this routine enables or disables cache sharing only for
+  connections created in the same thread in which this routine is called.
+  There is no mechanism for sharing cache between database connections
+  running in different threads.
+
+  Sharing must be disabled prior to shutting down a thread or else
+  the thread will leak memory.  Call this routine with an argument of
+  0 to turn off sharing.  Or use the sqlite3_thread_cleanup() API.
+
+  This routine must not be called when any database connections
+  are active in the current thread.  Enabling or disabling shared
+  cache while there are active database connections will result
+  in memory corruption.
+
+  When the shared cache is enabled, the
+  following routines must always be called from the same thread:
+  sqlite3_open(), sqlite3_prepare_v2(), sqlite3_step(), sqlite3_reset(),
+  sqlite3_finalize(), and sqlite3_close().
+  This is due to the fact that the shared cache makes use of
+  thread-specific storage so that it will be available for sharing
+  with other connections.
+
+  Virtual tables cannot be used with a shared cache.  When shared
+  cache is enabled, the sqlite3_create_module() API used to register
+  virtual tables will always return an error.
+
+  This routine returns SQLITE_OK if shared cache was
+  enabled or disabled successfully.  An error code is returned
+  otherwise.
+
+  Shared cache is disabled by default for backward compatibility.
+}
+
+api {} {
+  void sqlite3_thread_cleanup(void);
+} {
+  This routine makes sure that all thread local storage used by SQLite
+  in the current thread has been deallocated.  A thread can call this
+  routine prior to terminating in order to make sure there are no memory
+  leaks.
+
+  This routine is not strictly necessary.  If cache sharing has been
+  disabled using sqlite3_enable_shared_cache() and if all database
+  connections have been closed and if SQLITE_ENABLE_MEMORY_MANAGMENT is
+  on and all memory has been freed, then the thread local storage will
+  already have been automatically deallocated.  This routine is provided
+  as a convenience to the program who just wants to make sure that there
+  are no leaks.
+}
+
+api {} {
+  int sqlite3_release_memory(int N);
+} {
+  This routine attempts to free at least N bytes of memory from the caches
+  of database connecions that were created in the same thread from which this
+  routine is called.  The value returned is the number of bytes actually
+  freed.  
+
+  This routine is only available if memory management has been enabled
+  by compiling with the SQLITE_ENABLE_MEMORY_MANAGMENT macro.
+}
+
+api {} {
+  void sqlite3_soft_heap_limit(int N);
+} {
+  This routine sets the soft heap limit for the current thread to N.
+  If the total heap usage by SQLite in the current thread exceeds N,
+  then sqlite3_release_memory() is called to try to reduce the memory usage
+  below the soft limit.
+
+  Prior to shutting down a thread sqlite3_soft_heap_limit() must be set to 
+  zero (the default) or else the thread will leak memory. Alternatively, use
+  the sqlite3_thread_cleanup() API.
+
+  A negative or zero value for N means that there is no soft heap limit and
+  sqlite3_release_memory() will only be called when memory is exhaused.
+  The default value for the soft heap limit is zero.
+
+  SQLite makes a best effort to honor the soft heap limit.  But if it
+  is unable to reduce memory usage below the soft limit, execution will
+  continue without error or notification.  This is why the limit is 
+  called a "soft" limit.  It is advisory only.
+
+  This routine is only available if memory management has been enabled
+  by compiling with the SQLITE_ENABLE_MEMORY_MANAGMENT macro.
+}
+
+api {} {
+  void sqlite3_thread_cleanup(void);
+} {
+  This routine ensures that a thread that has used SQLite in the past
+  has released any thread-local storage it might have allocated.  
+  When the rest of the API is used properly, the cleanup of 
+  thread-local storage should be completely automatic.  You should
+  never really need to invoke this API.  But it is provided to you
+  as a precaution and as a potential work-around for future
+  thread-releated memory-leaks.
+}
+
+set n 0
+set i 0
+foreach item $apilist {
+  set namelist [lindex $item 0]
+  foreach name $namelist {
+    set n_to_name($n) $name
+    set n_to_idx($n) $i
+    set name_to_idx($name) $i
+    incr n
+  }
+  incr i
+}
+set i 0
+foreach name [lsort [array names name_to_idx]] {
+  set sname($i) $name
+  incr i
+}
+#parray n_to_name
+#parray n_to_idx
+#parray name_to_idx
+#parray sname
+incr n -1
+puts "<DIV class=pdf_ignore>"
+puts {<table width="100%" cellpadding="5"><tr>}
+set nrow [expr {($n+2)/3}]
+set i 0
+for {set j 0} {$j<3} {incr j} {
+  if {$j>0} {puts {<td width="10"></td>}}
+  puts {<td valign="top">}
+  set limit [expr {$i+$nrow}]
+  puts {<ul>}
+  while {$i<$limit && $i<$n} {
+    set name $sname($i)
+    if {[regexp {^sqlite} $name]} {set display $name} {set display <i>$name</i>}
+    puts "<li><a href=\"#$name\">$display</a></li>"
+    incr i
+  }
+  puts {</ul></td>}
+}
+puts "</table>"
+puts "<!-- $n entries.  $nrow rows in 3 columns -->"
+puts "</DIV>"
+
+proc resolve_name {ignore_list name} {
+  global name_to_idx
+  if {![info exists name_to_idx($name)] || [lsearch $ignore_list $name]>=0} {
+    return $name
+  } else {
+    return "<a href=\"#$name\">$name</a>"
+  }
+}
+
+foreach name [lsort [array names name_to_idx]] {
+  set i $name_to_idx($name)
+  if {[info exists done($i)]} continue
+  set done($i) 1
+  foreach {namelist prototype desc} [lindex $apilist $i] break
+  foreach name $namelist {
+    puts "<a name=\"$name\"></a>"
+  }
+  puts "<p><hr></p>"
+  puts "<blockquote><pre>"
+  regsub "^( *\n)+" $prototype {} p2
+  regsub "(\n *)+\$" $p2 {} p3
+  puts $p3
+  puts "</pre></blockquote>"
+  regsub -all {\[} $desc {\[} desc
+  regsub -all {sqlite3_[a-z0-9_]+} $desc "\[resolve_name $name &\]" d2
+  foreach x $specialname {
+    regsub -all $x $d2 "\[resolve_name $name &\]" d2
+  }
+  regsub -all "\n( *\n)+" [subst $d2] "</p>\n\n<p>" d3
+  puts "<p>$d3</p>"
+}
+
+puts "<DIV class=pdf_ignore>"
+footer $rcsid
+puts "</DIV>"
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/changes.tcl b/client/src/thirdparty/sqlite-3.4.2/www/changes.tcl
new file mode 100644
index 0000000..b64a71c
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/changes.tcl
@@ -0,0 +1,1880 @@
+#
+# Run this script to generated a changes.html output file
+#
+source common.tcl
+header {SQLite changes}
+puts {
+<p>
+This page provides a high-level summary of changes to SQLite.
+For more detail, refer the the checkin logs generated by
+CVS at
+<a href="http://www.sqlite.org/cvstrac/timeline">
+http://www.sqlite.org/cvstrac/timeline</a>.
+</p>
+
+<DL>
+}
+
+
+proc chng {date desc} {
+  if {[regexp {\(([0-9.]+)\)} $date all vers]} {
+    set label [string map {. _} $vers]
+    puts "<A NAME=\"version_$label\">"
+  }
+  puts "<DT><B>$date</B></DT>"
+  regsub -all {[Tt]icket #(\d+)} $desc \
+      {<a href="http://www.sqlite.org/cvstrac/tktview?tn=\1">\0</a>} desc
+  puts "<DD><P><UL>$desc</UL></P>"
+  puts "</DD>"
+}
+
+chng {2007 Nov 05 (3.5.2)} {
+<li>Dropped support for the SQLITE_OMIT_MEMORY_ALLOCATION compile-time
+option.
+<li>Always open files using FILE_FLAG_RANDOM_ACCESS under windows.
+<li>The 3rd parameter of the built-in SUBSTR() function is now optional.
+<li>Bug fix: do not invoke the authorizer when reparsing the schema after
+a schema change.
+<li>Added the experimental malloc-free memory allocator in mem3.c.
+<li>Virtual machine stores 64-bit integer and floating point constants
+in binary instead of text for a performance boost.
+<li>Fix a race condition in test_async.c.
+<li>Added the ".timer" command to the CLI
+}
+
+chng {2007 Oct 04 (3.5.1)} {
+<li><i><b>Nota Bene:</b> We are not using terms "alpha" or "beta" on this
+    release because the code is stable and because if we use those terms,
+    nobody will upgrade.  However, we still reserve the right to make
+    incompatible changes to the new VFS interface in future releases.</i></li>
+
+<li>Fix a bug in the handling of SQLITE_FULL errors that could lead
+    to database corruption.  Ticket #2686.
+<li>The test_async.c drive now does full file locking and works correctly
+    when used simultaneously by multiple processes on the same database.
+<li>The CLI ignores whitespace (including comments) at the end of lines
+<li>Make sure the query optimizer checks dependences on all terms of
+    a compound SELECT statement.  Ticket #2640.
+<li>Add demonstration code showing how to build a VFS for a raw
+    mass storage without a filesystem.
+<li>Added an output buffer size parameter to the xGetTempname() method
+    of the VFS layer.
+<li>Sticky SQLITE_FULL or SQLITE_IOERR errors in the pager are reset
+    when a new transaction is started.
+}
+
+
+chng {2007 Sep 04 (3.5.0) alpha} {
+<li>Redesign the OS interface layer.  See
+    <a href="34to35.html">34to35.html</a> for details.
+    <font color="red">*** Potentially incompatible change ***</font>
+<li>The <a href="capi3ref.html#sqlite3_release_memory">
+    sqlite3_release_memory()</a>,
+    <a href="capi3ref.html#sqlite3_soft_heap_limit">
+    sqlite3_soft_heap_limit()</a>,
+    and <a href="capi3ref.html#sqlite3_enable_shared_cache">
+    sqlite3_enable_shared_cache()</a> interfaces now work cross all
+    threads in the process, not just the single thread in which they
+    are invoked.
+    <font color="red">*** Potentially incompatible change ***</font>
+<li>Added the 
+    <a href="capi3ref.html#sqlite3_open_v2">sqlite3_open_v2()</a>
+    interface.  
+<li>Reimplemented the memory allocation subsystem and made it 
+    replacable at compile-time.
+<li>Created a new mutex subsystem and made it replacable at
+    compile-time.
+<li>The same database connection may now be used simultaneously by
+    separate threads.
+}
+
+
+chng {2007 August 13 (3.4.2)} {
+<li>Fix a database corruption bug that might occur if a ROLLBACK command
+is executed in <a href="pragma.html#pragma_auto_vacuum">auto-vacuum mode</a>
+and a very small <a href="capi3ref.html#sqlite3_soft_heap_limit">
+soft_heap_limit</a> is set. 
+<a href="http://www.sqlite.org/cvstrac/tktview?tn=2565">Ticket #2565</a>.
+
+<li>Add the ability to run a full regression test with a small
+<a href="capi3ref.html#sqlite3_soft_heap_limit">soft_heap_limit</a>.
+
+<li>Fix other minor problems with using small soft heap limits.
+
+<li>Work-around for 
+<a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=32575">GCC bug 32575</a>.
+
+<li>Improved error detection of misused aggregate functions.
+
+<li>Improvements to the amalgamation generator script so that all symbols
+are prefixed with either SQLITE_PRIVATE or SQLITE_API.
+}
+
+chng {2007 July 20 (3.4.1)} {
+<li>Fix a bug in <a href="lang_vacuum.html">VACUUM</a> that can lead to
+    <a href="http://www.sqlite.org/cvstrac/wiki?p=DatabaseCorruption">
+    database corruption</a> if two
+    processes are connected to the database at the same time and one
+    VACUUMs then the other then modifies the database.</li>
+<li>The expression "+column" is now considered the same as "column"
+    when computing the collating sequence to use on the expression.</li>
+<li>In the <a href="tclsqlite.html">TCL language interface</a>,
+   "@variable" instead of "$variable" always binds as a blob.</li>
+<li>Added <a href="pragma.html#pragma_freelist_count">PRAGMA freelist_count</a>
+    for determining the current size of the freelist.</li>
+<li>The <a href="pragma.html#pragma_auto_vacuum">
+    PRAGMA auto_vacuum=incremental</a> setting is now persistent.</li>
+<li>Add FD_CLOEXEC to all open files under unix.</li>
+<li>Fix a bug in the <a href="optoverview.html#minmax">
+    min()/max() optimization</a> when applied to
+    descending indices.</li>
+<li>Make sure the TCL language interface works correctly with 64-bit
+    integers on 64-bit machines.</li>
+<li>Allow the value -9223372036854775808 as an integer literal in SQL
+    statements.</li>
+<li>Add the capability of "hidden" columns in virtual tables.</li>
+<li>Use the macro SQLITE_PRIVATE (defaulting to "static") on all
+    internal functions in the amalgamation.</li>
+<li>Add pluggable tokenizers and <a href="http://www.icu-project.org/">ICU</a>
+    tokenization support to FTS2</li>
+<li>Other minor bug fixes and documentation enhancements</li>
+}
+
+chng {2007 June 18 (3.4.0)} {
+<li>Fix a bug that can lead to database corruption if an SQLITE_BUSY error
+    occurs in the middle of an explicit transaction and that transaction
+    is later committed.  
+    <a href="http://www.sqlite.org/cvstrac/tktview?tn=2409">Ticket #2409.</a>
+    See the
+    <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError">
+    CorruptionFollowingBusyError</a> wiki page for details.</i>
+<li>Fix a bug that can lead to database corruption if autovacuum mode is
+    on and a malloc() failure follows a CREATE TABLE or CREATE INDEX statement
+    which itself follows a cache overflow inside a transaction.  See
+    <a href="http://www.sqlite.org/cvstrac/tktview?tn=2418">ticket #2418</a>. 
+    </li>
+<li>Added explicit <a href="limits.html">upper bounds</a> on the sizes and
+    quantities of things SQLite can process.  This change might cause
+    compatibility problems for
+    applications that use SQLite in the extreme, which is why the current
+    release is 3.4.0 instead of 3.3.18.</li>
+<li>Added support for <a href="capi3ref.html#sqlite3_blob_open">
+    Incremental BLOB I/O</a>.</li>
+<li>Added the <a href="capi3ref.html#sqlite3_bind_zeroblob">zeroblob API</a>
+    and the <a href="lang_expr.html#zeroblob">zeroblob()</a> SQL function.</li>
+<li>Added support for <a href="pragma.html#pragma_incremental_vacuum">
+    Incremental Vacuum</a>.</li>
+<li>Added the SQLITE_MIXED_ENDIAN_64BIT_FLOAT compile-time option to suppport
+    ARM7 processors with goofy endianness.</li>
+<li>Removed all instances of sprintf() and strcpy() from the core library.</li>
+<li>Added support for <a href="http://www.icu-project.org/">
+    International Components for Unicode (ICU)</a> to the full-text search
+    extensions.
+</ul><p>
+<ul type="circle">
+<li>In the windows OS driver, reacquire a SHARED lock if an attempt to
+    acquire an EXCLUSIVE lock fails.  Ticket #2354</li>
+<li>Fix the REPLACE() function so that it returns NULL if the second argument
+    is an empty string.  Ticket #2324.</li>
+<li>Document the hazards of type coversions in
+    <a href="capi3ref.html#sqlite3_column_blob">sqlite3_column_blob()</a>
+    and related APIs.  Fix unnecessary type conversions.  Ticket #2321.</li>
+<li>Internationalization of the TRIM() function.  Ticket #2323</li>
+<li>Use memmove() instead of memcpy() when moving between memory regions
+    that might overlap.  Ticket #2334</li>
+<li>Fix an optimizer bug involving subqueries in a compound SELECT that has
+    both an ORDER BY and a LIMIT clause.  Ticket #2339.</li>
+<li>Make sure the <a href="capi3ref.html#sqlite3_snprintf">sqlite3_snprintf()
+    </a> interface does not zero-terminate the buffer if the buffer size is
+    less than 1.  Ticket #2341</li>
+<li>Fix the built-in printf logic so that it prints "NaN" not "Inf" for
+    floating-point NaNs.  Ticket #2345</li>
+<li>When converting BLOB to TEXT, use the text encoding of the main database.
+    Ticket #2349</li>
+<li>Keep the full precision of integers (if possible) when casting to
+    NUMERIC.  Ticket #2364</li>
+<li>Fix a bug in the handling of UTF16 codepoint 0xE000</li>
+<li>Consider explicit collate clauses when matching WHERE constraints
+    to indices in the query optimizer.  Ticket #2391</li>
+<li>Fix the query optimizer to correctly handle constant expressions in 
+    the ON clause of a LEFT JOIN.  Ticket #2403</li>
+<li>Fix the query optimizer to handle rowid comparisions to NULL
+    correctly.  Ticket #2404</li>
+<li>Fix many potental segfaults that could be caused by malicious SQL
+    statements.</li>
+}
+
+chng {2007 April 25 (3.3.17)} {
+<li>When the "write_version" value of the database header is larger than
+    what the library understands, make the database read-only instead of
+    unreadable.</li>
+<li>Other minor bug fixes</li>
+}
+
+chng {2007 April 18 (3.3.16)} {
+<li>Fix a bug that caused VACUUM to fail if NULLs appeared in a
+    UNIQUE column.</li>
+<li>Reinstate performance improvements that were added in 3.3.14
+    but regressed in 3.3.15.</li>
+<li>Fix problems with the handling of ORDER BY expressions on
+    compound SELECT statements in subqueries.</li>
+<li>Fix a potential segfault when destroying locks on WinCE in
+    a multi-threaded environment.</li>
+<li>Documentation updates.</li>
+}
+
+chng {2007 April 9 (3.3.15)} {
+<li>Fix a bug introduced in 3.3.14 that caused a rollback of
+    CREATE TEMP TABLE to leave the database connection wedged.</li>
+<li>Fix a bug that caused an extra NULL row to be returned when
+    a descending query was interrupted by a change to the database.</li>
+<li>The FOR EACH STATEMENT clause on a trigger now causes a syntax
+    error.  It used to be silently ignored.</li>
+<li>Fix an obscure and relatively harmless problem that might have caused
+    a resource leak following an I/O error.</li>
+<li>Many improvements to the test suite.  Test coverage now exceeded 98%</li>
+}
+
+chng {2007 April 2 (3.3.14)} {
+<li>Fix a <a href="http://www.sqlite.org/cvstrac/tktview?tn=2273">bug</a>
+    in 3.3.13 that could cause a segfault when the IN operator
+    is used one one term of a two-column index and the right-hand side of
+    the IN operator contains a NULL.</li>
+<li>Added a new OS interface method for determining the sector size
+    of underlying media:  sqlite3OsSectorSize().</li>
+<li>A new algorithm for statements of the form
+    INSERT INTO <i>table1</i> SELECT * FROM <i>table2</i>
+    is faster and reduces fragmentation.  VACUUM uses statements of
+    this form and thus runs faster and defragments better.</li>
+<li>Performance enhancements through reductions in disk I/O:
+<ul>
+<li>Do not read the last page of an overflow chain when
+    deleting the row - just add that page to the freelist.</li>
+<li>Do not store pages being deleted in the 
+    rollback journal.</li>
+<li>Do not read in the (meaningless) content of
+    pages extracted from the freelist.</li>
+<li>Do not flush the page cache (and thus avoiding
+    a cache refill) unless another process changes the underlying
+    database file.</li>
+<li>Truncate rather than delete the rollback journal when committing
+    a transaction in exclusive access mode, or when committing the TEMP
+    database.</li>
+</ul></li>
+<li>Added support for exclusive access mode using
+    <a href="pragma.html#pragma_locking_mode">
+    "PRAGMA locking_mode=EXCLUSIVE"</a></li>
+<li>Use heap space instead of stack space for large buffers in the
+    pager - useful on embedded platforms with  stack-space
+    limitations.</li>
+<li>Add a makefile target "sqlite3.c" that builds an amalgamation containing
+    the core SQLite library C code in a single file.</li>
+<li>Get the library working correctly when compiled 
+    with GCC option "-fstrict-aliasing".</li>
+<li>Removed the vestigal SQLITE_PROTOCOL error.</li>
+<li>Improvements to test coverage, other minor bugs fixed,
+    memory leaks plugged,
+    code refactored and/or recommented in places for easier reading.</li>
+}
+
+chng {2007 February 13 (3.3.13)} {
+<li>Add a "fragmentation" measurement in the output of sqlite3_analyzer.</li>
+<li>Add the COLLATE operator used to explicitly set the collating sequence
+used by an expression.  This feature is considered experimental pending
+additional testing.</li>
+<li>Allow up to 64 tables in a join - the old limit was 32.</li>
+<li>Added two new experimental functions:
+<a href="lang_expr.html#randomblobFunc">randomBlob()</a> and
+<a href="lang_expr.html#hexFunc">hex()</a>.
+Their intended use is to facilitate generating 
+<a href="http://en.wikipedia.org/wiki/UUID">UUIDs</a>.
+</li>
+<li>Fix a problem where
+<a href="pragma.html#pragma_count_changes">PRAGMA count_changes</a> was
+causing incorrect results for updates on tables with triggers</li>
+<li>Fix a bug in the ORDER BY clause optimizer for joins where the
+left-most table in the join is constrained by a UNIQUE index.</li>
+<li>Fixed a bug in the "copy" method of the TCL interface.</li>
+<li>Bug fixes in fts1 and fts2 modules.</li>
+}
+
+chng {2007 January 27 (3.3.12)} {
+<li>Fix another bug in the IS NULL optimization that was added in
+version 3.3.9.</li>
+<li>Fix a assertion fault that occurred on deeply nested views.</li>
+<li>Limit the amount of output that
+<a href="pragma.html#pragma_integrity_check">PRAGMA integrity_check</a>
+generates.</li>
+<li>Minor syntactic changes to support a wider variety of compilers.</li>
+}
+
+chng {2007 January 22 (3.3.11)} {
+<li>Fix another bug in the implementation of the new 
+<a href="capi3ref.html#sqlite3_prepare_v2">sqlite3_prepare_v2()</a> API.
+We'll get it right eventually...</li>
+<li>Fix a bug in the IS NULL optimization that was added in version 3.3.9 -
+the bug was causing incorrect results on certain LEFT JOINs that included
+in the WHERE clause an IS NULL constraint for the right table of the
+LEFT JOIN.</li>
+<li>Make AreFileApisANSI() a no-op macro in winCE since winCE does not
+support this function.</li>
+}
+
+chng {2007 January 9 (3.3.10)} {
+<li>Fix bugs in the implementation of the new 
+<a href="capi3ref.html#sqlite3_prepare_v2">sqlite3_prepare_v2()</a> API
+that can lead to segfaults.</li>
+<li>Fix 1-second round-off errors in the 
+<a href="http://www.sqlite.org/cvstrac/wiki?p=DateAndTimeFunctions">
+strftime()</a> function</li>
+<li>Enhance the windows OS layer to provide detailed error codes</li>
+<li>Work around a win2k problem so that SQLite can use single-character
+database file names</li>
+<li>The
+<a href="pragma.html#pragma_user_version">user_version</a> and
+<a href="pragma.html#pragma_schema_version">schema_version</a> pragmas 
+correctly set their column names in the result set</li>
+<li>Documentation updates</li>
+}
+
+chng {2007 January 4 (3.3.9)} {
+<li>Fix bugs in pager.c that could lead to database corruption if two
+processes both try to recover a hot journal at the same instant</li>
+<li>Added the <a href="capi3ref.html#sqlite3_prepare_v2">sqlite3_prepare_v2()</a>
+API.</li>
+<li>Fixed the ".dump" command in the command-line shell to show
+indices, triggers and views again.</li>
+<li>Change the table_info pragma so that it returns NULL for the default
+value if there is no default value</li>
+<li>Support for non-ASCII characters in win95 filenames</li>
+<li>Query optimizer enhancements:
+<ul>
+<li>Optimizer does a better job of using indices to satisfy ORDER BY
+clauses that sort on the integer primary key</li>
+<li>Use an index to satisfy an IS NULL operator in the WHERE clause</li>
+<li>Fix a bug that was causing the optimizer to miss an OR optimization
+opportunity</li>
+<li>The optimizer has more freedom to reorder tables in the FROM clause
+even in there are LEFT joins.</li>
+</ul>
+<li>Extension loading supported added to winCE</li>
+<li>Allow constraint names on the DEFAULT clause in a table definition</li>
+<li>Added the ".bail" command to the command-line shell</li>
+<li>Make CSV (comma separate value) output from the command-line shell
+more closely aligned to accepted practice</li>
+<li>Experimental FTS2 module added</li>
+<li>Use sqlite3_mprintf() instead of strdup() to avoid libc dependencies</li>
+<li>VACUUM uses a temporary file in the official TEMP folder, not in the
+same directory as the original database</li>
+<li>The prefix on temporary filenames on windows is changed from "sqlite"
+to "etilqs".</li>
+}
+
+chng {2006 October 9 (3.3.8)} {
+<li>Support for full text search using the
+<a href="http://www.sqlite.org/cvstrac/wiki?p=FullTextIndex">FTS1 module</a>
+(beta)</li>
+<li>Added OS-X locking patches (beta - disabled by default)</li>
+<li>Introduce extended error codes and add error codes for various
+kinds of I/O errors.</li>
+<li>Added support for IF EXISTS on CREATE/DROP TRIGGER/VIEW</li>
+<li>Fix the regression test suite so that it works with Tcl8.5</li>
+<li>Enhance sqlite3_set_authorizer() to provide notification of calls to
+    SQL functions.</li>
+<li>Added experimental API:  sqlite3_auto_extension()</li>
+<li>Various minor bug fixes</li>
+}
+
+chng {2006 August 12 (3.3.7)} {
+<li>Added support for
+<a href="http://www.sqlite.org/cvstrac/wiki?p=VirtualTables">virtual tables</a>
+(beta)</li>
+<li>Added support for 
+<a href="http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions">
+dynamically loaded extensions</a> (beta)</li>
+<li>The 
+<a href="capi3ref.html#sqlite3_interrupt">sqlite3_interrupt()</a>
+routine can be called for a different thread</li>
+<li>Added the <a href="lang_expr.html#match">MATCH</a> operator.</li>
+<li>The default file format is now 1.  
+}
+
+chng {2006 June 6 (3.3.6)} {
+<li>Plays better with virus scanners on windows</li>
+<li>Faster :memory: databases</li>
+<li>Fix an obscure segfault in UTF-8 to UTF-16 conversions</li>
+<li>Added driver for OS/2</li>
+<li>Correct column meta-information returned for aggregate queries</li>
+<li>Enhanced output from EXPLAIN QUERY PLAN</li>
+<li>LIMIT 0 now works on subqueries</li>
+<li>Bug fixes and performance enhancements in the query optimizer</li>
+<li>Correctly handle NULL filenames in ATTACH and DETACH</li>
+<li>Inproved syntax error messages in the parser</li>
+<li>Fix type coercion rules for the IN operator</li>
+}
+
+chng {2006 April 5 (3.3.5)} {
+<li>CHECK constraints use conflict resolution algorithms correctly.</li>
+<li>The SUM() function throws an error on integer overflow.</li>
+<li>Choose the column names in a compound query from the left-most SELECT
+    instead of the right-most.</li>
+<li>The sqlite3_create_collation() function
+    honors the SQLITE_UTF16_ALIGNED flag.</li>
+<li>SQLITE_SECURE_DELETE compile-time option causes deletes to overwrite
+    old data with zeros.</li>
+<li>Detect integer overflow in abs().</li>
+<li>The random() function provides 64 bits of randomness instead of
+    only 32 bits.</li>
+<li>Parser detects and reports automaton stack overflow.</li>
+<li>Change the round() function to return REAL instead of TEXT.</li>
+<li>Allow WHERE clause terms on the left table of a LEFT OUTER JOIN to
+    contain aggregate subqueries.</li>
+<li>Skip over leading spaces in text to numeric conversions.</li>
+<li>Various minor bug and documentation typo fixes and
+    performance enhancements.</li>
+}
+
+chng {2006 February 11 (3.3.4)} {
+<li>Fix a blunder in the Unix mutex implementation that can lead to
+deadlock on multithreaded systems.</li>
+<li>Fix an alignment problem on 64-bit machines</li>
+<li>Added the fullfsync pragma.</li>
+<li>Fix an optimizer bug that could have caused some unusual LEFT OUTER JOINs
+to give incorrect results.</li>
+<li>The SUM function detects integer overflow and converts to accumulating
+an approximate result using floating point numbers</li>
+<li>Host parameter names can begin with '@' for compatibility with SQL Server.
+</li>
+<li>Other miscellaneous bug fixes</li>
+}
+
+chng {2006 January 31 (3.3.3)} {
+<li>Removed support for an ON CONFLICT clause on CREATE INDEX - it never
+worked correctly so this should not present any backward compatibility
+problems.</li>
+<li>Authorizer callback now notified of ALTER TABLE ADD COLUMN commands</li>
+<li>After any changes to the TEMP database schema, all prepared statements
+are invalidated and must be recreated using a new call to
+sqlite3_prepare()</li>
+<li>Other minor bug fixes in preparation for the first stable release
+of version 3.3</li>
+}
+
+chng {2006 January 24 (3.3.2 beta)} {
+<li>Bug fixes and speed improvements.  Improved test coverage.</li>
+<li>Changes to the OS-layer interface: mutexes must now be recursive.</li>
+<li>Discontinue the use of thread-specific data for out-of-memory
+exception handling</li>
+}
+
+chng {2006 January 16 (3.3.1 alpha)} {
+<li>Countless bug fixes</li>
+<li>Speed improvements</li>
+<li>Database connections can now be used by multiple threads, not just
+the thread in which they were created.</li>
+}
+
+chng {2006 January 10 (3.3.0 alpha)} {
+<li>CHECK constraints</li>
+<li>IF EXISTS and IF NOT EXISTS clauses on CREATE/DROP TABLE/INDEX.</li>
+<li>DESC indices</li>
+<li>More efficient encoding of boolean values resulting in smaller database
+files</li>
+<li>More aggressive SQLITE_OMIT_FLOATING_POINT</li>
+<li>Separate INTEGER and REAL affinity</li>
+<li>Added a virtual function layer for the OS interface</li>
+<li>"exists" method added to the TCL interface</li>
+<li>Improved response to out-of-memory errors</li>
+<li>Database cache can be optionally shared between connections
+in the same thread</li>
+<li>Optional READ UNCOMMITTED isolation (instead of the default
+isolation level of SERIALIZABLE) and table level locking when
+database connections share a common cache.</li>
+}
+
+chng {2005 December 19 (3.2.8)} {
+<li>Fix an obscure bug that can cause database corruption under the
+following unusual circumstances: A large INSERT or UPDATE statement which 
+is part of an even larger transaction fails due to a uniqueness contraint
+but the containing transaction commits.</li>
+}
+
+chng {2005 December 19 (2.8.17)} {
+<li>Fix an obscure bug that can cause database corruption under the
+following unusual circumstances: A large INSERT or UPDATE statement which 
+is part of an even larger transaction fails due to a uniqueness contraint
+but the containing transaction commits.</li>
+}
+
+chng {2005 September 24 (3.2.7)} {
+<li>GROUP BY now considers NULLs to be equal again, as it should
+</li>
+<li>Now compiles on Solaris and OpenBSD and other Unix variants
+that lack the fdatasync() function</li>
+<li>Now compiles on MSVC++6 again</li>
+<li>Fix uninitialized variables causing malfunctions for various obscure
+queries</li>
+<li>Correctly compute a LEFT OUTER JOINs that is constrained on the
+left table only</li>
+}
+
+chng {2005 September 17 (3.2.6)} {
+<li>Fix a bug that can cause database corruption if a VACUUM (or
+    autovacuum) fails and is rolled back on a database that is
+    larger than 1GiB</li>
+<li>LIKE optiization now works for columns with COLLATE NOCASE</li>
+<li>ORDER BY and GROUP BY now use bounded memory</li>
+<li>Added support for COUNT(DISTINCT expr)</li>
+<li>Change the way SUM() handles NULL values in order to comply with
+    the SQL standard</li>
+<li>Use fdatasync() instead of fsync() where possible in order to speed
+    up commits slightly</li>
+<li>Use of the CROSS keyword in a join turns off the table reordering
+    optimization</li>
+<li>Added the experimental and undocumented EXPLAIN QUERY PLAN capability</li>
+<li>Use the unicode API in windows</li>
+}
+
+chng {2005 August 27 (3.2.5)} {
+<li>Fix a bug effecting DELETE and UPDATE statements that changed
+more than 40960 rows.</li>
+<li>Change the makefile so that it no longer requires GNUmake extensions</li>
+<li>Fix the --enable-threadsafe option on the configure script</li>
+<li>Fix a code generator bug that occurs when the left-hand side of an IN
+operator is constant and the right-hand side is a SELECT statement</li>
+<li>The PRAGMA synchronous=off statement now disables syncing of the
+master journal file in addition to the normal rollback journals</li>
+}
+
+chng {2005 August 24 (3.2.4)} {
+<li>Fix a bug introduced in the previous release
+that can cause a segfault while generating code
+for complex WHERE clauses.</li>
+<li>Allow floating point literals to begin or end with a decimal point.</li>
+}
+
+chng {2005 August 21 (3.2.3)} {
+<li>Added support for the CAST operator</li>
+<li>Tcl interface allows BLOB values to be transferred to user-defined
+functions</li>
+<li>Added the "transaction" method to the Tcl interface</li>
+<li>Allow the DEFAULT value of a column to call functions that have constant
+operands</li>
+<li>Added the ANALYZE command for gathering statistics on indices and
+using those statistics when picking an index in the optimizer</li>
+<li>Remove the limit (formerly 100) on the number of terms in the
+WHERE clause</li>
+<li>The right-hand side of the IN operator can now be a list of expressions
+instead of just a list of constants</li>
+<li>Rework the optimizer so that it is able to make better use of indices</li>
+<li>The order of tables in a join is adjusted automatically to make
+better use of indices</li>
+<li>The IN operator is now a candidate for optimization even if the left-hand
+side is not the left-most term of the index.  Multiple IN operators can be
+used with the same index.</li>
+<li>WHERE clause expressions using BETWEEN and OR are now candidates
+for optimization</li>
+<li>Added the "case_sensitive_like" pragma and the SQLITE_CASE_SENSITIVE_LIKE
+compile-time option to set its default value to "on".</li>
+<li>Use indices to help with GLOB expressions and LIKE expressions too
+when the case_sensitive_like pragma is enabled</li>
+<li>Added support for grave-accent quoting for compatibility with MySQL</li>
+<li>Improved test coverage</li>
+<li>Dozens of minor bug fixes</li>
+}
+
+chng {2005 June 13 (3.2.2)} {
+<li>Added the sqlite3_db_handle() API</li>
+<li>Added the sqlite3_get_autocommit() API</li>
+<li>Added a REGEXP operator to the parser.  There is no function to back
+up this operator in the standard build but users can add their own using
+sqlite3_create_function()</li>
+<li>Speed improvements and library footprint reductions.</li>
+<li>Fix byte alignment problems on 64-bit architectures.</li>
+<li>Many, many minor bug fixes and documentation updates.</li>
+}
+
+chng {2005 March 29 (3.2.1)} {
+<li>Fix a memory allocation error in the new ADD COLUMN comment.</li>
+<li>Documentation updates</li>
+}
+
+chng {2005 March 21 (3.2.0)} {
+<li>Added support for ALTER TABLE ADD COLUMN.</li>
+<li>Added support for the "T" separator in ISO-8601 date/time strings.</li>
+<li>Improved support for Cygwin.</li>
+<li>Numerous bug fixes and documentation updates.</li>
+}
+
+chng {2005 March 16 (3.1.6)} {
+<li>Fix a bug that could cause database corruption when inserting
+    record into tables with around 125 columns.</li>
+<li>sqlite3_step() is now much more likely to invoke the busy handler
+    and less likely to return SQLITE_BUSY.</li>
+<li>Fix memory leaks that used to occur after a malloc() failure.</li>
+}
+
+chng {2005 March 11 (3.1.5)} {
+<li>The ioctl on OS-X to control syncing to disk is F_FULLFSYNC,
+    not F_FULLSYNC.  The previous release had it wrong.</li>
+}
+
+chng {2005 March 10 (3.1.4)} {
+<li>Fix a bug in autovacuum that could cause database corruption if
+a CREATE UNIQUE INDEX fails because of a constraint violation.
+This problem only occurs if the new autovacuum feature introduced in
+version 3.1 is turned on.</li>
+<li>The F_FULLSYNC ioctl (currently only supported on OS-X) is disabled
+if the synchronous pragma is set to something other than "full".</li>
+<li>Add additional forward compatibility to the future version 3.2 database 
+file format.</li>
+<li>Fix a bug in WHERE clauses of the form (rowid<'2')</li>
+<li>New SQLITE_OMIT_... compile-time options added</li>
+<li>Updates to the man page</li>
+<li>Remove the use of strcasecmp() from the shell</li>
+<li>Windows DLL exports symbols Tclsqlite_Init and Sqlite_Init</li>
+}
+
+chng {2005 February 19 (3.1.3)} {
+<li>Fix a problem with VACUUM on databases from which tables containing
+AUTOINCREMENT have been dropped.</li>
+<li>Add forward compatibility to the future version 3.2 database file
+format.</li>
+<li>Documentation updates</li>
+}
+
+chng {2005 February 15 (3.1.2)} {
+<li>Fix a bug that can lead to database corruption if there are two
+open connections to the same database and one connection does a VACUUM
+and the second makes some change to the database.</li>
+<li>Allow "?" parameters in the LIMIT clause.</li>
+<li>Fix VACUUM so that it works with AUTOINCREMENT.</li>
+<li>Fix a race condition in AUTOVACUUM that can lead to corrupt databases</li>
+<li>Add a numeric version number to the sqlite3.h include file.</li>
+<li>Other minor bug fixes and performance enhancements.</li>
+}
+
+chng {2005 February 15 (2.8.16)} {
+<li>Fix a bug that can lead to database corruption if there are two
+open connections to the same database and one connection does a VACUUM
+and the second makes some change to the database.</li>
+<li>Correctly handle quoted names in CREATE INDEX statements.</li>
+<li>Fix a naming conflict between sqlite.h and sqlite3.h.</li>
+<li>Avoid excess heap usage when copying expressions.</li>
+<li>Other minor bug fixes.</li>
+}
+
+chng {2005 February 1 (3.1.1 BETA)} {
+<li>Automatic caching of prepared statements in the TCL interface</li>
+<li>ATTACH and DETACH as well as some other operations cause existing
+    prepared statements to expire.</li>
+<li>Numerious minor bug fixes</li>
+}
+
+chng {2005 January 21 (3.1.0 ALPHA)} {
+<li>Autovacuum support added</li>
+<li>CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP added</li>
+<li>Support for the EXISTS clause added.</li>
+<li>Support for correlated subqueries added.</li>
+<li>Added the ESCAPE clause on the LIKE operator.</li>
+<li>Support for ALTER TABLE ... RENAME TABLE ... added</li>
+<li>AUTOINCREMENT keyword supported on INTEGER PRIMARY KEY</li>
+<li>Many SQLITE_OMIT_ macros inserts to omit features at compile-time
+    and reduce the library footprint.</li>
+<li>The REINDEX command was added.</li>
+<li>The engine no longer consults the main table if it can get
+    all the information it needs from an index.</li>
+<li>Many nuisance bugs fixed.</li>
+}
+
+chng {2004 October 11 (3.0.8)} {
+<li>Add support for DEFERRED, IMMEDIATE, and EXCLUSIVE transactions.</li>
+<li>Allow new user-defined functions to be created when there are
+already one or more precompiled SQL statements.<li>
+<li>Fix portability problems for Mingw/MSYS.</li>
+<li>Fix a byte alignment problem on 64-bit Sparc machines.</li>
+<li>Fix the ".import" command of the shell so that it ignores \r
+characters at the end of lines.</li>
+<li>The "csv" mode option in the shell puts strings inside double-quotes.</li>
+<li>Fix typos in documentation.</li>
+<li>Convert array constants in the code to have type "const".</li>
+<li>Numerous code optimizations, specially optimizations designed to
+make the code footprint smaller.</li>
+}
+
+chng {2004 September 18 (3.0.7)} {
+<li>The BTree module allocates large buffers using malloc() instead of
+    off of the stack, in order to play better on machines with limited
+    stack space.</li>
+<li>Fixed naming conflicts so that versions 2.8 and 3.0 can be
+    linked and used together in the same ANSI-C source file.</li>
+<li>New interface: sqlite3_bind_parameter_index()</li>
+<li>Add support for wildcard parameters of the form: "?nnn"</li>
+<li>Fix problems found on 64-bit systems.</li>
+<li>Removed encode.c file (containing unused routines) from the 
+    version 3.0 source tree.</li>
+<li>The sqlite3_trace() callbacks occur before each statement
+    is executed, not when the statement is compiled.</li>
+<li>Makefile updates and miscellaneous bug fixes.</li>
+}
+
+chng {2004 September 02 (3.0.6 beta)} {
+<li>Better detection and handling of corrupt database files.</li>
+<li>The sqlite3_step() interface returns SQLITE_BUSY if it is unable
+    to commit a change because of a lock</li>
+<li>Combine the implementations of LIKE and GLOB into a single
+    pattern-matching subroutine.</li>
+<li>Miscellaneous code size optimizations and bug fixes</li>
+}
+
+chng {2004 August 29 (3.0.5 beta)} {
+<li>Support for ":AAA" style bind parameter names.</li>
+<li>Added the new sqlite3_bind_parameter_name() interface.</li>
+<li>Support for TCL variable names embedded in SQL statements in the
+    TCL bindings.</li>
+<li>The TCL bindings transfer data without necessarily doing a conversion
+    to a string.</li>
+<li>The database for TEMP tables is not created until it is needed.</li>
+<li>Add the ability to specify an alternative temporary file directory
+    using the "sqlite_temp_directory" global variable.</li>
+<li>A compile-time option (SQLITE_BUSY_RESERVED_LOCK) causes the busy
+    handler to be called when there is contention for a RESERVED lock.</li>
+<li>Various bug fixes and optimizations</li>
+}
+
+chng {2004 August 8 (3.0.4 beta)} {
+<li>CREATE TABLE and DROP TABLE now work correctly as prepared statements.</li>
+<li>Fix a bug in VACUUM and UNIQUE indices.</li>
+<li>Add the ".import" command to the command-line shell.</li>
+<li>Fix a bug that could cause index corruption when an attempt to
+    delete rows of a table is blocked by a pending query.</li>
+<li>Library size optimizations.</li>
+<li>Other minor bug fixes.</li>
+}
+
+chng {2004 July 22 (2.8.15)} {
+<li>This is a maintenance release only.  Various minor bugs have been
+fixed and some portability enhancements are added.</li>
+}
+
+chng {2004 July 22 (3.0.3 beta)} {
+<li>The second beta release for SQLite 3.0.</li>
+<li>Add support for "PRAGMA page_size" to adjust the page size of
+the database.</li>
+<li>Various bug fixes and documentation updates.</li>
+}
+
+chng {2004 June 30 (3.0.2 beta)} {
+<li>The first beta release for SQLite 3.0.</li>
+}
+
+chng {2004 June 22 (3.0.1 alpha)} {
+<li><font color="red"><b>
+    *** Alpha Release - Research And Testing Use Only ***</b></font>
+<li>Lots of bug fixes.</li>
+}
+
+chng {2004 June 18 (3.0.0 alpha)} {
+<li><font color="red"><b>
+    *** Alpha Release - Research And Testing Use Only ***</b></font>
+<li>Support for internationalization including UTF-8, UTF-16, and
+    user defined collating sequences.</li>
+<li>New file format that is 25% to 35% smaller for typical use.</li>
+<li>Improved concurrency.</li>
+<li>Atomic commits for ATTACHed databases.</li>
+<li>Remove cruft from the APIs.</li>
+<li>BLOB support.</li>
+<li>64-bit rowids.</li>
+<li><a href="version3.html">More information</a>.
+}
+
+chng {2004 June 9 (2.8.14)} {
+<li>Fix the min() and max() optimizer so that it works when the FROM
+    clause consists of a subquery.</li>
+<li>Ignore extra whitespace at the end of of "." commands in the shell.</li>
+<li>Bundle sqlite_encode_binary() and sqlite_decode_binary() with the 
+    library.</li>
+<li>The TEMP_STORE and DEFAULT_TEMP_STORE pragmas now work.</li>
+<li>Code changes to compile cleanly using OpenWatcom.</li>
+<li>Fix VDBE stack overflow problems with INSTEAD OF triggers and
+    NULLs in IN operators.</li>
+<li>Add the global variable sqlite_temp_directory which if set defines the
+    directory in which temporary files are stored.</li>
+<li>sqlite_interrupt() plays well with VACUUM.</li>
+<li>Other minor bug fixes.</li>
+}
+
+chng {2004 March 8 (2.8.13)} {
+<li>Refactor parts of the code in order to make the code footprint
+    smaller.  The code is now also a little bit faster.</li>
+<li>sqlite_exec() is now implemented as a wrapper around sqlite_compile()
+    and sqlite_step().</li>
+<li>The built-in min() and max() functions now honor the difference between
+    NUMERIC and TEXT datatypes.  Formerly, min() and max() always assumed
+    their arguments were of type NUMERIC.</li>
+<li>New HH:MM:SS modifier to the built-in date/time functions.</li>
+<li>Experimental sqlite_last_statement_changes() API added.  Fixed the
+    the last_insert_rowid() function so that it works correctly with
+    triggers.</li>
+<li>Add functions prototypes for the database encryption API.</li>
+<li>Fix several nuisance bugs.</li>
+}
+
+chng {2004 February 8 (2.8.12)} {
+<li>Fix a bug that will might corrupt the rollback journal if a power failure
+    or external program halt occurs in the middle of a COMMIT.  The corrupt
+    journal can lead to database corruption when it is rolled back.</li>
+<li>Reduce the size and increase the speed of various modules, especially
+    the virtual machine.</li>
+<li>Allow "&lt;expr&gt; IN &lt;table&gt;" as a shorthand for
+    "&lt;expr&gt; IN (SELECT * FROM &lt;table&gt;".</li>
+<li>Optimizations to the sqlite_mprintf() routine.</li>
+<li>Make sure the MIN() and MAX() optimizations work within subqueries.</li>
+}
+
+chng {2004 January 14 (2.8.11)} {
+<li>Fix a bug in how the IN operator handles NULLs in subqueries.  The bug
+    was introduced by the previous release.</li>
+}
+
+chng {2004 January 13 (2.8.10)} {
+<li>Fix a potential database corruption problem on Unix caused by the fact
+    that all posix advisory locks are cleared whenever you close() a file.
+    The work around it to embargo all close() calls while locks are 
+    outstanding.</li>
+<li>Performance enhancements on some corner cases of COUNT(*).</li>
+<li>Make sure the in-memory backend response sanely if malloc() fails.</li>
+<li>Allow sqlite_exec() to be called from within user-defined SQL
+    functions.</li>
+<li>Improved accuracy of floating-point conversions using "long double".</li>
+<li>Bug fixes in the experimental date/time functions.</li>
+}
+
+chng {2004 January 5 (2.8.9)} {
+<li>Fix a 32-bit integer overflow problem that could result in corrupt
+    indices in a database if large negative numbers (less than -2147483648)
+    were inserted into a indexed numeric column.</li>
+<li>Fix a locking problem on multi-threaded Linux implementations.</li>
+<li>Always use "." instead of "," as the decimal point even if the locale
+    requests ",".</li>
+<li>Added UTC to localtime conversions to the experimental date/time
+    functions.</li>
+<li>Bug fixes to date/time functions.</li>
+}
+
+chng {2003 December 17 (2.8.8)} {
+<li>Fix a critical bug introduced into 2.8.0 which could cause
+    database corruption.</li>
+<li>Fix a problem with 3-way joins that do not use indices</li>
+<li>The VACUUM command now works with the non-callback API</li>
+<li>Improvements to the "PRAGMA integrity_check" command</li>
+}
+
+chng {2003 December 4 (2.8.7)} {
+<li>Added experimental sqlite_bind() and sqlite_reset() APIs.</li>
+<li>If the name of the database is an empty string, open a new database
+    in a temporary file that is automatically deleted when the database
+    is closed.</li>
+<li>Performance enhancements in the lemon-generated parser</li>
+<li>Experimental date/time functions revised.</li>
+<li>Disallow temporary indices on permanent tables.</li>
+<li>Documentation updates and typo fixes</li>
+<li>Added experimental sqlite_progress_handler() callback API</li>
+<li>Removed support for the Oracle8 outer join syntax.</li>
+<li>Allow GLOB and LIKE operators to work as functions.</li>
+<li>Other minor documentation and makefile changes and bug fixes.</li>
+}
+
+chng {2003 August 21 (2.8.6)} {
+<li>Moved the CVS repository to www.sqlite.org</li>
+<li>Update the NULL-handling documentation.</li>
+<li>Experimental date/time functions added.</li>
+<li>Bug fix: correctly evaluate a view of a view without segfaulting.</li>
+<li>Bug fix: prevent database corruption if you dropped a
+    trigger that had the same name as a table.</li>
+<li>Bug fix: allow a VACUUM (without segfaulting) on an empty
+    database after setting the EMPTY_RESULT_CALLBACKS pragma.</li>
+<li>Bug fix: if an integer value will not fit in a 32-bit int, store it in
+    a double instead.</li>
+<li>Bug fix: Make sure the journal file directory entry is committed to disk
+    before writing the database file.</li>
+}
+
+chng {2003 July 22 (2.8.5)} {
+<li>Make LIMIT work on a compound SELECT statement.</li>
+<li>LIMIT 0 now shows no rows.  Use LIMIT -1 to see all rows.</li>
+<li>Correctly handle comparisons between an INTEGER PRIMARY KEY and
+    a floating point number.</li>
+<li>Fix several important bugs in the new ATTACH and DETACH commands.</li>
+<li>Updated the <a href="nulls.html">NULL-handling document</a>.</li> 
+<li>Allow NULL arguments in sqlite_compile() and sqlite_step().</li>
+<li>Many minor bug fixes</li>
+}
+
+chng {2003 June 29 (2.8.4)} {
+<li>Enhanced the "PRAGMA integrity_check" command to verify indices.</li>
+<li>Added authorization hooks for the new ATTACH and DETACH commands.</li>
+<li>Many documentation updates</li>
+<li>Many minor bug fixes</li>
+}
+
+chng {2003 June 4 (2.8.3)} {
+<li>Fix a problem that will corrupt the indices on a table if you
+    do an INSERT OR REPLACE or an UPDATE OR REPLACE on a table that
+    contains an INTEGER PRIMARY KEY plus one or more indices.</li>
+<li>Fix a bug in windows locking code so that locks work correctly
+    when simultaneously accessed by Win95 and WinNT systems.</li>
+<li>Add the ability for INSERT and UPDATE statements to refer to the
+    "rowid" (or "_rowid_" or "oid") columns.</li>
+<li>Other important bug fixes</li>
+}
+
+chng {2003 May 17 (2.8.2)} {
+<li>Fix a problem that will corrupt the database file if you drop a
+    table from the main database that has a TEMP index.</li>
+}
+
+chng {2003 May 16 (2.8.1)} {
+<li>Reactivated the VACUUM command that reclaims unused disk space in 
+    a database file.</li>
+<li>Added the ATTACH and DETACH commands to allow interacting with multiple
+    database files at the same time.</li>
+<li>Added support for TEMP triggers and indices.</li>
+<li>Added support for in-memory databases.</li>
+<li>Removed the experimental sqlite_open_aux_file().  Its function is
+    subsumed in the new ATTACH command.</li>
+<li>The precedence order for ON CONFLICT clauses was changed so that
+    ON CONFLICT clauses on BEGIN statements have a higher precedence than
+    ON CONFLICT clauses on constraints.
+<li>Many, many bug fixes and compatibility enhancements.</li>
+}
+
+chng {2003 Feb 16 (2.8.0)} {
+<li>Modified the journal file format to make it more resistant to corruption
+    that can occur after an OS crash or power failure.</li>
+<li>Added a new C/C++ API that does not use callback for returning data.</li>
+}
+
+chng {2003 Jan 25 (2.7.6)} {
+<li>Performance improvements.  The library is now much faster.</li>
+<li>Added the <b>sqlite_set_authorizer()</b> API.  Formal documentation has
+    not been written - see the source code comments for instructions on
+    how to use this function.</li>
+<li>Fix a bug in the GLOB operator that was preventing it from working
+    with upper-case letters.</li>
+<li>Various minor bug fixes.</li>
+}
+
+chng {2002 Dec 27 (2.7.5)} {
+<li>Fix an uninitialized variable in pager.c which could (with a probability
+    of about 1 in 4 billion) result in a corrupted database.</li>
+}
+
+chng {2002 Dec 17 (2.7.4)} {
+<li>Database files can now grow to be up to 2^41 bytes.  The old limit
+    was 2^31 bytes.</li>
+<li>The optimizer will now scan tables in the reverse if doing so will
+    satisfy an ORDER BY ... DESC clause.</li>
+<li>The full pathname of the database file is now remembered even if
+    a relative path is passed into sqlite_open().  This allows 
+    the library to continue operating correctly after a chdir().</li>
+<li>Speed improvements in the VDBE.</li>
+<li>Lots of little bug fixes.</li>
+}
+
+chng {2002 Oct 30 (2.7.3)} {
+<li>Various compiler compatibility fixes.</li>
+<li>Fix a bug in the "expr IN ()" operator.</li>
+<li>Accept column names in parentheses.</li>
+<li>Fix a problem with string memory management in the VDBE</li>
+<li>Fix a bug in the "table_info" pragma"</li>
+<li>Export the sqlite_function_type() API function in the Windows DLL</li>
+<li>Fix locking behavior under windows</li>
+<li>Fix a bug in LEFT OUTER JOIN</li>
+}
+
+chng {2002 Sep 25 (2.7.2)} {
+<li>Prevent journal file overflows on huge transactions.</li>
+<li>Fix a memory leak that occurred when sqlite_open() failed.</li>
+<li>Honor the ORDER BY and LIMIT clause of a SELECT even if the
+    result set is used for an INSERT.</li>
+<li>Do not put write locks on the file used to hold TEMP tables.</li>
+<li>Added documentation on SELECT DISTINCT and on how SQLite handles NULLs.</li>
+<li>Fix a problem that was causing poor performance when many thousands
+    of SQL statements were executed by a single sqlite_exec() call.</li>
+}
+
+chng {2002 Aug 31 (2.7.1)} {
+<li>Fix a bug in the ORDER BY logic that was introduced in version 2.7.0</li>
+<li>C-style comments are now accepted by the tokenizer.</li>
+<li>INSERT runs a little faster when the source is a SELECT statement.</li>
+}
+
+chng {2002 Aug 25 (2.7.0)} {
+<li>Make a distinction between numeric and text values when sorting.
+    Text values sort according to memcmp().  Numeric values sort in
+    numeric order.</li>
+<li>Allow multiple simultaneous readers under windows by simulating
+    the reader/writers locks that are missing from Win95/98/ME.</li>
+<li>An error is now returned when trying to start a transaction if
+    another transaction is already active.</li>
+}
+
+chng {2002 Aug 12 (2.6.3)} {
+<li>Add the ability to read both little-endian and big-endian databases.
+    So database created under SunOS or MacOSX can be read and written
+    under Linux or Windows and vice versa.</li>
+<li>Convert to the new website: http://www.sqlite.org/</li>
+<li>Allow transactions to span Linux Threads</li>
+<li>Bug fix in the processing of the ORDER BY clause for GROUP BY queries</li>
+}
+
+chng {2002 Jly 30 (2.6.2)} {
+<li>Text files read by the COPY command can now have line terminators
+    of LF,  CRLF, or CR.</li>
+<li>SQLITE_BUSY is handled correctly if encountered during database
+    initialization.</li>
+<li>Fix to UPDATE triggers on TEMP tables.</li>
+<li>Documentation updates.</li>
+}
+
+chng {2002 Jly 19 (2.6.1)} {
+<li>Include a static string in the library that responds to the RCS
+    "ident" command and which contains the library version number.</li>
+<li>Fix an assertion failure that occurred when deleting all rows of
+    a table with the "count_changes" pragma turned on.</li>
+<li>Better error reporting when problems occur during the automatic
+    2.5.6 to 2.6.0 database format upgrade.</li>
+}
+
+chng {2002 Jly 17 (2.6.0)} {
+<li>Change the format of indices to correct a design flaw the originated
+    with version 2.1.0.  <font color="red">*** This is an incompatible
+    file format change ***</font>  When version 2.6.0 or later of the
+    library attempts to open a database file created by version 2.5.6 or
+    earlier, it will automatically and irreversibly convert the file format.
+    <b>Make backup copies of older database files before opening them with
+    version 2.6.0 of the library.</b>
+    </li>
+}
+
+chng {2002 Jly 7 (2.5.6)} {
+<li>Fix more problems with rollback.  Enhance the test suite to exercise
+    the rollback logic extensively in order to prevent any future problems.
+    </li>
+}
+
+chng {2002 Jly 6 (2.5.5)} {
+<li>Fix a bug which could cause database corruption during a rollback.
+    This bugs was introduced in version 2.4.0 by the freelist
+    optimization of checking [410].</li>
+<li>Fix a bug in aggregate functions for VIEWs.</li>
+<li>Other minor changes and enhancements.</li>
+}
+
+chng {2002 Jly 1 (2.5.4)} {
+<li>Make the "AS" keyword optional again.</li>
+<li>The datatype of columns now appear in the 4th argument to the
+    callback.</li>
+<li>Added the <b>sqlite_open_aux_file()</b> API, though it is still
+    mostly undocumented and untested.</li>
+<li>Added additional test cases and fixed a few bugs that those
+    test cases found.</li>
+}
+
+chng {2002 Jun 24 (2.5.3)} {
+<li>Bug fix:  Database corruption can occur due to the optimization
+    that was introduced in version 2.4.0 (check-in [410]).  The problem
+    should now be fixed.  The use of versions 2.4.0 through 2.5.2 is
+    not recommended.</li>
+}
+
+chng {2002 Jun 24 (2.5.2)} {
+<li>Added the new <b>SQLITE_TEMP_MASTER</b> table which records the schema
+    for temporary tables in the same way that <b>SQLITE_MASTER</b> does for
+    persistent tables.</li>
+<li>Added an optimization to UNION ALL</li>
+<li>Fixed a bug in the processing of LEFT OUTER JOIN</li>
+<li>The LIMIT clause now works on subselects</li>
+<li>ORDER BY works on subselects</li>
+<li>There is a new TypeOf() function used to determine if an expression
+    is numeric or text.</li>
+<li>Autoincrement now works for INSERT from a SELECT.</li>
+}
+
+chng {2002 Jun 19 (2.5.1)} {
+<li>The query optimizer now attempts to implement the ORDER BY clause
+    using an index.  Sorting is still used if not suitable index is
+    available.</li>
+}
+
+chng {2002 Jun 17 (2.5.0)} {
+<li>Added support for row triggers.</li>
+<li>Added SQL-92 compliant handling of NULLs.</li>
+<li>Add support for the full SQL-92 join syntax and LEFT OUTER JOINs.</li>
+<li>Double-quoted strings interpreted as column names not text literals.</li>
+<li>Parse (but do not implement) foreign keys.</li>
+<li>Performance improvements in the parser, pager, and WHERE clause code
+    generator.</li>
+<li>Make the LIMIT clause work on subqueries.  (ORDER BY still does not
+    work, though.)</li>
+<li>Added the "%Q" expansion to sqlite_*_printf().</li>
+<li>Bug fixes too numerous to mention (see the change log).</li>
+}
+
+chng {2002 May 09 (2.4.12)} {
+<li>Added logic to detect when the library API routines are called out
+    of sequence.</li>
+}
+
+chng {2002 May 08 (2.4.11)} {
+<li>Bug fix: Column names in the result set were not being generated
+    correctly for some (rather complex) VIEWs.  This could cause a
+    segfault under certain circumstances.</li>
+}
+
+chng {2002 May 02 (2.4.10)} {
+<li>Bug fix: Generate correct column headers when a compound SELECT is used
+    as a subquery.</li>
+<li>Added the sqlite_encode_binary() and sqlite_decode_binary() functions to
+    the source tree.  But they are not yet linked into the library.</li>
+<li>Documentation updates.</li>
+<li>Export the sqlite_changes() function from windows DLLs.</li>
+<li>Bug fix: Do not attempt the subquery flattening optimization on queries
+    that lack a FROM clause.  To do so causes a segfault.</li>
+}
+
+chng {2002 Apr 21 (2.4.9)} {
+<li>Fix a bug that was causing the precompiled binary of SQLITE.EXE to
+    report "out of memory" under Windows 98.</li>
+}
+
+chng {2002 Apr 20 (2.4.8)} {
+<li>Make sure VIEWs are created after their corresponding TABLEs in the
+    output of the <b>.dump</b> command in the shell.</li>
+<li>Speed improvements: Do not do synchronous updates on TEMP tables.</li>
+<li>Many improvements and enhancements to the shell.</li>
+<li>Make the GLOB and LIKE operators functions that can be overridden
+    by a programmer.  This allows, for example, the LIKE operator to
+    be changed to be case sensitive.</li>
+}
+
+chng {2002 Apr 06 (2.4.7)} {
+<li>Add the ability to put TABLE.* in the column list of a
+    SELECT statement.</li>
+<li>Permit SELECT statements without a FROM clause.</li>
+<li>Added the <b>last_insert_rowid()</b> SQL function.</li>
+<li>Do not count rows where the IGNORE conflict resolution occurs in
+    the row count.</li>
+<li>Make sure functions expressions in the VALUES clause of an INSERT
+    are correct.</li>
+<li>Added the <b>sqlite_changes()</b> API function to return the number
+    of row that changed in the most recent operation.</li>
+}
+
+chng {2002 Apr 02 (2.4.6)} {
+<li>Bug fix: Correctly handle terms in the WHERE clause of a join that
+    do not contain a comparison operator.</li>
+}
+
+chng {2002 Apr 01 (2.4.5)} {
+<li>Bug fix: Correctly handle functions that appear in the WHERE clause
+    of a join.</li>
+<li>When the PRAGMA vdbe_trace=ON is set, correctly print the P3 operand
+    value when it is a pointer to a structure rather than a pointer to
+    a string.</li>
+<li>When inserting an explicit NULL into an INTEGER PRIMARY KEY, convert
+    the NULL value into a unique key automatically.</li>
+}
+
+chng {2002 Mar 24 (2.4.4)} {
+<li>Allow "VIEW" to be a column name</li>
+<li>Added support for CASE expressions (patch from Dan Kennedy)</li>
+<li>Added RPMS to the delivery (patches from Doug Henry)</li>
+<li>Fix typos in the documentation</li>
+<li>Cut over configuration management to a new CVS repository with
+    its own CVSTrac bug tracking system.</li>
+}
+
+chng {2002 Mar 22 (2.4.3)} {
+<li>Fix a bug in SELECT that occurs when a compound SELECT is used as a
+    subquery in the FROM of a SELECT.</li>
+<li>The <b>sqlite_get_table()</b> function now returns an error if you
+    give it two or more SELECTs that return different numbers of columns.</li>
+}
+
+chng {2002 Mar 14 (2.4.2)} {
+<li>Bug fix: Fix an assertion failure that occurred when ROWID was a column
+    in a SELECT statement on a view.</li>
+<li>Bug fix: Fix an uninitialized variable in the VDBE that would could an
+    assert failure.</li>
+<li>Make the os.h header file more robust in detecting when the compile is
+    for windows and when it is for unix.</li>
+}
+
+chng {2002 Mar 13 (2.4.1)} {
+<li>Using an unnamed subquery in a FROM clause would cause a segfault.</li>
+<li>The parser now insists on seeing a semicolon or the end of input before
+    executing a statement.  This avoids an accidental disaster if the
+    WHERE keyword is misspelled in an UPDATE or DELETE statement.</li>
+}
+
+
+chng {2002 Mar 10 (2.4.0)} {
+<li>Change the name of the sanity_check PRAGMA to <b>integrity_check</b>
+    and make it available in all compiles.</li>
+<li>SELECT min() or max() of an indexed column with no WHERE or GROUP BY
+    clause is handled as a special case which avoids a complete table scan.</li>
+<li>Automatically generated ROWIDs are now sequential.</li>
+<li>Do not allow dot-commands of the command-line shell to occur in the
+    middle of a real SQL command.</li>
+<li>Modifications to the "lemon" parser generator so that the parser tables
+    are 4 times smaller.</li>
+<li>Added support for user-defined functions implemented in C.</li>
+<li>Added support for new functions: <b>coalesce()</b>, <b>lower()</b>,
+    <b>upper()</b>, and <b>random()</b>
+<li>Added support for VIEWs.</li>
+<li>Added the subquery flattening optimizer.</li>
+<li>Modified the B-Tree and Pager modules so that disk pages that do not
+    contain real data (free pages) are not journaled and are not
+    written from memory back to the disk when they change.  This does not 
+    impact database integrity, since the
+    pages contain no real data, but it does make large INSERT operations
+    about 2.5 times faster and large DELETEs about 5 times faster.</li>
+<li>Made the CACHE_SIZE pragma persistent</li>
+<li>Added the SYNCHRONOUS pragma</li>
+<li>Fixed a bug that was causing updates to fail inside of transactions when
+    the database contained a temporary table.</li>
+}
+
+chng {2002 Feb 18 (2.3.3)} {
+<li>Allow identifiers to be quoted in square brackets, for compatibility
+    with MS-Access.</li>
+<li>Added support for sub-queries in the FROM clause of a SELECT.</li>
+<li>More efficient implementation of sqliteFileExists() under Windows.
+    (by Joel Luscy)</li>
+<li>The VALUES clause of an INSERT can now contain expressions, including
+    scalar SELECT clauses.</li>
+<li>Added support for CREATE TABLE AS SELECT</li>
+<li>Bug fix: Creating and dropping a table all within a single
+    transaction was not working.</li>
+}
+
+chng {2002 Feb 14 (2.3.2)} {
+<li>Bug fix: There was an incorrect assert() in pager.c.  The real code was
+    all correct (as far as is known) so everything should work OK if you
+    compile with -DNDEBUG=1.  When asserts are not disabled, there
+    could be a fault.</li>
+}
+
+chng {2002 Feb 13 (2.3.1)} {
+<li>Bug fix: An assertion was failing if "PRAGMA full_column_names=ON;" was
+    set and you did a query that used a rowid, like this:  
+    "SELECT rowid, * FROM ...".</li>
+}
+
+chng {2002 Jan 30 (2.3.0)} {
+<li>Fix a serious bug in the INSERT command which was causing data to go
+    into the wrong columns if the data source was a SELECT and the INSERT
+    clauses specified its columns in some order other than the default.</li>
+<li>Added the ability to resolve constraint conflicts is ways other than
+    an abort and rollback.  See the documentation on the "ON CONFLICT"
+    clause for details.</li>
+<li>Temporary files are now automatically deleted by the operating system
+    when closed.  There are no more dangling temporary files on a program
+    crash.  (If the OS crashes, fsck will delete the file after reboot 
+    under Unix.  I do not know what happens under Windows.)</li>
+<li>NOT NULL constraints are honored.</li>
+<li>The COPY command puts NULLs in columns whose data is '\N'.</li>
+<li>In the COPY command, backslash can now be used to escape a newline.</li>
+<li>Added the SANITY_CHECK pragma.</li>
+}
+
+chng {2002 Jan 28 (2.2.5)} {
+<li>Important bug fix: the IN operator was not working if either the
+    left-hand or right-hand side was derived from an INTEGER PRIMARY KEY.</li>
+<li>Do not escape the backslash '\' character in the output of the
+    <b>sqlite</b> command-line access program.</li>
+}
+
+chng {2002 Jan 22 (2.2.4)} {
+<li>The label to the right of an AS in the column list of a SELECT can now
+    be used as part of an expression in the WHERE, ORDER BY, GROUP BY, and/or
+    HAVING clauses.</li>
+<li>Fix a bug in the <b>-separator</b> command-line option to the <b>sqlite</b>
+    command.</li>
+<li>Fix a problem with the sort order when comparing upper-case strings against
+    characters greater than 'Z' but less than 'a'.</li>
+<li>Report an error if an ORDER BY or GROUP BY expression is constant.</li>
+}
+
+chng {2002 Jan 16 (2.2.3)} {
+<li>Fix warning messages in VC++ 7.0.  (Patches from nicolas352001)</li>
+<li>Make the library thread-safe.  (The code is there and appears to work
+    but has not been stressed.)</li>
+<li>Added the new <b>sqlite_last_insert_rowid()</b> API function.</li>
+}
+
+chng {2002 Jan 13 (2.2.2)} {
+<li>Bug fix: An assertion was failing when a temporary table with an index
+    had the same name as a permanent table created by a separate process.</li>
+<li>Bug fix: Updates to tables containing an INTEGER PRIMARY KEY and an
+    index could fail.</li>
+}
+
+chng {2002 Jan 9 (2.2.1)} {
+<li>Bug fix: An attempt to delete a single row of a table with a WHERE
+    clause of "ROWID=x" when no such rowid exists was causing an error.</li>
+<li>Bug fix: Passing in a NULL as the 3rd parameter to <b>sqlite_open()</b>
+    would sometimes cause a coredump.</li>
+<li>Bug fix: DROP TABLE followed by a CREATE TABLE with the same name all
+    within a single transaction was causing a coredump.</li>
+<li>Makefile updates from A. Rottmann</li>
+}
+
+chng {2001 Dec 22 (2.2.0)} {
+<li>Columns of type INTEGER PRIMARY KEY are actually used as the primary
+    key in underlying B-Tree representation of the table.</li>
+<li>Several obscure, unrelated bugs were found and fixed while 
+    implemented the integer primary key change of the previous bullet.</li>
+<li>Added the ability to specify "*" as part of a larger column list in
+    the result section of a SELECT statement.  For example:
+    <nobr>"<b>SELECT rowid, * FROM table1;</b>"</nobr>.</li>
+<li>Updates to comments and documentation.</li>
+}
+
+chng {2001 Dec 14 (2.1.7)} {
+<li>Fix a bug in <b>CREATE TEMPORARY TABLE</b> which was causing the
+    table to be initially allocated in the main database file instead
+    of in the separate temporary file.  This bug could cause the library
+    to suffer an assertion failure and it could cause "page leaks" in the
+    main database file.
+<li>Fix a bug in the b-tree subsystem that could sometimes cause the first
+    row of a table to be repeated during a database scan.</li>
+}
+
+chng {2001 Dec 14 (2.1.6)} {
+<li>Fix the locking mechanism yet again to prevent
+    <b>sqlite_exec()</b> from returning SQLITE_PROTOCOL
+    unnecessarily.  This time the bug was a race condition in
+    the locking code.  This change effects both POSIX and Windows users.</li>
+}
+
+chng {2001 Dec 6 (2.1.5)} {
+<li>Fix for another problem (unrelated to the one fixed in 2.1.4) 
+    that sometimes causes <b>sqlite_exec()</b> to return SQLITE_PROTOCOL
+    unnecessarily.  This time the bug was
+    in the POSIX locking code and should not effect windows users.</li>
+}
+
+chng {2001 Dec 4 (2.1.4)} {
+<li>Sometimes <b>sqlite_exec()</b> would return SQLITE_PROTOCOL when it
+    should have returned SQLITE_BUSY.</li>
+<li>The fix to the previous bug uncovered a deadlock which was also
+    fixed.</li>
+<li>Add the ability to put a single .command in the second argument
+    of the sqlite shell</li>
+<li>Updates to the FAQ</li>
+}
+
+chng {2001 Nov 23 (2.1.3)} {
+<li>Fix the behavior of comparison operators 
+    (ex: "<b>&lt</b>", "<b>==</b>", etc.)
+    so that they are consistent with the order of entries in an index.</li>
+<li>Correct handling of integers in SQL expressions that are larger than
+    what can be represented by the machine integer.</li>
+}
+
+chng {2001 Nov 22 (2.1.2)} {
+<li>Changes to support 64-bit architectures.</li>
+<li>Fix a bug in the locking protocol.</li>
+<li>Fix a bug that could (rarely) cause the database to become 
+    unreadable after a DROP TABLE due to corruption to the SQLITE_MASTER
+    table.</li>
+<li>Change the code so that version 2.1.1 databases that were rendered 
+    unreadable by the above bug can be read by this version of
+    the library even though the SQLITE_MASTER table is (slightly)
+    corrupted.</li>
+}
+
+chng {2001 Nov 13 (2.1.1)} {
+<li>Bug fix: Sometimes arbitrary strings were passed to the callback
+    function when the actual value of a column was NULL.</li>
+}
+
+chng {2001 Nov 12 (2.1.0)} {
+<li>Change the format of data records so that records up to 16MB in size
+    can be stored.</li>
+<li>Change the format of indices to allow for better query optimization.</li>
+<li>Implement the "LIMIT ... OFFSET ..." clause on SELECT statements.</li>
+}
+
+chng {2001 Nov 3 (2.0.8)} {
+<li>Made selected parameters in API functions <b>const</b>. This should
+    be fully backwards compatible.</li>
+<li>Documentation updates</li>
+<li>Simplify the design of the VDBE by restricting the number of sorters
+    and lists to 1.
+    In practice, no more than one sorter and one list was ever used anyhow.
+    </li>
+}
+
+chng {2001 Oct 21 (2.0.7)} {
+<li>Any UTF-8 character or ISO8859 character can be used as part of
+    an identifier.</li>
+<li>Patches from Christian Werner to improve ODBC compatibility and to
+    fix a bug in the round() function.</li>
+<li>Plug some memory leaks that use to occur if malloc() failed.
+    We have been and continue to be memory leak free as long as
+    malloc() works.</li>
+<li>Changes to some test scripts so that they work on Windows in
+    addition to Unix.</li>
+}
+
+chng {2001 Oct 19 (2.0.6)} {
+<li>Added the EMPTY_RESULT_CALLBACKS pragma</li>
+<li>Support for UTF-8 and ISO8859 characters in column and table names.</li>
+<li>Bug fix: Compute correct table names with the FULL_COLUMN_NAMES pragma
+    is turned on.</li>
+}
+
+chng {2001 Oct 14 (2.0.5)} {
+<li>Added the COUNT_CHANGES pragma.</li>
+<li>Changes to the FULL_COLUMN_NAMES pragma to help out the ODBC driver.</li>
+<li>Bug fix: "SELECT count(*)" was returning NULL for empty tables.
+    Now it returns 0.</li>
+}
+
+chng {2001 Oct 13 (2.0.4)} {
+<li>Bug fix: an obscure and relatively harmless bug was causing one of
+    the tests to fail when gcc optimizations are turned on.  This release
+    fixes the problem.</li>
+}
+
+chng {2001 Oct 13 (2.0.3)} {
+<li>Bug fix: the <b>sqlite_busy_timeout()</b> function was delaying 1000
+    times too long before failing.</li>
+<li>Bug fix: an assertion was failing if the disk holding the database
+    file became full or stopped accepting writes for some other reason.
+    New tests were added to detect similar problems in the future.</li>
+<li>Added new operators: <b>&amp;</b> (bitwise-and)
+    <b>|</b> (bitwise-or), <b>~</b> (ones-complement),
+    <b>&lt;&lt;</b> (shift left), <b>&gt;&gt;</b> (shift right).</li>
+<li>Added new functions: <b>round()</b> and <b>abs()</b>.</li>
+}
+
+chng {2001 Oct 9 (2.0.2)} {
+<li>Fix two bugs in the locking protocol.  (One was masking the other.)</li>
+<li>Removed some unused "#include <unistd.h>" that were causing problems
+    for VC++.</li>
+<li>Fixed <b>sqlite.h</b> so that it is usable from C++</li>
+<li>Added the FULL_COLUMN_NAMES pragma.  When set to "ON", the names of
+    columns are reported back as TABLE.COLUMN instead of just COLUMN.</li>
+<li>Added the TABLE_INFO() and INDEX_INFO() pragmas to help support the
+    ODBC interface.</li>
+<li>Added support for TEMPORARY tables and indices.</li>
+}
+
+chng {2001 Oct 2 (2.0.1)} {
+<li>Remove some C++ style comments from btree.c so that it will compile
+    using compilers other than gcc.</li>
+<li>The ".dump" output from the shell does not work if there are embedded
+    newlines anywhere in the data.  This is an old bug that was carried
+    forward from version 1.0.  To fix it, the ".dump" output no longer
+    uses the COPY command.  It instead generates INSERT statements.</li>
+<li>Extend the expression syntax to support "expr NOT NULL" (with a
+    space between the "NOT" and the "NULL") in addition to "expr NOTNULL"
+    (with no space).</li>
+}
+
+chng {2001 Sep 28 (2.0.0)} {
+<li>Automatically build binaries for Linux and Windows and put them on
+    the website.</li>
+}
+
+chng {2001 Sep 28 (2.0-alpha-4)} {
+<li>Incorporate makefile patches form A. Rottmann to use LIBTOOL</li>
+}
+
+chng {2001 Sep 27 (2.0-alpha-3)} {
+<li>SQLite now honors the UNIQUE keyword in CREATE UNIQUE INDEX.  Primary
+    keys are required to be unique.</li>
+<li>File format changed back to what it was for alpha-1</li>
+<li>Fixes to the rollback and locking behavior</li>
+}
+
+chng {2001 Sep 20 (2.0-alpha-2)} {
+<li>Initial release of version 2.0.  The idea of renaming the library
+    to "SQLus" was abandoned in favor of keeping the "SQLite" name and
+    bumping the major version number.</li>
+<li>The pager and btree subsystems added back. They are now the only
+    available backend.</li>
+<li>The Dbbe abstraction and the GDBM and memory drivers were removed.</li>
+<li>Copyright on all code was disclaimed.  The library is now in the
+    public domain.</li>
+}
+
+chng {2001 Jul 23 (1.0.32)} {
+<li>Pager and btree subsystems removed.  These will be used in a follow-on
+    SQL server library named "SQLus".</li>
+<li>Add the ability to use quoted strings as table and column names in
+    expressions.</li>
+}
+
+chng {2001 Apr 14 (1.0.31)} {
+<li>Pager subsystem added but not yet used.</li>
+<li>More robust handling of out-of-memory errors.</li>
+<li>New tests added to the test suite.</li>
+}
+
+chng {2001 Apr 6 (1.0.30)} {
+<li>Remove the <b>sqlite_encoding</b> TCL variable that was introduced
+    in the previous version.</li>
+<li>Add options <b>-encoding</b> and <b>-tcl-uses-utf</b> to the
+    <b>sqlite</b> TCL command.</li>
+<li>Add tests to make sure that tclsqlite was compiled using Tcl header
+    files and libraries that match.</li>
+}
+
+chng {2001 Apr 5 (1.0.29)} {
+<li>The library now assumes data is stored as UTF-8 if the --enable-utf8
+    option is given to configure.  The default behavior is to assume
+    iso8859-x, as it has always done.  This only makes a difference for
+    LIKE and GLOB operators and the LENGTH and SUBSTR functions.</li>
+<li>If the library is not configured for UTF-8 and the Tcl library
+    is one of the newer ones that uses UTF-8 internally,
+    then a conversion from UTF-8 to iso8859 and
+    back again is done inside the TCL interface.</li>
+}
+
+chng {2001 Apr 4 (1.0.28)} {
+<li>Added limited support for transactions.  At this point, transactions
+    will do table locking on the GDBM backend.  There is no support (yet)
+    for rollback or atomic commit.</li>
+<li>Added special column names ROWID, OID, and _ROWID_ that refer to the
+    unique random integer key associated with every row of every table.</li>
+<li>Additional tests added to the regression suite to cover the new ROWID
+    feature and the TCL interface bugs mentioned below.</li>
+<li>Changes to the "lemon" parser generator to help it work better when
+    compiled using MSVC.</li>
+<li>Bug fixes in the TCL interface identified by Oleg Oleinick.</li>
+}
+
+chng {2001 Mar 20 (1.0.27)} {
+<li>When doing DELETE and UPDATE, the library used to write the record
+    numbers of records to be deleted or updated into a temporary file.
+    This is changed so that the record numbers are held in memory.</li>
+<li>The DELETE command without a WHILE clause just removes the database
+    files from the disk, rather than going through and deleting record
+    by record.</li>
+}
+
+chng {2001 Mar 20 (1.0.26)} {
+<li>A serious bug fixed on Windows.  Windows users should upgrade.
+    No impact to Unix.</li>
+}
+
+chng {2001 Mar 15 (1.0.25)} {
+<li>Modify the test scripts to identify tests that depend on system
+    load and processor speed and
+    to warn the user that a failure of one of those (rare) tests does
+    not necessarily mean the library is malfunctioning.  No changes to
+    code.
+    </li>
+}
+
+chng {2001 Mar 14 (1.0.24)} {
+<li>Fix a bug which was causing
+    the UPDATE command to fail on systems where "malloc(0)" returns
+    NULL.  The problem does not appear Windows, Linux, or HPUX but does 
+    cause the library to fail on QNX.
+    </li>
+}
+
+chng {2001 Feb 19 (1.0.23)} {
+<li>An unrelated (and minor) bug from Mark Muranwski fixed.  The algorithm
+    for figuring out where to put temporary files for a "memory:" database
+    was not working quite right.
+    </li>
+}
+
+chng {2001 Feb 19 (1.0.22)} {
+<li>The previous fix was not quite right.  This one seems to work better.
+    </li>
+}
+
+chng {2001 Feb 19 (1.0.21)} {
+<li>The UPDATE statement was not working when the WHERE clause contained
+    some terms that could be satisfied using indices and other terms that
+    could not.  Fixed.</li>
+}
+
+chng {2001 Feb 11 (1.0.20)} {
+<li>Merge development changes into the main trunk.  Future work toward
+    using a BTree file structure will use a separate CVS source tree.  This
+    CVS tree will continue to support the GDBM version of SQLite only.</li>
+}
+
+chng {2001 Feb 6 (1.0.19)} {
+<li>Fix a strange (but valid) C declaration that was causing problems
+    for QNX.  No logical changes.</li>
+}
+
+chng {2001 Jan 4 (1.0.18)} {
+<li>Print the offending SQL statement when an error occurs.</li>
+<li>Do not require commas between constraints in CREATE TABLE statements.</li>
+<li>Added the "-echo" option to the shell.</li>
+<li>Changes to comments.</li>
+}
+
+chng {2000 Dec 10 (1.0.17)} {
+<li>Rewrote <b>sqlite_complete()</b> to make it faster.</li>
+<li>Minor tweaks to other code to make it run a little faster.</li>
+<li>Added new tests for <b>sqlite_complete()</b> and for memory leaks.</li>
+}
+
+chng {2000 Dec 4 (1.0.16)} {
+<li>Documentation updates.  Mostly fixing of typos and spelling errors.</li>
+}
+
+chng {2000 Oct 23 (1.0.15)} {
+<li>Documentation updates</li>
+<li>Some sanity checking code was removed from the inner loop of vdbe.c
+    to help the library to run a little faster.  The code is only
+    removed if you compile with -DNDEBUG.</li>
+}
+
+chng {2000 Oct 19 (1.0.14)} {
+<li>Added a "memory:" backend driver that stores its database in an
+    in-memory hash table.</li>
+}
+
+chng {2000 Oct 18 (1.0.13)} {
+<li>Break out the GDBM driver into a separate file in anticipation
+    to added new drivers.</li>
+<li>Allow the name of a database to be prefixed by the driver type.
+    For now, the only driver type is "gdbm:".</li>
+}
+
+chng {2000 Oct 16 (1.0.12)} {
+<li>Fixed an off-by-one error that was causing a coredump in 
+    the '%q' format directive of the new
+    <b>sqlite_..._printf()</b> routines.</li>
+<li>Added the <b>sqlite_interrupt()</b> interface.</li>
+<li>In the shell, <b>sqlite_interrupt()</b> is invoked when the
+    user presses Control-C</li>
+<li>Fixed some instances where <b>sqlite_exec()</b> was
+    returning the wrong error code.</li>
+}
+
+chng {2000 Oct 11 (1.0.10)} {
+<li>Added notes on how to compile for Windows95/98.</li>
+<li>Removed a few variables that were not being used.  Etc.</li>
+}
+
+chng {2000 Oct 8 (1.0.9)} {
+<li>Added the <b>sqlite_..._printf()</b> interface routines.</li>
+<li>Modified the <b>sqlite</b> shell program to use the new interface 
+    routines.</li>
+<li>Modified the <b>sqlite</b> shell program to print the schema for
+    the built-in SQLITE_MASTER table, if explicitly requested.</li>
+}
+
+chng {2000 Sep 30 (1.0.8)} {
+<li>Begin writing documentation on the TCL interface.</li>
+}
+
+chng {2000 Sep 29 (Not Released)} {
+<li>Added the <b>sqlite_get_table()</b> API</li>
+<li>Updated the documentation for due to the above change.</li>
+<li>Modified the <b>sqlite</b> shell to make use of the new
+    sqlite_get_table() API in order to print a list of tables
+    in multiple columns, similar to the way "ls" prints filenames.</li>
+<li>Modified the <b>sqlite</b> shell to print a semicolon at the
+    end of each CREATE statement in the output of the ".schema" command.</li>
+}
+
+chng {2000 Sep 21 (Not Released)} {
+<li>Change the tclsqlite "eval" method to return a list of results if
+    no callback script is specified.</li>
+<li>Change tclsqlite.c to use the Tcl_Obj interface</li>
+<li>Add tclsqlite.c to the libsqlite.a library</li>
+}
+
+chng {2000 Sep 13 (Version 1.0.5)} {
+<li>Changed the print format for floating point values from "%g" to "%.15g".
+    </li>
+<li>Changed the comparison function so that numbers in exponential notation
+    (ex: 1.234e+05) sort in numerical order.</li>
+}
+
+chng {2000 Aug 28 (Version 1.0.4)} {
+<li>Added functions <b>length()</b> and <b>substr()</b>.</li>
+<li>Fix a bug in the <b>sqlite</b> shell program that was causing
+    a coredump when the output mode was "column" and the first row
+    of data contained a NULL.</li>
+}
+
+chng {2000 Aug 22 (Version 1.0.3)} {
+<li>In the sqlite shell, print the "Database opened READ ONLY" message
+    to stderr instead of stdout.</li>
+<li>In the sqlite shell, now print the version number on initial startup.</li>
+<li>Add the <b>sqlite_version[]</b> string constant to the library</li>
+<li>Makefile updates</li>
+<li>Bug fix: incorrect VDBE code was being generated for the following
+    circumstance: a query on an indexed table containing a WHERE clause with
+    an IN operator that had a subquery on its right-hand side.</li>
+}
+
+chng {2000 Aug 18 (Version 1.0.1)} {
+<li>Fix a bug in the configure script.</li>
+<li>Minor revisions to the website.</li>
+}
+
+chng {2000 Aug 17 (Version 1.0)} {
+<li>Change the <b>sqlite</b> program so that it can read
+    databases for which it lacks write permission.  (It used to
+    refuse all access if it could not write.)</li>
+}
+
+chng {2000 Aug 9} {
+<li>Treat carriage returns as white space.</li>
+}
+
+chng {2000 Aug 8} {
+<li>Added pattern matching to the ".table" command in the "sqlite"
+command shell.</li>
+}
+
+chng {2000 Aug 4} {
+<li>Documentation updates</li>
+<li>Added "busy" and "timeout" methods to the Tcl interface</li>
+}
+
+chng {2000 Aug 3} {
+<li>File format version number was being stored in sqlite_master.tcl
+    multiple times. This was harmless, but unnecessary. It is now fixed.</li>
+}
+
+chng {2000 Aug 2} {
+<li>The file format for indices was changed slightly in order to work
+    around an inefficiency that can sometimes come up with GDBM when
+    there are large indices having many entries with the same key.
+    <font color="red">** Incompatible Change **</font></li>
+}
+
+chng {2000 Aug 1} {
+<li>The parser's stack was overflowing on a very long UPDATE statement.
+    This is now fixed.</li>
+}
+
+chng {2000 July 31} {
+<li>Finish the <a href="vdbe.html">VDBE tutorial</a>.</li>
+<li>Added documentation on compiling to WindowsNT.</li>
+<li>Fix a configuration program for WindowsNT.</li>
+<li>Fix a configuration problem for HPUX.</li>
+}
+
+chng {2000 July 29} {
+<li>Better labels on column names of the result.</li>
+}
+
+chng {2000 July 28} {
+<li>Added the <b>sqlite_busy_handler()</b> 
+    and <b>sqlite_busy_timeout()</b> interface.</li>
+}
+
+chng {2000 June 23} {
+<li>Begin writing the <a href="vdbe.html">VDBE tutorial</a>.</li>
+}
+
+chng {2000 June 21} {
+<li>Clean up comments and variable names.  Changes to documentation.
+    No functional changes to the code.</li>
+}
+
+chng {2000 June 19} {
+<li>Column names in UPDATE statements were case sensitive.
+    This mistake has now been fixed.</li>
+}
+
+chng {2000 June 16} {
+<li>Added the concatenate string operator (||)</li>
+}
+
+chng {2000 June 12} {
+<li>Added the fcnt() function to the SQL interpreter.  The fcnt() function
+    returns the number of database "Fetch" operations that have occurred.
+    This function is designed for use in test scripts to verify that
+    queries are efficient and appropriately optimized.  Fcnt() has no other
+    useful purpose, as far as I know.</li>
+<li>Added a bunch more tests that take advantage of the new fcnt() function.
+    The new tests did not uncover any new problems.</li>
+}
+
+chng {2000 June 8} {
+<li>Added lots of new test cases</li>
+<li>Fix a few bugs discovered while adding test cases</li>
+<li>Begin adding lots of new documentation</li>
+}
+
+chng {2000 June 6} {
+<li>Added compound select operators: <B>UNION</b>, <b>UNION ALL</B>,
+<b>INTERSECT</b>, and <b>EXCEPT</b></li>
+<li>Added support for using <b>(SELECT ...)</b> within expressions</li>
+<li>Added support for <b>IN</b> and <b>BETWEEN</b> operators</li>
+<li>Added support for <b>GROUP BY</b> and <b>HAVING</b></li>
+<li>NULL values are now reported to the callback as a NULL pointer
+    rather than an empty string.</li>
+}
+
+chng {2000 June 3} {
+<li>Added support for default values on columns of a table.</li>
+<li>Improved test coverage.  Fixed a few obscure bugs found by the
+improved tests.</li>
+}
+
+chng {2000 June 2} {
+<li>All database files to be modified by an UPDATE, INSERT or DELETE are 
+now locked before any changes are made to any files.  
+This makes it safe (I think) to access
+the same database simultaneously from multiple processes.</li>
+<li>The code appears stable so we are now calling it "beta".</li>
+}
+
+chng {2000 June 1} {
+<li>Better support for file locking so that two or more processes 
+(or threads)
+can access the same database simultaneously.  More work needed in
+this area, though.</li>
+}
+
+chng {2000 May 31} {
+<li>Added support for aggregate functions (Ex: <b>COUNT(*)</b>, <b>MIN(...)</b>)
+to the SELECT statement.</li>
+<li>Added support for <B>SELECT DISTINCT ...</B></li>
+}
+
+chng {2000 May 30} {
+<li>Added the <b>LIKE</b> operator.</li>
+<li>Added a <b>GLOB</b> operator: similar to <B>LIKE</B> 
+but it uses Unix shell globbing wildcards instead of the '%' 
+and '_' wildcards of SQL.</li>
+<li>Added the <B>COPY</b> command patterned after 
+<a href="http://www.postgresql.org/">PostgreSQL</a> so that SQLite
+can now read the output of the <b>pg_dump</b> database dump utility
+of PostgreSQL.</li>
+<li>Added a <B>VACUUM</B> command that that calls the 
+<b>gdbm_reorganize()</b> function on the underlying database
+files.</li>
+<li>And many, many bug fixes...</li>
+}
+
+chng {2000 May 29} {
+<li>Initial Public Release of Alpha code</li>
+}
+
+puts {
+</DL>
+}
+footer {$Id:}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/common.tcl b/client/src/thirdparty/sqlite-3.4.2/www/common.tcl
new file mode 100644
index 0000000..07129f8
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/common.tcl
@@ -0,0 +1,90 @@
+# This file contains TCL procedures used to generate standard parts of
+# web pages.
+#
+
+proc header {txt} {
+  puts "<html><head><title>$txt</title></head>"
+  puts {<DIV class="pdf_ignore">}
+  puts \
+{<body bgcolor="white" link="#50695f" vlink="#508896">
+<table width="100%" border="0">
+<tr><td valign="top">
+<a href="index.html"><img src="sqlite.gif" border="none"></a></td>
+<td width="100%"></td>
+<td valign="bottom">
+<ul>
+<li><a href="http://www.sqlite.org/cvstrac/tktnew">bugs</a></li>
+<li><a href="changes.html">changes</a></li>
+<li><a href="contrib">contrib</a></li>
+<li><a href="download.html#cvs">cvs&nbsp;repository</a></li>
+<li><a href="docs.html">documentation</a></li>
+</ul>
+</td>
+<td width="10"></td>
+<td valign="bottom">
+<ul>
+<li><a href="download.html">download</a></li>
+<li><a href="faq.html">faq</a></li>
+<li><a href="index.html">home</a></li>
+<li><a href="copyright.html">license</a></li>
+<li><a href="index.html">news</a></li>
+</ul>
+</td>
+<td width="10"></td>
+<td valign="bottom">
+<ul>
+<li><a href="quickstart.html">quick&nbsp;start</a></li>
+<li><a href="support.html">support</a></li>
+<li><a href="lang.html">syntax</a></li>
+<li><a href="http://www.sqlite.org/cvstrac/timeline">timeline</a></li>
+<li><a href="http://www.sqlite.org/cvstrac/wiki">wiki</a></li>
+</ul>
+</td>
+</tr></table>
+<table width="100%">
+<tr><td bgcolor="#80a796"></td></tr>
+</table>}
+  puts </DIV>
+}
+
+proc footer {{rcsid {}}} {
+  puts {
+<table width="100%">
+<tr><td bgcolor="#80a796"></td></tr>
+</table>}
+  set date [lrange $rcsid 3 4]
+  if {$date!=""} {
+    puts "<small><i>This page last modified on $date</i></small>"
+  }
+  puts {</body></html>}
+}
+
+
+# The following proc is used to ensure consistent formatting in the 
+# HTML generated by lang.tcl and pragma.tcl.
+#
+proc Syntax {args} {
+  puts {<table cellpadding="10" class=pdf_syntax>}
+  foreach {rule body} $args {
+    puts "<tr><td align=\"right\" valign=\"top\">"
+    puts "<i><font color=\"#ff3434\">$rule</font></i>&nbsp;::=</td>"
+    regsub -all < $body {%LT} body
+    regsub -all > $body {%GT} body
+    regsub -all %LT $body {</font></b><i><font color="#ff3434">} body
+    regsub -all %GT $body {</font></i><b><font color="#2c2cf0">} body
+    regsub -all {[]|[*?]} $body {</font></b>&<b><font color="#2c2cf0">} body
+    regsub -all "\n" [string trim $body] "<br>\n" body
+    regsub -all "\n  *" $body "\n\\&nbsp;\\&nbsp;\\&nbsp;\\&nbsp;" body
+    regsub -all {[|,.*()]} $body {<big>&</big>} body
+    regsub -all { = } $body { <big>=</big> } body
+    regsub -all {STAR} $body {<big>*</big>} body
+    ## These metacharacters must be handled to undo being
+    ## treated as SQL punctuation characters above.
+    regsub -all {RPPLUS} $body {</font></b>)+<b><font color="#2c2cf0">} body
+    regsub -all {LP} $body {</font></b>(<b><font color="#2c2cf0">} body
+    regsub -all {RP} $body {</font></b>)<b><font color="#2c2cf0">} body
+    ## Place the left-hand side of the rule in the 2nd table column.
+    puts "<td><b><font color=\"#2c2cf0\">$body</font></b></td></tr>"
+  }
+  puts {</table>}
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/compile.tcl b/client/src/thirdparty/sqlite-3.4.2/www/compile.tcl
new file mode 100644
index 0000000..bdf7d22
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/compile.tcl
@@ -0,0 +1,278 @@
+#
+# Run this Tcl script to generate the compile.html file.
+#
+set rcsid {$Id: compile.tcl,v 1.5 2005/03/19 15:10:45 drh Exp $ }
+source common.tcl
+header {Compilation Options For SQLite}
+
+puts {
+<h1>Compilation Options For SQLite</h1>
+
+<p>
+For most purposes, SQLite can be built just fine using the default
+compilation options. However, if required, the compile-time options
+documented below can be used to 
+<a href="#omitfeatures">omit SQLite features</a> (resulting in
+a smaller compiled library size) or to change the
+<a href="#defaults">default values</a> of some parameters.
+</p>
+<p>
+Every effort has been made to ensure that the various combinations
+of compilation options work harmoniously and produce a working library.
+Nevertheless, it is strongly recommended that the SQLite test-suite
+be executed to check for errors before using an SQLite library built
+with non-standard compilation options.
+</p>
+<a name="defaults"></a>
+<h2>Options To Set Default Parameter Values</h2>
+
+<p><b>SQLITE_DEFAULT_AUTOVACUUM=<i>&lt;1 or 0&gt;</i></b><br>
+This macro determines if SQLite creates databases with the 
+<a href="pragma.html#pragma_auto_vacuum">auto-vacuum</a> 
+flag set by default. The default value is 0 (do not create auto-vacuum
+databases). In any case the compile-time default may be overridden by the 
+"PRAGMA auto_vacuum" command.
+</p>
+
+<p><b>SQLITE_DEFAULT_CACHE_SIZE=<i>&lt;pages&gt;</i></b><br>
+This macro sets the default size of the page-cache for each attached
+database, in pages. This can be overridden by the "PRAGMA cache_size"
+comamnd. The default value is 2000.
+</p>
+
+<p><b>SQLITE_DEFAULT_PAGE_SIZE=<i>&lt;bytes&gt;</i></b><br>
+This macro is used to set the default page-size used when a
+database is created. The value assigned must be a power of 2. The
+default value is 1024. The compile-time default may be overridden at 
+runtime by the "PRAGMA page_size" command.
+</p>
+
+<p><b>SQLITE_DEFAULT_TEMP_CACHE_SIZE=<i>&lt;pages&gt;</i></b><br>
+This macro sets the default size of the page-cache for temporary files
+created by SQLite to store intermediate results, in pages. It does
+not affect the page-cache for the temp database, where tables created
+using "CREATE TEMP TABLE" are stored. The default value is 500.
+</p>
+
+<p><b>SQLITE_MAX_PAGE_SIZE=<i>&lt;bytes&gt;</i></b><br>
+This is used to set the maximum allowable page-size that can
+be specified by the "PRAGMA page_size" command. The default value
+is 8192.
+</p>
+
+<a name="omitfeatures"></a>
+<h2>Options To Omit Features</h2>
+
+<p>The following options are used to reduce the size of the compiled
+library by omiting optional features. This is probably only useful
+in embedded systems where space is especially tight, as even with all
+features included the SQLite library is relatively small. Don't forget
+to tell your compiler to optimize for binary size! (the -Os option if
+using GCC).</p>
+
+<p>The macros in this section do not require values. The following 
+compilation switches all have the same effect:<br>
+-DSQLITE_OMIT_ALTERTABLE<br>
+-DSQLITE_OMIT_ALTERTABLE=1<br>
+-DSQLITE_OMIT_ALTERTABLE=0
+</p>
+
+<p>If any of these options are defined, then the same set of SQLITE_OMIT_XXX
+options must also be defined when using the 'lemon' tool to generate a parse.c
+file. Because of this, these options may only used when the library is built
+from source, not from the collection of pre-packaged C files provided for
+non-UNIX like platforms on the website.
+</p>
+
+<p><b>SQLITE_OMIT_ALTERTABLE</b><br>
+When this option is defined, the 
+<a href="lang_altertable.html">ALTER TABLE</a> command is not included in the 
+library. Executing an ALTER TABLE statement causes a parse error.
+</p>
+
+<p><b>SQLITE_OMIT_AUTHORIZATION</b><br>
+Defining this option omits the authorization callback feature from the
+library. The <a href="capi3ref.html#sqlite3_set_authorizer">
+sqlite3_set_authorizer()</a> API function is not present in the library.
+</p>
+
+<p><b>SQLITE_OMIT_AUTOVACUUM</b><br>
+If this option is defined, the library cannot create or write to 
+databases that support 
+<a href="pragma.html#pragma_auto_vacuum">auto-vacuum</a>. Executing a
+"PRAGMA auto_vacuum" statement is not an error, but does not return a value
+or modify the auto-vacuum flag in the database file. If a database that
+supports auto-vacuum is opened by a library compiled with this option, it
+is automatically opened in read-only mode.
+</p>
+
+<p><b>SQLITE_OMIT_AUTOINCREMENT</b><br>
+This option is used to omit the AUTOINCREMENT functionality. When this 
+is macro is defined, columns declared as "INTEGER PRIMARY KEY AUTOINCREMENT"
+behave in the same way as columns declared as "INTEGER PRIMARY KEY" when a 
+NULL is inserted. The sqlite_sequence system table is neither created, nor
+respected if it already exists.
+</p>
+<p><i>TODO: Need a link here - AUTOINCREMENT is not yet documented</i><p>
+
+<p><b>SQLITE_OMIT_BLOB_LITERAL</b><br>
+When this option is defined, it is not possible to specify a blob in
+an SQL statement using the X'ABCD' syntax.</p> 
+}
+#<p>WARNING: The VACUUM command depends on this syntax for vacuuming databases
+#that contain blobs, so disabling this functionality may render a database
+#unvacuumable.
+#</p>
+#<p><i>TODO: Need a link here - is that syntax documented anywhere?</i><p>
+puts {
+
+<p><b>SQLITE_OMIT_COMPLETE</b><br>
+This option causes the <a href="capi3ref.html#sqlite3_complete">
+sqlite3_complete</a> API to be omitted.
+</p>
+
+<p><b>SQLITE_OMIT_COMPOUND_SELECT</b><br>
+This option is used to omit the compound SELECT functionality. 
+<a href="lang_select.html">SELECT statements</a> that use the 
+UNION, UNION ALL, INTERSECT or EXCEPT compound SELECT operators will 
+cause a parse error.
+</p>
+
+<p><b>SQLITE_OMIT_CONFLICT_CLAUSE</b><br>
+In the future, this option will be used to omit the 
+<a href="lang_conflict.html">ON CONFLICT</a> clause from the library.
+</p>
+
+<p><b>SQLITE_OMIT_DATETIME_FUNCS</b><br>
+If this option is defined, SQLite's built-in date and time manipulation
+functions are omitted. Specifically, the SQL functions julianday(), date(),
+time(), datetime() and strftime() are not available. The default column
+values CURRENT_TIME, CURRENT_DATE and CURRENT_DATETIME are still available.
+</p>
+
+<p><b>SQLITE_OMIT_EXPLAIN</b><br>
+Defining this option causes the EXPLAIN command to be omitted from the
+library. Attempting to execute an EXPLAIN statement will cause a parse
+error.
+</p>
+
+<p><b>SQLITE_OMIT_FLOATING_POINT</b><br>
+This option is used to omit floating-point number support from the SQLite
+library. When specified, specifying a floating point number as a literal 
+(i.e. "1.01") results in a parse error.
+</p>
+<p>In the future, this option may also disable other floating point 
+functionality, for example the sqlite3_result_double(), 
+sqlite3_bind_double(), sqlite3_value_double() and sqlite3_column_double() 
+API functions.
+</p>
+
+<p><b>SQLITE_OMIT_FOREIGN_KEY</b><br>
+If this option is defined, FOREIGN KEY clauses in column declarations are
+ignored.
+</p>
+
+<p><b>SQLITE_OMIT_INTEGRITY_CHECK</b><br>
+This option may be used to omit the 
+<a href="pragma.html#pragma_integrity_check">"PRAGMA integrity_check"</a> 
+command from the compiled library.
+</p>
+
+<p><b>SQLITE_OMIT_MEMORYDB</b><br>
+When this is defined, the library does not respect the special database
+name ":memory:" (normally used to create an in-memory database). If 
+":memory:" is passed to sqlite3_open(), a file with this name will be 
+opened or created.
+</p>
+
+<p><b>SQLITE_OMIT_PAGER_PRAGMAS</b><br>
+Defining this option omits pragmas related to the pager subsystem from 
+the build. Currently, the 
+<a href="pragma.html#pragma_default_cache_size">default_cache_size</a> and 
+<a href="pragma.html#pragma_cache_size">cache_size</a> pragmas are omitted.
+</p>
+
+<p><b>SQLITE_OMIT_PRAGMA</b><br>
+This option is used to omit the <a href="pragma.html">PRAGMA command</a> 
+from the library. Note that it is useful to define the macros that omit
+specific pragmas in addition to this, as they may also remove supporting code
+in other sub-systems. This macro removes the PRAGMA command only.
+</p>
+
+<p><b>SQLITE_OMIT_PROGRESS_CALLBACK</b><br>
+This option may be defined to omit the capability to issue "progress" 
+callbacks during long-running SQL statements. The 
+<a href="capi3ref.html#sqlite3_progress_handler">sqlite3_progress_handler()</a>
+API function is not present in the library.
+
+<p><b>SQLITE_OMIT_REINDEX</b><br>
+When this option is defined, the <a href="lang_reindex.html">REINDEX</a> 
+command is not included in the library. Executing a REINDEX statement causes 
+a parse error.
+</p>
+
+<p><b>SQLITE_OMIT_SCHEMA_PRAGMAS</b><br>
+Defining this option omits pragmas for querying the database schema from 
+the build. Currently, the 
+<a href="pragma.html#pragma_table_info">table_info</a>,
+<a href="pragma.html#pragma_index_info">index_info</a>,
+<a href="pragma.html#pragma_index_list">index_list</a> and
+<a href="pragma.html#pragma_database_list">database_list</a>
+pragmas are omitted.
+</p>
+
+<p><b>SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS</b><br>
+Defining this option omits pragmas for querying and modifying the 
+database schema version and user version from the build. Specifically, the 
+<a href="pragma.html#pragma_schema_version">schema_version</a> and
+<a href="pragma.html#pragma_user_version">user_version</a>
+pragmas are omitted.
+
+<p><b>SQLITE_OMIT_SUBQUERY</b><br>
+<p>If defined, support for sub-selects and the IN() operator are omitted.
+</p>
+
+<p><b>SQLITE_OMIT_TCL_VARIABLE</b><br>
+<p>If this macro is defined, then the special "$<variable-name>" syntax
+used to automatically bind SQL variables to TCL variables is omitted.
+</p>
+
+<p><b>SQLITE_OMIT_TRIGGER</b><br>
+Defining this option omits support for VIEW objects. Neither the 
+<a href="lang_createtrigger.html">CREATE TRIGGER</a> or 
+<a href="lang_droptrigger.html">DROP TRIGGER</a> 
+commands are available in this case, attempting to execute either will result
+in a parse error.
+</p>
+<p>
+WARNING: If this macro is defined, it will not be possible to open a database
+for which the schema contains TRIGGER objects. 
+</p>
+
+<p><b>SQLITE_OMIT_UTF16</b><br>
+This macro is used to omit support for UTF16 text encoding. When this is
+defined all API functions that return or accept UTF16 encoded text are
+unavailable. These functions can be identified by the fact that they end
+with '16', for example sqlite3_prepare16(), sqlite3_column_text16() and
+sqlite3_bind_text16().
+</p>
+
+<p><b>SQLITE_OMIT_VACUUM</b><br>
+When this option is defined, the <a href="lang_vacuum.html">VACUUM</a> 
+command is not included in the library. Executing a VACUUM statement causes 
+a parse error.
+</p>
+
+<p><b>SQLITE_OMIT_VIEW</b><br>
+Defining this option omits support for VIEW objects. Neither the 
+<a href="lang_createview.html">CREATE VIEW</a> or 
+<a href="lang_dropview.html">DROP VIEW</a> 
+commands are available in this case, attempting to execute either will result
+in a parse error.
+</p>
+<p>
+WARNING: If this macro is defined, it will not be possible to open a database
+for which the schema contains VIEW objects. 
+</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/conflict.tcl b/client/src/thirdparty/sqlite-3.4.2/www/conflict.tcl
new file mode 100644
index 0000000..2d11639
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/conflict.tcl
@@ -0,0 +1,91 @@
+#
+# Run this Tcl script to generate the constraint.html file.
+#
+set rcsid {$Id: conflict.tcl,v 1.4 2004/10/10 17:24:55 drh Exp $ }
+source common.tcl
+header {Constraint Conflict Resolution in SQLite}
+puts {
+<h1>Constraint Conflict Resolution in SQLite</h1>
+
+<p>
+In most SQL databases, if you have a UNIQUE constraint on
+a table and you try to do an UPDATE or INSERT that violates
+the constraint, the database will abort the operation in
+progress, back out any prior changes associated with
+UPDATE or INSERT command, and return an error.
+This is the default behavior of SQLite.
+Beginning with version 2.3.0, though, SQLite allows you to
+define alternative ways for dealing with constraint violations.
+This article describes those alternatives and how to use them.
+</p>
+
+<h2>Conflict Resolution Algorithms</h2>
+
+<p>
+SQLite defines five constraint conflict resolution algorithms
+as follows:
+</p>
+
+<dl>
+<dt><b>ROLLBACK</b></dt>
+<dd><p>When a constraint violation occurs, an immediate ROLLBACK
+occurs, thus ending the current transaction, and the command aborts
+with a return code of SQLITE_CONSTRAINT.  If no transaction is
+active (other than the implied transaction that is created on every
+command) then this algorithm works the same as ABORT.</p></dd>
+
+<dt><b>ABORT</b></dt>
+<dd><p>When a constraint violation occurs, the command backs out
+any prior changes it might have made and aborts with a return code
+of SQLITE_CONSTRAINT.  But no ROLLBACK is executed so changes
+from prior commands within the same transaction
+are preserved.  This is the default behavior for SQLite.</p></dd>
+
+<dt><b>FAIL</b></dt>
+<dd><p>When a constraint violation occurs, the command aborts with a
+return code SQLITE_CONSTRAINT.  But any changes to the database that
+the command made prior to encountering the constraint violation
+are preserved and are not backed out.  For example, if an UPDATE
+statement encountered a constraint violation on the 100th row that
+it attempts to update, then the first 99 row changes are preserved
+by change to rows 100 and beyond never occur.</p></dd>
+
+<dt><b>IGNORE</b></dt>
+<dd><p>When a constraint violation occurs, the one row that contains
+the constraint violation is not inserted or changed.  But the command
+continues executing normally.  Other rows before and after the row that
+contained the constraint violation continue to be inserted or updated
+normally.  No error is returned.</p></dd>
+
+<dt><b>REPLACE</b></dt>
+<dd><p>When a UNIQUE constraint violation occurs, the pre-existing row
+that caused the constraint violation is removed prior to inserting
+or updating the current row.  Thus the insert or update always occurs.
+The command continues executing normally.  No error is returned.</p></dd>
+</dl>
+
+<h2>Why So Many Choices?</h2>
+
+<p>SQLite provides multiple conflict resolution algorithms for a
+couple of reasons.  First, SQLite tries to be roughly compatible with as
+many other SQL databases as possible, but different SQL database
+engines exhibit different conflict resolution strategies.  For
+example, PostgreSQL always uses ROLLBACK, Oracle always uses ABORT, and
+MySQL usually uses FAIL but can be instructed to use IGNORE or REPLACE.
+By supporting all five alternatives, SQLite provides maximum
+portability.</p>
+
+<p>Another reason for supporting multiple algorithms is that sometimes
+it is useful to use an algorithm other than the default.
+Suppose, for example, you are
+inserting 1000 records into a database, all within a single
+transaction, but one of those records is malformed and causes
+a constraint error.  Under PostgreSQL or Oracle, none of the
+1000 records would get inserted.  In MySQL, some subset of the
+records that appeared before the malformed record would be inserted
+but the rest would not.  Neither behavior is especially helpful.
+What you really want is to use the IGNORE algorithm to insert
+all but the malformed record.</p>
+
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/copyright-release.html b/client/src/thirdparty/sqlite-3.4.2/www/copyright-release.html
new file mode 100644
index 0000000..bc0c764
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/copyright-release.html
@@ -0,0 +1,109 @@
+<html>
+<body bgcolor="white">
+<h1 align="center">
+Copyright Release for<br>
+Contributions To SQLite
+</h1>
+
+<p>
+SQLite is software that implements an embeddable SQL database engine.
+SQLite is available for free download from http://www.sqlite.org/.
+The principal author and maintainer of SQLite has disclaimed all
+copyright interest in his contributions to SQLite
+and thus released his contributions into the public domain.
+In order to keep the SQLite software unencumbered by copyright
+claims, the principal author asks others who may from time to
+time contribute changes and enhancements to likewise disclaim
+their own individual copyright interest.
+</p>
+
+<p>
+Because the SQLite software found at http://www.sqlite.org/ is in the
+public domain, anyone is free to download the SQLite software
+from that website, make changes to the software, use, distribute,
+or sell the modified software, under either the original name or
+under some new name, without any need to obtain permission, pay
+royalties, acknowledge the original source of the software, or
+in any other way compensate, identify, or notify the original authors.  
+Nobody is in any way compelled to contribute their SQLite changes and 
+enhancements back to the SQLite website.  This document concerns
+only changes and enhancements to SQLite that are intentionally and
+deliberately contributed back to the SQLite website.  
+</p>
+
+<p>
+For the purposes of this document, "SQLite software" shall mean any
+computer source code, documentation, makefiles, test scripts, or
+other information that is published on the SQLite website, 
+http://www.sqlite.org/.  Precompiled binaries are excluded from
+the definition of "SQLite software" in this document because the
+process of compiling the software may introduce information from
+outside sources which is not properly a part of SQLite.
+</p>
+
+<p>
+The header comments on the SQLite source files exhort the reader to
+share freely and to never take more than one gives.
+In the spirit of that exhortation I make the following declarations:
+</p>
+
+<ol>
+<li><p>
+I dedicate to the public domain 
+any and all copyright interest in the SQLite software that
+was publicly available on the SQLite website (http://www.sqlite.org/) prior
+to the date of the signature below and any changes or enhancements to
+the SQLite software 
+that I may cause to be published on that website in the future.
+I make this dedication for the benefit of the public at large and
+to the detriment of my heirs and successors.  I intend this
+dedication to be an overt act of relinquishment in perpetuity of
+all present and future rights to the SQLite software under copyright
+law.
+</p></li>
+
+<li><p>
+To the best of my knowledge and belief, the changes and enhancements that
+I have contributed to SQLite are either originally written by me
+or are derived from prior works which I have verified are also
+in the public domain and are not subject to claims of copyright
+by other parties.
+</p></li>
+
+<li><p>
+To the best of my knowledge and belief, no individual, business, organization,
+government, or other entity has any copyright interest
+in the SQLite software as it existed on the
+SQLite website as of the date on the signature line below.
+</p></li>
+
+<li><p>
+I agree never to publish any additional information
+to the SQLite website (by CVS, email, scp, FTP, or any other means) unless
+that information is an original work of authorship by me or is derived from 
+prior published versions of SQLite.
+I agree never to copy and paste code into the SQLite code base from
+other sources.
+I agree never to publish on the SQLite website any information that
+would violate a law or breach a contract.
+</p></li>
+</ol>
+
+<p>
+<table width="100%" cellpadding="0" cellspacing="0">
+<tr>
+<td width="60%" valign="top">
+Signature:
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+</td><td valign="top" align="left">
+Date:
+</td></tr>
+<td colspan=2>
+Name (printed):
+</td>
+</tr>
+</table>
+</body>
+</html>
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/copyright-release.pdf b/client/src/thirdparty/sqlite-3.4.2/www/copyright-release.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..9465d3179de213b05bd1b11998fb52f5d72faf0b
GIT binary patch
literal 2848
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
A0{{R3

literal 0
HcmV?d00001

diff --git a/client/src/thirdparty/sqlite-3.4.2/www/copyright.tcl b/client/src/thirdparty/sqlite-3.4.2/www/copyright.tcl
new file mode 100644
index 0000000..7468744
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/copyright.tcl
@@ -0,0 +1,126 @@
+set rcsid {$Id: copyright.tcl,v 1.7 2007/05/06 21:20:43 drh Exp $}
+source common.tcl
+header {SQLite Copyright}
+puts {
+<h2>SQLite Copyright</h2>
+
+<table align="right" vspace="0" hspace="10" border="1" cellpadding="20">
+<tr><td align="center">
+<img src="nocopy.gif"><br>
+SQLite is in the<br>
+<a href="http://en.wikipedia.org/wiki/Public_Domain">Public Domain</a>
+</td></tr>
+</table>
+
+<p>
+All of the deliverable code in SQLite has been dedicated to the
+<a href="http://en.wikipedia.org/wiki/Public_Domain">public domain</a>
+by the authors.
+All code authors, and representatives of the companies they work for,
+have signed affidavits dedicating their contributions to
+the public domain and originals of
+those signed affidavits are stored in a firesafe at the main offices
+of <a href="http://www.hwaci.com">Hwaci</a>.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute
+the original SQLite code, either in source code form or as a compiled binary,
+for any purpose, commercial or non-commercial, and by any means.
+</p>
+
+<p>
+The previous paragraph applies to the deliverable code in SQLite - 
+those parts of the SQLite library that you actually bundle and
+ship with a larger application.  Portions of the documentation and
+some code used as part of the build process might fall under
+other licenses.  The details here are unclear.  We do not worry
+about the licensing of the documentation and build code so much
+because none of these things are part of the core deliverable
+SQLite library.
+</p>
+
+<p>
+All of the deliverable code in SQLite has been written from scratch.
+No code has been taken from other projects or from the open
+internet.  Every line of code can be traced back to its original
+author, and all of those authors have public domain dedications
+on file.  So the SQLite code base is clean and is
+uncontaminated with licensed code from other projects.
+</p>
+
+<h2>Obtaining An Explicit License To Use SQLite</h2>
+
+<p>
+Even though SQLite is in the public domain and does not require
+a license, some users want to obtain a license anyway.  Some reasons
+for obtaining a license include:
+</p>
+
+<ul>
+<li> You are using SQLite in a jurisdiction that does not recognize
+     the public domain.  </li>
+<li> You are using SQLite in a jurisdiction that does not recognize
+     the right of an author to dedicate their work to the public
+     domain. </li>
+<li> You want to hold a tangible legal document
+     as evidence that you have the legal right to use and distribute
+     SQLite. </li>
+<li> Your legal department tells you that you have to purchase a license.
+     </li>
+</ul>
+
+<p>
+If you feel like you really have to purchase a license for SQLite,
+<a href="http://www.hwaci.com/">Hwaci</a>, the company that employs 
+the architect and principal developers of SQLite, will sell you
+one.
+Please contact:
+</p>
+
+<blockquote>
+D. Richard Hipp <br />
+Hwaci - Applied Software Research <br />
+704.948.4565 <br />
+<a href="mailto:drh@hwaci.com">drh@hwaci.com</a>
+</blockquote>
+
+<h2>Contributed Code</h2>
+
+<p>
+In order to keep SQLite completely free and unencumbered by copyright,
+all new contributors to the SQLite code base are asked to dedicate
+their contributions to the public domain.
+If you want to send a patch or enhancement for possible inclusion in the
+SQLite source tree, please accompany the patch with the following statement:
+</p>
+
+<blockquote><i>
+The author or authors of this code dedicate any and all copyright interest
+in this code to the public domain.  We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and successors.
+We intend this dedication to be an overt act of relinquishment in
+perpetuity of all present and future rights to this code under copyright law.
+</i></blockquote>
+
+<p>
+We are not able to accept patches or changes to 
+SQLite that are not accompanied by a statement such as the above.
+In addition, if you make
+changes or enhancements as an employee, then a simple statement such as the
+above is insufficient.  You must also send by surface mail a copyright release
+signed by a company officer.
+A signed original of the copyright release should be mailed to:</p>
+
+<blockquote>
+Hwaci<br>
+6200 Maple Cove Lane<br>
+Charlotte, NC 28269<br>
+USA
+</blockquote>
+
+<p>
+A template copyright release is available
+in <a href="copyright-release.pdf">PDF</a> or
+<a href="copyright-release.html">HTML</a>.
+You can use this release to make future changes. 
+</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/datatype3.tcl b/client/src/thirdparty/sqlite-3.4.2/www/datatype3.tcl
new file mode 100644
index 0000000..da400ae
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/datatype3.tcl
@@ -0,0 +1,440 @@
+set rcsid {$Id: datatype3.tcl,v 1.17 2007/06/20 16:13:23 drh Exp $}
+source common.tcl
+header {Datatypes In SQLite Version 3}
+puts {
+<h2>Datatypes In SQLite Version 3</h2>
+
+<h3>1. Storage Classes</h3>
+
+<P>Version 2 of SQLite stores all column values as ASCII text.
+Version 3 enhances this by providing the ability to store integer and
+real numbers in a more compact format and the capability to store
+BLOB data.</P>
+
+<P>Each value stored in an SQLite database (or manipulated by the
+database engine) has one of the following storage classes:</P>
+<UL>
+	<LI><P><B>NULL</B>. The value is a NULL value.</P>
+	<LI><P><B>INTEGER</B>. The value is a signed integer, stored in 1,
+	2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.</P>
+	<LI><P><B>REAL</B>. The value is a floating point value, stored as
+	an 8-byte IEEE floating point number.</P>
+	<LI><P><B>TEXT</B>. The value is a text string, stored using the
+	database encoding (UTF-8, UTF-16BE or UTF-16-LE).</P>
+	<LI><P><B>BLOB</B>. The value is a blob of data, stored exactly as
+	it was input.</P>
+</UL>
+
+<P>As in SQLite version 2, any column in a version 3 database except an INTEGER
+PRIMARY KEY may be used to store any type of value. The exception to
+this rule is described below under 'Strict Affinity Mode'.</P>
+
+<P>All values supplied to SQLite, whether as literals embedded in SQL
+statements or values bound to pre-compiled SQL statements
+are assigned a storage class before the SQL statement is executed.
+Under circumstances described below, the
+database engine may convert values between numeric storage classes
+(INTEGER and REAL) and TEXT during query execution. 
+</P>
+
+<P>Storage classes are initially assigned as follows:</P>
+<UL>
+	<LI><P>Values specified as literals as part of SQL statements are
+	assigned storage class TEXT if they are enclosed by single or double
+	quotes, INTEGER if the literal is specified as an unquoted number
+	with no decimal point or exponent, REAL if the literal is an
+	unquoted number with a decimal point or exponent and NULL if the
+	value is a NULL. Literals with storage class BLOB are specified
+        using the X'ABCD' notation.</P>
+	<LI><P>Values supplied using the sqlite3_bind_* APIs are assigned
+	the storage class that most closely matches the native type bound
+	(i.e. sqlite3_bind_blob() binds a value with storage class BLOB).</P>
+</UL>
+<P>The storage class of a value that is the result of an SQL scalar
+operator depends on the outermost operator of the expression.
+User-defined functions may return values with any storage class. It
+is not generally possible to determine the storage class of the
+result of an expression at compile time.</P>
+
+<a name="affinity">
+<h3>2. Column Affinity</h3>
+
+<p>
+In SQLite version 3, the type of a value is associated with the value
+itself, not with the column or variable in which the value is stored.
+(This is sometimes called
+<a href="http://www.cliki.net/manifest%20type%20system">
+manifest typing</a>.)
+All other SQL databases engines that we are aware of use the more
+restrictive system of static typing where the type is associated with
+the container, not the value.
+</p>
+
+<p>
+In order to maximize compatibility between SQLite and other database
+engines, SQLite support the concept of "type affinity" on columns.
+The type affinity of a column is the recommended type for data stored
+in that column.  The key here is that the type is recommended, not
+required.  Any column can still store any type of data, in theory.
+It is just that some columns, given the choice, will prefer to use
+one storage class over another.  The preferred storage class for
+a column is called its "affinity".
+</p>
+
+<P>Each column in an SQLite 3 database is assigned one of the
+following type affinities:</P>
+<UL>
+	<LI>TEXT</LI>
+	<LI>NUMERIC</LI>
+	<LI>INTEGER</LI>
+        <LI>REAL</li>
+	<LI>NONE</LI>
+</UL>
+
+<P>A column with TEXT affinity stores all data using storage classes
+NULL, TEXT or BLOB. If numerical data is inserted into a column with
+TEXT affinity it is converted to text form before being stored.</P>
+
+<P>A column with NUMERIC affinity may contain values using all five
+storage classes. When text data is inserted into a NUMERIC column, an
+attempt is made to convert it to an integer or real number before it
+is stored. If the conversion is successful, then the value is stored
+using the INTEGER or REAL storage class. If the conversion cannot be
+performed the value is stored using the TEXT storage class. No
+attempt is made to convert NULL or blob values.</P>
+
+<P>A column that uses INTEGER affinity behaves in the same way as a
+column with NUMERIC affinity, except that if a real value with no
+floating point component (or text value that converts to such) is
+inserted it is converted to an integer and stored using the INTEGER
+storage class.</P>
+
+<P>A column with REAL affinity behaves like a column with NUMERIC
+affinity except that it forces integer values into floating point
+representation.  (As an optimization, integer values are stored on
+disk as integers in order to take up less space and are only converted
+to floating point as the value is read out of the table.)</P>
+
+<P>A column with affinity NONE does not prefer one storage class over
+another.  It makes no attempt to coerce data before
+it is inserted.</P>
+
+<h4>2.1 Determination Of Column Affinity</h4>
+
+<P>The type affinity of a column is determined by the declared type
+of the column, according to the following rules:</P>
+<OL>
+	<LI><P>If the datatype contains the string &quot;INT&quot; then it
+	is assigned INTEGER affinity.</P>
+
+	<LI><P>If the datatype of the column contains any of the strings
+	&quot;CHAR&quot;, &quot;CLOB&quot;, or &quot;TEXT&quot; then that
+	column has TEXT affinity. Notice that the type VARCHAR contains the
+	string &quot;CHAR&quot; and is thus assigned TEXT affinity.</P>
+
+	<LI><P>If the datatype for a column
+         contains the string &quot;BLOB&quot; or if
+        no datatype is specified then the column has affinity NONE.</P>
+
+        <LI><P>If the datatype for a column
+        contains any of the strings &quot;REAL&quot;, &quot;FLOA&quot;,
+        or &quot;DOUB&quot; then the column has REAL affinity</P>
+
+	<LI><P>Otherwise, the affinity is NUMERIC.</P>
+</OL>
+
+<P>If a table is created using a "CREATE TABLE &lt;table&gt; AS
+SELECT..." statement, then all columns have no datatype specified
+and they are given no affinity.</P>
+
+<h4>2.2 Column Affinity Example</h4>
+
+<blockquote>
+<PRE>CREATE TABLE t1(
+    t  TEXT,
+    nu NUMERIC, 
+    i  INTEGER,
+    no BLOB
+);
+
+-- Storage classes for the following row:
+-- TEXT, REAL, INTEGER, TEXT
+INSERT INTO t1 VALUES('500.0', '500.0', '500.0', '500.0');
+
+-- Storage classes for the following row:
+-- TEXT, REAL, INTEGER, REAL
+INSERT INTO t1 VALUES(500.0, 500.0, 500.0, 500.0);
+</PRE>
+</blockquote>
+
+<a name="comparisons">
+<h3>3. Comparison Expressions</h3>
+
+<P>Like SQLite version 2, version 3
+features the binary comparison operators '=',
+'&lt;', '&lt;=', '&gt;=' and '!=', an operation to test for set
+membership, 'IN', and the ternary comparison operator 'BETWEEN'.</P>
+<P>The results of a comparison depend on the storage classes of the
+two values being compared, according to the following rules:</P>
+<UL>
+	<LI><P>A value with storage class NULL is considered less than any
+	other value (including another value with storage class NULL).</P>
+
+	<LI><P>An INTEGER or REAL value is less than any TEXT or BLOB value.
+	When an INTEGER or REAL is compared to another INTEGER or REAL, a
+	numerical comparison is performed.</P>
+
+	<LI><P>A TEXT value is less than a BLOB value. When two TEXT values
+	are compared, the C library function memcmp() is usually used to
+	determine the result. However this can be overridden, as described
+	under 'User-defined collation Sequences' below.</P>
+
+	<LI><P>When two BLOB values are compared, the result is always
+	determined using memcmp().</P>
+</UL>
+
+<P>SQLite may attempt to convert values between the numeric storage
+classes (INTEGER and REAL) and TEXT before performing a comparison.
+For binary comparisons, this is done in the cases enumerated below.
+The term "expression" used in the bullet points below means any
+SQL scalar expression or literal other than a column value.  Note that
+if X and Y.Z are a column names, then +X and +Y.Z are considered
+expressions.</P>
+<UL>
+	<LI><P>When a column value is compared to the result of an
+	expression, the affinity of the column is applied to the result of
+	the expression before the comparison takes place.</P>
+
+	<LI><P>When two column values are compared, if one column has
+	INTEGER or REAL or NUMERIC affinity and the other does not, 
+        then NUMERIC affinity is applied to any values with storage
+        class TEXT extracted from the non-NUMERIC column.</P>
+
+	<LI><P>When the results of two expressions are compared, no
+        conversions occur.  The results are compared as is.  If a string
+        is compared to a number, the number will always be less than the
+        string.</P>
+</UL>
+
+<P>
+In SQLite, the expression "a BETWEEN b AND c" is equivalent to "a &gt;= b
+AND a &lt;= c", even if this means that different affinities are applied to
+'a' in each of the comparisons required to evaluate the expression.
+</P>
+
+<P>Expressions of the type "a IN (SELECT b ....)" are handled by the three
+rules enumerated above for binary comparisons (e.g. in a
+similar manner to "a = b"). For example if 'b' is a column value
+and 'a' is an expression, then the affinity of 'b' is applied to 'a'
+before any comparisons take place.</P>
+
+<P>SQLite treats the expression "a IN (x, y, z)" as equivalent to "a = +x OR
+a = +y OR a = +z".  The values to the right of the IN operator (the "x", "y",
+and "z" values in this example) are considered to be expressions, even if they
+happen to be column values.  If the value of the left of the IN operator is
+a column, then the affinity of that column is used.  If the value is an
+expression then no conversions occur.
+</P>
+
+<h4>3.1 Comparison Example</h4>
+
+<blockquote>
+<PRE>
+CREATE TABLE t1(
+    a TEXT,
+    b NUMERIC,
+    c BLOB
+);
+
+-- Storage classes for the following row:
+-- TEXT, REAL, TEXT
+INSERT INTO t1 VALUES('500', '500', '500');
+
+-- 60 and 40 are converted to '60' and '40' and values are compared as TEXT.
+SELECT a &lt; 60, a &lt; 40 FROM t1;
+1|0
+
+-- Comparisons are numeric. No conversions are required.
+SELECT b &lt; 60, b &lt; 600 FROM t1;
+0|1
+
+-- Both 60 and 600 (storage class NUMERIC) are less than '500'
+-- (storage class TEXT).
+SELECT c &lt; 60, c &lt; 600 FROM t1;
+0|0
+</PRE>
+</blockquote>
+<h3>4. Operators</h3>
+
+<P>All mathematical operators (which is to say, all operators other
+than the concatenation operator &quot;||&quot;) apply NUMERIC
+affinity to all operands prior to being carried out. If one or both
+operands cannot be converted to NUMERIC then the result of the
+operation is NULL.</P>
+
+<P>For the concatenation operator, TEXT affinity is applied to both
+operands. If either operand cannot be converted to TEXT (because it
+is NULL or a BLOB) then the result of the concatenation is NULL.</P>
+
+<h3>5. Sorting, Grouping and Compound SELECTs</h3>
+
+<P>When values are sorted by an ORDER by clause, values with storage
+class NULL come first, followed by INTEGER and REAL values
+interspersed in numeric order, followed by TEXT values usually in
+memcmp() order, and finally BLOB values in memcmp() order. No storage
+class conversions occur before the sort.</P>
+
+<P>When grouping values with the GROUP BY clause values with
+different storage classes are considered distinct, except for INTEGER
+and REAL values which are considered equal if they are numerically
+equal. No affinities are applied to any values as the result of a
+GROUP by clause.</P>
+
+<P>The compound SELECT operators UNION,
+INTERSECT and EXCEPT perform implicit comparisons between values.
+Before these comparisons are performed an affinity may be applied to
+each value. The same affinity, if any, is applied to all values that
+may be returned in a single column of the compound SELECT result set.
+The affinity applied is the affinity of the column returned by the
+left most component SELECTs that has a column value (and not some
+other kind of expression) in that position. If for a given compound
+SELECT column none of the component SELECTs return a column value, no
+affinity is applied to the values from that column before they are
+compared.</P>
+
+<h3>6. Other Affinity Modes</h3>
+
+<P>The above sections describe the operation of the database engine
+in 'normal' affinity mode. SQLite version 3 will feature two other affinity
+modes, as follows:</P>
+<UL>
+	<LI><P><B>Strict affinity</B> mode. In this mode if a conversion
+	between storage classes is ever required, the database engine
+	returns an error and the current statement is rolled back.</P>
+
+	<LI><P><B>No affinity</B> mode. In this mode no conversions between
+	storage classes are ever performed. Comparisons between values of
+	different storage classes (except for INTEGER and REAL) are always
+	false.</P>
+</UL>
+
+<a name="collation"></a>
+<h3>7. User-defined Collation Sequences</h3>
+
+<p>
+By default, when SQLite compares two text values, the result of the
+comparison is determined using memcmp(), regardless of the encoding of the
+string. SQLite v3 provides the ability for users to supply arbitrary
+comparison functions, known as user-defined collation sequences, to be used
+instead of memcmp().
+</p>  
+<p>
+Aside from the default collation sequence BINARY, implemented using
+memcmp(), SQLite features one extra built-in collation sequences 
+intended for testing purposes, the NOCASE collation:
+</p>  
+<UL>
+	<LI><b>BINARY</b> - Compares string data using memcmp(), regardless
+                            of text encoding.</LI>
+	<LI><b>NOCASE</b> - The same as binary, except the 26 upper case
+			    characters used by the English language are
+			    folded to their lower case equivalents before
+                            the comparison is performed.  </UL>
+
+
+<h4>7.1 Assigning Collation Sequences from SQL</h4>
+
+<p>
+Each column of each table has a default collation type. If a collation type
+other than BINARY is required, a COLLATE clause is specified as part of the
+<a href="lang_createtable.html">column definition</a> to define it. 
+</p>  
+
+<p>
+Whenever two text values are compared by SQLite, a collation sequence is
+used to determine the results of the comparison according to the following
+rules. Sections 3 and 5 of this document describe the circumstances under
+which such a comparison takes place.
+</p>  
+
+<p>
+For binary comparison operators (=, <, >, <= and >=) if either operand is a
+column, then the default collation type of the column determines the
+collation sequence to use for the comparison. If both operands are columns,
+then the collation type for the left operand determines the collation
+sequence used. If neither operand is a column, then the BINARY collation
+sequence is used.  For the purposes of this paragraph, a column name
+preceded by one or more unary "+" operators is considered a column name.
+</p>  
+
+<p>
+The expression "x BETWEEN y and z" is equivalent to "x &gt;= y AND x &lt;=
+z". The expression "x IN (SELECT y ...)" is handled in the same way as the
+expression "x = y" for the purposes of determining the collation sequence
+to use. The collation sequence used for expressions of the form "x IN (y, z
+...)" is the default collation type of x if x is a column, or BINARY
+otherwise.
+</p>  
+
+<p>
+An <a href="lang_select.html">ORDER BY</a> clause that is part of a SELECT
+statement may be assigned a collation sequence to be used for the sort
+operation explicitly. In this case the explicit collation sequence is
+always used.  Otherwise, if the expression sorted by an ORDER BY clause is
+a column, then the default collation type of the column is used to
+determine sort order. If the expression is not a column, then the BINARY
+collation sequence is used.
+</p>  
+
+<h4>7.2 Collation Sequences Example</h4>
+<p>
+The examples below identify the collation sequences that would be used to
+determine the results of text comparisons that may be performed by various
+SQL statements. Note that a text comparison may not be required, and no
+collation sequence used, in the case of numeric, blob or NULL values.
+</p>
+<blockquote>
+<PRE>
+CREATE TABLE t1(
+    a,                 -- default collation type BINARY
+    b COLLATE BINARY,  -- default collation type BINARY
+    c COLLATE REVERSE, -- default collation type REVERSE
+    d COLLATE NOCASE   -- default collation type NOCASE
+);
+
+-- Text comparison is performed using the BINARY collation sequence.
+SELECT (a = b) FROM t1;
+
+-- Text comparison is performed using the NOCASE collation sequence.
+SELECT (d = a) FROM t1;
+
+-- Text comparison is performed using the BINARY collation sequence.
+SELECT (a = d) FROM t1;
+
+-- Text comparison is performed using the REVERSE collation sequence.
+SELECT ('abc' = c) FROM t1;
+
+-- Text comparison is performed using the REVERSE collation sequence.
+SELECT (c = 'abc') FROM t1;
+
+-- Grouping is performed using the NOCASE collation sequence (i.e. values
+-- 'abc' and 'ABC' are placed in the same group).
+SELECT count(*) GROUP BY d FROM t1;
+
+-- Grouping is performed using the BINARY collation sequence.
+SELECT count(*) GROUP BY (d || '') FROM t1;
+
+-- Sorting is performed using the REVERSE collation sequence.
+SELECT * FROM t1 ORDER BY c;
+
+-- Sorting is performed using the BINARY collation sequence.
+SELECT * FROM t1 ORDER BY (c || '');
+
+-- Sorting is performed using the NOCASE collation sequence.
+SELECT * FROM t1 ORDER BY c COLLATE NOCASE;
+
+</PRE>
+</blockquote>
+
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/datatypes.tcl b/client/src/thirdparty/sqlite-3.4.2/www/datatypes.tcl
new file mode 100644
index 0000000..1b45fb6
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/datatypes.tcl
@@ -0,0 +1,243 @@
+#
+# Run this script to generated a datatypes.html output file
+#
+set rcsid {$Id: datatypes.tcl,v 1.8 2004/10/10 17:24:55 drh Exp $}
+source common.tcl
+header {Datatypes In SQLite version 2}
+puts {
+<h2>Datatypes In SQLite Version 2</h2>
+
+<h3>1.0 &nbsp; Typelessness</h3>
+<p>
+SQLite is "typeless".  This means that you can store any
+kind of data you want in any column of any table, regardless of the
+declared datatype of that column.  
+(See the one exception to this rule in section 2.0 below.)
+This behavior is a feature, not
+a bug.  A database is suppose to store and retrieve data and it 
+should not matter to the database what format that data is in.
+The strong typing system found in most other SQL engines and
+codified in the SQL language spec is a misfeature -
+it is an example of the implementation showing through into the
+interface.  SQLite seeks to overcome this misfeature by allowing
+you to store any kind of data into any kind of column and by
+allowing flexibility in the specification of datatypes.
+</p>
+
+<p>
+A datatype to SQLite is any sequence of zero or more names
+optionally followed by a parenthesized lists of one or two
+signed integers.  Notice in particular that a datatype may
+be <em>zero</em> or more names.  That means that an empty
+string is a valid datatype as far as SQLite is concerned.
+So you can declare tables where the datatype of each column
+is left unspecified, like this:
+</p>
+
+<blockquote><pre>
+CREATE TABLE ex1(a,b,c);
+</pre></blockquote>
+
+<p>
+Even though SQLite allows the datatype to be omitted, it is
+still a good idea to include it in your CREATE TABLE statements,
+since the data type often serves as a good hint to other
+programmers about what you intend to put in the column. And
+if you ever port your code to another database engine, that
+other engine will probably require a datatype of some kind.
+SQLite accepts all the usual datatypes.  For example:
+</p>
+
+<blockquote><pre>
+CREATE TABLE ex2(
+  a VARCHAR(10),
+  b NVARCHAR(15),
+  c TEXT,
+  d INTEGER,
+  e FLOAT,
+  f BOOLEAN,
+  g CLOB,
+  h BLOB,
+  i TIMESTAMP,
+  j NUMERIC(10,5)
+  k VARYING CHARACTER (24),
+  l NATIONAL VARYING CHARACTER(16)
+);
+</pre></blockquote>
+
+<p>
+And so forth.  Basically any sequence of names optionally followed by 
+one or two signed integers in parentheses will do.
+</p>
+
+<h3>2.0 &nbsp; The INTEGER PRIMARY KEY</h3>
+
+<p>
+One exception to the typelessness of SQLite is a column whose type
+is INTEGER PRIMARY KEY.  (And you must use "INTEGER" not "INT".
+A column of type INT PRIMARY KEY is typeless just like any other.)
+INTEGER PRIMARY KEY columns must contain a 32-bit signed integer.  Any
+attempt to insert non-integer data will result in an error.
+</p>
+
+<p>
+INTEGER PRIMARY KEY columns can be used to implement the equivalent
+of AUTOINCREMENT.  If you try to insert a NULL into an INTEGER PRIMARY
+KEY column, the column will actually be filled with a integer that is
+one greater than the largest key already in the table.  Or if the
+largest key is 2147483647, then the column will be filled with a
+random integer.  Either way, the INTEGER PRIMARY KEY column will be
+assigned a unique integer.  You can retrieve this integer using
+the <b>sqlite_last_insert_rowid()</b> API function or using the
+<b>last_insert_rowid()</b> SQL function in a subsequent SELECT statement.
+</p>
+
+<h3>3.0 &nbsp; Comparison and Sort Order</h3>
+
+<p>
+SQLite is typeless for the purpose of deciding what data is allowed
+to be stored in a column.  But some notion of type comes into play
+when sorting and comparing data.  For these purposes, a column or
+an expression can be one of two types: <b>numeric</b> and <b>text</b>.
+The sort or comparison may give different results depending on which
+type of data is being sorted or compared.
+</p>
+
+<p>
+If data is of type <b>text</b> then the comparison is determined by
+the standard C data comparison functions <b>memcmp()</b> or
+<b>strcmp()</b>.  The comparison looks at bytes from two inputs one
+by one and returns the first non-zero difference.
+Strings are '\000' terminated so shorter
+strings sort before longer strings, as you would expect.
+</p>
+
+<p>
+For numeric data, this situation is more complex.  If both inputs
+look like well-formed numbers, then they are converted
+into floating point values using <b>atof()</b> and compared numerically.
+If one input is not a well-formed number but the other is, then the
+number is considered to be less than the non-number.  If neither inputs
+is a well-formed number, then <b>strcmp()</b> is used to do the
+comparison.
+</p>
+
+<p>
+Do not be confused by the fact that a column might have a "numeric"
+datatype.  This does not mean that the column can contain only numbers.
+It merely means that if the column does contain a number, that number
+will sort in numerical order.
+</p>
+
+<p>
+For both text and numeric values, NULL sorts before any other value.
+A comparison of any value against NULL using operators like "&lt;" or
+"&gt;=" is always false.
+</p>
+
+<h3>4.0 &nbsp; How SQLite Determines Datatypes</h3>
+
+<p>
+For SQLite version 2.6.3 and earlier, all values used the numeric datatype.
+The text datatype appears in version 2.7.0 and later.  In the sequel it
+is assumed that you are using version 2.7.0 or later of SQLite.
+</p>
+
+<p>
+For an expression, the datatype of the result is often determined by
+the outermost operator.  For example, arithmetic operators ("+", "*", "%")
+always return a numeric results.  The string concatenation operator
+("||") returns a text result.  And so forth.  If you are ever in doubt
+about the datatype of an expression you can use the special <b>typeof()</b>
+SQL function to determine what the datatype is.  For example:
+</p>
+
+<blockquote><pre>
+sqlite&gt; SELECT typeof('abc'+123);
+numeric
+sqlite&gt; SELECT typeof('abc'||123);
+text
+</pre></blockquote>
+
+<p>
+For table columns, the datatype is determined by the type declaration
+of the CREATE TABLE statement.  The datatype is text if and only if
+the type declaration contains one or more of the following strings:
+</p>
+
+<blockquote>
+BLOB<br>
+CHAR<br>
+CLOB</br>
+TEXT
+</blockquote>
+
+<p>
+The search for these strings in the type declaration is case insensitive,
+of course.  If any of the above strings occur anywhere in the type
+declaration, then the datatype of the column is text.  Notice that
+the type "VARCHAR" contains "CHAR" as a substring so it is considered
+text.</p>
+
+<p>If none of the strings above occur anywhere in the type declaration,
+then the datatype is numeric.  Note in particular that the datatype for columns
+with an empty type declaration is numeric.
+</p>
+
+<h3>5.0 &nbsp; Examples</h3>
+
+<p>
+Consider the following two command sequences:
+</p>
+
+<blockquote><pre>
+CREATE TABLE t1(a INTEGER UNIQUE);        CREATE TABLE t2(b TEXT UNIQUE);
+INSERT INTO t1 VALUES('0');               INSERT INTO t2 VALUES(0);
+INSERT INTO t1 VALUES('0.0');             INSERT INTO t2 VALUES(0.0);
+</pre></blockquote>
+
+<p>In the sequence on the left, the second insert will fail.  In this case,
+the strings '0' and '0.0' are treated as numbers since they are being 
+inserted into a numeric column but 0==0.0 which violates the uniqueness
+constraint.  However, the second insert in the right-hand sequence works.  In
+this case, the constants 0 and 0.0 are treated a strings which means that
+they are distinct.</p>
+
+<p>SQLite always converts numbers into double-precision (64-bit) floats
+for comparison purposes.  This means that a long sequence of digits that
+differ only in insignificant digits will compare equal if they
+are in a numeric column but will compare unequal if they are in a text
+column.  We have:</p>
+
+<blockquote><pre>
+INSERT INTO t1                            INSERT INTO t2
+   VALUES('12345678901234567890');           VALUES(12345678901234567890);
+INSERT INTO t1                            INSERT INTO t2
+   VALUES('12345678901234567891');           VALUES(12345678901234567891);
+</pre></blockquote>
+
+<p>As before, the second insert on the left will fail because the comparison
+will convert both strings into floating-point number first and the only
+difference in the strings is in the 20-th digit which exceeds the resolution
+of a 64-bit float.  In contrast, the second insert on the right will work
+because in that case, the numbers being inserted are strings and are
+compared using memcmp().</p>
+
+<p>
+Numeric and text types make a difference for the DISTINCT keyword too:
+</p>
+
+<blockquote><pre>
+CREATE TABLE t3(a INTEGER);               CREATE TABLE t4(b TEXT);
+INSERT INTO t3 VALUES('0');               INSERT INTO t4 VALUES(0);
+INSERT INTO t3 VALUES('0.0');             INSERT INTO t4 VALUES(0.0);
+SELECT DISTINCT * FROM t3;                SELECT DISTINCT * FROM t4;
+</pre></blockquote>
+
+<p>
+The SELECT statement on the left returns a single row since '0' and '0.0'
+are treated as numbers and are therefore indistinct.  But the SELECT 
+statement on the right returns two rows since 0 and 0.0 are treated
+a strings which are different.</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/different.tcl b/client/src/thirdparty/sqlite-3.4.2/www/different.tcl
new file mode 100644
index 0000000..1858e6f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/different.tcl
@@ -0,0 +1,224 @@
+set rcsid {$Id: different.tcl,v 1.8 2006/12/18 14:12:21 drh Exp $}
+source common.tcl
+header {Distinctive Features Of SQLite}
+puts {
+<p>
+This page highlights some of the characteristics of SQLite that are
+unusual and which make SQLite different from many other SQL
+database engines.
+</p>
+}
+proc feature {tag name text} {
+  puts "<a name=\"$tag\" />"
+  puts "<p><b>$name</b></p>\n"
+  puts "<blockquote>$text</blockquote>\n"
+}
+
+feature zeroconfig {Zero-Configuration} {
+  SQLite does not need to be "installed" before it is used. 
+  There is no "setup" procedure.  There is no
+  server process that needs to be started, stopped, or configured.
+  There is
+  no need for an administrator to create a new database instance or assign
+  access permissions to users.
+  SQLite uses no configuration files.
+  Nothing needs to be done to tell the system that SQLite is running.
+  No actions are required to recover after a system crash or power failure.
+  There is nothing to troubleshoot.
+  <p>
+  SQLite just works.
+  <p>
+  Other more familiar database engines run great once you get them going.
+  But doing the initial installation and configuration can be
+  intimidatingly complex.
+}
+
+feature serverless {Serverless} {
+  Most SQL database engines are implemented as a separate server
+  process.  Programs that want to access the database communicate
+  with the server using some kind of interprocess communcation
+  (typically TCP/IP) to send requests to the server and to receive
+  back results.  SQLite does not work this way.  With SQLite, the
+  process that wants to access the database reads and writes
+  directly from the database files on disk.  There is no intermediary
+  server process.
+  <p>
+  There are advantages and disadvantages to being serverless.  The
+  main advantage is that there is no separate server process
+  to install, setup, configure, initialize, manage, and troubleshoot.
+  This is one reason why SQLite is a "zero-configuration" database
+  engine.  Programs that use SQLite require no administrative support
+  for setting up the database engine before they are run.  Any program
+  that is able to access the disk is able to use an SQLite database.
+  <p>
+  On the other hand, a database engine that uses a server can provide
+  better protection from bugs in the client application - stray pointers
+  in a client cannot corrupt memory on the server.  And because a server
+  is a single persistent process, it is able control database access with
+  more precision, allowing for finer grain locking and better concurrancy.
+  <p>
+  Most SQL database engines are client/server based.  Of those that are
+  serverless, SQLite is the only one that this author knows of that
+  allows multiple applications to access the same database at the same time.
+}
+
+feature onefile {Single Database File} {
+  An SQLite database is a single ordinary disk file that can be located
+  anywhere in the directory hierarchy.  If SQLite can read
+  the disk file then it can read anything in the database.  If the disk
+  file and its directory are writable, then SQLite can change anything
+  in the database.   Database files can easily be copied onto a USB
+  memory stick or emailed for sharing.
+  <p>
+  Other SQL database engines tend to store data as a large collection of
+  files.  Often these files are in a standard location that only the
+  database engine itself can access.  This makes the data more secure,
+  but also makes it harder to access.  Some SQL database engines provide
+  the option of writing directly to disk and bypassing the filesystem
+  all together.  This provides added performance, but at the cost of
+  considerable setup and maintenance complexity.
+}
+
+feature small {Compact} {
+  When optimized for size, the whole SQLite library with everything enabled
+  is less than 225KiB in size (as measured on an ix86 using the "size"
+  utility from the GNU compiler suite.)  Unneeded features can be disabled
+  at compile-time to further reduce the size of the library to under
+  170KiB if desired.
+  <p>
+  Most other SQL database engines are much larger than this.  IBM boasts
+  that it's recently released CloudScape database engine is "only" a 2MiB
+  jar file - 10 times larger than SQLite even after it is compressed!
+  Firebird boasts that it's client-side library is only 350KiB.  That's
+  50% larger than SQLite and does not even contain the database engine.
+  The Berkeley DB library from Sleepycat is 450KiB and it omits SQL
+  support, providing the programmer with only simple key/value pairs.
+}
+
+feature typing {Manifest typing} {
+  Most SQL database engines use static typing.  A datatype is associated
+  with each column in a table and only values of that particular datatype
+  are allowed to be stored in that column.  SQLite relaxes this restriction
+  by using manifest typing.
+  In manifest typing, the datatype is a property of the value itself, not 
+  of the column in which the value is stored.
+  SQLite thus allows the user to store
+  any value of any datatype into any column regardless of the declared type
+  of that column.  (There are some exceptions to this rule: An INTEGER
+  PRIMARY KEY column may only store integers.  And SQLite attempts to coerce
+  values into the declared datatype of the column when it can.)
+  <p>
+  As far as we can tell, the SQL language specification allows the use
+  of manifest typing.   Nevertheless, most other SQL database engines are
+  statically typed and so some people
+  feel that the use of manifest typing is a bug in SQLite.  But the authors
+  of SQLite feel very strongly that this is a feature.  The use of manifest
+  typing in SQLite is a deliberate design decision which has proven in practice
+  to make SQLite more reliable and easier to use, especially when used in
+  combination with dynamically typed programming languages such as Tcl and
+  Python.
+}
+
+feature flex {Variable-length records} {
+  Most other SQL database engines allocated a fixed amount of disk space
+  for each row in most tables.  They play special tricks for handling
+  BLOBs and CLOBs which can be of wildly varying length.  But for most
+  tables, if you declare a column to be a VARCHAR(100) then the database
+  engine will allocate
+  100 bytes of disk space regardless of how much information you actually
+  store in that column.
+  <p>
+  SQLite, in contrast, use only the amount of disk space actually
+  needed to store the information in a row.  If you store a single
+  character in a VARCHAR(100) column, then only a single byte of disk
+  space is consumed.  (Actually two bytes - there is some overhead at
+  the beginning of each column to record its datatype and length.)
+  <p>
+  The use of variable-length records by SQLite has a number of advantages.
+  It results in smaller database files, obviously.  It also makes the
+  database run faster, since there is less information to move to and from
+  disk.  And, the use of variable-length records makes it possible for
+  SQLite to employ manifest typing instead of static typing.
+}
+
+feature readable {Readable source code} {
+  The source code to SQLite is designed to be readable and accessible to
+  the average programmer.  All procedures and data structures and many
+  automatic variables are carefully commented with useful information about
+  what they do.  Boilerplate commenting is omitted.
+}
+
+feature vdbe {SQL statements compile into virtual machine code} {
+  Every SQL database engine compiles each SQL statement into some kind of
+  internal data structure which is then used to carry out the work of the
+  statement.  But in most SQL engines that internal data structure is a
+  complex web of interlinked structures and objects.  In SQLite, the compiled
+  form of statements is a short program in a machine-language like
+  representation.  Users of the database can view this 
+  <a href="opcode.html">virtual machine language</a>
+  by prepending the <a href="lang_explain.html">EXPLAIN</a> keyword
+  to a query.
+  <p>
+  The use of a virtual machine in SQLite has been a great benefit to
+  library's development.  The virtual machine provides a crisp, well-defined
+  junction between the front-end of SQLite (the part that parses SQL
+  statements and generates virtual machine code) and the back-end (the
+  part that executes the virtual machine code and computes a result.)
+  The virtual machine allows the developers to see clearly and in an
+  easily readable form what SQLite is trying to do with each statement
+  it compiles, which is a tremendous help in debugging.
+  Depending on how it is compiled, SQLite also has the capability of
+  tracing the execution of the virtual machine - printing each
+  virtual machine instruction and its result as it executes.
+}
+
+#feature binding {Tight bindings to dynamic languages} {
+#  Because it is embedded, SQLite can have a much tighter and more natural
+#  binding to high-level dynamic languages such as Tcl, Perl, Python,
+#  PHP, and Ruby.
+#  For example, 
+#}
+
+feature license {Public domain} {
+  The source code for SQLite is in the public domain.  No claim of copyright
+  is made on any part of the core source code.  (The documentation and test
+  code is a different matter - some sections of documentation and test logic
+  are governed by open-sources licenses.)  All contributors to the
+  SQLite core software have signed affidavits specifically disavowing any
+  copyright interest in the code.  This means that anybody is able to legally
+  do anything they want with the SQLite source code.
+  <p>
+  There are other SQL database engines with liberal licenses that allow
+  the code to be broadly and freely used.  But those other engines are
+  still governed by copyright law.  SQLite is different in that copyright
+  law simply does not apply.  
+  <p>
+  The source code files for other SQL database engines typically begin
+  with a comment describing your license rights to view and copy that file.
+  The SQLite source code contains no license since it is not governed by
+  copyright.  Instead of a license, the SQLite source code offers a blessing:
+  <blockquote>
+  <i>May you do good and not evil<br>
+  May you find forgiveness for yourself and forgive others<br>
+  May you share freely, never taking more than you give.</i>
+  </blockquote>
+}
+
+feature extensions {SQL language extensions} {
+  SQLite provides a number of enhancements to the SQL language 
+  not normally found in other database engines.
+  The EXPLAIN keyword and manifest typing have already been mentioned
+  above.  SQLite also provides statements such as 
+  <a href="lang_replace.html">REPLACE</a> and the
+  <a href="lang_conflict.html">ON CONFLICT</a> clause that allow for
+  added control over the resolution of constraint conflicts.
+  SQLite supports <a href="lang_attach.html">ATTACH</a> and
+  <a href="lang_detach.html">DETACH</a> commands that allow multiple
+  independent databases to be used together in the same query.
+  And SQLite defines APIs that allows the user to add new
+  <a href="capi3ref.html#sqlite3_create_function">SQL functions</a>
+  and <a href="capi3ref.html#sqlite3_create_collation">collating sequences</a>.
+}
+
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/direct1b.gif b/client/src/thirdparty/sqlite-3.4.2/www/direct1b.gif
new file mode 100644
index 0000000..6f90118
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/direct1b.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7d244add5474ce4c14dc5bcbfd5b4ed2cfb12177dcca8822136654ed6a611a6
+size 11439
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/docs.tcl b/client/src/thirdparty/sqlite-3.4.2/www/docs.tcl
new file mode 100644
index 0000000..80fac53
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/docs.tcl
@@ -0,0 +1,159 @@
+# This script generates the "docs.html" page that describes various
+# sources of documentation available for SQLite.
+#
+set rcsid {$Id: docs.tcl,v 1.15 2007/10/04 00:29:29 drh Exp $}
+source common.tcl
+header {SQLite Documentation}
+puts {
+<h2>Available Documentation</h2>
+<table width="100%" cellpadding="5">
+}
+
+proc doc {name url desc} {
+  puts {<tr><td valign="top" align="right">}
+  regsub -all { +} $name {\&nbsp;} name
+  puts "<a href=\"$url\">$name</a></td>"
+  puts {<td width="10"></td>}
+  puts {<td valign="top" align="left">}
+  puts $desc
+  puts {</td></tr>}
+}
+
+doc {Appropriate Uses For SQLite} {whentouse.html} {
+  This document describes situations where SQLite is an approriate
+  database engine to use versus situations where a client/server
+  database engine might be a better choice.
+}
+
+doc {Distinctive Features} {different.html} {
+  This document enumerates and describes some of the features of
+  SQLite that make it different from other SQL database engines.
+}
+
+doc {SQLite In 5 Minutes Or Less} {quickstart.html} {
+  A very quick introduction to programming with SQLite.
+}
+
+doc {SQL Syntax} {lang.html} {
+  This document describes the SQL language that is understood by
+  SQLite.  
+}
+doc {Version 3 C/C++ API<br>Reference} {capi3ref.html} {
+  This document describes each API function separately.
+}
+doc {Sharing Cache Mode} {sharedcache.html} {
+  Version 3.3.0 and later supports the ability for two or more
+  database connections to share the same page and schema cache.
+  This feature is useful for certain specialized applications.
+}
+doc {Tcl API} {tclsqlite.html} {
+  A description of the TCL interface bindings for SQLite.
+}
+
+doc {How SQLite Implements Atomic Commit} {ac/atomiccommit.html} {
+  A description of the logic within SQLite that implements
+  transactions with atomic commit, even in the face of power
+  failures.
+}
+doc {Moving From SQLite 3.4 to 3.5} {34to35.html} {
+  A document describing the differences between SQLite version 3.4.2
+  and 3.5.0.
+}
+
+doc {Pragma commands} {pragma.html} {
+  This document describes SQLite performance tuning options and other 
+  special purpose database commands.
+}
+doc {SQLite Version 3} {version3.html} {
+  A summary of of the changes between SQLite version 2.8 and SQLite version 3.0.
+}
+doc {Version 3 C/C++ API} {capi3.html} {
+  A description of the C/C++ interface bindings for SQLite version 3.0.0
+  and following.
+}
+doc {Version 3 DataTypes } {datatype3.html} {
+  SQLite version 3 introduces the concept of manifest typing, where the
+  type of a value is associated with the value itself, not the column that
+  it is stored in.
+  This page describes data typing for SQLite version 3 in further detail.
+}
+
+doc {Locking And Concurrency<br>In SQLite Version 3} {lockingv3.html} {
+  A description of how the new locking code in version 3 increases
+  concurrancy and decreases the problem of writer starvation.
+}
+
+doc {Overview Of The Optimizer} {optoverview.html} {
+  A quick overview of the various query optimizations that are
+  attempted by the SQLite code generator.
+}
+
+
+doc {Null Handling} {nulls.html} {
+  Different SQL database engines handle NULLs in different ways.  The
+  SQL standards are ambiguous.  This document describes how SQLite handles
+  NULLs in comparison with other SQL database engines.
+}
+
+doc {Copyright} {copyright.html} {
+  SQLite is in the public domain.  This document describes what that means
+  and the implications for contributors.
+}
+
+doc {Unsupported SQL} {omitted.html} {
+  This page describes features of SQL that SQLite does not support.
+}
+
+doc {Version 2 C/C++ API} {c_interface.html} {
+  A description of the C/C++ interface bindings for SQLite through version 
+  2.8
+}
+
+
+doc {Version 2 DataTypes } {datatypes.html} {
+  A description of how SQLite version 2 handles SQL datatypes.
+  Short summary:  Everything is a string.
+}
+
+doc {Release History} {changes.html} {
+  A chronology of SQLite releases going back to version 1.0.0
+}
+
+
+doc {Speed Comparison} {speed.html} {
+  The speed of version 2.7.6 of SQLite is compared against PostgreSQL and
+  MySQL.
+}
+
+doc {Architecture} {arch.html} {
+  An architectural overview of the SQLite library, useful for those who want
+  to hack the code.
+}
+
+doc {VDBE Tutorial} {vdbe.html} {
+  The VDBE is the subsystem within SQLite that does the actual work of
+  executing SQL statements.  This page describes the principles of operation
+  for the VDBE in SQLite version 2.7.  This is essential reading for anyone
+  who want to modify the SQLite sources.
+}
+
+doc {VDBE Opcodes} {opcode.html} {
+  This document is an automatically generated description of the various
+  opcodes that the VDBE understands.  Programmers can use this document as
+  a reference to better understand the output of EXPLAIN listings from
+  SQLite.
+}
+
+doc {Compilation Options} {compile.html} {
+  This document describes the compile time options that may be set to 
+  modify the default behaviour of the library or omit optional features
+  in order to reduce binary size.
+}
+
+doc {Backwards Compatibility} {formatchng.html} {
+  This document details all of the incompatible changes to the SQLite
+  file format that have occurred since version 1.0.0.
+}
+
+puts {</table>}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/download.tcl b/client/src/thirdparty/sqlite-3.4.2/www/download.tcl
new file mode 100644
index 0000000..b47cd5b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/download.tcl
@@ -0,0 +1,236 @@
+#
+# Run this TCL script to generate HTML for the download.html file.
+#
+set rcsid {$Id: download.tcl,v 1.27 2007/05/08 18:30:36 drh Exp $}
+source common.tcl
+header {SQLite Download Page}
+
+puts {
+<h2>SQLite Download Page</h1>
+<table width="100%" cellpadding="5">
+}
+
+proc Product {pattern desc} {
+  regsub {V[23]} $pattern {*} p3
+  regsub V2 $pattern {(2[0-9a-z._]+)} pattern
+  regsub V3 $pattern {(3[0-9a-z._]+)} pattern
+  set p2 [string map {* .*} $pattern]
+  set flist [glob -nocomplain $p3]
+  foreach file [lsort -dict $flist] {
+    if {![regexp ^$p2\$ $file all version]} continue
+    regsub -all _ $version . version
+    set size [file size $file]
+    set units bytes
+    if {$size>1024*1024} {
+      set size [format %.2f [expr {$size/(1024.0*1024.0)}]]
+      set units MiB
+    } elseif {$size>1024} {
+      set size [format %.2f [expr {$size/(1024.0)}]]
+      set units KiB
+    }
+    puts "<tr><td width=\"10\"></td>"
+    puts "<td valign=\"top\" align=\"right\">"
+    puts "<a href=\"$file\">$file</a><br>($size $units)</td>"
+    puts "<td width=\"5\"></td>"
+    regsub -all VERSION $desc $version d2
+    puts "<td valign=\"top\">[string trim $d2]</td></tr>"
+  }
+}
+cd doc
+
+proc Heading {title} {
+  puts "<tr><td colspan=4><big><b>$title</b></big></td></tr>"
+}
+
+Heading {Precompiled Binaries for Linux}
+
+Product sqlite3-V3.bin.gz {
+  A command-line program for accessing and modifying
+  SQLite version 3.* databases.
+  See <a href="sqlite.html">the documentation</a> for additional information.
+}
+
+Product sqlite-V3.bin.gz {
+  A command-line program for accessing and modifying
+  SQLite databases.
+  See <a href="sqlite.html">the documentation</a> for additional information.
+}
+
+Product tclsqlite-V3.so.gz {
+  Bindings for <a href="http://www.tcl.tk/">Tcl/Tk</a>.
+  You can import this shared library into either
+  tclsh or wish to get SQLite database access from Tcl/Tk.
+  See <a href="tclsqlite.html">the documentation</a> for details.
+}
+
+Product sqlite-V3.so.gz {
+  A precompiled shared-library for Linux without the TCL bindings.
+}
+
+Product fts1-V3.so.gz {
+  A precompiled 
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=FtsOne">FTS1 Module</a> 
+  for Linux.
+}
+
+Product fts2-V3.so.gz {
+  A precompiled 
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=FtsTwo">FTS2 Module</a> 
+  for Linux.
+}
+
+Product sqlite-devel-V3.i386.rpm {
+  RPM containing documentation, header files, and static library for
+  SQLite version VERSION.
+}
+Product sqlite-V3-1.i386.rpm {
+  RPM containing shared libraries and the <b>sqlite</b> command-line
+  program for SQLite version VERSION.
+}
+
+Product sqlite*_analyzer-V3.bin.gz {
+  An analysis program for database files compatible with SQLite 
+  version VERSION and later.
+}
+
+Heading {Precompiled Binaries For Windows}
+
+Product sqlite-V3.zip {
+  A command-line program for accessing and modifing SQLite databases.
+  See <a href="sqlite.html">the documentation</a> for additional information.
+}
+Product tclsqlite-V3.zip {
+  Bindings for <a href="http://www.tcl.tk/">Tcl/Tk</a>.
+  You can import this shared library into either
+  tclsh or wish to get SQLite database access from Tcl/Tk.
+  See <a href="tclsqlite.html">the documentation</a> for details.
+}
+Product sqlitedll-V3.zip {
+  This is a DLL of the SQLite library without the TCL bindings.
+  The only external dependency is MSVCRT.DLL.
+}
+
+Product fts1dll-V3.zip {
+  A precompiled 
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=FtsOne">FTS1 Module</a> 
+  for win32.
+}
+
+Product fts2dll-V3.zip {
+  A precompiled 
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=FtsTwo">FTS2 Module</a> 
+  for win32.
+}
+
+Product sqlite*_analyzer-V3.zip {
+  An analysis program for database files compatible with SQLite version
+  VERSION and later.
+}
+
+
+Heading {Source Code}
+
+Product {sqlite-V3.tar.gz} {
+  A tarball of the complete source tree for SQLite version VERSION
+  including all of the documentation.
+}
+
+Product {sqlite-source-V3.zip} {
+  This ZIP archive contains preprocessed C code for the SQLite library as
+  individual source files.
+  Unlike the tarballs below, all of the preprocessing and automatic
+  code generation has already been done on these C code files, so they
+  can be converted to object code directly with any ordinary C compiler.
+}
+
+Product {sqlite-amalgamation-V3.zip} {
+  This ZIP archive contains all preprocessed C code combined into a
+  single source file (the
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=TheAmalgamation">
+  amalgamation</a>).
+}
+
+Product {sqlite-V3-tea.tar.gz} {
+  A tarball of proprocessed source code together with a
+  <a href="http://www.tcl.tk/doc/tea/">Tcl Extension Architecture (TEA)</a>
+  compatible configure script and makefile.
+}
+
+Product {sqlite-V3.src.rpm} {
+  An RPM containing complete source code for SQLite version VERSION
+}
+
+Heading {Cross-Platform Binaries}
+
+Product {sqlite-V3.kit} {
+  A <a href="http://www.equi4.com/starkit.html">starkit</a> containing
+  precompiled SQLite binaries and Tcl bindings for Linux-x86, Windows,
+  and Mac OS-X ppc and x86.
+}
+
+Heading {Historical Binaries And Source Code}
+
+Product sqlite-V2.bin.gz {
+  A command-line program for accessing and modifying
+  SQLite version 2.* databases on Linux-x86.
+}
+Product sqlite-V2.zip {
+  A command-line program for accessing and modifying 
+  SQLite version 2.* databases on win32.
+}
+
+Product sqlite*_analyzer-V2.bin.gz {
+  An analysis program for version 2.* database files on Linux-x86
+}
+Product sqlite*_analyzer-V2.zip {
+  An analysis program for version 2.* database files on win32.
+}
+Product {sqlite-source-V2.zip} {
+  This ZIP archive contains C source code for the SQLite library
+  version VERSION.
+}
+
+
+
+
+puts {
+</table>
+
+<a name="cvs">
+<h3>Direct Access To The Sources Via Anonymous CVS</h3>
+
+<p>
+All SQLite source code is maintained in a 
+<a href="http://www.cvshome.org/">CVS</a> repository that is
+available for read-only access by anyone.  You can 
+interactively view the
+repository contents and download individual files
+by visiting
+<a href="http://www.sqlite.org/cvstrac/dir?d=sqlite">
+http://www.sqlite.org/cvstrac/dir?d=sqlite</a>.
+To access the repository directly, use the following
+commands:
+</p>
+
+<blockquote><pre>
+cvs -d :pserver:anonymous@www.sqlite.org:/sqlite login
+cvs -d :pserver:anonymous@www.sqlite.org:/sqlite checkout sqlite
+</pre></blockquote>
+
+<p>
+When the first command prompts you for a password, enter "anonymous".
+</p>
+
+<p>
+To access the SQLite version 2.8 sources, begin by getting the 3.0
+tree as described above.  Then update to the "version_2" branch
+as follows:
+</p>
+
+<blockquote><pre>
+cvs update -r version_2
+</pre></blockquote>
+
+}
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/dynload.tcl b/client/src/thirdparty/sqlite-3.4.2/www/dynload.tcl
new file mode 100644
index 0000000..3e12b7f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/dynload.tcl
@@ -0,0 +1,70 @@
+#
+# Run this Tcl script to generate the dynload.html file.
+#
+set rcsid {$Id: dynload.tcl,v 1.1 2001/02/11 16:58:22 drh Exp $}
+
+puts {<html>
+<head>
+  <title>How to build a dynamically loaded Tcl extension for SQLite</title>
+</head>
+<body bgcolor=white>
+<h1 align=center>
+How To Build A Dynamically Loaded Tcl Extension
+</h1>}
+puts {<p>
+<i>This note was contributed by 
+<a href="bsaunder@tampabay.rr.com.nospam">Bill Saunders</a>.  Thanks, Bill!</i>
+
+<p>
+To compile the SQLite Tcl extension into a dynamically loaded module 
+I did the following:
+</p>
+
+<ol>
+<li><p>Do a standard compile
+(I had a dir called bld at the same level as sqlite  ie
+        /root/bld
+        /root/sqlite
+I followed the directions and did a standard build in the bld
+directory)</p></li>
+
+<li><p>
+Now do the following in the bld directory
+<blockquote><pre>
+gcc -shared -I. -lgdbm ../sqlite/src/tclsqlite.c libsqlite.a -o sqlite.so
+</pre></blockquote></p></li>
+
+<li><p>
+This should produce the file sqlite.so in the bld directory</p></li>
+
+<li><p>
+Create a pkgIndex.tcl file that contains this line
+
+<blockquote><pre>
+package ifneeded sqlite 1.0 [list load [file join $dir sqlite.so]]
+</pre></blockquote></p></li>
+
+<li><p>
+To use this put sqlite.so and pkgIndex.tcl in the same directory</p></li>
+
+<li><p>
+From that directory start wish</p></li>
+
+<li><p>
+Execute the following tcl command (tells tcl where to fine loadable
+modules)
+<blockquote><pre>
+lappend auto_path [exec pwd]
+</pre></blockquote></p></li>
+
+<li><p>
+Load the package 
+<blockquote><pre>
+package require sqlite
+</pre></blockquote></p></li>
+
+<li><p>
+Have fun....</p></li>
+</ul>
+
+</body></html>}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/faq.tcl b/client/src/thirdparty/sqlite-3.4.2/www/faq.tcl
new file mode 100644
index 0000000..dd2c7cc
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/faq.tcl
@@ -0,0 +1,463 @@
+#
+# Run this script to generated a faq.html output file
+#
+set rcsid {$Id: faq.tcl,v 1.40 2007/09/04 01:58:27 drh Exp $}
+source common.tcl
+header {SQLite Frequently Asked Questions</title>}
+
+set cnt 1
+proc faq {question answer} {
+  set ::faq($::cnt) [list [string trim $question] [string trim $answer]]
+  incr ::cnt
+}
+
+#############
+# Enter questions and answers here.
+
+faq {
+  How do I create an AUTOINCREMENT field.
+} {
+  <p>Short answer: A column declared INTEGER PRIMARY KEY will
+  autoincrement.</p>
+
+  <p>Here is the long answer:
+  If you declare a column of a table to be INTEGER PRIMARY KEY, then
+  whenever you insert a NULL
+  into that column of the table, the NULL is automatically converted
+  into an integer which is one greater than the largest value of that
+  column over all other rows in the table, or 1 if the table is empty.
+  (If the largest possible integer key, 9223372036854775807, then an
+  unused key value is chosen at random.)
+  For example, suppose you have a table like this:
+<blockquote><pre>
+CREATE TABLE t1(
+  a INTEGER PRIMARY KEY,
+  b INTEGER
+);
+</pre></blockquote>
+  <p>With this table, the statement</p>
+<blockquote><pre>
+INSERT INTO t1 VALUES(NULL,123);
+</pre></blockquote>
+  <p>is logically equivalent to saying:</p>
+<blockquote><pre>
+INSERT INTO t1 VALUES((SELECT max(a) FROM t1)+1,123);
+</pre></blockquote>
+
+  <p>There is a new API function named
+  <a href="capi3ref.html#sqlite3_last_insert_rowid">
+  sqlite3_last_insert_rowid()</a> which will return the integer key
+  for the most recent insert operation.</p>
+
+  <p>Note that the integer key is one greater than the largest
+  key that was in the table just prior to the insert.  The new key
+  will be unique over all keys currently in the table, but it might
+  overlap with keys that have been previously deleted from the
+  table.  To create keys that are unique over the lifetime of the
+  table, add the AUTOINCREMENT keyword to the INTEGER PRIMARY KEY
+  declaration.  Then the key chosen will be one more than than the
+  largest key that has ever existed in that table.  If the largest
+  possible key has previously existed in that table, then the INSERT
+  will fail with an SQLITE_FULL error code.</p>
+}
+
+faq {
+  What datatypes does SQLite support?
+} {
+  <p>See <a href="datatype3.html">http://www.sqlite.org/datatype3.html</a>.</p>
+}
+
+faq {
+  SQLite lets me insert a string into a database column of type integer!
+} {
+  <p>This is a feature, not a bug.  SQLite does not enforce data type
+  constraints.  Any data can be
+  inserted into any column.  You can put arbitrary length strings into
+  integer columns, floating point numbers in boolean columns, or dates
+  in character columns.  The datatype you assign to a column in the
+  CREATE TABLE command does not restrict what data can be put into
+  that column.  Every column is able to hold
+  an arbitrary length string.  (There is one exception: Columns of
+  type INTEGER PRIMARY KEY may only hold a 64-bit signed integer.
+  An error will result
+  if you try to put anything other than an integer into an
+  INTEGER PRIMARY KEY column.)</p>
+
+  <p>But SQLite does use the declared type of a column as a hint
+  that you prefer values in that format.  So, for example, if a
+  column is of type INTEGER and you try to insert a string into
+  that column, SQLite will attempt to convert the string into an
+  integer.  If it can, it inserts the integer instead.  If not,
+  it inserts the string.  This feature is sometimes
+  call <a href="datatype3.html#affinity">type or column affinity</a>.
+  </p>
+}
+
+faq {
+  Why doesn't SQLite allow me to use '0' and '0.0' as the primary
+  key on two different rows of the same table?
+} {
+  <p>Your primary key must have a numeric type.  Change the datatype of
+  your primary key to TEXT and it should work.</p>
+
+  <p>Every row must have a unique primary key.  For a column with a
+  numeric type, SQLite thinks that <b>'0'</b> and <b>'0.0'</b> are the
+  same value because they compare equal to one another numerically.
+  (See the previous question.)  Hence the values are not unique.</p>
+}
+        
+
+faq {
+  Can multiple applications or multiple instances of the same
+  application access a single database file at the same time?
+} {
+  <p>Multiple processes can have the same database open at the same
+  time.  Multiple processes can be doing a SELECT
+  at the same time.  But only one process can be making changes to
+  the database at any moment in time, however.</p>
+
+  <p>SQLite uses reader/writer locks to control access to the database.
+  (Under Win95/98/ME which lacks support for reader/writer locks, a
+  probabilistic simulation is used instead.)
+  But use caution: this locking mechanism might
+  not work correctly if the database file is kept on an NFS filesystem.
+  This is because fcntl() file locking is broken on many NFS implementations.
+  You should avoid putting SQLite database files on NFS if multiple
+  processes might try to access the file at the same time.  On Windows,
+  Microsoft's documentation says that locking may not work under FAT
+  filesystems if you are not running the Share.exe daemon.  People who
+  have a lot of experience with Windows tell me that file locking of
+  network files is very buggy and is not dependable.  If what they
+  say is true, sharing an SQLite database between two or more Windows
+  machines might cause unexpected problems.</p>
+
+  <p>We are aware of no other <i>embedded</i> SQL database engine that
+  supports as much concurrancy as SQLite.  SQLite allows multiple processes
+  to have the database file open at once, and for multiple processes to
+  read the database at once.  When any process wants to write, it must
+  lock the entire database file for the duration of its update.  But that
+  normally only takes a few milliseconds.  Other processes just wait on
+  the writer to finish then continue about their business.  Other embedded
+  SQL database engines typically only allow a single process to connect to
+  the database at once.</p>
+
+  <p>However, client/server database engines (such as PostgreSQL, MySQL,
+  or Oracle) usually support a higher level of concurrency and allow
+  multiple processes to be writing to the same database at the same time.
+  This is possible in a client/server database because there is always a
+  single well-controlled server process available to coordinate access.
+  If your application has a need for a lot of concurrency, then you should
+  consider using a client/server database.  But experience suggests that
+  most applications need much less concurrency than their designers imagine.
+  </p>
+
+  <p>When SQLite tries to access a file that is locked by another
+  process, the default behavior is to return SQLITE_BUSY.  You can
+  adjust this behavior from C code using the 
+  <a href="capi3ref.html#sqlite3_busy_handler">sqlite3_busy_handler()</a> or
+  <a href="capi3ref.html#sqlite3_busy_timeout">sqlite3_busy_timeout()</a>
+  API functions.</p>
+}
+
+faq {
+  Is SQLite threadsafe?
+} {
+  <p>Yes.  Sometimes.  In order to be thread-safe, SQLite must be compiled
+  with the SQLITE_THREADSAFE preprocessor macro set to 1.  Both the windows
+  and linux precompiled binaries in the distribution are compiled this way.
+  If you are unsure if the SQLite library you are linking against is compiled
+  to be threadsafe you can call the
+  <a href="capi3ref.html#sqlite3_threadsafe">sqlite3_threadsafe()</a>
+  interface to find out.
+  </p>
+
+  <p>Prior to version 3.3.1,
+  an <b>sqlite3</b> structure could only be used in the same thread
+  that called <a href="capi3ref.html#sqlite3_open">sqlite3_open</a>
+  to create it.
+  You could not open a
+  database in one thread then pass the handle off to another thread for
+  it to use.  This was due to limitations (bugs?) in many common threading
+  implementations such as on RedHat9.  Specifically, an fcntl() lock
+  created by one thread cannot be removed or modified by a different
+  thread on the troublesome systems.  And since SQLite uses fcntl()
+  locks heavily for concurrency control, serious problems arose if you 
+  start moving database connections across threads.</p>
+
+  <p>The restriction on moving database connections across threads
+  was relaxed somewhat in version 3.3.1.  With that and subsequent
+  versions, it is safe to move a connection handle across threads
+  as long as the connection is not holding any fcntl() locks.  You
+  can safely assume that no locks are being held if no
+  transaction is pending and all statements have been finalized.</p>
+
+  <p>Under UNIX, you should not carry an open SQLite database across
+  a fork() system call into the child process.  Problems will result
+  if you do.</p>
+}
+
+faq {
+  How do I list all tables/indices contained in an SQLite database
+} {
+  <p>If you are running the <b>sqlite3</b> command-line access program
+  you can type "<b>.tables</b>" to get a list of all tables.  Or you
+  can type "<b>.schema</b>" to see the complete database schema including
+  all tables and indices.  Either of these commands can be followed by
+  a LIKE pattern that will restrict the tables that are displayed.</p>
+
+  <p>From within a C/C++ program (or a script using Tcl/Ruby/Perl/Python
+  bindings) you can get access to table and index names by doing a SELECT
+  on a special table named "<b>SQLITE_MASTER</b>".  Every SQLite database
+  has an SQLITE_MASTER table that defines the schema for the database.
+  The SQLITE_MASTER table looks like this:</p>
+<blockquote><pre>
+CREATE TABLE sqlite_master (
+  type TEXT,
+  name TEXT,
+  tbl_name TEXT,
+  rootpage INTEGER,
+  sql TEXT
+);
+</pre></blockquote>
+  <p>For tables, the <b>type</b> field will always be <b>'table'</b> and the
+  <b>name</b> field will be the name of the table.  So to get a list of
+  all tables in the database, use the following SELECT command:</p>
+<blockquote><pre>
+SELECT name FROM sqlite_master
+WHERE type='table'
+ORDER BY name;
+</pre></blockquote>
+  <p>For indices, <b>type</b> is equal to <b>'index'</b>, <b>name</b> is the
+  name of the index and <b>tbl_name</b> is the name of the table to which
+  the index belongs.  For both tables and indices, the <b>sql</b> field is
+  the text of the original CREATE TABLE or CREATE INDEX statement that
+  created the table or index.  For automatically created indices (used
+  to implement the PRIMARY KEY or UNIQUE constraints) the <b>sql</b> field
+  is NULL.</p>
+
+  <p>The SQLITE_MASTER table is read-only.  You cannot change this table
+  using UPDATE, INSERT, or DELETE.  The table is automatically updated by
+  CREATE TABLE, CREATE INDEX, DROP TABLE, and DROP INDEX commands.</p>
+
+  <p>Temporary tables do not appear in the SQLITE_MASTER table.  Temporary
+  tables and their indices and triggers occur in another special table
+  named SQLITE_TEMP_MASTER.  SQLITE_TEMP_MASTER works just like SQLITE_MASTER
+  except that it is only visible to the application that created the 
+  temporary tables.  To get a list of all tables, both permanent and
+  temporary, one can use a command similar to the following:
+<blockquote><pre>
+SELECT name FROM 
+   (SELECT * FROM sqlite_master UNION ALL
+    SELECT * FROM sqlite_temp_master)
+WHERE type='table'
+ORDER BY name
+</pre></blockquote>
+}
+
+faq {
+  Are there any known size limits to SQLite databases?
+} {
+  <p>See <a href="limits.html">limits.html</a> for a full discussion of
+  the limits of SQLite.</p>
+}
+
+faq {
+  What is the maximum size of a VARCHAR in SQLite?
+} {
+  <p>SQLite does not enforce the length of a VARCHAR.  You can declare
+  a VARCHAR(10) and SQLite will be happy to let you put 500 characters
+  in it.  And it will keep all 500 characters intact - it never truncates.
+  </p>
+}
+
+faq {
+  Does SQLite support a BLOB type?
+} {
+  <p>SQLite versions 3.0 and later allow you to store BLOB data in any 
+  column, even columns that are declared to hold some other type.</p>
+}
+
+faq {
+  How do I add or delete columns from an existing table in SQLite.
+} {
+  <p>SQLite has limited 
+  <a href="lang_altertable.html">ALTER TABLE</a> support that you can
+  use to add a column to the end of a table or to change the name of
+  a table.  
+  If you what make more complex changes the structure of a table,
+  you will have to recreate the
+  table.  You can save existing data to a temporary table, drop the
+  old table, create the new table, then copy the data back in from
+  the temporary table.</p>
+
+  <p>For example, suppose you have a table named "t1" with columns
+  names "a", "b", and "c" and that you want to delete column "c" from
+  this table.  The following steps illustrate how this could be done:
+  </p>
+
+  <blockquote><pre>
+BEGIN TRANSACTION;
+CREATE TEMPORARY TABLE t1_backup(a,b);
+INSERT INTO t1_backup SELECT a,b FROM t1;
+DROP TABLE t1;
+CREATE TABLE t1(a,b);
+INSERT INTO t1 SELECT a,b FROM t1_backup;
+DROP TABLE t1_backup;
+COMMIT;
+</pre></blockquote>
+}
+
+faq {
+  I deleted a lot of data but the database file did not get any
+  smaller.  Is this a bug?
+} {
+  <p>No.  When you delete information from an SQLite database, the
+  unused disk space is added to an internal "free-list" and is reused
+  the next time you insert data.  The disk space is not lost.  But
+  neither is it returned to the operating system.</p>
+
+  <p>If you delete a lot of data and want to shrink the database file,
+  run the <a href="lang_vacuum.html">VACUUM</a> command.
+  VACUUM will reconstruct
+  the database from scratch.  This will leave the database with an empty
+  free-list and a file that is minimal in size.  Note, however, that the
+  VACUUM can take some time to run (around a half second per megabyte
+  on the Linux box where SQLite is developed) and it can use up to twice
+  as much temporary disk space as the original file while it is running.
+  </p>
+
+  <p>As of SQLite version 3.1, an alternative to using the VACUUM command
+  is auto-vacuum mode, enabled using the 
+  <a href="pragma.html#pragma_auto_vacuum">auto_vacuum pragma</a>.</p>
+}
+
+faq {
+  Can I use SQLite in my commercial product without paying royalties?
+} {
+  <p>Yes.  SQLite is in the 
+  <a href="copyright.html">public domain</a>.  No claim of ownership is made
+  to any part of the code.  You can do anything you want with it.</p>
+}
+
+faq {
+  How do I use a string literal that contains an embedded single-quote (')
+  character?
+} {
+  <p>The SQL standard specifies that single-quotes in strings are escaped
+  by putting two single quotes in a row.  SQL works like the Pascal programming
+  language in the regard.  SQLite follows this standard.  Example:
+  </p>
+
+  <blockquote><pre>
+    INSERT INTO xyz VALUES('5 O''clock');
+  </pre></blockquote>
+}
+
+faq {What is an SQLITE_SCHEMA error, and why am I getting one?} {
+  <p>An SQLITE_SCHEMA error is returned when a 
+  prepared SQL statement is no longer valid and cannot be executed.
+  When this occurs, the statement must be recompiled from SQL using 
+  the 
+  <a href="capi3ref.html#sqlite3_prepare">sqlite3_prepare()</a> API.
+  In SQLite version 3, an SQLITE_SCHEMA error can
+  only occur when using the 
+  <a href="capi3ref.html#sqlite3_prepare">sqlite3_prepare()</a>/<a
+  href="capi3ref.html#sqlite3_step">sqlite3_step()</a>/<a
+  href="capi3ref.html#sqlite3_finalize">sqlite3_finalize()</a>
+  API to execute SQL, not when using the
+  <a href="capi3ref.html#sqlite3_exec">sqlite3_exec()</a>. This was not
+  the case in version 2.</p>
+
+  <p>The most common reason for a prepared statement to become invalid
+  is that the schema of the database was modified after the SQL was 
+  prepared (possibly by another process).  The other reasons this can 
+  happen are:</p> 
+  <ul>
+  <li>A database was <a href="lang_detach.html">DETACH</a>ed.
+  <li>The database was <a href="lang_vacuum.html">VACUUM</a>ed
+  <li>A user-function definition was deleted or changed.
+  <li>A collation sequence definition was deleted or changed.
+  <li>The authorization function was changed.
+  </ul>
+
+  <p>In all cases, the solution is to recompile the statement from SQL
+  and attempt to execute it again. Because a prepared statement can be
+  invalidated by another process changing the database schema, all code
+  that uses the
+  <a href="capi3ref.html#sqlite3_prepare">sqlite3_prepare()</a>/<a
+  href="capi3ref.html#sqlite3_step">sqlite3_step()</a>/<a
+  href="capi3ref.html#sqlite3_finalize">sqlite3_finalize()</a>
+  API should be prepared to handle SQLITE_SCHEMA errors. An example
+  of one approach to this follows:</p>
+
+  <blockquote><pre>
+
+    int rc;
+    sqlite3_stmt *pStmt;
+    char zSql[] = "SELECT .....";
+
+    do {
+      /* Compile the statement from SQL. Assume success. */
+      sqlite3_prepare(pDb, zSql, -1, &pStmt, 0);
+
+      while( SQLITE_ROW==sqlite3_step(pStmt) ){
+        /* Do something with the row of available data */
+      }
+
+      /* Finalize the statement. If an SQLITE_SCHEMA error has
+      ** occured, then the above call to sqlite3_step() will have
+      ** returned SQLITE_ERROR. sqlite3_finalize() will return
+      ** SQLITE_SCHEMA. In this case the loop will execute again.
+      */
+      rc = sqlite3_finalize(pStmt);
+    } while( rc==SQLITE_SCHEMA );
+    
+  </pre></blockquote>
+}
+
+faq {Why does ROUND(9.95,1)  return 9.9 instead of 10.0?
+     Shouldn't 9.95 round up?} {
+  <p>SQLite uses binary arithmetic and in binary, there is no
+  way to write 9.95 in a finite number of bits.  The closest to
+  you can get to 9.95 in a 64-bit IEEE float (which is what
+  SQLite uses) is 9.949999999999999289457264239899814128875732421875.
+  So when you type "9.95", SQLite really understands the number to be
+  the much longer value shown above.  And that value rounds down.</p>
+
+  <p>This kind of problem comes up all the time when dealing with
+  floating point binary numbers.  The general rule to remember is
+  that most fractional numbers that have a finite representation in decimal
+  (a.k.a "base-10")
+  do not have a finite representation in binary (a.k.a "base-2").
+  And so they are
+  approximated using the closest binary number available.  That
+  approximation is usually very close, but it will be slightly off
+  and in some cases can cause your results to be a little different
+  from what you might expect.</p>
+}
+
+# End of questions and answers.
+#############
+
+puts {<h2>Frequently Asked Questions</h2>}
+
+# puts {<DL COMPACT>}
+# for {set i 1} {$i<$cnt} {incr i} {
+#   puts "  <DT><A HREF=\"#q$i\">($i)</A></DT>"
+#   puts "  <DD>[lindex $faq($i) 0]</DD>"
+# }
+# puts {</DL>}
+puts {<OL>}
+for {set i 1} {$i<$cnt} {incr i} {
+  puts "<li><a href=\"#q$i\">[lindex $faq($i) 0]</a></li>"
+}
+puts {</OL>}
+
+for {set i 1} {$i<$cnt} {incr i} {
+  puts "<A NAME=\"q$i\"><HR />"
+  puts "<P><B>($i) [lindex $faq($i) 0]</B></P>\n"
+  puts "<BLOCKQUOTE>[lindex $faq($i) 1]</BLOCKQUOTE></LI>\n"
+}
+
+puts {</OL>}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/fileformat.tcl b/client/src/thirdparty/sqlite-3.4.2/www/fileformat.tcl
new file mode 100644
index 0000000..d143f08
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/fileformat.tcl
@@ -0,0 +1,785 @@
+#
+# Run this script to generated a fileformat.html output file
+#
+set rcsid {$Id: fileformat.tcl,v 1.13 2004/10/10 17:24:55 drh Exp $}
+source common.tcl
+header {SQLite Database File Format (Version 2)}
+puts {
+<h2>SQLite 2.X Database File Format</h2>
+
+<p>
+This document describes the disk file format for SQLite versions 2.1
+through 2.8.  SQLite version 3.0 and following uses a very different
+format which is described separately.
+</p>
+
+<h3>1.0 &nbsp; Layers</h3>
+
+<p>
+SQLite is implemented in layers.
+(See the <a href="arch.html">architecture description</a>.)
+The format of database files is determined by three different
+layers in the architecture.
+</p>
+
+<ul>
+<li>The <b>schema</b> layer implemented by the VDBE.</li>
+<li>The <b>b-tree</b> layer implemented by btree.c</li>
+<li>The <b>pager</b> layer implemented by pager.c</li>
+</ul>
+
+<p>
+We will describe each layer beginning with the bottom (pager)
+layer and working upwards.
+</p>
+
+<h3>2.0 &nbsp; The Pager Layer</h3>
+
+<p>
+An SQLite database consists of
+"pages" of data.  Each page is 1024 bytes in size.
+Pages are numbered beginning with 1.
+A page number of 0 is used to indicate "no such page" in the
+B-Tree and Schema layers.
+</p>
+
+<p>
+The pager layer is responsible for implementing transactions
+with atomic commit and rollback.  It does this using a separate
+journal file.  Whenever a new transaction is started, a journal
+file is created that records the original state of the database.
+If the program terminates before completing the transaction, the next
+process to open the database can use the journal file to restore
+the database to its original state.
+</p>
+
+<p>
+The journal file is located in the same directory as the database
+file and has the same name as the database file but with the
+characters "<tt>-journal</tt>" appended.
+</p>
+
+<p>
+The pager layer does not impose any content restrictions on the
+main database file.  As far as the pager is concerned, each page
+contains 1024 bytes of arbitrary data.  But there is structure to
+the journal file.
+</p>
+
+<p>
+A journal file begins with 8 bytes as follows:
+0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, and 0xd6.
+Processes that are attempting to rollback a journal use these 8 bytes
+as a sanity check to make sure the file they think is a journal really
+is a valid journal.  Prior version of SQLite used different journal
+file formats.  The magic numbers for these prior formats are different
+so that if a new version of the library attempts to rollback a journal
+created by an earlier version, it can detect that the journal uses
+an obsolete format and make the necessary adjustments.  This article
+describes only the newest journal format - supported as of version
+2.8.0.
+</p>
+
+<p>
+Following the 8 byte prefix is a three 4-byte integers that tell us
+the number of pages that have been committed to the journal,
+a magic number used for
+sanity checking each page, and the
+original size of the main database file before the transaction was
+started.  The number of committed pages is used to limit how far
+into the journal to read.  The use of the checksum magic number is
+described below.
+The original size of the database is used to restore the database
+file back to its original size.
+The size is expressed in pages (1024 bytes per page).
+</p>
+
+<p>
+All three integers in the journal header and all other multi-byte
+numbers used in the journal file are big-endian.
+That means that the most significant byte
+occurs first.  That way, a journal file that is
+originally created on one machine can be rolled back by another
+machine that uses a different byte order.  So, for example, a
+transaction that failed to complete on your big-endian SparcStation
+can still be rolled back on your little-endian Linux box.
+</p>
+
+<p>
+After the 8-byte prefix and the three 4-byte integers, the
+journal file consists of zero or more page records.  Each page
+record is a 4-byte (big-endian) page number followed by 1024 bytes
+of data and a 4-byte checksum.  
+The data is the original content of the database page
+before the transaction was started.  So to roll back the transaction,
+the data is simply written into the corresponding page of the
+main database file.  Pages can appear in the journal in any order,
+but they are guaranteed to appear only once. All page numbers will be
+between 1 and the maximum specified by the page size integer that
+appeared at the beginning of the journal.
+</p>
+
+<p>
+The so-called checksum at the end of each record is not really a
+checksum - it is the sum of the page number and the magic number which
+was the second integer in the journal header.  The purpose of this
+value is to try to detect journal corruption that might have occurred
+because of a power loss or OS crash that occurred which the journal
+file was being written to disk.  It could have been the case that the
+meta-data for the journal file, specifically the size of the file, had
+been written to the disk so that when the machine reboots it appears that
+file is large enough to hold the current record.  But even though the
+file size has changed, the data for the file might not have made it to
+the disk surface at the time of the OS crash or power loss.  This means
+that after reboot, the end of the journal file will contain quasi-random
+garbage data.  The checksum is an attempt to detect such corruption.  If
+the checksum does not match, that page of the journal is not rolled back.
+</p>
+
+<p>
+Here is a summary of the journal file format:
+</p>
+
+<ul>
+<li>8 byte prefix: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd6</li>
+<li>4 byte number of records in journal</li>
+<li>4 byte magic number used for page checksums</li>
+<li>4 byte initial database page count</li>
+<li>Zero or more instances of the following:
+   <ul>
+   <li>4 byte page number</li>
+   <li>1024 bytes of original data for the page</li>
+   <li>4 byte checksum</li>
+   </ul>
+</li>
+</ul>
+
+<h3>3.0 &nbsp; The B-Tree Layer</h3>
+
+<p>
+The B-Tree layer builds on top of the pager layer to implement
+one or more separate b-trees all in the same disk file.  The
+algorithms used are taken from Knuth's <i>The Art Of Computer
+Programming.</i></p>
+
+<p>
+Page 1 of a database contains a header string used for sanity
+checking, a few 32-bit words of configuration data, and a pointer
+to the beginning of a list of unused pages in the database.
+All other pages in the
+database are either pages of a b-tree, overflow pages, or unused
+pages on the freelist.
+</p>
+
+<p>
+Each b-tree page contains zero or more database entries.
+Each entry has an unique key of one or more bytes and data of
+zero or more bytes.
+Both the key and data are arbitrary byte sequences.  The combination
+of key and data are collectively known as "payload".  The current
+implementation limits the amount of payload in a single entry to
+1048576 bytes.  This limit can be raised to 16777216 by adjusting
+a single #define in the source code and recompiling.  But most entries
+contain less than a hundred bytes of payload so a megabyte limit seems
+more than enough.
+</p>
+
+<p>
+Up to 238 bytes of payload for an entry can be held directly on
+a b-tree page.  Any additional payload is contained on a linked list
+of overflow pages.  This limit on the amount of payload held directly
+on b-tree pages guarantees that each b-tree page can hold at least
+4 entries.  In practice, most entries are smaller than 238 bytes and
+thus most pages can hold more than 4 entries.
+</p>
+
+<p>
+A single database file can hold any number of separate, independent b-trees.
+Each b-tree is identified by its root page, which never changes.
+Child pages of the b-tree may change as entries are added and removed
+and pages split and combine.  But the root page always stays the same.
+The b-tree itself does not record which pages are root pages and which
+are not.  That information is handled entirely at the schema layer.
+</p>
+
+<h4>3.1 &nbsp; B-Tree Page 1 Details</h4>
+
+<p>
+Page 1 begins with the following 48-byte string:
+</p>
+
+<blockquote><pre>
+** This file contains an SQLite 2.1 database **
+</pre></blockquote>
+
+<p>
+If you count the number of characters in the string above, you will
+see that there are only 47.  A '\000' terminator byte is added to
+bring the total to 48.
+</p>
+
+<p>
+A frequent question is why the string says version 2.1 when (as
+of this writing) we are up to version 2.7.0 of SQLite and any
+change to the second digit of the version is suppose to represent
+a database format change.  The answer to this is that the B-tree
+layer has not changed any since version 2.1.  There have been
+database format changes since version 2.1 but those changes have
+all been in the schema layer.  Because the format of the b-tree
+layer is unchanged since version 2.1.0, the header string still
+says version 2.1.
+</p>
+
+<p>
+After the format string is a 4-byte integer used to determine the
+byte-order of the database.  The integer has a value of
+0xdae37528.  If this number is expressed as 0xda, 0xe3, 0x75, 0x28, then
+the database is in a big-endian format and all 16 and 32-bit integers
+elsewhere in the b-tree layer are also big-endian.  If the number is
+expressed as 0x28, 0x75, 0xe3, and 0xda, then the database is in a
+little-endian format and all other multi-byte numbers in the b-tree 
+layer are also little-endian.  
+Prior to version 2.6.3, the SQLite engine was only able to read databases
+that used the same byte order as the processor they were running on.
+But beginning with 2.6.3, SQLite can read or write databases in any
+byte order.
+</p>
+
+<p>
+After the byte-order code are six 4-byte integers.  Each integer is in the
+byte order determined by the byte-order code.  The first integer is the
+page number for the first page of the freelist.  If there are no unused
+pages in the database, then this integer is 0.  The second integer is
+the number of unused pages in the database.  The last 4 integers are
+not used by the b-tree layer.  These are the so-called "meta" values that
+are passed up to the schema layer
+and used there for configuration and format version information.
+All bytes of page 1 past beyond the meta-value integers are unused 
+and are initialized to zero.
+</p>
+
+<p>
+Here is a summary of the information contained on page 1 in the b-tree layer:
+</p>
+
+<ul>
+<li>48 byte header string</li>
+<li>4 byte integer used to determine the byte-order</li>
+<li>4 byte integer which is the first page of the freelist</li>
+<li>4 byte integer which is the number of pages on the freelist</li>
+<li>36 bytes of meta-data arranged as nine 4-byte integers</li>
+<li>928 bytes of unused space</li>
+</ul>
+
+<h4>3.2 &nbsp; Structure Of A Single B-Tree Page</h4>
+
+<p>
+Conceptually, a b-tree page contains N database entries and N+1 pointers
+to other b-tree pages.
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center">Ptr<br>0</td>
+<td align="center">Entry<br>0</td>
+<td align="center">Ptr<br>1</td>
+<td align="center">Entry<br>1</td>
+<td align="center"><b>...</b></td>
+<td align="center">Ptr<br>N-1</td>
+<td align="center">Entry<br>N-1</td>
+<td align="center">Ptr<br>N</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+The entries are arranged in increasing order.  That is, the key to
+Entry 0 is less than the key to Entry 1, and the key to Entry 1 is
+less than the key of Entry 2, and so forth.  The pointers point to
+pages containing additional entries that have keys in between the
+entries on either side.  So Ptr 0 points to another b-tree page that
+contains entries that all have keys less than Key 0, and Ptr 1
+points to a b-tree pages where all entries have keys greater than Key 0
+but less than Key 1, and so forth.
+</p>
+
+<p>
+Each b-tree page in SQLite consists of a header, zero or more "cells"
+each holding a single entry and pointer, and zero or more "free blocks"
+that represent unused space on the page.
+</p>
+
+<p>
+The header on a b-tree page is the first 8 bytes of the page.
+The header contains the value
+of the right-most pointer (Ptr N) and the byte offset into the page
+of the first cell and the first free block.  The pointer is a 32-bit
+value and the offsets are each 16-bit values.  We have:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center" width=30>0</td>
+<td align="center" width=30>1</td>
+<td align="center" width=30>2</td>
+<td align="center" width=30>3</td>
+<td align="center" width=30>4</td>
+<td align="center" width=30>5</td>
+<td align="center" width=30>6</td>
+<td align="center" width=30>7</td>
+</tr>
+<tr>
+<td align="center" colspan=4>Ptr N</td>
+<td align="center" colspan=2>Cell 0</td>
+<td align="center" colspan=2>Freeblock 0</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+The 1016 bytes of a b-tree page that come after the header contain
+cells and freeblocks.  All 1016 bytes are covered by either a cell
+or a freeblock.
+</p>
+
+<p>
+The cells are connected in a linked list.  Cell 0 contains Ptr 0 and
+Entry 0.  Bytes 4 and 5 of the header point to Cell 0.  Cell 0 then
+points to Cell 1 which contains Ptr 1 and Entry 1.  And so forth.
+Cells vary in size.  Every cell has a 12-byte header and at least 4
+bytes of payload space.  Space is allocated to payload in increments
+of 4 bytes.  Thus the minimum size of a cell is 16 bytes and up to
+63 cells can fit on a single page.  The size of a cell is always a multiple
+of 4 bytes.
+A cell can have up to 238 bytes of payload space.  If
+the payload is more than 238 bytes, then an additional 4 byte page
+number is appended to the cell which is the page number of the first
+overflow page containing the additional payload.  The maximum size
+of a cell is thus 254 bytes, meaning that a least 4 cells can fit into
+the 1016 bytes of space available on a b-tree page.
+An average cell is usually around 52 to 100 bytes in size with about
+10 or 20 cells to a page.
+</p>
+
+<p>
+The data layout of a cell looks like this:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center" width=20>0</td>
+<td align="center" width=20>1</td>
+<td align="center" width=20>2</td>
+<td align="center" width=20>3</td>
+<td align="center" width=20>4</td>
+<td align="center" width=20>5</td>
+<td align="center" width=20>6</td>
+<td align="center" width=20>7</td>
+<td align="center" width=20>8</td>
+<td align="center" width=20>9</td>
+<td align="center" width=20>10</td>
+<td align="center" width=20>11</td>
+<td align="center" width=100>12 ... 249</td>
+<td align="center" width=20>250</td>
+<td align="center" width=20>251</td>
+<td align="center" width=20>252</td>
+<td align="center" width=20>253</td>
+</tr>
+<tr>
+<td align="center" colspan=4>Ptr</td>
+<td align="center" colspan=2>Keysize<br>(low)</td>
+<td align="center" colspan=2>Next</td>
+<td align="center" colspan=1>Ksz<br>(hi)</td>
+<td align="center" colspan=1>Dsz<br>(hi)</td>
+<td align="center" colspan=2>Datasize<br>(low)</td>
+<td align="center" colspan=1>Payload</td>
+<td align="center" colspan=4>Overflow<br>Pointer</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+The first four bytes are the pointer.  The size of the key is a 24-bit
+where the upper 8 bits are taken from byte 8 and the lower 16 bits are
+taken from bytes 4 and 5 (or bytes 5 and 4 on little-endian machines.)
+The size of the data is another 24-bit value where the upper 8 bits
+are taken from byte 9 and the lower 16 bits are taken from bytes 10 and
+11 or 11 and 10, depending on the byte order.  Bytes 6 and 7 are the
+offset to the next cell in the linked list of all cells on the current
+page.  This offset is 0 for the last cell on the page.
+</p>
+
+<p>
+The payload itself can be any number of bytes between 1 and 1048576.
+But space to hold the payload is allocated in 4-byte chunks up to
+238 bytes.  If the entry contains more than 238 bytes of payload, then
+additional payload data is stored on a linked list of overflow pages.
+A 4 byte page number is appended to the cell that contains the first
+page of this linked list.
+</p>
+
+<p>
+Each overflow page begins with a 4-byte value which is the
+page number of the next overflow page in the list.   This value is
+0 for the last page in the list.  The remaining
+1020 bytes of the overflow page are available for storing payload.
+Note that a full page is allocated regardless of the number of overflow
+bytes stored.  Thus, if the total payload for an entry is 239 bytes,
+the first 238 are stored in the cell and the overflow page stores just
+one byte.
+</p>
+
+<p>
+The structure of an overflow page looks like this:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center" width=20>0</td>
+<td align="center" width=20>1</td>
+<td align="center" width=20>2</td>
+<td align="center" width=20>3</td>
+<td align="center" width=200>4 ... 1023</td>
+</tr>
+<tr>
+<td align="center" colspan=4>Next Page</td>
+<td align="center" colspan=1>Overflow Data</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+All space on a b-tree page which is not used by the header or by cells
+is filled by freeblocks.  Freeblocks, like cells, are variable in size.
+The size of a freeblock is at least 4 bytes and is always a multiple of
+4 bytes.
+The first 4 bytes contain a header and the remaining bytes
+are unused.  The structure of the freeblock is as follows:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center" width=20>0</td>
+<td align="center" width=20>1</td>
+<td align="center" width=20>2</td>
+<td align="center" width=20>3</td>
+<td align="center" width=200>4 ... 1015</td>
+</tr>
+<tr>
+<td align="center" colspan=2>Size</td>
+<td align="center" colspan=2>Next</td>
+<td align="center" colspan=1>Unused</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+Freeblocks are stored in a linked list in increasing order.  That is
+to say, the first freeblock occurs at a lower index into the page than
+the second free block, and so forth.  The first 2 bytes of the header
+are an integer which is the total number of bytes in the freeblock.
+The second 2 bytes are the index into the page of the next freeblock
+in the list.  The last freeblock has a Next value of 0.
+</p>
+
+<p>
+When a new b-tree is created in a database, the root page of the b-tree
+consist of a header and a single 1016 byte freeblock.  As entries are
+added, space is carved off of that freeblock and used to make cells.
+When b-tree entries are deleted, the space used by their cells is converted
+into freeblocks.  Adjacent freeblocks are merged, but the page can still
+become fragmented.  The b-tree code will occasionally try to defragment
+the page by moving all cells to the beginning and constructing a single
+freeblock at the end to take up all remaining space.
+</p>
+
+<h4>3.3 &nbsp; The B-Tree Free Page List</h4>
+
+<p>
+When information is removed from an SQLite database such that one or
+more pages are no longer needed, those pages are added to a list of
+free pages so that they can be reused later when new information is
+added.  This subsection describes the structure of this freelist.
+</p>
+
+<p>
+The 32-bit integer beginning at byte-offset 52 in page 1 of the database
+contains the address of the first page in a linked list of free pages.
+If there are no free pages available, this integer has a value of 0.
+The 32-bit integer at byte-offset 56 in page 1 contains the number of
+free pages on the freelist.
+</p>
+
+<p>
+The freelist contains a trunk and many branches.  The trunk of
+the freelist is composed of overflow pages.  That is to say, each page
+contains a single 32-bit integer at byte offset 0 which
+is the page number of the next page on the freelist trunk.
+The payload area
+of each trunk page is used to record pointers to branch pages. 
+The first 32-bit integer in the payload area of a trunk page
+is the number of branch pages to follow (between 0 and 254)
+and each subsequent 32-bit integer is a page number for a branch page.
+The following diagram shows the structure of a trunk freelist page:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td align="center" width=20>0</td>
+<td align="center" width=20>1</td>
+<td align="center" width=20>2</td>
+<td align="center" width=20>3</td>
+<td align="center" width=20>4</td>
+<td align="center" width=20>5</td>
+<td align="center" width=20>6</td>
+<td align="center" width=20>7</td>
+<td align="center" width=200>8 ... 1023</td>
+</tr>
+<tr>
+<td align="center" colspan=4>Next trunk page</td>
+<td align="center" colspan=4># of branch pages</td>
+<td align="center" colspan=1>Page numbers for branch pages</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+It is important to note that only the pages on the trunk of the freelist
+contain pointers to other pages.  The branch pages contain no
+data whatsoever.  The fact that the branch pages are completely
+blank allows for an important optimization in the paging layer.  When
+a branch page is removed from the freelist to be reused, it is not
+necessary to write the original content of that page into the rollback
+journal.  The branch page contained no data to begin with, so there is
+no need to restore the page in the event of a rollback.  Similarly,
+when a page is not longer needed and is added to the freelist as a branch
+page, it is not necessary to write the content of that page
+into the database file.
+Again, the page contains no real data so it is not necessary to record the
+content of that page.  By reducing the amount of disk I/O required,
+these two optimizations allow some database operations
+to go four to six times faster than they would otherwise.
+</p>
+
+<h3>4.0 &nbsp; The Schema Layer</h3>
+
+<p>
+The schema layer implements an SQL database on top of one or more
+b-trees and keeps track of the root page numbers for all b-trees.
+Where the b-tree layer provides only unformatted data storage with
+a unique key, the schema layer allows each entry to contain multiple
+columns.  The schema layer also allows indices and non-unique key values.
+</p>
+
+<p>
+The schema layer implements two separate data storage abstractions:
+tables and indices.  Each table and each index uses its own b-tree
+but they use the b-tree capabilities in different ways.  For a table,
+the b-tree key is a unique 4-byte integer and the b-tree data is the
+content of the table row, encoded so that columns can be separately
+extracted.  For indices, the b-tree key varies in size depending on the
+size of the fields being indexed and the b-tree data is empty.
+</p>
+
+<h4>4.1 &nbsp; SQL Table Implementation Details</h4>
+
+<p>Each row of an SQL table is stored in a single b-tree entry.
+The b-tree key is a 4-byte big-endian integer that is the ROWID
+or INTEGER PRIMARY KEY for that table row.
+The key is stored in a big-endian format so
+that keys will sort in numerical order using memcmp() function.</p>
+
+<p>The content of a table row is stored in the data portion of
+the corresponding b-tree table.  The content is encoded to allow
+individual columns of the row to be extracted as necessary.  Assuming
+that the table has N columns, the content is encoded as N+1 offsets
+followed by N column values, as follows:
+</p>
+
+<blockquote>
+<table border=1 cellspacing=0 cellpadding=5>
+<tr>
+<td>offset 0</td>
+<td>offset 1</td>
+<td><b>...</b></td>
+<td>offset N-1</td>
+<td>offset N</td>
+<td>value 0</td>
+<td>value 1</td>
+<td><b>...</b></td>
+<td>value N-1</td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+The offsets can be either 8-bit, 16-bit, or 24-bit integers depending
+on how much data is to be stored.  If the total size of the content
+is less than 256 bytes then 8-bit offsets are used.  If the total size
+of the b-tree data is less than 65536 then 16-bit offsets are used.
+24-bit offsets are used otherwise.  Offsets are always little-endian,
+which means that the least significant byte occurs first.
+</p>
+
+<p>
+Data is stored as a nul-terminated string.  Any empty string consists
+of just the nul terminator.  A NULL value is an empty string with no
+nul-terminator.  Thus a NULL value occupies zero bytes and an empty string
+occupies 1 byte.
+</p>
+
+<p>
+Column values are stored in the order that they appear in the CREATE TABLE
+statement.  The offsets at the beginning of the record contain the
+byte index of the corresponding column value.  Thus, Offset 0 contains
+the byte index for Value 0, Offset 1 contains the byte offset
+of Value 1, and so forth.  The number of bytes in a column value can
+always be found by subtracting offsets.  This allows NULLs to be
+recovered from the record unambiguously.
+</p>
+
+<p>
+Most columns are stored in the b-tree data as described above.
+The one exception is column that has type INTEGER PRIMARY KEY.
+INTEGER PRIMARY KEY columns correspond to the 4-byte b-tree key.
+When an SQL statement attempts to read the INTEGER PRIMARY KEY,
+the 4-byte b-tree key is read rather than information out of the
+b-tree data.  But there is still an Offset associated with the
+INTEGER PRIMARY KEY, just like any other column.  But the Value
+associated with that offset is always NULL.
+</p>
+
+<h4>4.2 &nbsp; SQL Index Implementation Details</h4>
+
+<p>
+SQL indices are implement using a b-tree in which the key is used
+but the data is always empty.  The purpose of an index is to map
+one or more column values into the ROWID for the table entry that
+contains those column values.
+</p>
+
+<p>
+Each b-tree in an index consists of one or more column values followed
+by a 4-byte ROWID.  Each column value is nul-terminated (even NULL values)
+and begins with a single character that indicates the datatype for that
+column value.  Only three datatypes are supported: NULL, Number, and
+Text.  NULL values are encoded as the character 'a' followed by the
+nul terminator.  Numbers are encoded as the character 'b' followed by
+a string that has been crafted so that sorting the string using memcmp()
+will sort the corresponding numbers in numerical order.  (See the
+sqliteRealToSortable() function in util.c of the SQLite sources for
+additional information on this encoding.)  Numbers are also nul-terminated.
+Text values consists of the character 'c' followed by a copy of the
+text string and a nul-terminator.  These encoding rules result in
+NULLs being sorted first, followed by numerical values in numerical
+order, followed by text values in lexicographical order.
+</p>
+
+<h4>4.4 &nbsp; SQL Schema Storage And Root B-Tree Page Numbers</h4>
+
+<p>
+The database schema is stored in the database in a special tabled named
+"sqlite_master" and which always has a root b-tree page number of 2.
+This table contains the original CREATE TABLE,
+CREATE INDEX, CREATE VIEW, and CREATE TRIGGER statements used to define
+the database to begin with.  Whenever an SQLite database is opened,
+the sqlite_master table is scanned from beginning to end and 
+all the original CREATE statements are played back through the parser
+in order to reconstruct an in-memory representation of the database
+schema for use in subsequent command parsing.  For each CREATE TABLE
+and CREATE INDEX statement, the root page number for the corresponding
+b-tree is also recorded in the sqlite_master table so that SQLite will
+know where to look for the appropriate b-tree.
+</p>
+
+<p>
+SQLite users can query the sqlite_master table just like any other table
+in the database.  But the sqlite_master table cannot be directly written.
+The sqlite_master table is automatically updated in response to CREATE
+and DROP statements but it cannot be changed using INSERT, UPDATE, or
+DELETE statements as that would risk corrupting the database.
+</p>
+
+<p>
+SQLite stores temporary tables and indices in a separate
+file from the main database file.  The temporary table database file
+is the same structure as the main database file.  The schema table
+for the temporary tables is stored on page 2 just as in the main
+database.  But the schema table for the temporary database named
+"sqlite_temp_master" instead of "sqlite_master".  Other than the
+name change, it works exactly the same.
+</p>
+
+<h4>4.4 &nbsp; Schema Version Numbering And Other Meta-Information</h4>
+
+<p>
+The nine 32-bit integers that are stored beginning at byte offset
+60 of Page 1 in the b-tree layer are passed up into the schema layer
+and used for versioning and configuration information.  The meaning
+of the first four integers is shown below.  The other five are currently
+unused.
+</p>
+
+<ol>
+<li>The schema version number</li>
+<li>The format version number</li>
+<li>The recommended pager cache size</li>
+<li>The safety level</li>
+</ol>
+
+<p>
+The first meta-value, the schema version number, is used to detect when
+the schema of the database is changed by a CREATE or DROP statement.
+Recall that when a database is first opened the sqlite_master table is
+scanned and an internal representation of the tables, indices, views,
+and triggers for the database is built in memory.  This internal
+representation is used for all subsequent SQL command parsing and
+execution.  But what if another process were to change the schema
+by adding or removing a table, index, view, or trigger?  If the original
+process were to continue using the old schema, it could potentially
+corrupt the database by writing to a table that no longer exists.
+To avoid this problem, the schema version number is changed whenever
+a CREATE or DROP statement is executed.  Before each command is
+executed, the current schema version number for the database file
+is compared against the schema version number from when the sqlite_master
+table was last read.  If those numbers are different, the internal
+schema representation is erased and the sqlite_master table is reread
+to reconstruct the internal schema representation.
+(Calls to sqlite_exec() generally return SQLITE_SCHEMA when this happens.)
+</p>
+
+<p>
+The second meta-value is the schema format version number.  This
+number tells what version of the schema layer should be used to
+interpret the file.  There have been changes to the schema layer
+over time and this number is used to detect when an older database
+file is being processed by a newer version of the library.
+As of this writing (SQLite version 2.7.0) the current format version
+is "4".
+</p>
+
+<p>
+The third meta-value is the recommended pager cache size as set 
+by the DEFAULT_CACHE_SIZE pragma.  If the value is positive it
+means that synchronous behavior is enable (via the DEFAULT_SYNCHRONOUS
+pragma) and if negative it means that synchronous behavior is
+disabled.
+</p>
+
+<p>
+The fourth meta-value is safety level added in version 2.8.0.
+A value of 1 corresponds to a SYNCHRONOUS setting of OFF.  In other
+words, SQLite does not pause to wait for journal data to reach the disk
+surface before overwriting pages of the database.  A value of 2 corresponds
+to a SYNCHRONOUS setting of NORMAL.  A value of 3 corresponds to a
+SYNCHRONOUS setting of FULL. If the value is 0, that means it has not
+been initialized so the default synchronous setting of NORMAL is used.
+</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/formatchng.tcl b/client/src/thirdparty/sqlite-3.4.2/www/formatchng.tcl
new file mode 100644
index 0000000..83a2dcf
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/formatchng.tcl
@@ -0,0 +1,285 @@
+#
+# Run this Tcl script to generate the formatchng.html file.
+#
+set rcsid {$Id: formatchng.tcl,v 1.20 2007/09/03 20:32:45 drh Exp $ }
+source common.tcl
+header {File Format Changes in SQLite}
+puts {
+<h2>File Format Changes in SQLite</h2>
+
+<p>
+Every effort is made to keep SQLite fully backwards compatible from
+one release to the next.  Rarely, however, some
+enhancements or bug fixes may require a change to
+the underlying file format.  When this happens and you
+must convert the contents of your
+databases into a portable ASCII representation using the old version
+of the library then reload the data using the new version of the
+library.
+</p>
+
+<p>
+You can tell if you should reload your databases by comparing the
+version numbers of the old and new libraries.  If the first digit
+of the version number is different, then a reload of the database will
+be required.  If the second digit changes, newer versions of SQLite
+will be able to read and write older database files, but older versions
+of the library may have difficulty reading or writing newer database
+files.
+For example, upgrading from
+version 2.8.14 to 3.0.0 requires a reload.  Going from
+version 3.0.8 to 3.1.0 is backwards compatible but not necessarily
+forwards compatible.
+</p>
+
+<p>
+The following table summarizes the SQLite file format changes that have
+occurred since version 1.0.0:
+</p>
+
+<blockquote>
+<table border=2 cellpadding=5>
+<tr>
+  <th>Version Change</th>
+  <th>Approx. Date</th>
+  <th>Description Of File Format Change</th>
+</tr>
+<tr>
+  <td valign="top">1.0.32 to 2.0.0</td>
+  <td valign="top">2001-Sep-20</td>
+  <td>Version 1.0.X of SQLite used the GDBM library as its backend
+  interface to the disk.  Beginning in version 2.0.0, GDBM was replaced
+  by a custom B-Tree library written especially for SQLite.  The new
+  B-Tree backend is twice as fast as GDBM, supports atomic commits and
+  rollback, and stores an entire database in a single disk file instead
+  using a separate file for each table as GDBM does.  The two
+  file formats are not even remotely similar.</td>
+</tr>
+<tr>
+  <td valign="top">2.0.8 to 2.1.0</td>
+  <td valign="top">2001-Nov-12</td>
+  <td>The same basic B-Tree format is used but the details of the 
+  index keys were changed in order to provide better query 
+  optimization opportunities.  Some of the headers were also changed in order
+  to increase the maximum size of a row from 64KB to 24MB.<p>
+
+  This change is an exception to the version number rule described above
+  in that it is neither forwards or backwards compatible.  A complete
+  reload of the database is required.  This is the only exception.</td>
+</tr>
+<tr>
+  <td valign="top">2.1.7 to 2.2.0</td>
+  <td valign="top">2001-Dec-21</td>
+  <td>Beginning with version 2.2.0, SQLite no longer builds an index for
+  an INTEGER PRIMARY KEY column.  Instead, it uses that column as the actual
+  B-Tree key for the main table.<p>Version 2.2.0 and later of the library
+  will automatically detect when it is reading a 2.1.x database and will
+  disable the new INTEGER PRIMARY KEY feature.   In other words, version
+  2.2.x is backwards compatible to version 2.1.x.  But version 2.1.x is not
+  forward compatible with version 2.2.x. If you try to open
+  a 2.2.x database with an older 2.1.x library and that database contains
+  an INTEGER PRIMARY KEY, you will likely get a coredump.  If the database
+  schema does not contain any INTEGER PRIMARY KEYs, then the version 2.1.x
+  and version 2.2.x database files will be identical and completely
+  interchangeable.</p>
+</tr>
+<tr>
+  <td valign="top">2.2.5 to 2.3.0</td>
+  <td valign="top">2002-Jan-30</td>
+  <td>Beginning with version 2.3.0, SQLite supports some additional syntax
+  (the "ON CONFLICT" clause) in the CREATE TABLE and CREATE INDEX statements
+  that are stored in the SQLITE_MASTER table.  If you create a database that
+  contains this new syntax, then try to read that database using version 2.2.5
+  or earlier, the parser will not understand the new syntax and you will get
+  an error.  Otherwise, databases for 2.2.x and 2.3.x are interchangeable.</td>
+</tr>
+<tr>
+  <td valign="top">2.3.3 to 2.4.0</td>
+  <td valign="top">2002-Mar-10</td>
+  <td>Beginning with version 2.4.0, SQLite added support for views. 
+  Information about views is stored in the SQLITE_MASTER table.  If an older
+  version of SQLite attempts to read a database that contains VIEW information
+  in the SQLITE_MASTER table, the parser will not understand the new syntax
+  and initialization will fail.  Also, the
+  way SQLite keeps track of unused disk blocks in the database file
+  changed slightly.
+  If an older version of SQLite attempts to write a database that
+  was previously written by version 2.4.0 or later, then it may leak disk
+  blocks.</td>
+</tr>
+<tr>
+  <td valign="top">2.4.12 to 2.5.0</td>
+  <td valign="top">2002-Jun-17</td>
+  <td>Beginning with version 2.5.0, SQLite added support for triggers. 
+  Information about triggers is stored in the SQLITE_MASTER table.  If an older
+  version of SQLite attempts to read a database that contains a CREATE TRIGGER
+  in the SQLITE_MASTER table, the parser will not understand the new syntax
+  and initialization will fail.
+  </td>
+</tr>
+<tr>
+  <td valign="top">2.5.6 to 2.6.0</td>
+  <td valign="top">2002-July-17</td>
+  <td>A design flaw in the layout of indices required a file format change
+  to correct.  This change appeared in version 2.6.0.<p>
+
+  If you use version 2.6.0 or later of the library to open a database file
+  that was originally created by version 2.5.6 or earlier, an attempt to
+  rebuild the database into the new format will occur automatically.
+  This can take some time for a large database.  (Allow 1 or 2 seconds
+  per megabyte of database under Unix - longer under Windows.)  This format
+  conversion is irreversible.  It is <strong>strongly</strong> suggested
+  that you make a backup copy of older database files prior to opening them
+  with version 2.6.0 or later of the library, in case there are errors in
+  the format conversion logic.<p>
+
+  Version 2.6.0 or later of the library cannot open read-only database
+  files from version 2.5.6 or earlier, since read-only files cannot be
+  upgraded to the new format.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">2.6.3 to 2.7.0</td>
+  <td valign="top">2002-Aug-13</td>
+  <td><p>Beginning with version 2.7.0, SQLite understands two different
+  datatypes: text and numeric.  Text data sorts in memcmp() order.
+  Numeric data sorts in numerical order if it looks like a number,
+  or in memcmp() order if it does not.</p>
+
+  <p>When SQLite version 2.7.0 or later opens a 2.6.3 or earlier database,
+  it assumes all columns of all tables have type "numeric".  For 2.7.0
+  and later databases, columns have type "text" if their datatype
+  string contains the substrings "char" or "clob" or "blob" or "text".
+  Otherwise they are of type "numeric".</p>
+
+  <p>Because "text" columns have a different sort order from numeric,
+  indices on "text" columns occur in a different order for version
+  2.7.0 and later database.  Hence version 2.6.3 and earlier of SQLite 
+  will be unable to read a 2.7.0 or later database.  But version 2.7.0
+  and later of SQLite will read earlier databases.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">2.7.6 to 2.8.0</td>
+  <td valign="top">2003-Feb-14</td>
+  <td><p>Version 2.8.0 introduces a change to the format of the rollback
+  journal file.  The main database file format is unchanged.  Versions
+  2.7.6 and earlier can read and write 2.8.0 databases and vice versa.
+  Version 2.8.0 can rollback a transaction that was started by version
+  2.7.6 and earlier.  But version 2.7.6 and earlier cannot rollback a
+  transaction started by version 2.8.0 or later.</p>
+
+  <p>The only time this would ever be an issue is when you have a program
+  using version 2.8.0 or later that crashes with an incomplete
+  transaction, then you try to examine the database using version 2.7.6 or
+  earlier.  The 2.7.6 code will not be able to read the journal file
+  and thus will not be able to rollback the incomplete transaction
+  to restore the database.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">2.8.14 to 3.0.0</td>
+  <td valign="top">2004-Jun-18</td>
+  <td><p>Version 3.0.0 is a major upgrade for SQLite that incorporates
+  support for UTF-16, BLOBs, and a more compact encoding that results
+  in database files that are typically 25% to 50% smaller.  The new file
+  format is very different and is completely incompatible with the
+  version 2 file format.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">3.0.8 to 3.1.0</td>
+  <td valign="top">2005-Jan-21</td>
+  <td><p>Version 3.1.0 adds support for
+  <a href="pragma.html#pragma_auto_vacuum">autovacuum mode</a>.
+  Prior versions of SQLite will be able to read an autovacuumed
+  database but will not be able to write it.  If autovaccum is disabled
+  (which is the default condition)
+  then databases are fully forwards and backwards compatible.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">3.1.6 to 3.2.0</td>
+  <td valign="top">2005-Mar-19</td>
+  <td><p>Version 3.2.0 adds support for the 
+  <a href="lang_altertable.html">ALTER TABLE ADD COLUMN</a>
+  command.  A database that has been modified by this command can
+  not be read by a version of SQLite prior to 3.1.4.  Running 
+  <a href="lang_vacuum.html">VACUUM</a>
+  after the ALTER TABLE
+  restores the database to a format such that it can be read by earlier
+  SQLite versions.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">3.2.8 to 3.3.0</td>
+  <td valign="top">2006-Jan-10</td>
+  <td><p>Version 3.3.0 adds support for descending indices and
+  uses a new encoding for boolean values that requires
+  less disk space.  Version 3.3.0 can read and write database
+  files created by prior versions of SQLite.  But prior versions
+  of SQLite will not be able to read or write databases created
+  by Version 3.3.0</p>
+  <p>If you need backwards and forwards capatibility, you can
+  compile with -DSQLITE_DEFAULT_FILE_FORMAT=1.  Or at runtime
+  you can say "PRAGMA legacy_file_format=ON" prior to creating
+  a new database file</p>
+  <p>Once a database file is created, its format is fixed.  So
+  a database file created by SQLite 3.2.8 and merely modified
+  by version 3.3.0 or later will retain the old format.  Except,
+  the VACUUM command recreates the database so running VACUUM
+  on 3.3.0 or later will change the file format to the latest
+  edition.</p>
+  </td>
+</tr>
+<tr>
+  <td valign="top">3.3.6 to 3.3.7</td>
+  <td valign="top">2006-Aug-12</td>
+  <td><p>The previous file format change has caused so much
+  grief that the default behavior has been changed back to 
+  the original file format.  This means that DESC option on
+  indices is ignored by default that the more efficient encoding
+  of boolean values is not used.  In that way, older versions
+  of SQLite can read and write databases created by newer
+  versions.  If the new features are desired, they can be
+  enabled using pragma: "PRAGMA legacy_file_format=OFF".</p>
+  <p>To be clear: both old and new file formats continue to
+  be understood and continue to work.  But the old file format
+  is used by default instead of the new.  This might change
+  again in some future release - we may go back to generating
+  the new file format by default - but probably not until
+  all users have upgraded to a version of SQLite that will
+  understand the new file format.  That might take several
+  years.</p></td>
+</tr>
+<tr>
+  <td valign="top">3.4.2 to 3.5.0</td>
+  <td valign="top">2007-Sep-3</td>
+  <td><p>The design of the OS interface layer was changed for
+  release 3.5.0.  Applications that implemented a custom OS
+  interface will need to be modified in order to upgrade.
+  There are also some subtly different semantics a few obscure
+  APIs.  An <a href="34to35.html">article</a> is avilable which
+  describing the changes in detail.</p>
+
+  <p>The on-disk file format is unchanged.</p>
+  </td>
+</tr>
+</table>
+</blockquote>
+
+<p>
+To perform a database reload, have ready versions of the
+<b>sqlite</b> command-line utility for both the old and new
+version of SQLite.  Call these two executables "<b>sqlite-old</b>"
+and "<b>sqlite-new</b>".  Suppose the name of your old database
+is "<b>old.db</b>" and you want to create a new database with
+the same information named "<b>new.db</b>".  The command to do
+this is as follows:
+</p>
+
+<blockquote>
+  sqlite-old old.db .dump | sqlite-new new.db
+</blockquote>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/fullscanb.gif b/client/src/thirdparty/sqlite-3.4.2/www/fullscanb.gif
new file mode 100644
index 0000000..5b04a73
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/fullscanb.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bc653c768b2bda579f7e0bbaad883dc3431efec16b3a5315c4178fa01d17279
+size 11946
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/index-ex1-x-b.gif b/client/src/thirdparty/sqlite-3.4.2/www/index-ex1-x-b.gif
new file mode 100644
index 0000000..aaa04d1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/index-ex1-x-b.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76492483f76792d9a3695de3ad65a6c02e639612930ac2a59c96de21547af3e0
+size 23173
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/index.tcl b/client/src/thirdparty/sqlite-3.4.2/www/index.tcl
new file mode 100644
index 0000000..46945ff
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/index.tcl
@@ -0,0 +1,115 @@
+#!/usr/bin/tclsh
+source common.tcl
+header {SQLite home page}
+puts {
+<table width="100%" border="0" cellspacing="5">
+<tr>
+<td width="50%" valign="top">
+<h2>About SQLite</h2>
+<p>
+  <table align="right" border="0"><tr><td>
+  <a href="http://osdir.com/Article6677.phtml">
+  <img src="2005osaward.gif"></a>
+  </td></tr></table>
+SQLite is a small
+C library that implements a self-contained, embeddable,
+zero-configuration
+SQL database engine.
+Features include:
+</p>
+
+<p><ul>
+<li>Transactions are atomic, consistent, isolated, and durable (ACID)
+    even after system crashes and power failures.
+<li>Zero-configuration - no setup or administration needed.</li>
+<li>Implements most of SQL92.
+    (<a href="omitted.html">Features not supported</a>)</li>
+<li>A complete database is stored in a single disk file.</li>
+<li>Database files can be freely shared between machines with
+    different byte orders.</li>
+<li>Supports terabyte-sized databases and gigabyte-sized strings
+    and blobs.  (See <a href="limits.html">limits.html</a>.)
+<li>Small code footprint: 
+    <a href="http://www.sqlite.org/cvstrac/wiki?p=SizeOfSqlite">
+    less than 250KiB</a> fully configured or less
+    than 150KiB with optional features omitted.</li>
+<li><a href="speed.html">Faster</a> than popular client/server database
+    engines for most common operations.</li>
+<li>Simple, easy to use <a href="capi3.html">API</a>.</li>
+<li><a href="tclsqlite.html">TCL bindings</a> included.
+    Bindings for many other languages 
+    <a href="http://www.sqlite.org/cvstrac/wiki?p=SqliteWrappers">
+    available separately.</a></li>
+<li>Well-commented source code with over 98% test coverage.</li>
+<li>Available as a 
+    <a href="http://www.sqlite.org/cvstrac/wiki?p=TheAmalgamation">
+    single ANSI-C source-code file</a> that you can easily drop into
+    another project.
+<li>Self-contained: no external dependencies.</li>
+<li>Sources are in the <a href="copyright.html">public domain</a>.
+    Use for any purpose.</li>
+</ul>
+</p>
+
+<p>
+The SQLite distribution comes with a standalone command-line
+access program (<a href="sqlite.html">sqlite</a>) that can
+be used to administer an SQLite database and which serves as
+an example of how to use the SQLite library.
+</p>
+
+</td>
+<td width="1" bgcolor="#80a796"></td>
+<td valign="top" width="50%">
+<h2>News</h2>
+}
+
+proc newsitem {date title text} {
+  puts "<h3>$date - $title</h3>"
+  regsub -all "\n( *\n)+" $text "</p>\n\n<p>" txt
+  puts "<p>$txt</p>"
+  puts "<hr width=\"50%\">"
+}
+
+newsitem {2007-Nov-05} {Version 3.5.2} {
+  This is an incremental release that fixes several minor problems,
+  adds some obscure features, and provides some performance tweaks.  
+  Upgrading is optional.
+
+  The experimental compile-time option
+  SQLITE_OMIT_MEMORY_ALLOCATION is no longer supported.  On the other
+  hand, it is now possible to compile SQLite so that it uses a static
+  array for all its dynamic memory allocation needs and never calls
+  malloc.  Expect to see additional radical changes to the memory 
+  allocation subsystem in future releases.
+}
+
+newsitem {2007-Oct-04} {Version 3.5.1} {
+  Fix a long-standing bug that might cause database corruption if a
+  disk-full error occurs in the middle of a transaction and that
+  transaction is not rolled back.
+  <a href="http://www.sqlite.org/cvstrac/tktview?tn=2686">Ticket #2686.</a>
+
+  The new VFS layer is stable.  However, we still reserve the right to
+  make tweaks to the interface definition of the VFS if necessary.
+}
+
+newsitem {2007-Sep-04} {Version 3.5.0 alpha} {
+  The OS interface layer and the memory allocation subsystems in
+  SQLite have been reimplemented.  The published API is largely unchanged
+  but the (unpublished) OS interface has been modified extensively.  
+  Applications that implement their own OS interface will require
+  modification.  See
+  <a href="34to35.html">34to35.html</a> for details.<p>
+
+  This is a large change.  Approximately 10% of the source code was
+  modified.  We are calling this first release "alpha" in order to give
+  the user community time to test and evaluate the changes before we
+  freeze the new design.
+}
+
+puts {
+<p align="right"><a href="oldnews.html">Old news...</a></p>
+</td></tr></table>
+}
+footer {$Id: index.tcl,v 1.165 2007/11/05 18:11:18 drh Exp $}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/indirect1b1.gif b/client/src/thirdparty/sqlite-3.4.2/www/indirect1b1.gif
new file mode 100644
index 0000000..34b3478
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/indirect1b1.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9ee628da0bd97e40e40b706a6fcbd4a28a2d9724c619d3895c377778b39253c
+size 18098
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/lang.tcl b/client/src/thirdparty/sqlite-3.4.2/www/lang.tcl
new file mode 100644
index 0000000..c721b59
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/lang.tcl
@@ -0,0 +1,2207 @@
+#
+# Run this Tcl script to generate the lang-*.html files.
+#
+set rcsid {$Id: lang.tcl,v 1.137 2007/10/12 19:11:55 drh Exp $}
+source common.tcl
+
+if {[llength $argv]>0} {
+  set outputdir [lindex $argv 0]
+} else {
+  set outputdir ""
+}
+
+header {Query Language Understood by SQLite}
+puts {
+<h1 class="pdf_section">SQL As Understood By SQLite</h1>
+
+<p>The SQLite library understands most of the standard SQL
+language.  But it does <a href="omitted.html">omit some features</a>
+while at the same time
+adding a few features of its own.  This document attempts to
+describe precisely what parts of the SQL language SQLite does
+and does not support.  A list of <a href="lang_keywords.html">keywords</a> is 
+also provided.</p>
+
+<p>In all of the syntax diagrams that follow, literal text is shown in
+bold blue.  Non-terminal symbols are shown in italic red.  Operators
+that are part of the syntactic markup itself are shown in black roman.</p>
+
+<p>This document is just an overview of the SQL syntax implemented
+by SQLite.  Many low-level productions are omitted.  For detailed information
+on the language that SQLite understands, refer to the source code and
+the grammar file "parse.y".</p>
+
+<div class="pdf_ignore">
+<p>SQLite implements the follow syntax:</p>
+<p><ul>
+}
+
+proc slink {label} {
+  if {[string match *.html $label]} {
+    return $label
+  }
+  if {[string length $::outputdir]==0} {
+    return #$label
+  } else { 
+    return lang_$label.html
+  }
+}
+
+foreach {section} [lsort -index 0 -dictionary {
+  {{CREATE TABLE} createtable}
+  {{CREATE VIRTUAL TABLE} createvtab}
+  {{CREATE INDEX} createindex}
+  {VACUUM vacuum}
+  {{DROP TABLE} droptable}
+  {{DROP INDEX} dropindex}
+  {INSERT insert}
+  {REPLACE replace}
+  {DELETE delete}
+  {UPDATE update}
+  {SELECT select}
+  {comment comment}
+  {COPY copy}
+  {EXPLAIN explain}
+  {expression expr}
+  {{BEGIN TRANSACTION} transaction}
+  {{COMMIT TRANSACTION} transaction}
+  {{END TRANSACTION} transaction}
+  {{ROLLBACK TRANSACTION} transaction}
+  {PRAGMA pragma.html}
+  {{ON CONFLICT clause} conflict}
+  {{CREATE VIEW} createview}
+  {{DROP VIEW} dropview}
+  {{CREATE TRIGGER} createtrigger}
+  {{DROP TRIGGER} droptrigger}
+  {{ATTACH DATABASE} attach}
+  {{DETACH DATABASE} detach}
+  {REINDEX reindex}
+  {{ALTER TABLE} altertable}
+  {{ANALYZE} analyze}
+}] {
+  foreach {s_title s_tag} $section {}
+  puts "<li><a href=\"[slink $s_tag]\">$s_title</a></li>"
+}
+puts {</ul></p>
+</div>
+
+<p>Details on the implementation of each command are provided in
+the sequel.</p>
+}
+
+proc Operator {name} {
+  return "<font color=\"#2c2cf0\"><big>$name</big></font>"
+}
+proc Nonterminal {name} {
+  return "<i><font color=\"#ff3434\">$name</font></i>"
+}
+proc Keyword {name} {
+  return "<font color=\"#2c2cf0\">$name</font>"
+}
+proc Example {text} {
+  puts "<blockquote><pre>$text</pre></blockquote>"
+}
+
+proc Section {name label} {
+  global outputdir
+
+  if {[string length $outputdir]!=0} {
+    if {[llength [info commands puts_standard]]>0} {
+      footer $::rcsid
+    }
+
+    if {[string length $label]>0} {
+      rename puts puts_standard
+      proc puts {str} {
+        regsub -all {href="#([a-z]+)"} $str {href="lang_\1.html"} str
+        puts_standard $::section_file $str
+      }
+      rename footer footer_standard
+      proc footer {id} {
+        footer_standard $id
+        rename footer ""
+        rename puts ""
+        rename puts_standard puts
+        rename footer_standard footer
+      } 
+      set ::section_file [open [file join $outputdir lang_$label.html] w]
+      header "Query Language Understood by SQLite: $name"
+      puts "<h1>SQL As Understood By SQLite</h1>"
+      puts "<a href=\"lang.html\">\[Contents\]</a>"
+      puts "<h2>$name</h2>"
+      return 
+    }
+  }
+  puts "\n<hr />"
+  if {$label!=""} {
+    puts "<a name=\"$label\"></a>"
+  }
+  puts "<h1>$name</h1>\n"
+}
+
+Section {ALTER TABLE} altertable
+
+Syntax {sql-statement} {
+ALTER TABLE [<database-name> .] <table-name> <alteration>
+} {alteration} {
+RENAME TO <new-table-name>
+} {alteration} {
+ADD [COLUMN] <column-def>
+}
+
+puts {
+<p>SQLite's version of the ALTER TABLE command allows the user to 
+rename or add a new column to an existing table. It is not possible
+to remove a column from a table.
+</p>
+
+<p>The RENAME TO syntax is used to rename the table identified by 
+<i>[database-name.]table-name</i> to <i>new-table-name</i>. This command 
+cannot be used to move a table between attached databases, only to rename 
+a table within the same database.</p>
+
+<p>If the table being renamed has triggers or indices, then these remain
+attached to the table after it has been renamed. However, if there are
+any view definitions, or statements executed by triggers that refer to
+the table being renamed, these are not automatically modified to use the new
+table name. If this is required, the triggers or view definitions must be
+dropped and recreated to use the new table name by hand.
+</p>
+
+<p>The ADD [COLUMN] syntax is used to add a new column to an existing table.
+The new column is always appended to the end of the list of existing columns.
+<i>Column-def</i> may take any of the forms permissable in a CREATE TABLE 
+statement, with the following restrictions:
+<ul>
+<li>The column may not have a PRIMARY KEY or UNIQUE constraint.</li>
+<li>The column may not have a default value of CURRENT_TIME, CURRENT_DATE 
+    or CURRENT_TIMESTAMP.</li>
+<li>If a NOT NULL constraint is specified, then the column must have a
+    default value other than NULL.
+</ul>
+
+<p>The execution time of the ALTER TABLE command is independent of
+the amount of data in the table.  The ALTER TABLE command runs as quickly
+on a table with 10 million rows as it does on a table with 1 row.
+</p>
+
+<p>After ADD COLUMN has been run on a database, that database will not
+be readable by SQLite version 3.1.3 and earlier until the database
+is <a href="lang_vacuum.html">VACUUM</a>ed.</p>
+}
+
+Section {ANALYZE} analyze
+
+Syntax {sql-statement} {
+  ANALYZE
+}
+Syntax {sql-statement} {
+  ANALYZE <database-name>
+}
+Syntax {sql-statement} {
+  ANALYZE [<database-name> .] <table-name>
+}
+
+puts {
+<p>The ANALYZE command gathers statistics about indices and stores them
+in a special tables in the database where the query optimizer can use
+them to help make better index choices.
+If no arguments are given, all indices in all attached databases are
+analyzed.  If a database name is given as the argument, all indices
+in that one database are analyzed.  If the argument is a table name,
+then only indices associated with that one table are analyzed.</p>
+
+<p>The initial implementation stores all statistics in a single
+table named <b>sqlite_stat1</b>.  Future enhancements may create
+additional tables with the same name pattern except with the "1"
+changed to a different digit.  The <b>sqlite_stat1</b> table cannot
+be <a href="#droptable">DROP</a>ped,
+but all the content can be <a href="#delete">DELETE</a>d which has the
+same effect.</p>
+}
+
+Section {ATTACH DATABASE} attach
+
+Syntax {sql-statement} {
+ATTACH [DATABASE] <database-filename> AS <database-name>
+}
+
+puts {
+<p>The ATTACH DATABASE statement adds another database 
+file to the current database connection.  If the filename contains 
+punctuation characters it must be quoted.  The names 'main' and 
+'temp' refer to the main database and the database used for 
+temporary tables.  These cannot be detached.  Attached databases 
+are removed using the <a href="#detach">DETACH DATABASE</a> 
+statement.</p>
+
+<p>You can read from and write to an attached database and you
+can modify the schema of the attached database.  This is a new
+feature of SQLite version 3.0.  In SQLite 2.8, schema changes
+to attached databases were not allowed.</p>
+
+<p>You cannot create a new table with the same name as a table in 
+an attached database, but you can attach a database which contains
+tables whose names are duplicates of tables in the main database.  It is 
+also permissible to attach the same database file multiple times.</p>
+
+<p>Tables in an attached database can be referred to using the syntax 
+<i>database-name.table-name</i>.  If an attached table doesn't have 
+a duplicate table name in the main database, it doesn't require a 
+database name prefix.  When a database is attached, all of its 
+tables which don't have duplicate names become the default table
+of that name.  Any tables of that name attached afterwards require the table 
+prefix. If the default table of a given name is detached, then 
+the last table of that name attached becomes the new default.</p>
+
+<p>
+Transactions involving multiple attached databases are atomic,
+assuming that the main database is not ":memory:".  If the main
+database is ":memory:" then 
+transactions continue to be atomic within each individual
+database file. But if the host computer crashes in the middle
+of a COMMIT where two or more database files are updated,
+some of those files might get the changes where others
+might not.
+Atomic commit of attached databases is a new feature of SQLite version 3.0.
+In SQLite version 2.8, all commits to attached databases behaved as if
+the main database were ":memory:".
+</p>
+
+<p>There is a compile-time limit of 10 attached database files.</p>
+}
+
+
+Section {BEGIN TRANSACTION} transaction
+
+Syntax {sql-statement} {
+BEGIN [ DEFERRED | IMMEDIATE | EXCLUSIVE ] [TRANSACTION [<name>]]
+}
+Syntax {sql-statement} {
+END [TRANSACTION [<name>]]
+}
+Syntax {sql-statement} {
+COMMIT [TRANSACTION [<name>]]
+}
+Syntax {sql-statement} {
+ROLLBACK [TRANSACTION [<name>]]
+}
+
+puts {
+
+<p>
+No changes can be made to the database except within a transaction.
+Any command that changes the database (basically, any SQL command
+other than SELECT) will automatically start a transaction if
+one is not already in effect.  Automatically started transactions
+are committed at the conclusion of the command.
+</p>
+
+<p>
+Transactions can be started manually using the BEGIN
+command.  Such transactions usually persist until the next
+COMMIT or ROLLBACK command.  But a transaction will also 
+ROLLBACK if the database is closed or if an error occurs
+and the ROLLBACK conflict resolution algorithm is specified.
+See the documentation on the <a href="#conflict">ON CONFLICT</a>
+clause for additional information about the ROLLBACK
+conflict resolution algorithm.
+</p>
+
+<p>
+END TRANSACTION is an alias for COMMIT.
+</p>
+
+<p>The optional transaction name is current ignored. SQLite 
+does not recognize nested transactions at this time.
+However, future versions of SQLite may be enhanced to support nested
+transactions and the transaction name would then become significant.
+Application are advised not to use the transaction name in order
+to avoid future compatibility problems.</p>
+
+<p>
+Transactions can be deferred, immediate, or exclusive.  
+The default transaction behavior is deferred.
+Deferred means that no locks are acquired
+on the database until the database is first accessed.  Thus with a
+deferred transaction, the BEGIN statement itself does nothing.  Locks
+are not acquired until the first read or write operation.  The first read
+operation against a database creates a SHARED lock and the first
+write operation creates a RESERVED lock.   Because the acquisition of
+locks is deferred until they are needed, it is possible that another
+thread or process could create a separate transaction and write to
+the database after the BEGIN on the current thread has executed.
+If the transaction is immediate, then RESERVED locks
+are acquired on all databases as soon as the BEGIN command is
+executed, without waiting for the
+database to be used.  After a BEGIN IMMEDIATE, you are guaranteed that
+no other thread or process will be able to write to the database or
+do a BEGIN IMMEDIATE or BEGIN EXCLUSIVE.  Other processes can continue
+to read from the database, however.  An exclusive transaction causes
+EXCLUSIVE locks to be acquired on all databases.  After a BEGIN
+EXCLUSIVE, you are guaranteed that no other thread or process will
+be able to read or write the database until the transaction is
+complete.
+</p>
+
+<p>
+A description of the meaning of SHARED, RESERVED, and EXCLUSIVE locks
+is available <a href="lockingv3.html">separately</a>.
+</p>
+
+<p>
+The COMMIT command does not actually perform a commit until all
+pending SQL commands finish.  Thus if two or more SELECT statements
+are in the middle of processing and a COMMIT is executed, the commit
+will not actually occur until all SELECT statements finish.
+</p>
+
+<p>
+An attempt to execute COMMIT might result in an SQLITE_BUSY return code.
+This indicates that another thread or process had a read lock on the database
+that prevented the database from being updated.  When COMMIT fails in this
+way, the transaction remains active and the COMMIT can be retried later
+after the reader has had a chance to clear.
+</p>
+
+<h3>Response To Errors Within A Transaction</h3>
+
+<p>If certain kinds of errors occur within a transaction, the
+transaction may or may not be rolled back automatically.  The
+errors that cause the behavior include:</p>
+
+<ul>
+<li> SQLITE_FULL: database or disk full
+<li> SQLITE_IOERR: disk I/O error
+<li> SQLITE_BUSY: database in use by another process
+<li> SQLITE_NOMEM: out or memory
+<li> SQLITE_INTERRUPT: processing interrupted by user request
+</ul>
+
+<p>
+For all of these errors, SQLite attempts to undo just the one statement
+it was working on and leave changes from prior statements within the
+same transaction intact and continue with the transaction.  However, 
+depending on the statement being evaluated and the point at which the
+error occurs, it might be necessary for SQLite to rollback and
+cancel the transaction.  An application can tell which
+course of action SQLite took by using the
+<a href="capi3ref.html#sqlite3_get_autocommit">sqlite3_get_autocommit()</a>
+C-language interface.</p>
+
+<p>It is recommended that applications respond to the errors
+listed above by explicitly issuing a ROLLBACK command.  If the 
+transaction has already been rolled back automatically
+by the error response, then the ROLLBACK command will fail with an
+error, but no harm is caused by this.</p>
+
+<p>Future versions of SQLite may extend the list of errors which
+might cause automatic transaction rollback.  Future versions of
+SQLite might change the error response.  In particular, we may
+choose to simplify the interface in future versions of SQLite by
+causing the errors above to force an unconditional rollback.</p>
+}
+
+
+Section comment comment
+
+Syntax {comment} {<SQL-comment> | <C-comment>
+} {SQL-comment} {-- <single-line>
+} {C-comment} {/STAR <multiple-lines> [STAR/]
+}
+
+puts {
+<p> Comments aren't SQL commands, but can occur in SQL queries. They are 
+treated as whitespace by the parser.  They can begin anywhere whitespace 
+can be found, including inside expressions that span multiple lines.
+</p>
+
+<p> SQL comments only extend to the end of the current line.</p>
+
+<p> C comments can span any number of lines.  If there is no terminating
+delimiter, they extend to the end of the input.  This is not treated as
+an error.  A new SQL statement can begin on a line after a multiline
+comment ends.  C comments can be embedded anywhere whitespace can occur,
+including inside expressions, and in the middle of other SQL statements.
+C comments do not nest.  SQL comments inside a C comment will be ignored.
+</p>
+}
+
+
+Section COPY copy
+
+Syntax {sql-statement} {
+COPY [ OR <conflict-algorithm> ] [<database-name> .] <table-name> FROM <filename>
+[ USING DELIMITERS <delim> ]
+}
+
+puts {
+<p>The COPY command is available in SQLite version 2.8 and earlier.
+The COPY command has been removed from SQLite version 3.0 due to
+complications in trying to support it in a mixed UTF-8/16 environment.
+In version 3.0, the <a href="sqlite.html">command-line shell</a>
+contains a new command <b>.import</b> that can be used as a substitute
+for COPY.
+</p>
+
+<p>The COPY command is an extension used to load large amounts of
+data into a table.  It is modeled after a similar command found
+in PostgreSQL.  In fact, the SQLite COPY command is specifically
+designed to be able to read the output of the PostgreSQL dump
+utility <b>pg_dump</b> so that data can be easily transferred from
+PostgreSQL into SQLite.</p>
+
+<p>The table-name is the name of an existing table which is to
+be filled with data.  The filename is a string or identifier that
+names a file from which data will be read.  The filename can be
+the <b>STDIN</b> to read data from standard input.</p>
+
+<p>Each line of the input file is converted into a single record
+in the table.  Columns are separated by tabs.  If a tab occurs as
+data within a column, then that tab is preceded by a baskslash "\"
+character.  A baskslash in the data appears as two backslashes in
+a row.  The optional USING DELIMITERS clause can specify a delimiter
+other than tab.</p>
+
+<p>If a column consists of the character "\N", that column is filled
+with the value NULL.</p>
+
+<p>The optional conflict-clause allows the specification of an alternative
+constraint conflict resolution algorithm to use for this one command.
+See the section titled
+<a href="#conflict">ON CONFLICT</a> for additional information.</p>
+
+<p>When the input data source is STDIN, the input can be terminated
+by a line that contains only a baskslash and a dot:}
+puts "\"[Operator \\.]\".</p>"
+
+
+Section {CREATE INDEX} createindex
+
+Syntax {sql-statement} {
+CREATE [UNIQUE] INDEX [IF NOT EXISTS] [<database-name> .] <index-name> 
+ON <table-name> ( <column-name> [, <column-name>]* )
+} {column-name} {
+<name> [ COLLATE <collation-name>] [ ASC | DESC ]
+}
+
+puts {
+<p>The CREATE INDEX command consists of the keywords "CREATE INDEX" followed
+by the name of the new index, the keyword "ON", the name of a previously
+created table that is to be indexed, and a parenthesized list of names of
+columns in the table that are used for the index key.
+Each column name can be followed by one of the "ASC" or "DESC" keywords
+to indicate sort order, but the sort order is ignored in the current
+implementation.  Sorting is always done in ascending order.</p>
+
+<p>The COLLATE clause following each column name defines a collating
+sequence used for text entires in that column.  The default collating
+sequence is the collating sequence defined for that column in the
+CREATE TABLE statement.  Or if no collating sequence is otherwise defined,
+the built-in BINARY collating sequence is used.</p>
+
+<p>There are no arbitrary limits on the number of indices that can be
+attached to a single table, nor on the number of columns in an index.</p>
+
+<p>If the UNIQUE keyword appears between CREATE and INDEX then duplicate
+index entries are not allowed.  Any attempt to insert a duplicate entry
+will result in an error.</p>
+
+<p>The exact text
+of each CREATE INDEX statement is stored in the <b>sqlite_master</b>
+or <b>sqlite_temp_master</b> table, depending on whether the table
+being indexed is temporary.  Every time the database is opened,
+all CREATE INDEX statements
+are read from the <b>sqlite_master</b> table and used to regenerate
+SQLite's internal representation of the index layout.</p>
+
+<p>If the optional IF NOT EXISTS clause is present and another index
+with the same name aleady exists, then this command becomes a no-op.</p>
+
+<p>Indexes are removed with the <a href="#dropindex">DROP INDEX</a> 
+command.</p>
+}
+
+
+Section {CREATE TABLE} {createtable}
+
+Syntax {sql-command} {
+CREATE [TEMP | TEMPORARY] TABLE [IF NOT EXISTS] [<database-name> .] <table-name> (
+  <column-def> [, <column-def>]*
+  [, <constraint>]*
+)
+} {sql-command} {
+CREATE [TEMP | TEMPORARY] TABLE [<database-name>.] <table-name> AS <select-statement>
+} {column-def} {
+<name> [<type>] [[CONSTRAINT <name>] <column-constraint>]*
+} {type} {
+<typename> |
+<typename> ( <number> ) |
+<typename> ( <number> , <number> )
+} {column-constraint} {
+NOT NULL [ <conflict-clause> ] |
+PRIMARY KEY [<sort-order>] [ <conflict-clause> ] [AUTOINCREMENT] |
+UNIQUE [ <conflict-clause> ] |
+CHECK ( <expr> ) |
+DEFAULT <value> |
+COLLATE <collation-name>
+} {constraint} {
+PRIMARY KEY ( <column-list> ) [ <conflict-clause> ] |
+UNIQUE ( <column-list> ) [ <conflict-clause> ] |
+CHECK ( <expr> )
+} {conflict-clause} {
+ON CONFLICT <conflict-algorithm>
+}
+
+puts {
+<p>A CREATE TABLE statement is basically the keywords "CREATE TABLE"
+followed by the name of a new table and a parenthesized list of column
+definitions and constraints.  The table name can be either an identifier
+or a string.  Tables names that begin with "<b>sqlite_</b>" are reserved
+for use by the engine.</p>
+
+<p>Each column definition is the name of the column followed by the
+datatype for that column, then one or more optional column constraints.
+The datatype for the column does not restrict what data may be put
+in that column.
+See <a href="datatype3.html">Datatypes In SQLite Version 3</a> for
+additional information.
+The UNIQUE constraint causes an index to be created on the specified
+columns.  This index must contain unique keys.
+The COLLATE clause specifies what text <a href="datatype3.html#collation">
+collating function</a> to use when comparing text entries for the column.  
+The built-in BINARY collating function is used by default.
+<p>
+The DEFAULT constraint specifies a default value to use when doing an INSERT.
+The value may be NULL, a string constant or a number. Starting with version
+3.1.0, the default value may also be one of the special case-independant
+keywords CURRENT_TIME, CURRENT_DATE or CURRENT_TIMESTAMP. If the value is
+NULL, a string constant or number, it is literally inserted into the column
+whenever an INSERT statement that does not specify a value for the column is
+executed. If the value is CURRENT_TIME, CURRENT_DATE or CURRENT_TIMESTAMP, then
+the current UTC date and/or time is inserted into the columns. For
+CURRENT_TIME, the format is HH:MM:SS. For CURRENT_DATE, YYYY-MM-DD. The format
+for CURRENT_TIMESTAMP is "YYYY-MM-DD HH:MM:SS".
+</p>
+
+<p>Specifying a PRIMARY KEY normally just creates a UNIQUE index
+on the corresponding columns.  However, if primary key is on a single column
+that has datatype INTEGER, then that column is used internally
+as the actual key of the B-Tree for the table.  This means that the column
+may only hold unique integer values.  (Except for this one case,
+SQLite ignores the datatype specification of columns and allows
+any kind of data to be put in a column regardless of its declared
+datatype.)  If a table does not have an INTEGER PRIMARY KEY column,
+then the B-Tree key will be a automatically generated integer.
+<a name="rowid"> The
+B-Tree key for a row can always be accessed using one of the
+special names "<b>ROWID</b>", "<b>OID</b>", or "<b>_ROWID_</b>".
+This is true regardless of whether or not there is an INTEGER
+PRIMARY KEY.  An INTEGER PRIMARY KEY column can also include the
+keyword AUTOINCREMENT.  The AUTOINCREMENT keyword modified the way
+that B-Tree keys are automatically generated.  Additional detail
+on automatic B-Tree key generation is available
+<a href="autoinc.html">separately</a>.</p>
+
+<p>According to the SQL standard, PRIMARY KEY should imply NOT NULL.
+Unfortunately, due to a long-standing coding oversight, this is not 
+the case in SQLite.  SQLite allows NULL values
+in a PRIMARY KEY column.  We could change SQLite to conform to the
+standard (and we might do so in the future), but by the time the
+oversight was discovered, SQLite was in such wide use that we feared
+breaking legacy code if we fixed the problem.  So for now we have
+chosen to contain allowing NULLs in PRIMARY KEY columns.
+Developers should be aware, however, that we may change SQLite to
+conform to the SQL standard in future and should design new programs
+accordingly.</p>
+
+<p>If the "TEMP" or "TEMPORARY" keyword occurs in between "CREATE"
+and "TABLE" then the table that is created is only visible
+within that same database connection
+and is automatically deleted when
+the database connection is closed.  Any indices created on a temporary table
+are also temporary.  Temporary tables and indices are stored in a
+separate file distinct from the main database file.</p>
+
+<p> If a &lt;database-name&gt; is specified, then the table is created in 
+the named database. It is an error to specify both a &lt;database-name&gt;
+and the TEMP keyword, unless the &lt;database-name&gt; is "temp". If no
+database name is specified, and the TEMP keyword is not present,
+the table is created in the main database.</p>
+
+<p>The optional conflict-clause following each constraint
+allows the specification of an alternative default
+constraint conflict resolution algorithm for that constraint.
+The default is abort ABORT.  Different constraints within the same
+table may have different default conflict resolution algorithms.
+If an COPY, INSERT, or UPDATE command specifies a different conflict
+resolution algorithm, then that algorithm is used in place of the
+default algorithm specified in the CREATE TABLE statement.
+See the section titled
+<a href="#conflict">ON CONFLICT</a> for additional information.</p>
+
+<p>CHECK constraints are supported as of version 3.3.0.  Prior
+to version 3.3.0, CHECK constraints were parsed but not enforced.</p>
+
+<p>There are no arbitrary limits on the number
+of columns or on the number of constraints in a table.
+The total amount of data in a single row is limited to about
+1 megabytes in version 2.8.  In version 3.0 there is no arbitrary
+limit on the amount of data in a row.</p>
+
+
+<p>The CREATE TABLE AS form defines the table to be
+the result set of a query.  The names of the table columns are
+the names of the columns in the result.</p>
+
+<p>The exact text
+of each CREATE TABLE statement is stored in the <b>sqlite_master</b>
+table.  Every time the database is opened, all CREATE TABLE statements
+are read from the <b>sqlite_master</b> table and used to regenerate
+SQLite's internal representation of the table layout.
+If the original command was a CREATE TABLE AS then then an equivalent
+CREATE TABLE statement is synthesized and store in <b>sqlite_master</b>
+in place of the original command.
+The text of CREATE TEMPORARY TABLE statements are stored in the
+<b>sqlite_temp_master</b> table.
+</p>
+
+<p>If the optional IF NOT EXISTS clause is present and another table
+with the same name aleady exists, then this command becomes a no-op.</p>
+
+<p>Tables are removed using the <a href="#droptable">DROP TABLE</a> 
+statement.  </p>
+}
+
+
+Section {CREATE TRIGGER} createtrigger
+
+Syntax {sql-statement} {
+CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] <trigger-name> [ BEFORE | AFTER ]
+<database-event> ON [<database-name> .] <table-name>
+<trigger-action>
+}
+
+Syntax {sql-statement} {
+CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] <trigger-name> INSTEAD OF
+<database-event> ON [<database-name> .] <view-name>
+<trigger-action>
+}
+
+Syntax {database-event} {
+DELETE | 
+INSERT | 
+UPDATE | 
+UPDATE OF <column-list>
+}
+
+Syntax {trigger-action} {
+[ FOR EACH ROW ] [ WHEN <expression> ] 
+BEGIN 
+  <trigger-step> ; [ <trigger-step> ; ]*
+END
+}
+
+Syntax {trigger-step} {
+<update-statement> | <insert-statement> | 
+<delete-statement> | <select-statement> 
+}
+
+puts {
+<p>The CREATE TRIGGER statement is used to add triggers to the 
+database schema. Triggers are database operations (the <i>trigger-action</i>) 
+that are automatically performed when a specified database event (the
+<i>database-event</i>) occurs.  </p>
+
+<p>A trigger may be specified to fire whenever a DELETE, INSERT or UPDATE of a
+particular database table occurs, or whenever an UPDATE of one or more
+specified columns of a table are updated.</p>
+
+<p>At this time SQLite supports only FOR EACH ROW triggers, not FOR EACH
+STATEMENT triggers. Hence explicitly specifying FOR EACH ROW is optional.  FOR
+EACH ROW implies that the SQL statements specified as <i>trigger-steps</i> 
+may be executed (depending on the WHEN clause) for each database row being
+inserted, updated or deleted by the statement causing the trigger to fire.</p>
+
+<p>Both the WHEN clause and the <i>trigger-steps</i> may access elements of 
+the row being inserted, deleted or updated using references of the form 
+"NEW.<i>column-name</i>" and "OLD.<i>column-name</i>", where
+<i>column-name</i> is the name of a column from the table that the trigger
+is associated with. OLD and NEW references may only be used in triggers on
+<i>trigger-event</i>s for which they are relevant, as follows:</p>
+
+<table border=0 cellpadding=10>
+<tr>
+<td valign="top" align="right" width=120><i>INSERT</i></td>
+<td valign="top">NEW references are valid</td>
+</tr>
+<tr>
+<td valign="top" align="right" width=120><i>UPDATE</i></td>
+<td valign="top">NEW and OLD references are valid</td>
+</tr>
+<tr>
+<td valign="top" align="right" width=120><i>DELETE</i></td>
+<td valign="top">OLD references are valid</td>
+</tr>
+</table>
+</p>
+
+<p>If a WHEN clause is supplied, the SQL statements specified as <i>trigger-steps</i> are only executed for rows for which the WHEN clause is true. If no WHEN clause is supplied, the SQL statements are executed for all rows.</p>
+
+<p>The specified <i>trigger-time</i> determines when the <i>trigger-steps</i>
+will be executed relative to the insertion, modification or removal of the
+associated row.</p>
+
+<p>An ON CONFLICT clause may be specified as part of an UPDATE or INSERT
+<i>trigger-step</i>. However if an ON CONFLICT clause is specified as part of 
+the statement causing the trigger to fire, then this conflict handling
+policy is used instead.</p>
+
+<p>Triggers are automatically dropped when the table that they are 
+associated with is dropped.</p>
+
+<p>Triggers may be created on views, as well as ordinary tables, by specifying
+INSTEAD OF in the CREATE TRIGGER statement. If one or more ON INSERT, ON DELETE
+or ON UPDATE triggers are defined on a view, then it is not an error to execute
+an INSERT, DELETE or UPDATE statement on the view, respectively. Thereafter,
+executing an INSERT, DELETE or UPDATE on the view causes the associated
+  triggers to fire. The real tables underlying the view are not modified
+  (except possibly explicitly, by a trigger program).</p>
+
+<p><b>Example:</b></p>
+
+<p>Assuming that customer records are stored in the "customers" table, and
+that order records are stored in the "orders" table, the following trigger
+ensures that all associated orders are redirected when a customer changes
+his or her address:</p>
+}
+Example {
+CREATE TRIGGER update_customer_address UPDATE OF address ON customers 
+  BEGIN
+    UPDATE orders SET address = new.address WHERE customer_name = old.name;
+  END;
+}
+puts {
+<p>With this trigger installed, executing the statement:</p>
+}
+
+Example {
+UPDATE customers SET address = '1 Main St.' WHERE name = 'Jack Jones';
+}
+puts {
+<p>causes the following to be automatically executed:</p>
+}
+Example {
+UPDATE orders SET address = '1 Main St.' WHERE customer_name = 'Jack Jones';
+}
+
+puts {
+<p>Note that currently, triggers may behave oddly when created on tables
+  with INTEGER PRIMARY KEY fields. If a BEFORE trigger program modifies the 
+  INTEGER PRIMARY KEY field of a row that will be subsequently updated by the
+  statement that causes the trigger to fire, then the update may not occur. 
+  The workaround is to declare the table with a PRIMARY KEY column instead
+  of an INTEGER PRIMARY KEY column.</p>
+}
+
+puts {
+<p>A special SQL function RAISE() may be used within a trigger-program, with the following syntax</p> 
+}
+Syntax {raise-function} {
+RAISE ( ABORT, <error-message> ) | 
+RAISE ( FAIL, <error-message> ) | 
+RAISE ( ROLLBACK, <error-message> ) | 
+RAISE ( IGNORE )
+}
+puts {
+<p>When one of the first three forms is called during trigger-program execution, the specified ON CONFLICT processing is performed (either ABORT, FAIL or 
+ ROLLBACK) and the current query terminates. An error code of SQLITE_CONSTRAINT is returned to the user, along with the specified error message.</p>
+
+<p>When RAISE(IGNORE) is called, the remainder of the current trigger program,
+the statement that caused the trigger program to execute and any subsequent
+    trigger programs that would of been executed are abandoned. No database
+    changes are rolled back.  If the statement that caused the trigger program
+    to execute is itself part of a trigger program, then that trigger program
+    resumes execution at the beginning of the next step.
+</p>
+
+<p>Triggers are removed using the <a href="#droptrigger">DROP TRIGGER</a>
+statement.</p>
+}
+
+
+Section {CREATE VIEW} {createview}
+
+Syntax {sql-command} {
+CREATE [TEMP | TEMPORARY] VIEW [IF NOT EXISTS] [<database-name>.] <view-name> AS <select-statement>
+}
+
+puts {
+<p>The CREATE VIEW command assigns a name to a pre-packaged 
+<a href="#select">SELECT</a>
+statement.  Once the view is created, it can be used in the FROM clause
+of another SELECT in place of a table name.
+</p>
+
+<p>If the "TEMP" or "TEMPORARY" keyword occurs in between "CREATE"
+and "VIEW" then the view that is created is only visible to the
+process that opened the database and is automatically deleted when
+the database is closed.</p>
+
+<p> If a &lt;database-name&gt; is specified, then the view is created in 
+the named database. It is an error to specify both a &lt;database-name&gt;
+and the TEMP keyword, unless the &lt;database-name&gt; is "temp". If no
+database name is specified, and the TEMP keyword is not present,
+the table is created in the main database.</p>
+
+<p>You cannot COPY, DELETE, INSERT or UPDATE a view.  Views are read-only 
+in SQLite.  However, in many cases you can use a <a href="#createtrigger">
+TRIGGER</a> on the view to accomplish the same thing.  Views are removed 
+with the <a href="#dropview">DROP VIEW</a> 
+command.</p>
+}
+
+Section {CREATE VIRTUAL TABLE} {createvtab}
+
+Syntax {sql-command} {
+CREATE VIRTUAL TABLE [<database-name> .] <table-name> USING <module-name> [( <arguments> )]
+}
+
+puts {
+<p>A virtual table is an interface to an external storage or computation
+engine that appears to be a table but does not actually store information
+in the database file.</p>
+
+<p>In general, you can do anything with a virtual table that can be done
+with an ordinary table, except that you cannot create triggers on a
+virtual table.  Some virtual table implementations might impose additional
+restrictions.  For example, many virtual tables are read-only.</p>
+
+<p>The &lt;module-name&gt; is the name of an object that implements
+the virtual table.  The &lt;module-name&gt; must be registered with
+the SQLite database connection using
+<a href="capi3ref.html#sqlite3_create_module">sqlite3_create_module</a>
+prior to issuing the CREATE VIRTUAL TABLE statement.
+The module takes zero or more comma-separated arguments.
+The arguments can be just about any text as long as it has balanced
+parentheses.  The argument syntax is sufficiently general that the
+arguments can be made to appear as column definitions in a traditional
+<a href="#createtable">CREATE TABLE</a> statement.  
+SQLite passes the module arguments directly
+to the module without any interpretation.  It is the responsibility
+of the module implementation to parse and interpret its own arguments.</p>
+
+<p>A virtual table is destroyed using the ordinary
+<a href="#droptable">DROP TABLE</a> statement.  There is no
+DROP VIRTUAL TABLE statement.</p>
+}
+
+Section DELETE delete
+
+Syntax {sql-statement} {
+DELETE FROM [<database-name> .] <table-name> [WHERE <expr>]
+}
+
+puts {
+<p>The DELETE command is used to remove records from a table.
+The command consists of the "DELETE FROM" keywords followed by
+the name of the table from which records are to be removed.
+</p>
+
+<p>Without a WHERE clause, all rows of the table are removed.
+If a WHERE clause is supplied, then only those rows that match
+the expression are removed.</p>
+}
+
+
+Section {DETACH DATABASE} detach
+
+Syntax {sql-command} {
+DETACH [DATABASE] <database-name>
+}
+
+puts {
+<p>This statement detaches an additional database connection previously 
+attached using the <a href="#attach">ATTACH DATABASE</a> statement.  It
+is possible to have the same database file attached multiple times using 
+different names, and detaching one connection to a file will leave the 
+others intact.</p>
+
+<p>This statement will fail if SQLite is in the middle of a transaction.</p>
+}
+
+
+Section {DROP INDEX} dropindex
+
+Syntax {sql-command} {
+DROP INDEX [IF EXISTS] [<database-name> .] <index-name>
+}
+
+puts {
+<p>The DROP INDEX statement removes an index added
+with the <a href="#createindex">
+CREATE INDEX</a> statement.  The index named is completely removed from
+the disk.  The only way to recover the index is to reenter the
+appropriate CREATE INDEX command.</p>
+
+<p>The DROP INDEX statement does not reduce the size of the database 
+file in the default mode.
+Empty space in the database is retained for later INSERTs.  To 
+remove free space in the database, use the <a href="#vacuum">VACUUM</a> 
+command.  If AUTOVACUUM mode is enabled for a database then space
+will be freed automatically by DROP INDEX.</p>
+}
+
+
+Section {DROP TABLE} droptable
+
+Syntax {sql-command} {
+DROP TABLE [IF EXISTS] [<database-name>.] <table-name>
+}
+
+puts {
+<p>The DROP TABLE statement removes a table added with the <a href=
+"#createtable">CREATE TABLE</a> statement.  The name specified is the
+table name.  It is completely removed from the database schema and the 
+disk file.  The table can not be recovered.  All indices associated 
+with the table are also deleted.</p>
+
+<p>The DROP TABLE statement does not reduce the size of the database 
+file in the default mode.  Empty space in the database is retained for
+later INSERTs.  To 
+remove free space in the database, use the <a href="#vacuum">VACUUM</a> 
+command.  If AUTOVACUUM mode is enabled for a database then space
+will be freed automatically by DROP TABLE.</p>
+
+<p>The optional IF EXISTS clause suppresses the error that would normally
+result if the table does not exist.</p>
+}
+
+
+Section {DROP TRIGGER} droptrigger
+Syntax {sql-statement} {
+DROP TRIGGER [IF EXISTS] [<database-name> .] <trigger-name>
+}
+puts { 
+<p>The DROP TRIGGER statement removes a trigger created by the 
+<a href="#createtrigger">CREATE TRIGGER</a> statement.  The trigger is 
+deleted from the database schema. Note that triggers are automatically 
+dropped when the associated table is dropped.</p>
+}
+
+
+Section {DROP VIEW} dropview
+
+Syntax {sql-command} {
+DROP VIEW [IF EXISTS] <view-name>
+}
+
+puts {
+<p>The DROP VIEW statement removes a view created by the <a href=
+"#createview">CREATE VIEW</a> statement.  The name specified is the 
+view name.  It is removed from the database schema, but no actual data 
+in the underlying base tables is modified.</p>
+}
+
+
+Section EXPLAIN explain
+
+Syntax {sql-statement} {
+EXPLAIN <sql-statement>
+}
+
+puts {
+<p>The EXPLAIN command modifier is a non-standard extension.  The
+idea comes from a similar command found in PostgreSQL, but the operation
+is completely different.</p>
+
+<p>If the EXPLAIN keyword appears before any other SQLite SQL command
+then instead of actually executing the command, the SQLite library will
+report back the sequence of virtual machine instructions it would have
+used to execute the command had the EXPLAIN keyword not been present.
+For additional information about virtual machine instructions see
+the <a href="arch.html">architecture description</a> or the documentation
+on <a href="opcode.html">available opcodes</a> for the virtual machine.</p>
+}
+
+
+Section expression expr
+
+Syntax {expr} {
+<expr> <binary-op> <expr> |
+<expr> [NOT] <like-op> <expr> [ESCAPE <expr>] |
+<unary-op> <expr> |
+( <expr> ) |
+<column-name> |
+<table-name> . <column-name> |
+<database-name> . <table-name> . <column-name> |
+<literal-value> |
+<parameter> |
+<function-name> ( <expr-list> | STAR ) |
+<expr> ISNULL |
+<expr> NOTNULL |
+<expr> [NOT] BETWEEN <expr> AND <expr> |
+<expr> [NOT] IN ( <value-list> ) |
+<expr> [NOT] IN ( <select-statement> ) |
+<expr> [NOT] IN [<database-name> .] <table-name> |
+[EXISTS] ( <select-statement> ) |
+CASE [<expr>] LP WHEN <expr> THEN <expr> RPPLUS [ELSE <expr>] END |
+CAST ( <expr> AS <type> ) |
+<expr> COLLATE <collation-name>
+} {like-op} {
+LIKE | GLOB | REGEXP | MATCH
+}
+
+puts {
+<p>This section is different from the others.  Most other sections of
+this document talks about a particular SQL command.  This section does
+not talk about a standalone command but about "expressions" which are 
+subcomponents of most other commands.</p>
+
+<p>SQLite understands the following binary operators, in order from
+highest to lowest precedence:</p>
+
+<blockquote><pre>
+<font color="#2c2cf0"><big>||
+*    /    %
++    -
+&lt;&lt;   &gt;&gt;   &amp;    |
+&lt;    &lt;=   &gt;    &gt;=
+=    ==   !=   &lt;&gt;   </big>IN
+AND   
+OR</font>
+</pre></blockquote>
+
+<p>Supported unary prefix operators are these:</p>
+
+<blockquote><pre>
+<font color="#2c2cf0"><big>-    +    !    ~    NOT</big></font>
+</pre></blockquote>
+
+<p>The COLLATE operator can be thought of as a unary postfix
+operator.  The COLLATE operator has the highest precedence.
+It always binds more tightly than any prefix unary operator or
+any binary operator.</p>
+
+<p>The unary operator [Operator +] is a no-op.  It can be applied
+to strings, numbers, or blobs and it always gives as its result the
+value of the operand.</p>
+
+<p>Note that there are two variations of the equals and not equals
+operators.  Equals can be either}
+puts "[Operator =] or [Operator ==].
+The non-equals operator can be either
+[Operator !=] or [Operator {&lt;&gt;}].
+The [Operator ||] operator is \"concatenate\" - it joins together
+the two strings of its operands.
+The operator [Operator %] outputs the remainder of its left 
+operand modulo its right operand.</p>
+
+<p>The result of any binary operator is a numeric value, except
+for the [Operator ||] concatenation operator which gives a string
+result.</p>"
+
+puts {
+
+<a name="literal_value"></a>
+<p>
+A literal value is an integer number or a floating point number.
+Scientific notation is supported.  The "." character is always used
+as the decimal point even if the locale setting specifies "," for
+this role - the use of "," for the decimal point would result in
+syntactic ambiguity.  A string constant is formed by enclosing the
+string in single quotes (').  A single quote within the string can
+be encoded by putting two single quotes in a row - as in Pascal.
+C-style escapes using the backslash character are not supported because
+they are not standard SQL.
+BLOB literals are string literals containing hexadecimal data and
+preceded by a single "x" or "X" character.  For example:</p>
+
+<blockquote><pre>
+X'53514C697465'
+</pre></blockquote>
+
+<p>
+A literal value can also be the token "NULL".
+</p>
+
+<p>
+A parameter specifies a placeholder in the expression for a literal
+value that is filled in at runtime using the
+<a href="capi3ref.html#sqlite3_bind_int">sqlite3_bind</a> API.
+Parameters can take several forms:
+</p
+
+<blockquote>
+<table class="pdf_functions">
+<tr>
+<td align="right" valign="top"><b>?</b><i>NNN</i></td><td width="20"></td>
+<td>A question mark followed by a number <i>NNN</i> holds a spot for the
+NNN-th parameter.  NNN must be between 1 and 999.</td>
+</tr>
+<tr>
+<td align="right" valign="top"><b>?</b></td><td width="20"></td>
+<td>A question mark that is not followed by a number holds a spot for
+the next unused parameter.</td>
+</tr>
+<tr>
+<td align="right" valign="top"><b>:</b><i>AAAA</i></td><td width="20"></td>
+<td>A colon followed by an identifier name holds a spot for a named
+parameter with the name AAAA.  Named parameters are also numbered.
+The number assigned is the next unused number.  To avoid confusion,
+it is best to avoid mixing named and numbered parameters.</td>
+</tr>
+<tr>
+<td align="right" valign="top"><b>@</b><i>AAAA</i></td><td width="20"></td>
+<td>An "at" sign works exactly like a colon.</td>
+</tr>
+<tr>
+<td align="right" valign="top"><b>$</b><i>AAAA</i></td><td width="20"></td>
+<td>A dollar-sign followed by an identifier name also holds a spot for a named
+parameter with the name AAAA.  The identifier name in this case can include
+one or more occurances of "::" and a suffix enclosed in "(...)" containing
+any text at all.  This syntax is the form of a variable name in the Tcl
+programming language.</td>
+</tr>
+</table>
+</blockquote>
+
+<p>Parameters that are not assigned values using
+<a href="capi3ref.html#sqlite3_bind_int">sqlite3_bind</a> are treated
+as NULL.</p>
+
+<a name="like"></a>
+<p>The LIKE operator does a pattern matching comparison. The operand
+to the right contains the pattern, the left hand operand contains the
+string to match against the pattern. 
+}
+puts "A percent symbol [Operator %] in the pattern matches any
+sequence of zero or more characters in the string.  An underscore
+[Operator _] in the pattern matches any single character in the
+string.  Any other character matches itself or it's lower/upper case
+equivalent (i.e. case-insensitive matching).  (A bug: SQLite only
+understands upper/lower case for 7-bit Latin characters.  Hence the
+LIKE operator is case sensitive for 8-bit iso8859 characters or UTF-8
+characters.  For example, the expression <b>'a'&nbsp;LIKE&nbsp;'A'</b>
+is TRUE but <b>'&aelig;'&nbsp;LIKE&nbsp;'&AElig;'</b> is FALSE.).</p>"
+
+puts {
+<p>If the optional ESCAPE clause is present, then the expression
+following the ESCAPE keyword must evaluate to a string consisting of
+a single character. This character may be used in the LIKE pattern
+to include literal percent or underscore characters. The escape
+character followed by a percent symbol, underscore or itself matches a
+literal percent symbol, underscore or escape character in the string,
+respectively. The infix LIKE operator is implemented by calling the
+user function <a href="#likeFunc"> like(<i>X</i>,<i>Y</i>)</a>.</p>
+}
+
+puts {
+The LIKE operator is not case sensitive and will match upper case
+characters on one side against lower case characters on the other.  
+(A bug: SQLite only understands upper/lower case for 7-bit Latin
+characters.  Hence the LIKE operator is case sensitive for 8-bit
+iso8859 characters or UTF-8 characters.  For example, the expression
+<b>'a'&nbsp;LIKE&nbsp;'A'</b> is TRUE but
+<b>'&aelig;'&nbsp;LIKE&nbsp;'&AElig;'</b> is FALSE.).</p>
+
+<p>The infix LIKE
+operator is implemented by calling the user function <a href="#likeFunc">
+like(<i>X</i>,<i>Y</i>)</a>.  If an ESCAPE clause is present, it adds
+a third parameter to the function call. If the functionality of LIKE can be
+overridden by defining an alternative implementation of the
+like() SQL function.</p>
+</p>
+
+<a name="glob"></a>
+<p>The GLOB operator is similar to LIKE but uses the Unix
+file globbing syntax for its wildcards.  Also, GLOB is case
+sensitive, unlike LIKE.  Both GLOB and LIKE may be preceded by
+the NOT keyword to invert the sense of the test.  The infix GLOB 
+operator is implemented by calling the user function <a href="#globFunc">
+glob(<i>X</i>,<i>Y</i>)</a> and can be modified by overriding
+that function.</p>
+
+<a name="regexp"></a>
+<p>The REGEXP operator is a special syntax for the regexp()
+user function.  No regexp() user function is defined by default
+and so use of the REGEXP operator will normally result in an
+error message.  If a user-defined function named "regexp"
+is added at run-time, that function will be called in order
+to implement the REGEXP operator.</p>
+
+<a name="match"></a>
+<p>The MATCH operator is a special syntax for the match()
+user function.  The default match() function implementation
+raises and exception and is not really useful for anything.
+But extensions can override the match() function with more
+helpful logic.</p>
+
+<p>A column name can be any of the names defined in the CREATE TABLE
+statement or one of the following special identifiers: "<b>ROWID</b>",
+"<b>OID</b>", or "<b>_ROWID_</b>".
+These special identifiers all describe the
+unique integer key (the "row key") associated with every 
+row of every table.
+The special identifiers only refer to the row key if the CREATE TABLE
+statement does not define a real column with the same name.  Row keys
+act like read-only columns.  A row key can be used anywhere a regular
+column can be used, except that you cannot change the value
+of a row key in an UPDATE or INSERT statement.
+"SELECT * ..." does not return the row key.</p>
+
+<p>SELECT statements can appear in expressions as either the
+right-hand operand of the IN operator, as a scalar quantity, or
+as the operand of an EXISTS operator.
+As a scalar quantity or the operand of an IN operator,
+the SELECT should have only a single column in its
+result.  Compound SELECTs (connected with keywords like UNION or
+EXCEPT) are allowed.
+With the EXISTS operator, the columns in the result set of the SELECT are
+ignored and the expression returns TRUE if one or more rows exist
+and FALSE if the result set is empty.
+If no terms in the SELECT expression refer to value in the containing
+query, then the expression is evaluated once prior to any other
+processing and the result is reused as necessary.  If the SELECT expression
+does contain variables from the outer query, then the SELECT is reevaluated
+every time it is needed.</p>
+
+<p>When a SELECT is the right operand of the IN operator, the IN
+operator returns TRUE if the result of the left operand is any of
+the values generated by the select.  The IN operator may be preceded
+by the NOT keyword to invert the sense of the test.</p>
+
+<p>When a SELECT appears within an expression but is not the right
+operand of an IN operator, then the first row of the result of the
+SELECT becomes the value used in the expression.  If the SELECT yields
+more than one result row, all rows after the first are ignored.  If
+the SELECT yields no rows, then the value of the SELECT is NULL.</p>
+
+<p>A CAST expression changes the datatype of the <expr> into the
+type specified by &lt;type&gt;. 
+&lt;type&gt; can be any non-empty type name that is valid
+for the type in a column definition of a CREATE TABLE statement.</p>
+
+<p>Both simple and aggregate functions are supported.  A simple
+function can be used in any expression.  Simple functions return
+a result immediately based on their inputs.  Aggregate functions
+may only be used in a SELECT statement.  Aggregate functions compute
+their result across all rows of the result set.</p>
+
+<a name="corefunctions"></a>
+<b>Core Functions</b>
+
+<p>The core functions shown below are available by default.  Additional
+functions may be written in C and added to the database engine using
+the <a href="capi3ref.html#cfunc">sqlite3_create_function()</a>
+API.</p>
+
+<table border=0 cellpadding=10 class="pdf_functions">
+<tr>
+<td valign="top" align="right" width=120>abs(<i>X</i>)</td>
+<td valign="top">Return the absolute value of argument <i>X</i>.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">coalesce(<i>X</i>,<i>Y</i>,...)</td>
+<td valign="top">Return a copy of the first non-NULL argument.  If
+all arguments are NULL then NULL is returned.  There must be at least 
+2 arguments.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="globFunc"></a>
+glob(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">This function is used to implement the
+"<b>X GLOB Y</b>" syntax of SQLite.  The
+<a href="capi3ref.html#sqlite3_create_function">sqlite3_create_function()</a> 
+interface can
+be used to override this function and thereby change the operation
+of the <a href="#globFunc">GLOB</a> operator.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">ifnull(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return a copy of the first non-NULL argument.  If
+both arguments are NULL then NULL is returned. This behaves the same as 
+<b>coalesce()</b> above.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="hexFunc">
+hex(<i>X</i>)</td>
+<td valign="top">The argument is interpreted as a BLOB.  The result
+is a hexadecimal rendering of the content of that blob.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">last_insert_rowid()</td>
+<td valign="top">Return the <a href="lang_createtable.html#rowid">ROWID</a>
+of the last row insert from this
+connection to the database.  This is the same value that would be returned
+from the <b>sqlite_last_insert_rowid()</b> API function.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">length(<i>X</i>)</td>
+<td valign="top">Return the string length of <i>X</i> in characters.
+If SQLite is configured to support UTF-8, then the number of UTF-8
+characters is returned, not the number of bytes.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="likeFunc"></a>
+like(<i>X</i>,<i>Y</i>)<br>
+like(<i>X</i>,<i>Y</i>,<i>Z</i>)</td>
+<td valign="top">
+This function is used to implement the "<b>X LIKE Y [ESCAPE Z]</b>"
+syntax of SQL. If the optional ESCAPE clause is present, then the
+user-function is invoked with three arguments. Otherwise, it is
+invoked with two arguments only. The 
+<a href="capi3ref.html#sqlite3_create_function">
+sqlite_create_function()</a> interface can be used to override this
+function and thereby change the operation of the <a
+href= "#like">LIKE</a> operator. When doing this, it may be important
+to override both the two and three argument versions of the like() 
+function. Otherwise, different code may be called to implement the
+LIKE operator depending on whether or not an ESCAPE clause was 
+specified.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">load_extension(<i>X</i>)<br>
+load_extension(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Load SQLite extensions out of the shared library
+file named <i>X</i> using the entry point <i>Y</i>.  The result
+is a NULL.  If <i>Y</i> is omitted then the default entry point
+of <b>sqlite3_extension_init</b> is used.  This function raises
+an exception if the extension fails to load or initialize correctly.
+
+<p>This function will fail if the extension attempts to modify
+or delete a SQL function or collating sequence.  The
+extension can add new functions or collating sequences, but cannot
+modify or delete existing functions or collating sequences because
+those functions and/or collating sequences might be used elsewhere
+in the currently running SQL statement.  To load an extension that
+changes or deletes functions or collating sequences, use the
+<a href="capi3ref.html#sqlite3_load_extension">sqlite3_load_extension()</a>
+C-language API.</p>
+</tr>
+
+<tr>
+<td valign="top" align="right">lower(<i>X</i>)</td>
+<td valign="top">Return a copy of string <i>X</i> will all characters
+converted to lower case.  The C library <b>tolower()</b> routine is used
+for the conversion, which means that this function might not
+work correctly on UTF-8 characters.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="ltrimFunc">
+ltrim(<i>X</i>)<br>ltrim(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return a string formed by removing any and all
+characters that appear in <i>Y</i> from the left side of <i>X</i>.
+If the <i>Y</i> argument is omitted, spaces are removed.</td>
+</tr>
+
+
+<tr>
+<td valign="top" align="right">max(<i>X</i>,<i>Y</i>,...)</td>
+<td valign="top">Return the argument with the maximum value.  Arguments
+may be strings in addition to numbers.  The maximum value is determined
+by the usual sort order.  Note that <b>max()</b> is a simple function when
+it has 2 or more arguments but converts to an aggregate function if given
+only a single argument.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">min(<i>X</i>,<i>Y</i>,...)</td>
+<td valign="top">Return the argument with the minimum value.  Arguments
+may be strings in addition to numbers.  The minimum value is determined
+by the usual sort order.  Note that <b>min()</b> is a simple function when
+it has 2 or more arguments but converts to an aggregate function if given
+only a single argument.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">nullif(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return the first argument if the arguments are different, 
+otherwise return NULL.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">quote(<i>X</i>)</td>
+<td valign="top">This routine returns a string which is the value of
+its argument suitable for inclusion into another SQL statement.
+Strings are surrounded by single-quotes with escapes on interior quotes
+as needed.  BLOBs are encoded as hexadecimal literals.
+The current implementation of VACUUM uses this function.  The function
+is also useful when writing triggers to implement undo/redo functionality.
+</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">random(*)</td>
+<td valign="top">Return a pseudo-random integer
+between -9223372036854775808 and +9223372036854775807.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="replaceFunc">
+replace(<i>X</i>,<i>Y</i>,<i>Z</i>)</td>
+<td valign="top">Return a string formed by substituting string <i>Z</i> for
+every occurrance of string <i>Y</i> in string <i>X</i>.  The BINARY
+collating sequence is used for comparisons.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="randomblobFunc">
+randomblob(<i>N</i>)</td>
+<td valign="top">Return a <i>N</i>-byte blob containing pseudo-random bytes.
+<i>N</i> should be a postive integer.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">round(<i>X</i>)<br>round(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Round off the number <i>X</i> to <i>Y</i> digits to the
+right of the decimal point.  If the <i>Y</i> argument is omitted, 0 is 
+assumed.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="rtrimFunc">
+rtrim(<i>X</i>)<br>rtrim(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return a string formed by removing any and all
+characters that appear in <i>Y</i> from the right side of <i>X</i>.
+If the <i>Y</i> argument is omitted, spaces are removed.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">soundex(<i>X</i>)</td>
+<td valign="top">Compute the soundex encoding of the string <i>X</i>.
+The string "?000" is returned if the argument is NULL.
+This function is omitted from SQLite by default.
+It is only available the -DSQLITE_SOUNDEX=1 compiler option
+is used when SQLite is built.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">sqlite_version(*)</td>
+<td valign="top">Return the version string for the SQLite library
+that is running.  Example:  "2.8.0"</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+  substr(<i>X</i>,<i>Y</i>,<i>Z</i>)<br>
+  substr(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return a substring of input string <i>X</i> that begins
+with the <i>Y</i>-th character and which is <i>Z</i> characters long.
+If <i>Z</i> is omitted then all character through the end of the string
+are returned.
+The left-most character of <i>X</i> is number 1.  If <i>Y</i> is negative
+the the first character of the substring is found by counting from the
+right rather than the left.  If <i>X</i> is string
+then characters indices refer to actual UTF-8 characters.  If
+<i>X</i> is a BLOB then the indices refer to bytes.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">
+<a name="trimFunc">
+trim(<i>X</i>)<br>trim(<i>X</i>,<i>Y</i>)</td>
+<td valign="top">Return a string formed by removing any and all
+characters that appear in <i>Y</i> from both ends of <i>X</i>.
+If the <i>Y</i> argument is omitted, spaces are removed.</td>
+</tr>
+
+
+<tr>
+<td valign="top" align="right">typeof(<i>X</i>)</td>
+<td valign="top">Return the type of the expression <i>X</i>.  The only 
+return values are "null", "integer", "real", "text", and "blob".
+SQLite's type handling is 
+explained in <a href="datatype3.html">Datatypes in SQLite Version 3</a>.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">upper(<i>X</i>)</td>
+<td valign="top">Return a copy of input string <i>X</i> converted to all
+upper-case letters.  The implementation of this function uses the C library
+routine <b>toupper()</b> which means it may not work correctly on 
+UTF-8 strings.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">zeroblob(<i>N</i>)</td>
+<td valign="top"><a name="zeroblob">
+Return a BLOB consisting of N bytes of 0x00.  SQLite
+manages these zeroblobs very efficiently.  Zeroblobs can be used to
+reserve space for a BLOB that is later written using 
+<a href="capi3ref.html#sqlite3_blob_open">incremental BLOB I/O</a>.</td>
+</tr>
+
+</table>
+
+<b>Date And Time Functions</b>
+
+<p>Date and time functions are documented in the 
+<a href="http://www.sqlite.org/cvstrac/wiki?p=DateAndTimeFunctions">
+SQLite Wiki</a>.</p>
+
+<a name="aggregatefunctions"></a>
+<b>Aggregate Functions</b>
+
+<p>
+The aggregate functions shown below are available by default.  Additional
+aggregate functions written in C may be added using the 
+<a href="capi3ref.html#sqlite3_create_function">sqlite3_create_function()</a>
+API.</p>
+
+<p>
+In any aggregate function that takes a single argument, that argument
+can be preceeded by the keyword DISTINCT.  In such cases, duplicate
+elements are filtered before being passed into the aggregate function.
+For example, the function "count(distinct X)" will return the number
+of distinct values of column X instead of the total number of non-null
+values in column X.
+</p>
+
+<table border=0 cellpadding=10 class="pdf_functions">
+<tr>
+<td valign="top" align="right" width=120>avg(<i>X</i>)</td>
+<td valign="top">Return the average value of all non-NULL <i>X</i> within a
+group.  String and BLOB values that do not look like numbers are
+interpreted as 0.
+The result of avg() is always a floating point value even if all
+inputs are integers. </p></td>
+</tr>
+
+<tr>
+<td valign="top" align="right">count(<i>X</i>)<br>count(*)</td>
+<td valign="top">The first form return a count of the number of times
+that <i>X</i> is not NULL in a group.  The second form (with no argument)
+returns the total number of rows in the group.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">max(<i>X</i>)</td>
+<td valign="top">Return the maximum value of all values in the group.
+The usual sort order is used to determine the maximum.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">min(<i>X</i>)</td>
+<td valign="top">Return the minimum non-NULL value of all values in the group.
+The usual sort order is used to determine the minimum.  NULL is only returned
+if all values in the group are NULL.</td>
+</tr>
+
+<tr>
+<td valign="top" align="right">sum(<i>X</i>)<br>total(<i>X</i>)</td>
+<td valign="top">Return the numeric sum of all non-NULL values in the group.
+   If there are no non-NULL input rows then sum() returns
+   NULL but total() returns 0.0.
+   NULL is not normally a helpful result for the sum of no rows
+   but the SQL standard requires it and most other
+   SQL database engines implement sum() that way so SQLite does it in the
+   same way in order to be compatible.   The non-standard total() function
+   is provided as a convenient way to work around this design problem
+   in the SQL language.</p>
+
+   <p>The result of total() is always a floating point value.
+   The result of sum() is an integer value if all non-NULL inputs are integers.
+   If any input to sum() is neither an integer or a NULL
+   then sum() returns a floating point value
+   which might be an approximation to the true sum.</p>
+
+   <p>Sum() will throw an "integer overflow" exception if all inputs
+   are integers or NULL
+   and an integer overflow occurs at any point during the computation.
+   Total() never throws an exception.</p>
+</tr>
+</table>
+}
+
+
+Section INSERT insert
+
+Syntax {sql-statement} {
+INSERT [OR <conflict-algorithm>] INTO [<database-name> .] <table-name> [(<column-list>)] VALUES(<value-list>) |
+INSERT [OR <conflict-algorithm>] INTO [<database-name> .] <table-name> [(<column-list>)] <select-statement>
+}
+
+puts {
+<p>The INSERT statement comes in two basic forms.  The first form
+(with the "VALUES" keyword) creates a single new row in an existing table.
+If no column-list is specified then the number of values must
+be the same as the number of columns in the table.  If a column-list
+is specified, then the number of values must match the number of
+specified columns.  Columns of the table that do not appear in the
+column list are filled with the default value, or with NULL if no
+default value is specified.
+</p>
+
+<p>The second form of the INSERT statement takes it data from a
+SELECT statement.  The number of columns in the result of the
+SELECT must exactly match the number of columns in the table if
+no column list is specified, or it must match the number of columns
+name in the column list.  A new entry is made in the table
+for every row of the SELECT result.  The SELECT may be simple
+or compound.</p>
+
+<p>The optional conflict-clause allows the specification of an alternative
+constraint conflict resolution algorithm to use during this one command.
+See the section titled
+<a href="#conflict">ON CONFLICT</a> for additional information.
+For compatibility with MySQL, the parser allows the use of the
+single keyword <a href="#replace">REPLACE</a> as an alias for "INSERT OR REPLACE".
+</p>
+}
+
+
+Section {ON CONFLICT clause} conflict
+
+Syntax {conflict-clause} {
+ON CONFLICT <conflict-algorithm>
+} {conflict-algorithm} {
+ROLLBACK | ABORT | FAIL | IGNORE | REPLACE
+}
+
+puts {
+<p>The ON CONFLICT clause is not a separate SQL command.  It is a
+non-standard clause that can appear in many other SQL commands.
+It is given its own section in this document because it is not
+part of standard SQL and therefore might not be familiar.</p>
+
+<p>The syntax for the ON CONFLICT clause is as shown above for
+the CREATE TABLE command.  For the INSERT and
+UPDATE commands, the keywords "ON CONFLICT" are replaced by "OR", to make
+the syntax seem more natural.  For example, instead of
+"INSERT ON CONFLICT IGNORE" we have "INSERT OR IGNORE".
+The keywords change but the meaning of the clause is the same
+either way.</p>
+
+<p>The ON CONFLICT clause specifies an algorithm used to resolve
+constraint conflicts.  There are five choices: ROLLBACK, ABORT,
+FAIL, IGNORE, and REPLACE. The default algorithm is ABORT.  This
+is what they mean:</p>
+
+<dl>
+<dt><b>ROLLBACK</b></dt>
+<dd><p>When a constraint violation occurs, an immediate ROLLBACK
+occurs, thus ending the current transaction, and the command aborts
+with a return code of SQLITE_CONSTRAINT.  If no transaction is
+active (other than the implied transaction that is created on every
+command) then this algorithm works the same as ABORT.</p></dd>
+
+<dt><b>ABORT</b></dt>
+<dd><p>When a constraint violation occurs, the command backs out
+any prior changes it might have made and aborts with a return code
+of SQLITE_CONSTRAINT.  But no ROLLBACK is executed so changes
+from prior commands within the same transaction
+are preserved.  This is the default behavior.</p></dd>
+
+<dt><b>FAIL</b></dt>
+<dd><p>When a constraint violation occurs, the command aborts with a
+return code SQLITE_CONSTRAINT.  But any changes to the database that
+the command made prior to encountering the constraint violation
+are preserved and are not backed out.  For example, if an UPDATE
+statement encountered a constraint violation on the 100th row that
+it attempts to update, then the first 99 row changes are preserved
+but changes to rows 100 and beyond never occur.</p></dd>
+
+<dt><b>IGNORE</b></dt>
+<dd><p>When a constraint violation occurs, the one row that contains
+the constraint violation is not inserted or changed.  But the command
+continues executing normally.  Other rows before and after the row that
+contained the constraint violation continue to be inserted or updated
+normally.  No error is returned.</p></dd>
+
+<dt><b>REPLACE</b></dt>
+<dd><p>When a UNIQUE constraint violation occurs, the pre-existing rows
+that are causing the constraint violation are removed prior to inserting
+or updating the current row.  Thus the insert or update always occurs.
+The command continues executing normally.  No error is returned.
+If a NOT NULL constraint violation occurs, the NULL value is replaced
+by the default value for that column.  If the column has no default
+value, then the ABORT algorithm is used.  If a CHECK constraint violation
+occurs then the IGNORE algorithm is used.</p>
+
+<p>When this conflict resolution strategy deletes rows in order to
+satisfy a constraint, it does not invoke delete triggers on those
+rows.  This behavior might change in a future release.</p>
+</dl>
+
+<p>The algorithm specified in the OR clause of a INSERT or UPDATE
+overrides any algorithm specified in a CREATE TABLE.
+If no algorithm is specified anywhere, the ABORT algorithm is used.</p>
+}
+
+Section REINDEX reindex
+
+Syntax {sql-statement} {
+  REINDEX <collation name>
+}
+Syntax {sql-statement} {
+  REINDEX [<database-name> .] <table/index-name>
+}
+
+puts {
+<p>The REINDEX command is used to delete and recreate indices from scratch.
+This is useful when the definition of a collation sequence has changed.
+</p>
+
+<p>In the first form, all indices in all attached databases that use the
+named collation sequence are recreated. In the second form, if 
+<i>[database-name.]table/index-name</i> identifies a table, then all indices
+associated with the table are rebuilt. If an index is identified, then only
+this specific index is deleted and recreated.
+</p>
+
+<p>If no <i>database-name</i> is specified and there exists both a table or
+index and a collation sequence of the specified name, then indices associated
+with the collation sequence only are reconstructed. This ambiguity may be
+dispelled by always specifying a <i>database-name</i> when reindexing a
+specific table or index.
+}
+
+Section REPLACE replace
+
+Syntax {sql-statement} {
+REPLACE INTO [<database-name> .] <table-name> [( <column-list> )] VALUES ( <value-list> ) |
+REPLACE INTO [<database-name> .] <table-name> [( <column-list> )] <select-statement>
+}
+
+puts {
+<p>The REPLACE command is an alias for the "INSERT OR REPLACE" variant
+of the <a href="#insert">INSERT</a> command.  This alias is provided for
+compatibility with MySQL.  See the 
+<a href="#insert">INSERT</a> command documentation for additional
+information.</p>  
+}
+
+
+Section SELECT select
+
+Syntax {sql-statement} {
+SELECT [ALL | DISTINCT] <result> [FROM <table-list>]
+[WHERE <expr>]
+[GROUP BY <expr-list>]
+[HAVING <expr>]
+[<compound-op> <select>]*
+[ORDER BY <sort-expr-list>]
+[LIMIT <integer> [LP OFFSET | , RP <integer>]]
+} {result} {
+<result-column> [, <result-column>]*
+} {result-column} {
+STAR | <table-name> . STAR | <expr> [ [AS] <string> ]
+} {table-list} {
+<table> [<join-op> <table> <join-args>]*
+} {table} {
+<table-name> [AS <alias>] |
+( <select> ) [AS <alias>]
+} {join-op} {
+, | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN
+} {join-args} {
+[ON <expr>] [USING ( <id-list> )]
+} {sort-expr-list} {
+<expr> [<sort-order>] [, <expr> [<sort-order>]]*
+} {sort-order} {
+[ COLLATE <collation-name> ] [ ASC | DESC ]
+} {compound_op} {
+UNION | UNION ALL | INTERSECT | EXCEPT
+}
+
+puts {
+<p>The SELECT statement is used to query the database.  The
+result of a SELECT is zero or more rows of data where each row
+has a fixed number of columns.  The number of columns in the
+result is specified by the expression list in between the
+SELECT and FROM keywords.  Any arbitrary expression can be used
+as a result.  If a result expression is }
+puts "[Operator *] then all columns of all tables are substituted"
+puts {for that one expression.  If the expression is the name of}
+puts "a table followed by [Operator .*] then the result is all columns"
+puts {in that one table.</p>
+
+<p>The DISTINCT keyword causes a subset of result rows to be returned, 
+in which each result row is different.  NULL values are not treated as 
+distinct from each other.  The default behavior is that all result rows 
+be returned, which can be made explicit with the keyword ALL.</p>
+
+<p>The query is executed against one or more tables specified after
+the FROM keyword.  If multiple tables names are separated by commas,
+then the query is against the cross join of the various tables.
+The full SQL-92 join syntax can also be used to specify joins.
+A sub-query
+in parentheses may be substituted for any table name in the FROM clause.
+The entire FROM clause may be omitted, in which case the result is a
+single row consisting of the values of the expression list.
+</p>
+
+<p>The WHERE clause can be used to limit the number of rows over
+which the query operates.</p>
+
+<p>The GROUP BY clauses causes one or more rows of the result to
+be combined into a single row of output.  This is especially useful
+when the result contains aggregate functions.  The expressions in
+the GROUP BY clause do <em>not</em> have to be expressions that
+appear in the result.  The HAVING clause is similar to WHERE except
+that HAVING applies after grouping has occurred.  The HAVING expression
+may refer to values, even aggregate functions, that are not in the result.</p>
+
+<p>The ORDER BY clause causes the output rows to be sorted.  
+The argument to ORDER BY is a list of expressions that are used as the
+key for the sort.  The expressions do not have to be part of the
+result for a simple SELECT, but in a compound SELECT each sort
+expression must exactly match one of the result columns.  Each
+sort expression may be optionally followed by a COLLATE keyword and
+the name of a collating function used for ordering text and/or
+keywords ASC or DESC to specify the sort order.</p>
+
+<p>The LIMIT clause places an upper bound on the number of rows
+returned in the result.  A negative LIMIT indicates no upper bound.
+The optional OFFSET following LIMIT specifies how many
+rows to skip at the beginning of the result set.
+In a compound query, the LIMIT clause may only appear on the
+final SELECT statement.
+The limit is applied to the entire query not
+to the individual SELECT statement to which it is attached.
+Note that if the OFFSET keyword is used in the LIMIT clause, then the
+limit is the first number and the offset is the second number.  If a
+comma is used instead of the OFFSET keyword, then the offset is the
+first number and the limit is the second number.  This seeming
+contradition is intentional - it maximizes compatibility with legacy
+SQL database systems.
+</p>
+
+<p>A compound SELECT is formed from two or more simple SELECTs connected
+by one of the operators UNION, UNION ALL, INTERSECT, or EXCEPT.  In
+a compound SELECT, all the constituent SELECTs must specify the
+same number of result columns.  There may be only a single ORDER BY
+clause at the end of the compound SELECT.  The UNION and UNION ALL
+operators combine the results of the SELECTs to the right and left into
+a single big table.  The difference is that in UNION all result rows
+are distinct where in UNION ALL there may be duplicates.
+The INTERSECT operator takes the intersection of the results of the
+left and right SELECTs.  EXCEPT takes the result of left SELECT after
+removing the results of the right SELECT.  When three or more SELECTs
+are connected into a compound, they group from left to right.</p>
+}
+
+
+Section UPDATE update
+
+Syntax {sql-statement} {
+UPDATE [ OR <conflict-algorithm> ] [<database-name> .] <table-name>
+SET <assignment> [, <assignment>]*
+[WHERE <expr>]
+} {assignment} {
+<column-name> = <expr>
+}
+
+puts {
+<p>The UPDATE statement is used to change the value of columns in 
+selected rows of a table.  Each assignment in an UPDATE specifies
+a column name to the left of the equals sign and an arbitrary expression
+to the right.  The expressions may use the values of other columns.
+All expressions are evaluated before any assignments are made.
+A WHERE clause can be used to restrict which rows are updated.</p>
+
+<p>The optional conflict-clause allows the specification of an alternative
+constraint conflict resolution algorithm to use during this one command.
+See the section titled
+<a href="#conflict">ON CONFLICT</a> for additional information.</p>
+}
+
+
+Section VACUUM vacuum
+
+Syntax {sql-statement} {
+VACUUM [<index-or-table-name>]
+}
+
+puts {
+<p>The VACUUM command is an SQLite extension modeled after a similar
+command found in PostgreSQL.  If VACUUM is invoked with the name of a
+table or index then it is suppose to clean up the named table or index.
+In version 1.0 of SQLite, the VACUUM command would invoke 
+<b>gdbm_reorganize()</b> to clean up the backend database file.</p>
+
+<p>
+VACUUM became a no-op when the GDBM backend was removed from
+SQLITE in version 2.0.0.
+VACUUM was reimplemented in version 2.8.1.
+The index or table name argument is now ignored.
+</p>
+
+<p>When an object (table, index, or trigger) is dropped from the 
+database, it leaves behind empty space.  This makes the database 
+file larger than it needs to be, but can speed up inserts.  In time 
+inserts and deletes can leave the database file structure fragmented, 
+which slows down disk access to the database contents.
+
+The VACUUM command cleans
+the main database by copying its contents to a temporary database file and 
+reloading the original database file from the copy.  This eliminates 
+free pages,  aligns table data to be contiguous, and otherwise cleans 
+up the database file structure.</p>
+
+<p>The VACUUM command may change the 
+<a href="lang_createtable.html#rowid">ROWID</a> of entires in tables that do
+not have an explicit INTEGER PRIMARY KEY.</p>
+
+<p>VACUUM only works on the main database.
+It is not possible to VACUUM an attached database file.</p>
+
+<p>The VACUUM command will fail if there is an active transaction.
+The VACUUM command is a no-op for in-memory databases.</p>
+
+<p>As of SQLite version 3.1, an alternative to using the VACUUM command
+is auto-vacuum mode, enabled using the 
+<a href="pragma.html#pragma_auto_vacuum">auto_vacuum pragma</a>.
+When auto-vacuum is enabled for a database, large deletes cause
+the size of the database file to shrink.  However, auto-vacuum
+also causes excess fragmentation of the database file.  And auto-vacuum
+does not compact partially filled pages of the database as VACUUM
+does.
+</p>
+}
+
+# A list of keywords.  A asterisk occurs after the keyword if it is on
+# the fallback list.
+#
+set keyword_list [lsort {
+   ABORT*
+   ADD
+   AFTER*
+   ALL
+   ALTER
+   ANALYZE*
+   AND
+   AS
+   ASC*
+   ATTACH*
+   AUTOINCREMENT
+   BEFORE*
+   BEGIN*
+   BETWEEN
+   BY
+   CASCADE*
+   CASE
+   CAST*
+   CHECK
+   COLLATE
+   COMMIT
+   CONFLICT*
+   CONSTRAINT
+   CREATE
+   CROSS
+   CURRENT_DATE*
+   CURRENT_TIME*
+   CURRENT_TIMESTAMP*
+   DATABASE*
+   DEFAULT
+   DEFERRED*
+   DEFERRABLE
+   DELETE
+   DESC*
+   DETACH*
+   DISTINCT
+   DROP
+   END*
+   EACH*
+   ELSE
+   ESCAPE
+   EXCEPT
+   EXCLUSIVE*
+   EXPLAIN*
+   FAIL*
+   FOR*
+   FOREIGN
+   FROM
+   FULL
+   GLOB*
+   GROUP
+   HAVING
+   IF*
+   IGNORE*
+   IMMEDIATE*
+   IN
+   INDEX
+   INITIALLY*
+   INNER
+   INSERT
+   INSTEAD*
+   INTERSECT
+   INTO
+   IS
+   ISNULL
+   JOIN
+   KEY*
+   LEFT
+   LIKE*
+   LIMIT
+   MATCH*
+   NATURAL
+   NOT
+   NOTNULL
+   NULL
+   OF*
+   OFFSET*
+   ON
+   OR
+   ORDER
+   OUTER
+   PLAN*
+   PRAGMA*
+   PRIMARY
+   QUERY*
+   RAISE*
+   REFERENCES
+   REINDEX*
+   RENAME*
+   REPLACE*
+   RESTRICT*
+   RIGHT
+   ROLLBACK
+   ROW*
+   SELECT
+   SET
+   TABLE
+   TEMP*
+   TEMPORARY*
+   THEN
+   TO
+   TRANSACTION
+   TRIGGER*
+   UNION
+   UNIQUE
+   UPDATE
+   USING
+   VACUUM*
+   VALUES
+   VIEW*
+   VIRTUAL*
+   WHEN
+   WHERE
+}]
+
+
+
+puts {<DIV class="pdf_section">}
+Section {SQLite Keywords} keywords 
+puts {</DIV>}
+
+puts {
+<p>The SQL standard specifies a huge number of keywords which may not
+be used as the names of tables, indices, columns, databases, user-defined
+functions, collations, virtual table modules, or any other named object.
+The list of keywords is so long that few people can remember them all.
+For most SQL code, your safest bet is to never use any English language
+word as the name of a user-defined object.</p>
+
+<p>If you want to use a keyword as a name, you need to quote it.  There
+are three ways of quoting keywords in SQLite:</p>
+
+<p>
+<blockquote>
+<table class="pdf_functions">
+<tr>	<td valign="top"><b>'keyword'</b></td><td width="20"></td>
+	<td>A keyword in single quotes is interpreted as a literal string
+        if it occurs in a context where a string literal is allowed, otherwise
+	it is understood as an identifier.</td></tr>
+<tr>	<td valign="top"><b>"keyword"</b></td><td></td>
+	<td>A keyword in double-quotes is interpreted as an identifier if
+        it matches a known identifier.  Otherwise it is interpreted as a
+        string literal.</td></tr>
+<tr>	<td valign="top"><b>[keyword]</b></td><td></td>
+	<td>A keyword enclosed in square brackets is always understood as
+        an identifier.  This is not standard SQL.  This quoting mechanism
+        is used by MS Access and SQL Server and is included in SQLite for
+        compatibility.</td></tr>
+</table>
+</blockquote>
+</p>
+
+<p>Quoted keywords are unaesthetic.
+To help you avoid them, SQLite allows many keywords to be used unquoted
+as the names of databases, tables, indices, triggers, views, columns,
+user-defined functions, collations, attached databases, and virtual
+function modules.
+In the list of keywords that follows, those that can be used as identifiers
+are shown in an italic font.  Keywords that must be quoted in order to be
+used as identifiers are shown in bold.</p>
+
+<p>
+SQLite adds new keywords from time to time when it take on new features.
+So to prevent your code from being broken by future enhancements, you should
+normally quote any indentifier that is an English language word, even if
+you do not have to.
+</p>
+
+<p>
+The following are the keywords currently recognized by SQLite:
+</p>
+
+<blockquote>
+<table width="100%" class="pdf_keywords">
+<tr>
+<td align="left" valign="top" width="20%">
+}
+
+set n [llength $keyword_list]
+set nCol 5
+set nRow [expr {($n+$nCol-1)/$nCol}]
+set i 0
+foreach word $keyword_list {
+  if {[string index $word end]=="*"} {
+    set word [string range $word 0 end-1]
+    set font i
+  } else {
+    set font b
+  }
+  if {$i==$nRow} {
+    puts "</td><td valign=\"top\" align=\"left\" width=\"20%\">"
+    set i 1
+  } else {
+    incr i
+  }
+  puts "<$font>$word</$font><br>"
+}
+
+puts {
+</td></tr></table></blockquote>
+
+<h2>Special names</h2>
+
+<p>The following are not keywords in SQLite, but are used as names of 
+system objects.  They can be used as an identifier for a different 
+type of object.</p>
+
+<blockquote class="pdf_keywords"><b>
+  _ROWID_<br>
+  MAIN<br>
+  OID<br>
+  ROWID<br>
+  SQLITE_MASTER<br>
+  SQLITE_SEQUENCE<br>
+  SQLITE_TEMP_MASTER<br>
+  TEMP<br>
+</b></blockquote>
+}
+
+puts {<DIV class="pdf_ignore">}
+footer $rcsid
+if {[string length $outputdir]} {
+  footer $rcsid
+}
+puts {</DIV>}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/limits.tcl b/client/src/thirdparty/sqlite-3.4.2/www/limits.tcl
new file mode 100644
index 0000000..cf85e38
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/limits.tcl
@@ -0,0 +1,318 @@
+#
+# Run this script to generate the limits.html output file
+#
+set rcsid {$Id: limits.tcl,v 1.5 2007/08/09 00:00:26 drh Exp $}
+source common.tcl
+header {Implementation Limits For SQLite}
+puts {
+<h2>Limits In SQLite</h2>
+
+<p>
+"Limits" in the context of this article means sizes or
+quantities that can not be exceeded.  We are concerned
+with things like the maximum number of bytes in a
+BLOB or the maximum number of columns in a table.
+</p>
+
+<p>
+SQLite was originally designed with a policy of avoiding
+arbitrary limits.
+Of course, every program that runs on a machine with finite
+memory and disk space has limits of some kind.  But in SQLite, 
+those limits
+were not well defined.  The policy was that if it would fit
+in memory and you could count it with a 32-bit integer, then
+it should work.
+</p>
+
+<p>
+Unfortunately, the no-limits policy has been shown to create
+problems.  Because the upper bounds were not well
+defined, they were not tested, and bugs (including possible
+security exploits) were often found when pushing SQLite to
+extremes.  For this reason, newer versions of SQLite have
+well-defined limits and those limits are tested as part of
+the test suite.
+</p>
+
+<p>
+This article defines what the limits of SQLite are and how they
+can be customized for specific applications.  The default settings
+for limits are normally quite large and adequate for almost every
+application.  Some applications may what to increase a limit here
+or there, but we expect such needs to be rare.  More commonly,
+an application might want to recompile SQLite with much lower
+limits to avoid excess resource utilization in the event of
+bug in higher-level SQL statement generators or to help thwart 
+attackers who inject malicious SQL statements.
+</p>
+}
+proc limititem {title text} {
+  puts "<li><p><b>$title</b></p>\n$text</li>"
+}
+puts {
+<ol>
+}
+
+limititem {Maximum length of a string or BLOB} {
+<p>
+The maximum number of bytes in a string or BLOB in SQLite is defined
+by the preprocessor macro SQLITE_MAX_LENGTH.  The default value
+of this macro is 1 billion (1 thousand million or 1,000,000,000).
+You can raise or lower this value at compile-time using a command-line 
+option like this:
+</p>
+
+<blockquote>-DSQLITE_MAX_LENGTH=123456789</blockquote>
+
+<p>
+The current implementation will only support a string or BLOB
+length up to 2<small><sup>31</sup></small>-1 or 2147483647.  And
+some built-in functions such as hex() might fail well before that
+point.  In security-sensitive applications it is best not to
+try to increase the maximum string and blob length.  In fact,
+you might do well to lower the maximum string and blob length
+to something more in the range of a few million if that is
+possible.
+</p>
+
+<p>
+During part of SQLite's INSERT and SELECT processing, the complete
+content of each row in the database is encoded as a single BLOB.
+So the SQLITE_MAX_LENGTH parameter also determines the maximum
+number of bytes in a row.
+</p>
+}
+
+limititem {Maximum Number Of Columns} {
+<p>
+The SQLITE_MAX_COLUMN compile-time parameter is used to set an upper
+bound on:
+</p>
+
+<ul>
+<li>The number of columns in a table</li>
+<li>The number of columns in an index</li>
+<li>The number of columns in a view</li>
+<li>The number of terms in the SET clause of an UPDATE statement</li>
+<li>The number of columns in the result set of a SELECT statement</li>
+<li>The number of terms in a GROUP BY or ORDER BY clause</li>
+<li>The number of values in an INSERT statement</li>
+</ul>
+
+<p>
+The default setting for SQLITE_MAX_COLUMN is 2000.  You can change it
+at compile time to values as large as 32676.  You might be able to
+redefine this value to be as large as billions, though nobody has ever
+tried doing that so we do not know if it will work.  On the other hand, there
+are people who will argue that a well-normalized database design
+will never need a value larger than about 100.
+</p>
+
+<p>
+In most applications, the number of columns is small - a few dozen.
+There are places in the SQLite code generator that use algorithms
+that are O(N&sup2;) where N is the number of columns.  
+So if you redefine SQLITE_MAX_COLUMN to be a
+really huge number and you generate SQL that uses a large number of
+columns, you may find that 
+<a href="capi3ref.html#sqlite3_prepare_v2">sqlite3_prepare_v2()</a>
+runs slowly.
+}
+
+limititem {Maximum Length Of An SQL Statement} {
+<p>
+The maximum number of bytes in the text of an SQL statement is 
+limited to SQLITE_MAX_SQL_LENGTH which defaults to 1000000.  You
+can redefine this limit to be as large as the smaller of SQLITE_MAX_LENGTH
+and 1073741824.  
+</p>
+
+<p>
+If an SQL statement is limited to be a million bytes in length, then
+obviously you will not be able to insert multi-million byte strings
+by embedding them as literals inside of INSERT statements.  But
+you should not do that anyway.  Use host parameters 
+for your data.  Prepare short SQL statements like this:
+</p>
+
+<blockquote>
+INSERT INTO tab1 VALUES(?,?,?);
+</blockquote>
+
+<p>
+Then use the
+<a href="capi3ref.html#sqlite3_bind_text">sqlite3_bind_XXXX()</a> functions
+to bind your large string values to the SQL statement.  The use of binding
+obviates the need to escape quote characters in the string, reducing the
+risk of SQL injection attacks.  It is also runs faster since the large
+string does not need to be parsed or copied as much.
+</p>
+}
+
+limititem {Maximum Number Of Tables In A Join} {
+<p>
+SQLite does not support joins containing more than 64 tables.
+This limit arises from the fact that the SQLite code generator
+uses bitmaps with one bit per join-table in the query optimizer.
+</p>
+}
+
+limititem {Maximum Depth Of An Expression Tree} {
+<p>
+SQLite parses expressions into a tree for processing.  During
+code generation, SQLite walks this tree recursively.  The depth
+of expression trees is therefore limited in order to avoid
+using too much stack space.
+</p>
+
+<p>
+The SQLITE_MAX_EXPR_DEPTH parameter determines the maximum expression
+tree depth.  If the value is 0, then no limit is enforced.  The
+current implementation has a default value of 1000.
+</p>
+}
+
+limititem {Maximum Number Of Arguments On A Function} {
+<p>
+The SQLITE_MAX_FUNCTION_ARG parameter determines the maximum number
+of parameters that can be passed to an SQL function.  The default value
+of this limit is 100.  We know of no 
+technical reason why SQLite would not work with functions that have 
+millions of parameters.  However, we suspect that anybody who tries
+to invoke a function with millions of parameters is really
+trying to find security exploits in systems that use SQLite, 
+not do useful work, 
+and so for that reason we have set this parameter relatively low.
+}
+
+limititem {Maximum Number Of Terms In A Compound SELECT Statement} {
+<p>
+A compound SELECT statement is two or more SELECT statements connected
+by operators UNION, UNION ALL, EXCEPT, or INTERSECT.  We call each
+individual SELECT statement within a compound SELECT a "term".
+</p>
+
+<p>
+The code generator in SQLite processes compound SELECT statements using
+a recursive algorithm.  In order to limit the size of the stack, we
+therefore limit the number of terms in a compound SELECT.  The maximum
+number of terms is SQLITE_MAX_COMPOUND_SELECT which defaults to 500.
+We think this is a generous allotment since in practice we almost
+never see the number of terms in a compound select exceed single digits.
+</p>
+}
+
+limititem {Maximum Length Of A LIKE Or GLOB Pattern} {
+<p>
+The pattern matching algorithm used in the default LIKE and GLOB
+implementation of SQLite can exhibit O(N&sup2) performance (where
+N is the number of characters in the pattern) for certain pathological
+cases.  To avoid denial-of-service attacks from miscreants who are able
+to specify their own LIKE or GLOB patterns, the length of the LIKE
+or GLOB pattern is limited to SQLITE_MAX_LIKE_PATTERN_LENGTH bytes.
+The default value of this limit is 50000.  A modern workstation can
+evaluate even a pathological LIKE or GLOB pattern of 50000 bytes
+relatively quickly.  The denial of service problem only comes into
+play when the pattern length gets into millions of bytes.  Nevertheless,
+since most useful LIKE or GLOB patterns are at most a few dozen bytes
+in length, paranoid application developers may want to reduce this
+parameter to something in the range of a few hundred if they know that
+external users are able to generate arbitrary patterns.
+</p>
+}
+
+limititem {Maximum Number Of Host Parameters In A Single SQL Statement} {
+<p>
+A host parameter is a place-holder in an SQL statement that is filled
+in using one of the
+<a href="capi3ref.html#sqlite3_bind_blob">sqlite3_bind_XXXX()</a> interfaces.
+Many SQL programmers are familiar with using a question mark ("?") as a
+host parameter.  SQLite also supports named host parameters prefaced
+by ":", "$", or "@" and numbered host parameters of the form "?123".
+</p>
+
+<p>
+Each host parameter in an SQLite statement is assigned a number.  The
+numbers normally begin with 1 and increase by one with each new
+parameter.  However, when the "?123" form is used, the host parameter
+number is the number that follows the question mark.
+</p>
+
+<p>
+The maximum value of a host parameter number is SQLITE_MAX_VARIABLE_NUMBER.
+This setting defaults to 999.
+</p>
+}
+
+limititem {Maximum Number Of Attached Databases} {
+<p>
+The <a href="lang_attach.html">ATTACH</a> statement is an SQLite extension
+that allows two or more databases to be associated to the same database
+connection and to operate as if they were a single database.  The number
+of simulataneously attached databases is limited to SQLITE_MAX_ATTACHED
+which is set to 10 by default.
+The code generator in SQLite uses bitmaps
+to keep track of attached databases.  That means that the number of
+attached databases cannot be increased above 30 on a 32-bit machine
+or 62 on a 64-bit machine.
+}
+
+limititem {Maximum Database Page Size} {
+<p>
+An SQLite database file is organized as pages.  The size of each
+page is a power of 2 between 512 and SQLITE_MAX_PAGE_SIZE.
+The default value for SQLITE_MAX_PAGE_SIZE is 32768.  The current
+implementation will not support a larger value.
+</p>
+
+<p>
+It used to be the case that SQLite would allocate some stack
+structures whose size was proportional to the maximum page size.
+For this reason, SQLite would sometimes be compiled with a smaller
+maximum page size on embedded devices with limited stack memory.  But
+more recent versions of SQLite put these large structures on the
+heap, not on the stack, so reducing the maximum page size is no
+longer necessary on embedded devices.
+</p>
+}
+
+limititem {Maximum Number Of Pages In A Database File} {
+<p>
+SQLite is able to limit the size of a database file to prevent
+the database file from growing too large and consuming too much
+disk or flash space.
+The SQLITE_MAX_PAGE_COUNT parameter, which is normally set to
+1073741823, is the maximum number of pages allowed in a single
+database file.  An attempt to insert new data that would cause
+the database file to grow larger than this will return
+SQLITE_FULL.
+</p>
+
+<p>
+The <a href="pragma.html#pragma_max_page_count">
+max_page_count PRAGMA</a> can be used to raise or lower this
+limit at run-time.
+</p>
+
+<p>
+Note that the transaction processing in SQLite requires two bits
+of heap memory for every page in the database file.  For databases
+of a few megabytes in size, this amounts to only a few hundred
+bytes of heap memory.  But for gigabyte-sized databases the amount
+of heap memory required is getting into the kilobyte range and
+for terabyte-sized databases, megabytes of heap memory must be
+allocated and zeroed at each transaction.  SQLite will
+support very large databases in theory, but the current implementation
+is optimized for the common SQLite use cases of embedded devices
+and persistent stores for desktop applications.  In other words,
+SQLite is designed for use with databases sized in kilobytes or 
+megabytes not gigabytes.  If you are building an application to
+work with databases that are hundreds of gigabytes or more 
+in size, then you should perhaps consider using a different database 
+engine that is explicitly designed for such large data sets.
+</p>
+}
+
+puts {</ol>}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/lockingv3.tcl b/client/src/thirdparty/sqlite-3.4.2/www/lockingv3.tcl
new file mode 100644
index 0000000..c51cf79
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/lockingv3.tcl
@@ -0,0 +1,570 @@
+#
+# Run this script to generated a lockingv3.html output file
+#
+set rcsid {$Id: }
+source common.tcl
+header {File Locking And Concurrency In SQLite Version 3}
+
+proc HEADING {level title {label {}}} {
+  global pnum
+  incr pnum($level)
+  foreach i [array names pnum] {
+    if {$i>$level} {set pnum($i) 0}
+  }
+  set h [expr {$level+1}]
+  if {$h>6} {set h 6}
+  set n $pnum(1).$pnum(2)
+  for {set i 3} {$i<=$level} {incr i} {
+    append n .$pnum($i)
+  }
+  if {$label!=""} {
+    puts "<a name=\"$label\">"
+  }
+  puts "<h$h>$n $title</h$h>"
+}
+set pnum(1) 0
+set pnum(2) 0
+set pnum(3) 0
+set pnum(4) 0
+set pnum(5) 0
+set pnum(6) 0
+set pnum(7) 0
+set pnum(8) 0
+
+HEADING 1 {File Locking And Concurrency In SQLite Version 3}
+
+puts {
+<p>Version 3 of SQLite introduces a more complex locking and journaling 
+mechanism designed to improve concurrency and reduce the writer starvation 
+problem.  The new mechanism also allows atomic commits of transactions
+involving multiple database files.
+This document describes the new locking mechanism.
+The intended audience is programmers who want to understand and/or modify
+the pager code and reviewers working to verify the design
+of SQLite version 3.
+</p>
+}
+
+HEADING 1 {Overview} overview
+
+puts {
+<p>
+Locking and concurrency control are handled by the the 
+<a href="http://www.sqlite.org/cvstrac/getfile/sqlite/src/pager.c">
+pager module</a>.
+The pager module is responsible for making SQLite "ACID" (Atomic,
+Consistent, Isolated, and Durable).  The pager module makes sure changes
+happen all at once, that either all changes occur or none of them do,
+that two or more processes do not try to access the database
+in incompatible ways at the same time, and that once changes have been
+written they persist until explicitly deleted.  The pager also provides
+an memory cache of some of the contents of the disk file.</p>
+
+<p>The pager is unconcerned
+with the details of B-Trees, text encodings, indices, and so forth.
+From the point of view of the pager the database consists of
+a single file of uniform-sized blocks.  Each block is called a
+"page" and is usually 1024 bytes in size.   The pages are numbered
+beginning with 1.  So the first 1024 bytes of the database are called
+"page 1" and the second 1024 bytes are call "page 2" and so forth. All 
+other encoding details are handled by higher layers of the library.  
+The pager communicates with the operating system using one of several
+modules 
+(Examples:
+<a href="http://www.sqlite.org/cvstrac/getfile/sqlite/src/os_unix.c">
+os_unix.c</a>,
+<a href="http://www.sqlite.org/cvstrac/getfile/sqlite/src/os_win.c">
+os_win.c</a>)
+that provides a uniform abstraction for operating system services.
+</p>
+
+<p>The pager module effectively controls access for separate threads, or
+separate processes, or both.  Throughout this document whenever the
+word "process" is written you may substitute the word "thread" without
+changing the truth of the statement.</p>
+}
+
+HEADING 1 {Locking} locking
+
+puts {
+<p>
+From the point of view of a single process, a database file
+can be in one of five locking states:
+</p>
+
+<p>
+<table cellpadding="20">
+<tr><td valign="top">UNLOCKED</td>
+<td valign="top">
+No locks are held on the database.  The database may be neither read nor
+written.  Any internally cached data is considered suspect and subject to
+verification against the database file before being used.  Other 
+processes can read or write the database as their own locking states
+permit.  This is the default state.
+</td></tr>
+
+<tr><td valign="top">SHARED</td>
+<td valign="top">
+The database may be read but not written.  Any number of 
+processes can hold SHARED locks at the same time, hence there can be
+many simultaneous readers.  But no other thread or process is allowed
+to write to the database file while one or more SHARED locks are active.
+</td></tr>
+
+<tr><td valign="top">RESERVED</td>
+<td valign="top">
+A RESERVED lock means that the process is planning on writing to the
+database file at some point in the future but that it is currently just
+reading from the file.  Only a single RESERVED lock may be active at one
+time, though multiple SHARED locks can coexist with a single RESERVED lock.
+RESERVED differs from PENDING in that new SHARED locks can be acquired
+while there is a RESERVED lock.
+</td></tr>
+
+<tr><td valign="top">PENDING</td>
+<td valign="top">
+A PENDING lock means that the process holding the lock wants to write
+to the database as soon as possible and is just waiting on all current
+SHARED locks to clear so that it can get an EXCLUSIVE lock.  No new 
+SHARED locks are permitted against the database if
+a PENDING lock is active, though existing SHARED locks are allowed to
+continue.
+</td></tr>
+
+<tr><td valign="top">EXCLUSIVE</td>
+<td valign="top">
+An EXCLUSIVE lock is needed in order to write to the database file.
+Only one EXCLUSIVE lock is allowed on the file and no other locks of
+any kind are allowed to coexist with an EXCLUSIVE lock.  In order to
+maximize concurrency, SQLite works to minimize the amount of time that
+EXCLUSIVE locks are held.
+</td></tr>
+</table>
+</p>
+
+<p>
+The operating system interface layer understands and tracks all five
+locking states described above.  
+The pager module only tracks four of the five locking states.
+A PENDING lock is always just a temporary
+stepping stone on the path to an EXCLUSIVE lock and so the pager module
+does not track PENDING locks.
+</p>
+}
+
+HEADING 1 {The Rollback Journal} rollback
+
+puts {
+<p>Any time a process wants to make a changes to a database file, it
+first records enough information in the <em>rollback journal</em> to
+restore the database file back to its initial condition.  Thus, before
+altering any page of the database, the original contents of that page
+must be written into the journal.  The journal also records the initial
+size of the database so that if the database file grows it can be truncated
+back to its original size on a rollback.</p>
+
+<p>The rollback journal is a ordinary disk file that has the same name as
+the database file with the suffix "<tt>-journal</tt>" added.</p>
+
+<p>If SQLite is working with multiple databases at the same time
+(using the ATTACH command) then each database has its own journal.
+But there is also a separate aggregate journal
+called the <em>master journal</em>.
+The master journal does not contain page data used for rolling back
+changes.  Instead the master journal contains the names of the
+individual file journals for each of the ATTACHed databases.   Each of
+the individual file journals also contain the name of the master journal.
+If there are no ATTACHed databases (or if none of the ATTACHed database
+is participating in the current transaction) no master journal is
+created and the normal rollback journal contains an empty string
+in the place normally reserved for recording the name of the master
+journal.</p>
+
+<p>A individual file journal is said to be <em>hot</em>
+if it needs to be rolled back
+in order to restore the integrity of its database.  
+A hot journal is created when a process is in the middle of a database
+update and a program or operating system crash or power failure prevents 
+the update from completing.
+Hot journals are an exception condition. 
+Hot journals exist to recover from crashes and power failures.
+If everything is working correctly 
+(that is, if there are no crashes or power failures)
+you will never get a hot journal.
+</p>
+
+<p>
+If no master journal is involved, then
+a journal is hot if it exists and its corresponding database file
+does not have a RESERVED lock.
+If a master journal is named in the file journal, then the file journal
+is hot if its master journal exists and there is no RESERVED
+lock on the corresponding database file.
+It is important to understand when a journal is hot so the
+preceding rules will be repeated in bullets:
+</p>
+
+<ul>
+<li>A journal is hot if...
+    <ul>
+    <li>It exists, and</li>
+    <li>It's master journal exists or the master journal name is an
+        empty string, and</li>
+    <li>There is no RESERVED lock on the corresponding database file.</li>
+    </ul>
+</li>
+</ul>
+}
+
+HEADING 2 {Dealing with hot journals} hot_journals
+
+puts {
+<p>
+Before reading from a a database file, SQLite always checks to see if that
+database file has a hot journal.  If the file does have a hot journal, then
+the journal is rolled back before the file is read.  In this way, we ensure
+that the database file is in a consistent state before it is read.
+</p>
+
+<p>When a process wants to read from a database file, it followed
+the following sequence of steps:
+</p>
+
+<ol>
+<li>Open the database file and obtain a SHARED lock.  If the SHARED lock
+    cannot be obtained, fail immediately and return SQLITE_BUSY.</li>
+<li>Check to see if the database file has a hot journal.   If the file
+    does not have a hot journal, we are done.  Return immediately.
+    If there is a hot journal, that journal must be rolled back by
+    the subsequent steps of this algorithm.</li>
+<li>Acquire a PENDING lock then an EXCLUSIVE lock on the database file.
+    (Note: Do not acquire a RESERVED lock because that would make
+    other processes think the journal was no longer hot.)  If we
+    fail to acquire these locks it means another process
+    is already trying to do the rollback.  In that case,
+    drop all locks, close the database, and return SQLITE_BUSY. </li>
+<li>Read the journal file and roll back the changes.</li>
+<li>Wait for the rolled back changes to be written onto 
+    the surface of the disk.  This protects the integrity of the database
+    in case another power failure or crash occurs.</li>
+<li>Delete the journal file.</li>
+<li>Delete the master journal file if it is safe to do so.
+    This step is optional.  It is here only to prevent stale
+    master journals from cluttering up the disk drive.
+    See the discussion below for details.</li>
+<li>Drop the EXCLUSIVE and PENDING locks but retain the SHARED lock.</li>
+</ol>
+
+<p>After the algorithm above completes successfully, it is safe to 
+read from the database file.  Once all reading has completed, the
+SHARED lock is dropped.</p>
+}
+
+HEADING 2 {Deleting stale master journals} stale_master_journals
+
+puts {
+<p>A stale master journal is a master journal that is no longer being
+used for anything.  There is no requirement that stale master journals
+be deleted.  The only reason for doing so is to free up disk space.</p>
+
+<p>A master journal is stale if no individual file journals are pointing
+to it.  To figure out if a master journal is stale, we first read the
+master journal to obtain the names of all of its file journals.  Then
+we check each of those file journals.  If any of the file journals named
+in the master journal exists and points back to the master journal, then
+the master journal is not stale.  If all file journals are either missing
+or refer to other master journals or no master journal at all, then the
+master journal we are testing is stale and can be safely deleted.</p>
+}
+
+HEADING 1 {Writing to a database file} writing
+
+puts {
+<p>To write to a database, a process must first acquire a SHARED lock
+as described above (possibly rolling back incomplete changes if there
+is a hot journal). 
+After a SHARED lock is obtained, a RESERVED lock must be acquired.
+The RESERVED lock signals that the process intends to write to the
+database at some point in the future.  Only one process at a time
+can hold a RESERVED lock.  But other processes can continue to read
+the database while the RESERVED lock is held.
+</p>
+
+<p>If the process that wants to write is unable to obtain a RESERVED
+lock, it must mean that another process already has a RESERVED lock.
+In that case, the write attempt fails and returns SQLITE_BUSY.</p>
+
+<p>After obtaining a RESERVED lock, the process that wants to write
+creates a rollback journal.  The header of the journal is initialized
+with the original size of the database file.  Space in the journal header
+is also reserved for a master journal name, though the master journal
+name is initially empty.</p>
+
+<p>Before making changes to any page of the database, the process writes
+the original content of that page into the rollback journal.  Changes
+to pages are held in memory at first and are not written to the disk.
+The original database file remains unaltered, which means that other
+processes can continue to read the database.</p>
+
+<p>Eventually, the writing process will want to update the database
+file, either because its memory cache has filled up or because it is
+ready to commit its changes.  Before this happens, the writer must
+make sure no other process is reading the database and that the rollback
+journal data is safely on the disk surface so that it can be used to
+rollback incomplete changes in the event of a power failure.
+The steps are as follows:</p>
+
+<ol>
+<li>Make sure all rollback journal data has actually been written to
+    the surface of the disk (and is not just being held in the operating
+    system's  or disk controllers cache) so that if a power failure occurs
+    the data will still be there after power is restored.</li>
+<li>Obtain a PENDING lock and then an EXCLUSIVE lock on the database file.
+    If other processes are still have SHARED locks, the writer might have
+    to wait until those SHARED locks clear before it is able to obtain
+    an EXCLUSIVE lock.</li>
+<li>Write all page modifications currently held in memory out to the
+    original database disk file.</li>
+</ol>
+
+<p>
+If the reason for writing to the database file is because the memory
+cache was full, then the writer will not commit right away.  Instead,
+the writer might continue to make changes to other pages.  Before 
+subsequent changes are written to the database file, the rollback
+journal must be flushed to disk again.  Note also that the EXCLUSIVE
+lock that the writer obtained in order to write to the database initially
+must be held until all changes are committed.  That means that no other
+processes are able to access the database from the
+time the memory cache first spills to disk until the transaction
+commits.
+</p>
+
+<p>
+When a writer is ready to commit its changes, it executes the following
+steps:
+</p>
+
+<ol>
+<li value="4">
+   Obtain an EXCLUSIVE lock on the database file and
+   make sure all memory changes have been written to the database file
+   using the algorithm of steps 1-3 above.</li>
+<li>Flush all database file changes to the disk.  Wait for those changes
+    to actually be written onto the disk surface.</li>
+<li>Delete the journal file.  This is the instant when the changes are
+    committed.  Prior to deleting the journal file, if a power failure
+    or crash occurs, the next process to open the database will see that
+    it has a hot journal and will roll the changes back.
+    After the journal is deleted, there will no longer be a hot journal
+    and the changes will persist.
+    </li>
+<li>Drop the EXCLUSIVE and PENDING locks from the database file.
+    </li>
+</ol>
+
+<p>As soon as PENDING lock is released from the database file, other
+processes can begin reading the database again.  In the current implementation,
+the RESERVED lock is also released, but that is not essential.  Future
+versions of SQLite might provide a "CHECKPOINT" SQL command that will
+commit all changes made so far within a transaction but retain the
+RESERVED lock so that additional changes can be made without given
+any other process an opportunity to write.</p>
+
+<p>If a transaction involves multiple databases, then a more complex
+commit sequence is used, as follows:</p>
+
+<ol>
+<li value="4">
+   Make sure all individual database files have an EXCLUSIVE lock and a
+   valid journal.
+<li>Create a master-journal.  The name of the master-journal is arbitrary.
+    (The current implementation appends random suffixes to the name of the
+    main database file until it finds a name that does not previously exist.)
+    Fill the master journal with the names of all the individual journals
+    and flush its contents to disk.
+<li>Write the name of the master journal into
+    all individual journals (in space set aside for that purpose in the
+    headers of the individual journals) and flush the contents of the
+    individual journals to disk and wait for those changes to reach the
+    disk surface.
+<li>Flush all database file changes to the disk.  Wait for those changes
+    to actually be written onto the disk surface.</li>
+<li>Delete the master journal file.  This is the instant when the changes are
+    committed.  Prior to deleting the master journal file, if a power failure
+    or crash occurs, the individual file journals will be considered hot
+    and will be rolled back by the next process that
+    attempts to read them.  After the master journal has been deleted,
+    the file journals will no longer be considered hot and the changes
+    will persist.
+    </li>
+<li>Delete all individual journal files.
+<li>Drop the EXCLUSIVE and PENDING locks from all database files.
+    </li>
+</ol>
+}
+
+HEADING 2 {Writer starvation} writer_starvation
+
+puts {
+<p>In SQLite version 2, if many processes are reading from the database,
+it might be the case that there is never a time when there are
+no active readers.  And if there is always at least one read lock on the
+database, no process would ever be able to make changes to the database
+because it would be impossible to acquire a write lock.  This situation
+is called <em>writer starvation</em>.</p>
+
+<p>SQLite version 3 seeks to avoid writer starvation through the use of
+the PENDING lock.  The PENDING lock allows existing readers to continue
+but prevents new readers from connecting to the database.  So when a
+process wants to write a busy database, it can set a PENDING lock which
+will prevent new readers from coming in.  Assuming existing readers do
+eventually complete, all SHARED locks will eventually clear and the
+writer will be given a chance to make its changes.</p>
+}
+
+HEADING 1 {How To Corrupt Your Database Files} how_to_corrupt
+
+puts {
+<p>The pager module is robust but it is not completely failsafe.
+It can be subverted.  This section attempts to identify and explain
+the risks.</p>
+
+<p>
+Clearly, a hardware or operating system fault that introduces incorrect data
+into the middle of the database file or journal will cause problems.
+Likewise, 
+if a rogue process opens a database file or journal and writes malformed
+data into the middle of it, then the database will become corrupt.
+There is not much that can be done about these kinds of problems
+so they are given no further attention.
+</p>
+
+<p>
+SQLite uses POSIX advisory locks to implement locking on Unix.  On
+windows it uses the LockFile(), LockFileEx(), and UnlockFile() system
+calls.  SQLite assumes that these system calls all work as advertised.  If
+that is not the case, then database corruption can result.  One should
+note that POSIX advisory locking is known to be buggy or even unimplemented
+on many NFS implementations (including recent versions of Mac OS X)
+and that there are reports of locking problems
+for network filesystems under windows.  Your best defense is to not
+use SQLite for files on a network filesystem.
+</p>
+
+<p>
+SQLite uses the fsync() system call to flush data to the disk under Unix and
+it uses the FlushFileBuffers() to do the same under windows.  Once again,
+SQLite assumes that these operating system services function as advertised.
+But it has been reported that fsync() and FlushFileBuffers() do not always
+work correctly, especially with inexpensive IDE disks.  Apparently some
+manufactures of IDE disks have defective controller chips that report
+that data has reached the disk surface when in fact the data is still
+in volatile cache memory in the disk drive electronics.  There are also
+reports that windows sometimes chooses to ignore FlushFileBuffers() for
+unspecified reasons.  The author cannot verify any of these reports.
+But if they are true, it means that database corruption is a possibility
+following an unexpected power loss.  These are hardware and/or operating
+system bugs that SQLite is unable to defend against.
+</p>
+
+<p>
+If a crash or power failure occurs and results in a hot journal but that
+journal is deleted, the next process to open the database will not
+know that it contains changes that need to be rolled back.  The rollback
+will not occur and the database will be left in an inconsistent state.
+Rollback journals might be deleted for any number of reasons:
+</p>
+
+<ul>
+<li>An administrator might be cleaning up after an OS crash or power failure,
+    see the journal file, think it is junk, and delete it.</li>
+<li>Someone (or some process) might rename the database file but fail to
+    also rename its associated journal.</li>
+<li>If the database file has aliases (hard or soft links) and the file
+    is opened by a different alias than the one used to create the journal,
+    then the journal will not be found.  To avoid this problem, you should
+    not create links to SQLite database files.</li>
+<li>Filesystem corruption following a power failure might cause the
+    journal to be renamed or deleted.</li>
+</ul>
+
+<p>
+The last (fourth) bullet above merits additional comment.  When SQLite creates
+a journal file on Unix, it opens the directory that contains that file and
+calls fsync() on the directory, in an effort to push the directory information
+to disk.  But suppose some other process is adding or removing unrelated
+files to the directory that contains the database and journal at the the
+moment of a power failure.  The supposedly unrelated actions of this other
+process might result in the journal file being dropped from the directory and
+moved into "lost+found".  This is an unlikely scenario, but it could happen.
+The best defenses are to use a journaling filesystem or to keep the
+database and journal in a directory by themselves.
+</p>
+
+<p>
+For a commit involving multiple databases and a master journal, if the
+various databases were on different disk volumes and a power failure occurs
+during the commit, then when the machine comes back up the disks might
+be remounted with different names.  Or some disks might not be mounted
+at all.   When this happens the individual file journals and the master
+journal might not be able to find each other. The worst outcome from
+this scenario is that the commit ceases to be atomic.  
+Some databases might be rolled back and others might not. 
+All databases will continue to be self-consistent.
+To defend against this problem, keep all databases
+on the same disk volume and/or remount disks using exactly the same names
+after a power failure.
+</p>
+}
+
+HEADING 1 {Transaction Control At The SQL Level} transaction_control
+
+puts {
+<p>
+The changes to locking and concurrency control in SQLite version 3 also
+introduce some subtle changes in the way transactions work at the SQL
+language level.
+By default, SQLite version 3 operates in <em>autocommit</em> mode.
+In autocommit mode,
+all changes to the database are committed as soon as all operations associated
+with the current database connection complete.</p>
+
+<p>The SQL command "BEGIN TRANSACTION" (the TRANSACTION keyword
+is optional) is used to take SQLite out of autocommit mode.
+Note that the BEGIN command does not acquire any locks on the database.
+After a BEGIN command, a SHARED lock will be acquired when the first
+SELECT statement is executed.  A RESERVED lock will be acquired when
+the first INSERT, UPDATE, or DELETE statement is executed.  No EXCLUSIVE
+lock is acquired until either the memory cache fills up and must
+be spilled to disk or until the transaction commits.  In this way,
+the system delays blocking read access to the file file until the
+last possible moment.
+</p>
+
+<p>The SQL command "COMMIT"  does not actually commit the changes to
+disk.  It just turns autocommit back on.  Then, at the conclusion of
+the command, the regular autocommit logic takes over and causes the
+actual commit to disk to occur.
+The SQL command "ROLLBACK" also operates by turning autocommit back on,
+but it also sets a flag that tells the autocommit logic to rollback rather
+than commit.</p>
+
+<p>If the SQL COMMIT command turns autocommit on and the autocommit logic
+then tries to commit change but fails because some other process is holding
+a SHARED lock, then autocommit is turned back off automatically.  This
+allows the user to retry the COMMIT at a later time after the SHARED lock
+has had an opportunity to clear.</p>
+
+<p>If multiple commands are being executed against the same SQLite database
+connection at the same time, the autocommit is deferred until the very
+last command completes.  For example, if a SELECT statement is being
+executed, the execution of the command will pause as each row of the
+result is returned.  During this pause other INSERT, UPDATE, or DELETE
+commands can be executed against other tables in the database.  But none
+of these changes will commit until the original SELECT statement finishes.
+</p>
+}
+
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/mingw.tcl b/client/src/thirdparty/sqlite-3.4.2/www/mingw.tcl
new file mode 100644
index 0000000..f1a0186
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/mingw.tcl
@@ -0,0 +1,160 @@
+#
+# Run this Tcl script to generate the mingw.html file.
+#
+set rcsid {$Id: mingw.tcl,v 1.4 2003/03/30 18:58:58 drh Exp $}
+
+puts {<html>
+<head>
+  <title>Notes On How To Build MinGW As A Cross-Compiler</title>
+</head>
+<body bgcolor=white>
+<h1 align=center>
+Notes On How To Build MinGW As A Cross-Compiler
+</h1>}
+puts "<p align=center>
+(This page was last modified on [lrange $rcsid 3 4] UTC)
+</p>"
+
+puts {
+<p><a href="http://www.mingw.org/">MinGW</a> or
+<a href="http://www.mingw.org/">Minimalist GNU For Windows</a>
+is a version of the popular GCC compiler that builds Win95/Win98/WinNT
+binaries.  See the website for details.</p>
+
+<p>This page describes how you can build MinGW 
+from sources as a cross-compiler
+running under Linux.  Doing so will allow you to construct
+WinNT binaries from the comfort and convenience of your
+Unix desktop.</p>
+}
+
+proc Link {path {file {}}} {
+  if {$file!=""} {
+    set path $path/$file
+  } else {
+    set file $path
+  }
+  puts "<a href=\"$path\">$file</a>"
+}
+
+puts {
+<p>Here are the steps:</p>
+
+<ol>
+<li>
+<p>Get a copy of source code.  You will need the binutils, the
+compiler, and the MinGW runtime.  Each are available separately.
+As of this writing, Mumit Khan has collected everything you need
+together in one FTP site:
+}
+set ftpsite \
+  ftp://ftp.nanotech.wisc.edu/pub/khan/gnu-win32/mingw32/snapshots/gcc-2.95.2-1
+Link $ftpsite
+puts {
+The three files you will need are:</p>
+<ul>
+<li>}
+Link $ftpsite binutils-19990818-1-src.tar.gz
+puts </li><li>
+Link $ftpsite gcc-2.95.2-1-src.tar.gz
+puts </li><li>
+Link $ftpsite mingw-20000203.zip
+puts {</li>
+</ul>
+
+<p>Put all the downloads in a directory out of the way.  The sequel
+will assume all downloads are in a directory named
+<b>~/mingw/download</b>.</p>
+</li>
+
+<li>
+<p>
+Create a directory in which to install the new compiler suite and make
+the new directory writable.
+Depending on what directory you choose, you might need to become
+root.  The example shell commands that follow
+will assume the installation directory is
+<b>/opt/mingw</b> and that your user ID is <b>drh</b>.</p>
+<blockquote><pre>
+su
+mkdir /opt/mingw
+chown drh /opt/mingw
+exit
+</pre></blockquote>
+</li>
+
+<li>
+<p>Unpack the source tarballs into a separate directory.</p>
+<blockquote><pre>
+mkdir ~/mingw/src
+cd ~/mingw/src
+tar xzf ../download/binutils-*.tar.gz
+tar xzf ../download/gcc-*.tar.gz
+unzip ../download/mingw-*.zip
+</pre></blockquote>
+</li>
+
+<li>
+<p>Create a directory in which to put all the build products.</p>
+<blockquote><pre>
+mkdir ~/mingw/bld
+</pre></blockquote>
+</li>
+
+<li>
+<p>Configure and build binutils and add the results to your PATH.</p>
+<blockquote><pre>
+mkdir ~/mingw/bld/binutils
+cd ~/mingw/bld/binutils
+../../src/binutils/configure --prefix=/opt/mingw --target=i386-mingw32 -v
+make 2&gt;&amp;1 | tee make.out
+make install 2&gt;&amp;1 | tee make-install.out
+export PATH=$PATH:/opt/mingw/bin
+</pre></blockquote>
+</li>
+
+<li>
+<p>Manually copy the runtime include files into the installation directory
+before trying to build the compiler.</p>
+<blockquote><pre>
+mkdir /opt/mingw/i386-mingw32/include
+cd ~/mingw/src/mingw-runtime*/mingw/include
+cp -r * /opt/mingw/i386-mingw32/include
+</pre></blockquote>
+</li>
+
+<li>
+<p>Configure and build the compiler</p>
+<blockquote><pre>
+mkdir ~/mingw/bld/gcc
+cd ~/mingw/bld/gcc
+../../src/gcc-*/configure --prefix=/opt/mingw --target=i386-mingw32 -v
+cd gcc
+make installdirs
+cd ..
+make 2&gt;&amp;1 | tee make.out
+make install
+</pre></blockquote>
+</li>
+
+<li>
+<p>Configure and build the MinGW runtime</p>
+<blockquote><pre>
+mkdir ~/mingw/bld/runtime
+cd ~/mingw/bld/runtime
+../../src/mingw-runtime*/configure --prefix=/opt/mingw --target=i386-mingw32 -v
+make install-target-w32api
+make install
+</pre></blockquote>
+</li>
+</ol>
+
+<p>And you are done...</p>
+}
+puts {
+<p><hr /></p>
+<p><a href="index.html"><img src="/goback.jpg" border=0 />
+Back to the SQLite Home Page</a>
+</p>
+
+</body></html>}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/mkapidoc.tcl b/client/src/thirdparty/sqlite-3.4.2/www/mkapidoc.tcl
new file mode 100644
index 0000000..723f84a
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/mkapidoc.tcl
@@ -0,0 +1,176 @@
+#!/usr/bin/tclsh
+#
+# Run this script redirecting the sqlite3.h file as standard
+# inputs and this script will generate API documentation.
+#
+set rcsid {$Id: mkapidoc.tcl,v 1.2 2007/06/20 09:09:48 danielk1977 Exp $}
+source common.tcl
+header {C/C++ Interface For SQLite Version 3}
+puts {
+<h2 class=pdf_section>C/C++ Interface For SQLite Version 3</h2>
+}
+
+# Scan standard input to extract the information we need
+# to build the documentation.
+#
+set title {}
+set type {}
+set body {}
+set code {}
+set phase 0
+set content {}
+while {![eof stdin]} {
+  set line [gets stdin]
+  if {$phase==0} {
+    # Looking for the CAPI3REF: keyword
+    if {[regexp {^\*\* CAPI3REF: +(.*)} $line all tx]} {
+      set title $tx
+      set phase 1
+    }
+  } elseif {$phase==1} {
+    if {[string range $line 0 1]=="**"} {
+      set lx [string trim [string range $line 3 end]]
+      if {[regexp {^CATEGORY: +([a-z]*)} $lx all cx]} {
+        set type $cx
+      } elseif {[regexp {^KEYWORDS: +(.*)} $lx all kx]} {
+        foreach k $kx {
+          set keyword($k) 1
+        }
+      } else {
+        append body $lx\n
+      }
+    } elseif {[string range $line 0 1]=="*/"} {
+      set phase 2
+    }
+  } elseif {$phase==2} {
+    if {$line==""} {
+      set kwlist [lsort [array names keyword]]
+      unset -nocomplain keyword
+      set key $type:$kwlist
+      lappend content [list $key $title $type $kwlist $body $code]
+      set title {}
+      set keywords {}
+      set type {}
+      set body {}
+      set code {}
+      set phase 0
+    } else {
+      if {[regexp {^#define (SQLITE_[A-Z0-9_]+)} $line all kx]} {
+        set type constant
+        set keyword($kx) 1
+      } elseif {[regexp {^typedef .* (sqlite[0-9a-z_]+);} $line all kx]} {
+        set type datatype
+        set keyword($kx) 1
+      } elseif {[regexp {^[a-z].*[ *](sqlite3_[a-z0-9_]+)\(} $line all kx]} {
+        set type function
+        set keyword($kx) 1
+      }
+      append code $line\n
+    }
+  }
+}
+
+# Output HTML that displays the given list in N columns
+#
+proc output_list {N lx} {
+  puts {<table width="100%" cellpadding="5"><tr>}
+  set len [llength $lx]
+  set n [expr {($len + $N - 1)/$N}]
+  for {set i 0} {$i<$N} {incr i} {
+    set start [expr {$i*$n}]
+    set end [expr {($i+1)*$n}]
+    puts {<td valign="top"><ul>}
+    for {set j $start} {$j<$end} {incr j} {
+      set entry [lindex $lx $j]
+      if {$entry!=""} {
+        foreach {link label} $entry break
+        puts "<li><a href=\"#$link\">$label</a></li>"
+      }
+    }
+    puts {</ul></td>}
+  }
+  puts {</tr></table>}
+}
+
+# Do a table of contents for objects
+#
+set objlist {}
+foreach c $content {
+  foreach {key title type keywords body code} $c break
+  if {$type!="datatype"} continue
+  set keywords [lsort $keywords]
+  set k [lindex $keywords 0]
+  foreach kw $keywords {
+    lappend objlist [list $k $kw]
+  }
+}
+puts {<h2>Datatypes:</h2>}
+output_list 3 $objlist
+puts {<hr>}
+
+# Do a table of contents for constants
+#
+set clist {}
+foreach c $content {
+  foreach {key title type keywords body code} $c break
+  if {$type!="constant"} continue
+  set keywords [lsort $keywords]
+  set k [lindex $keywords 0]
+  foreach kw $keywords {
+    lappend clist [list $k $kw]
+  }
+}
+puts {<h2>Constants:</h2>}
+set clist [lsort -index 1 $clist]
+output_list 3 $clist
+puts {<hr>}
+
+
+# Do a table of contents for functions
+#
+set funclist {}
+foreach c $content {
+  foreach {key title type keywords body code} $c break
+  if {$type!="function"} continue
+  set keywords [lsort $keywords]
+  set k [lindex $keywords 0]
+  foreach kw $keywords {
+    lappend funclist [list $k $kw]
+  }
+}
+puts {<h2>Functions:</h2>}
+set funclist [lsort -index 1 $funclist]
+output_list 3 $funclist
+puts {<hr>}
+
+# Resolve links
+#
+proc resolve_links {args} {
+  set tag [lindex $args 0]
+  regsub -all {[^a-zA-Z0-9_]} $tag {} tag
+  set x "<a href=\"#$tag\">"
+  if {[llength $args]>2} {
+    append x [lrange $args 2 end]</a>
+  } else {
+    append x [lindex $args 0]</a>
+  }
+  return $x
+}
+
+# Output all the records
+#
+foreach c [lsort $content] {
+  foreach {key title type keywords body code} $c break
+  foreach k $keywords {
+    puts "<a name=\"$k\"></a>"
+  }
+  puts "<h2>$title</h2>"
+  puts "<blockquote><pre>"
+  puts "$code"
+  puts "</pre></blockquote>"
+  regsub -all "\n\n+" $body {</p>\1<p>} body
+  regsub -all {\[} <p>$body</p> {[resolve_links } body
+  set body [subst -novar -noback $body]
+  puts "$body"
+  puts "<hr>"
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/nulls.tcl b/client/src/thirdparty/sqlite-3.4.2/www/nulls.tcl
new file mode 100644
index 0000000..9091389
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/nulls.tcl
@@ -0,0 +1,329 @@
+#
+# Run this script to generated a nulls.html output file
+#
+set rcsid {$Id: nulls.tcl,v 1.8 2004/10/10 17:24:55 drh Exp $}
+source common.tcl
+header {NULL Handling in SQLite}
+puts {
+<h2>NULL Handling in SQLite Versus Other Database Engines</h2>
+
+<p>
+The goal is
+to make SQLite handle NULLs in a standards-compliant way.
+But the descriptions in the SQL standards on how to handle
+NULLs seem ambiguous. 
+It is not clear from the standards documents exactly how NULLs should
+be handled in all circumstances.
+</p>
+
+<p>
+So instead of going by the standards documents, various popular
+SQL engines were tested to see how they handle NULLs.  The idea
+was to make SQLite work like all the other engines.
+A SQL test script was developed and run by volunteers on various
+SQL RDBMSes and the results of those tests were used to deduce
+how each engine processed NULL values.
+The original tests were run in May of 2002.
+A copy of the test script is found at the end of this document.
+</p>
+
+<p>
+SQLite was originally coded in such a way that the answer to
+all questions in the chart below would be "Yes".  But the
+experiments run on other SQL engines showed that none of them
+worked this way.  So SQLite was modified to work the same as
+Oracle, PostgreSQL, and DB2.  This involved making NULLs
+indistinct for the purposes of the SELECT DISTINCT statement and
+for the UNION operator in a SELECT.  NULLs are still distinct
+in a UNIQUE column.  This seems somewhat arbitrary, but the desire
+to be compatible with other engines outweighted that objection.
+</p>
+
+<p>
+It is possible to make SQLite treat NULLs as distinct for the
+purposes of the SELECT DISTINCT and UNION.  To do so, one should
+change the value of the NULL_ALWAYS_DISTINCT #define in the
+<tt>sqliteInt.h</tt> source file and recompile.
+</p>
+
+<blockquote>
+<p>
+<i>Update 2003-07-13:</i>
+Since this document was originally written some of the database engines
+tested have been updated and users have been kind enough to send in
+corrections to the chart below.  The original data showed a wide variety
+of behaviors, but over time the range of behaviors has converged toward
+the PostgreSQL/Oracle model.  The only significant difference 
+is that Informix and MS-SQL both threat NULLs as
+indistinct in a UNIQUE column.
+</p>
+
+<p>
+The fact that NULLs are distinct for UNIQUE columns but are indistinct for
+SELECT DISTINCT and UNION continues to be puzzling.  It seems that NULLs
+should be either distinct everywhere or nowhere.  And the SQL standards
+documents suggest that NULLs should be distinct everywhere.  Yet as of
+this writing, no SQL engine tested treats NULLs as distinct in a SELECT
+DISTINCT statement or in a UNION.
+</p>
+</blockquote>
+
+
+<p>
+The following table shows the results of the NULL handling experiments.
+</p>
+
+<table border=1 cellpadding=3 width="100%">
+<tr><th>&nbsp&nbsp;</th>
+<th>SQLite</th>
+<th>PostgreSQL</th>
+<th>Oracle</th>
+<th>Informix</th>
+<th>DB2</th>
+<th>MS-SQL</th>
+<th>OCELOT</th>
+</tr>
+
+<tr><td>Adding anything to null gives null</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>Multiplying null by zero gives null</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>nulls are distinct in a UNIQUE column</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#aaaad2">(Note 4)</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>nulls are distinct in SELECT DISTINCT</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+</tr>
+<tr><td>nulls are distinct in a UNION</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+</tr>
+<tr><td>"CASE WHEN null THEN 1 ELSE 0 END" is 0?</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>"null OR true" is true</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>"not (null AND false)" is true</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+</table>
+
+<table border=1 cellpadding=3 width="100%">
+<tr><th>&nbsp&nbsp;</th>
+<th>MySQL<br>3.23.41</th>
+<th>MySQL<br>4.0.16</th>
+<th>Firebird</th>
+<th>SQL<br>Anywhere</th>
+<th>Borland<br>Interbase</th>
+</tr>
+
+<tr><td>Adding anything to null gives null</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>Multiplying null by zero gives null</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>nulls are distinct in a UNIQUE column</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#aaaad2">(Note 4)</td>
+<td valign="center" align="center" bgcolor="#aaaad2">(Note 4)</td>
+</tr>
+<tr><td>nulls are distinct in SELECT DISTINCT</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No (Note 1)</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+</tr>
+<tr><td>nulls are distinct in a UNION</td>
+<td valign="center" align="center" bgcolor="#aaaad2">(Note 3)</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No (Note 1)</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+</tr>
+<tr><td>"CASE WHEN null THEN 1 ELSE 0 END" is 0?</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#aaaad2">(Note 5)</td>
+</tr>
+<tr><td>"null OR true" is true</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+<tr><td>"not (null AND false)" is true</td>
+<td valign="center" align="center" bgcolor="#c7a9a9">No</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+<td valign="center" align="center" bgcolor="#a9c7a9">Yes</td>
+</tr>
+</table>
+
+<table border=0 align="right" cellpadding=0 cellspacing=0>
+<tr>
+<td valign="top" rowspan=5>Notes:&nbsp;&nbsp;</td>
+<td>1.&nbsp;</td>
+<td>Older versions of firebird omits all NULLs from SELECT DISTINCT
+and from UNION.</td>
+</tr>
+<tr><td>2.&nbsp;</td>
+<td>Test data unavailable.</td>
+</tr>
+<tr><td>3.&nbsp;</td>
+<td>MySQL version 3.23.41 does not support UNION.</td>
+</tr>
+<tr><td>4.&nbsp;</td>
+<td>DB2, SQL Anywhere, and Borland Interbase 
+do not allow NULLs in a UNIQUE column.</td>
+</tr>
+<tr><td>5.&nbsp;</td>
+<td>Borland Interbase does not support CASE expressions.</td>
+</tr>
+</table>
+<br clear="both">
+
+<p>&nbsp;</p>
+<p>
+The following script was used to gather information for the table
+above.
+</p>
+
+<pre>
+-- I have about decided that SQL's treatment of NULLs is capricious and cannot be
+-- deduced by logic.  It must be discovered by experiment.  To that end, I have 
+-- prepared the following script to test how various SQL databases deal with NULL.
+-- My aim is to use the information gather from this script to make SQLite as much
+-- like other databases as possible.
+--
+-- If you could please run this script in your database engine and mail the results
+-- to me at drh@hwaci.com, that will be a big help.  Please be sure to identify the
+-- database engine you use for this test.  Thanks.
+--
+-- If you have to change anything to get this script to run with your database
+-- engine, please send your revised script together with your results.
+--
+
+-- Create a test table with data
+create table t1(a int, b int, c int);
+insert into t1 values(1,0,0);
+insert into t1 values(2,0,1);
+insert into t1 values(3,1,0);
+insert into t1 values(4,1,1);
+insert into t1 values(5,null,0);
+insert into t1 values(6,null,1);
+insert into t1 values(7,null,null);
+
+-- Check to see what CASE does with NULLs in its test expressions
+select a, case when b<>0 then 1 else 0 end from t1;
+select a+10, case when not b<>0 then 1 else 0 end from t1;
+select a+20, case when b<>0 and c<>0 then 1 else 0 end from t1;
+select a+30, case when not (b<>0 and c<>0) then 1 else 0 end from t1;
+select a+40, case when b<>0 or c<>0 then 1 else 0 end from t1;
+select a+50, case when not (b<>0 or c<>0) then 1 else 0 end from t1;
+select a+60, case b when c then 1 else 0 end from t1;
+select a+70, case c when b then 1 else 0 end from t1;
+
+-- What happens when you multiple a NULL by zero?
+select a+80, b*0 from t1;
+select a+90, b*c from t1;
+
+-- What happens to NULL for other operators?
+select a+100, b+c from t1;
+
+-- Test the treatment of aggregate operators
+select count(*), count(b), sum(b), avg(b), min(b), max(b) from t1;
+
+-- Check the behavior of NULLs in WHERE clauses
+select a+110 from t1 where b<10;
+select a+120 from t1 where not b>10;
+select a+130 from t1 where b<10 OR c=1;
+select a+140 from t1 where b<10 AND c=1;
+select a+150 from t1 where not (b<10 AND c=1);
+select a+160 from t1 where not (c=1 AND b<10);
+
+-- Check the behavior of NULLs in a DISTINCT query
+select distinct b from t1;
+
+-- Check the behavior of NULLs in a UNION query
+select b from t1 union select b from t1;
+
+-- Create a new table with a unique column.  Check to see if NULLs are considered
+-- to be distinct.
+create table t2(a int, b int unique);
+insert into t2 values(1,1);
+insert into t2 values(2,null);
+insert into t2 values(3,null);
+select * from t2;
+
+drop table t1;
+drop table t2;
+</pre>
+}
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/oldnews.tcl b/client/src/thirdparty/sqlite-3.4.2/www/oldnews.tcl
new file mode 100644
index 0000000..a4cf5ab
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/oldnews.tcl
@@ -0,0 +1,509 @@
+#!/usr/bin/tclsh
+source common.tcl
+header {SQLite Older News}
+
+proc newsitem {date title text} {
+  puts "<h3>$date - $title</h3>"
+  regsub -all "\n( *\n)+" $text "</p>\n\n<p>" txt
+  puts "<p>$txt</p>"
+  puts "<hr width=\"50%\">"
+}
+
+newsitem {2007-Aug-13} {Version 3.4.2} {
+  While stress-testing the 
+  <a href="capi3ref.html#sqlite3_soft_heap_limit">soft_heap_limit</a>
+  feature, a bug that could lead to
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=DatabaseCorruption">database
+  corruption</a> was <a href="http://www.sqlite.org/cvstrac/tktview?tn=2565">
+  discovered and fixed</a>.
+  Though the consequences of this bug are severe, the chances of hitting 
+  it in a typical application are remote.  Upgrading is recommended
+  only if you use the 
+  <a href="capi3ref.html#sqlite3_soft_heap_limit">sqlite3_soft_heap_limit</a>
+  interface.
+}
+
+newsitem {2007-Jly-20} {Version 3.4.1} {
+  This release fixes a bug in <a href="lang_vacuum.html">VACUUM</a> that
+  can lead to <a href="http://www.sqlite.org/cvstrac/wiki?p=DatabaseCorruption">
+  database corruption</a>.  The bug was introduced in version 
+  <a href="changes.html#version_3_3_14">3.3.14</a>.
+  Upgrading is recommended for all users.  Also included are a slew of
+  other more routine
+  <a href="changes.html#version_3_4_1">enhancements and bug fixes</a>.
+}
+
+newsitem {2007-Jun-18} {Version 3.4.0} {
+  This release fixes two separate bugs either of which 
+  can lead to database corruption.  Upgrading
+  is strongly recommended.  If you must continue using an older version
+  of SQLite, please at least read about how to avoid these bugs
+  at
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError">
+  CorruptionFollowingBusyError</a> and
+  <a href="http://www.sqlite.org/cvstrac/tktview?tn=2418">ticket #2418</a>
+  <p>
+  This release also adds explicit <a href="limits.html">limits</a> on the
+  sizes and quantities of things SQLite will handle.  The new limits might
+  causes compatibility problems for existing applications that
+  use excessively large strings, BLOBs, tables, or SQL statements. 
+  The new limits can be increased at compile-time to work around any problems
+  that arise.  Nevertheless, the version number of this release is
+  3.4.0 instead of 3.3.18 in order to call attention to the possible
+  incompatibility.
+  </p>
+  There are also new features, including
+  <a href="capi3ref.html#sqlite3_blob_open">incremental BLOB I/O</a> and
+  <a href="pragma.html#pragma_incremental_vacuum">incremental vacuum</a>.
+  See the <a href="changes.html#version_3_4_0">change log</a> 
+  for additional information.
+}
+
+newsitem {2007-Apr-25} {Version 3.3.17} {
+  This version fixes a bug in the forwards-compatibility logic of SQLite
+  that was causing a database to become unreadable when it should have
+  been read-only.  Upgrade from 3.3.16 only if you plan to deploy into
+  a product that might need to be upgraded in the future.  For day to day
+  use, it probably does not matter.
+}
+
+newsitem {2007-Apr-18} {Version 3.3.16} {
+  Performance improvements added in 3.3.14 but mistakenly turned off
+  in 3.3.15 have been reinstated.  A bug has been fixed that prevented 
+  VACUUM from running if a NULL value was in a UNIQUE column.
+}
+
+newsitem {2007-Apr-09} {Version 3.3.15} {
+  An annoying bug introduced in 3.3.14 has been fixed.  There are
+  also many enhancements to the test suite.  
+}
+
+newsitem {2007-Apr-02} {Version 3.3.14} {
+  This version focuses on performance improvements.  If you recompile
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=TheAmalgamation">
+  the amalgamation</a> using GCC option -O3 (the precompiled binaries
+  use -O2) you may see performance
+  improvements of 35% or more over version 3.3.13 depending on your
+  workload.  This version also
+  adds support for <a href="pragma.html#pragma_locking_mode">
+  exclusive access mode</a>.
+}
+
+newsitem {2007-Feb-13} {Version 3.3.13} {
+  This version fixes a subtle bug in the ORDER BY optimizer that can 
+  occur when using joins.  There are also a few minor enhancements.
+  Upgrading is recommended.
+}
+
+newsitem {2007-Jan-27} {Version 3.3.12} {
+  The first published build of the previous version used the wrong
+  set of source files.  Consequently, many people downloaded a build
+  that was labeled as "3.3.11" but was really 3.3.10.  Version 3.3.12
+  is released to clear up the ambiguity.  A couple more bugs have
+  also been fixed and <a href="pragma.html#pragma_integrity_check">
+  PRAGMA integrity_check</a> has been enhanced.
+}
+
+newsitem {2007-Jan-22} {Version 3.3.11} {
+  Version 3.3.11 fixes for a few more problems in version 3.3.9 that
+  version 3.3.10 failed to catch.  Upgrading is recommended.
+}
+
+newsitem {2007-Jan-9} {Version 3.3.10} {
+  Version 3.3.10 fixes several bugs that were introduced by the previous
+  release.  Upgrading is recommended.
+}
+
+newsitem {2007-Jan-4} {Version 3.3.9} {
+  Version 3.3.9 fixes bugs that can lead to database corruption under
+  obscure and difficult to reproduce circumstances.  See
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=DatabaseCorruption">
+  DatabaseCorruption</a> in the
+  <a href="http://www.sqlite.org/cvstrac/wiki">wiki</a> for details.
+  This release also adds the new
+  <a href="capi3ref.html#sqlite3_prepare_v2">sqlite3_prepare_v2()</a>
+  API and includes important bug fixes in the command-line
+  shell and enhancements to the query optimizer.  Upgrading is
+  recommended.
+}
+
+newsitem {2006-Oct-9} {Version 3.3.8} {
+  Version 3.3.8 adds support for full-text search using the 
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=FtsOne">FTS1
+  module.</a>  There are also minor bug fixes.  Upgrade only if
+  you want to try out the new full-text search capabilities or if
+  you are having problems with 3.3.7.
+}
+
+newsitem {2006-Aug-12} {Version 3.3.7} {
+  Version 3.3.7 includes support for loadable extensions and virtual
+  tables.  But both features are still considered "beta" and their
+  APIs are subject to change in a future release.  This release is
+  mostly to make available the minor bug fixes that have accumulated
+  since 3.3.6.  Upgrading is not necessary.  Do so only if you encounter
+  one of the obscure bugs that have been fixed or if you want to try
+  out the new features.
+}
+
+newsitem {2006-Jun-19} {New Book About SQLite} {
+  <a href="http://www.apress.com/book/bookDisplay.html?bID=10130">
+  <i>The Definitive Guide to SQLite</i></a>, a new book by
+  <a href="http://www.mikesclutter.com">Mike Owens</a>.
+  is now available from <a href="http://www.apress.com">Apress</a>.
+  The books covers the latest SQLite internals as well as
+  the native C interface and bindings for PHP, Python,
+  Perl, Ruby, Tcl, and Java.  Recommended.
+}
+
+
+newsitem {2006-Jun-6} {Version 3.3.6} {
+  Changes include improved tolerance for windows virus scanners
+  and faster :memory: databases.  There are also fixes for several
+  obscure bugs.  Upgrade if you are having problems.
+}
+
+newsitem {2006-Apr-5} {Version 3.3.5} {
+  This release fixes many minor bugs and documentation typos and
+  provides some minor new features and performance enhancements.
+  Upgrade only if you are having problems or need one of the new features.
+}
+
+newsitem {2006-Feb-11} {Version 3.3.4} {
+  This release fixes several bugs, including a 
+  a blunder that might cause a deadlock on multithreaded systems.
+  Anyone using SQLite in a multithreaded environment should probably upgrade.
+}
+
+newsitem {2006-Jan-31} {Version 3.3.3 stable} {
+  There have been no major problems discovered in version 3.3.2, so
+  we hereby declare the new APIs and language features to be stable
+  and supported.
+}
+
+newsitem {2006-Jan-24} {Version 3.3.2 beta} {
+  More bug fixes and performance improvements as we move closer to
+  a production-ready version 3.3.x.
+}
+
+newsitem {2006-Jan-16} {Version 3.3.1 alpha} {
+  Many bugs found in last week's alpha release have now been fixed and
+  the library is running much faster again.
+
+  Database connections can now be moved between threads as long as the
+  connection holds no locks at the time it is moved.  Thus the common
+  paradigm of maintaining a pool of database connections and handing
+  them off to transient worker threads is now supported.
+  Please help test this new feature.
+  See <a href="http://www.sqlite.org/cvstrac/wiki?p=MultiThreading">
+  the MultiThreading wiki page</a> for additional
+  information.
+}
+
+newsitem {2006-Jan-10} {Version 3.3.0 alpha} {
+  Version 3.3.0 adds support for CHECK constraints, DESC indices,
+  separate REAL and INTEGER column affinities, a new OS interface layer
+  design, and many other changes.  The code passed a regression
+  test but should still be considered alpha.  Please report any
+  problems.
+
+  The file format for version 3.3.0 has changed slightly to support
+  descending indices and
+  a more efficient encoding of boolean values.  SQLite 3.3.0 will read and
+  write legacy databases created with any prior version of SQLite 3.  But
+  databases created by version 3.3.0 will not be readable or writable
+  by earlier versions of the SQLite.  The older file format can be
+  specified at compile-time for those rare cases where it is needed.
+}
+
+newsitem {2005-Dec-19} {Versions 3.2.8 and 2.8.17} {
+  These versions contain one-line changes to 3.2.7 and 2.8.16 to fix a bug
+  that has been present since March of 2002 and version 2.4.0.
+  That bug might possibly cause database corruption if a large INSERT or
+  UPDATE statement within a multi-statement transaction fails due to a
+  uniqueness constraint but the containing transaction commits.
+}
+
+
+newsitem {2005-Sep-24} {Version 3.2.7} {
+  This version fixes several minor and obscure bugs.
+  Upgrade only if you are having problems.
+}
+
+newsitem {2005-Sep-16} {Version 3.2.6 - Critical Bug Fix} {
+  This version fixes a bug that can result in database
+  corruption if a VACUUM of a 1 gibibyte or larger database fails
+  (perhaps do to running out of disk space or an unexpected power loss)
+  and is later rolled back.
+  <p>
+  Also in this release:
+  The ORDER BY and GROUP BY processing was rewritten to use less memory.
+  Support for COUNT(DISTINCT) was added.  The LIKE operator can now be
+  used by the optimizer on columns with COLLATE NOCASE.
+}
+
+newsitem {2005-Aug-27} {Version 3.2.5} {
+  This release fixes a few more lingering bugs in the new code.
+  We expect that this release will be stable and ready for production use.
+}
+
+newsitem {2005-Aug-24} {Version 3.2.4} {
+  This release fixes a bug in the new optimizer that can lead to segfaults
+  when parsing very complex WHERE clauses.
+}
+
+newsitem {2005-Aug-21} {Version 3.2.3} {
+  This release adds the <a href="lang_analyze.html">ANALYZE</a> command,
+  the <a href="lang_expr.html">CAST</a> operator, and many
+  very substantial improvements to the query optimizer.  See the
+  <a href="changes.html#version_3_2_3">change log</a> for additional
+  information.
+}
+
+newsitem {2005-Aug-2} {2005 Open Source Award for SQLite} {
+  SQLite and its primary author D. Richard Hipp have been honored with
+  a <a href="http://osdir.com/Article6677.phtml">2005 Open Source
+  Award</a> from Google and O'Reilly.<br clear="right">
+}
+
+
+newsitem {2005-Jun-13} {Version 3.2.2} {
+  This release includes numerous minor bug fixes, speed improvements,
+  and code size reductions.  There is no reason to upgrade unless you
+  are having problems or unless you just want to.
+}
+
+newsitem {2005-Mar-29} {Version 3.2.1} {
+  This release fixes a memory allocation problem in the new
+  <a href="lang_altertable.html">ALTER TABLE ADD COLUMN</a>
+  command.
+}
+
+newsitem {2005-Mar-21} {Version 3.2.0} {
+  The primary purpose for version 3.2.0 is to add support for
+  <a href="lang_altertable.html">ALTER TABLE ADD COLUMN</a>.
+  The new ADD COLUMN capability is made
+  possible by AOL developers supporting and embracing great
+  open-source software.  Thanks, AOL!
+
+  Version 3.2.0 also fixes an obscure but serious bug that was discovered
+  just prior to release.  If you have a multi-statement transaction and
+  within that transaction an UPDATE or INSERT statement fails due to a
+  constraint, then you try to rollback the whole transaction, the rollback
+  might not work correctly.  See
+  <a href="http://www.sqlite.org/cvstrac/tktview?tn=1171">Ticket #1171</a>
+  for details.  Upgrading is recommended for all users.
+}
+
+newsitem {2005-Mar-16} {Version 3.1.6} {
+  Version 3.1.6 fixes a critical bug that can cause database corruption
+  when inserting rows into tables with around 125 columns. This bug was
+  introduced in version 3.0.0.  See
+  <a href="http://www.sqlite.org/cvstrac/tktview?tn=1163">Ticket #1163</a>
+  for additional information.
+}
+
+newsitem {2005-Mar-11} {Versions 3.1.4 and 3.1.5 Released} {
+  Version 3.1.4 fixes a critical bug that could cause database corruption
+  if the autovacuum mode of version 3.1.0 is turned on (it is off by
+  default) and a CREATE UNIQUE INDEX is executed within a transaction but
+  fails because the indexed columns are not unique.  Anyone using the
+  autovacuum feature and unique indices should upgrade.
+
+  Version 3.1.5 adds the ability to disable
+  the F_FULLFSYNC ioctl() in OS-X by setting "PRAGMA synchronous=on" instead
+  of the default "PRAGMA synchronous=full".  There was an attempt to add
+  this capability in 3.1.4 but it did not work due to a spelling error.
+}
+
+newsitem {2005-Feb-19} {Version 3.1.3 Released} {
+  Version 3.1.3 cleans up some minor issues discovered in version 3.1.2.
+}
+  
+newsitem {2005-Feb-15} {Versions 2.8.16 and 3.1.2 Released} {
+  A critical bug in the VACUUM command that can lead to database
+  corruption has been fixed in both the 2.x branch and the main
+  3.x line.  This bug has existed in all prior versions of SQLite.
+  Even though it is unlikely you will ever encounter this bug,
+  it is suggested that all users upgrade.  See
+  <a href="http://www.sqlite.org/cvstrac/tktview?tn=1116">
+  ticket #1116</a>. for additional information.
+
+  Version 3.1.2 is also the first stable release of the 3.1
+  series.  SQLite 3.1 features added support for correlated
+  subqueries, autovacuum, autoincrement, ALTER TABLE, and
+  other enhancements.  See the 
+  <a href="http://www.sqlite.org/releasenotes310.html">release notes
+  for version 3.1.0</a> for a detailed description of the
+  changes available in the 3.1 series.
+}
+
+newsitem {2005-Feb-01} {Version 3.1.1 (beta) Released} {
+  Version 3.1.1 (beta) is now available on the
+  website.  Verison 3.1.1 is fully backwards compatible with the 3.0 series
+  and features many new features including Autovacuum and correlated
+  subqueries.  The
+  <a href="http://www.sqlite.org/releasenotes310.html">release notes</a>
+  From version 3.1.0 apply equally to this release beta.  A stable release
+  is expected within a couple of weeks.
+}
+
+newsitem {2005-Jan-21} {Version 3.1.0 (alpha) Released} {
+  Version 3.1.0 (alpha) is now available on the
+  website.  Verison 3.1.0 is fully backwards compatible with the 3.0 series
+  and features many new features including Autovacuum and correlated
+  subqueries.  See the
+  <a href="http://www.sqlite.org/releasenotes310.html">release notes</a>
+  for details.
+
+  This is an alpha release.  A beta release is expected in about a week
+  with the first stable release to follow after two more weeks.
+}
+
+newsitem {2004-Nov-09} {SQLite at the 2004 International PHP Conference} {
+  There was a talk on the architecture of SQLite and how to optimize
+  SQLite queries at the 2004 International PHP Conference in Frankfurt,
+  Germany.
+  <a href="http://www.sqlite.org/php2004/page-001.html">
+  Slides</a> from that talk are available.
+}
+
+newsitem {2004-Oct-11} {Version 3.0.8} {
+  Version 3.0.8 of SQLite contains several code optimizations and minor
+  bug fixes and adds support for DEFERRED, IMMEDIATE, and EXCLUSIVE
+  transactions.  This is an incremental release.  There is no reason
+  to upgrade from version 3.0.7 if that version is working for you.
+}
+
+
+newsitem {2004-Oct-10} {SQLite at the 11<sup><small>th</small></sup>
+Annual Tcl/Tk Conference} {
+  There will be a talk on the use of SQLite in Tcl/Tk at the
+  11<sup><small>th</small></sup> Tcl/Tk Conference this week in
+  New Orleans.  Visit <a href="http://www.tcl.tk/community/tcl2004/">
+  http://www.tcl.tk/</a> for details.
+  <a href="http://www.sqlite.org/tclconf2004/page-001.html">
+  Slides</a> from the talk are available.
+}
+
+newsitem {2004-Sep-18} {Version 3.0.7} {
+  Version 3.0 has now been in use by multiple projects for several
+  months with no major difficulties.   We consider it stable and
+  ready for production use. 
+}
+
+newsitem {2004-Sep-02} {Version 3.0.6 (beta)} {
+  Because of some important changes to sqlite3_step(),
+  we have decided to
+  do an additional beta release prior to the first "stable" release.
+  If no serious problems are discovered in this version, we will
+  release version 3.0 "stable" in about a week.
+}
+
+
+newsitem {2004-Aug-29} {Version 3.0.5 (beta)} {
+  The fourth beta release of SQLite version 3.0 is now available.
+  The next release is expected to be called "stable".
+}
+
+
+newsitem {2004-Aug-08} {Version 3.0.4 (beta)} {
+  The third beta release of SQLite version 3.0 is now available.
+  This new beta fixes several bugs including a database corruption
+  problem that can occur when doing a DELETE while a SELECT is pending.
+  Expect at least one more beta before version 3.0 goes final.
+}
+
+newsitem {2004-July-22} {Version 3.0.3 (beta)} {
+  The second beta release of SQLite version 3.0 is now available.
+  This new beta fixes many bugs and adds support for databases with
+  varying page sizes.  The next 3.0 release will probably be called
+  a final or stable release.
+
+  Version 3.0 adds support for internationalization and a new
+  more compact file format. 
+  <a href="version3.html">Details.</a>
+  The API and file format have been fixed since 3.0.2.  All
+  regression tests pass (over 100000 tests) and the test suite
+  exercises over 95% of the code.
+
+  SQLite version 3.0 is made possible in part by AOL
+  developers supporting and embracing great Open-Source Software.
+}
+
+newsitem {2004-Jly-22} {Version 2.8.15} {
+  SQLite version 2.8.15 is a maintenance release for the version 2.8
+  series.  Version 2.8 continues to be maintained with bug fixes, but
+  no new features will be added to version 2.8.  All the changes in
+  this release are minor.  If you are not having problems, there is
+  there is no reason to upgrade.
+}
+
+newsitem {2004-Jun-30} {Version 3.0.2 (beta) Released} {
+  The first beta release of SQLite version 3.0 is now available.
+  Version 3.0 adds support for internationalization and a new
+  more compact file format. 
+  <a href="version3.html">Details.</a>
+  As of this release, the API and file format are frozen.  All
+  regression tests pass (over 100000 tests) and the test suite
+  exercises over 95% of the code.
+
+  SQLite version 3.0 is made possible in part by AOL
+  developers supporting and embracing great Open-Source Software.
+}
+  
+
+newsitem {2004-Jun-25} {Website hacked} {
+  The www.sqlite.org website was hacked sometime around 2004-Jun-22
+  because the lead SQLite developer failed to properly patch CVS.
+  Evidence suggests that the attacker was unable to elevate privileges
+  above user "cvs".  Nevertheless, as a precaution the entire website
+  has been reconstructed from scratch on a fresh machine.  All services
+  should be back to normal as of 2004-Jun-28.
+}
+
+
+newsitem {2004-Jun-18} {Version 3.0.0 (alpha) Released} {
+  The first alpha release of SQLite version 3.0 is available for
+  public review and comment.  Version 3.0 enhances internationalization support
+  through the use of UTF-16 and user-defined text collating sequences.
+  BLOBs can now be stored directly, without encoding.
+  A new file format results in databases that are 25% smaller (depending
+  on content).  The code is also a little faster.  In spite of the many
+  new features, the library footprint is still less than 240KB
+  (x86, gcc -O1).
+  <a href="version3.html">Additional information</a>.
+
+  Our intent is to freeze the file format and API on 2004-Jul-01.
+  Users are encouraged to review and evaluate this alpha release carefully 
+  and submit any feedback prior to that date.
+
+  The 2.8 series of SQLite will continue to be supported with bug
+  fixes for the foreseeable future.
+}
+
+newsitem {2004-Jun-09} {Version 2.8.14 Released} {
+  SQLite version 2.8.14 is a patch release to the stable 2.8 series.
+  There is no reason to upgrade if 2.8.13 is working ok for you.
+  This is only a bug-fix release.  Most development effort is
+  going into version 3.0.0 which is due out soon.
+}
+
+newsitem {2004-May-31} {CVS Access Temporarily Disabled} {
+  Anonymous access to the CVS repository will be suspended
+  for 2 weeks beginning on 2004-June-04.  Everyone will still
+  be able to download
+  prepackaged source bundles, create or modify trouble tickets, or view
+  change logs during the CVS service interruption. Full open access to the
+  CVS repository will be restored on 2004-June-18.
+}
+
+newsitem {2004-Apr-23} {Work Begins On SQLite Version 3} {
+  Work has begun on version 3 of SQLite.  Version 3 is a major
+  changes to both the C-language API and the underlying file format
+  that will enable SQLite to better support internationalization.
+  The first beta is schedule for release on 2004-July-01.
+
+  Plans are to continue to support SQLite version 2.8 with
+  bug fixes.  But all new development will occur in version 3.0.
+}
+footer {$Id: oldnews.tcl,v 1.24 2007/11/05 18:11:18 drh Exp $}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/omitted.tcl b/client/src/thirdparty/sqlite-3.4.2/www/omitted.tcl
new file mode 100644
index 0000000..23241e7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/omitted.tcl
@@ -0,0 +1,85 @@
+#
+# Run this script to generated a omitted.html output file
+#
+set rcsid {$Id: omitted.tcl,v 1.10 2005/11/03 00:41:18 drh Exp $}
+source common.tcl
+header {SQL Features That SQLite Does Not Implement}
+puts {
+<h2>SQL Features That SQLite Does Not Implement</h2>
+
+<p>
+Rather than try to list all the features of SQL92 that SQLite does
+support, it is much easier to list those that it does not.
+Unsupported features of SQL92 are shown below.</p>
+
+<p>
+The order of this list gives some hint as to when a feature might
+be added to SQLite.  Those features near the top of the list are
+likely to be added in the near future.  There are no immediate
+plans to add features near the bottom of the list.
+</p>
+
+<table cellpadding="10">
+}
+
+proc feature {name desc} {
+  puts "<tr><td valign=\"top\"><b><nobr>$name</nobr></b></td>"
+  puts "<td width=\"10\">&nbsp;</th>"
+  puts "<td valign=\"top\">$desc</td></tr>"
+}
+
+feature {FOREIGN KEY constraints} {
+  FOREIGN KEY constraints are parsed but are not enforced.
+}
+
+feature {Complete trigger support} {
+  There is some support for triggers but it is not complete.  Missing
+  subfeatures include FOR EACH STATEMENT triggers (currently all triggers
+  must be FOR EACH ROW), INSTEAD OF triggers on tables (currently 
+  INSTEAD OF triggers are only allowed on views), and recursive
+  triggers - triggers that trigger themselves.
+}
+
+feature {Complete ALTER TABLE support} {
+  Only the RENAME TABLE and ADD COLUMN variants of the 
+  ALTER TABLE command are supported.  Other kinds of ALTER TABLE operations
+  such as
+  DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT, and so forth are omitted.
+}
+
+feature {Nested transactions} {
+  The current implementation only allows a single active transaction.
+}
+
+feature {RIGHT and FULL OUTER JOIN} {
+  LEFT OUTER JOIN is implemented, but not RIGHT OUTER JOIN or
+  FULL OUTER JOIN.
+}
+
+feature {Writing to VIEWs} {
+  VIEWs in SQLite are read-only.  You may not execute a DELETE, INSERT, or
+  UPDATE statement on a view. But you can create a trigger
+  that fires on an attempt to DELETE, INSERT, or UPDATE a view and do
+  what you need in the body of the trigger.
+}
+
+feature {GRANT and REVOKE} {
+  Since SQLite reads and writes an ordinary disk file, the
+  only access permissions that can be applied are the normal
+  file access permissions of the underlying operating system.
+  The GRANT and REVOKE commands commonly found on client/server
+  RDBMSes are not implemented because they would be meaningless
+  for an embedded database engine.
+}
+
+puts {
+</table>
+
+<p>
+If you find other SQL92 features that SQLite does not support, please
+add them to the Wiki page at 
+<a href="http://www.sqlite.org/cvstrac/wiki?p=UnsupportedSql">
+http://www.sqlite.org/cvstrac/wiki?p=Unsupported</a>
+</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/opcode.tcl b/client/src/thirdparty/sqlite-3.4.2/www/opcode.tcl
new file mode 100644
index 0000000..f28534f
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/opcode.tcl
@@ -0,0 +1,243 @@
+#
+# Run this Tcl script to generate the sqlite.html file.
+#
+set rcsid {$Id: opcode.tcl,v 1.15 2005/03/09 12:26:51 danielk1977 Exp $}
+source common.tcl
+header {SQLite Virtual Machine Opcodes}
+puts {
+<h2>SQLite Virtual Machine Opcodes</h2>
+}
+
+set fd [open [lindex $argv 0] r]
+set file [read $fd [file size [lindex $argv 0]]]
+close $fd
+set current_op {}
+foreach line [split $file \n] {
+  set line [string trim $line]
+  if {[string index $line 1]!="*"} {
+    set current_op {}
+    continue
+  }
+  if {[regexp {^/\* Opcode: } $line]} {
+    set current_op [lindex $line 2]
+    set txt [lrange $line 3 end]
+    regsub -all {>} $txt {\&gt;} txt
+    regsub -all {<} $txt {\&lt;} txt
+    set Opcode($current_op:args) $txt
+    lappend OpcodeList $current_op
+    continue
+  }
+  if {$current_op==""} continue
+  if {[regexp {^\*/} $line]} {
+    set current_op {}
+    continue
+  }
+  set line [string trim [string range $line 3 end]]
+  if {$line==""} {
+    append Opcode($current_op:text) \n<p>
+  } else {
+    regsub -all {>} $line {\&gt;} line
+    regsub -all {<} $line {\&lt;} line
+    append Opcode($current_op:text) \n$line
+  }
+}
+unset file
+
+puts {
+<h3>Introduction</h3>
+
+<p>In order to execute an SQL statement, the SQLite library first parses
+the SQL, analyzes the statement, then generates a short program to execute
+the statement.  The program is generated for a "virtual machine" implemented
+by the SQLite library.  This document describes the operation of that
+virtual machine.</p>
+
+<p>This document is intended as a reference, not a tutorial.
+A separate <a href="vdbe.html">Virtual Machine Tutorial</a> is 
+available.  If you are looking for a narrative description
+of how the virtual machine works, you should read the tutorial
+and not this document.  Once you have a basic idea of what the
+virtual machine does, you can refer back to this document for
+the details on a particular opcode.
+Unfortunately, the virtual machine tutorial was written for
+SQLite version 1.0.  There are substantial changes in the virtual
+machine for version 2.0 and the document has not been updated.
+</p>
+
+<p>The source code to the virtual machine is in the <b>vdbe.c</b> source
+file.  All of the opcode definitions further down in this document are
+contained in comments in the source file.  In fact, the opcode table
+in this document
+was generated by scanning the <b>vdbe.c</b> source file 
+and extracting the necessary information from comments.  So the 
+source code comments are really the canonical source of information
+about the virtual machine.  When in doubt, refer to the source code.</p>
+
+<p>Each instruction in the virtual machine consists of an opcode and
+up to three operands named P1, P2 and P3.  P1 may be an arbitrary
+integer.  P2 must be a non-negative integer.  P2 is always the
+jump destination in any operation that might cause a jump.
+P3 is a null-terminated
+string or NULL.  Some operators use all three operands.  Some use
+one or two.  Some operators use none of the operands.<p>
+
+<p>The virtual machine begins execution on instruction number 0.
+Execution continues until (1) a Halt instruction is seen, or 
+(2) the program counter becomes one greater than the address of
+last instruction, or (3) there is an execution error.
+When the virtual machine halts, all memory
+that it allocated is released and all database cursors it may
+have had open are closed.  If the execution stopped due to an
+error, any pending transactions are terminated and changes made
+to the database are rolled back.</p>
+
+<p>The virtual machine also contains an operand stack of unlimited
+depth.  Many of the opcodes use operands from the stack.  See the
+individual opcode descriptions for details.</p>
+
+<p>The virtual machine can have zero or more cursors.  Each cursor
+is a pointer into a single table or index within the database.
+There can be multiple cursors pointing at the same index or table.
+All cursors operate independently, even cursors pointing to the same
+indices or tables.
+The only way for the virtual machine to interact with a database
+file is through a cursor.
+Instructions in the virtual
+machine can create a new cursor (Open), read data from a cursor
+(Column), advance the cursor to the next entry in the table
+(Next) or index (NextIdx), and many other operations.
+All cursors are automatically
+closed when the virtual machine terminates.</p>
+
+<p>The virtual machine contains an arbitrary number of fixed memory
+locations with addresses beginning at zero and growing upward.
+Each memory location can hold an arbitrary string.  The memory
+cells are typically used to hold the result of a scalar SELECT
+that is part of a larger expression.</p>
+
+<p>The virtual machine contains a single sorter.
+The sorter is able to accumulate records, sort those records,
+then play the records back in sorted order.  The sorter is used
+to implement the ORDER BY clause of a SELECT statement.</p>
+
+<p>The virtual machine contains a single "List".
+The list stores a list of integers.  The list is used to hold the
+rowids for records of a database table that needs to be modified.
+The WHERE clause of an UPDATE or DELETE statement scans through
+the table and writes the rowid of every record to be modified
+into the list.  Then the list is played back and the table is modified
+in a separate step.</p>
+
+<p>The virtual machine can contain an arbitrary number of "Sets".
+Each set holds an arbitrary number of strings.  Sets are used to
+implement the IN operator with a constant right-hand side.</p>
+
+<p>The virtual machine can open a single external file for reading.
+This external read file is used to implement the COPY command.</p>
+
+<p>Finally, the virtual machine can have a single set of aggregators.
+An aggregator is a device used to implement the GROUP BY clause
+of a SELECT.  An aggregator has one or more slots that can hold
+values being extracted by the select.  The number of slots is the
+same for all aggregators and is defined by the AggReset operation.
+At any point in time a single aggregator is current or "has focus".
+There are operations to read or write to memory slots of the aggregator
+in focus.  There are also operations to change the focus aggregator
+and to scan through all aggregators.</p>
+
+<h3>Viewing Programs Generated By SQLite</h3>
+
+<p>Every SQL statement that SQLite interprets results in a program
+for the virtual machine.  But if you precede the SQL statement with
+the keyword "EXPLAIN" the virtual machine will not execute the
+program.  Instead, the instructions of the program will be returned
+like a query result.  This feature is useful for debugging and
+for learning how the virtual machine operates.</p>
+
+<p>You can use the <b>sqlite</b> command-line tool to see the
+instructions generated by an SQL statement.  The following is
+an example:</p>}
+
+proc Code {body} {
+  puts {<blockquote><tt>}
+  regsub -all {&} [string trim $body] {\&amp;} body
+  regsub -all {>} $body {\&gt;} body
+  regsub -all {<} $body {\&lt;} body
+  regsub -all {\(\(\(} $body {<b>} body
+  regsub -all {\)\)\)} $body {</b>} body
+  regsub -all { } $body {\&nbsp;} body
+  regsub -all \n $body <br>\n body
+  puts $body
+  puts {</tt></blockquote>}
+}
+
+Code {
+$ (((sqlite ex1)))
+sqlite> (((.explain)))
+sqlite> (((explain delete from tbl1 where two<20;)))
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  ----------------------------------------
+0     Transaction   0      0                                              
+1     VerifyCookie  219    0                                              
+2     ListOpen      0      0                                              
+3     Open          0      3      tbl1                                    
+4     Rewind        0      0                                              
+5     Next          0      12                                             
+6     Column        0      1                                              
+7     Integer       20     0                                              
+8     Ge            0      5                                              
+9     Recno         0      0                                              
+10    ListWrite     0      0                                              
+11    Goto          0      5                                              
+12    Close         0      0                                              
+13    ListRewind    0      0                                              
+14    OpenWrite     0      3                                              
+15    ListRead      0      19                                             
+16    MoveTo        0      0                                              
+17    Delete        0      0                                              
+18    Goto          0      15                                             
+19    ListClose     0      0                                              
+20    Commit        0      0                                              
+}
+
+puts {
+<p>All you have to do is add the "EXPLAIN" keyword to the front of the
+SQL statement.  But if you use the ".explain" command to <b>sqlite</b>
+first, it will set up the output mode to make the program more easily
+viewable.</p>
+
+<p>If <b>sqlite</b> has been compiled without the "-DNDEBUG=1" option
+(that is, with the NDEBUG preprocessor macro not defined) then you
+can put the SQLite virtual machine in a mode where it will trace its
+execution by writing messages to standard output.  The non-standard
+SQL "PRAGMA" comments can be used to turn tracing on and off.  To
+turn tracing on, enter:
+</p>
+
+<blockquote><pre>
+PRAGMA vdbe_trace=on;
+</pre></blockquote>
+
+<p>
+You can turn tracing back off by entering a similar statement but
+changing the value "on" to "off".</p>
+
+<h3>The Opcodes</h3>
+}
+
+puts "<p>There are currently [llength $OpcodeList] opcodes defined by
+the virtual machine."
+puts {All currently defined opcodes are described in the table below.
+This table was generated automatically by scanning the source code
+from the file <b>vdbe.c</b>.</p>}
+
+puts {
+<p><table cellspacing="1" border="1" cellpadding="10">
+<tr><th>Opcode&nbsp;Name</th><th>Description</th></tr>}
+foreach op [lsort -dictionary $OpcodeList] {
+  puts {<tr><td valign="top" align="center">}
+  puts "<a name=\"$op\">$op</a>"
+  puts "<td>[string trim $Opcode($op:text)]</td></tr>"
+}
+puts {</table></p>}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/optimizer.tcl b/client/src/thirdparty/sqlite-3.4.2/www/optimizer.tcl
new file mode 100644
index 0000000..5b2897e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/optimizer.tcl
@@ -0,0 +1,265 @@
+#
+# Run this TCL script to generate HTML for the goals.html file.
+#
+set rcsid {$Id: optimizer.tcl,v 1.1 2005/08/30 22:44:06 drh Exp $}
+source common.tcl
+header {The SQLite Query Optimizer}
+
+proc CODE {text} {
+  puts "<blockquote><pre>"
+  puts $text
+  puts "</pre></blockquote>"
+}
+proc IMAGE {name {caption {}}} {
+  puts "<center><img src=\"$name\">"
+  if {$caption!=""} {
+    puts "<br>$caption"
+  }
+  puts "</center>"
+}
+proc PARAGRAPH {text} {
+  puts "<p>$text</p>\n"
+}
+proc HEADING {level name} {
+  puts "<h$level>$name</h$level>"
+}
+
+HEADING 1 {The SQLite Query Optimizer}
+
+PARAGRAPH {
+  This article describes how the SQLite query optimizer works.
+  This is not something you have to know in order to use SQLite - many
+  programmers use SQLite successfully without the slightest hint of what
+  goes on in the inside.
+  But a basic understanding of what SQLite is doing
+  behind the scenes will help you to write more efficient SQL.  And the
+  knowledge gained by studying the SQLite query optimizer has broad
+  application since most other relational database engines operate 
+  similarly.
+  A solid understanding of how the query optimizer works is also
+  required before making meaningful changes or additions to the SQLite, so 
+  this article should be read closely by anyone aspiring
+  to hack the source code.
+}
+
+HEADING 2 Background
+
+PARAGRAPH {
+  It is important to understand that SQL is a programming language.
+  SQL is a perculiar programming language in that it
+  describes <u>what</u> the programmer wants to compute not <u>how</u>
+  to compute it as most other programming languages do.
+  But perculiar or not, SQL is still just a programming language.
+}
+
+PARAGRAPH {
+  It is very helpful to think of each SQL statement as a separate
+  program.
+  An important job of the SQL database engine is to translate each
+  SQL statement from its descriptive form that specifies what the
+  information is desired (the <u>what</u>) 
+  into a procedural form that specifies how to go
+  about acquiring the desired information (the <u>how</u>).
+  The task of translating the <u>what</u> into a 
+  <u>how</u> is assigned to the query optimizer.
+}
+
+PARAGRAPH {
+  The beauty of SQL comes from the fact that the optimizer frees the programmer
+  from having to worry over the details of <u>how</u>.  The programmer
+  only has to specify the <u>what</u> and then leave the optimizer
+  to deal with all of the minutae of implementing the
+  <u>how</u>.  Thus the programmer is able to think and work at a
+  much higher level and leave the optimizer to stress over the low-level
+  work.
+}
+
+HEADING 2 {Database Layout}
+
+PARAGRAPH {
+  An SQLite database consists of one or more "b-trees".
+  Each b-tree contains zero or more "rows". 
+  A single row contains a "key" and some "data".
+  In general, both the key and the data are arbitrary binary
+  data of any length.
+  The keys must all be unique within a single b-tree.
+  Rows are stored in order of increasing key values - each
+  b-tree has a comparision functions for keys that determines
+  this order.
+}
+
+PARAGRAPH {
+  In SQLite, each SQL table is stored as a b-tree where the
+  key is a 64-bit integer and the data is the content of the
+  table row.  The 64-bit integer key is the ROWID.  And, of course,
+  if the table has an INTEGER PRIMARY KEY, then that integer is just
+  an alias for the ROWID.
+}
+
+PARAGRAPH {
+  Consider the following block of SQL code:
+}
+
+CODE {
+  CREATE TABLE ex1(
+     id INTEGER PRIMARY KEY,
+     x  VARCHAR(30),
+     y  INTEGER
+  );
+  INSERT INTO ex1 VALUES(NULL,'abc',12345);
+  INSERT INTO ex1 VALUES(NULL,456,'def');
+  INSERT INTO ex1 VALUES(100,'hello','world');
+  INSERT INTO ex1 VALUES(-5,'abc','xyz');
+  INSERT INTO ex1 VALUES(54321,NULL,987);
+}
+
+PARAGRAPH {
+  This code generates a new b-tree (named "ex1") containing 5 rows.
+  This table can be visualized as follows:
+}
+IMAGE table-ex1b2.gif
+
+PARAGRAPH {
+  Note that the key for each row if the b-tree is the INTEGER PRIMARY KEY
+  for that row.  (Remember that the INTEGER PRIMARY KEY is just an alias
+  for the ROWID.)  The other fields of the table form the data for each
+  entry in the b-tree.  Note also that the b-tree entries are in ROWID order
+  which is different from the order that they were originally inserted.
+}
+
+PARAGRAPH {
+  Now consider the following SQL query:
+}
+CODE {
+  SELECT y FROM ex1 WHERE x=456;
+}
+
+PARAGRAPH {
+  When the SQLite parser and query optimizer are handed this query, they
+  have to translate it into a procedure that will find the desired result.
+  In this case, they do what is call a "full table scan".  They start
+  at the beginning of the b-tree that contains the table and visit each
+  row.  Within each row, the value of the "x" column is tested and when it
+  is found to match 456, the value of the "y" column is output.
+  We can represent this procedure graphically as follows:
+}
+IMAGE fullscanb.gif
+
+PARAGRAPH {
+  A full table scan is the access method of last resort.  It will always
+  work.  But if the table contains millions of rows and you are only looking
+  a single one, it might take a very long time to find the particular row
+  you are interested in.
+  In particular, the time needed to access a single row of the table is
+  proportional to the total number of rows in the table.
+  So a big part of the job of the optimizer is to try to find ways to 
+  satisfy the query without doing a full table scan.
+}
+PARAGRAPH {
+  The usual way to avoid doing a full table scan is use a binary search
+  to find the particular row or rows of interest in the table.
+  Consider the next query which searches on rowid instead of x:
+}
+CODE {
+  SELECT y FROM ex1 WHERE rowid=2;
+}
+
+PARAGRAPH {
+  In the previous query, we could not use a binary search for x because
+  the values of x were not ordered.  But the rowid values are ordered.
+  So instead of having to visit every row of the b-tree looking for one
+  that has a rowid value of 2, we can do a binary search for that particular
+  row and output its corresponding y value.  We show this graphically
+  as follows:
+}
+IMAGE direct1b.gif
+
+PARAGRAPH {
+  When doing a binary search, we only have to look at a number of
+  rows with is proportional to the logorithm of the number of entries
+  in the table.  For a table with just 5 entires as in the example above,
+  the difference between a full table scan and a binary search is
+  negligible.  In fact, the full table scan might be faster.  But in
+  a database that has 5 million rows, a binary search will be able to
+  find the desired row in only about 23 tries, whereas the full table
+  scan will need to look at all 5 million rows.  So the binary search
+  is about 200,000 times faster in that case.
+}
+PARAGRAPH {
+  A 200,000-fold speed improvement is huge.  So we always want to do
+  a binary search rather than a full table scan when we can.
+}
+PARAGRAPH {
+  The problem with a binary search is that the it only works if the
+  fields you are search for are in sorted order.  So we can do a binary
+  search when looking up the rowid because the rows of the table are
+  sorted by rowid.  But we cannot use a binary search when looking up
+  x because the values in the x column are in no particular order.
+}
+PARAGRAPH {
+  The way to work around this problem and to permit binary searching on
+  fields like x is to provide an index.
+  An index is another b-tree.
+  But in the index b-tree the key is not the rowid but rather the field
+  or fields being indexed followed by the rowid.
+  The data in an index b-tree is empty - it is not needed or used.
+  The following diagram shows an index on the x field of our example table:
+}
+IMAGE index-ex1-x-b.gif
+
+PARAGRAPH {
+  An important point to note in the index are that they keys of the
+  b-tree are in sorted order.  (Recall that NULL values in SQLite sort
+  first, followed by numeric values in numerical order, then strings, and
+  finally BLOBs.)  This is the property that will allow use to do a
+  binary search for the field x.  The rowid is also included in every
+  key for two reasons.  First, by including the rowid we guarantee that
+  every key will be unique.  And second, the rowid will be used to look
+  up the actual table entry after doing the binary search.  Finally, note
+  that the data portion of the index b-tree serves no purpose and is thus
+  kept empty to save space in the disk file.
+}
+PARAGRAPH {
+  Remember what the original query example looked like:
+}
+CODE {
+  SELECT y FROM ex1 WHERE x=456;
+}
+
+PARAGRAPH {
+  The first time this query was encountered we had to do a full table
+  scan.  But now that we have an index on x, we can do a binary search
+  on that index for the entry where x==456.  Then from that entry we
+  can find the rowid value and use the rowid to look up the corresponding
+  entry in the original table.  From the entry in the original table,
+  we can find the value y and return it as our result.  The following
+  diagram shows this process graphically:
+}
+IMAGE indirect1b1.gif
+
+PARAGRAPH {
+  With the index, we are able to look up an entry based on the value of
+  x after visiting only a logorithmic number of b-tree entries.  Unlike
+  the case where we were searching using rowid, we have to do two binary
+  searches for each output row.  But for a 5-million row table, that is
+  still only 46 searches instead of 5 million for a 100,000-fold speedup.
+}
+
+HEADING 3 {Parsing The WHERE Clause}
+
+
+
+# parsing the where clause
+# rowid lookup
+# index lookup
+# index lookup without the table
+# how an index is chosen
+# joins
+# join reordering
+# order by using an index
+# group by using an index
+# OR -> IN optimization
+# Bitmap indices
+# LIKE and GLOB optimization
+# subquery flattening
+# MIN and MAX optimizations
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/optimizing.tcl b/client/src/thirdparty/sqlite-3.4.2/www/optimizing.tcl
new file mode 100644
index 0000000..44d2825
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/optimizing.tcl
@@ -0,0 +1,15 @@
+set rcsid {$Id: optimizing.tcl,v 1.1 2005/01/17 03:42:52 drh Exp $}
+source common.tcl
+header {Hints For Optimizing Queries In SQLite}
+proc section {level tag name} {
+  incr level
+  if {$level>6} {set level 6}
+  puts "\n"<a name=\"tag\" />"
+  puts "<h$level>$name</h$level>\n"
+}
+section 1 recompile {Recompile the library for optimal performance}
+section 2 avoidtrans {Minimize the number of transactions}
+section 3 usebind {Use sqlite3_bind to insert large chunks of data}
+section 4 useindices {Use appropriate indices}
+section 5 recordjoin {Reorder the tables in a join}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/optoverview.tcl b/client/src/thirdparty/sqlite-3.4.2/www/optoverview.tcl
new file mode 100644
index 0000000..15646e3
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/optoverview.tcl
@@ -0,0 +1,516 @@
+#
+# Run this TCL script to generate HTML for the goals.html file.
+#
+set rcsid {$Id: optoverview.tcl,v 1.5 2005/11/24 13:15:34 drh Exp $}
+source common.tcl
+header {The SQLite Query Optimizer Overview}
+
+proc CODE {text} {
+  puts "<blockquote><pre>"
+  puts $text
+  puts "</pre></blockquote>"
+}
+proc SYNTAX {text} {
+  puts "<blockquote><pre>"
+  set t2 [string map {& &amp; < &lt; > &gt;} $text]
+  regsub -all "/(\[^\n/\]+)/" $t2 {</b><i>\1</i><b>} t3
+  puts "<b>$t3</b>"
+  puts "</pre></blockquote>"
+}
+proc IMAGE {name {caption {}}} {
+  puts "<center><img src=\"$name\">"
+  if {$caption!=""} {
+    puts "<br>$caption"
+  }
+  puts "</center>"
+}
+proc PARAGRAPH {text} {
+  # regsub -all "/(\[a-zA-Z0-9\]+)/" $text {<i>\1</i>} t2
+  regsub -all "\\*(\[^\n*\]+)\\*" $text {<tt><b><big>\1</big></b></tt>} t3
+  puts "<p>$t3</p>\n"
+}
+set level(0) 0
+set level(1) 0
+proc HEADING {n name {tag {}}} {
+  if {$tag!=""} {
+    puts "<a name=\"$tag\">"
+  }
+  global level
+  incr level($n)
+  for {set i [expr {$n+1}]} {$i<10} {incr i} {
+    set level($i) 0
+  }
+  if {$n==0} {
+    set num {}
+  } elseif {$n==1} {
+    set num $level(1).0
+  } else {
+    set num $level(1)
+    for {set i 2} {$i<=$n} {incr i} {
+      append num .$level($i)
+    }
+  }
+  incr n 1
+  puts "<h$n>$num $name</h$n>"
+}
+
+HEADING 0 {The SQLite Query Optimizer Overview}
+
+PARAGRAPH {
+  This document provides a terse overview of how the query optimizer
+  for SQLite works.  This is not a tutorial.  The reader is likely to
+  need some prior knowledge of how database engines operate 
+  in order to fully understand this text.
+}
+
+HEADING 1 {WHERE clause analysis} where_clause
+
+PARAGRAPH {
+  The WHERE clause on a query is broken up into "terms" where each term
+  is separated from the others by an AND operator.
+}
+PARAGRAPH {
+  All terms of the WHERE clause are analyzed to see if they can be
+  satisfied using indices.
+  Terms that cannot be satisfied through the use of indices become
+  tests that are evaluated against each row of the relevant input
+  tables.  No tests are done for terms that are completely satisfied by
+  indices.  Sometimes
+  one or more terms will provide hints to indices but still must be
+  evaluated against each row of the input tables.
+}
+
+PARAGRAPH {
+  The analysis of a term might cause new "virtual" terms to
+  be added to the WHERE clause.  Virtual terms can be used with
+  indices to restrict a search.  But virtual terms never generate code
+  that is tested against input rows.
+}
+
+PARAGRAPH {
+  To be usable by an index a term must be of one of the following
+  forms:
+}
+SYNTAX {
+  /column/ = /expression/
+  /column/ > /expression/
+  /column/ >= /expression/
+  /column/ < /expression/
+  /column/ <= /expression/
+  /expression/ = /column/
+  /expression/ > /column/
+  /expression/ >= /column/
+  /expression/ < /column/
+  /expression/ <= /column/
+  /column/ IN (/expression-list/)
+  /column/ IN (/subquery/)
+}
+PARAGRAPH {
+  If an index is created using a statement like this:
+}
+CODE {
+  CREATE INDEX idx_ex1 ON ex1(a,b,c,d,e,...,y,z);
+}
+PARAGRAPH {
+  Then the index might be used if the initial columns of the index
+  (columns a, b, and so forth) appear in WHERE clause terms.
+  All index columns must be used with
+  the *=* or *IN* operators except for
+  the right-most column which can use inequalities.  For the right-most
+  column of an index that is used, there can be up to two inequalities
+  that must sandwich the allowed values of the column between two extremes.
+}
+PARAGRAPH {
+  It is not necessary for every column of an index to appear in a
+  WHERE clause term in order for that index to be used. 
+  But there can not be gaps in the columns of the index that are used.
+  Thus for the example index above, if there is no WHERE clause term
+  that constraints column c, then terms that constraint columns a and b can
+  be used with the index but not terms that constraint columns d through z.
+  Similarly, no index column will be used (for indexing purposes)
+  that is to the right of a 
+  column that is constrained only by inequalities.
+  For the index above and WHERE clause like this:
+}
+CODE {
+  ... WHERE a=5 AND b IN (1,2,3) AND c>12 AND d='hello'
+}
+PARAGRAPH {
+  Only columns a, b, and c of the index would be usable.  The d column
+  would not be usable because it occurs to the right of c and c is
+  constrained only by inequalities.
+}
+
+HEADING 1 {The BETWEEN optimization} between_opt
+
+PARAGRAPH {
+  If a term of the WHERE clause is of the following form:
+}
+SYNTAX {
+  /expr1/ BETWEEN /expr2/ AND /expr3/
+}
+PARAGRAPH {
+  Then two virtual terms are added as follows:
+}
+SYNTAX {
+  /expr1/ >= /expr2/ AND /expr1/ <= /expr3/
+}
+PARAGRAPH {
+  If both virtual terms end up being used as constraints on an index,
+  then the original BETWEEN term is omitted and the corresponding test
+  is not performed on input rows.
+  Thus if the BETWEEN term ends up being used as an index constraint
+  no tests are ever performed on that term.
+  On the other hand, the
+  virtual terms themselves never causes tests to be performed on
+  input rows.
+  Thus if the BETWEEN term is not used as an index constraint and
+  instead must be used to test input rows, the <i>expr1</i> expression is
+  only evaluated once.
+}
+
+HEADING 1 {The OR optimization} or_opt
+
+PARAGRAPH {
+  If a term consists of multiple subterms containing a common column
+  name and separated by OR, like this:
+}
+SYNTAX {
+  /column/ = /expr1/ OR /column/ = /expr2/ OR /column/ = /expr3/ OR ...
+}
+PARAGRAPH {
+  Then the term is rewritten as follows:
+}
+SYNTAX {
+  /column/ IN (/expr1/,/expr2/,/expr3/,/expr4/,...)
+}
+PARAGRAPH {
+  The rewritten term then might go on to constraint an index using the
+  normal rules for *IN* operators.
+  Note that <i>column</i> must be the same column in every OR-connected subterm,
+  although the column can occur on either the left or the right side of
+  the *=* operator.
+}
+
+HEADING 1 {The LIKE optimization} like_opt
+
+PARAGRAPH {
+  Terms that are composed of the LIKE or GLOB operator
+  can sometimes be used to constrain indices.
+  There are many conditions on this use:
+}
+PARAGRAPH {
+  <ol>
+  <li>The left-hand side of the LIKE or GLOB operator must be the name
+      of an indexed column.</li>
+  <li>The right-hand side of the LIKE or GLOB must be a string literal
+      that does not begin with a wildcard character.</li>
+  <li>The ESCAPE clause cannot appear on the LIKE operator.</li>
+  <li>The build-in functions used to implement LIKE and GLOB must not
+      have been overloaded using the sqlite3_create_function() API.</li>
+  <li>For the GLOB operator, the column must use the default BINARY
+      collating sequence.</li>
+  <li>For the LIKE operator, if case_sensitive_like mode is enabled then
+      the column must use the default BINARY collating sequence, or if
+      case_sensitive_like mode is disabled then the column must use the
+      built-in NOCASE collating sequence.</li>
+  </ol>
+}
+PARAGRAPH {
+  The LIKE operator has two modes that can be set by a pragma.  The
+  default mode is for LIKE comparisons to be insensitive to differences
+  of case for latin1 characters.  Thus, by default, the following
+  expression is true:
+}
+CODE {
+  'a' LIKE 'A'
+}
+PARAGRAPH {
+  By turned on the case_sensitive_like pragma as follows:
+}
+CODE {
+  PRAGMA case_sensitive_like=ON;
+}
+PARAGRAPH {
+  Then the LIKE operator pays attention to case and the example above would
+  evaluate to false.  Note that case insensitivity only applies to
+  latin1 characters - basically the upper and lower case letters of English
+  in the lower 127 byte codes of ASCII.  International character sets
+  are case sensitive in SQLite unless a user-supplied collating
+  sequence is used.  But if you employ a user-supplied collating sequence,
+  the LIKE optimization describe here will never be taken.
+}
+PARAGRAPH {
+  The LIKE operator is case insensitive by default because this is what
+  the SQL standard requires.  You can change the default behavior at
+  compile time by using the -DSQLITE_CASE_SENSITIVE_LIKE command-line option
+  to the compiler.
+}
+PARAGRAPH {
+  The LIKE optimization might occur if the column named on the left of the
+  operator uses the BINARY collating sequence (which is the default) and
+  case_sensitive_like is turned on.  Or the optimization might occur if
+  the column uses the built-in NOCASE collating sequence and the 
+  case_sensitive_like mode is off.  These are the only two combinations
+  under which LIKE operators will be optimized.  If the column on the
+  right-hand side of the LIKE operator uses any collating sequence other
+  than the built-in BINARY and NOCASE collating sequences, then no optimizations
+  will ever be attempted on the LIKE operator.
+}
+PARAGRAPH {
+  The GLOB operator is always case sensitive.  The column on the left side
+  of the GLOB operator must always use the built-in BINARY collating sequence
+  or no attempt will be made to optimize that operator with indices.
+}
+PARAGRAPH {
+  The right-hand side of the GLOB or LIKE operator must be a literal string
+  value that does not begin with a wildcard.  If the right-hand side is a
+  parameter that is bound to a string, then no optimization is attempted.
+  If the right-hand side begins with a wildcard character then no 
+  optimization is attempted.
+}
+PARAGRAPH {
+  Suppose the initial sequence of non-wildcard characters on the right-hand
+  side of the LIKE or GLOB operator is <i>x</i>.  We are using a single 
+  character to denote this non-wildcard prefix but the reader should
+  understand that the prefix can consist of more than 1 character.
+  Let <i>y</i> the smallest string that is the same length as /x/ but which
+  compares greater than <i>x</i>.  For example, if <i>x</i> is *hello* then
+  <i>y</i> would be *hellp*.
+  The LIKE and GLOB optimizations consist of adding two virtual terms
+  like this:
+}
+SYNTAX {
+  /column/ >= /x/ AND /column/ < /y/
+}
+PARAGRAPH {
+  Under most circumstances, the original LIKE or GLOB operator is still
+  tested against each input row even if the virtual terms are used to
+  constrain an index.  This is because we do not know what additional
+  constraints may be imposed by characters to the right
+  of the <i>x</i> prefix.  However, if there is only a single global wildcard
+  to the right of <i>x</i>, then the original LIKE or GLOB test is disabled.
+  In other words, if the pattern is like this:
+}
+SYNTAX {
+  /column/ LIKE /x/%
+  /column/ GLOB /x/*
+}
+PARAGRAPH {
+  Then the original LIKE or GLOB tests are disabled when the virtual
+  terms constrain an index because in that case we know that all of the
+  rows selected by the index will pass the LIKE or GLOB test.
+}
+
+HEADING 1 {Joins} joins
+
+PARAGRAPH {
+  The current implementation of 
+  SQLite uses only loop joins.  That is to say, joins are implemented as
+  nested loops.
+}
+PARAGRAPH {
+  The default order of the nested loops in a join is for the left-most
+  table in the FROM clause to form the outer loop and the right-most
+  table to form the inner loop.
+  However, SQLite will nest the loops in a different order if doing so
+  will help it to select better indices.
+}
+PARAGRAPH {
+  Inner joins can be freely reordered.  However a left outer join is
+  neither commutative nor associative and hence will not be reordered.
+  Inner joins to the left and right of the outer join might be reordered
+  if the optimizer thinks that is advantageous but the outer joins are
+  always evaluated in the order in which they occur.
+}
+PARAGRAPH {
+  When selecting the order of tables in a join, SQLite uses a greedy
+  algorithm that runs in polynomial time.
+}
+PARAGRAPH {
+  The ON and USING clauses of a join are converted into additional
+  terms of the WHERE clause prior to WHERE clause analysis described
+  above in paragraph 1.0.  Thus
+  with SQLite, there is no advantage to use the newer SQL92 join syntax
+  over the older SQL89 comma-join syntax.  They both end up accomplishing
+  exactly the same thing.
+}
+PARAGRAPH {
+  Join reordering is automatic and usually works well enough that
+  programmer do not have to think about it.  But occasionally some
+  hints from the programmer are needed.  For a description of when
+  hints might be necessary and how to provide those hints, see the
+  <a href="http://www.sqlite.org/cvstrac/wiki?p=QueryPlans">QueryPlans</a>
+  page in the Wiki.
+}
+
+HEADING 1 {Choosing between multiple indices} multi_index
+
+PARAGRAPH {
+  Each table in the FROM clause of a query can use at most one index,
+  and SQLite strives to use at least one index on each table.  Sometimes,
+  two or more indices might be candidates for use on a single table.
+  For example:
+}
+CODE {
+  CREATE TABLE ex2(x,y,z);
+  CREATE INDEX ex2i1 ON ex2(x);
+  CREATE INDEX ex2i2 ON ex2(y);
+  SELECT z FROM ex2 WHERE x=5 AND y=6;
+}
+PARAGRAPH {
+  For the SELECT statement above, the optimizer can use the ex2i1 index
+  to lookup rows of ex2 that contain x=5 and then test each row against
+  the y=6 term.  Or it can use the ex2i2 index to lookup rows
+  of ex2 that contain y=6 then test each of those rows against the
+  x=5 term.
+}
+PARAGRAPH {
+  When faced with a choice of two or more indices, SQLite tries to estimate
+  the total amount of work needed to perform the query using each option.
+  It then selects the option that gives the least estimated work.
+}
+PARAGRAPH {
+  To help the optimizer get a more accurate estimate of the work involved
+  in using various indices, the user may optional run the ANALYZE command.
+  The ANALYZE command scans all indices of database where there might
+  be a choice between two or more indices and gathers statistics on the
+  selectiveness of those indices.  The results of this scan are stored
+  in the sqlite_stat1 table.
+  The contents of the sqlite_stat1 table are not updated as the database
+  changes so after making significant changes it might be prudent to
+  rerun ANALYZE.
+  The results of an ANALYZE command are only available to database connections
+  that are opened after the ANALYZE command completes.
+}
+PARAGRAPH {
+  Once created, the sqlite_stat1 table cannot be dropped.  But its
+  content can be viewed, modified, or erased.  Erasing the entire content
+  of the sqlite_stat1 table has the effect of undoing the ANALYZE command.
+  Changing the content of the sqlite_stat1 table can get the optimizer
+  deeply confused and cause it to make silly index choices.  Making
+  updates to the sqlite_stat1 table (except by running ANALYZE) is
+  not recommended.
+}
+PARAGRAPH {
+  Terms of the WHERE clause can be manually disqualified for use with
+  indices by prepending a unary *+* operator to the column name.  The
+  unary *+* is a no-op and will not slow down the evaluation of the test
+  specified by the term.
+  But it will prevent the term from constraining an index.
+  So, in the example above, if the query were rewritten as:
+}
+CODE {
+  SELECT z FROM ex2 WHERE +x=5 AND y=6;
+}
+PARAGRAPH {
+  The *+* operator on the *x* column would prevent that term from 
+  constraining an index.  This would force the use of the ex2i2 index.
+}
+
+HEADING 1 {Avoidance of table lookups} index_only
+
+PARAGRAPH {
+  When doing an indexed lookup of a row, the usual procedure is to
+  do a binary search on the index to find the index entry, then extract
+  the rowid from the index and use that rowid to do a binary search on
+  the original table.  Thus a typical indexed lookup involves two
+  binary searches.
+  If, however, all columns that were to be fetched from the table are
+  already available in the index itself, SQLite will use the values
+  contained in the index and will never look up the original table
+  row.  This saves one binary search for each row and can make many
+  queries run twice as fast.
+}
+
+HEADING 1 {ORDER BY optimizations} order_by
+
+PARAGRAPH {
+  SQLite attempts to use an index to satisfy the ORDER BY clause of a
+  query when possible.
+  When faced with the choice of using an index to satisfy WHERE clause
+  constraints or satisfying an ORDER BY clause, SQLite does the same
+  work analysis described in section 6.0
+  and chooses the index that it believes will result in the fastest answer.
+
+}
+
+HEADING 1 {Subquery flattening} flattening
+
+PARAGRAPH {
+  When a subquery occurs in the FROM clause of a SELECT, the default
+  behavior is to evaluate the subquery into a transient table, then run
+  the outer SELECT against the transient table. 
+  This is problematic since the transient table will not have any indices
+  and the outer query (which is likely a join) will be forced to do a
+  full table scan on the transient table.
+}
+PARAGRAPH {
+  To overcome this problem, SQLite attempts to flatten subqueries in
+  the FROM clause of a SELECT.
+  This involves inserting the FROM clause of the subquery into the
+  FROM clause of the outer query and rewriting expressions in
+  the outer query that refer to the result set of the subquery.
+  For example:
+}
+CODE {
+  SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
+}
+PARAGRAPH {
+  Would be rewritten using query flattening as:
+}
+CODE {
+  SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
+}
+PARAGRAPH {
+  There is a long list of conditions that must all be met in order for
+  query flattening to occur.
+}
+PARAGRAPH {
+  <ol>
+  <li> The subquery and the outer query do not both use aggregates.</li>
+  <li> The subquery is not an aggregate or the outer query is not a join. </li>
+  <li> The subquery is not the right operand of a left outer join, or
+          the subquery is not itself a join. </li>
+  <li>  The subquery is not DISTINCT or the outer query is not a join. </li>
+  <li>  The subquery is not DISTINCT or the outer query does not use
+          aggregates. </li>
+  <li>  The subquery does not use aggregates or the outer query is not
+          DISTINCT. </li>
+  <li>  The subquery has a FROM clause. </li>
+  <li>  The subquery does not use LIMIT or the outer query is not a join. </li>
+  <li>  The subquery does not use LIMIT or the outer query does not use
+         aggregates. </li>
+  <li>  The subquery does not use aggregates or the outer query does not
+         use LIMIT. </li>
+  <li>  The subquery and the outer query do not both have ORDER BY clauses.</li>
+  <li>  The subquery is not the right term of a LEFT OUTER JOIN or the
+         subquery has no WHERE clause.  </li>
+  </ol>
+}
+PARAGRAPH {
+  The proof that query flattening may safely occur if all of the the
+  above conditions are met is left as an exercise to the reader.
+}
+PARAGRAPH {
+  Query flattening is an important optimization when views are used as
+  each use of a view is translated into a subquery.
+}
+
+HEADING 1 {The MIN/MAX optimization} minmax
+
+PARAGRAPH {
+  Queries of the following forms will be optimized to run in logarithmic
+  time assuming appropriate indices exist:
+}
+CODE {
+  SELECT MIN(x) FROM table;
+  SELECT MAX(x) FROM table;
+}
+PARAGRAPH {
+  In order for these optimizations to occur, they must appear in exactly
+  the form shown above - changing only the name of the table and column.
+  It is not permissible to add a WHERE clause or do any arithmetic on the
+  result.  The result set must contain a single column.
+  The column in the MIN or MAX function must be an indexed column.
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/pragma.tcl b/client/src/thirdparty/sqlite-3.4.2/www/pragma.tcl
new file mode 100644
index 0000000..d1fcb21
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/pragma.tcl
@@ -0,0 +1,635 @@
+#
+# Run this Tcl script to generate the pragma.html file.
+#
+set rcsid {$Id: pragma.tcl,v 1.28 2007/08/28 08:19:49 danielk1977 Exp $}
+source common.tcl
+header {Pragma statements supported by SQLite}
+
+proc Section {name {label {}}} {
+  puts "\n<hr />"
+  if {$label!=""} {
+    puts "<a name=\"$label\"></a>"
+  }
+  puts "<h1>$name</h1>\n"
+}
+
+puts {
+<p>The <a href="#syntax">PRAGMA command</a> is a special command used to 
+modify the operation of the SQLite library or to query the library for 
+internal (non-table) data. The PRAGMA command is issued using the same
+interface as other SQLite commands (e.g. SELECT, INSERT) but is
+different in the following important respects:
+</p>
+<ul>
+<li>Specific pragma statements may be removed and others added in future
+    releases of SQLite. Use with caution!
+<li>No error messages are generated if an unknown pragma is issued.
+    Unknown pragmas are simply ignored. This means if there is a typo in 
+    a pragma statement the library does not inform the user of the fact.
+<li>Some pragmas take effect during the SQL compilation stage, not the
+    execution stage. This means if using the C-language sqlite3_prepare(), 
+    sqlite3_step(), sqlite3_finalize() API (or similar in a wrapper 
+    interface), the pragma may be applied to the library during the 
+    sqlite3_prepare() call.
+<li>The pragma command is unlikely to be compatible with any other SQL
+    engine.
+</ul>
+
+<p>The available pragmas fall into four basic categories:</p>
+<ul>
+<li>Pragmas used to <a href="#modify">modify the operation</a> of the 
+    SQLite library in some manner, or to query for the current mode of 
+    operation.
+<li>Pragmas used to <a href="#schema">query the schema</a> of the current 
+    database.
+<li>Pragmas used to <a href="#version">query or modify the databases two 
+    version values</a>, the schema-version and the user-version.
+<li>Pragmas used to <a href="#debug">debug the library</a> and verify that
+    database files are not corrupted.
+</ul>
+}
+
+Section {PRAGMA command syntax} syntax
+
+Syntax {sql-statement} {
+PRAGMA <name> [= <value>] |
+PRAGMA <function>(<arg>)
+}
+
+puts {
+<p>The pragmas that take an integer <b><i>value</i></b> also accept 
+symbolic names.  The strings "<b>on</b>", "<b>true</b>", and "<b>yes</b>" 
+are equivalent to <b>1</b>.  The strings "<b>off</b>", "<b>false</b>", 
+and "<b>no</b>" are equivalent to <b>0</b>.  These strings are case-
+insensitive, and do not require quotes.  An unrecognized string will be 
+treated as <b>1</b>, and will not generate an error.  When the <i>value</i> 
+is returned it is as an integer.</p>
+}
+
+Section {Pragmas to modify library operation} modify
+
+puts {
+<ul>
+<a name="pragma_auto_vacuum"></a>
+<li><p><b>PRAGMA auto_vacuum;<br>
+          PRAGMA auto_vacuum = </b>
+            <i>0 | none | 1 | full | 2 | incremental</i><b>;</b></p>
+    <p>Query or set the auto-vacuum flag in the database.</p>
+
+    <p>Normally, (that is to say when auto_vacuum is 0 or "none")
+    when a transaction that deletes data from a database is
+    committed, the database file remains the same size. Unused database file 
+    pages are added to a "freelist" are reused for subsequent inserts.  The
+    database file does not shrink.
+    In this mode the <a href="lang_vacuum.html">VACUUM</a>
+    command can be used to reclaim unused space.</p>
+
+    <p>When the auto-vacuum flag is 1 (full), the freelist pages are
+    moved to the end of the file and the file is truncated to remove
+    the freelist pages at every commit.
+    Note, however, that auto-vacuum only truncates the freelist pages
+    from the file.  Auto-vacuum does not defragment the database nor
+    repack individual database pages the way that the
+    <a href="lang_vacuum.html">VACUUM</a> command does.  In fact, because
+    it moves pages around within the file, auto-vacuum can actually
+    make fragmentation worse.</p>
+
+    <p>Auto-vacuuming is only possible if the database stores some
+    additional information that allows each database page to be
+    traced backwards to its referer.  Therefore, auto-vacuuming must
+    be turned on before any tables are created.  It is not possible
+    to enable or disable auto-vacuum after a table has been created.</p>
+
+    <p>When the value of auto-vacuum is 2 (incremental) then the additional
+    information needed to do autovacuuming is stored in the database file
+    but autovacuuming does not occur automatically at each commit as it
+    does with auto_vacuum==full.  In incremental mode, the separate
+    <a href="#pragma_incremental_vacuum">incremental_vacuum</a> pragma must
+    be invoked to cause the vacuum to occur.</p>
+
+    <p>The database connection can be changed between full and incremental
+    autovacuum mode at will.  However, the connection cannot be changed
+    in and out of the "none" mode after any table has been created in the
+    database.
+    </p></li>
+
+<a name="pragma_cache_size"></a>
+<li><p><b>PRAGMA cache_size;
+       <br>PRAGMA cache_size = </b><i>Number-of-pages</i><b>;</b></p>
+    <p>Query or change the maximum number of database disk pages that SQLite
+    will hold in memory at once.  Each page uses about 1.5K of memory.
+    The default cache size is 2000.  If you are doing UPDATEs or DELETEs
+    that change many rows of a database and you do not mind if SQLite
+    uses more memory, you can increase the cache size for a possible speed
+    improvement.</p>
+    <p>When you change the cache size using the cache_size pragma, the
+    change only endures for the current session.  The cache size reverts
+    to the default value when the database is closed and reopened.  Use
+    the <a href="#pragma_default_cache_size"><b>default_cache_size</b></a> 
+    pragma to check the cache size permanently.</p></li>
+
+<a name="pragma_case_sensitive_like"></a>
+<li><p><b>PRAGMA case_sensitive_like;
+       <br>PRAGMA case_sensitive_like = </b><i>0 | 1</i><b>;</b></p>
+    <p>The default behavior of the LIKE operator is to ignore case
+    for latin1 characters. Hence, by default <b>'a' LIKE 'A'</b> is
+    true.  The case_sensitive_like pragma can be turned on to change
+    this behavior.  When case_sensitive_like is enabled,
+    <b>'a' LIKE 'A'</b> is false but <b>'a' LIKE 'a'</b> is still true.</p>
+    </li>
+
+<a name="pragma_count_changes"></a>
+<li><p><b>PRAGMA count_changes;
+       <br>PRAGMA count_changes = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query or change the count-changes flag. Normally, when the
+    count-changes flag is not set, INSERT, UPDATE and DELETE statements
+    return no data. When count-changes is set, each of these commands 
+    returns a single row of data consisting of one integer value - the
+    number of rows inserted, modified or deleted by the command. The 
+    returned change count does not include any insertions, modifications
+    or deletions performed by triggers.</p>
+
+<a name="pragma_default_cache_size"></a>
+<li><p><b>PRAGMA default_cache_size;
+       <br>PRAGMA default_cache_size = </b><i>Number-of-pages</i><b>;</b></p>
+    <p>Query or change the maximum number of database disk pages that SQLite
+    will hold in memory at once.  Each page uses 1K on disk and about
+    1.5K in memory.
+    This pragma works like the
+    <a href="#pragma_cache_size"><b>cache_size</b></a> 
+    pragma with the additional
+    feature that it changes the cache size persistently.  With this pragma,
+    you can set the cache size once and that setting is retained and reused
+    every time you reopen the database.</p></li>
+
+<a name="pragma_default_synchronous"></a>
+<li><p><b>PRAGMA default_synchronous;</b></p>
+    <p>This pragma was available in version 2.8 but was removed in version
+    3.0.  It is a dangerous pragma whose use is discouraged.  To help
+    dissuide users of version 2.8 from employing this pragma, the documentation
+    will not tell you what it does.</p></li>
+
+
+<a name="pragma_empty_result_callbacks"></a>
+<li><p><b>PRAGMA empty_result_callbacks;
+       <br>PRAGMA empty_result_callbacks = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query or change the empty-result-callbacks flag.</p> 
+    <p>The empty-result-callbacks flag affects the sqlite3_exec API only.
+    Normally, when the empty-result-callbacks flag is cleared, the
+    callback function supplied to the sqlite3_exec() call is not invoked
+    for commands that return zero rows of data. When empty-result-callbacks
+    is set in this situation, the callback function is invoked exactly once,
+    with the third parameter set to 0 (NULL). This is to enable programs  
+    that use the sqlite3_exec() API to retrieve column-names even when
+    a query returns no data.
+    </p>
+
+<a name="pragma_encoding"></a>
+<li><p><b>PRAGMA encoding;
+       <br>PRAGMA encoding = "UTF-8";
+       <br>PRAGMA encoding = "UTF-16";
+       <br>PRAGMA encoding = "UTF-16le";
+       <br>PRAGMA encoding = "UTF-16be";</b></p>
+    <p>In first form, if the main database has already been
+    created, then this pragma returns the text encoding used by the
+    main database, one of "UTF-8", "UTF-16le" (little-endian UTF-16
+    encoding) or "UTF-16be" (big-endian UTF-16 encoding).  If the main
+    database has not already been created, then the value returned is the
+    text encoding that will be used to create the main database, if 
+    it is created by this session.</p>
+    <p>The second and subsequent forms of this pragma are only useful if
+    the main database has not already been created. In this case the 
+    pragma sets the encoding that the main database will be created with if
+    it is created by this session. The string "UTF-16" is interpreted
+    as "UTF-16 encoding using native machine byte-ordering".  If the second
+    and subsequent forms are used after the database file has already
+    been created, they have no effect and are silently ignored.</p>
+
+    <p>Once an encoding has been set for a database, it cannot be changed.</p>
+
+    <p>Databases created by the ATTACH command always use the same encoding
+    as the main database.</p>
+</li>
+
+<a name="pragma_full_column_names"></a>
+<li><p><b>PRAGMA full_column_names;
+       <br>PRAGMA full_column_names = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query or change the full-column-names flag. This flag affects
+    the way SQLite names columns of data returned by SELECT statements
+    when the expression for the column is a table-column name or the
+    wildcard "*".  Normally, such result columns are named
+    &lt;table-name/alias&gt;&lt;column-name&gt; if the SELECT statement joins 
+    two or
+    more tables together, or simply &lt;column-name&gt; if the SELECT
+    statement queries a single table. When the full-column-names flag
+    is set, such columns are always named &lt;table-name/alias&gt;
+    &lt;column-name&gt; regardless of whether or not a join is performed.
+    </p>
+    <p>If both the short-column-names and full-column-names are set,
+    then the behaviour associated with the full-column-names flag is
+    exhibited.
+    </p>
+</li>
+
+<a name="pragma_fullfsync"></a>
+<li><p><b>PRAGMA fullfsync
+       <br>PRAGMA fullfsync = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query or change the fullfsync flag. This flag affects
+    determines whether or not the F_FULLFSYNC syncing method is used
+    on systems that support it.  The default value is off.  As of this
+    writing (2006-02-10) only Mac OS X supports F_FULLFSYNC.
+    </p>
+</li>
+
+<a name="pragma_incremental_vacuum"></a>
+<li><p><b>PRAGMA incremental_vacuum</b><i>(N)</i><b>;</b></p>
+    <p>The incremental_vacuum pragma causes up to <i>N</i> pages to
+    be removed from the freelist.  The database file is truncated by
+    the same amount.  The incremental_vacuum pragma has no effect if
+    the database is not in
+    <a href="#pragma_auto_vacuum">auto_vacuum==incremental</a> mode
+    or if there are no pages on the freelist.  If there are fewer than
+    <i>N</i> pages on the freelist, then the entire freelist is cleared.</p>
+
+    <p>As of version 3.4.0 (the first version that supports
+    incremental_vacuum) this feature is still experimental.  Possible
+    future changes include enhancing incremental vacuum to do
+    defragmentation and node repacking just as the full-blown
+    <a href="lang_vacuum.html">VACUUM</a> command does.  And
+    incremental vacuum may be promoted from a pragma to a separate
+    SQL command, or perhaps some variation on the VACUUM command.
+    Programmers are cautioned to not become enamored with the
+    current syntax or functionality as it is likely to change.</p>
+</li>
+
+
+<a name="pragma_legacy_file_format"></a>
+<li><p><b>PRAGMA legacy_file_format;
+       <br>PRAGMA legacy_file_format = <i>ON | OFF</i></b></p>
+    <p>This pragma sets or queries the value of the legacy_file_format
+    flag.  When this flag is on, new SQLite databases are created in
+    a file format that is readable and writable by all versions of
+    SQLite going back to 3.0.0.  When the flag is off, new databases
+    are created using the latest file format which might not be
+    readable or writable by older versions of SQLite.</p>
+
+    <p>This flag only affects newly created databases.  It has no
+    effect on databases that already exist.</p>
+</li>
+
+<a name="pragma_locking_mode"></a>
+<li><p><b>PRAGMA locking_mode;
+       <br>PRAGMA locking_mode = <i>NORMAL | EXCLUSIVE</i></b></p>
+    <p>This pragma sets or queries the database connection locking-mode. 
+    The locking-mode is either NORMAL or EXCLUSIVE.
+
+    <p>In NORMAL locking-mode (the default), a database connection
+    unlocks the database file at the conclusion of each read or
+    write transaction. When the locking-mode is set to EXCLUSIVE, the
+    database connection never releases file-locks. The first time the
+    database is read in EXCLUSIVE mode, a shared lock is obtained and 
+    held. The first time the database is written, an exclusive lock is
+    obtained and held.</p>
+
+    <p>Database locks obtained by a connection in EXCLUSIVE mode may be
+    released either by closing the database connection, or by setting the
+    locking-mode back to NORMAL using this pragma and then accessing the
+    database file (for read or write). Simply setting the locking-mode to
+    NORMAL is not enough - locks are not be released until the next time
+    the database file is accessed.</p>
+
+    <p>There are two reasons to set the locking-mode to EXCLUSIVE. One
+    is if the application actually wants to prevent other processes from
+    accessing the database file. The other is that a small number of
+    filesystem operations are saved by optimizations enabled in this
+    mode. This may be significant in embedded environments.</p>
+
+    <p>When the locking_mode pragma specifies a particular database,
+    for example:</p>
+
+    <blockquote>
+PRAGMA <b>main.</b>locking_mode=EXCLUSIVE;
+    </blockquote>
+
+    <p>Then the locking mode applies only to the named database.  If no
+    database name qualifier preceeds the "locking_mode" keyword then
+    the locking mode is applied to all databases, including any new
+    databases added by subsequent <a href="lang_attach.html">ATTACH</a>
+    commands.</p>
+
+   <p>The "temp" database (in which TEMP tables and indices are stored)
+   always uses exclusive locking mode.  The locking mode of temp cannot
+   be changed.  All other databases use the normal locking mode by default
+   and are affected by this pragma.</p>
+</li>
+
+<a name="pragma_page_size"></a>
+<li><p><b>PRAGMA page_size;
+       <br>PRAGMA page_size = </b><i>bytes</i><b>;</b></p>
+    <p>Query or set the page-size of the database. The page-size
+    may only be set if the database has not yet been created. The page
+    size must be a power of two greater than or equal to 512 and less
+    than or equal to 8192. The upper limit may be modified by setting
+    the value of macro SQLITE_MAX_PAGE_SIZE during compilation.  The
+    maximum upper bound is 32768.
+    </p>
+</li>
+
+<a name="pragma_max_page_count"></a>
+<li><p><b>PRAGMA max_page_count;
+       <br>PRAGMA max_page_count = </b><i>N</i><b>;</b></p>
+    <p>Query or set the maximum number of pages in the database file.
+    Both forms of the pragma return the maximum page count.  The second
+    form attempts to modify the maximum page count.  The maximum page
+    count cannot be reduced below the current database size.
+    </p>
+</li>
+
+<a name="pragma_read_uncommitted"></a>
+<li><p><b>PRAGMA read_uncommitted;
+       <br>PRAGMA read_uncommitted = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query, set, or clear READ UNCOMMITTED isolation.  The default isolation
+    level for SQLite is SERIALIZABLE.  Any process or thread can select
+    READ UNCOMMITTED isolation, but SERIALIZABLE will still be used except
+    between connections that share a common page and schema cache.
+    Cache sharing is enabled using the
+    <a href="capi3ref.html#sqlite3_enable_shared_cache">
+    sqlite3_enable_shared_cache()</a> API and is only available between
+    connections running the same thread.  Cache sharing is off by default.
+    </p>
+</li>
+
+<a name="pragma_short_column_names"></a>
+<li><p><b>PRAGMA short_column_names;
+       <br>PRAGMA short_column_names = </b><i>0 | 1</i><b>;</b></p>
+    <p>Query or change the short-column-names flag. This flag affects
+    the way SQLite names columns of data returned by SELECT statements
+    when the expression for the column is a table-column name or the
+    wildcard "*".  Normally, such result columns are named
+    &lt;table-name/alias&gt;lt;column-name&gt; if the SELECT statement 
+    joins two or more tables together, or simply &lt;column-name&gt; if 
+    the SELECT statement queries a single table. When the short-column-names 
+    flag is set, such columns are always named &lt;column-name&gt; 
+    regardless of whether or not a join is performed.
+    </p>
+    <p>If both the short-column-names and full-column-names are set,
+    then the behaviour associated with the full-column-names flag is
+    exhibited.
+    </p>
+</li>
+
+<a name="pragma_synchronous"></a>
+<li><p><b>PRAGMA synchronous;
+       <br>PRAGMA synchronous = FULL; </b>(2)<b>
+       <br>PRAGMA synchronous = NORMAL; </b>(1)<b>
+       <br>PRAGMA synchronous = OFF; </b>(0)</p>
+    <p>Query or change the setting of the "synchronous" flag.  
+    The first (query) form will return the setting as an 
+    integer.  When synchronous is FULL (2), the SQLite database engine will
+    pause at critical moments to make sure that data has actually been 
+    written to the disk surface before continuing.  This ensures that if
+    the operating system crashes or if there is a power failure, the database
+    will be uncorrupted after rebooting.  FULL synchronous is very 
+    safe, but it is also slow.  
+    When synchronous is NORMAL, the SQLite database
+    engine will still pause at the most critical moments, but less often
+    than in FULL mode.  There is a very small (though non-zero) chance that
+    a power failure at just the wrong time could corrupt the database in
+    NORMAL mode.  But in practice, you are more likely to suffer
+    a catastrophic disk failure or some other unrecoverable hardware
+    fault.
+    With synchronous OFF (0), SQLite continues without pausing
+    as soon as it has handed data off to the operating system.
+    If the application running SQLite crashes, the data will be safe, but
+    the database might become corrupted if the operating system
+    crashes or the computer loses power before that data has been written
+    to the disk surface.  On the other hand, some
+    operations are as much as 50 or more times faster with synchronous OFF.
+    </p>
+    <p>In SQLite version 2, the default value is NORMAL. For version 3, the
+    default was changed to FULL.
+    </p>
+</li>
+
+
+<a name="pragma_temp_store"></a>
+<li><p><b>PRAGMA temp_store;
+       <br>PRAGMA temp_store = DEFAULT;</b> (0)<b>
+       <br>PRAGMA temp_store = FILE;</b> (1)<b>
+       <br>PRAGMA temp_store = MEMORY;</b> (2)</p>
+    <p>Query or change the setting of the "<b>temp_store</b>" parameter.
+    When temp_store is DEFAULT (0), the compile-time C preprocessor macro
+    TEMP_STORE is used to determine where temporary tables and indices
+    are stored.  When
+    temp_store is MEMORY (2) temporary tables and indices are kept in memory.
+    When temp_store is FILE (1) temporary tables and indices are stored
+    in a file.  The <a href="#pragma_temp_store_directory">
+    temp_store_directory</a> pragma can be used to specify the directory
+    containing this file.
+    <b>FILE</b> is specified. When the temp_store setting is changed,
+    all existing temporary tables, indices, triggers, and views are
+    immediately deleted.</p>
+
+    <p>It is possible for the library compile-time C preprocessor symbol
+    TEMP_STORE to override this pragma setting.  The following table summarizes
+    the interaction of the TEMP_STORE preprocessor macro and the
+    temp_store pragma:</p>
+
+    <blockquote>
+    <table cellpadding="2" border="1">
+    <tr><th valign="bottom">TEMP_STORE</th>
+        <th valign="bottom">PRAGMA<br>temp_store</th>
+        <th>Storage used for<br>TEMP tables and indices</th></tr>
+    <tr><td align="center">0</td>
+        <td align="center"><em>any</em></td>
+        <td align="center">file</td></tr>
+    <tr><td align="center">1</td>
+        <td align="center">0</td>
+        <td align="center">file</td></tr>
+    <tr><td align="center">1</td>
+        <td align="center">1</td>
+        <td align="center">file</td></tr>
+    <tr><td align="center">1</td>
+        <td align="center">2</td>
+        <td align="center">memory</td></tr>
+    <tr><td align="center">2</td>
+        <td align="center">0</td>
+        <td align="center">memory</td></tr>
+    <tr><td align="center">2</td>
+        <td align="center">1</td>
+        <td align="center">file</td></tr>
+    <tr><td align="center">2</td>
+        <td align="center">2</td>
+        <td align="center">memory</td></tr>
+    <tr><td align="center">3</td>
+        <td align="center"><em>any</em></td>
+        <td align="center">memory</td></tr>
+    </table>
+    </blockquote>
+    </li>
+    <br>
+
+<a name="pragma_temp_store_directory"></a>
+<li><p><b>PRAGMA temp_store_directory;
+       <br>PRAGMA temp_store_directory = 'directory-name';</b></p>
+    <p>Query or change the setting of the "temp_store_directory" - the
+    directory where files used for storing temporary tables and indices
+    are kept.  This setting lasts for the duration of the current connection
+    only and resets to its default value for each new connection opened.
+
+    <p>When the temp_store_directory setting is changed, all existing temporary
+    tables, indices, triggers, and viewers are immediately deleted.  In
+    practice, temp_store_directory should be set immediately after the 
+    database is opened.  </p>
+
+    <p>The value <i>directory-name</i> should be enclosed in single quotes.
+    To revert the directory to the default, set the <i>directory-name</i> to
+    an empty string, e.g., <i>PRAGMA temp_store_directory = ''</i>.  An
+    error is raised if <i>directory-name</i> is not found or is not
+    writable. </p>
+
+    <p>The default directory for temporary files depends on the OS.  For
+    Unix/Linux/OSX, the default is the is the first writable directory found
+    in the list of: <b>/var/tmp, /usr/tmp, /tmp,</b> and <b>
+    <i>current-directory</i></b>.  For Windows NT, the default 
+    directory is determined by Windows, generally
+    <b>C:\Documents and Settings\<i>user-name</i>\Local Settings\Temp\</b>. 
+    Temporary files created by SQLite are unlinked immediately after
+    opening, so that the operating system can automatically delete the
+    files when the SQLite process exits.  Thus, temporary files are not
+    normally visible through <i>ls</i> or <i>dir</i> commands.</p>
+ 
+    </li>
+</ul>
+}
+
+Section {Pragmas to query the database schema} schema
+
+puts {
+<ul>
+<a name="pragma_database_list"></a>
+<li><p><b>PRAGMA database_list;</b></p>
+    <p>For each open database, invoke the callback function once with
+    information about that database.  Arguments include the index and 
+    the name the database was attached with.  The first row will be for 
+    the main database.  The second row will be for the database used to 
+    store temporary tables.</p></li>
+
+<a name="pragma_foreign_key_list"></a>
+<li><p><b>PRAGMA foreign_key_list(</b><i>table-name</i><b>);</b></p>
+    <p>For each foreign key that references a column in the argument
+    table, invoke the callback function with information about that
+    foreign key. The callback function will be invoked once for each
+    column in each foreign key.</p></li>
+
+<a name="pragma_freelist_count"></a>
+<li><p><b>PRAGMA [database].freelist_count;</b></p>
+    <p>Return the number of unused pages in the database file. Running
+    a <a href="#pragma_incremental_vacuum">"PRAGMA incremental_vaccum(N);"</a> 
+    command with a large value of N will shrink the database file by this
+    number of pages. </p></li>
+
+<a name="pragma_index_info"></a>
+<li><p><b>PRAGMA index_info(</b><i>index-name</i><b>);</b></p>
+    <p>For each column that the named index references, invoke the 
+    callback function
+    once with information about that column, including the column name,
+    and the column number.</p></li>
+
+<a name="pragma_index_list"></a>
+<li><p><b>PRAGMA index_list(</b><i>table-name</i><b>);</b></p>
+    <p>For each index on the named table, invoke the callback function
+    once with information about that index.  Arguments include the
+    index name and a flag to indicate whether or not the index must be
+    unique.</p></li>
+
+<a name="pragma_table_info"></a>
+<li><p><b>PRAGMA table_info(</b><i>table-name</i><b>);</b></p>
+    <p>For each column in the named table, invoke the callback function
+    once with information about that column, including the column name,
+    data type, whether or not the column can be NULL, and the default
+    value for the column.</p></li>
+</ul>
+}
+
+Section {Pragmas to query/modify version values} version
+
+puts {
+
+<ul>
+<a name="pragma_schema_version"></a>
+<a name="pragma_user_version"></a>
+<li><p><b>PRAGMA [database.]schema_version; 
+       <br>PRAGMA [database.]schema_version = </b><i>integer </i><b>;
+       <br>PRAGMA [database.]user_version;
+       <br>PRAGMA [database.]user_version = </b><i>integer </i><b>;</b>
+
+  
+<p>    The pragmas schema_version and user_version are used to set or get
+       the value of the schema-version and user-version, respectively. Both
+       the schema-version and the user-version are 32-bit signed integers
+       stored in the database header.</p>
+  
+<p>    The schema-version is usually only manipulated internally by SQLite.  
+       It is incremented by SQLite whenever the database schema is modified 
+       (by creating or dropping a table or index). The schema version is 
+       used by SQLite each time a query is executed to ensure that the 
+       internal cache of the schema used when compiling the SQL query matches 
+       the schema of the database against which the compiled query is actually 
+       executed.  Subverting this mechanism by using "PRAGMA schema_version" 
+       to modify the schema-version is potentially dangerous and may lead 
+       to program crashes or database corruption. Use with caution!</p>
+  
+<p>    The user-version is not used internally by SQLite. It may be used by
+       applications for any purpose.</p>
+</li>
+</ul>
+}
+
+Section {Pragmas to debug the library} debug
+
+puts {
+<ul>
+<a name="pragma_integrity_check"></a>
+<li><p><b>PRAGMA integrity_check;
+    <br>PRAGMA integrity_check(</b><i>integer</i><b>)</b></p>
+    <p>The command does an integrity check of the entire database.  It
+    looks for out-of-order records, missing pages, malformed records, and
+    corrupt indices.
+    If any problems are found, then strings are returned (as multiple
+    rows with a single column per row) which describe
+    the problems.  At most <i>integer</i> errors will be reported
+    before the analysis quits.  The default value for <i>integer</i>
+    is 100.  If no errors are found, a single row with the value "ok" is
+    returned.</p></li>
+
+<a name="pragma_parser_trace"></a>
+<li><p><b>PRAGMA parser_trace = ON; </b>(1)<b>
+    <br>PRAGMA parser_trace = OFF;</b> (0)</p>
+    <p>Turn tracing of the SQL parser inside of the
+    SQLite library on and off.  This is used for debugging.
+    This only works if the library is compiled without the NDEBUG macro.
+    </p></li>
+
+<a name="pragma_vdbe_trace"></a>
+<li><p><b>PRAGMA vdbe_trace = ON; </b>(1)<b>
+    <br>PRAGMA vdbe_trace = OFF;</b> (0)</p>
+    <p>Turn tracing of the virtual database engine inside of the
+    SQLite library on and off.  This is used for debugging.  See the 
+    <a href="vdbe.html#trace">VDBE documentation</a> for more 
+    information.</p></li>
+
+<a name="pragma_vdbe_listing"></a>
+<li><p><b>PRAGMA vdbe_listing = ON; </b>(1)<b>
+    <br>PRAGMA vdbe_listing = OFF;</b> (0)</p>
+    <p>Turn listings of virtual machine programs on and off.
+    With listing is on, the entire content of a program is printed
+    just prior to beginning execution.  This is like automatically
+    executing an EXPLAIN prior to each statement.  The statement
+    executes normally after the listing is printed.
+    This is used for debugging.  See the 
+    <a href="vdbe.html#trace">VDBE documentation</a> for more 
+    information.</p></li>
+</ul>
+
+}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/quickstart.tcl b/client/src/thirdparty/sqlite-3.4.2/www/quickstart.tcl
new file mode 100644
index 0000000..8ae3d72
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/quickstart.tcl
@@ -0,0 +1,110 @@
+#
+# Run this TCL script to generate HTML for the quickstart.html file.
+#
+set rcsid {$Id: quickstart.tcl,v 1.8 2006/06/13 11:27:22 drh Exp $}
+source common.tcl
+header {SQLite In 5 Minutes Or Less}
+puts {
+<p>Here is what you do to start experimenting with SQLite without having
+to do a lot of tedious reading and configuration:</p>
+
+<h2>Download The Code</h2>
+
+<ul>
+<li><p>Get a copy of the prebuilt binaries for your machine, or get a copy
+of the sources and compile them yourself.  Visit
+the <a href="download.html">download</a> page for more information.</p></li>
+</ul>
+
+<h2>Create A New Database</h2>
+
+<ul>
+<li><p>At a shell or DOS prompt, enter: "<b>sqlite3 test.db</b>".  This will
+create a new database named "test.db".  (You can use a different name if
+you like.)</p></li>
+<li><p>Enter SQL commands at the prompt to create and populate the
+new database.</p></li>
+<li><p>Additional documentation is available <a href="sqlite.html">here</a></li>
+</ul>
+
+<h2>Write Programs That Use SQLite</h2>
+
+<ul>
+<li><p>Below is a simple TCL program that demonstrates how to use
+the TCL interface to SQLite.  The program executes the SQL statements
+given as the second argument on the database defined by the first
+argument.  The commands to watch for are the <b>sqlite3</b> command
+on line 7 which opens an SQLite database and creates
+a new TCL command named "<b>db</b>" to access that database, the
+invocation of the <b>db</b> command on line 8 to execute
+SQL commands against the database, and the closing of the database connection
+on the last line of the script.</p>
+
+<blockquote><pre>
+#!/usr/bin/tclsh
+if {$argc!=2} {
+  puts stderr "Usage: %s DATABASE SQL-STATEMENT"
+  exit 1
+}
+load /usr/lib/tclsqlite3.so Sqlite3
+<b>sqlite3</b> db [lindex $argv 0]
+<b>db</b> eval [lindex $argv 1] x {
+  foreach v $x(*) {
+    puts "$v = $x($v)"
+  }
+  puts ""
+}
+<b>db</b> close
+</pre></blockquote>
+</li>
+
+<li><p>Below is a simple C program that demonstrates how to use
+the C/C++ interface to SQLite.  The name of a database is given by
+the first argument and the second argument is one or more SQL statements
+to execute against the database.  The function calls to pay attention
+to here are the call to <b>sqlite3_open()</b> on line 22 which opens
+the database, <b>sqlite3_exec()</b> on line 27 that executes SQL
+commands against the database, and <b>sqlite3_close()</b> on line 31
+that closes the database connection.</p>
+
+<blockquote><pre>
+#include &lt;stdio.h&gt;
+#include &lt;sqlite3.h&gt;
+
+static int callback(void *NotUsed, int argc, char **argv, char **azColName){
+  int i;
+  for(i=0; i&lt;argc; i++){
+    printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+  }
+  printf("\n");
+  return 0;
+}
+
+int main(int argc, char **argv){
+  sqlite3 *db;
+  char *zErrMsg = 0;
+  int rc;
+
+  if( argc!=3 ){
+    fprintf(stderr, "Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);
+    exit(1);
+  }
+  rc = <b>sqlite3_open</b>(argv[1], &db);
+  if( rc ){
+    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
+    sqlite3_close(db);
+    exit(1);
+  }
+  rc = <b>sqlite3_exec</b>(db, argv[2], callback, 0, &zErrMsg);
+  if( rc!=SQLITE_OK ){
+    fprintf(stderr, "SQL error: %s\n", zErrMsg);
+    sqlite3_free(zErrMsg);
+  }
+  <b>sqlite3_close</b>(db);
+  return 0;
+}
+</pre></blockquote>
+</li>
+</ul>
+}
+footer {$Id: quickstart.tcl,v 1.8 2006/06/13 11:27:22 drh Exp $}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/shared.gif b/client/src/thirdparty/sqlite-3.4.2/www/shared.gif
new file mode 100644
index 0000000..68a1daf
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/shared.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4970bf2cdf53a5fd57eb36307b5cab98661d06b861466cac22d13c3264959f3d
+size 5787
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/sharedcache.tcl b/client/src/thirdparty/sqlite-3.4.2/www/sharedcache.tcl
new file mode 100644
index 0000000..c06c888
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/sharedcache.tcl
@@ -0,0 +1,221 @@
+#
+# Run this script to generated a sharedcache.html output file
+#
+set rcsid {$Id: }
+source common.tcl
+header {SQLite Shared-Cache Mode}
+
+proc HEADING {level title} {
+  global pnum
+  incr pnum($level)
+  foreach i [array names pnum] {
+    if {$i>$level} {set pnum($i) 0}
+  }
+  set h [expr {$level+1}]
+  if {$h>6} {set h 6}
+  set n $pnum(1).$pnum(2)
+  for {set i 3} {$i<=$level} {incr i} {
+    append n .$pnum($i)
+  }
+  puts "<h$h>$n $title</h$h>"
+}
+set pnum(1) 0
+set pnum(2) 0
+set pnum(3) 0
+set pnum(4) 0
+set pnum(5) 0
+set pnum(6) 0
+set pnum(7) 0
+set pnum(8) 0
+
+HEADING 1 {SQLite Shared-Cache Mode}
+
+puts {
+<p>Starting with version 3.3.0, SQLite includes a special "shared-cache"
+mode (disabled by default) intended for use in embedded servers. If
+shared-cache mode is enabled and a thread establishes multiple connections
+to the same database, the connections share a single data and schema cache.
+This can significantly reduce the quantity of memory and IO required by
+the system.</p>
+
+<p>Using shared-cache mode imposes some extra restrictions on 
+passing database handles between threads and changes the semantics
+of the locking model in some cases. These details are described in full by
+this document. A basic understanding of the normal SQLite locking model (see
+<a href="lockingv3.html">File Locking And Concurrency In SQLite Version 3</a>
+for details) is assumed.</p>
+}
+
+HEADING 1 {Shared-Cache Locking Model}
+
+puts {
+<p>Externally, from the point of view of another process or thread, two
+or more database connections using a shared-cache appear as a single 
+connection. The locking protocol used to arbitrate between multiple 
+shared-caches or regular database users is described elsewhere.
+</p>
+
+<table style="margin:auto">
+<tr><td>
+<img src="shared.gif">
+<!-- <pre>
+            +--------------+      +--------------+
+            | Connection 2 |      | Connection 3 |
+            +--------------+      +--------------+
+                         |          |
+                         V          V
++--------------+       +--------------+
+| Connection 1 |       | Shared cache |
++--------------+       +--------------+
+            |            |
+            V            V
+          +----------------+
+          |    Database    |
+          +----------------+
+</pre> -->
+</table>
+<p style="font-style:italic;text-align:center">Figure 1</p>
+
+<p>Figure 1 depicts an example runtime configuration where three 
+database connections have been established. Connection 1 is a normal
+SQLite database connection. Connections 2 and 3 share a cache (and so must
+have been established by the same process thread). The normal locking
+protocol is used to serialize database access between connection 1 and
+the shared cache. The internal protocol used to serialize (or not, see
+"Read-Uncommitted Isolation Mode" below) access to the shared-cache by
+connections 2 and 3 is described in the remainder of this section.
+</p>
+
+<p>There are three levels to the shared-cache locking model, 
+transaction level locking, table level locking and schema level locking. 
+They are described in the following three sub-sections.</p>
+
+}
+
+HEADING 2 {Transaction Level Locking}
+
+puts {
+<p>SQLite connections can open two kinds of transactions, read and write
+transactions. This is not done explicitly, a transaction is implicitly a
+read-transaction until it first writes to a database table, at which point
+it becomes a write-transaction.
+</p>
+<p>At most one connection to a single shared cache may open a 
+write transaction at any one time. This may co-exist with any number of read 
+transactions. 
+</p>
+}
+
+HEADING 2 {Table Level Locking}
+
+puts {
+<p>When two or more connections use a shared-cache, locks are used to 
+serialize concurrent access attempts on a per-table basis. Tables support 
+two types of locks, "read-locks" and "write-locks". Locks are granted to
+connections - at any one time, each database connection has either a
+read-lock, write-lock or no lock on each database table.
+</p>
+
+<p>At any one time, a single table may have any number of active read-locks
+or a single active write lock. To read data a table, a connection must 
+first obtain a read-lock. To write to a table, a connection must obtain a 
+write-lock on that table. If a required table lock cannot be obtained,
+the query fails and SQLITE_LOCKED is returned to the caller.
+</p> 
+
+<p>Once a connection obtains a table lock, it is not released until the
+current transaction (read or write) is concluded.
+</p>
+}
+
+HEADING 3 {Read-Uncommitted Isolation Mode}
+
+puts {
+<p>The behaviour described above may be modified slightly by using the 
+<i>read_uncommitted</i> pragma to change the isolation level from serialized 
+(the default), to read-uncommitted.</p>
+
+<p> A database connection in read-uncommitted mode does not attempt 
+to obtain read-locks before reading from database tables as described 
+above. This can lead to inconsistent query results if another database
+connection modifies a table while it is being read, but it also means that
+a read-transaction opened by a connection in read-uncommitted mode can
+neither block nor be blocked by any other connection.</p>
+
+<p>Read-uncommitted mode has no effect on the locks required to write to
+database tables (i.e. read-uncommitted connections must still obtain 
+write-locks and hence database writes may still block or be blocked). 
+Also, read-uncommitted mode has no effect on the <i>sqlite_master</i> 
+locks required by the rules enumerated below (see section 
+"Schema (sqlite_master) Level Locking").
+</p>
+
+<pre>
+  /* Set the value of the read-uncommitted flag:
+  **
+  **   True  -> Set the connection to read-uncommitted mode.
+  **   False -> Set the connectino to serialized (the default) mode.
+  */
+  PRAGMA read_uncommitted = &lt;boolean&gt;;
+
+  /* Retrieve the current value of the read-uncommitted flag */
+  PRAGMA read_uncommitted;
+</pre>
+}
+
+HEADING 2 {Schema (sqlite_master) Level Locking}
+
+puts {
+<p>The <i>sqlite_master</i> table supports shared-cache read and write 
+locks in the same way as all other database tables (see description 
+above). The following special rules also apply:
+</p>
+
+<ul>
+<li>A connection must obtain a read-lock on <i>sqlite_master</i> before 
+accessing any database tables or obtaining any other read or write locks.</li>
+<li>Before executing a statement that modifies the database schema (i.e. 
+a CREATE or DROP TABLE statement), a connection must obtain a write-lock on 
+<i>sqlite_master</i>.
+</li>
+<li>A connection may not compile an SQL statement if any other connection
+is holding a write-lock on the <i>sqlite_master</i> table of any attached
+database (including the default database, "main"). 
+</li>
+</ul>
+}
+
+HEADING 1 {Thread Related Issues}
+
+puts {
+<p>When shared-cache mode is enabled, a database connection may only be
+used by the thread that called sqlite3_open() to create it. If another 
+thread attempts to use the database connection, in most cases an 
+SQLITE_MISUSE error is returned. However this is not guaranteed and 
+programs should not depend on this behaviour, in some cases a segfault 
+may result.
+</p>
+}
+
+HEADING 1 {Enabling Shared-Cache Mode}
+
+puts {
+<p>Shared-cache mode is enabled on a thread-wide basis. Using the C 
+interface, the following API can be used to enable or disable shared-cache
+mode for the calling thread:
+</p>
+
+<pre>
+int sqlite3_enable_shared_cache(int);
+</pre>
+
+<p>It is illegal to call sqlite3_enable_shared_cache() if one or more 
+open database connections were opened by the calling thread. If the argument
+is non-zero, shared-cache mode is enabled. If the argument is zero,
+shared-cache mode is disabled. The return value is either SQLITE_OK (if the
+operation was successful), SQLITE_NOMEM (if a malloc() failed), or
+SQLITE_MISUSE (if the thread has open database connections).
+</p>
+}
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/speed.tcl b/client/src/thirdparty/sqlite-3.4.2/www/speed.tcl
new file mode 100644
index 0000000..b60cfe1
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/speed.tcl
@@ -0,0 +1,495 @@
+#
+# Run this Tcl script to generate the speed.html file.
+#
+set rcsid {$Id: speed.tcl,v 1.17 2005/03/12 15:55:11 drh Exp $ }
+source common.tcl
+header {SQLite Database Speed Comparison}
+
+puts {
+<h2>Database Speed Comparison</h2>
+
+<font color="red"><b>
+Note:  This document is old.  It describes a speed comparison between
+an older version of SQLite against archaic versions of MySQL and PostgreSQL.
+Readers are invited to contribute more up-to-date speed comparisons
+on the <a href="http://www.sqlite.org/cvstrac/wiki">SQLite Wiki</a>.
+<p>
+The numbers here are old enough to be nearly meaningless.  Until it is
+updated, use this document only as proof that SQLite is not a
+sluggard.
+</b></font>
+
+<h3>Executive Summary</h3>
+
+<p>A series of tests were run to measure the relative performance of
+SQLite 2.7.6, PostgreSQL 7.1.3, and MySQL 3.23.41.
+The following are general
+conclusions drawn from these experiments:
+</p>
+
+<ul>
+<li><p>
+  SQLite 2.7.6 is significantly faster (sometimes as much as 10 or
+  20 times faster) than the default PostgreSQL 7.1.3 installation
+  on RedHat 7.2 for most common operations.  
+</p></li>
+<li><p>
+  SQLite 2.7.6 is often faster (sometimes
+  more than twice as fast) than MySQL 3.23.41
+  for most common operations.
+</p></li>
+<li><p>
+  SQLite does not execute CREATE INDEX or DROP TABLE as fast as
+  the other databases.  But this is not seen as a problem because
+  those are infrequent operations.
+</p></li>
+<li><p>
+  SQLite works best if you group multiple operations together into
+  a single transaction.
+</p></li>
+</ul>
+
+<p>
+The results presented here come with the following caveats:
+</p>
+
+<ul>
+<li><p>
+  These tests did not attempt to measure multi-user performance or
+  optimization of complex queries involving multiple joins and subqueries.
+</p></li>
+<li><p>
+  These tests are on a relatively small (approximately 14 megabyte) database.
+  They do not measure how well the database engines scale to larger problems.
+</p></li>
+</ul>
+
+<h3>Test Environment</h3>
+
+<p>
+The platform used for these tests is a 1.6GHz Athlon with 1GB or memory
+and an IDE disk drive.  The operating system is RedHat Linux 7.2 with
+a stock kernel.
+</p>
+
+<p>
+The PostgreSQL and MySQL servers used were as delivered by default on
+RedHat 7.2.  (PostgreSQL version 7.1.3 and MySQL version 3.23.41.)
+No effort was made to tune these engines.  Note in particular
+the the default MySQL configuration on RedHat 7.2 does not support
+transactions.  Not having to support transactions gives MySQL a
+big speed advantage, but SQLite is still able to hold its own on most
+tests.
+</p>
+
+<p>
+I am told that the default PostgreSQL configuration in RedHat 7.3
+is unnecessarily conservative (it is designed to
+work on a machine with 8MB of RAM) and that PostgreSQL could
+be made to run a lot faster with some knowledgeable configuration
+tuning.
+Matt Sergeant reports that he has tuned his PostgreSQL installation
+and rerun the tests shown below.  His results show that
+PostgreSQL and MySQL run at about the same speed.  For Matt's
+results, visit
+</p>
+
+<blockquote>
+<a href="http://www.sergeant.org/sqlite_vs_pgsync.html">
+http://www.sergeant.org/sqlite_vs_pgsync.html</a>
+</blockquote>
+
+<p>
+SQLite was tested in the same configuration that it appears
+on the website.  It was compiled with -O6 optimization and with
+the -DNDEBUG=1 switch which disables the many "assert()" statements
+in the SQLite code.  The -DNDEBUG=1 compiler option roughly doubles
+the speed of SQLite.
+</p>
+
+<p>
+All tests are conducted on an otherwise quiescent machine.
+A simple Tcl script was used to generate and run all the tests.
+A copy of this Tcl script can be found in the SQLite source tree
+in the file <b>tools/speedtest.tcl</b>.
+</p>
+
+<p>
+The times reported on all tests represent wall-clock time 
+in seconds.  Two separate time values are reported for SQLite.
+The first value is for SQLite in its default configuration with
+full disk synchronization turned on.  With synchronization turned
+on, SQLite executes
+an <b>fsync()</b> system call (or the equivalent) at key points
+to make certain that critical data has 
+actually been written to the disk drive surface.  Synchronization
+is necessary to guarantee the integrity of the database if the
+operating system crashes or the computer powers down unexpectedly
+in the middle of a database update.  The second time reported for SQLite is
+when synchronization is turned off.  With synchronization off,
+SQLite is sometimes much faster, but there is a risk that an
+operating system crash or an unexpected power failure could
+damage the database.  Generally speaking, the synchronous SQLite
+times are for comparison against PostgreSQL (which is also
+synchronous) and the asynchronous SQLite times are for 
+comparison against the asynchronous MySQL engine.
+</p>
+
+<h3>Test 1: 1000 INSERTs</h3>
+<blockquote>
+CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100));<br>
+INSERT INTO t1 VALUES(1,13153,'thirteen thousand one hundred fifty three');<br>
+INSERT INTO t1 VALUES(2,75560,'seventy five thousand five hundred sixty');<br>
+<i>... 995 lines omitted</i><br>
+INSERT INTO t1 VALUES(998,66289,'sixty six thousand two hundred eighty nine');<br>
+INSERT INTO t1 VALUES(999,24322,'twenty four thousand three hundred twenty two');<br>
+INSERT INTO t1 VALUES(1000,94142,'ninety four thousand one hundred forty two');<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;4.373</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.114</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;13.061</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.223</td></tr>
+</table>
+
+<p>
+Because it does not have a central server to coordinate access,
+SQLite must close and reopen the database file, and thus invalidate
+its cache, for each transaction.  In this test, each SQL statement
+is a separate transaction so the database file must be opened and closed
+and the cache must be flushed 1000 times.  In spite of this, the asynchronous
+version of SQLite is still nearly as fast as MySQL.  Notice how much slower
+the synchronous version is, however.  SQLite calls <b>fsync()</b> after 
+each synchronous transaction to make sure that all data is safely on
+the disk surface before continuing.  For most of the 13 seconds in the
+synchronous test, SQLite was sitting idle waiting on disk I/O to complete.</p>
+
+
+<h3>Test 2: 25000 INSERTs in a transaction</h3>
+<blockquote>
+BEGIN;<br>
+CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100));<br>
+INSERT INTO t2 VALUES(1,59672,'fifty nine thousand six hundred seventy two');<br>
+<i>... 24997 lines omitted</i><br>
+INSERT INTO t2 VALUES(24999,89569,'eighty nine thousand five hundred sixty nine');<br>
+INSERT INTO t2 VALUES(25000,94666,'ninety four thousand six hundred sixty six');<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;4.900</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;2.184</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;0.914</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.757</td></tr>
+</table>
+
+<p>
+When all the INSERTs are put in a transaction, SQLite no longer has to
+close and reopen the database or invalidate its cache between each statement.
+It also does not
+have to do any fsync()s until the very end.  When unshackled in
+this way, SQLite is much faster than either PostgreSQL and MySQL.
+</p>
+
+<h3>Test 3: 25000 INSERTs into an indexed table</h3>
+<blockquote>
+BEGIN;<br>
+CREATE TABLE t3(a INTEGER, b INTEGER, c VARCHAR(100));<br>
+CREATE INDEX i3 ON t3(c);<br>
+<i>... 24998 lines omitted</i><br>
+INSERT INTO t3 VALUES(24999,88509,'eighty eight thousand five hundred nine');<br>
+INSERT INTO t3 VALUES(25000,84791,'eighty four thousand seven hundred ninety one');<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;8.175</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;3.197</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;1.555</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;1.402</td></tr>
+</table>
+
+<p>
+There were reports that SQLite did not perform as well on an indexed table.
+This test was recently added to disprove those rumors.  It is true that
+SQLite is not as fast at creating new index entries as the other engines
+(see Test 6 below) but its overall speed is still better.
+</p>
+
+<h3>Test 4: 100 SELECTs without an index</h3>
+<blockquote>
+BEGIN;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=0 AND b<1000;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=100 AND b<1100;<br>
+<i>... 96 lines omitted</i><br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=9800 AND b<10800;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=9900 AND b<10900;<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;3.629</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;2.760</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;2.494</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;2.526</td></tr>
+</table>
+
+
+<p>
+This test does 100 queries on a 25000 entry table without an index,
+thus requiring a full table scan.   Prior versions of SQLite used to
+be slower than PostgreSQL and MySQL on this test, but recent performance
+enhancements have increased its speed so that it is now the fastest
+of the group.
+</p>
+
+<h3>Test 5: 100 SELECTs on a string comparison</h3>
+<blockquote>
+BEGIN;<br>
+SELECT count(*), avg(b) FROM t2 WHERE c LIKE '%one%';<br>
+SELECT count(*), avg(b) FROM t2 WHERE c LIKE '%two%';<br>
+<i>... 96 lines omitted</i><br>
+SELECT count(*), avg(b) FROM t2 WHERE c LIKE '%ninety nine%';<br>
+SELECT count(*), avg(b) FROM t2 WHERE c LIKE '%one hundred%';<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;13.409</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;4.640</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;3.362</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;3.372</td></tr>
+</table>
+
+<p>
+This test still does 100 full table scans but it uses
+uses string comparisons instead of numerical comparisons.
+SQLite is over three times faster than PostgreSQL here and about 30%
+faster than MySQL.
+</p>
+
+<h3>Test 6: Creating an index</h3>
+<blockquote>
+CREATE INDEX i2a ON t2(a);<br>CREATE INDEX i2b ON t2(b);
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.381</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.318</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;0.777</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.659</td></tr>
+</table>
+
+<p>
+SQLite is slower at creating new indices.  This is not a huge problem
+(since new indices are not created very often) but it is something that
+is being worked on.  Hopefully, future versions of SQLite will do better
+here.
+</p>
+
+<h3>Test 7: 5000 SELECTs with an index</h3>
+<blockquote>
+SELECT count(*), avg(b) FROM t2 WHERE b>=0 AND b<100;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=100 AND b<200;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=200 AND b<300;<br>
+<i>... 4994 lines omitted</i><br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=499700 AND b<499800;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=499800 AND b<499900;<br>
+SELECT count(*), avg(b) FROM t2 WHERE b>=499900 AND b<500000;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;4.614</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.270</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;1.121</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;1.162</td></tr>
+</table>
+
+<p>
+All three database engines run faster when they have indices to work with.
+But SQLite is still the fastest.
+</p>
+
+<h3>Test 8: 1000 UPDATEs without an index</h3>
+<blockquote>
+BEGIN;<br>
+UPDATE t1 SET b=b*2 WHERE a>=0 AND a<10;<br>
+UPDATE t1 SET b=b*2 WHERE a>=10 AND a<20;<br>
+<i>... 996 lines omitted</i><br>
+UPDATE t1 SET b=b*2 WHERE a>=9980 AND a<9990;<br>
+UPDATE t1 SET b=b*2 WHERE a>=9990 AND a<10000;<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.739</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;8.410</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;0.637</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.638</td></tr>
+</table>
+
+<p>
+For this particular UPDATE test, MySQL is consistently
+five or ten times
+slower than PostgreSQL and SQLite.  I do not know why.  MySQL is
+normally a very fast engine.  Perhaps this problem has been addressed
+in later versions of MySQL.
+</p>
+
+<h3>Test 9: 25000 UPDATEs with an index</h3>
+<blockquote>
+BEGIN;<br>
+UPDATE t2 SET b=468026 WHERE a=1;<br>
+UPDATE t2 SET b=121928 WHERE a=2;<br>
+<i>... 24996 lines omitted</i><br>
+UPDATE t2 SET b=35065 WHERE a=24999;<br>
+UPDATE t2 SET b=347393 WHERE a=25000;<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;18.797</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;8.134</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;3.520</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;3.104</td></tr>
+</table>
+
+<p>
+As recently as version 2.7.0, SQLite ran at about the same speed as
+MySQL on this test.  But recent optimizations to SQLite have more
+than doubled speed of UPDATEs.
+</p>
+
+<h3>Test 10: 25000 text UPDATEs with an index</h3>
+<blockquote>
+BEGIN;<br>
+UPDATE t2 SET c='one hundred forty eight thousand three hundred eighty two' WHERE a=1;<br>
+UPDATE t2 SET c='three hundred sixty six thousand five hundred two' WHERE a=2;<br>
+<i>... 24996 lines omitted</i><br>
+UPDATE t2 SET c='three hundred eighty three thousand ninety nine' WHERE a=24999;<br>
+UPDATE t2 SET c='two hundred fifty six thousand eight hundred thirty' WHERE a=25000;<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;48.133</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;6.982</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;2.408</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;1.725</td></tr>
+</table>
+
+<p>
+Here again, version 2.7.0 of SQLite used to run at about the same speed
+as MySQL.  But now version 2.7.6 is over two times faster than MySQL and
+over twenty times faster than PostgreSQL.
+</p>
+
+<p>
+In fairness to PostgreSQL, it started thrashing on this test.  A
+knowledgeable administrator might be able to get PostgreSQL to run a lot
+faster here by tweaking and tuning the server a little.
+</p>
+
+<h3>Test 11: INSERTs from a SELECT</h3>
+<blockquote>
+BEGIN;<br>INSERT INTO t1 SELECT b,a,c FROM t2;<br>INSERT INTO t2 SELECT b,a,c FROM t1;<br>COMMIT;
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;61.364</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.537</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;2.787</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;1.599</td></tr>
+</table>
+
+<p>
+The asynchronous SQLite is just a shade slower than MySQL on this test.
+(MySQL seems to be especially adept at INSERT...SELECT statements.)
+The PostgreSQL engine is still thrashing - most of the 61 seconds it used
+were spent waiting on disk I/O.
+</p>
+
+<h3>Test 12: DELETE without an index</h3>
+<blockquote>
+DELETE FROM t2 WHERE c LIKE '%fifty%';
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.509</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.975</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;4.004</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.560</td></tr>
+</table>
+
+<p>
+The synchronous version of SQLite is the slowest of the group in this test,
+but the asynchronous version is the fastest.  
+The difference is the extra time needed to execute fsync().
+</p>
+
+<h3>Test 13: DELETE with an index</h3>
+<blockquote>
+DELETE FROM t2 WHERE a>10 AND a<20000;
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.316</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;2.262</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;2.068</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.752</td></tr>
+</table>
+
+<p>
+This test is significant because it is one of the few where
+PostgreSQL is faster than MySQL.  The asynchronous SQLite is,
+however, faster then both the other two.
+</p>
+
+<h3>Test 14: A big INSERT after a big DELETE</h3>
+<blockquote>
+INSERT INTO t2 SELECT * FROM t1;
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;13.168</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.815</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;3.210</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;1.485</td></tr>
+</table>
+
+<p>
+Some older versions of SQLite (prior to version 2.4.0)
+would show decreasing performance after a
+sequence of DELETEs followed by new INSERTs.  As this test shows, the
+problem has now been resolved.
+</p>
+
+<h3>Test 15: A big DELETE followed by many small INSERTs</h3>
+<blockquote>
+BEGIN;<br>
+DELETE FROM t1;<br>
+INSERT INTO t1 VALUES(1,10719,'ten thousand seven hundred nineteen');<br>
+<i>... 11997 lines omitted</i><br>
+INSERT INTO t1 VALUES(11999,72836,'seventy two thousand eight hundred thirty six');<br>
+INSERT INTO t1 VALUES(12000,64231,'sixty four thousand two hundred thirty one');<br>
+COMMIT;<br>
+
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;4.556</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;1.704</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;0.618</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.406</td></tr>
+</table>
+
+<p>
+SQLite is very good at doing INSERTs within a transaction, which probably
+explains why it is so much faster than the other databases at this test.
+</p>
+
+<h3>Test 16: DROP TABLE</h3>
+<blockquote>
+DROP TABLE t1;<br>DROP TABLE t2;<br>DROP TABLE t3;
+</blockquote><table border=0 cellpadding=0 cellspacing=0>
+<tr><td>PostgreSQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.135</td></tr>
+<tr><td>MySQL:</td><td align="right">&nbsp;&nbsp;&nbsp;0.015</td></tr>
+<tr><td>SQLite 2.7.6:</td><td align="right">&nbsp;&nbsp;&nbsp;0.939</td></tr>
+<tr><td>SQLite 2.7.6 (nosync):</td><td align="right">&nbsp;&nbsp;&nbsp;0.254</td></tr>
+</table>
+
+<p>
+SQLite is slower than the other databases when it comes to dropping tables.
+This probably is because when SQLite drops a table, it has to go through and
+erase the records in the database file that deal with that table.  MySQL and
+PostgreSQL, on the other hand, use separate files to represent each table
+so they can drop a table simply by deleting a file, which is much faster.
+</p>
+
+<p>
+On the other hand, dropping tables is not a very common operation 
+so if SQLite takes a little longer, that is not seen as a big problem.
+</p>
+
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/sqlite.tcl b/client/src/thirdparty/sqlite-3.4.2/www/sqlite.tcl
new file mode 100644
index 0000000..eed1cd7
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/sqlite.tcl
@@ -0,0 +1,582 @@
+#
+# Run this Tcl script to generate the sqlite.html file.
+#
+set rcsid {$Id: sqlite.tcl,v 1.25 2007/01/08 14:31:36 drh Exp $}
+source common.tcl
+header {sqlite3: A command-line access program for SQLite databases}
+puts {
+<h2>sqlite3: A command-line access program for SQLite databases</h2>
+
+<p>The SQLite library includes a simple command-line utility named
+<b>sqlite3</b> that allows the user to manually enter and execute SQL
+commands against an SQLite database.  This document provides a brief
+introduction on how to use <b>sqlite3</b>.
+
+<h3>Getting Started</h3>
+
+<p>To start the <b>sqlite3</b> program, just type "sqlite3" followed by
+the name the file that holds the SQLite database.  If the file does
+not exist, a new one is created automatically.
+The <b>sqlite3</b> program will
+then prompt you to enter SQL.  Type in SQL statements (terminated by a
+semicolon), press "Enter" and the SQL will be executed.</p>
+
+<p>For example, to create a new SQLite database named "ex1" 
+with a single table named "tbl1", you might do this:</p>
+}
+
+proc Code {body} {
+  puts {<blockquote><tt>}
+  regsub -all {&} [string trim $body] {\&amp;} body
+  regsub -all {>} $body {\&gt;} body
+  regsub -all {<} $body {\&lt;} body
+  regsub -all {\(\(\(} $body {<b>} body
+  regsub -all {\)\)\)} $body {</b>} body
+  regsub -all { } $body {\&nbsp;} body
+  regsub -all \n $body <br>\n body
+  puts $body
+  puts {</tt></blockquote>}
+}
+
+Code {
+$ (((sqlite3 ex1)))
+SQLite version 3.3.10
+Enter ".help" for instructions
+sqlite> (((create table tbl1(one varchar(10), two smallint);)))
+sqlite> (((insert into tbl1 values('hello!',10);)))
+sqlite> (((insert into tbl1 values('goodbye', 20);)))
+sqlite> (((select * from tbl1;)))
+hello!|10
+goodbye|20
+sqlite>
+}
+
+puts {
+<p>You can terminate the sqlite3 program by typing your systems
+End-Of-File character (usually a Control-D) or the interrupt
+character (usually a Control-C).</p>
+
+<p>Make sure you type a semicolon at the end of each SQL command!
+The sqlite3 program looks for a semicolon to know when your SQL command is
+complete.  If you omit the semicolon, sqlite3 will give you a
+continuation prompt and wait for you to enter more text to be
+added to the current SQL command.  This feature allows you to
+enter SQL commands that span multiple lines.  For example:</p>
+}
+
+Code {
+sqlite> (((CREATE TABLE tbl2 ()))
+   ...> (((  f1 varchar(30) primary key,)))
+   ...> (((  f2 text,)))
+   ...> (((  f3 real)))
+   ...> ((();)))
+sqlite> 
+}
+
+puts {
+
+<h3>Aside: Querying the SQLITE_MASTER table</h3>
+
+<p>The database schema in an SQLite database is stored in
+a special table named "sqlite_master".
+You can execute "SELECT" statements against the
+special sqlite_master table just like any other table
+in an SQLite database.  For example:</p>
+}
+
+Code {
+$ (((sqlite3 ex1)))
+SQlite vresion 3.3.10
+Enter ".help" for instructions
+sqlite> (((select * from sqlite_master;)))
+    type = table
+    name = tbl1
+tbl_name = tbl1
+rootpage = 3
+     sql = create table tbl1(one varchar(10), two smallint)
+sqlite>
+}
+
+puts {
+<p>
+But you cannot execute DROP TABLE, UPDATE, INSERT or DELETE against
+the sqlite_master table.  The sqlite_master
+table is updated automatically as you create or drop tables and
+indices from the database.  You can not make manual changes
+to the sqlite_master table.
+</p>
+
+<p>
+The schema for TEMPORARY tables is not stored in the "sqlite_master" table
+since TEMPORARY tables are not visible to applications other than the
+application that created the table.  The schema for TEMPORARY tables
+is stored in another special table named "sqlite_temp_master".  The
+"sqlite_temp_master" table is temporary itself.
+</p>
+
+<h3>Special commands to sqlite3</h3>
+
+<p>
+Most of the time, sqlite3 just reads lines of input and passes them
+on to the SQLite library for execution.
+But if an input line begins with a dot ("."), then
+that line is intercepted and interpreted by the sqlite3 program itself.
+These "dot commands" are typically used to change the output format
+of queries, or to execute certain prepackaged query statements.
+</p>
+
+<p>
+For a listing of the available dot commands, you can enter ".help"
+at any time.  For example:
+</p>}
+
+Code {
+sqlite> (((.help)))
+.bail ON|OFF           Stop after hitting an error.  Default OFF
+.databases             List names and files of attached databases
+.dump ?TABLE? ...      Dump the database in an SQL text format
+.echo ON|OFF           Turn command echo on or off
+.exit                  Exit this program
+.explain ON|OFF        Turn output mode suitable for EXPLAIN on or off.
+.header(s) ON|OFF      Turn display of headers on or off
+.help                  Show this message
+.import FILE TABLE     Import data from FILE into TABLE
+.indices TABLE         Show names of all indices on TABLE
+.load FILE ?ENTRY?     Load an extension library
+.mode MODE ?TABLE?     Set output mode where MODE is one of:
+                         csv      Comma-separated values
+                         column   Left-aligned columns.  (See .width)
+                         html     HTML <table> code
+                         insert   SQL insert statements for TABLE
+                         line     One value per line
+                         list     Values delimited by .separator string
+                         tabs     Tab-separated values
+                         tcl      TCL list elements
+.nullvalue STRING      Print STRING in place of NULL values
+.output FILENAME       Send output to FILENAME
+.output stdout         Send output to the screen
+.prompt MAIN CONTINUE  Replace the standard prompts
+.quit                  Exit this program
+.read FILENAME         Execute SQL in FILENAME
+.schema ?TABLE?        Show the CREATE statements
+.separator STRING      Change separator used by output mode and .import
+.show                  Show the current values for various settings
+.tables ?PATTERN?      List names of tables matching a LIKE pattern
+.timeout MS            Try opening locked tables for MS milliseconds
+.width NUM NUM ...     Set column widths for "column" mode
+sqlite> 
+}
+
+puts {
+<h3>Changing Output Formats</h3>
+
+<p>The sqlite3 program is able to show the results of a query
+in eight different formats: "csv", "column", "html", "insert",
+"line", "tabs", and "tcl".
+You can use the ".mode" dot command to switch between these output
+formats.</p>
+
+<p>The default output mode is "list".  In
+list mode, each record of a query result is written on one line of
+output and each column within that record is separated by a specific
+separator string.  The default separator is a pipe symbol ("|").
+List mode is especially useful when you are going to send the output
+of a query to another program (such as AWK) for additional processing.</p>}
+
+Code {
+sqlite> (((.mode list)))
+sqlite> (((select * from tbl1;)))
+hello|10
+goodbye|20
+sqlite>
+}
+
+puts {
+<p>You can use the ".separator" dot command to change the separator
+for list mode.  For example, to change the separator to a comma and
+a space, you could do this:</p>}
+
+Code {
+sqlite> (((.separator ", ")))
+sqlite> (((select * from tbl1;)))
+hello, 10
+goodbye, 20
+sqlite>
+}
+
+puts {
+<p>In "line" mode, each column in a row of the database
+is shown on a line by itself.  Each line consists of the column
+name, an equal sign and the column data.  Successive records are
+separated by a blank line.  Here is an example of line mode
+output:</p>}
+
+Code {
+sqlite> (((.mode line)))
+sqlite> (((select * from tbl1;)))
+one = hello
+two = 10
+
+one = goodbye
+two = 20
+sqlite>
+}
+
+puts {
+<p>In column mode, each record is shown on a separate line with the
+data aligned in columns.  For example:</p>}
+
+Code {
+sqlite> (((.mode column)))
+sqlite> (((select * from tbl1;)))
+one         two       
+----------  ----------
+hello       10        
+goodbye     20        
+sqlite>
+}
+
+puts {
+<p>By default, each column is at least 10 characters wide. 
+Data that is too wide to fit in a column is truncated.  You can
+adjust the column widths using the ".width" command.  Like this:</p>}
+
+Code {
+sqlite> (((.width 12 6)))
+sqlite> (((select * from tbl1;)))
+one           two   
+------------  ------
+hello         10    
+goodbye       20    
+sqlite>
+}
+
+puts {
+<p>The ".width" command in the example above sets the width of the first
+column to 12 and the width of the second column to 6.  All other column
+widths were unaltered.  You can gives as many arguments to ".width" as
+necessary to specify the widths of as many columns as are in your
+query results.</p>
+
+<p>If you specify a column a width of 0, then the column
+width is automatically adjusted to be the maximum of three
+numbers: 10, the width of the header, and the width of the
+first row of data.  This makes the column width self-adjusting.
+The default width setting for every column is this 
+auto-adjusting 0 value.</p>
+
+<p>The column labels that appear on the first two lines of output
+can be turned on and off using the ".header" dot command.  In the
+examples above, the column labels are on.  To turn them off you
+could do this:</p>}
+
+Code {
+sqlite> (((.header off)))
+sqlite> (((select * from tbl1;)))
+hello         10    
+goodbye       20    
+sqlite>
+}
+
+puts {
+<p>Another useful output mode is "insert".  In insert mode, the output
+is formatted to look like SQL INSERT statements.  You can use insert
+mode to generate text that can later be used to input data into a 
+different database.</p>
+
+<p>When specifying insert mode, you have to give an extra argument
+which is the name of the table to be inserted into.  For example:</p>
+}
+
+Code {
+sqlite> (((.mode insert new_table)))
+sqlite> (((select * from tbl1;)))
+INSERT INTO 'new_table' VALUES('hello',10);
+INSERT INTO 'new_table' VALUES('goodbye',20);
+sqlite>
+}
+
+puts {
+<p>The last output mode is "html".  In this mode, sqlite3 writes
+the results of the query as an XHTML table.  The beginning
+&lt;TABLE&gt; and the ending &lt;/TABLE&gt; are not written, but
+all of the intervening &lt;TR&gt;s, &lt;TH&gt;s, and &lt;TD&gt;s
+are.  The html output mode is envisioned as being useful for
+CGI.</p>
+}
+
+puts {
+<h3>Writing results to a file</h3>
+
+<p>By default, sqlite3 sends query results to standard output.  You
+can change this using the ".output" command.  Just put the name of
+an output file as an argument to the .output command and all subsequent
+query results will be written to that file.  Use ".output stdout" to
+begin writing to standard output again.  For example:</p>}
+
+Code {
+sqlite> (((.mode list)))
+sqlite> (((.separator |)))
+sqlite> (((.output test_file_1.txt)))
+sqlite> (((select * from tbl1;)))
+sqlite> (((.exit)))
+$ (((cat test_file_1.txt)))
+hello|10
+goodbye|20
+$
+}
+
+puts {
+<h3>Querying the database schema</h3>
+
+<p>The sqlite3 program provides several convenience commands that
+are useful for looking at the schema of the database.  There is
+nothing that these commands do that cannot be done by some other
+means.  These commands are provided purely as a shortcut.</p>
+
+<p>For example, to see a list of the tables in the database, you
+can enter ".tables".</p>
+}
+
+Code {
+sqlite> (((.tables)))
+tbl1
+tbl2
+sqlite>
+}
+
+puts {
+<p>The ".tables" command is similar to setting list mode then
+executing the following query:</p>
+
+<blockquote><pre>
+SELECT name FROM sqlite_master 
+WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'
+UNION ALL 
+SELECT name FROM sqlite_temp_master 
+WHERE type IN ('table','view') 
+ORDER BY 1
+</pre></blockquote>
+
+<p>In fact, if you look at the source code to the sqlite3 program
+(found in the source tree in the file src/shell.c) you'll find
+exactly the above query.</p>
+
+<p>The ".indices" command works in a similar way to list all of
+the indices for a particular table.  The ".indices" command takes
+a single argument which is the name of the table for which the
+indices are desired.  Last, but not least, is the ".schema" command.
+With no arguments, the ".schema" command shows the original CREATE TABLE
+and CREATE INDEX statements that were used to build the current database.
+If you give the name of a table to ".schema", it shows the original
+CREATE statement used to make that table and all if its indices.
+We have:</p>}
+
+Code {
+sqlite> (((.schema)))
+create table tbl1(one varchar(10), two smallint)
+CREATE TABLE tbl2 (
+  f1 varchar(30) primary key,
+  f2 text,
+  f3 real
+)
+sqlite> (((.schema tbl2)))
+CREATE TABLE tbl2 (
+  f1 varchar(30) primary key,
+  f2 text,
+  f3 real
+)
+sqlite>
+}
+
+puts {
+<p>The ".schema" command accomplishes the same thing as setting
+list mode, then entering the following query:</p>
+
+<blockquote><pre>
+SELECT sql FROM 
+   (SELECT * FROM sqlite_master UNION ALL
+    SELECT * FROM sqlite_temp_master)
+WHERE type!='meta'
+ORDER BY tbl_name, type DESC, name
+</pre></blockquote>
+
+<p>Or, if you give an argument to ".schema" because you only
+want the schema for a single table, the query looks like this:</p>
+
+<blockquote><pre>
+SELECT sql FROM
+   (SELECT * FROM sqlite_master UNION ALL
+    SELECT * FROM sqlite_temp_master)
+WHERE type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%'
+ORDER BY substr(type,2,1), name
+</pre></blockquote>
+
+<p>
+You can supply an argument to the .schema command.  If you do, the
+query looks like this:
+</p>
+
+<blockquote><pre>
+SELECT sql FROM
+   (SELECT * FROM sqlite_master UNION ALL
+    SELECT * FROM sqlite_temp_master)
+WHERE tbl_name LIKE '%s'
+  AND type!='meta' AND sql NOT NULL AND name NOT LIKE 'sqlite_%'
+ORDER BY substr(type,2,1), name
+</pre></blockquote>
+
+<p>The "%s" in the query is replace by your argument.  This allows you
+to view the schema for some subset of the database.</p>
+}
+
+Code {
+sqlite> (((.schema %abc%)))
+}
+
+puts {
+<p>
+Along these same lines,
+the ".table" command also accepts a pattern as its first argument.
+If you give an argument to the .table command, a "%" is both
+appended and prepended and a LIKE clause is added to the query.
+This allows you to list only those tables that match a particular
+pattern.</p>
+
+<p>The ".databases" command shows a list of all databases open in
+the current connection.  There will always be at least 2.  The first
+one is "main", the original database opened.  The second is "temp",
+the database used for temporary tables. There may be additional 
+databases listed for databases attached using the ATTACH statement.
+The first output column is the name the database is attached with, 
+and the second column is the filename of the external file.</p>}
+
+Code {
+sqlite> (((.databases)))
+}
+
+puts {
+<h3>Converting An Entire Database To An ASCII Text File</h3>
+
+<p>Use the ".dump" command to convert the entire contents of a
+database into a single ASCII text file.  This file can be converted
+back into a database by piping it back into <b>sqlite3</b>.</p>
+
+<p>A good way to make an archival copy of a database is this:</p>
+}
+
+Code {
+$ (((echo '.dump' | sqlite3 ex1 | gzip -c >ex1.dump.gz)))
+}
+
+puts {
+<p>This generates a file named <b>ex1.dump.gz</b> that contains everything
+you need to reconstruct the database at a later time, or on another
+machine.  To reconstruct the database, just type:</p>
+}
+
+Code {
+$ (((zcat ex1.dump.gz | sqlite3 ex2)))
+}
+
+puts {
+<p>The text format is pure SQL so you
+can also use the .dump command to export an SQLite database
+into other popular SQL database engines.  Like this:</p>
+}
+
+Code {
+$ (((createdb ex2)))
+$ (((sqlite3 ex1 .dump | psql ex2)))
+}
+
+puts {
+<h3>Other Dot Commands</h3>
+
+<p>The ".explain" dot command can be used to set the output mode
+to "column" and to set the column widths to values that are reasonable
+for looking at the output of an EXPLAIN command.  The EXPLAIN command
+is an SQLite-specific SQL extension that is useful for debugging.  If any
+regular SQL is prefaced by EXPLAIN, then the SQL command is parsed and
+analyzed but is not executed.  Instead, the sequence of virtual machine
+instructions that would have been used to execute the SQL command are
+returned like a query result.  For example:</p>}
+
+Code {
+sqlite> (((.explain)))
+sqlite> (((explain delete from tbl1 where two<20;)))
+addr  opcode        p1     p2     p3          
+----  ------------  -----  -----  -------------------------------------   
+0     ListOpen      0      0                  
+1     Open          0      1      tbl1        
+2     Next          0      9                  
+3     Field         0      1                  
+4     Integer       20     0                  
+5     Ge            0      2                  
+6     Key           0      0                  
+7     ListWrite     0      0                  
+8     Goto          0      2                  
+9     Noop          0      0                  
+10    ListRewind    0      0                  
+11    ListRead      0      14                 
+12    Delete        0      0                  
+13    Goto          0      11                 
+14    ListClose     0      0                  
+}
+
+puts {
+
+<p>The ".timeout" command sets the amount of time that the <b>sqlite3</b>
+program will wait for locks to clear on files it is trying to access
+before returning an error.  The default value of the timeout is zero so
+that an error is returned immediately if any needed database table or
+index is locked.</p>
+
+<p>And finally, we mention the ".exit" command which causes the
+sqlite3 program to exit.</p>
+
+<h3>Using sqlite3 in a shell script</h3>
+
+<p>
+One way to use sqlite3 in a shell script is to use "echo" or
+"cat" to generate a sequence of commands in a file, then invoke sqlite3
+while redirecting input from the generated command file.  This
+works fine and is appropriate in many circumstances.  But as
+an added convenience, sqlite3 allows a single SQL command to be
+entered on the command line as a second argument after the
+database name.  When the sqlite3 program is launched with two
+arguments, the second argument is passed to the SQLite library
+for processing, the query results are printed on standard output
+in list mode, and the program exits.  This mechanism is designed
+to make sqlite3 easy to use in conjunction with programs like
+"awk".  For example:</p>}
+
+Code {
+$ (((sqlite3 ex1 'select * from tbl1' |)))
+> ((( awk '{printf "<tr><td>%s<td>%s\n",$1,$2 }')))
+<tr><td>hello<td>10
+<tr><td>goodbye<td>20
+$
+}
+
+puts {
+<h3>Ending shell commands</h3>
+
+<p>
+SQLite commands are normally terminated by a semicolon.  In the shell 
+you can also use the word "GO" (case-insensitive) or a slash character 
+"/" on a line by itself to end a command.  These are used by SQL Server 
+and Oracle, respectively.  These won't work in <b>sqlite3_exec()</b>, 
+because the shell translates these into a semicolon before passing them 
+to that function.</p>
+}
+
+puts {
+<h3>Compiling the sqlite3 program from sources</h3>
+
+<p>
+The sqlite3 program is built automatically when you compile the
+SQLite library.  Just get a copy of the source tree, run
+"configure" and then "make".</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/support.tcl b/client/src/thirdparty/sqlite-3.4.2/www/support.tcl
new file mode 100644
index 0000000..6dc4693
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/support.tcl
@@ -0,0 +1,79 @@
+set rcsid {$Id: support.tcl,v 1.7 2007/06/21 13:30:40 drh Exp $}
+source common.tcl
+header {SQLite Support Options}
+puts {
+<h2>SQLite Support Options</h2>
+
+
+<h3>Mailing List</h3>
+<p>
+A mailing list has been set up for asking questions and
+for open discussion of problems
+and issues by the SQLite user community.
+To subscribe to the mailing list, send an email to
+<a href="mailto:sqlite-users-subscribe@sqlite.org">
+sqlite-users-subscribe@sqlite.org</a>.
+If you would prefer to get digests rather than individual
+emails, send a message to to
+<a href="mailto:sqlite-users-digest-subscribe@sqlite.org">
+sqlite-users-digest-subscribe@sqlite.org</a>.
+For additional information about operating and using this
+mailing list, send a message to
+<a href="mailto:sqlite-users-help@sqlite.org">
+sqlite-users-help@sqlite.org</a> and instructions will be
+sent by to you by return email.
+</p>
+
+<p>
+There are multiple archives of the mailing list:
+</p>
+
+<blockquote>
+<a href="http://www.mail-archive.com/sqlite-users%40sqlite.org/">
+http://www.mail-archive.com/sqlite-users%40sqlite.org</a><br>
+<a href="http://marc.info/?l=sqlite-users&r=1&w=2">
+http://marc.info/?l=sqlite-users&r=1&w=2</a><br>
+<a href="http://news.gmane.org/gmane.comp.db.sqlite.general">
+http://news.gmane.org/gmane.comp.db.sqlite.general</a>
+</blockquote>
+
+</p>
+
+<a name="directemail">
+<h3>Direct E-Mail To The Author</h3>
+
+<p>
+Use the mailing list.
+Please do <b>not</b> send email directly to the author of SQLite
+unless:
+<ul>
+<li>You have or intend to acquire a professional support contract
+as described below, or</li>
+<li>You are working on an open source project.</li>
+</ul>
+You are welcomed to use SQLite in closed source, proprietary, and/or
+commerical projects and to ask questions about such use on the public
+mailing list.  But please do not ask to receive free direct technical
+support.  The software is free; direct technical support is not.
+</p>
+
+
+<h3>Professional Support</h3>
+
+<p>
+If you would like professional support for SQLite
+or if you want custom modifications to SQLite performed by the
+original author, these services are available for a modest fee.
+For additional information visit
+<a href="http://www.hwaci.com/sw/sqlite/prosupport.html">
+http://www.hwaci.com/sw/sqlite/prosupport.html</a> or contact:</p>
+
+<blockquote>
+D. Richard Hipp <br />
+Hwaci - Applied Software Research <br />
+704.948.4565 <br />
+<a href="mailto:drh@hwaci.com">drh@hwaci.com</a>
+</blockquote>
+
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/table-ex1b2.gif b/client/src/thirdparty/sqlite-3.4.2/www/table-ex1b2.gif
new file mode 100644
index 0000000..7e95157
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/table-ex1b2.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15cca0ba17351dc0b25f4a88aa52c831f03568e32af0c448169ca2879ff04d9c
+size 10888
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/tclsqlite.tcl b/client/src/thirdparty/sqlite-3.4.2/www/tclsqlite.tcl
new file mode 100644
index 0000000..141cb5e
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/tclsqlite.tcl
@@ -0,0 +1,666 @@
+#
+# Run this Tcl script to generate the tclsqlite.html file.
+#
+set rcsid {$Id: tclsqlite.tcl,v 1.17 2007/06/19 17:48:57 drh Exp $}
+source common.tcl
+header {The Tcl interface to the SQLite library}
+proc METHOD {name text} {
+  puts "<a name=\"$name\">\n<h3>The \"$name\" method</h3>\n"
+  puts $text
+}
+puts {
+<h2>The Tcl interface to the SQLite library</h2>
+
+<p>The SQLite library is designed to be very easy to use from
+a Tcl or Tcl/Tk script.  This document gives an overview of the Tcl
+programming interface.</p>
+
+<h3>The API</h3>
+
+<p>The interface to the SQLite library consists of single
+tcl command named <b>sqlite3</b>
+Because there is only this
+one command, the interface is not placed in a separate
+namespace.</p>
+
+<p>The <b>sqlite3</b> command is used as follows:</p>
+
+<blockquote>
+<b>sqlite3</b>&nbsp;&nbsp;<i>dbcmd&nbsp;&nbsp;database-name</i>
+</blockquote>
+
+<p>
+The <b>sqlite3</b> command opens the database named in the second
+argument.  If the database does not already exist, it is
+automatically created.
+The <b>sqlite3</b> command also creates a new Tcl
+command to control the database.  The name of the new Tcl command
+is given by the first argument.  This approach is similar to the
+way widgets are created in Tk.
+</p>
+
+<p>
+The name of the database is just the name of a disk file in which
+the database is stored.  If the name of the database is an empty
+string or the special name ":memory:" then a new database is created
+in memory.
+</p>
+
+<p>
+Once an SQLite database is open, it can be controlled using 
+methods of the <i>dbcmd</i>.  There are currently 22 methods
+defined.</p>
+
+<p>
+<ul>
+}
+foreach m [lsort {
+ authorizer
+ busy
+ cache
+ changes
+ close
+ collate
+ collation_needed
+ commit_hook
+ complete
+ copy
+ enable_load_extension
+ errorcode
+ eval
+ exists
+ function
+ last_insert_rowid
+ nullvalue
+ onecolumn
+ profile
+ progress
+ rollback_hook
+ timeout
+ total_changes
+ trace
+ transaction
+ update_hook
+ version
+}] {
+ puts "<li><a href=\"#$m\">$m</a></li>"
+}
+puts {
+</ul>
+</p>
+
+<p>The use of each of these methods will be explained in the sequel, though
+not in the order shown above.</p>
+
+}
+
+##############################################################################
+METHOD eval {
+<p>
+The most useful <i>dbcmd</i> method is "eval".  The eval method is used
+to execute SQL on the database.  The syntax of the eval method looks
+like this:</p>
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>eval</b>&nbsp;&nbsp;<i>sql</i>
+&nbsp;&nbsp;&nbsp;&nbsp;?<i>array-name&nbsp;</i>?&nbsp;?<i>script</i>?
+</blockquote>
+
+<p>
+The job of the eval method is to execute the SQL statement or statements
+given in the second argument.  For example, to create a new table in
+a database, you can do this:</p>
+
+<blockquote>
+<b>sqlite3 db1 ./testdb<br>
+db1 eval {CREATE TABLE t1(a int, b text)}</b>
+</blockquote>
+
+<p>The above code creates a new table named <b>t1</b> with columns
+<b>a</b> and <b>b</b>.  What could be simpler?</p>
+
+<p>Query results are returned as a list of column values.  If a
+query requests 2 columns and there are 3 rows matching the query,
+then the returned list will contain 6 elements.  For example:</p>
+
+<blockquote>
+<b>db1 eval {INSERT INTO t1 VALUES(1,'hello')}<br>
+db1 eval {INSERT INTO t1 VALUES(2,'goodbye')}<br>
+db1 eval {INSERT INTO t1 VALUES(3,'howdy!')}<br>
+set x [db1 eval {SELECT * FROM t1 ORDER BY a}]</b>
+</blockquote>
+
+<p>The variable <b>$x</b> is set by the above code to</p>
+
+<blockquote>
+<b>1 hello 2 goodbye 3 howdy!</b>
+</blockquote>
+
+<p>You can also process the results of a query one row at a time
+by specifying the name of an array variable and a script following
+the SQL code.  For each row of the query result, the values of all
+columns will be inserted into the array variable and the script will
+be executed.  For instance:</p>
+
+<blockquote>
+<b>db1 eval {SELECT * FROM t1 ORDER BY a} values {<br>
+&nbsp;&nbsp;&nbsp;&nbsp;parray values<br>
+&nbsp;&nbsp;&nbsp;&nbsp;puts ""<br>
+}</b>
+</blockquote>
+
+<p>This last code will give the following output:</p>
+
+<blockquote><b>
+values(*) = a b<br>
+values(a) = 1<br>
+values(b) = hello<p>
+
+values(*) = a b<br>
+values(a) = 2<br>
+values(b) = goodbye<p>
+
+values(*) = a b<br>
+values(a) = 3<br>
+values(b) = howdy!</b>
+</blockquote>
+
+<p>
+For each column in a row of the result, the name of that column
+is used as an index in to array.  The value of the column is stored
+in the corresponding array entry.  The special array index * is
+used to store a list of column names in the order that they appear.
+</p>
+
+<p>
+If the array variable name is omitted or is the empty string, then the value of
+each column is stored in a variable with the same name as the column
+itself.  For example:
+</p>
+
+<blockquote>
+<b>db1 eval {SELECT * FROM t1 ORDER BY a} {<br>
+&nbsp;&nbsp;&nbsp;&nbsp;puts "a=$a b=$b"<br>
+}</b>
+</blockquote>
+
+<p>
+From this we get the following output
+</p>
+
+<blockquote><b>
+a=1 b=hello<br>
+a=2 b=goodbye<br>
+a=3 b=howdy!</b>
+</blockquote>
+
+<p>
+Tcl variable names can appear in the SQL statement of the second argument
+in any position where it is legal to put a string or number literal.  The
+value of the variable is substituted for the variable name.  If the
+variable does not exist a NULL values is used.  For example:
+</p>
+
+<blockquote><b>
+db1 eval {INSERT INTO t1 VALUES(5,$bigstring)}
+</b></blockquote>
+
+<p>
+Note that it is not necessary to quote the $bigstring value.  That happens
+automatically.  If $bigstring is a large string or binary object, this
+technique is not only easier to write, it is also much more efficient
+since it avoids making a copy of the content of $bigstring.
+</p>
+
+<p>
+If the $bigstring variable has both a string and a "bytearray" representation,
+then TCL inserts the value as a string.  If it has only a "bytearray"
+representation, then the value is inserted as a BLOB.  To force a
+value to be inserted as a BLOB even if it also has a text representation,
+us a "@" character to in place of the "$".  Like this:
+</p>
+
+<blockquote><b>
+db1 eval {INSERT INTO t1 VALUES(5,@bigstring)}
+</b></blockquote>
+
+<p>
+If the variable does not have a bytearray representation, then "@" works
+just like "$".
+</p>
+
+}
+
+##############################################################################
+METHOD close {
+
+<p>
+As its name suggests, the "close" method to an SQLite database just
+closes the database.  This has the side-effect of deleting the
+<i>dbcmd</i> Tcl command.  Here is an example of opening and then
+immediately closing a database:
+</p>
+
+<blockquote>
+<b>sqlite3 db1 ./testdb<br>
+db1 close</b>
+</blockquote>
+
+<p>
+If you delete the <i>dbcmd</i> directly, that has the same effect
+as invoking the "close" method.  So the following code is equivalent
+to the previous:</p>
+
+<blockquote>
+<b>sqlite3 db1 ./testdb<br>
+rename db1 {}</b>
+</blockquote>
+}
+
+##############################################################################
+METHOD transaction {
+
+<p>
+The "transaction" method is used to execute a TCL script inside an SQLite
+database transaction.  The transaction is committed when the script completes,
+or it rolls back if the script fails.  If the transaction occurs within
+another transaction (even one that is started manually using BEGIN) it
+is a no-op.
+</p>
+
+<p>
+The transaction command can be used to group together several SQLite
+commands in a safe way.  You can always start transactions manually using
+BEGIN, of
+course.  But if an error occurs so that the COMMIT or ROLLBACK are never
+run, then the database will remain locked indefinitely.  Also, BEGIN
+does not nest, so you have to make sure no other transactions are active
+before starting a new one.  The "transaction" method takes care of
+all of these details automatically.
+</p>
+
+<p>
+The syntax looks like this:
+</p>
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>transaction</b>&nbsp;&nbsp;<i>?transaction-type?</i>
+&nbsp;&nbsp;<i>SCRIPT,</i>
+</blockquote>
+
+
+<p>
+The <i>transaction-type</i> can be one of <b>deferred</b>,
+<b>exclusive</b> or <b>immediate</b>.  The default is deferred.
+</p>
+}
+
+##############################################################################
+METHOD cache {
+
+<p>
+The "eval" method described <a href="#eval">above</a> keeps a cache of
+<a href="capi3ref.html#sqlite3_prepare">prepared statements</a>
+for recently evaluated SQL commands.  
+The "cache" method is used to control this cache.
+The first form of this command is:</p>
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>cache size</b>&nbsp;&nbsp;<i>N</i>
+</blockquote>
+
+<p>This sets the maximum number of statements that can be cached.
+The upper limit is 100.  The default is 10.  If you set the cache size
+to 0, no caching is done.</p>
+
+<p>The second form of the command is this:</p>
+
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>cache flush</b>
+</blockquote>
+
+<p>The cache-flush method 
+<a href="capi3ref.html#sqlite3_finalize">finalizes</a>
+all prepared statements currently
+in the cache.</p>
+
+}
+
+##############################################################################
+METHOD complete {
+
+<p>
+The "complete" method takes a string of supposed SQL as its only argument.
+It returns TRUE if the string is a complete statement of SQL and FALSE if
+there is more to be entered.</p>
+
+<p>The "complete" method is useful when building interactive applications
+in order to know when the user has finished entering a line of SQL code.
+This is really just an interface to the 
+<a href="capi3ref.html#sqlite3_complete"><b>sqlite3_complete()</b></a> C
+function.
+}
+
+##############################################################################
+METHOD copy {
+
+<p>
+The "copy" method copies data from a file into a table.
+It returns the number of rows processed successfully from the file.
+The syntax of the copy method looks like this:</p>
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>copy</b>&nbsp;&nbsp;<i>conflict-algorithm</i>
+&nbsp;&nbsp;<i>table-name&nbsp;</i>&nbsp;&nbsp;<i>file-name&nbsp;</i>
+&nbsp;&nbsp;&nbsp;&nbsp;?<i>column-separator&nbsp;</i>?
+&nbsp;&nbsp;?<i>null-indicator</i>?
+</blockquote>
+
+<p>Conflict-alogrithm must be one of the SQLite conflict algorithms for
+the INSERT statement: <i>rollback</i>, <i>abort</i>,
+<i>fail</i>,<i>ignore</i>, or <i>replace</i>. See the SQLite Language
+section for <a href="lang.html#conflict">ON CONFLICT</a> for more information.
+The conflict-algorithm must be specified in lower case.
+</p>
+
+<p>Table-name must already exists as a table.  File-name must exist, and
+each row must contain the same number of columns as defined in the table.
+If a line in the file contains more or less than the number of columns defined,
+the copy method rollbacks any inserts, and returns an error.</p>
+
+<p>Column-separator is an optional column separator string.  The default is
+the ASCII tab character \t. </p>
+
+<p>Null-indicator is an optional string that indicates a column value is null.
+The default is an empty string.  Note that column-separator and
+null-indicator are optional positional arguments; if null-indicator
+is specified, a column-separator argument must be specifed and
+precede the null-indicator argument.</p>
+
+<p>The copy method implements similar functionality to the <b>.import</b>
+SQLite shell command. 
+The SQLite 2.x <a href="lang.html#copy"><b>COPY</b></a> statement 
+(using the PostgreSQL COPY file format)
+can be implemented with this method as:</p>
+
+<blockquote>
+dbcmd&nbsp;&nbsp;copy&nbsp;&nbsp;$conflictalgo
+&nbsp;&nbsp;$tablename&nbsp;&nbsp;&nbsp;$filename&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;\t&nbsp;
+&nbsp;&nbsp;\\N
+</blockquote>
+
+}
+
+##############################################################################
+METHOD timeout {
+
+<p>The "timeout" method is used to control how long the SQLite library
+will wait for locks to clear before giving up on a database transaction.
+The default timeout is 0 millisecond.  (In other words, the default behavior
+is not to wait at all.)</p>
+
+<p>The SQLite database allows multiple simultaneous
+readers or a single writer but not both.  If any process is writing to
+the database no other process is allows to read or write.  If any process
+is reading the database other processes are allowed to read but not write.
+The entire database shared a single lock.</p>
+
+<p>When SQLite tries to open a database and finds that it is locked, it
+can optionally delay for a short while and try to open the file again.
+This process repeats until the query times out and SQLite returns a
+failure.  The timeout is adjustable.  It is set to 0 by default so that
+if the database is locked, the SQL statement fails immediately.  But you
+can use the "timeout" method to change the timeout value to a positive
+number.  For example:</p>
+
+<blockquote><b>db1 timeout 2000</b></blockquote>
+
+<p>The argument to the timeout method is the maximum number of milliseconds
+to wait for the lock to clear.  So in the example above, the maximum delay
+would be 2 seconds.</p>
+}
+
+##############################################################################
+METHOD busy {
+
+<p>The "busy" method, like "timeout", only comes into play when the
+database is locked.  But the "busy" method gives the programmer much more
+control over what action to take.  The "busy" method specifies a callback
+Tcl procedure that is invoked whenever SQLite tries to open a locked
+database.  This callback can do whatever is desired.  Presumably, the
+callback will do some other useful work for a short while (such as service
+GUI events) then return
+so that the lock can be tried again.  The callback procedure should
+return "0" if it wants SQLite to try again to open the database and
+should return "1" if it wants SQLite to abandon the current operation.
+}
+
+##############################################################################
+METHOD exists {
+
+<p>The "exists" method is similar to "onecolumn" and "eval" in that
+it executes SQL statements.  The difference is that the "exists" method
+always returns a boolean value which is TRUE if a query in the SQL
+statement it executes returns one or more rows and FALSE if the SQL
+returns an empty set.</p>
+
+<p>The "exists" method is often used to test for the existance of
+rows in a table.  For example:</p>
+
+<blockquote><b>
+if {[db exists {SELECT 1 FROM table1 WHERE user=$user}]} {<br>
+&nbsp;&nbsp;&nbsp;# Processing if $user exists<br>
+} else {<br>
+&nbsp;&nbsp;&nbsp;# Processing if $user does not exist<br>
+}
+</b></blockquote>
+}
+
+
+##############################################################################
+METHOD last_insert_rowid {
+
+<p>The "last_insert_rowid" method returns an integer which is the ROWID
+of the most recently inserted database row.</p>
+}
+
+##############################################################################
+METHOD function {
+
+<p>The "function" method registers new SQL functions with the SQLite engine.
+The arguments are the name of the new SQL function and a TCL command that
+implements that function.  Arguments to the function are appended to the
+TCL command before it is invoked.</p>
+
+<p>
+The following example creates a new SQL function named "hex" that converts
+its numeric argument in to a hexadecimal encoded string:
+</p>
+
+<blockquote><b>
+db function hex {format 0x%X}
+</b></blockquote>
+
+}
+
+##############################################################################
+METHOD nullvalue {
+
+<p>
+The "nullvalue" method changes the representation for NULL returned
+as result of the "eval" method.</p>
+
+<blockquote><b>
+db1 nullvalue NULL
+</b></blockquote>
+
+<p>The "nullvalue" method is useful to differ between NULL and empty
+column values as Tcl lacks a NULL representation.  The default
+representation for NULL values is an empty string.</p>
+}
+
+
+
+##############################################################################
+METHOD onecolumn {
+
+<p>The "onecolumn" method works like 
+"<a href="#eval">eval</a>" in that it evaluates the
+SQL query statement given as its argument.  The difference is that
+"onecolumn" returns a single element which is the first column of the
+first row of the query result.</p>
+
+<p>This is a convenience method.  It saves the user from having to
+do a "<tt>[lindex&nbsp;...&nbsp;0]</tt>" on the results of an "eval"
+in order to extract a single column result.</p>
+}
+
+##############################################################################
+METHOD changes {
+
+<p>The "changes" method returns an integer which is the number of rows
+in the database that were inserted, deleted, and/or modified by the most
+recent "eval" method.</p>
+}
+
+##############################################################################
+METHOD total_changes {
+
+<p>The "total_changes" method returns an integer which is the number of rows
+in the database that were inserted, deleted, and/or modified since the
+current database connection was first opened.</p>
+}
+
+##############################################################################
+METHOD authorizer {
+
+<p>The "authorizer" method provides access to the 
+<a href="capi3ref.html#sqlite3_set_authorizer">sqlite3_set_authorizer</a>
+C/C++ interface.  The argument to authorizer is the name of a procedure that
+is called when SQL statements are being compiled in order to authorize
+certain operations.  The callback procedure takes 5 arguments which describe
+the operation being coded.  If the callback returns the text string
+"SQLITE_OK", then the operation is allowed.  If it returns "SQLITE_IGNORE",
+then the operation is silently disabled.  If the return is "SQLITE_DENY"
+then the compilation fails with an error.
+</p>
+
+<p>If the argument is an empty string then the authorizer is disabled.
+If the argument is omitted, then the current authorizer is returned.</p>
+}
+
+##############################################################################
+METHOD progress {
+
+<p>This method registers a callback that is invoked periodically during
+query processing.  There are two arguments: the number of SQLite virtual
+machine opcodes between invocations, and the TCL command to invoke.
+Setting the progress callback to an empty string disables it.</p>
+
+<p>The progress callback can be used to display the status of a lengthy
+query or to process GUI events during a lengthy query.</p>
+}
+
+
+##############################################################################
+METHOD collate {
+
+<p>This method registers new text collating sequences.  There are
+two arguments: the name of the collating sequence and the name of a
+TCL procedure that implements a comparison function for the collating
+sequence.
+</p>
+
+<p>For example, the following code implements a collating sequence called
+"NOCASE" that sorts in text order without regard to case:
+</p>
+
+<blockquote><b>
+proc nocase_compare {a b} {<br>
+&nbsp;&nbsp;&nbsp;&nbsp;return [string compare [string tolower $a] [string tolower $b]]<br>
+}<br>
+db collate NOCASE nocase_compare<br>
+</b></blockquote>
+}
+
+##############################################################################
+METHOD collation_needed {
+
+<p>This method registers a callback routine that is invoked when the SQLite
+engine needs a particular collating sequence but does not have that
+collating sequence registered.  The callback can register the collating
+sequence.  The callback is invoked with a single parameter which is the
+name of the needed collating sequence.</p>
+}
+
+##############################################################################
+METHOD commit_hook {
+
+<p>This method registers a callback routine that is invoked just before
+SQLite tries to commit changes to a database.  If the callback throws
+an exception or returns a non-zero result, then the transaction rolls back
+rather than commit.</p>
+}
+
+##############################################################################
+METHOD rollback_hook {
+
+<p>This method registers a callback routine that is invoked just before
+SQLite tries to do a rollback.  The script argument is run without change.</p>
+}
+
+##############################################################################
+METHOD update_hook {
+
+<p>This method registers a callback routine that is invoked just before
+each row is modified by an UPDATE, INSERT, or DELETE statement.  Four
+arguments are appended to the callback before it is invoked:</p>
+
+<ul>
+<li>The keyword "INSERT", "UPDATE", or "DELETE", as appropriate</li>
+<li>The name of the database which is being changed</li>
+<li>The table that is being changed</li>
+<li>The rowid of the row in the table being changed</li>
+</ul>
+}
+
+##############################################################################
+METHOD incrblob {
+
+<p>This method opens a TCL channel that can be used to read or write
+into a preexisting BLOB in the database.  The syntax is like this:</p>
+
+<blockquote>
+<i>dbcmd</i>&nbsp;&nbsp;<b>incrblob</b>&nbsp;&nbsp;<b>?-readonly??</b>
+&nbsp;&nbsp;<i>?DB?&nbsp;&nbsp;TABLE&nbsp;&nbsp;COLUMN&nbsp;&nbsp;ROWID</i>
+</blockquote>
+
+<p>
+The command returns a new TCL channel for reading or writing to the BLOB.
+The channel is opened using the underlying 
+<a href="/capi3ref.html#sqlite3_blob_open">sqlite3_blob_open()</a> C-langauge
+interface.  Close the channel using the <b>close</b> command of TCL.
+</p>
+}
+
+##############################################################################
+METHOD errorcode {
+
+<p>This method returns the numeric error code that resulted from the most
+recent SQLite operation.</p>
+}
+
+##############################################################################
+METHOD trace {
+
+<p>The "trace" method registers a callback that is invoked as each SQL
+statement is compiled.  The text of the SQL is appended as a single string
+to the command before it is invoked.  This can be used (for example) to
+keep a log of all SQL operations that an application performs.
+</p>
+}
+
+
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/vdbe.tcl b/client/src/thirdparty/sqlite-3.4.2/www/vdbe.tcl
new file mode 100644
index 0000000..ed0b712
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/vdbe.tcl
@@ -0,0 +1,1988 @@
+#
+# Run this Tcl script to generate the vdbe.html file.
+#
+set rcsid {$Id: vdbe.tcl,v 1.14 2005/03/12 15:55:11 drh Exp $}
+source common.tcl
+header {The Virtual Database Engine of SQLite}
+puts {
+<h2>The Virtual Database Engine of SQLite</h2>
+
+<blockquote><b>
+This document describes the virtual machine used in SQLite version 2.8.0. 
+The virtual machine in SQLite version 3.0 and 3.1 is very similar in
+concept but many of the opcodes have changed and the algorithms are
+somewhat different.  Use this document as a rough guide to the idea
+behind the virtual machine in SQLite version 3, not as a reference on
+how the virtual machine works.
+</b></blockquote>
+}
+
+puts {
+<p>If you want to know how the SQLite library works internally,
+you need to begin with a solid understanding of the Virtual Database
+Engine or VDBE.  The VDBE occurs right in the middle of the
+processing stream (see the <a href="arch.html">architecture diagram</a>)
+and so it seems to touch most parts of the library.  Even
+parts of the code that do not directly interact with the VDBE
+are usually in a supporting role.  The VDBE really is the heart of
+SQLite.</p>
+
+<p>This article is a brief introduction to how the VDBE
+works and in particular how the various VDBE instructions
+(documented <a href="opcode.html">here</a>) work together
+to do useful things with the database.  The style is tutorial,
+beginning with simple tasks and working toward solving more
+complex problems.  Along the way we will visit most
+submodules in the SQLite library.  After completeing this tutorial,
+you should have a pretty good understanding of how SQLite works
+and will be ready to begin studying the actual source code.</p>
+
+<h2>Preliminaries</h2>
+
+<p>The VDBE implements a virtual computer that runs a program in
+its virtual machine language.  The goal of each program is to 
+interrogate or change the database.  Toward this end, the machine
+language that the VDBE implements is specifically designed to
+search, read, and modify databases.</p>
+
+<p>Each instruction of the VDBE language contains an opcode and
+three operands labeled P1, P2, and P3.  Operand P1 is an arbitrary
+integer.   P2 is a non-negative integer.  P3 is a pointer to a data 
+structure or null-terminated string, possibly null.  Only a few VDBE
+instructions use all three operands.  Many instructions use only
+one or two operands.  A significant number of instructions use
+no operands at all but instead take their data and store their results
+on the execution stack.  The details of what each instruction
+does and which operands it uses are described in the separate
+<a href="opcode.html">opcode description</a> document.</p>
+
+<p>A VDBE program begins
+execution on instruction 0 and continues with successive instructions
+until it either (1) encounters a fatal error, (2) executes a
+Halt instruction, or (3) advances the program counter past the
+last instruction of the program.  When the VDBE completes execution,
+all open database cursors are closed, all memory is freed, and 
+everything is popped from the stack.
+So there are never any worries about memory leaks or 
+undeallocated resources.</p>
+
+<p>If you have done any assembly language programming or have
+worked with any kind of abstract machine before, all of these
+details should be familiar to you.  So let's jump right in and
+start looking as some code.</p>
+
+<a name="insert1">
+<h2>Inserting Records Into The Database</h2>
+
+<p>We begin with a problem that can be solved using a VDBE program
+that is only a few instructions long.  Suppose we have an SQL
+table that was created like this:</p>
+
+<blockquote><pre>
+CREATE TABLE examp(one text, two int);
+</pre></blockquote>
+
+<p>In words, we have a database table named "examp" that has two
+columns of data named "one" and "two".  Now suppose we want to insert a single
+record into this table.  Like this:</p>
+
+<blockquote><pre>
+INSERT INTO examp VALUES('Hello, World!',99);
+</pre></blockquote>
+
+<p>We can see the VDBE program that SQLite uses to implement this
+INSERT using the <b>sqlite</b> command-line utility.  First start
+up <b>sqlite</b> on a new, empty database, then create the table.
+Next change the output format of <b>sqlite</b> to a form that
+is designed to work with VDBE program dumps by entering the
+".explain" command.
+Finally, enter the INSERT statement shown above, but precede the
+INSERT with the special keyword "EXPLAIN".  The EXPLAIN keyword
+will cause <b>sqlite</b> to print the VDBE program rather than 
+execute it.  We have:</p>
+}
+proc Code {body} {
+  puts {<blockquote><tt>}
+  regsub -all {&} [string trim $body] {\&amp;} body
+  regsub -all {>} $body {\&gt;} body
+  regsub -all {<} $body {\&lt;} body
+  regsub -all {\(\(\(} $body {<b>} body
+  regsub -all {\)\)\)} $body {</b>} body
+  regsub -all { } $body {\&nbsp;} body
+  regsub -all \n $body <br>\n body
+  puts $body
+  puts {</tt></blockquote>}
+}
+
+Code {
+$ (((sqlite test_database_1)))
+sqlite> (((CREATE TABLE examp(one text, two int);)))
+sqlite> (((.explain)))
+sqlite> (((EXPLAIN INSERT INTO examp VALUES('Hello, World!',99);)))
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     Transaction   0      0                                         
+1     VerifyCookie  0      81                                        
+2     Transaction   1      0                                         
+3     Integer       0      0                                         
+4     OpenWrite     0      3      examp                              
+5     NewRecno      0      0                                         
+6     String        0      0      Hello, World!                      
+7     Integer       99     0      99                                 
+8     MakeRecord    2      0                                         
+9     PutIntKey     0      1                                         
+10    Close         0      0                                         
+11    Commit        0      0                                         
+12    Halt          0      0                                         
+}
+
+puts {<p>As you can see above, our simple insert statement is
+implemented in 12 instructions.  The first 3 and last 2 instructions are 
+a standard prologue and epilogue, so the real work is done in the middle 
+7 instructions.  There are no jumps, so the program executes once through 
+from top to bottom.  Let's now look at each instruction in detail.<p>
+}
+
+Code {
+0     Transaction   0      0                                         
+1     VerifyCookie  0      81                                        
+2     Transaction   1      0                                         
+}
+puts {
+<p>The instruction <a href="opcode.html#Transaction">Transaction</a> 
+begins a transaction.  The transaction ends when a Commit or Rollback 
+opcode is encountered.  P1 is the index of the database file on which 
+the transaction is started.  Index 0 is the main database file.  A write 
+lock is obtained on the database file when a transaction is started.  
+No other process can read or write the file while the transaction is 
+underway.  Starting a transaction also creates a rollback journal.  A 
+transaction must be started before any changes can be made to the 
+database.</p>
+
+<p>The instruction <a href="opcode.html#VerifyCookie">VerifyCookie</a>
+checks cookie 0 (the database schema version) to make sure it is equal 
+to P2 (the value obtained when the database schema was last read).  
+P1 is the database number (0 for the main database).  This is done to 
+make sure the database schema hasn't been changed by another thread, in 
+which case it has to be reread.</p>
+
+<p> The second <a href="opcode.html#Transaction">Transaction</a> 
+instruction begins a transaction and starts a rollback journal for 
+database 1, the database used for temporary tables.</p>
+}
+
+proc stack args {
+  puts "<blockquote><table border=2>"
+  foreach elem $args {
+    puts "<tr><td align=left>$elem</td></tr>"
+  }
+  puts "</table></blockquote>"
+}
+
+Code {
+3     Integer       0      0                                    
+4     OpenWrite     0      3      examp                         
+}
+puts {
+<p> The instruction <a href="opcode.html#Integer">Integer</a> pushes 
+the integer value P1 (0) onto the stack.  Here 0 is the number of the 
+database to use in the following OpenWrite instruction.  If P3 is not 
+NULL then it is a string representation of the same integer.  Afterwards 
+the stack looks like this:</p>
+}
+stack {(integer) 0}
+
+puts {
+<p> The instruction <a href="opcode.html#OpenWrite">OpenWrite</a> opens 
+a new read/write cursor with handle P1 (0 in this case) on table "examp", 
+whose root page is P2 (3, in this database file).  Cursor handles can be 
+any non-negative integer.  But the VDBE allocates cursors in an array 
+with the size of the array being one more than the largest cursor.  So 
+to conserve memory, it is best to use handles beginning with zero and 
+working upward consecutively.  Here P3 ("examp") is the name of the 
+table being opened, but this is unused, and only generated to make the 
+code easier to read.  This instruction pops the database number to use 
+(0, the main database) from the top of the stack, so afterwards the 
+stack is empty again.</p>
+}
+
+Code {
+5     NewRecno      0      0                                    
+}
+puts {
+<p> The instruction <a href="opcode.html#NewRecno">NewRecno</a> creates 
+a new integer record number for the table pointed to by cursor P1.  The 
+record number is one not currently used as a key in the table.  The new 
+record number is pushed onto the stack.  Afterwards the stack looks like 
+this:</p>
+}
+stack {(integer) new record key}
+
+Code {
+6     String        0      0      Hello, World!                 
+}
+puts {
+<p> The instruction <a href="opcode.html#String">String</a> pushes its 
+P3 operand onto the stack.  Afterwards the stack looks like this:</p>
+}
+stack {(string) "Hello, World!"} \
+ {(integer) new record key}
+
+Code {
+7     Integer       99     0      99                            
+}
+puts {
+<p> The instruction <a href="opcode.html#Integer">Integer</a> pushes 
+its P1 operand (99) onto the stack.  Afterwards the stack looks like 
+this:</p>
+}
+stack {(integer) 99} \
+ {(string) "Hello, World!"} \
+ {(integer) new record key}
+
+Code {
+8     MakeRecord    2      0                                    
+}
+puts {
+<p> The instruction <a href="opcode.html#MakeRecord">MakeRecord</a> pops 
+the top P1 elements off the stack (2 in this case) and converts them into 
+the binary format used for storing records in a database file.  
+(See the <a href="fileformat.html">file format</a> description for 
+details.)  The new record generated by the MakeRecord instruction is 
+pushed back onto the stack.  Afterwards the stack looks like this:</p>
+</ul>
+}
+stack {(record) "Hello, World!", 99} \
+ {(integer) new record key}
+
+Code {
+9     PutIntKey     0      1                                    
+}
+puts {
+<p> The instruction <a href="opcode.html#PutIntKey">PutIntKey</a> uses 
+the top 2 stack entries to write an entry into the table pointed to by 
+cursor P1.  A new entry is created if it doesn't already exist or the 
+data for an existing entry is overwritten.  The record data is the top 
+stack entry, and the key is the next entry down.  The stack is popped 
+twice by this instruction.  Because operand P2 is 1 the row change count 
+is incremented and the rowid is stored for subsequent return by the 
+sqlite_last_insert_rowid() function.  If P2 is 0 the row change count is 
+unmodified.  This instruction is where the insert actually occurs.</p>
+}
+
+Code {
+10    Close         0      0                                         
+}
+puts {
+<p> The instruction <a href="opcode.html#Close">Close</a> closes a 
+cursor previously opened as P1 (0, the only open cursor). If P1 is not 
+currently open, this instruction is a no-op.</p>
+}
+
+Code {
+11    Commit        0      0                                         
+}
+puts {
+<p> The instruction <a href="opcode.html#Commit">Commit</a> causes all 
+modifications to the database that have been made since the last 
+Transaction to actually take effect.  No additional modifications are 
+allowed until another transaction is started.  The Commit instruction 
+deletes the journal file and releases the write lock on the database.  
+A read lock continues to be held if there are still cursors open.</p>
+}
+
+Code {
+12    Halt          0      0                                         
+}
+puts {
+<p> The instruction <a href="opcode.html#Halt">Halt</a> causes the VDBE 
+engine to exit immediately.  All open cursors, Lists, Sorts, etc are 
+closed automatically.  P1 is the result code returned by sqlite_exec().  
+For a normal halt, this should be SQLITE_OK (0).  For errors, it can be 
+some other value.  The operand P2 is only used when there is an error.  
+There is an implied "Halt 0 0 0" instruction at the end of every 
+program, which the VDBE appends when it prepares a program to run.</p>
+
+
+<a name="trace">
+<h2>Tracing VDBE Program Execution</h2>
+
+<p>If the SQLite library is compiled without the NDEBUG preprocessor 
+macro, then the PRAGMA <a href="pragma.html#pragma_vdbe_trace">vdbe_trace
+</a> causes the VDBE to trace the execution of programs.  Though this 
+feature was originally intended for testing and debugging, it can also 
+be useful in learning about how the VDBE operates.  
+Use "<tt>PRAGMA&nbsp;vdbe_trace=ON;</tt>" to turn tracing on and 
+"<tt>PRAGMA&nbsp;vdbe_trace=OFF</tt>" to turn tracing back off.  
+Like this:</p>
+}
+
+Code {
+sqlite> (((PRAGMA vdbe_trace=ON;)))
+   0 Halt            0    0
+sqlite> (((INSERT INTO examp VALUES('Hello, World!',99);)))
+   0 Transaction     0    0
+   1 VerifyCookie    0   81
+   2 Transaction     1    0
+   3 Integer         0    0
+Stack: i:0
+   4 OpenWrite       0    3 examp
+   5 NewRecno        0    0
+Stack: i:2
+   6 String          0    0 Hello, World!
+Stack: t[Hello,.World!] i:2
+   7 Integer        99    0 99
+Stack: si:99 t[Hello,.World!] i:2
+   8 MakeRecord      2    0
+Stack: s[...Hello,.World!.99] i:2
+   9 PutIntKey       0    1
+  10 Close           0    0
+  11 Commit          0    0
+  12 Halt            0    0
+}
+
+puts {
+<p>With tracing mode on, the VDBE prints each instruction prior
+to executing it.  After the instruction is executed, the top few
+entries in the stack are displayed.  The stack display is omitted
+if the stack is empty.</p>
+
+<p>On the stack display, most entries are shown with a prefix
+that tells the datatype of that stack entry.  Integers begin
+with "<tt>i:</tt>".  Floating point values begin with "<tt>r:</tt>".
+(The "r" stands for "real-number".)  Strings begin with either
+"<tt>s:</tt>", "<tt>t:</tt>", "<tt>e:</tt>" or "<tt>z:</tt>".  
+The difference among the string prefixes is caused by how their 
+memory is allocated. The z: strings are stored in memory obtained
+from <b>malloc()</b>.  The t: strings are statically allocated.  
+The e: strings are ephemeral.  All other strings have the s: prefix.  
+This doesn't make any difference to you,
+the observer, but it is vitally important to the VDBE since the
+z: strings need to be passed to <b>free()</b> when they are
+popped to avoid a memory leak.  Note that only the first 10
+characters of string values are displayed and that binary
+values (such as the result of the MakeRecord instruction) are
+treated as strings.  The only other datatype that can be stored
+on the VDBE stack is a NULL, which is display without prefix
+as simply "<tt>NULL</tt>".  If an integer has been placed on the 
+stack as both an integer and a string, its prefix is "<tt>si:</tt>".
+
+
+<a name="query1">
+<h2>Simple Queries</h2>
+
+<p>At this point, you should understand the basics of how the VDBE
+writes to a database.  Now let's look at how it does queries.
+We will use the following simple SELECT statement as our example:</p>
+
+<blockquote><pre>
+SELECT * FROM examp;
+</pre></blockquote>
+
+<p>The VDBE program generated for this SQL statement is as follows:</p>
+}
+
+Code {
+sqlite> (((EXPLAIN SELECT * FROM examp;)))
+addr  opcode        p1     p2     p3                                 
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      one                                
+1     ColumnName    1      0      two                                
+2     Integer       0      0                                         
+3     OpenRead      0      3      examp                              
+4     VerifyCookie  0      81                                        
+5     Rewind        0      10                                        
+6     Column        0      0                                         
+7     Column        0      1                                         
+8     Callback      2      0                                         
+9     Next          0      6                                         
+10    Close         0      0                                         
+11    Halt          0      0                                         
+}
+
+puts {
+<p>Before we begin looking at this problem, let's briefly review
+how queries work in SQLite so that we will know what we are trying
+to accomplish.  For each row in the result of a query,
+SQLite will invoke a callback function with the following
+prototype:</p>
+
+<blockquote><pre>
+int Callback(void *pUserData, int nColumn, char *azData[], char *azColumnName[]);
+</pre></blockquote>
+
+<p>The SQLite library supplies the VDBE with a pointer to the callback function
+and the <b>pUserData</b> pointer.  (Both the callback and the user data were
+originally passed in as arguments to the <b>sqlite_exec()</b> API function.)
+The job of the VDBE is to
+come up with values for <b>nColumn</b>, <b>azData[]</b>, 
+and <b>azColumnName[]</b>.
+<b>nColumn</b> is the number of columns in the results, of course.
+<b>azColumnName[]</b> is an array of strings where each string is the name
+of one of the result columns.  <b>azData[]</b> is an array of strings holding
+the actual data.</p>
+}
+
+Code {
+0     ColumnName    0      0      one                                
+1     ColumnName    1      0      two                                
+}
+puts {
+<p>The first two instructions in the VDBE program for our query are
+concerned with setting up values for <b>azColumn</b>.
+The <a href="opcode.html#ColumnName">ColumnName</a> instructions tell 
+the VDBE what values to fill in for each element of the <b>azColumnName[]</b> 
+array.  Every query will begin with one ColumnName instruction for each 
+column in the result, and there will be a matching Column instruction for 
+each one later in the query.
+</p>
+}
+
+Code {
+2     Integer       0      0                                         
+3     OpenRead      0      3      examp                              
+4     VerifyCookie  0      81                                        
+}
+puts {
+<p>Instructions 2 and 3 open a read cursor on the database table that is 
+to be queried.  This works the same as the OpenWrite instruction in the 
+INSERT example except that the cursor is opened for reading this time 
+instead of for writing.  Instruction 4 verifies the database schema as 
+in the INSERT example.</p>
+}
+
+Code {
+5     Rewind        0      10                                        
+}
+puts {
+<p> The <a href="opcode.html#Rewind">Rewind</a> instruction initializes 
+a loop that iterates over the "examp" table. It rewinds the cursor P1 
+to the first entry in its table.  This is required by the the Column and 
+Next instructions, which use the cursor to iterate through the table.  
+If the table is empty, then jump to P2 (10), which is the instruction just 
+past the loop.  If the table is not empty, fall through to the following 
+instruction at 6, which is the beginning of the loop body.</p>
+}
+
+Code {
+6     Column        0      0                                         
+7     Column        0      1                                         
+8     Callback      2      0                                         
+}
+puts {
+<p> The instructions 6 through 8 form the body of the loop that will 
+execute once for each record in the database file.  
+
+The <a href="opcode.html#Column">Column</a> instructions at addresses 6 
+and 7 each take the P2-th column from the P1-th cursor and push it onto 
+the stack.  In this example, the first Column instruction is pushing the 
+value for the column "one" onto the stack and the second Column 
+instruction is pushing the value for column "two".  
+
+The <a href="opcode.html#Callback">Callback</a> instruction at address 8 
+invokes the callback() function.  The P1 operand to Callback becomes the 
+value for <b>nColumn</b>.  The Callback instruction pops P1 values from
+the stack and uses them to fill the <b>azData[]</b> array.</p>
+}
+
+Code {
+9     Next          0      6                                              
+}
+puts {
+<p>The instruction at address 9 implements the branching part of the 
+loop.  Together with the Rewind at address 5 it forms the loop logic.  
+This is a key concept that you should pay close attention to.   
+The <a href="opcode.html#Next">Next</a> instruction advances the cursor 
+P1 to the next record.  If the cursor advance was successful, then jump 
+immediately to P2 (6, the beginning of the loop body).  If the cursor 
+was at the end, then fall through to the following instruction, which 
+ends the loop.</p>
+}
+
+Code {
+10    Close         0      0                                         
+11    Halt          0      0                                         
+}
+puts {
+<p>The Close instruction at the end of the program closes the
+cursor that points into the table "examp".  It is not really necessary
+to call Close here since all cursors will be automatically closed
+by the VDBE when the program halts.  But we needed an instruction
+for the Rewind to jump to so we might as well go ahead and have that
+instruction do something useful.
+The Halt instruction ends the VDBE program.</p>
+
+<p>Note that the program for this SELECT query didn't contain the 
+Transaction and Commit instructions used in the INSERT example.  Because 
+the SELECT is a read operation that doesn't alter the database, it 
+doesn't require a transaction.</p>
+}
+
+
+puts {
+<a name="query2">
+<h2>A Slightly More Complex Query</h2>
+
+<p>The key points of the previous example were the use of the Callback
+instruction to invoke the callback function, and the use of the Next
+instruction to implement a loop over all records of the database file.
+This example attempts to drive home those ideas by demonstrating a
+slightly more complex query that involves more columns of
+output, some of which are computed values, and a WHERE clause that
+limits which records actually make it to the callback function.
+Consider this query:</p>
+
+<blockquote><pre>
+SELECT one, two, one || two AS 'both'
+FROM examp
+WHERE one LIKE 'H%'
+</pre></blockquote>
+
+<p>This query is perhaps a bit contrived, but it does serve to
+illustrate our points.  The result will have three column with
+names "one", "two", and "both".  The first two columns are direct
+copies of the two columns in the table and the third result
+column is a string formed by concatenating the first and
+second columns of the table.
+Finally, the
+WHERE clause says that we will only chose rows for the 
+results where the "one" column begins with an "H".
+Here is what the VDBE program looks like for this query:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      one
+1     ColumnName    1      0      two
+2     ColumnName    2      0      both
+3     Integer       0      0
+4     OpenRead      0      3      examp
+5     VerifyCookie  0      81
+6     Rewind        0      18
+7     String        0      0      H%                                      
+8     Column        0      0
+9     Function      2      0      ptr(0x7f1ac0)
+10    IfNot         1      17
+11    Column        0      0
+12    Column        0      1
+13    Column        0      0
+14    Column        0      1
+15    Concat        2      0
+16    Callback      3      0
+17    Next          0      7
+18    Close         0      0
+19    Halt          0      0
+}
+
+puts {
+<p>Except for the WHERE clause, the structure of the program for
+this example is very much like the prior example, just with an
+extra column.  There are now 3 columns, instead of 2 as before,
+and there are three ColumnName instructions.
+A cursor is opened using the OpenRead instruction, just like in the
+prior example.  The Rewind instruction at address 6 and the
+Next at address 17 form a loop over all records of the table.  
+The Close instruction at the end is there to give the
+Rewind instruction something to jump to when it is done.  All of
+this is just like in the first query demonstration.</p>
+
+<p>The Callback instruction in this example has to generate
+data for three result columns instead of two, but is otherwise
+the same as in the first query.  When the Callback instruction
+is invoked, the left-most column of the result should be
+the lowest in the stack and the right-most result column should
+be the top of the stack.  We can see the stack being set up 
+this way at addresses 11 through 15.  The Column instructions at
+11 and 12 push the values for the first two columns in the result.
+The two Column instructions at 13 and 14 pull in the values needed
+to compute the third result column and the Concat instruction at
+15 joins them together into a single entry on the stack.</p>
+
+<p>The only thing that is really new about the current example
+is the WHERE clause which is implemented by instructions at
+addresses 7 through 10.  Instructions at address 7 and 8 push
+onto the stack the value of the "one" column from the table
+and the literal string "H%".  
+The <a href="opcode.html#Function">Function</a> instruction at address 9 
+pops these two values from the stack and pushes the result of the LIKE() 
+function back onto the stack.  
+The <a href="opcode.html#IfNot">IfNot</a> instruction pops the top stack 
+value and causes an immediate jump forward to the Next instruction if the 
+top value was false (<em>not</em> not like the literal string "H%").  
+Taking this jump effectively skips the callback, which is the whole point
+of the WHERE clause.  If the result
+of the comparison is true, the jump is not taken and control
+falls through to the Callback instruction below.</p>
+
+<p>Notice how the LIKE operator is implemented.  It is a user-defined 
+function in SQLite, so the address of its function definition is 
+specified in P3.  The operand P1 is the number of function arguments for 
+it to take from the stack.  In this case the LIKE() function takes 2 
+arguments.  The arguments are taken off the stack in reverse order 
+(right-to-left), so the pattern to match is the top stack element, and 
+the next element is the data to compare.  The return value is pushed 
+onto the stack.</p>
+
+
+<a name="pattern1">
+<h2>A Template For SELECT Programs</h2>
+
+<p>The first two query examples illustrate a kind of template that
+every SELECT program will follow.  Basically, we have:</p>
+
+<p>
+<ol>
+<li>Initialize the <b>azColumnName[]</b> array for the callback.</li>
+<li>Open a cursor into the table to be queried.</li>
+<li>For each record in the table, do:
+    <ol type="a">
+    <li>If the WHERE clause evaluates to FALSE, then skip the steps that
+        follow and continue to the next record.</li>
+    <li>Compute all columns for the current row of the result.</li>
+    <li>Invoke the callback function for the current row of the result.</li>
+    </ol>
+<li>Close the cursor.</li>
+</ol>
+</p>
+
+<p>This template will be expanded considerably as we consider
+additional complications such as joins, compound selects, using
+indices to speed the search, sorting, and aggregate functions
+with and without GROUP BY and HAVING clauses.
+But the same basic ideas will continue to apply.</p>
+
+<h2>UPDATE And DELETE Statements</h2>
+
+<p>The UPDATE and DELETE statements are coded using a template
+that is very similar to the SELECT statement template.  The main
+difference, of course, is that the end action is to modify the
+database rather than invoke a callback function.  Because it modifies 
+the database it will also use transactions.  Let's begin
+by looking at a DELETE statement:</p>
+
+<blockquote><pre>
+DELETE FROM examp WHERE two<50;
+</pre></blockquote>
+
+<p>This DELETE statement will remove every record from the "examp"
+table where the "two" column is less than 50.
+The code generated to do this is as follows:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     Transaction   1      0
+1     Transaction   0      0
+2     VerifyCookie  0      178
+3     Integer       0      0
+4     OpenRead      0      3      examp
+5     Rewind        0      12
+6     Column        0      1
+7     Integer       50     0      50
+8     Ge            1      11
+9     Recno         0      0
+10    ListWrite     0      0
+11    Next          0      6
+12    Close         0      0
+13    ListRewind    0      0
+14    Integer       0      0
+15    OpenWrite     0      3
+16    ListRead      0      20
+17    NotExists     0      19
+18    Delete        0      1
+19    Goto          0      16
+20    ListReset     0      0
+21    Close         0      0
+22    Commit        0      0
+23    Halt          0      0
+}
+
+puts {
+<p>Here is what the program must do.  First it has to locate all of
+the records in the table "examp" that are to be deleted.  This is
+done using a loop very much like the loop used in the SELECT examples
+above.  Once all records have been located, then we can go back through
+and delete them one by one.  Note that we cannot delete each record
+as soon as we find it.  We have to locate all records first, then
+go back and delete them.  This is because the SQLite database
+backend might change the scan order after a delete operation.
+And if the scan
+order changes in the middle of the scan, some records might be
+visited more than once and other records might not be visited at all.</p>
+
+<p>So the implemention of DELETE is really in two loops.  The first loop 
+(instructions 5 through 11) locates the records that are to be deleted 
+and saves their keys onto a temporary list, and the second loop 
+(instructions 16 through 19) uses the key list to delete the records one 
+by one.  </p>
+}
+
+
+Code {
+0     Transaction   1      0
+1     Transaction   0      0
+2     VerifyCookie  0      178
+3     Integer       0      0
+4     OpenRead      0      3      examp
+}
+puts {
+<p>Instructions 0 though 4 are as in the INSERT example.  They start 
+transactions for the main and temporary databases, verify the database 
+schema for the main database, and open a read cursor on the table 
+"examp".  Notice that the cursor is opened for reading, not writing.  At 
+this stage of the program we are only going to be scanning the table, 
+not changing it.  We will reopen the same table for writing later, at 
+instruction 15.</p>
+}
+
+Code {
+5     Rewind        0      12
+}
+puts {
+<p>As in the SELECT example, the <a href="opcode.html#Rewind">Rewind</a> 
+instruction rewinds the cursor to the beginning of the table, readying 
+it for use in the loop body.</p>
+}
+
+Code {
+6     Column        0      1
+7     Integer       50     0      50
+8     Ge            1      11
+}
+puts {
+<p>The WHERE clause is implemented by instructions 6 through 8.
+The job of the where clause is to skip the ListWrite if the WHERE
+condition is false.  To this end, it jumps ahead to the Next instruction
+if the "two" column (extracted by the Column instruction) is
+greater than or equal to 50.</p>
+
+<p>As before, the Column instruction uses cursor P1 and pushes the data 
+record in column P2 (1, column "two") onto the stack.  The Integer 
+instruction pushes the value 50 onto the top of the stack.  After these 
+two instructions the stack looks like:</p>
+}
+stack {(integer) 50} \
+  {(record) current record for column "two" }
+
+puts {
+<p>The <a href="opcode.html#Ge">Ge</a> operator compares the top two 
+elements on the stack, pops them, and then branches based on the result 
+of the comparison.  If the second element is >= the top element, then 
+jump to address P2 (the Next instruction at the end of the loop).  
+Because P1 is true, if either operand is NULL (and thus the result is 
+NULL) then take the jump.  If we don't jump, just advance to the next 
+instruction.</p>
+}
+
+Code {
+9     Recno         0      0
+10    ListWrite     0      0
+}
+puts {
+<p>The <a href="opcode.html#Recno">Recno</a> instruction pushes onto the 
+stack an integer which is the first 4 bytes of the the key to the current 
+entry in a sequential scan of the table pointed to by cursor P1.
+The <a href="opcode.html#ListWrite">ListWrite</a> instruction writes the 
+integer on the top of the stack into a temporary storage list and pops 
+the top element.  This is the important work of this loop, to store the 
+keys of the records to be deleted so we can delete them in the second 
+loop.  After this ListWrite instruction the stack is empty again.</p>
+}
+
+Code {
+11    Next          0      6
+12    Close         0      0
+}
+puts {
+<p> The Next instruction increments the cursor to point to the next 
+element in the table pointed to by cursor P0, and if it was successful 
+branches to P2 (6, the beginning of the loop body).  The Close 
+instruction closes cursor P1.  It doesn't affect the temporary storage 
+list because it isn't associated with cursor P1; it is instead a global 
+working list (which can be saved with ListPush).</p>
+}
+
+Code {
+13    ListRewind    0      0
+}
+puts {
+<p> The <a href="opcode.html#ListRewind">ListRewind</a> instruction 
+rewinds the temporary storage list to the beginning.  This prepares it 
+for use in the second loop.</p>
+}
+
+Code {
+14    Integer       0      0
+15    OpenWrite     0      3
+}
+puts {
+<p> As in the INSERT example, we push the database number P1 (0, the main 
+database) onto the stack and use OpenWrite to open the cursor P1 on table 
+P2 (base page 3, "examp") for modification.</p>
+}
+
+Code {
+16    ListRead      0      20
+17    NotExists     0      19
+18    Delete        0      1
+19    Goto          0      16
+}
+puts {
+<p>This loop does the actual deleting.  It is organized differently from 
+the one in the UPDATE example.  The ListRead instruction plays the role 
+that the Next did in the INSERT loop, but because it jumps to P2 on 
+failure, and Next jumps on success, we put it at the start of the loop 
+instead of the end.  This means that we have to put a Goto at the end of 
+the loop to jump back to the the loop test at the beginning.  So this 
+loop has the form of a C while(){...} loop, while the loop in the INSERT 
+example had the form of a do{...}while() loop.  The Delete instruction 
+fills the role that the callback function did in the preceding examples.
+</p>
+<p>The <a href="opcode.html#ListRead">ListRead</a> instruction reads an 
+element from the temporary storage list and pushes it onto the stack.  
+If this was successful, it continues to the next instruction.  If this 
+fails because the list is empty, it branches to P2, which is the 
+instruction just after the loop.  Afterwards the stack looks like:</p>
+}
+stack {(integer) key for current record}
+
+puts {
+<p>Notice the similarity between the ListRead and Next instructions.  
+Both operations work according to this rule:
+</p>
+<blockquote>
+Push the next "thing" onto the stack and fall through OR jump to P2, 
+depending on whether or not there is a next "thing" to push.
+</blockquote>
+<p>One difference between Next and ListRead is their idea of a "thing".  
+The "things" for the Next instruction are records in a database file.  
+"Things" for ListRead are integer keys in a list.  Another difference 
+is whether to jump or fall through if there is no next "thing".  In this 
+case, Next falls through, and ListRead jumps. Later on, we will see 
+other looping instructions (NextIdx and SortNext) that operate using the 
+same principle.</p>
+
+<p>The <a href="opcode.html#NotExists">NotExists</a> instruction pops 
+the top stack element and uses it as an integer key.  If a record with 
+that key does not exist in table P1, then jump to P2.  If a record does 
+exist, then fall thru to the next instruction.  In this case P2 takes 
+us to the Goto at the end of the loop, which jumps back to the ListRead 
+at the beginning.  This could have been coded to have P2 be 16, the 
+ListRead at the start of the loop, but the SQLite parser which generated 
+this code didn't make that optimization.</p>
+<p>The <a href="opcode.html#Delete">Delete</a> does the work of this 
+loop; it pops an integer key off the stack (placed there by the 
+preceding ListRead) and deletes the record of cursor P1 that has that key.  
+Because P2 is true, the row change counter is incremented.</p>
+<p>The <a href="opcode.html#Goto">Goto</a> jumps back to the beginning 
+of the loop.  This is the end of the loop.</p>
+}
+
+Code {
+20    ListReset     0      0
+21    Close         0      0
+22    Commit        0      0
+23    Halt          0      0
+}
+puts {
+<p>This block of instruction cleans up the VDBE program. Three of these 
+instructions aren't really required, but are generated by the SQLite 
+parser from its code templates, which are designed to handle more 
+complicated cases.</p>
+<p>The <a href="opcode.html#ListReset">ListReset</a> instruction empties 
+the temporary storage list.  This list is emptied automatically when the 
+VDBE program terminates, so it isn't necessary in this case.  The Close 
+instruction closes the cursor P1.  Again, this is done by the VDBE 
+engine when it is finished running this program.  The Commit ends the 
+current transaction successfully, and causes all changes that occurred 
+in this transaction to be saved to the database.  The final Halt is also 
+unneccessary, since it is added to every VDBE program when it is 
+prepared to run.</p>
+
+
+<p>UPDATE statements work very much like DELETE statements except
+that instead of deleting the record they replace it with a new one.
+Consider this example:
+</p>
+
+<blockquote><pre>
+UPDATE examp SET one= '(' || one || ')' WHERE two < 50;
+</pre></blockquote>
+
+<p>Instead of deleting records where the "two" column is less than
+50, this statement just puts the "one" column in parentheses
+The VDBE program to implement this statement follows:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     Transaction   1      0                                         
+1     Transaction   0      0                                         
+2     VerifyCookie  0      178                                            
+3     Integer       0      0                                         
+4     OpenRead      0      3      examp                              
+5     Rewind        0      12                                        
+6     Column        0      1                                         
+7     Integer       50     0      50                                 
+8     Ge            1      11                                        
+9     Recno         0      0                                         
+10    ListWrite     0      0                                         
+11    Next          0      6                                              
+12    Close         0      0                                         
+13    Integer       0      0                                         
+14    OpenWrite     0      3                                              
+15    ListRewind    0      0                                         
+16    ListRead      0      28                                             
+17    Dup           0      0                                         
+18    NotExists     0      16                                             
+19    String        0      0      (                                  
+20    Column        0      0                                         
+21    Concat        2      0                                         
+22    String        0      0      )                                  
+23    Concat        2      0                                         
+24    Column        0      1                                         
+25    MakeRecord    2      0                                         
+26    PutIntKey     0      1                                         
+27    Goto          0      16                                             
+28    ListReset     0      0                                         
+29    Close         0      0                                         
+30    Commit        0      0                                         
+31    Halt          0      0                                         
+}
+
+puts {
+<p>This program is essentially the same as the DELETE program except 
+that the body of the second loop has been replace by a sequence of 
+instructions (at addresses 17 through 26) that update the record rather 
+than delete it.  Most of this instruction sequence should already be 
+familiar to you, but there are a couple of minor twists so we will go 
+over it briefly.  Also note that the order of some of the instructions 
+before and after the 2nd loop has changed.  This is just the way the 
+SQLite parser chose to output the code using a different template.</p>
+
+<p>As we enter the interior of the second loop (at instruction 17)
+the stack contains a single integer which is the key of the
+record we want to modify.  We are going to need to use this
+key twice: once to fetch the old value of the record and
+a second time to write back the revised record.  So the first instruction
+is a Dup to make a duplicate of the key on the top of the stack.  The
+Dup instruction will duplicate any element of the stack, not just the top
+element.  You specify which element to duplication using the
+P1 operand.  When P1 is 0, the top of the stack is duplicated.
+When P1 is 1, the next element down on the stack duplication.
+And so forth.</p>
+
+<p>After duplicating the key, the next instruction, NotExists,
+pops the stack once and uses the value popped as a key to
+check the existence of a record in the database file.  If there is no record 
+for this key, it jumps back to the ListRead to get another key.</p>
+
+<p>Instructions 19 through 25 construct a new database record
+that will be used to replace the existing record.  This is
+the same kind of code that we saw 
+in the description of INSERT and will not be described further.
+After instruction 25 executes, the stack looks like this:</p>
+}
+
+stack {(record) new data record} {(integer) key}
+
+puts {
+<p>The PutIntKey instruction (also described
+during the discussion about INSERT) writes an entry into the
+database file whose data is the top of the stack and whose key
+is the next on the stack, and then pops the stack twice.  The
+PutIntKey instruction will overwrite the data of an existing record
+with the same key, which is what we want here.  Overwriting was not
+an issue with INSERT because with INSERT the key was generated
+by the NewRecno instruction which is guaranteed to provide a key
+that has not been used before.</p>
+}
+
+if 0 {<p>(By the way, since keys must
+all be unique and each key is a 32-bit integer, a single
+SQLite database table can have no more than 2<sup>32</sup>
+rows.  Actually, the Key instruction starts to become
+very inefficient as you approach this upper bound, so it
+is best to keep the number of entries below 2<sup>31</sup>
+or so.  Surely a couple billion records will be enough for
+most applications!)</p>
+}
+
+puts {
+<h2>CREATE and DROP</h2>
+
+<p>Using CREATE or DROP to create or destroy a table or index is
+really the same as doing an INSERT or DELETE from the special
+"sqlite_master" table, at least from the point of view of the VDBE.
+The sqlite_master table is a special table that is automatically
+created for every SQLite database.  It looks like this:</p>
+
+<blockquote><pre>
+CREATE TABLE sqlite_master (
+  type      TEXT,    -- either "table" or "index"
+  name      TEXT,    -- name of this table or index
+  tbl_name  TEXT,    -- for indices: name of associated table
+  sql       TEXT     -- SQL text of the original CREATE statement
+)
+</pre></blockquote>
+
+<p>Every table (except the "sqlite_master" table itself)
+and every named index in an SQLite database has an entry
+in the sqlite_master table.  You can query this table using
+a SELECT statement just like any other table.  But you are
+not allowed to directly change the table using UPDATE, INSERT,
+or DELETE.  Changes to sqlite_master have to occur using
+the CREATE and DROP commands because SQLite also has to update
+some of its internal data structures when tables and indices
+are added or destroyed.</p>
+
+<p>But from the point of view of the VDBE, a CREATE works
+pretty much like an INSERT and a DROP works like a DELETE.
+When the SQLite library opens to an existing database,
+the first thing it does is a SELECT to read the "sql"
+columns from all entries of the sqlite_master table.
+The "sql" column contains the complete SQL text of the
+CREATE statement that originally generated the index or
+table.  This text is fed back into the SQLite parser
+and used to reconstruct the
+internal data structures describing the index or table.</p>
+
+<h2>Using Indexes To Speed Searching</h2>
+
+<p>In the example queries above, every row of the table being
+queried must be loaded off of the disk and examined, even if only
+a small percentage of the rows end up in the result.  This can
+take a long time on a big table.  To speed things up, SQLite
+can use an index.</p>
+
+<p>An SQLite file associates a key with some data.  For an SQLite
+table, the database file is set up so that the key is an integer
+and the data is the information for one row of the table.
+Indices in SQLite reverse this arrangement.  The index key
+is (some of) the information being stored and the index data 
+is an integer.
+To access a table row that has some particular
+content, we first look up the content in the index table to find
+its integer index, then we use that integer to look up the
+complete record in the table.</p>
+
+<p>Note that SQLite uses b-trees, which are a sorted data structure, 
+so indices can be used when the WHERE clause of the SELECT statement
+contains tests for equality or inequality.  Queries like the following 
+can use an index if it is available:</p>
+
+<blockquote><pre>
+SELECT * FROM examp WHERE two==50;
+SELECT * FROM examp WHERE two<50;
+SELECT * FROM examp WHERE two IN (50, 100);
+</pre></blockquote>
+
+<p>If there exists an index that maps the "two" column of the "examp"
+table into integers, then SQLite will use that index to find the integer
+keys of all rows in examp that have a value of 50 for column two, or 
+all rows that are less than 50, etc.
+But the following queries cannot use the index:</p>
+
+<blockquote><pre>
+SELECT * FROM examp WHERE two%50 == 10;
+SELECT * FROM examp WHERE two&127 == 3;
+</pre></blockquote>
+
+<p>Note that the SQLite parser will not always generate code to use an 
+index, even if it is possible to do so.  The following queries will not 
+currently use the index:</p>
+
+<blockquote><pre>
+SELECT * FROM examp WHERE two+10 == 50;
+SELECT * FROM examp WHERE two==50 OR two==100;
+</pre></blockquote>
+
+<p>To understand better how indices work, lets first look at how
+they are created.  Let's go ahead and put an index on the two
+column of the examp table.  We have:</p>
+
+<blockquote><pre>
+CREATE INDEX examp_idx1 ON examp(two);
+</pre></blockquote>
+
+<p>The VDBE code generated by the above statement looks like the
+following:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     Transaction   1      0                                         
+1     Transaction   0      0                                         
+2     VerifyCookie  0      178                                            
+3     Integer       0      0                                         
+4     OpenWrite     0      2                                         
+5     NewRecno      0      0                                         
+6     String        0      0      index                              
+7     String        0      0      examp_idx1                         
+8     String        0      0      examp                              
+9     CreateIndex   0      0      ptr(0x791380)                      
+10    Dup           0      0                                         
+11    Integer       0      0                                         
+12    OpenWrite     1      0                                         
+13    String        0      0      CREATE INDEX examp_idx1 ON examp(tw
+14    MakeRecord    5      0                                         
+15    PutIntKey     0      0                                         
+16    Integer       0      0                                         
+17    OpenRead      2      3      examp                              
+18    Rewind        2      24                                             
+19    Recno         2      0                                         
+20    Column        2      1                                         
+21    MakeIdxKey    1      0      n                                  
+22    IdxPut        1      0      indexed columns are not unique     
+23    Next          2      19                                             
+24    Close         2      0                                         
+25    Close         1      0                                         
+26    Integer       333    0                                         
+27    SetCookie     0      0                                         
+28    Close         0      0                                         
+29    Commit        0      0                                         
+30    Halt          0      0                                         
+}
+
+puts {
+<p>Remember that every table (except sqlite_master) and every named
+index has an entry in the sqlite_master table.  Since we are creating
+a new index, we have to add a new entry to sqlite_master.  This is
+handled by instructions 3 through 15.  Adding an entry to sqlite_master
+works just like any other INSERT statement so we will not say anymore
+about it here.  In this example, we want to focus on populating the
+new index with valid data, which happens on instructions 16 through 
+23.</p>
+}
+
+Code {
+16    Integer       0      0                                         
+17    OpenRead      2      3      examp                              
+}
+puts {
+<p>The first thing that happens is that we open the table being
+indexed for reading.  In order to construct an index for a table,
+we have to know what is in that table.  The index has already been 
+opened for writing using cursor 0 by instructions 3 and 4.</p>
+}
+
+Code {
+18    Rewind        2      24                                             
+19    Recno         2      0                                         
+20    Column        2      1                                         
+21    MakeIdxKey    1      0      n                                  
+22    IdxPut        1      0      indexed columns are not unique     
+23    Next          2      19                                             
+}
+puts {
+<p>Instructions 18 through 23 implement a loop over every row of the 
+table being indexed.  For each table row, we first extract the integer 
+key for that row using Recno in instruction 19, then get the value of 
+the "two" column using Column in instruction 20.  
+The <a href="opcode.html#MakeIdxKey">MakeIdxKey</a> instruction at 21 
+converts data from the "two" column (which is on the top of the stack) 
+into a valid index key.  For an index on a single column, this is 
+basically a no-op.  But if the P1 operand to MakeIdxKey had been 
+greater than one multiple entries would have been popped from the stack 
+and converted into a single index key.  
+The <a href="opcode.html#IdxPut">IdxPut</a> instruction at 22 is what 
+actually creates the index entry.  IdxPut pops two elements from the 
+stack.  The top of the stack is used as a key to fetch an entry from the 
+index table.  Then the integer which was second on stack is added to the 
+set of integers for that index and the new record is written back to the 
+database file.  Note
+that the same index entry can store multiple integers if there
+are two or more table entries with the same value for the two
+column.
+</p>
+
+<p>Now let's look at how this index will be used.  Consider the
+following query:</p>
+
+<blockquote><pre>
+SELECT * FROM examp WHERE two==50;
+</pre></blockquote>
+
+<p>SQLite generates the following VDBE code to handle this query:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      one                                
+1     ColumnName    1      0      two                                
+2     Integer       0      0                                         
+3     OpenRead      0      3      examp                              
+4     VerifyCookie  0      256                                            
+5     Integer       0      0                                         
+6     OpenRead      1      4      examp_idx1                         
+7     Integer       50     0      50                            
+8     MakeKey       1      0      n                                  
+9     MemStore      0      0                                         
+10    MoveTo        1      19                                             
+11    MemLoad       0      0                                         
+12    IdxGT         1      19                                             
+13    IdxRecno      1      0                                         
+14    MoveTo        0      0                                         
+15    Column        0      0                                         
+16    Column        0      1                                         
+17    Callback      2      0                                         
+18    Next          1      11                                        
+19    Close         0      0                                         
+20    Close         1      0                                         
+21    Halt          0      0                                         
+}
+
+puts {
+<p>The SELECT begins in a familiar fashion.  First the column
+names are initialized and the table being queried is opened.
+Things become different beginning with instructions 5 and 6 where
+the index file is also opened.  Instructions 7 and 8 make
+a key with the value of 50.  
+The <a href="opcode.html#MemStore">MemStore</a> instruction at 9 stores 
+the index key in VDBE memory location 0.  The VDBE memory is used to 
+avoid having to fetch a value from deep in the stack, which can be done,
+but makes the program harder to generate.  The following instruction 
+<a href="opcode.html#MoveTo">MoveTo</a> at address 10 pops the key off 
+the stack and moves the index cursor to the first row of the index with 
+that key.  This initializes the cursor for use in the following loop.</p>
+
+<p>Instructions 11 through 18 implement a loop over all index records 
+with the key that was fetched by instruction 8.  All of the index 
+records with this key will be contiguous in the index table, so we walk 
+through them and fetch the corresponding table key from the index.  
+This table key is then used to move the cursor to that row in the table.  
+The rest of the loop is the same as the loop for the non-indexed SELECT 
+query.</p>
+
+<p>The loop begins with the <a href="opcode.html#MemLoad">MemLoad</a> 
+instruction at 11 which pushes a copy of the index key back onto the 
+stack.  The instruction <a href="opcode.html#IdxGT">IdxGT</a> at 12 
+compares the key to the key in the current index record pointed to by 
+cursor P1.  If the index key at the current cursor location is greater 
+than the the index we are looking for, then jump out of the loop.</p>
+
+<p>The instruction <a href="opcode.html#IdxRecno">IdxRecno</a> at 13 
+pushes onto the stack the table record number from the index.  The 
+following MoveTo pops it and moves the table cursor to that row.  The 
+next 3 instructions select the column data the same way as in the non-
+indexed case. The Column instructions fetch the column data and the 
+callback function is invoked.  The final Next instruction advances the 
+index cursor, not the table cursor, to the next row, and then branches 
+back to the start of the loop if there are any index records left.</p>
+
+<p>Since the index is used to look up values in the table,
+it is important that the index and table be kept consistent.
+Now that there is an index on the examp table, we will have
+to update that index whenever data is inserted, deleted, or
+changed in the examp table.  Remember the first example above
+where we were able to insert a new row into the "examp" table using
+12 VDBE instructions.  Now that this table is indexed, 19
+instructions are required.  The SQL statement is this:</p>
+
+<blockquote><pre>
+INSERT INTO examp VALUES('Hello, World!',99);
+</pre></blockquote>
+
+<p>And the generated code looks like this:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     Transaction   1      0                                         
+1     Transaction   0      0                                         
+2     VerifyCookie  0      256                                            
+3     Integer       0      0                                         
+4     OpenWrite     0      3      examp                              
+5     Integer       0      0                                         
+6     OpenWrite     1      4      examp_idx1                         
+7     NewRecno      0      0                                         
+8     String        0      0      Hello, World!                      
+9     Integer       99     0      99                                 
+10    Dup           2      1                                         
+11    Dup           1      1                                         
+12    MakeIdxKey    1      0      n                                  
+13    IdxPut        1      0                                         
+14    MakeRecord    2      0                                         
+15    PutIntKey     0      1                                         
+16    Close         0      0                                         
+17    Close         1      0                                         
+18    Commit        0      0                                         
+19    Halt          0      0                                         
+}
+
+puts {
+<p>At this point, you should understand the VDBE well enough to
+figure out on your own how the above program works.  So we will
+not discuss it further in this text.</p>
+
+<h2>Joins</h2>
+
+<p>In a join, two or more tables are combined to generate a single
+result.  The result table consists of every possible combination
+of rows from the tables being joined.  The easiest and most natural
+way to implement this is with nested loops.</p>
+
+<p>Recall the query template discussed above where there was a
+single loop that searched through every record of the table.
+In a join we have basically the same thing except that there
+are nested loops.  For example, to join two tables, the query
+template might look something like this:</p>
+
+<p>
+<ol>
+<li>Initialize the <b>azColumnName[]</b> array for the callback.</li>
+<li>Open two cursors, one to each of the two tables being queried.</li>
+<li>For each record in the first table, do:
+    <ol type="a">
+    <li>For each record in the second table do:
+      <ol type="i">
+      <li>If the WHERE clause evaluates to FALSE, then skip the steps that
+          follow and continue to the next record.</li>
+      <li>Compute all columns for the current row of the result.</li>
+      <li>Invoke the callback function for the current row of the result.</li>
+      </ol></li>
+    </ol>
+<li>Close both cursors.</li>
+</ol>
+</p>
+
+<p>This template will work, but it is likely to be slow since we
+are now dealing with an O(N<sup>2</sup>) loop.  But it often works
+out that the WHERE clause can be factored into terms and that one or
+more of those terms will involve only columns in the first table.
+When this happens, we can factor part of the WHERE clause test out of
+the inner loop and gain a lot of efficiency.  So a better template
+would be something like this:</p>
+
+<p>
+<ol>
+<li>Initialize the <b>azColumnName[]</b> array for the callback.</li>
+<li>Open two cursors, one to each of the two tables being queried.</li>
+<li>For each record in the first table, do:
+    <ol type="a">
+    <li>Evaluate terms of the WHERE clause that only involve columns from
+        the first table.  If any term is false (meaning that the whole
+        WHERE clause must be false) then skip the rest of this loop and
+        continue to the next record.</li>
+    <li>For each record in the second table do:
+      <ol type="i">
+      <li>If the WHERE clause evaluates to FALSE, then skip the steps that
+          follow and continue to the next record.</li>
+      <li>Compute all columns for the current row of the result.</li>
+      <li>Invoke the callback function for the current row of the result.</li>
+      </ol></li>
+    </ol>
+<li>Close both cursors.</li>
+</ol>
+</p>
+
+<p>Additional speed-up can occur if an index can be used to speed
+the search of either or the two loops.</p>
+
+<p>SQLite always constructs the loops in the same order as the
+tables appear in the FROM clause of the SELECT statement.  The
+left-most table becomes the outer loop and the right-most table
+becomes the inner loop.  It is possible, in theory, to reorder
+the loops in some circumstances to speed the evaluation of the
+join.  But SQLite does not attempt this optimization.</p>
+
+<p>You can see how SQLite constructs nested loops in the following
+example:</p>
+
+<blockquote><pre>
+CREATE TABLE examp2(three int, four int);
+SELECT * FROM examp, examp2 WHERE two<50 AND four==two;
+</pre></blockquote>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      examp.one                          
+1     ColumnName    1      0      examp.two                          
+2     ColumnName    2      0      examp2.three                       
+3     ColumnName    3      0      examp2.four                        
+4     Integer       0      0                                         
+5     OpenRead      0      3      examp                              
+6     VerifyCookie  0      909                                            
+7     Integer       0      0                                         
+8     OpenRead      1      5      examp2                             
+9     Rewind        0      24                                             
+10    Column        0      1                                         
+11    Integer       50     0      50                                 
+12    Ge            1      23                                             
+13    Rewind        1      23                                             
+14    Column        1      1                                         
+15    Column        0      1                                         
+16    Ne            1      22                                        
+17    Column        0      0                                         
+18    Column        0      1                                         
+19    Column        1      0                                         
+20    Column        1      1                                         
+21    Callback      4      0                                         
+22    Next          1      14                                             
+23    Next          0      10                                        
+24    Close         0      0                                         
+25    Close         1      0                                         
+26    Halt          0      0                                         
+}
+
+puts {
+<p>The outer loop over table examp is implement by instructions
+7 through 23.  The inner loop is instructions 13 through 22.
+Notice that the "two<50" term of the WHERE expression involves
+only columns from the first table and can be factored out of
+the inner loop.  SQLite does this and implements the "two<50"
+test in instructions 10 through 12.  The "four==two" test is
+implement by instructions 14 through 16 in the inner loop.</p>
+
+<p>SQLite does not impose any arbitrary limits on the tables in
+a join.  It also allows a table to be joined with itself.</p>
+
+<h2>The ORDER BY clause</h2>
+
+<p>For historical reasons, and for efficiency, all sorting is currently 
+done in memory.</p>
+
+<p>SQLite implements the ORDER BY clause using a special
+set of instructions to control an object called a sorter.  In the
+inner-most loop of the query, where there would normally be
+a Callback instruction, instead a record is constructed that
+contains both callback parameters and a key.  This record
+is added to the sorter (in a linked list).  After the query loop 
+finishes, the list of records is sorted and this list is walked.  For 
+each record on the list, the callback is invoked.  Finally, the sorter
+is closed and memory is deallocated.</p>
+
+<p>We can see the process in action in the following query:</p>
+
+<blockquote><pre>
+SELECT * FROM examp ORDER BY one DESC, two;
+</pre></blockquote>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      one                                
+1     ColumnName    1      0      two                                
+2     Integer       0      0                                         
+3     OpenRead      0      3      examp                              
+4     VerifyCookie  0      909                                            
+5     Rewind        0      14                                             
+6     Column        0      0                                         
+7     Column        0      1                                         
+8     SortMakeRec   2      0                                              
+9     Column        0      0                                         
+10    Column        0      1                                         
+11    SortMakeKey   2      0      D+                                 
+12    SortPut       0      0                                              
+13    Next          0      6                                              
+14    Close         0      0                                              
+15    Sort          0      0                                              
+16    SortNext      0      19                                             
+17    SortCallback  2      0                                              
+18    Goto          0      16                                             
+19    SortReset     0      0                                         
+20    Halt          0      0                                         
+}
+
+puts {
+<p>There is only one sorter object, so there are no instructions to open 
+or close it.  It is opened automatically when needed, and it is closed 
+when the VDBE program halts.</p>
+
+<p>The query loop is built from instructions 5 through 13.  Instructions
+6 through 8 build a record that contains the azData[] values for a single
+invocation of the callback.  A sort key is generated by instructions
+9 through 11.  Instruction 12 combines the invocation record and the
+sort key into a single entry and puts that entry on the sort list.<p>
+
+<p>The P3 argument of instruction 11 is of particular interest.  The
+sort key is formed by prepending one character from P3 to each string
+and concatenating all the strings.  The sort comparison function will
+look at this character to determine whether the sort order is
+ascending or descending, and whether to sort as a string or number.  
+In this example, the first column should be sorted as a string 
+in descending order so its prefix is "D" and the second column should 
+sorted numerically in ascending order so its prefix is "+".  Ascending 
+string sorting uses "A", and descending numeric sorting uses "-".</p>
+
+<p>After the query loop ends, the table being queried is closed at
+instruction 14.  This is done early in order to allow other processes
+or threads to access that table, if desired.  The list of records
+that was built up inside the query loop is sorted by the instruction
+at 15.  Instructions 16 through 18 walk through the record list
+(which is now in sorted order) and invoke the callback once for
+each record.  Finally, the sorter is closed at instruction 19.</p>
+
+<h2>Aggregate Functions And The GROUP BY and HAVING Clauses</h2>
+
+<p>To compute aggregate functions, the VDBE implements a special 
+data structure and instructions for controlling that data structure.
+The data structure is an unordered set of buckets, where each bucket
+has a key and one or more memory locations.  Within the query
+loop, the GROUP BY clause is used to construct a key and the bucket
+with that key is brought into focus.  A new bucket is created with
+the key if one did not previously exist.  Once the bucket is in
+focus, the memory locations of the bucket are used to accumulate
+the values of the various aggregate functions.  After the query
+loop terminates, each bucket is visited once to generate a
+single row of the results.</p>
+
+<p>An example will help to clarify this concept.  Consider the
+following query:</p>
+
+<blockquote><pre>
+SELECT three, min(three+four)+avg(four) 
+FROM examp2
+GROUP BY three;
+</pre></blockquote>
+
+
+<p>The VDBE code generated for this query is as follows:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      three                              
+1     ColumnName    1      0      min(three+four)+avg(four)          
+2     AggReset      0      3                                              
+3     AggInit       0      1      ptr(0x7903a0)                      
+4     AggInit       0      2      ptr(0x790700)                      
+5     Integer       0      0                                         
+6     OpenRead      0      5      examp2                             
+7     VerifyCookie  0      909                                            
+8     Rewind        0      23                                             
+9     Column        0      0                                         
+10    MakeKey       1      0      n                                  
+11    AggFocus      0      14                                             
+12    Column        0      0                                         
+13    AggSet        0      0                                         
+14    Column        0      0                                         
+15    Column        0      1                                         
+16    Add           0      0                                         
+17    Integer       1      0                                         
+18    AggFunc       0      1      ptr(0x7903a0)                      
+19    Column        0      1                                         
+20    Integer       2      0                                         
+21    AggFunc       0      1      ptr(0x790700)                      
+22    Next          0      9                                              
+23    Close         0      0                                              
+24    AggNext       0      31                                        
+25    AggGet        0      0                                              
+26    AggGet        0      1                                              
+27    AggGet        0      2                                         
+28    Add           0      0                                         
+29    Callback      2      0                                         
+30    Goto          0      24                                             
+31    Noop          0      0                                         
+32    Halt          0      0                                         
+}
+
+puts {
+<p>The first instruction of interest is the 
+<a href="opcode.html#AggReset">AggReset</a> at 2.
+The AggReset instruction initializes the set of buckets to be the
+empty set and specifies the number of memory slots available in each
+bucket as P2.  In this example, each bucket will hold 3 memory slots.
+It is not obvious, but if you look closely at the rest of the program
+you can figure out what each of these slots is intended for.</p>
+
+<blockquote><table border="2" cellpadding="5">
+<tr><th>Memory Slot</th><th>Intended Use Of This Memory Slot</th></tr>
+<tr><td>0</td><td>The "three" column -- the key to the bucket</td></tr>
+<tr><td>1</td><td>The minimum "three+four" value</td></tr>
+<tr><td>2</td><td>The sum of all "four" values. This is used to compute 
+   "avg(four)".</td></tr>
+</table></blockquote>
+
+<p>The query loop is implemented by instructions 8 through 22.
+The aggregate key specified by the GROUP BY clause is computed
+by instructions 9 and 10.  Instruction 11 causes the appropriate
+bucket to come into focus.  If a bucket with the given key does
+not already exists, a new bucket is created and control falls
+through to instructions 12 and 13 which initialize the bucket.
+If the bucket does already exist, then a jump is made to instruction
+14.  The values of aggregate functions are updated by the instructions
+between 11 and 21.  Instructions 14 through 18 update memory
+slot 1 to hold the next value "min(three+four)".  Then the sum of the 
+"four" column is updated by instructions 19 through 21.</p>
+
+<p>After the query loop is finished, the table "examp2" is closed at
+instruction 23 so that its lock will be released and it can be
+used by other threads or processes.  The next step is to loop
+over all aggregate buckets and output one row of the result for
+each bucket.  This is done by the loop at instructions 24
+through 30.  The AggNext instruction at 24 brings the next bucket
+into focus, or jumps to the end of the loop if all buckets have
+been examined already.  The 3 columns of the result are fetched from 
+the aggregator bucket in order at instructions 25 through 27.
+Finally, the callback is invoked at instruction 29.</p>
+
+<p>In summary then, any query with aggregate functions is implemented
+by two loops.  The first loop scans the input table and computes
+aggregate information into buckets and the second loop scans through
+all the buckets to compute the final result.</p>
+
+<p>The realization that an aggregate query is really two consequtive
+loops makes it much easier to understand the difference between
+a WHERE clause and a HAVING clause in SQL query statement.  The
+WHERE clause is a restriction on the first loop and the HAVING
+clause is a restriction on the second loop.  You can see this
+by adding both a WHERE and a HAVING clause to our example query:</p>
+
+
+<blockquote><pre>
+SELECT three, min(three+four)+avg(four) 
+FROM examp2
+WHERE three>four
+GROUP BY three
+HAVING avg(four)<10;
+</pre></blockquote>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     ColumnName    0      0      three                              
+1     ColumnName    1      0      min(three+four)+avg(four)          
+2     AggReset      0      3                                              
+3     AggInit       0      1      ptr(0x7903a0)                      
+4     AggInit       0      2      ptr(0x790700)                      
+5     Integer       0      0                                         
+6     OpenRead      0      5      examp2                             
+7     VerifyCookie  0      909                                            
+8     Rewind        0      26                                             
+9     Column        0      0                                         
+10    Column        0      1                                         
+11    Le            1      25                                             
+12    Column        0      0                                         
+13    MakeKey       1      0      n                                  
+14    AggFocus      0      17                                             
+15    Column        0      0                                         
+16    AggSet        0      0                                         
+17    Column        0      0                                         
+18    Column        0      1                                         
+19    Add           0      0                                         
+20    Integer       1      0                                         
+21    AggFunc       0      1      ptr(0x7903a0)                      
+22    Column        0      1                                         
+23    Integer       2      0                                         
+24    AggFunc       0      1      ptr(0x790700)                      
+25    Next          0      9                                              
+26    Close         0      0                                              
+27    AggNext       0      37                                             
+28    AggGet        0      2                                         
+29    Integer       10     0      10                                 
+30    Ge            1      27                                             
+31    AggGet        0      0                                         
+32    AggGet        0      1                                         
+33    AggGet        0      2                                         
+34    Add           0      0                                         
+35    Callback      2      0                                         
+36    Goto          0      27                                             
+37    Noop          0      0                                         
+38    Halt          0      0                                         
+}
+
+puts {
+<p>The code generated in this last example is the same as the
+previous except for the addition of two conditional jumps used
+to implement the extra WHERE and HAVING clauses.  The WHERE
+clause is implemented by instructions 9 through 11 in the query
+loop.  The HAVING clause is implemented by instruction 28 through
+30 in the output loop.</p>
+
+<h2>Using SELECT Statements As Terms In An Expression</h2>
+
+<p>The very name "Structured Query Language" tells us that SQL should
+support nested queries.  And, in fact, two different kinds of nesting
+are supported.  Any SELECT statement that returns a single-row, single-column
+result can be used as a term in an expression of another SELECT statement.
+And, a SELECT statement that returns a single-column, multi-row result
+can be used as the right-hand operand of the IN and NOT IN operators.
+We will begin this section with an example of the first kind of nesting,
+where a single-row, single-column SELECT is used as a term in an expression
+of another SELECT.  Here is our example:</p>
+
+<blockquote><pre>
+SELECT * FROM examp
+WHERE two!=(SELECT three FROM examp2
+            WHERE four=5);
+</pre></blockquote>
+
+<p>The way SQLite deals with this is to first run the inner SELECT
+(the one against examp2) and store its result in a private memory
+cell.  SQLite then substitutes the value of this private memory
+cell for the inner SELECT when it evaluates the outer SELECT.
+The code looks like this:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     String        0      0                                         
+1     MemStore      0      1                                         
+2     Integer       0      0                                         
+3     OpenRead      1      5      examp2                             
+4     VerifyCookie  0      909                                            
+5     Rewind        1      13                                             
+6     Column        1      1                                         
+7     Integer       5      0      5                                  
+8     Ne            1      12                                        
+9     Column        1      0                                         
+10    MemStore      0      1                                         
+11    Goto          0      13                                             
+12    Next          1      6                                              
+13    Close         1      0                                         
+14    ColumnName    0      0      one                                
+15    ColumnName    1      0      two                                
+16    Integer       0      0                                         
+17    OpenRead      0      3      examp                              
+18    Rewind        0      26                                             
+19    Column        0      1                                         
+20    MemLoad       0      0                                         
+21    Eq            1      25                                             
+22    Column        0      0                                         
+23    Column        0      1                                         
+24    Callback      2      0                                         
+25    Next          0      19                                             
+26    Close         0      0                                         
+27    Halt          0      0                                         
+}
+
+puts {
+<p>The private memory cell is initialized to NULL by the first
+two instructions.  Instructions 2 through 13 implement the inner
+SELECT statement against the examp2 table.  Notice that instead of
+sending the result to a callback or storing the result on a sorter,
+the result of the query is pushed into the memory cell by instruction
+10 and the loop is abandoned by the jump at instruction 11.  
+The jump at instruction at 11 is vestigial and never executes.</p>
+
+<p>The outer SELECT is implemented by instructions 14 through 25.
+In particular, the WHERE clause that contains the nested select
+is implemented by instructions 19 through 21.  You can see that
+the result of the inner select is loaded onto the stack by instruction
+20 and used by the conditional jump at 21.</p>
+
+<p>When the result of a sub-select is a scalar, a single private memory
+cell can be used, as shown in the previous
+example.  But when the result of a sub-select is a vector, such
+as when the sub-select is the right-hand operand of IN or NOT IN,
+a different approach is needed.  In this case, 
+the result of the sub-select is
+stored in a transient table and the contents of that table
+are tested using the Found or NotFound operators.  Consider this
+example:</p>
+
+<blockquote><pre>
+SELECT * FROM examp
+WHERE two IN (SELECT three FROM examp2);
+</pre></blockquote>
+
+<p>The code generated to implement this last query is as follows:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     OpenTemp      1      1                                         
+1     Integer       0      0                                         
+2     OpenRead      2      5      examp2                             
+3     VerifyCookie  0      909                                            
+4     Rewind        2      10                                        
+5     Column        2      0                                         
+6     IsNull        -1     9                                              
+7     String        0      0                                         
+8     PutStrKey     1      0                                         
+9     Next          2      5                                              
+10    Close         2      0                                         
+11    ColumnName    0      0      one                                
+12    ColumnName    1      0      two                                
+13    Integer       0      0                                         
+14    OpenRead      0      3      examp                              
+15    Rewind        0      25                                             
+16    Column        0      1                                         
+17    NotNull       -1     20                                        
+18    Pop           1      0                                         
+19    Goto          0      24                                             
+20    NotFound      1      24                                             
+21    Column        0      0                                         
+22    Column        0      1                                         
+23    Callback      2      0                                         
+24    Next          0      16                                             
+25    Close         0      0                                         
+26    Halt          0      0                                         
+}
+
+puts {
+<p>The transient table in which the results of the inner SELECT are
+stored is created by the <a href="opcode.html#OpenTemp">OpenTemp</a> 
+instruction at 0.  This opcode is used for tables that exist for the 
+duration of a single SQL statement only.  The transient cursor is always 
+opened read/write even if the main database is read-only.  The transient 
+table is deleted automatically when the cursor is closed.  The P2 value 
+of 1 means the cursor points to a BTree index, which has no data but can 
+have an arbitrary key.</p>
+
+<p>The inner SELECT statement is implemented by instructions 1 through 10.
+All this code does is make an entry in the temporary table for each
+row of the examp2 table with a non-NULL value for the "three" column.  
+The key for each temporary table entry is the "three" column of examp2 
+and the data is an empty string since it is never used.</p>
+
+<p>The outer SELECT is implemented by instructions 11 through 25.  In
+particular, the WHERE clause containing the IN operator is implemented
+by instructions at 16, 17, and 20.  Instruction 16 pushes the value of
+the "two" column for the current row onto the stack and instruction 17
+checks to see that it is non-NULL.  If this is successful, execution 
+jumps to 20, where it tests to see if top of the stack matches any key 
+in the temporary table.  The rest of the code is the same as what has 
+been shown before.</p>
+
+<h2>Compound SELECT Statements</h2>
+
+<p>SQLite also allows two or more SELECT statements to be joined as
+peers using operators UNION, UNION ALL, INTERSECT, and EXCEPT.  These
+compound select statements are implemented using transient tables.
+The implementation is slightly different for each operator, but the
+basic ideas are the same.  For an example we will use the EXCEPT
+operator.</p>
+
+<blockquote><pre>
+SELECT two FROM examp
+EXCEPT
+SELECT four FROM examp2;
+</pre></blockquote>
+
+<p>The result of this last example should be every unique value
+of the "two" column in the examp table, except any value that is
+in the "four" column of examp2 is removed.  The code to implement
+this query is as follows:</p>
+}
+
+Code {
+addr  opcode        p1     p2     p3                                      
+----  ------------  -----  -----  -----------------------------------
+0     OpenTemp      0      1                                         
+1     KeyAsData     0      1                                              
+2     Integer       0      0                                         
+3     OpenRead      1      3      examp                              
+4     VerifyCookie  0      909                                            
+5     Rewind        1      11                                        
+6     Column        1      1                                         
+7     MakeRecord    1      0                                         
+8     String        0      0                                         
+9     PutStrKey     0      0                                         
+10    Next          1      6                                              
+11    Close         1      0                                         
+12    Integer       0      0                                         
+13    OpenRead      2      5      examp2                             
+14    Rewind        2      20                                        
+15    Column        2      1                                         
+16    MakeRecord    1      0                                         
+17    NotFound      0      19                                             
+18    Delete        0      0                                         
+19    Next          2      15                                             
+20    Close         2      0                                         
+21    ColumnName    0      0      four                               
+22    Rewind        0      26                                             
+23    Column        0      0                                         
+24    Callback      1      0                                         
+25    Next          0      23                                             
+26    Close         0      0                                         
+27    Halt          0      0                                         
+}
+
+puts {
+<p>The transient table in which the result is built is created by
+instruction 0.  Three loops then follow.  The loop at instructions
+5 through 10 implements the first SELECT statement.  The second
+SELECT statement is implemented by the loop at instructions 14 through
+19.  Finally, a loop at instructions 22 through 25 reads the transient
+table and invokes the callback once for each row in the result.</p>
+
+<p>Instruction 1 is of particular importance in this example.  Normally,
+the Column instruction extracts the value of a column from a larger
+record in the data of an SQLite file entry.  Instruction 1 sets a flag on
+the transient table so that Column will instead treat the key of the
+SQLite file entry as if it were data and extract column information from
+the key.</p>
+
+<p>Here is what is going to happen:  The first SELECT statement
+will construct rows of the result and save each row as the key of
+an entry in the transient table.  The data for each entry in the
+transient table is a never used so we fill it in with an empty string.
+The second SELECT statement also constructs rows, but the rows
+constructed by the second SELECT are removed from the transient table.
+That is why we want the rows to be stored in the key of the SQLite file
+instead of in the data -- so they can be easily located and deleted.</p>
+
+<p>Let's look more closely at what is happening here.  The first
+SELECT is implemented by the loop at instructions 5 through 10.
+Instruction 5 intializes the loop by rewinding its cursor.
+Instruction 6 extracts the value of the "two" column from "examp"
+and instruction 7 converts this into a row.  Instruction 8 pushes
+an empty string onto the stack.  Finally, instruction 9 writes the
+row into the temporary table.  But remember, the PutStrKey opcode uses
+the top of the stack as the record data and the next on stack as the
+key.  For an INSERT statement, the row generated by the
+MakeRecord opcode is the record data and the record key is an integer
+created by the NewRecno opcode.  But here the roles are reversed and
+the row created by MakeRecord is the record key and the record data is
+just an empty string.</p>
+
+<p>The second SELECT is implemented by instructions 14 through 19.
+Instruction 14 intializes the loop by rewinding its cursor.
+A new result row is created from the "four" column of table "examp2"
+by instructions 15 and 16.  But instead of using PutStrKey to write this
+new row into the temporary table, we instead call Delete to remove
+it from the temporary table if it exists.</p>
+
+<p>The result of the compound select is sent to the callback routine
+by the loop at instructions 22 through 25.  There is nothing new
+or remarkable about this loop, except for the fact that the Column 
+instruction at 23 will be extracting a column out of the record key
+rather than the record data.</p>
+
+<h2>Summary</h2>
+
+<p>This article has reviewed all of the major techniques used by
+SQLite's VDBE to implement SQL statements.  What has not been shown
+is that most of these techniques can be used in combination to
+generate code for an appropriately complex query statement.  For
+example, we have shown how sorting is accomplished on a simple query
+and we have shown how to implement a compound query.  But we did
+not give an example of sorting in a compound query.  This is because
+sorting a compound query does not introduce any new concepts: it
+merely combines two previous ideas (sorting and compounding)
+in the same VDBE program.</p>
+
+<p>For additional information on how the SQLite library
+functions, the reader is directed to look at the SQLite source
+code directly.  If you understand the material in this article,
+you should not have much difficulty in following the sources.
+Serious students of the internals of SQLite will probably
+also what to make a careful study of the VDBE opcodes
+as documented <a href="opcode.html">here</a>.  Most of the
+opcode documentation is extracted from comments in the source
+code using a script so you can also get information about the
+various opcodes directly from the <b>vdbe.c</b> source file.
+If you have successfully read this far, you should have little
+difficulty understanding the rest.</p>
+
+<p>If you find errors in either the documentation or the code,
+feel free to fix them and/or contact the author at
+<a href="mailto:drh@hwaci.com">drh@hwaci.com</a>.  Your bug fixes or
+suggestions are always welcomed.</p>
+}
+footer $rcsid
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/version3.tcl b/client/src/thirdparty/sqlite-3.4.2/www/version3.tcl
new file mode 100644
index 0000000..70e500d
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/version3.tcl
@@ -0,0 +1,293 @@
+#!/usr/bin/tclsh
+source common.tcl
+header {SQLite Version 3 Overview}
+puts {
+<h2>SQLite Version 3 Overview</h2>
+
+<p>
+SQLite version 3.0 introduces important changes to the library, including:
+</p>
+
+<ul>
+<li>A more compact format for database files.</li>
+<li>Manifest typing and BLOB support.</li>
+<li>Support for both UTF-8 and UTF-16 text.</li>
+<li>User-defined text collating sequences.</li>
+<li>64-bit ROWIDs.</li>
+<li>Improved Concurrency.</li>
+</ul>
+
+<p>
+This document is a quick introduction to the changes for SQLite 3.0
+for users who are already familiar with SQLite version 2.8.
+</p>
+
+<h3>Naming Changes</h3>
+
+<p>
+SQLite version 2.8 will continue to be supported with bug fixes
+for the foreseeable future.  In order to allow SQLite version 2.8
+and SQLite version 3.0 to peacefully coexist, the names of key files
+and APIs in SQLite version 3.0 have been changed to include the
+character "3".  For example, the include file used by C programs
+has been changed from "sqlite.h" to "sqlite3.h".  And the name of
+the shell program used to interact with databases has been changed
+from "sqlite.exe" to "sqlite3.exe".  With these changes, it is possible
+to have both SQLite 2.8 and SQLite 3.0 installed on the same system at
+the same time.  And it is possible for the same C program to link
+against both SQLite 2.8 and SQLite 3.0 at the same time and to use
+both libraries at the same time.
+</p>
+
+<h3>New File Format</h3>
+
+<p>
+The format used by SQLite database files has been completely revised.
+The old version 2.1 format and the new 3.0 format are incompatible with
+one another.  Version 2.8 of SQLite will not read a version 3.0 database
+files and version 3.0 of SQLite will not read a version 2.8 database file.
+</p>
+
+<p>
+To convert an SQLite 2.8 database into an SQLite 3.0 database, have
+ready the command-line shells for both version 2.8 and 3.0.  Then
+enter a command like the following:
+</p>
+
+<blockquote><pre>
+sqlite OLD.DB .dump | sqlite3 NEW.DB
+</pre></blockquote>
+
+<p>
+The new database file format uses B+trees for tables.  In a B+tree, all
+data is stored in the leaves of the tree instead of in both the leaves and
+the intermediate branch nodes.  The use of B+trees for tables allows for
+better scalability and the storage of larger data fields without the use of
+overflow pages.  Traditional B-trees are still used for indices.</p>
+
+<p>
+The new file format also supports variable pages sizes between 512 and
+32768 bytes.  The size of a page is stored in the file header so the
+same library can read databases with different pages sizes, in theory,
+though this feature has not yet been implemented in practice.
+</p>
+
+<p>
+The new file format omits unused fields from its disk images.  For example,
+indices use only the key part of a B-tree record and not the data.  So
+for indices, the field that records the length of the data is omitted.
+Integer values such as the length of key and data are stored using
+a variable-length encoding so that only one or two bytes are required to
+store the most common cases but up to 64-bits of information can be encoded
+if needed. 
+Integer and floating point data is stored on the disk in binary rather
+than being converted into ASCII as in SQLite version 2.8.
+These changes taken together result in database files that are typically
+25% to 35% smaller than the equivalent files in SQLite version 2.8.
+</p>
+
+<p>
+Details of the low-level B-tree format used in SQLite version 3.0 can
+be found in header comments to the 
+<a href="http://www.sqlite.org/cvstrac/getfile/sqlite/src/btree.c">btree.c</a>
+source file.
+</p>
+
+<h3>Manifest Typing and BLOB Support</h3>
+
+<p>
+SQLite version 2.8 will deal with data in various formats internally,
+but when writing to the disk or interacting through its API, SQLite 2.8
+always converts data into ASCII text.  SQLite 3.0, in contrast, exposes 
+its internal data representations to the user and stores binary representations
+to disk when appropriate.  The exposing of non-ASCII representations was
+added in order to support BLOBs.
+</p>
+
+<p>
+SQLite version 2.8 had the feature that any type of data could be stored
+in any table column regardless of the declared type of that column.  This
+feature is retained in version 3.0, though in a slightly modified form.
+Each table column will store any type of data, though columns have an
+affinity for the format of data defined by their declared datatype.
+When data is inserted into a column, that column will make at attempt
+to convert the data format into the columns declared type.   All SQL
+database engines do this.  The difference is that SQLite 3.0 will 
+still store the data even if a format conversion is not possible.
+</p>
+
+<p>
+For example, if you have a table column declared to be of type "INTEGER"
+and you try to insert a string, the column will look at the text string
+and see if it looks like a number.  If the string does look like a number
+it is converted into a number and into an integer if the number does not
+have a fractional part, and stored that way.  But if the string is not
+a well-formed number it is still stored as a string.  A column with a
+type of "TEXT" tries to convert numbers into an ASCII-Text representation
+before storing them.  But BLOBs are stored in TEXT columns as BLOBs because
+you cannot in general convert a BLOB into text.
+</p>
+
+<p>
+In most other SQL database engines the datatype is associated with
+the table column that holds the data - with the data container.
+In SQLite 3.0, the datatype is associated with the data itself, not
+with its container.
+<a href="http://www.paulgraham.com/">Paul Graham</a> in his book 
+<a href="http://www.paulgraham.com/acl.html"><i>ANSI Common Lisp</i></a>
+calls this property "Manifest Typing".
+Other writers have other definitions for the term "manifest typing",
+so beware of confusion.  But by whatever name, that is the datatype
+model supported by SQLite 3.0.
+</p>
+
+<p>
+Additional information about datatypes in SQLite version 3.0 is
+available
+<a href="datatype3.html">separately</a>.
+</p>
+
+<h3>Support for UTF-8 and UTF-16</h3>
+
+<p>
+The new API for SQLite 3.0 contains routines that accept text as
+both UTF-8 and UTF-16 in the native byte order of the host machine.
+Each database file manages text as either UTF-8, UTF-16BE (big-endian),
+or UTF-16LE (little-endian).  Internally and in the disk file, the
+same text representation is used everywhere.  If the text representation
+specified by the database file (in the file header) does not match
+the text representation required by the interface routines, then text
+is converted on-the-fly.
+Constantly converting text from one representation to another can be
+computationally expensive, so it is suggested that programmers choose a
+single representation and stick with it throughout their application.
+</p>
+
+<p>
+In the current implementation of SQLite, the SQL parser only works
+with UTF-8 text.  So if you supply UTF-16 text it will be converted.
+This is just an implementation issue and there is nothing to prevent
+future versions of SQLite from parsing UTF-16 encoded SQL natively.
+</p>
+
+<p>
+When creating new user-defined SQL functions and collating sequences,
+each function or collating sequence can specify it if works with
+UTF-8, UTF-16be, or UTF-16le.  Separate implementations can be registered
+for each encoding.   If an SQL function or collating sequences is required
+but a version for the current text encoding is not available, then 
+the text is automatically converted.  As before, this conversion takes
+computation time, so programmers are advised to pick a single
+encoding and stick with it in order to minimize the amount of unnecessary
+format juggling.
+</p>
+
+<p>
+SQLite is not particular about the text it receives and is more than
+happy to process text strings that are not normalized or even
+well-formed UTF-8 or UTF-16.  Thus, programmers who want to store
+IS08859 data can do so using the UTF-8 interfaces.  As long as no
+attempts are made to use a UTF-16 collating sequence or SQL function,
+the byte sequence of the text will not be modified in any way.
+</p>
+
+<h3>User-defined Collating Sequences</h3>
+
+<p>
+A collating sequence is just a defined order for text.  When SQLite 3.0
+sorts (or uses a comparison operator like "<" or ">=") the sort order
+is first determined by the data type.
+</p>
+
+<ul>
+<li>NULLs sort first</li>
+<li>Numeric values sort next in numerical order</li>
+<li>Text values come after numerics</li>
+<li>BLOBs sort last</li>
+</ul>
+
+<p>
+Collating sequences are used for comparing two text strings.
+The collating sequence does not change the ordering of NULLs, numbers,
+or BLOBs, only text.
+</p>
+
+<p>
+A collating sequence is implemented as a function that takes the
+two strings being compared as inputs and returns negative, zero, or
+positive if the first string is less than, equal to, or greater than
+the second.
+SQLite 3.0 comes with a single built-in collating sequence named "BINARY"
+which is implemented using the memcmp() routine from the standard C library.
+The BINARY collating sequence works well for English text.  For other
+languages or locales, alternative collating sequences may be preferred.
+</p>
+
+<p>
+The decision of which collating sequence to use is controlled by the
+COLLATE clause in SQL.  A COLLATE clause can occur on a table definition,
+to define a default collating sequence to a table column, or on field
+of an index, or in the ORDER BY clause of a SELECT statement.
+Planned enhancements to SQLite are to include standard CAST() syntax
+to allow the collating sequence of an expression to be defined.
+</p>
+
+<h3>64-bit ROWIDs</h3>
+
+<p>
+Every row of a table has a unique rowid.
+If the table defines a column with the type "INTEGER PRIMARY KEY" then that
+column becomes an alias for the rowid.  But with or without an INTEGER PRIMARY
+KEY column, every row still has a rowid.
+</p>
+
+<p>
+In SQLite version 3.0, the rowid is a 64-bit signed integer.
+This is an expansion of SQLite version 2.8 which only permitted
+rowids of 32-bits.
+</p>
+
+<p>
+To minimize storage space, the 64-bit rowid is stored as a variable length
+integer.  Rowids between 0 and 127 use only a single byte.  
+Rowids between 0 and 16383 use just 2 bytes.  Up to 2097152 uses three
+bytes.  And so forth.  Negative rowids are allowed but they always use
+nine bytes of storage and so their use is discouraged.  When rowids
+are generated automatically by SQLite, they will always be non-negative.
+</p>
+
+<h3>Improved Concurrency</h3>
+
+<p>
+SQLite version 2.8 allowed multiple simultaneous readers or a single
+writer but not both.  SQLite version 3.0 allows one process to begin
+writing the database while other processes continue to read.  The
+writer must still obtain an exclusive lock on the database for a brief
+interval in order to commit its changes, but the exclusive lock is no
+longer required for the entire write operation.
+A <a href="lockingv3.html">more detailed report</a> on the locking
+behavior of SQLite version 3.0 is available separately.
+</p>
+
+<p>
+A limited form of table-level locking is now also available in SQLite.
+If each table is stored in a separate database file, those separate
+files can be attached to the main database (using the ATTACH command)
+and the combined databases will function as one.  But locks will only
+be acquired on individual files as needed.  So if you redefine "database"
+to mean two or more database files, then it is entirely possible for
+two processes to be writing to the same database at the same time.
+To further support this capability, commits of transactions involving
+two or more ATTACHed database are now atomic.
+</p>
+
+<h3>Credits</h3>
+
+<p>
+SQLite version 3.0 is made possible in part by AOL developers
+supporting and embracing great Open-Source Software.
+</p>
+
+
+}
+footer {$Id: version3.tcl,v 1.6 2006/03/03 21:39:54 drh Exp $}
diff --git a/client/src/thirdparty/sqlite-3.4.2/www/whentouse.tcl b/client/src/thirdparty/sqlite-3.4.2/www/whentouse.tcl
new file mode 100644
index 0000000..bb4378b
--- /dev/null
+++ b/client/src/thirdparty/sqlite-3.4.2/www/whentouse.tcl
@@ -0,0 +1,254 @@
+#
+# Run this TCL script to generate HTML for the goals.html file.
+#
+set rcsid {$Id: whentouse.tcl,v 1.7 2007/04/14 12:04:39 drh Exp $}
+source common.tcl
+header {Appropriate Uses For SQLite}
+
+puts {
+<p>
+SQLite is different from most other SQL database engines in that its
+primary design goal is to be simple:
+</p>
+
+<ul>
+<li>Simple to administer</li>
+<li>Simple to operate</li>
+<li>Simple to embed in a larger program</li>
+<li>Simple to maintain and customize</li>
+</ul>
+
+<p>
+Many people like SQLite because it is small and fast.  But those
+qualities are just happy accidents.
+Users also find that SQLite is very reliable.  Reliability is
+a consequence of simplicity.  With less complication, there is
+less to go wrong.  So, yes, SQLite is small, fast, and reliable,
+but first and foremost, SQLite strives to be simple.
+</p>
+
+<p>
+Simplicity in a database engine can be either a strength or a
+weakness, depending on what you are trying to do.  In order to
+achieve simplicity, SQLite has had to sacrifice other characteristics
+that some people find useful, such as high concurrency, fine-grained
+access control, a rich set of built-in functions, stored procedures,
+esoteric SQL language features, XML and/or Java extensions,
+tera- or peta-byte scalability, and so forth.  If you need some of these
+features and do not mind the added complexity that they
+bring, then SQLite is probably not the database for you.
+SQLite is not intended to be an enterprise database engine.  It
+not designed to compete with Oracle or PostgreSQL.
+</p>
+
+<p>
+The basic rule of thumb for when it is appropriate to use SQLite is
+this:  Use SQLite in situations where simplicity of administration,
+implementation, and maintenance are more important than the countless
+complex features that enterprise database engines provide.
+As it turns out, situations where simplicity is the better choice
+are more common than many people realize.
+</p>
+
+<h2>Situations Where SQLite Works Well</h2>
+
+<ul>
+<li><p><b>Websites</b></p>
+
+<p>SQLite usually will work great as the database engine for low to
+medium traffic websites (which is to say, 99.9% of all websites).
+The amount of web traffic that SQLite can handle depends, of course,
+on how heavily the website uses its database.  Generally
+speaking, any site that gets fewer than a 100000 hits/day should work
+fine with SQLite.
+The 100000 hits/day figure is a conservative estimate, not a
+hard upper bound.
+SQLite has been demonstrated to work with 10 times that amount
+of traffic.</p>
+</li>
+
+<li><p><b>Embedded devices and applications</b></p>
+
+<p>Because an SQLite database requires little or no administration,
+SQLite is a good choice for devices or services that must work
+unattended and without human support.  SQLite is a good fit for
+use in cellphones, PDAs, set-top boxes, and/or appliances.  It also
+works well as an embedded database in downloadable consumer applications.
+</p>
+</li>
+
+<li><p><b>Application File Format</b></p>
+
+<p>
+SQLite has been used with great success as the on-disk file format
+for desktop applications such as financial analysis tools, CAD
+packages, record keeping programs, and so forth.  The traditional
+File/Open operation does an sqlite3_open() and executes a
+BEGIN TRANSACTION to get exclusive access to the content.  File/Save
+does a COMMIT followed by another BEGIN TRANSACTION.  The use
+of transactions guarantees that updates to the application file are atomic,
+durable, isolated, and consistent.
+</p>
+
+<p>
+Temporary triggers can be added to the database to record all
+changes into a (temporary) undo/redo log table.  These changes can then
+be played back when the user presses the Undo and Redo buttons.  Using
+this technique, a unlimited depth undo/redo implementation can be written
+in surprising little code.
+</p>
+</li>
+
+<li><p><b>Replacement for <i>ad hoc</i> disk files</b></p>
+
+<p>Many programs use fopen(), fread(), and fwrite() to create and
+manage files of data in home-grown formats.  SQLite works 
+particularly well as a
+replacement for these <i>ad hoc</i> data files.</p>
+</li>
+
+<li><p><b>Internal or temporary databases</b></p>
+
+<p>
+For programs that have a lot of data that must be sifted and sorted
+in diverse ways, it is often easier and quicker to load the data into
+an in-memory SQLite database and use queries with joins and ORDER BY
+clauses to extract the data in the form and order needed rather than
+to try to code the same operations manually.
+Using an SQL database internally in this way also gives the program
+greater flexibility since new columns and indices can be added without
+having to recode every query.
+</p>
+</li>
+
+<li><p><b>Command-line dataset analysis tool</b></p>
+
+<p>
+Experienced SQL users can employ
+the command-line <b>sqlite</b> program to analyze miscellaneous
+datasets. Raw data can be imported from CSV files, then that
+data can be sliced and diced to generate a myriad of summary
+reports.  Possible uses include website log analysis, sports
+statistics analysis, compilation of programming metrics, and
+analysis of experimental results.
+</p>
+
+<p>
+You can also do the same thing with a enterprise client/server
+database, of course.  The advantages to using SQLite in this situation
+are that SQLite is much easier to set up and the resulting database 
+is a single file that you can store on a floppy disk or flash-memory stick
+or email to a colleague.
+</p>
+</li>
+
+<li><p><b>Stand-in for an enterprise database during demos or testing</b></p>
+
+<p>
+If you are writing a client application for an enterprise database engine,
+it makes sense to use a generic database backend that allows you to connect
+to many different kinds of SQL database engines.  It makes even better
+sense to
+go ahead and include SQLite in the mix of supported database and to statically
+link the SQLite engine in with the client.  That way the client program
+can be used standalone with an SQLite data file for testing or for
+demonstrations.
+</p>
+</li>
+
+<li><p><b>Database Pedagogy</b></p>
+
+<p>
+Because it is simple to setup and use (installation is trivial: just
+copy the <b>sqlite</b> or <b>sqlite.exe</b> executable to the target machine
+and run it) SQLite makes a good database engine for use in teaching SQL.
+Students can easily create as many databases as they like and can
+email databases to the instructor for comments or grading.  For more
+advanced students who are interested in studying how an RDBMS is
+implemented, the modular and well-commented and documented SQLite code
+can serve as a good basis.  This is not to say that SQLite is an accurate
+model of how other database engines are implemented, but rather a student who
+understands how SQLite works can more quickly comprehend the operational
+principles of other systems.
+</p>
+</li>
+
+<li><p><b>Experimental SQL language extensions</b></p>
+
+<p>The simple, modular design of SQLite makes it a good platform for
+prototyping new, experimental database language features or ideas.
+</p>
+</li>
+
+
+</ul>
+
+<h2>Situations Where Another RDBMS May Work Better</h2>
+
+<ul>
+<li><p><b>Client/Server Applications</b><p>
+
+<p>If you have many client programs accessing a common database
+over a network, you should consider using a client/server database
+engine instead of SQLite.  SQLite will work over a network filesystem,
+but because of the latency associated with most network filesystems,
+performance will not be great.  Also, the file locking logic of
+many network filesystems implementation contains bugs (on both Unix
+and windows).  If file locking does not work like it should,
+it might be possible for two or more client programs to modify the
+same part of the same database at the same time, resulting in 
+database corruption.  Because this problem results from bugs in
+the underlying filesystem implementation, there is nothing SQLite
+can do to prevent it.</p>
+
+<p>A good rule of thumb is that you should avoid using SQLite
+in situations where the same database will be accessed simultaneously
+from many computers over a network filesystem.</p>
+</li>
+
+<li><p><b>High-volume Websites</b></p>
+
+<p>SQLite will normally work fine as the database backend to a website.
+But if you website is so busy that your are thinking of splitting the
+database component off onto a separate machine, then you should 
+definitely consider using an enterprise-class client/server database
+engine instead of SQLite.</p>
+</li>
+
+<li><p><b>Very large datasets</b></p>
+
+<p>When you start a transaction in SQLite (which happens automatically
+before any write operation that is not within an explicit BEGIN...COMMIT)
+the engine has to allocate a bitmap of dirty pages in the disk file to
+help it manage its rollback journal.  SQLite needs 256 bytes of RAM for
+every 1MiB of database (assuming a 1024-byte page size: less memory is
+used with larger page sizes, of course).  
+For smaller databases, the amount of memory
+required is not a problem, but when database begin to grow into the
+multi-gigabyte range, the size of the bitmap can get quite large.  If
+you need to store and modify more than a few dozen GB of data, you should
+consider using a different database engine.
+</p>
+</li>
+
+<li><p><b>High Concurrency</b></p>
+
+<p>
+SQLite uses reader/writer locks on the entire database file.  That means
+if any process is reading from any part of the database, all other
+processes are prevented from writing any other part of the database.
+Similarly, if any one process is writing to the database,
+all other processes are prevented from reading any other part of the
+database.
+For many situations, this is not a problem.  Each application
+does its database work quickly and moves on, and no lock lasts for more
+than a few dozen milliseconds.  But there are some applications that require
+more concurrency, and those applications may need to seek a different
+solution.
+</p>
+</li>
+
+</ul>
+
+}
+footer $rcsid
diff --git a/shared/util.c b/shared/util.c
index d313d1d..91d1cb9 100644
--- a/shared/util.c
+++ b/shared/util.c
@@ -18,6 +18,8 @@
  */
 
 
+#include "array.h"
+
 #include "util.h"
 
 
@@ -101,3 +103,40 @@ void utilDie(const char *why, ...) {
 	logWrite("DIE:  %s", msg);
 	exit(1);
 }
+
+
+char **utilWrapText(char *text, uint16_t width) {
+	char    **lines  = NULL;
+	char     *head   = text;
+	char     *buffer = NULL;
+	int32_t   bufferPos;
+	int32_t   pos;
+	int32_t   lastSpace;
+	int32_t   isLf;
+
+	buffer = (char *)malloc(width + 2);
+	if (buffer) {
+		pos = lastSpace = bufferPos = 0;
+		while (head[pos] != 0) {
+			isLf = (head[pos] == '\n');
+			if (isLf || pos == width) {
+				if (isLf || lastSpace == 0) lastSpace = pos; // just cut it
+				while (*head!=0 && lastSpace-- > 0) {
+					buffer[bufferPos++] = *head++;
+					buffer[bufferPos]   = 0;
+				}
+				arrput(lines, strdup(buffer));
+				if (isLf) head++; // jump the line feed
+				while (*head!=0 && *head==' ') head++; // clear the leading space
+				lastSpace = pos = bufferPos = 0;
+			} else {
+				if (head[pos] == ' ') lastSpace = pos;
+				pos++;
+			}
+		}
+		arrput(lines, strdup(head));
+		free(buffer);
+	}
+
+	return lines;
+}
diff --git a/shared/util.h b/shared/util.h
index e302373..24eeff1 100644
--- a/shared/util.h
+++ b/shared/util.h
@@ -25,11 +25,12 @@
 #include "os.h"
 
 
-char *utilAppNameWithNewExtensionGet(char *appName, char *extension);
-void  utilBitsPrint(uint8_t byte);
-char *utilCreateString(char *format, ...);
-char *utilCreateStringVArgs(char *format, va_list args);
-void  utilDie(const char *why, ...);
+char  *utilAppNameWithNewExtensionGet(char *appName, char *extension);
+void   utilBitsPrint(uint8_t byte);
+char  *utilCreateString(char *format, ...);
+char  *utilCreateStringVArgs(char *format, va_list args);
+void   utilDie(const char *why, ...);
+char **utilWrapText(char *text, uint16_t width);
 
 
 #endif // UTIL_H