npm - better-sqlite3-multiple-ciphers - Versions diffs - 11.0.0-beta.0 → 11.1.1 - Mend

better-sqlite3-multiple-ciphers 11.0.0-beta.0 → 11.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +4 -4
package/deps/setup.ps1 +1 -1
package/deps/sqlite3/sqlite3.c +668 -488
package/deps/sqlite3/sqlite3.h +4 -3
package/package.json +1 -1
package/src/better_sqlite3.cpp +29 -29
package/src/better_sqlite3.hpp +75 -77

package/deps/sqlite3/sqlite3.c CHANGED Viewed

@@ -51,8 +51,15 @@
 #define SQLITE_EXTRA_INIT sqlite3mc_initialize
 #define SQLITE_EXTRA_SHUTDOWN sqlite3mc_shutdown
-int sqlite3mc_initialize(const char* arg);
-void sqlite3mc_shutdown(void);
+/*
+** Declare all internal functions as 'static' unless told otherwise
+*/
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE static
+#endif
+SQLITE_PRIVATE int sqlite3mc_initialize(const char* arg);
+SQLITE_PRIVATE void sqlite3mc_shutdown(void);
 /*
 ** To enable the extension functions define SQLITE_ENABLE_EXTFUNC on compiling this module
@@ -113,13 +120,13 @@ void sqlite3mc_shutdown(void);
 #include <windows.h>
 /* SQLite functions only needed on Win32 */
-extern SQLITE_API void sqlite3_win32_write_debug(const char*, int);
-extern SQLITE_API char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
-extern SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char*);
-extern SQLITE_API char *sqlite3_win32_mbcs_to_utf8_v2(const char*, int);
-extern SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char*);
-extern SQLITE_API char *sqlite3_win32_utf8_to_mbcs_v2(const char*, int);
-extern SQLITE_API LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
+SQLITE_API void sqlite3_win32_write_debug(const char*, int);
+SQLITE_API char *sqlite3_win32_unicode_to_utf8(LPCWSTR);
+SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char*);
+SQLITE_API char *sqlite3_win32_mbcs_to_utf8_v2(const char*, int);
+SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char*);
+SQLITE_API char *sqlite3_win32_utf8_to_mbcs_v2(const char*, int);
+SQLITE_API LPWSTR sqlite3_win32_utf8_to_unicode(const char*);
 #endif
 /*
@@ -11288,7 +11295,7 @@ SQLITE_API int sqlite3_deserialize(
 }  /* End of the 'extern "C"' block */
 #endif
 #endif /* SQLITE3_H */
 /* Function prototypes of SQLite3 Multiple Ciphers */
 SQLITE_PRIVATE int sqlite3mcCheckVfs(const char*);
 SQLITE_PRIVATE int sqlite3mcFileControlPragma(sqlite3*, const char*, int, void*);
@@ -11299,6 +11306,7 @@ SQLITE_PRIVATE void* sqlite3mcPagerCodec(PgHdrMC* pPg);
 typedef struct Pager PagerMC;
 SQLITE_PRIVATE int sqlite3mcPagerHasCodec(PagerMC* pPager);
 SQLITE_PRIVATE void sqlite3mcInitMemoryMethods();
+SQLITE_PRIVATE int sqlite3mcIsBackupSupported(sqlite3*, const char*, sqlite3*, const char*);
 /******** Begin file sqlite3rtree.h *********/
 /*
@@ -25026,8 +25034,8 @@ static const struct {
   /* 1 */ { 6, "minute",   7.7379e+12,        60.0  },
   /* 2 */ { 4, "hour",     1.2897e+11,      3600.0  },
   /* 3 */ { 3, "day",      5373485.0,      86400.0  },
-  /* 4 */ { 5, "month",    176546.0,  30.0*86400.0  },
-  /* 5 */ { 4, "year",     14713.0,  365.0*86400.0  },
+  /* 4 */ { 5, "month",    176546.0,     2592000.0  },
+  /* 5 */ { 4, "year",     14713.0,     31536000.0  },
 };
 /*
@@ -82315,6 +82323,12 @@ SQLITE_API sqlite3_backup *sqlite3_backup_init(
   }
 #endif
+  /* Check whether databases are compatible with backup */
+  if (!sqlite3mcIsBackupSupported(pSrcDb, zSrcDb, pDestDb, zDestDb)){
+    sqlite3ErrorWithMsg(pDestDb, SQLITE_ERROR, "backup is not supported with incompatible source and target databases");
+    return NULL;
+  }
   /* Lock the source database handle. The destination database
   ** handle is not locked in this routine, but it is locked in
   ** sqlite3_backup_step(). The user is required to ensure that no
@@ -257839,7 +257853,7 @@ SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
 /*
-** Include SQLite3MultiCipher components
+** Include SQLite3MultiCipher components
 */
 /* #include "sqlite3mc_config.h" */
 /*** Begin of #include "sqlite3mc_config.h" ***/
@@ -258052,9 +258066,9 @@ SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
 #define SQLITE3MC_VERSION_MAJOR      1
 #define SQLITE3MC_VERSION_MINOR      8
-#define SQLITE3MC_VERSION_RELEASE    5
+#define SQLITE3MC_VERSION_RELEASE    6
 #define SQLITE3MC_VERSION_SUBRELEASE 0
-#define SQLITE3MC_VERSION_STRING     "SQLite3 Multiple Ciphers 1.8.5"
+#define SQLITE3MC_VERSION_STRING     "SQLite3 Multiple Ciphers 1.8.6"
 #endif /* SQLITE3MC_VERSION_H_ */
 /*** End of #include "sqlite3mc_version.h" ***/
@@ -271564,7 +271578,7 @@ SQLITE_API int sqlite3_user_add(
 ** The sqlite3_user_change() interface can be used to change a users
 ** login credentials or admin privilege.  Any user can change their own
 ** login credentials.  Only an admin user can change another users login
-** credentials or admin privilege setting.  No user may change their own
+** credentials or admin privilege setting.  No user may change their own
 ** admin privilege setting.
 */
 SQLITE_API int sqlite3_user_change(
@@ -271798,6 +271812,7 @@ extern "C" {
 #ifndef SQLITE_PRIVATE
 #define SQLITE_PRIVATE
 #endif
 SQLITE_PRIVATE int sqlite3mcCheckVfs(const char* zVfs);
 SQLITE_API int sqlite3mc_vfs_create(const char* zVfsReal, int makeDefault);
@@ -271918,19 +271933,19 @@ static void MD5_Final(unsigned char *result, MD5_CTX *ctx);
 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
 * implementation.
 */
-#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
-#define H(x, y, z)			(((x) ^ (y)) ^ (z))
-#define H2(x, y, z)			((x) ^ ((y) ^ (z)))
-#define I(x, y, z)			((y) ^ ((x) | ~(z)))
+#define F(x, y, z)      ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)      ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z)      (((x) ^ (y)) ^ (z))
+#define H2(x, y, z)     ((x) ^ ((y) ^ (z)))
+#define I(x, y, z)      ((y) ^ ((x) | ~(z)))
 /*
 * The MD5 transformation for all four rounds.
 */
 #define STEP(f, a, b, c, d, x, t, s) \
-	(a) += f((b), (c), (d)) + (x) + (t); \
-	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
-	(a) += (b);
+  (a) += f((b), (c), (d)) + (x) + (t); \
+  (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+  (a) += (b);
 /*
 * SET reads 4 input bytes in little-endian byte order and stores them
@@ -271942,18 +271957,18 @@ static void MD5_Final(unsigned char *result, MD5_CTX *ctx);
 */
 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
 #define SET(n) \
-	(*(MD5_u32plus *)&ptr[(n) * 4])
+  (*(MD5_u32plus *)&ptr[(n) * 4])
 #define GET(n) \
-	SET(n)
+  SET(n)
 #else
 #define SET(n) \
-	(ctx->block[(n)] = \
-	(MD5_u32plus)ptr[(n) * 4] | \
-	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
-	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
-	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
+  (ctx->block[(n)] = \
+  (MD5_u32plus)ptr[(n) * 4] | \
+  ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
+  ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
+  ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
 #define GET(n) \
-	(ctx->block[(n)])
+  (ctx->block[(n)])
 #endif
 /*
@@ -272181,10 +272196,10 @@ Still 100% Public Domain
 Corrected a problem which generated improper hash values on 16 bit machines
 Routine SHA1Update changed from
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
+  void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
 len)
 to
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
+  void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
 long len)
 The 'len' parameter was declared an int which works fine on 32 bit machines.
@@ -272277,7 +272292,7 @@ typedef unsigned long long uint64_t;
 #define UINT8_MAX 255
 #define UINT16_MAX 65535
 #define UINT32_MAX 0xffffffffU  /* 4294967295U */
-#define UINT64_MAX 0xffffffffffffffffULL /* 18446744073709551615ULL */
+#define UINT64_MAX 0xffffffffffffffffULL /* 18446744073709551615ULL */
 #else
 #include <stdint.h>
 #endif
@@ -272296,6 +272311,10 @@ typedef unsigned long long uint64_t;
 #ifndef SHA1_H_
 #define SHA1_H_ (1)
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 /** SHA-1 Context */
 typedef struct {
     uint32_t h[5];
@@ -272309,13 +272328,13 @@ typedef struct {
 /** SHA-1 Digest size in bytes */
 #define SHA1_DIGEST_SIZE 20
-void sha1_init(sha1_ctx *context);
+SQLITE_PRIVATE void sha1_init(sha1_ctx *context);
-void sha1_update(sha1_ctx *context, const void *p, size_t len);
+SQLITE_PRIVATE void sha1_update(sha1_ctx *context, const void *p, size_t len);
-void sha1_final(sha1_ctx *context, uint8_t digest[SHA1_DIGEST_SIZE]);
+SQLITE_PRIVATE void sha1_final(sha1_ctx *context, uint8_t digest[SHA1_DIGEST_SIZE]);
-void sha1_transform(sha1_ctx *context, const uint8_t buffer[64]);
+SQLITE_PRIVATE void sha1_transform(sha1_ctx *context, const uint8_t buffer[64]);
 #endif /* SHA1_H_ */
 /*** End of #include "sha1.h" ***/
@@ -272370,6 +272389,7 @@ void sha1_transform(sha1_ctx *context, const uint8_t buffer[64]);
   z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=ror(w,2);
 /* Hash a single 512-bit block. This is the core of the algorithm. */
+SQLITE_PRIVATE
 void sha1_transform(sha1_ctx *context, const uint8_t buffer[64])
 {
   uint32_t a, b, c, d, e;
@@ -272434,6 +272454,7 @@ void sha1_transform(sha1_ctx *context, const uint8_t buffer[64])
 *
 * @param context SHA1-Context
 */
+SQLITE_PRIVATE
 void sha1_init(sha1_ctx *context)
 {
   /* SHA1 initialization constants */
@@ -272453,6 +272474,7 @@ void sha1_init(sha1_ctx *context)
 * @param p       Buffer to run SHA1 on
 * @param len     Number of bytes
 */
+SQLITE_PRIVATE
 void sha1_update(sha1_ctx *context, const void *p, size_t len)
 {
   const uint8_t *data = p;
@@ -272488,6 +272510,7 @@ void sha1_update(sha1_ctx *context, const void *p, size_t len)
 * @param digest  Generated message digest
 * @param context SHA1-Context
 */
+SQLITE_PRIVATE
 void sha1_final(sha1_ctx *context, uint8_t digest[SHA1_DIGEST_SIZE])
 {
   uint32_t i;
@@ -272599,6 +272622,10 @@ void sha1_final(sha1_ctx *context, uint8_t digest[SHA1_DIGEST_SIZE])
 #ifndef SHA2_H
 #define SHA2_H
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 #define SHA224_DIGEST_SIZE ( 224 / 8)
 #define SHA256_DIGEST_SIZE ( 256 / 8)
 #define SHA384_DIGEST_SIZE ( 384 / 8)
@@ -272620,7 +272647,7 @@ typedef sqlite3_uint64 uint64;
   #define li_64(h) 0x##h##ui64
 #else
   #define li_64(h) 0x##h##ull
-#endif
+#endif
 #if 0  /* Start of original int64 defines */
@@ -272692,35 +272719,27 @@ typedef struct {
 typedef sha512_ctx sha384_ctx;
 typedef sha256_ctx sha224_ctx;
-void sha224_init(sha224_ctx *ctx);
-void sha224_update(sha224_ctx *ctx, const unsigned char *message,
-                   unsigned int len);
-void sha224_final(sha224_ctx *ctx, unsigned char *digest);
-void sha224(const unsigned char *message, unsigned int len,
-            unsigned char *digest);
+SQLITE_PRIVATE void sha224_init(sha224_ctx *ctx);
+SQLITE_PRIVATE void sha224_update(sha224_ctx *ctx, const unsigned char *message, unsigned int len);
+SQLITE_PRIVATE void sha224_final(sha224_ctx *ctx, unsigned char *digest);
+SQLITE_PRIVATE void sha224(const unsigned char *message, unsigned int len, unsigned char *digest);
-void sha256_init(sha256_ctx * ctx);
-void sha256_update(sha256_ctx *ctx, const unsigned char *message,
-                   unsigned int len);
-void sha256_final(sha256_ctx *ctx, unsigned char *digest);
-void sha256_transform(sha256_ctx *ctx, const unsigned char *message);
-void sha256(const unsigned char *message, unsigned int len,
-            unsigned char *digest);
+SQLITE_PRIVATE void sha256_init(sha256_ctx * ctx);
+SQLITE_PRIVATE void sha256_update(sha256_ctx *ctx, const unsigned char *message, unsigned int len);
+SQLITE_PRIVATE void sha256_final(sha256_ctx *ctx, unsigned char *digest);
+SQLITE_PRIVATE void sha256_transform(sha256_ctx *ctx, const unsigned char *message);
+SQLITE_PRIVATE void sha256(const unsigned char *message, unsigned int len, unsigned char *digest);
-void sha384_init(sha384_ctx *ctx);
-void sha384_update(sha384_ctx *ctx, const unsigned char *message,
-                   unsigned int len);
-void sha384_final(sha384_ctx *ctx, unsigned char *digest);
-void sha384(const unsigned char *message, unsigned int len,
-            unsigned char *digest);
+SQLITE_PRIVATE void sha384_init(sha384_ctx *ctx);
+SQLITE_PRIVATE void sha384_update(sha384_ctx *ctx, const unsigned char *message, unsigned int len);
+SQLITE_PRIVATE void sha384_final(sha384_ctx *ctx, unsigned char *digest);
+SQLITE_PRIVATE void sha384(const unsigned char *message, unsigned int len, unsigned char *digest);
-void sha512_init(sha512_ctx *ctx);
-void sha512_update(sha512_ctx *ctx, const unsigned char *message,
-                   unsigned int len);
-void sha512_final(sha512_ctx *ctx, unsigned char *digest);
-void sha512_transform(sha512_ctx *ctx, const unsigned char *message);
-void sha512(const unsigned char *message, unsigned int len,
-            unsigned char *digest);
+SQLITE_PRIVATE void sha512_init(sha512_ctx *ctx);
+SQLITE_PRIVATE void sha512_update(sha512_ctx *ctx, const unsigned char *message, unsigned int len);
+SQLITE_PRIVATE void sha512_final(sha512_ctx *ctx, unsigned char *digest);
+SQLITE_PRIVATE void sha512_transform(sha512_ctx *ctx, const unsigned char *message);
+SQLITE_PRIVATE void sha512(const unsigned char *message, unsigned int len, unsigned char *digest);
 #ifdef __cplusplus
 }
@@ -272823,27 +272842,27 @@ void sha512(const unsigned char *message, unsigned int len,
     wv[h] = t1 + t2;                                        \
 }
-uint32 sha224_h0[8] =
+static uint32 sha224_h0[8] =
             {0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
              0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
-uint32 sha256_h0[8] =
+static uint32 sha256_h0[8] =
             {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
              0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
-uint64 sha384_h0[8] =
+static uint64 sha384_h0[8] =
             {li_64(cbbb9d5dc1059ed8), li_64(629a292a367cd507),
              li_64(9159015a3070dd17), li_64(152fecd8f70e5939),
              li_64(67332667ffc00b31), li_64(8eb44a8768581511),
              li_64(db0c2e0d64f98fa7), li_64(47b5481dbefa4fa4)};
-uint64 sha512_h0[8] =
+static uint64 sha512_h0[8] =
             {li_64(6a09e667f3bcc908), li_64(bb67ae8584caa73b),
              li_64(3c6ef372fe94f82b), li_64(a54ff53a5f1d36f1),
              li_64(510e527fade682d1), li_64(9b05688c2b3e6c1f),
              li_64(1f83d9abfb41bd6b), li_64(5be0cd19137e2179)};
-uint32 sha256_k[64] =
+static uint32 sha256_k[64] =
             {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
              0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
              0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -272861,7 +272880,7 @@ uint32 sha256_k[64] =
              0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
              0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
-uint64 sha512_k[80] =
+static uint64 sha512_k[80] =
             {li_64(428a2f98d728ae22), li_64(7137449123ef65cd),
              li_64(b5c0fbcfec4d3b2f), li_64(e9b5dba58189dbbc),
              li_64(3956c25bf348b538), li_64(59f111f1b605d019),
@@ -273021,11 +273040,13 @@ void sha256_transf(sha256_ctx *ctx, const unsigned char *message,
     }
 }
+SQLITE_PRIVATE
 void sha256_transform(sha256_ctx *ctx, const unsigned char *message)
 {
   sha256_transf(ctx, message, 1);
 }
+SQLITE_PRIVATE
 void sha256(const unsigned char *message, unsigned int len, unsigned char *digest)
 {
     sha256_ctx ctx;
@@ -273035,6 +273056,7 @@ void sha256(const unsigned char *message, unsigned int len, unsigned char *diges
     sha256_final(&ctx, digest);
 }
+SQLITE_PRIVATE
 void sha256_init(sha256_ctx *ctx)
 {
 #ifndef UNROLL_LOOPS
@@ -273053,6 +273075,7 @@ void sha256_init(sha256_ctx *ctx)
     ctx->tot_len = 0;
 }
+SQLITE_PRIVATE
 void sha256_update(sha256_ctx *ctx, const unsigned char *message,
                    unsigned int len)
 {
@@ -273087,6 +273110,7 @@ void sha256_update(sha256_ctx *ctx, const unsigned char *message,
     ctx->tot_len += (block_nb + 1) << 6;
 }
+SQLITE_PRIVATE
 void sha256_final(sha256_ctx *ctx, unsigned char *digest)
 {
     unsigned int block_nb;
@@ -273223,11 +273247,13 @@ void sha512_transf(sha512_ctx *ctx, const unsigned char *message,
     }
 }
+SQLITE_PRIVATE
 void sha512_transform(sha512_ctx *ctx, const unsigned char *message)
 {
   sha512_transf(ctx, message, 1);
 }
+SQLITE_PRIVATE
 void sha512(const unsigned char *message, unsigned int len,
             unsigned char *digest)
 {
@@ -273238,6 +273264,7 @@ void sha512(const unsigned char *message, unsigned int len,
     sha512_final(&ctx, digest);
 }
+SQLITE_PRIVATE
 void sha512_init(sha512_ctx *ctx)
 {
 #ifndef UNROLL_LOOPS
@@ -273256,6 +273283,7 @@ void sha512_init(sha512_ctx *ctx)
     ctx->tot_len = 0;
 }
+SQLITE_PRIVATE
 void sha512_update(sha512_ctx *ctx, const unsigned char *message,
                    unsigned int len)
 {
@@ -273290,6 +273318,7 @@ void sha512_update(sha512_ctx *ctx, const unsigned char *message,
     ctx->tot_len += (block_nb + 1) << 7;
 }
+SQLITE_PRIVATE
 void sha512_final(sha512_ctx *ctx, unsigned char *digest)
 {
     unsigned int block_nb;
@@ -273330,6 +273359,7 @@ void sha512_final(sha512_ctx *ctx, unsigned char *digest)
 /* SHA-384 functions */
+SQLITE_PRIVATE
 void sha384(const unsigned char *message, unsigned int len,
             unsigned char *digest)
 {
@@ -273340,6 +273370,7 @@ void sha384(const unsigned char *message, unsigned int len,
     sha384_final(&ctx, digest);
 }
+SQLITE_PRIVATE
 void sha384_init(sha384_ctx *ctx)
 {
 #ifndef UNROLL_LOOPS
@@ -273358,6 +273389,7 @@ void sha384_init(sha384_ctx *ctx)
     ctx->tot_len = 0;
 }
+SQLITE_PRIVATE
 void sha384_update(sha384_ctx *ctx, const unsigned char *message,
                    unsigned int len)
 {
@@ -273392,6 +273424,7 @@ void sha384_update(sha384_ctx *ctx, const unsigned char *message,
     ctx->tot_len += (block_nb + 1) << 7;
 }
+SQLITE_PRIVATE
 void sha384_final(sha384_ctx *ctx, unsigned char *digest)
 {
     unsigned int block_nb;
@@ -273430,6 +273463,7 @@ void sha384_final(sha384_ctx *ctx, unsigned char *digest)
 /* SHA-224 functions */
+SQLITE_PRIVATE
 void sha224(const unsigned char *message, unsigned int len,
             unsigned char *digest)
 {
@@ -273440,6 +273474,7 @@ void sha224(const unsigned char *message, unsigned int len,
     sha224_final(&ctx, digest);
 }
+SQLITE_PRIVATE
 void sha224_init(sha224_ctx *ctx)
 {
 #ifndef UNROLL_LOOPS
@@ -273458,6 +273493,7 @@ void sha224_init(sha224_ctx *ctx)
     ctx->tot_len = 0;
 }
+SQLITE_PRIVATE
 void sha224_update(sha224_ctx *ctx, const unsigned char *message,
                    unsigned int len)
 {
@@ -273492,6 +273528,7 @@ void sha224_update(sha224_ctx *ctx, const unsigned char *message,
     ctx->tot_len += (block_nb + 1) << 6;
 }
+SQLITE_PRIVATE
 void sha224_final(sha224_ctx *ctx, unsigned char *digest)
 {
     unsigned int block_nb;
@@ -273655,7 +273692,6 @@ int main()
 }
 #endif /* TEST_VECTORS */
 /*** End of #include "sha2.c" ***/
@@ -273695,6 +273731,10 @@ int main()
 #ifndef FASTPBKDF2_H
 #define FASTPBKDF2_H
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 #include <stdlib.h>
 /* #include "mystdint.h" */
@@ -273712,6 +273752,7 @@ extern "C" {
  *
  *  This function cannot fail; it does not report errors.
  */
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
                           const uint8_t *salt, size_t nsalt,
                           uint32_t iterations,
@@ -273726,6 +273767,7 @@ void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
  *
  *  This function cannot fail; it does not report errors.
  */
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha256(const uint8_t *pw, size_t npw,
                             const uint8_t *salt, size_t nsalt,
                             uint32_t iterations,
@@ -273740,6 +273782,7 @@ void fastpbkdf2_hmac_sha256(const uint8_t *pw, size_t npw,
  *
  *  This function cannot fail; it does not report errors.
  */
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha512(const uint8_t *pw, size_t npw,
                             const uint8_t *salt, size_t nsalt,
                             uint32_t iterations,
@@ -273749,6 +273792,7 @@ void fastpbkdf2_hmac_sha512(const uint8_t *pw, size_t npw,
  *
  *  This function cannot fail; it does not report errors.
  */
+SQLITE_PRIVATE
 void sqlcipher_hmac(int algorithm,
                     unsigned char* key, int nkey,
                     unsigned char* in, int in_sz,
@@ -274142,6 +274186,7 @@ DECL_PBKDF2(sha512,
             sha512_extract,
             sha512_xor)
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
                           const uint8_t *salt, size_t nsalt,
                           uint32_t iterations,
@@ -274153,6 +274198,7 @@ void fastpbkdf2_hmac_sha1(const uint8_t *pw, size_t npw,
 #endif
 }
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha256(const uint8_t *pw, size_t npw,
                             const uint8_t *salt, size_t nsalt,
                             uint32_t iterations,
@@ -274161,6 +274207,7 @@ void fastpbkdf2_hmac_sha256(const uint8_t *pw, size_t npw,
   PBKDF2(sha256)(pw, npw, salt, nsalt, iterations, out, nout);
 }
+SQLITE_PRIVATE
 void fastpbkdf2_hmac_sha512(const uint8_t *pw, size_t npw,
                             const uint8_t *salt, size_t nsalt,
                             uint32_t iterations,
@@ -274169,6 +274216,7 @@ void fastpbkdf2_hmac_sha512(const uint8_t *pw, size_t npw,
   PBKDF2(sha512)(pw, npw, salt, nsalt, iterations, out, nout);
 }
+SQLITE_PRIVATE
 void sqlcipher_hmac(int algorithm, unsigned char* key, int nkey, unsigned char* in, int in_sz, unsigned char* in2, int in2_sz, unsigned char* out)
 {
   switch (algorithm)
@@ -274218,10 +274266,10 @@ void sqlcipher_hmac(int algorithm, unsigned char* key, int nkey, unsigned char*
 /* Prototypes for several crypto functions to make pedantic compilers happy */
-void chacha20_xor(void* data, size_t n, const uint8_t key[32], const uint8_t nonce[12], uint32_t counter);
-void poly1305(const uint8_t* msg, size_t n, const uint8_t key[32], uint8_t tag[16]);
-int poly1305_tagcmp(const uint8_t tag1[16], const uint8_t tag2[16]);
-void chacha20_rng(void* out, size_t n);
+SQLITE_PRIVATE void chacha20_xor(void* data, size_t n, const uint8_t key[32], const uint8_t nonce[12], uint32_t counter);
+SQLITE_PRIVATE void poly1305(const uint8_t* msg, size_t n, const uint8_t key[32], uint8_t tag[16]);
+SQLITE_PRIVATE int poly1305_tagcmp(const uint8_t tag1[16], const uint8_t tag2[16]);
+SQLITE_PRIVATE void chacha20_rng(void* out, size_t n);
 /* #include "chacha20poly1305.c" */
 /*** Begin of #include "chacha20poly1305.c" ***/
@@ -274302,6 +274350,7 @@ static void chacha20_block(uint32_t x[16])
   #undef CC20QR
 }
+SQLITE_PRIVATE
 void chacha20_xor(void* buffer, size_t n, const uint8_t key[32],
                   const uint8_t nonce[12], uint32_t counter)
 {
@@ -274369,6 +274418,7 @@ void chacha20_xor(void* buffer, size_t n, const uint8_t key[32],
 /*
  * Poly1305 authentication tags
  */
+SQLITE_PRIVATE
 void poly1305(const uint8_t* msg, size_t n, const uint8_t key[32],
               uint8_t tag[16])
 {
@@ -274438,6 +274488,7 @@ process_block:
   s4 = d4; STORE32_LE(tag + 12, s4);
 }
+SQLITE_PRIVATE
 int poly1305_tagcmp(const uint8_t tag1[16], const uint8_t tag2[16])
 {
   uint8_t d = 0;
@@ -274514,7 +274565,7 @@ static size_t entropy(void* buf, size_t n)
 }
 #else
 #include <windows.h>
 #define RtlGenRandom SystemFunction036
 BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
@@ -274633,6 +274684,7 @@ static size_t entropy(void* buf, size_t n)
 /*
  * ChaCha20 random number generator
  */
+SQLITE_PRIVATE
 void chacha20_rng(void* out, size_t n)
 {
   static uint8_t key[32], nonce[12], buffer[64] = { 0 };
@@ -274926,7 +274978,7 @@ SQLITE_API int sqlite3_user_add(
   if( db->auth.authLevel<UAUTH_Admin ) return SQLITE_AUTH;
   if( !userTableExists(db, "main") ){
     if( !isAdmin ) return SQLITE_AUTH;
-    pStmt = sqlite3UserAuthPrepare(db,
+    pStmt = sqlite3UserAuthPrepare(db,
               "CREATE TABLE sqlite_user(\n"
               "  uname TEXT PRIMARY KEY,\n"
               "  isAdmin BOOLEAN,\n"
@@ -274937,7 +274989,7 @@ SQLITE_API int sqlite3_user_add(
     rc = sqlite3_finalize(pStmt);
     if( rc ) return rc;
   }
-  pStmt = sqlite3UserAuthPrepare(db,
+  pStmt = sqlite3UserAuthPrepare(db,
             "INSERT INTO sqlite_user(uname,isAdmin,pw)"
             " VALUES(%Q,%d,sqlite_crypt(?1,NULL))",
             zUsername, isAdmin!=0);
@@ -274957,7 +275009,7 @@ SQLITE_API int sqlite3_user_add(
 ** The sqlite3_user_change() interface can be used to change a users
 ** login credentials or admin privilege.  Any user can change their own
 ** login credentials.  Only an admin user can change another users login
-** credentials or admin privilege setting.  No user may change their own
+** credentials or admin privilege setting.  No user may change their own
 ** admin privilege setting.
 */
 SQLITE_API int sqlite3_user_change(
@@ -275121,6 +275173,10 @@ mcRegisterCodecExtensions(sqlite3* db, char** pzErrMsg, const sqlite3_api_routin
 #ifndef _RIJNDAEL_H_
 #define _RIJNDAEL_H_
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 /*
 // File : rijndael.h
 // Creation date : Sun Nov 5 2000 03:21:05 CEST
@@ -275219,16 +275275,16 @@ typedef unsigned short UINT16;
 */
 typedef struct _Rijndael
-{
-	int     m_state;
-	int     m_mode;
-	int     m_direction;
-	UINT8   m_initVector[MAX_IV_SIZE];
-	UINT32  m_uRounds;
-	UINT8   m_expandedKey[_MAX_ROUNDS+1][4][4];
+{
+  int     m_state;
+  int     m_mode;
+  int     m_direction;
+  UINT8   m_initVector[MAX_IV_SIZE];
+  UINT32  m_uRounds;
+  UINT8   m_expandedKey[_MAX_ROUNDS+1][4][4];
 } Rijndael;
-void RijndaelCreate(Rijndael* rijndael);
+SQLITE_PRIVATE void RijndaelCreate(Rijndael* rijndael);
 /*
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -275250,7 +275306,7 @@ void RijndaelCreate(Rijndael* rijndael);
 // keyLen    : Rijndael::Key16Bytes , Rijndael::Key24Bytes or Rijndael::Key32Bytes
 // initVector: initialization vector, you will usually use 0 here
 */
-int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen, UINT8* initVector);
+SQLITE_PRIVATE int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen, UINT8* initVector);
 /*
 // Encrypts the input array (can be binary data)
@@ -275261,7 +275317,7 @@ int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen,
 // outBuffer must be at least inputLen / 8 bytes long.
 // Returns the encrypted buffer length in BITS or an error code < 0 in case of error
 */
-int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
+SQLITE_PRIVATE int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
 /*
 // Encrypts the input array (can be binary data)
@@ -275270,7 +275326,7 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *
 // outBuffer must be at least (inputLen + 16) bytes long
 // Returns the encrypted buffer length in BYTES or an error code < 0 in case of error
 */
-int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
+SQLITE_PRIVATE int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
 /*
 // Decrypts the input vector
@@ -275278,7 +275334,7 @@ int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
 // outBuffer must be at least inputLen / 8 bytes long
 // Returns the decrypted buffer length in BITS and an error code < 0 in case of error
 */
-int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
+SQLITE_PRIVATE int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
 /*
 // Decrypts the input vector
@@ -275286,14 +275342,14 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *
 // outBuffer must be at least inputLen bytes long
 // Returns the decrypted buffer length in BYTES and an error code < 0 in case of error
 */
-int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
+SQLITE_PRIVATE int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
+SQLITE_PRIVATE void RijndaelInvalidate(Rijndael* rijndael);
+SQLITE_PRIVATE void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4]);
+SQLITE_PRIVATE void RijndaelKeyEncToDec(Rijndael* rijndael);
+SQLITE_PRIVATE void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
+SQLITE_PRIVATE void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
-void RijndaelInvalidate(Rijndael* rijndael);
-void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4]);
-void RijndaelKeyEncToDec(Rijndael* rijndael);
-void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
-void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
 #endif /* _RIJNDAEL_H_ */
 /*** End of #include "rijndael.h" ***/
@@ -275535,7 +275591,7 @@ aesGenKeyEncrypt(const unsigned char* userKey, const int bits, unsigned char* ke
 {
   int numberOfRounds = (bits == 128) ? 10 : (bits == 192) ? 12 : (bits == 256) ? 14 : 0;
   int rc = (!userKey || !keyData) ? -1 : (numberOfRounds > 0) ? 0 : -2;
   if (rc == 0)
   {
     __m128i tempKey[_MAX_ROUNDS + 1];
@@ -275684,7 +275740,7 @@ aesDecryptCBC(const unsigned char* in,
     int offset;
     --numBlocks;
     offset = numBlocks * 16;
     /* Decrypt the last plain block. */
     last_in = _mm_loadu_si128(&((__m128i*) in)[numBlocks]);
     data = _mm_xor_si128(last_in, key[numberOfRounds - 0]);
@@ -275814,7 +275870,7 @@ aesGenKeyEncryptInternal(const unsigned char* userKey, const int bits, uint8x16_
   int i;
   int j;
   int numberOfRounds = (bits == 128) ? 10 : (bits == 192) ? 12 : (bits == 256) ? 14 : 0;
-  int keyWords = bits / 32;
+  int keyWords = bits / 32;
   int schedWords = (numberOfRounds + 1) * 4;
   /*
@@ -275875,7 +275931,7 @@ aesGenKeyEncrypt(const unsigned char* userKey, const int bits, unsigned char* ke
 {
   int numberOfRounds = (bits == 128) ? 10 : (bits == 192) ? 12 : (bits == 256) ? 14 : 0;
   int rc = (!userKey || !keyData) ? -1 : (numberOfRounds > 0) ? 0 : -2;
   if (rc == 0)
   {
     uint8x16_t tempKey[_MAX_ROUNDS + 1];
@@ -275985,7 +276041,7 @@ aesEncryptCBC(const unsigned char* in,
     }
     feedback = vaeseq_u8(feedback, key[numberOfRounds-1]);
     feedback = veorq_u8(feedback, key[numberOfRounds]);                          \
     vst1q_u8(&out[(numBlocks-1)*16], feedback);
     memcpy(&out[numBlocks*16], lastblock, lenFrag);
@@ -276026,7 +276082,7 @@ aesDecryptCBC(const unsigned char* in,
     int offset;
     --numBlocks;
     offset = numBlocks * 16;
     /* Decrypt the last plain block. */
     last_in = vld1q_u8(&in[numBlocks*16]);
@@ -276122,21 +276178,21 @@ aesHardwareAvailable()
 static UINT8 S[256]=
 {
-   99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118,
-  202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
-  183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 216,  49,  21,
-    4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,
-    9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,  47, 132,
-   83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,  57,  74,  76,  88, 207,
-  208, 239, 170, 251,  67,  77,  51, 133,  69, 249,   2, 127,  80,  60, 159, 168,
-   81, 163,  64, 143, 146, 157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210,
-  205,  12,  19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25, 115,
-   96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20, 222,  94,  11, 219,
-  224,  50,  58,  10,  73,   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121,
-  231, 200,  55, 109, 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8,
-  186, 120,  37,  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,
-  112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158,
-  225, 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,
+   99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118,
+  202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
+  183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 216,  49,  21,
+    4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,
+    9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,  47, 132,
+   83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,  57,  74,  76,  88, 207,
+  208, 239, 170, 251,  67,  77,  51, 133,  69, 249,   2, 127,  80,  60, 159, 168,
+   81, 163,  64, 143, 146, 157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210,
+  205,  12,  19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25, 115,
+   96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20, 222,  94,  11, 219,
+  224,  50,  58,  10,  73,   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121,
+  231, 200,  55, 109, 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8,
+  186, 120,  37,  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,
+  112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158,
+  225, 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,
   140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,  22
 };
@@ -276207,7 +276263,7 @@ static UINT8 T1[256][4]=
   {0x82,0x41,0x41,0xc3}, {0x29,0x99,0x99,0xb0}, {0x5a,0x2d,0x2d,0x77}, {0x1e,0x0f,0x0f,0x11},
   {0x7b,0xb0,0xb0,0xcb}, {0xa8,0x54,0x54,0xfc}, {0x6d,0xbb,0xbb,0xd6}, {0x2c,0x16,0x16,0x3a}
 };
 static UINT8 T2[256][4]=
 {
   {0xa5,0xc6,0x63,0x63}, {0x84,0xf8,0x7c,0x7c}, {0x99,0xee,0x77,0x77}, {0x8d,0xf6,0x7b,0x7b},
@@ -276819,7 +276875,7 @@ static UINT8 U1[256][4]=
   {0xa7,0x79,0xb4,0x92}, {0xa9,0x70,0xb9,0x99}, {0xbb,0x6b,0xae,0x84}, {0xb5,0x62,0xa3,0x8f},
   {0x9f,0x5d,0x80,0xbe}, {0x91,0x54,0x8d,0xb5}, {0x83,0x4f,0x9a,0xa8}, {0x8d,0x46,0x97,0xa3}
 };
 static UINT8 U2[256][4]=
 {
   {0x00,0x00,0x00,0x00}, {0x0b,0x0e,0x09,0x0d}, {0x16,0x1c,0x12,0x1a}, {0x1d,0x12,0x1b,0x17},
@@ -277025,7 +277081,7 @@ static UINT8 U4[256][4]=
 };
 static UINT32 rcon[30]=
-{
+{
   0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
   0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
   0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc,
@@ -277039,11 +277095,13 @@ static UINT32 rcon[30]=
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 */
+SQLITE_PRIVATE
 void RijndaelCreate(Rijndael* rijndael)
 {
    rijndael->m_state = RIJNDAEL_State_Invalid;
 }
+SQLITE_PRIVATE
 int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen, UINT8* initVector)
 {
   UINT32 uKeyLenInBytes;
@@ -277128,7 +277186,7 @@ int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen,
 #endif
     }
   }
-#ifndef TEST_AES_HW
+#ifndef TEST_AES_HW
   else
 #endif
 #endif
@@ -277140,7 +277198,7 @@ int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen,
     if (rijndael->m_direction == RIJNDAEL_Direction_Decrypt) RijndaelKeyEncToDec(rijndael);
   }
-#ifdef TEST_AES_HW
+#ifdef TEST_AES_HW
   {
     int cmpkeyexp = memcmp((unsigned char*) rijndael->m_expandedKey, aesKeySched, (rijndael->m_uRounds+1)*16);
     int datalen = (rijndael->m_uRounds + 1) * 16;
@@ -277170,10 +277228,10 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
   numBlocks = inputLen/128;
   lenFrag = (inputLen % 128) / 8;
   switch (rijndael->m_mode)
   {
-    case RIJNDAEL_Direction_Mode_ECB:
+    case RIJNDAEL_Direction_Mode_ECB:
       for(i = numBlocks;i > 0;i--)
       {
         RijndaelEncrypt(rijndael, input, outBuffer);
@@ -277185,7 +277243,7 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
 #if HAS_AES_HARDWARE
       if (aesHardwareAvailable())
       {
-#ifndef TEST_AES_HW
+#ifndef TEST_AES_HW
         aesEncryptCBC(input, outBuffer, rijndael->m_initVector, inputLen/8, (unsigned char*) (rijndael->m_expandedKey), rijndael->m_uRounds);
 #else
         TEST_AES_HW_DEBUG_LOG("aes enc: hw enabled\n");
@@ -277231,8 +277289,8 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
       }
     break;
     case RIJNDAEL_Direction_Mode_CFB1:
-#if STRICT_ALIGN
-      memcpy(iv,rijndael->m_initVector,16);
+#if STRICT_ALIGN
+      memcpy(iv,rijndael->m_initVector,16);
 #else  /* !STRICT_ALIGN */
       *((UINT32*)iv[0]) = *((UINT32*)(rijndael->m_initVector   ));
       *((UINT32*)iv[1]) = *((UINT32*)(rijndael->m_initVector + 4));
@@ -277276,7 +277334,7 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
     break;
   }
-#ifdef TEST_AES_HW
+#ifdef TEST_AES_HW
   {
     int cmpdata = memcmp((unsigned char*) outOrig, outBuffer2, inputLen/8);
     TEST_AES_HW_DEBUG_LOG("aes enc: cmp=%d\n", cmpdata);
@@ -277284,10 +277342,11 @@ int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
     TEST_AES_HW_DEBUG_HEX("aes enc HW:", outBuffer2, 16);
   }
 #endif
   return 128 * numBlocks;
 }
+SQLITE_PRIVATE
 int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer)
 {
   int i, numBlocks, padLen;
@@ -277302,7 +277361,7 @@ int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
   switch (rijndael->m_mode)
   {
-    case RIJNDAEL_Direction_Mode_ECB:
+    case RIJNDAEL_Direction_Mode_ECB:
       for(i = numBlocks; i > 0; i--)
       {
         RijndaelEncrypt(rijndael, input, outBuffer);
@@ -277342,10 +277401,11 @@ int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
       return -1;
     break;
   }
   return 16*(numBlocks + 1);
 }
+SQLITE_PRIVATE
 int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8* outBuffer)
 {
   int i, k, numBlocks, lenFrag;
@@ -277365,7 +277425,7 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
   switch (rijndael->m_mode)
   {
-    case RIJNDAEL_Direction_Mode_ECB:
+    case RIJNDAEL_Direction_Mode_ECB:
       for (i = numBlocks; i > 0; i--)
       {
         RijndaelDecrypt(rijndael, input, outBuffer);
@@ -277420,8 +277480,8 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
             }
           }
         }
-#if STRICT_ALIGN
-        memcpy(iv,rijndael->m_initVector,16);
+#if STRICT_ALIGN
+        memcpy(iv,rijndael->m_initVector,16);
 #else
         *((UINT32*)iv[0]) = *((UINT32*)(rijndael->m_initVector  ));
         *((UINT32*)iv[1]) = *((UINT32*)(rijndael->m_initVector+ 4));
@@ -277450,8 +277510,8 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
       }
       break;
     case RIJNDAEL_Direction_Mode_CFB1:
-#if STRICT_ALIGN
-      memcpy(iv, rijndael->m_initVector, 16);
+#if STRICT_ALIGN
+      memcpy(iv, rijndael->m_initVector, 16);
 #else
       *((UINT32*)iv[0]) = *((UINT32*)(rijndael->m_initVector));
       *((UINT32*)iv[1]) = *((UINT32*)(rijndael->m_initVector+ 4));
@@ -277495,7 +277555,7 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
     break;
   }
-#ifdef TEST_AES_HW
+#ifdef TEST_AES_HW
   {
     int cmpdata = memcmp((unsigned char*) outOrig, outBuffer2, inputLen/8);
     TEST_AES_HW_DEBUG_LOG("aes dec: cmp=%d\n", cmpdata);
@@ -277503,10 +277563,11 @@ int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8* input, int inputLen, UINT8*
     TEST_AES_HW_DEBUG_HEX("aes dec HW:", outBuffer2, 16);
   }
 #endif
   return 128*numBlocks;
 }
+SQLITE_PRIVATE
 int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer)
 {
   int i, numBlocks, padLen;
@@ -277540,7 +277601,7 @@ int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
         if (block[i] != padLen) return RIJNDAEL_CORRUPTED_DATA;
       }
       memcpy(outBuffer, block, 16 - padLen);
-    break;
+    break;
     case RIJNDAEL_Direction_Mode_CBC:
       memcpy(iv, rijndael->m_initVector, 16);
       /* all blocks but last */
@@ -277570,12 +277631,12 @@ int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
       }
       memcpy(outBuffer, block, 16 - padLen);
       break;
     default:
       return -1;
     break;
   }
   return 16*numBlocks - padLen;
 }
@@ -277585,6 +277646,7 @@ int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 */
+SQLITE_PRIVATE
 void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4])
 {
   int j,rconpointer = 0;
@@ -277621,7 +277683,7 @@ void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4])
       t = 0;
     }
   }
   while(r <= rijndael->m_uRounds)
   {
     tempKey[0][0] ^= S[tempKey[uKeyColumns-1][1]];
@@ -277662,9 +277724,10 @@ void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4])
         t = 0;
       }
     }
-  }
+  }
 }
+SQLITE_PRIVATE
 void RijndaelKeyEncToDec(Rijndael* rijndael)
 {
   UINT32 r;
@@ -277681,8 +277744,9 @@ void RijndaelKeyEncToDec(Rijndael* rijndael)
     w = rijndael->m_expandedKey[r][3];
     *((UINT32*)w) = *((UINT32*)U1[w[0]]) ^ *((UINT32*)U2[w[1]]) ^ *((UINT32*)U3[w[2]]) ^ *((UINT32*)U4[w[3]]);
   }
-}
+}
+SQLITE_PRIVATE
 void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
 {
   UINT32 r;
@@ -277694,19 +277758,19 @@ void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
     *((UINT32*)temp[3]) = *((UINT32*)(a+12)) ^ *((UINT32*)rijndael->m_expandedKey[0][3]);
     *((UINT32*)(b    )) = *((UINT32*)T1[temp[0][0]])
             ^ *((UINT32*)T2[temp[1][1]])
-            ^ *((UINT32*)T3[temp[2][2]])
+            ^ *((UINT32*)T3[temp[2][2]])
             ^ *((UINT32*)T4[temp[3][3]]);
     *((UINT32*)(b + 4)) = *((UINT32*)T1[temp[1][0]])
             ^ *((UINT32*)T2[temp[2][1]])
-            ^ *((UINT32*)T3[temp[3][2]])
+            ^ *((UINT32*)T3[temp[3][2]])
             ^ *((UINT32*)T4[temp[0][3]]);
     *((UINT32*)(b + 8)) = *((UINT32*)T1[temp[2][0]])
             ^ *((UINT32*)T2[temp[3][1]])
-            ^ *((UINT32*)T3[temp[0][2]])
+            ^ *((UINT32*)T3[temp[0][2]])
             ^ *((UINT32*)T4[temp[1][3]]);
     *((UINT32*)(b +12)) = *((UINT32*)T1[temp[3][0]])
             ^ *((UINT32*)T2[temp[0][1]])
-            ^ *((UINT32*)T3[temp[1][2]])
+            ^ *((UINT32*)T3[temp[1][2]])
             ^ *((UINT32*)T4[temp[2][3]]);
   for(r = 1; r < rijndael->m_uRounds-1; r++)
   {
@@ -277717,19 +277781,19 @@ void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
     *((UINT32*)(b    )) = *((UINT32*)T1[temp[0][0]])
               ^ *((UINT32*)T2[temp[1][1]])
-              ^ *((UINT32*)T3[temp[2][2]])
+              ^ *((UINT32*)T3[temp[2][2]])
               ^ *((UINT32*)T4[temp[3][3]]);
     *((UINT32*)(b + 4)) = *((UINT32*)T1[temp[1][0]])
               ^ *((UINT32*)T2[temp[2][1]])
-              ^ *((UINT32*)T3[temp[3][2]])
+              ^ *((UINT32*)T3[temp[3][2]])
               ^ *((UINT32*)T4[temp[0][3]]);
     *((UINT32*)(b + 8)) = *((UINT32*)T1[temp[2][0]])
               ^ *((UINT32*)T2[temp[3][1]])
-              ^ *((UINT32*)T3[temp[0][2]])
+              ^ *((UINT32*)T3[temp[0][2]])
               ^ *((UINT32*)T4[temp[1][3]]);
     *((UINT32*)(b +12)) = *((UINT32*)T1[temp[3][0]])
               ^ *((UINT32*)T2[temp[0][1]])
-              ^ *((UINT32*)T3[temp[1][2]])
+              ^ *((UINT32*)T3[temp[1][2]])
               ^ *((UINT32*)T4[temp[2][3]]);
   }
   *((UINT32*)temp[0]) = *((UINT32*)(b   )) ^ *((UINT32*)rijndael->m_expandedKey[rijndael->m_uRounds-1][0]);
@@ -277758,11 +277822,12 @@ void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
   *((UINT32*)(b+12)) ^= *((UINT32*)rijndael->m_expandedKey[rijndael->m_uRounds][3]);
 }
+SQLITE_PRIVATE
 void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
 {
   int r;
   UINT8 temp[4][4];
     *((UINT32*)temp[0]) = *((UINT32*)(a   )) ^ *((UINT32*)rijndael->m_expandedKey[rijndael->m_uRounds][0]);
     *((UINT32*)temp[1]) = *((UINT32*)(a+ 4)) ^ *((UINT32*)rijndael->m_expandedKey[rijndael->m_uRounds][1]);
     *((UINT32*)temp[2]) = *((UINT32*)(a+ 8)) ^ *((UINT32*)rijndael->m_expandedKey[rijndael->m_uRounds][2]);
@@ -277770,19 +277835,19 @@ void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
     *((UINT32*)(b   )) = *((UINT32*)T5[temp[0][0]])
            ^ *((UINT32*)T6[temp[3][1]])
-           ^ *((UINT32*)T7[temp[2][2]])
+           ^ *((UINT32*)T7[temp[2][2]])
            ^ *((UINT32*)T8[temp[1][3]]);
   *((UINT32*)(b+ 4)) = *((UINT32*)T5[temp[1][0]])
            ^ *((UINT32*)T6[temp[0][1]])
-           ^ *((UINT32*)T7[temp[3][2]])
+           ^ *((UINT32*)T7[temp[3][2]])
            ^ *((UINT32*)T8[temp[2][3]]);
   *((UINT32*)(b+ 8)) = *((UINT32*)T5[temp[2][0]])
            ^ *((UINT32*)T6[temp[1][1]])
-           ^ *((UINT32*)T7[temp[0][2]])
+           ^ *((UINT32*)T7[temp[0][2]])
            ^ *((UINT32*)T8[temp[3][3]]);
   *((UINT32*)(b+12)) = *((UINT32*)T5[temp[3][0]])
            ^ *((UINT32*)T6[temp[2][1]])
-           ^ *((UINT32*)T7[temp[1][2]])
+           ^ *((UINT32*)T7[temp[1][2]])
            ^ *((UINT32*)T8[temp[0][3]]);
   for(r = rijndael->m_uRounds-1; r > 1; r--)
   {
@@ -277792,22 +277857,22 @@ void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
     *((UINT32*)temp[3]) = *((UINT32*)(b+12)) ^ *((UINT32*)rijndael->m_expandedKey[r][3]);
     *((UINT32*)(b   )) = *((UINT32*)T5[temp[0][0]])
            ^ *((UINT32*)T6[temp[3][1]])
-           ^ *((UINT32*)T7[temp[2][2]])
+           ^ *((UINT32*)T7[temp[2][2]])
            ^ *((UINT32*)T8[temp[1][3]]);
     *((UINT32*)(b+ 4)) = *((UINT32*)T5[temp[1][0]])
            ^ *((UINT32*)T6[temp[0][1]])
-           ^ *((UINT32*)T7[temp[3][2]])
+           ^ *((UINT32*)T7[temp[3][2]])
            ^ *((UINT32*)T8[temp[2][3]]);
     *((UINT32*)(b+ 8)) = *((UINT32*)T5[temp[2][0]])
            ^ *((UINT32*)T6[temp[1][1]])
-           ^ *((UINT32*)T7[temp[0][2]])
+           ^ *((UINT32*)T7[temp[0][2]])
            ^ *((UINT32*)T8[temp[3][3]]);
     *((UINT32*)(b+12)) = *((UINT32*)T5[temp[3][0]])
            ^ *((UINT32*)T6[temp[2][1]])
-           ^ *((UINT32*)T7[temp[1][2]])
+           ^ *((UINT32*)T7[temp[1][2]])
            ^ *((UINT32*)T8[temp[0][3]]);
   }
   *((UINT32*)temp[0]) = *((UINT32*)(b   )) ^ *((UINT32*)rijndael->m_expandedKey[1][0]);
   *((UINT32*)temp[1]) = *((UINT32*)(b+ 4)) ^ *((UINT32*)rijndael->m_expandedKey[1][1]);
   *((UINT32*)temp[2]) = *((UINT32*)(b+ 8)) ^ *((UINT32*)rijndael->m_expandedKey[1][2]);
@@ -277834,6 +277899,7 @@ void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16])
   *((UINT32*)(b+12)) ^= *((UINT32*)rijndael->m_expandedKey[0][3]);
 }
+SQLITE_PRIVATE
 void RijndaelInvalidate(Rijndael* rijndael)
 {
   rijndael->m_state = RIJNDAEL_State_Invalid;
@@ -277944,6 +278010,7 @@ typedef struct _Codec
   unsigned char m_page[SQLITE_MAX_PAGE_SIZE + 24];
   int           m_pageSize;
   int           m_reserved;
+  int           m_lastError;
   int           m_hasKeySalt;
   unsigned char m_keySalt[KEYSALT_LENGTH];
 } Codec;
@@ -278015,6 +278082,9 @@ SQLITE_PRIVATE int sqlite3mcGetReservedWriteCipher(Codec* codec);
 SQLITE_PRIVATE int sqlite3mcReservedEqual(Codec* codec);
+SQLITE_PRIVATE void sqlite3mcSetCodecLastError(Codec* codec, int error);
+SQLITE_PRIVATE int sqlite3mcGetCodecLastError(Codec* codec);
 SQLITE_PRIVATE unsigned char* sqlite3mcGetSaltWriteCipher(Codec* codec);
 SQLITE_PRIVATE int sqlite3mcCodecCopy(Codec* codec, Codec* other);
@@ -278239,7 +278309,7 @@ sqlite3mcAES128(Rijndael* aesCtx, int page, int encrypt, unsigned char encryptio
   {
     len = RijndaelBlockDecrypt(aesCtx, datain, datalen*8, dataout);
   }
   /* It is a good idea to check the error code */
   if (len < 0)
   {
@@ -278293,7 +278363,7 @@ sqlite3mcAES256(Rijndael* aesCtx, int page, int encrypt, unsigned char encryptio
   {
     len = RijndaelBlockDecrypt(aesCtx, datain, datalen*8, dataout);
   }
   /* It is a good idea to check the error code */
   if (len < 0)
   {
@@ -279166,7 +279236,8 @@ EncryptPageChaCha20Cipher(void* cipher, int page, unsigned char* data, int len,
   return rc;
 }
-int chacha20_ismemset(const void* v, unsigned char value, int len)
+static int
+chacha20_ismemset(const void* v, unsigned char value, int len)
 {
   const unsigned char* a = v;
   int i = 0, result = 0;
@@ -279616,6 +279687,8 @@ GetHmacSizeSQLCipherCipher(int algorithm)
       hmacSize = SHA1_DIGEST_SIZE;
       break;
     case SQLCIPHER_HMAC_ALGORITHM_SHA256:
+      hmacSize = SHA256_DIGEST_SIZE;
+      break;
     case SQLCIPHER_HMAC_ALGORITHM_SHA512:
     default:
       hmacSize = SHA512_DIGEST_SIZE;
@@ -279634,7 +279707,7 @@ EncryptPageSQLCipherCipher(void* cipher, int page, unsigned char* data, int len,
   int n = len - nReserved;
   int offset = (page == 1) ? (sqlCipherCipher->m_legacy != 0) ? 16 : 24 : 0;
   int blen;
-  unsigned char iv[64];
+  unsigned char iv[128];
   int usePlaintextHeader = 0;
   /* Check whether a plaintext header should be used */
@@ -279651,10 +279724,10 @@ EncryptPageSQLCipherCipher(void* cipher, int page, unsigned char* data, int len,
   }
   /* Generate nonce (64 bytes) */
-  memset(iv, 0, 64);
+  memset(iv, 0, 128);
   if (nReserved > 0)
   {
-    chacha20_rng(iv, 64);
+    chacha20_rng(iv, 128);
   }
   else
   {
@@ -280003,7 +280076,7 @@ SQLITE_PRIVATE const CipherDescriptor mcRC4Descriptor =
 /*** Begin of #include "ascon/prolog.h" ***/
 /*
 ** Name:        prolog.h
-** Purpose:     Include important header files, before
+** Purpose:     Include important header files, before
 ** Based on:    Public domain Ascon reference implementation
 **              and optimized variants for 32- and 64-bit
 **              (see https://github.com/ascon/ascon-c)
@@ -280103,6 +280176,8 @@ typedef union {
 #define ASCON_U64TOWORD(x) ASCON_U64BIG(x)
 #define ASCON_WORDTOU64(x) ASCON_U64BIG(x)
+#define ASCON_LOAD(b, n) ASCON_LOADBYTES(b, n)
+#define ASCON_STORE(b, w, n) ASCON_STOREBYTES(b, w, n)
 forceinline uint64_t ASCON_ROR(uint64_t x, int n) { return x >> n | x << (-n & 63); }
@@ -280120,6 +280195,8 @@ forceinline int ASCON_NOTZERO(uint64_t a, uint64_t b) {
 forceinline uint64_t ASCON_PAD(int i) { return 0x80ull << (56 - 8 * i); }
+forceinline uint64_t ASCON_DSEP() { return 0x01; }
 forceinline uint64_t ASCON_PRFS_MLEN(uint64_t len) { return len << 51; }
 forceinline uint64_t ASCON_CLEAR(uint64_t w, int n) {
@@ -280133,16 +280210,6 @@ forceinline uint64_t ASCON_MASK(int n) {
   return ~0ull >> (64 - 8 * n);
 }
-forceinline uint64_t ASCON_LOAD(const uint8_t* bytes, int n) {
-  uint64_t x = *(uint64_t*)bytes & ASCON_MASK(n);
-  return ASCON_U64TOWORD(x);
-}
-forceinline void ASCON_STORE(uint8_t* bytes, uint64_t w, int n) {
-  *(uint64_t*)bytes &= ~ASCON_MASK(n);
-  *(uint64_t*)bytes |= ASCON_WORDTOU64(w);
-}
 forceinline uint64_t ASCON_LOADBYTES(const uint8_t* bytes, int n) {
   uint64_t x = 0;
   memcpy(&x, bytes, n);
@@ -280305,6 +280372,10 @@ void ascon_squeeze(ascon_state_t* s, uint8_t* out, uint64_t outlen);
 #ifndef CRYPTO_AEAD_H
 #define CRYPTO_AEAD_H
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 #include <stddef.h>
 /*
@@ -280319,6 +280390,7 @@ void ascon_squeeze(ascon_state_t* s, uint8_t* out, uint64_t outlen);
 ** \param nonce Buffer with nonce data
 ** \param k Buffer with key data
 */
+SQLITE_PRIVATE
 int ascon_aead_encrypt(uint8_t* ctext, uint8_t tag[ASCON_AEAD_TAG_LEN],
                        const uint8_t* mtext, uint64_t mlen,
                        const uint8_t* ad, uint64_t adlen,
@@ -280337,6 +280409,7 @@ int ascon_aead_encrypt(uint8_t* ctext, uint8_t tag[ASCON_AEAD_TAG_LEN],
 ** \param nonce Buffer with nonce data
 ** \param k Buffer with key data
 */
+SQLITE_PRIVATE
 int ascon_aead_decrypt(uint8_t* mtext, const uint8_t* ctext, uint64_t clen,
                        const uint8_t* ad, uint64_t adlen,
                        const uint8_t tag[ASCON_AEAD_TAG_LEN],
@@ -280773,7 +280846,7 @@ forceinline void ascon_adata(ascon_state_t* s, const uint8_t* ad,
     ASCON_P(s, nr);
   }
   /* domain separation */
-  s->x[4] ^= 1;
+  s->x[4] ^= ASCON_DSEP();
   ascon_printstate("domain separation", s);
 }
@@ -280882,6 +280955,7 @@ forceinline void ascon_final(ascon_state_t* s, const ascon_key_t* key) {
   ascon_printstate("final 2nd key xor", s);
 }
+SQLITE_PRIVATE
 int ascon_aead_encrypt(uint8_t* ctext,
                        uint8_t tag[ASCON_AEAD_TAG_LEN],
                        const uint8_t* mtext, uint64_t mlen,
@@ -280905,6 +280979,7 @@ int ascon_aead_encrypt(uint8_t* ctext,
   return 0;
 }
+SQLITE_PRIVATE
 int ascon_aead_decrypt(uint8_t* mtext,
                        const uint8_t* ctext, uint64_t clen,
                        const uint8_t* ad, uint64_t adlen,
@@ -280969,6 +281044,10 @@ int ascon_aead_decrypt(uint8_t* mtext,
 #ifndef CRYPTO_HASH_H
 #define CRYPTO_HASH_H
+#ifndef SQLITE_PRIVATE
+#define SQLITE_PRIVATE
+#endif
 #include <stddef.h>
 /*
@@ -280978,6 +281057,7 @@ int ascon_aead_decrypt(uint8_t* mtext,
 ** \param in Buffer with input data
 ** \param passwordlen Length of input data in bytes
 */
+SQLITE_PRIVATE
 int ascon_hash(uint8_t* out, const uint8_t* in, uint64_t inlen);
 #endif
@@ -281061,6 +281141,7 @@ forceinline void ascon_squeeze(ascon_state_t* s, uint8_t* out,
   ascon_printstate("squeeze output", s);
 }
+SQLITE_PRIVATE
 int ascon_hash(uint8_t* out, const uint8_t* in, uint64_t inlen)
 {
   ascon_state_t s;
@@ -281093,6 +281174,7 @@ int ascon_hash(uint8_t* out, const uint8_t* in, uint64_t inlen)
 #define ASCON_HASH_SIZE 32
 #define ASCON_PBKDF2_SIZE 32
+SQLITE_PRIVATE
 void ascon_pbkdf2_init(ascon_state_t* state, const char* functionName,
                        const unsigned char* custom, uint32_t customlen, uint32_t outlen)
 {
@@ -281138,10 +281220,11 @@ void ascon_pbkdf2_init(ascon_state_t* state, const char* functionName,
  * Note: Instead of HMAC like in RFC 8018, use the following PRF:
  * PRF(P, X) = ASCON-cXOF(X, 256, "PBKDF2", P)
  */
-static void ascon_pbkdf2_f(ascon_state_t* state,
-                           uint8_t* T, /*uint8_t* U,*/
-                           const uint8_t* salt, uint32_t saltlen,
-                           uint32_t count, uint32_t blocknum)
+static
+void ascon_pbkdf2_f(ascon_state_t* state,
+                    uint8_t* T, /*uint8_t* U,*/
+                    const uint8_t* salt, uint32_t saltlen,
+                    uint32_t count, uint32_t blocknum)
 {
   uint32_t asconSaltLen = (saltlen < ASCON_SALT_LEN) ? saltlen : ASCON_SALT_LEN;
   uint8_t temp[ASCON_SALT_LEN+4];
@@ -281151,7 +281234,7 @@ static void ascon_pbkdf2_f(ascon_state_t* state,
   memset(temp, 0, ASCON_SALT_LEN);
   memcpy(temp, salt, asconSaltLen);
   STORE32_BE(temp+ASCON_SALT_LEN, blocknum);
   /* Copy initial state */
   for (j = 0; j < 5; ++j) state2.x[j] = state->x[j];
@@ -281187,6 +281270,7 @@ static void ascon_pbkdf2_f(ascon_state_t* state,
   sqlite3mcSecureZeroMemory(&state2, sizeof(ascon_state_t));
 }
+SQLITE_PRIVATE
 void ascon_pbkdf2(uint8_t* out, uint32_t outlen,
                   const uint8_t* password, uint32_t passwordlen,
                   const uint8_t* salt, uint32_t saltlen, uint32_t count)
@@ -281760,6 +281844,7 @@ sqlite3mcCodecInit(Codec* codec)
     memset(codec->m_page, 0, sizeof(codec->m_page));
     codec->m_pageSize = 0;
     codec->m_reserved = 0;
+    codec->m_lastError = SQLITE_OK;
     codec->m_hasKeySalt = 0;
     memset(codec->m_keySalt, 0, sizeof(codec->m_keySalt));
   }
@@ -281967,7 +282052,7 @@ sqlite3mcGetLegacyWriteCipher(Codec* codec)
 SQLITE_PRIVATE int
 sqlite3mcGetPageSizeReadCipher(Codec* codec)
 {
-  int pageSize = (codec->m_hasReadCipher  && codec->m_readCipher != NULL) ? globalCodecDescriptorTable[codec->m_readCipherType - 1].m_getPageSize(codec->m_readCipher) : 0;
+  int pageSize = (codec->m_hasReadCipher  && codec->m_readCipher != NULL) ? globalCodecDescriptorTable[codec->m_readCipherType - 1].m_getPageSize(codec->m_readCipher) : -1;
   return pageSize;
 }
@@ -282000,6 +282085,21 @@ sqlite3mcReservedEqual(Codec* codec)
   return (readReserved == writeReserved);
 }
+SQLITE_PRIVATE void
+sqlite3mcSetCodecLastError(Codec* codec, int error)
+{
+  if (codec)
+  {
+    codec->m_lastError = error;
+  }
+}
+SQLITE_PRIVATE int
+sqlite3mcGetCodecLastError(Codec* codec)
+{
+  return codec ? codec->m_lastError : SQLITE_OK;
+}
 SQLITE_PRIVATE unsigned char*
 sqlite3mcGetSaltWriteCipher(Codec* codec)
 {
@@ -282053,6 +282153,9 @@ sqlite3mcCodecCopy(Codec* codec, Codec* other)
   codec->m_bt = other->m_bt;
 #endif
   codec->m_btShared = other->m_btShared;
+  codec->m_lastError = SQLITE_OK;
   return rc;
 }
@@ -282163,7 +282266,7 @@ sqlite3mcConfigureSQLCipherVersion(sqlite3* db, int configDefault, int legacyVer
   static char* defNames[] = { "default:legacy_page_size", "default:kdf_iter", "default:hmac_use", "default:kdf_algorithm", "default:hmac_algorithm", NULL };
   static int versionParams[SQLCIPHER_VERSION_MAX][5] =
   {
-    { 1024,   4000, 0, SQLCIPHER_KDF_ALGORITHM_SHA1,   SQLCIPHER_HMAC_ALGORITHM_SHA1   },
+    { 1024,   4000, 0, SQLCIPHER_KDF_ALGORITHM_SHA1,   SQLCIPHER_HMAC_ALGORITHM_SHA1   },
     { 1024,   4000, 1, SQLCIPHER_KDF_ALGORITHM_SHA1,   SQLCIPHER_HMAC_ALGORITHM_SHA1   },
     { 1024,  64000, 1, SQLCIPHER_KDF_ALGORITHM_SHA1,   SQLCIPHER_HMAC_ALGORITHM_SHA1   },
     { 4096, 256000, 1, SQLCIPHER_KDF_ALGORITHM_SHA512, SQLCIPHER_HMAC_ALGORITHM_SHA512 }
@@ -282217,7 +282320,7 @@ SQLITE_PRIVATE void sqlite3mcConfigTable(sqlite3_context* context, int argc, sql
 SQLITE_PRIVATE CodecParameter* sqlite3mcGetCodecParams(sqlite3* db);
 /* Forward declaration */
-static unsigned char* sqlite3mcGetSaltWriteCipher(Codec* codec);
+SQLITE_PRIVATE unsigned char* sqlite3mcGetSaltWriteCipher(Codec* codec);
 SQLITE_PRIVATE void sqlite3mcCodecDataSql(sqlite3_context* context, int argc, sqlite3_value** argv);
 SQLITE_PRIVATE void sqlite3mcConfigParams(sqlite3_context* context, int argc, sqlite3_value** argv);
@@ -282410,6 +282513,21 @@ sqlite3mc_cipher_name(int cipherIndex)
   return cipherName;
 }
+static
+int checkParameterValue(const char* paramName, int value)
+{
+  int ok = 1;
+  if (sqlite3_stricmp(paramName, "legacy_page_size") == 0 && value > 0)
+  {
+    ok = value >= 512 && value <= SQLITE_MAX_PAGE_SIZE && ((value - 1) & value) == 0;
+  }
+  if (ok && sqlite3_stricmp(paramName, "plaintext_header_size") == 0 && value > 0)
+  {
+    ok = value % 16 == 0;
+  }
+  return ok;
+}
 SQLITE_API int
 sqlite3mc_config_cipher(sqlite3* db, const char* cipherName, const char* paramName, int newValue)
 {
@@ -282516,7 +282634,8 @@ sqlite3mc_config_cipher(sqlite3* db, const char* cipherName, const char* paramNa
       value = (hasDefaultPrefix) ? param->m_default : (hasMinPrefix) ? param->m_minValue : (hasMaxPrefix) ? param->m_maxValue : param->m_value;
       if (!hasMinPrefix && !hasMaxPrefix)
       {
-        if (newValue >= 0 && newValue >= param->m_minValue && newValue <= param->m_maxValue)
+        if (newValue >= 0 && newValue >= param->m_minValue && newValue <= param->m_maxValue &&
+            checkParameterValue(paramName, newValue))
         {
           if (hasDefaultPrefix)
           {
@@ -283769,7 +283888,7 @@ sqlite3_activate_see(const char *info)
 /*
 ** Free the encryption data structure associated with a pager instance.
-** (called from the modified code in pager.c)
+** (called from the modified code in pager.c)
 */
 SQLITE_PRIVATE void
 sqlite3mcCodecFree(void *pCodecArg)
@@ -283799,12 +283918,15 @@ mcReportCodecError(BtShared* pBt, int error)
   {
     pBt->pPager->eState = PAGER_ERROR;
   }
-  setGetterMethod(pBt->pPager);
   if (error == SQLITE_OK)
   {
     /* Clear cache to force reread of database after a new passphrase has been set */
     sqlite3PagerClearCache(pBt->pPager);
+    /* unlock required?
+    pager_unlock(pBt->pPager);
+    */
   }
+  setGetterMethod(pBt->pPager);
 }
 /*
@@ -283823,6 +283945,7 @@ sqlite3mcCodec(void* pCodecArg, void* data, Pgno nPageNum, int nMode)
   codec = (Codec*) pCodecArg;
   if (!sqlite3mcIsEncrypted(codec))
   {
+    sqlite3mcSetCodecLastError(codec, rc);
     return data;
   }
@@ -283836,7 +283959,11 @@ sqlite3mcCodec(void* pCodecArg, void* data, Pgno nPageNum, int nMode)
       if (sqlite3mcHasReadCipher(codec))
       {
         rc = sqlite3mcDecrypt(codec, nPageNum, (unsigned char*) data, pageSize);
-        if (rc != SQLITE_OK) mcReportCodecError(sqlite3mcGetBtShared(codec), rc);
+        if (rc != SQLITE_OK)
+        {
+          mcReportCodecError(sqlite3mcGetBtShared(codec), rc);
+          memset(data, 0, pageSize);
+        }
       }
       break;
@@ -283870,6 +283997,7 @@ sqlite3mcCodec(void* pCodecArg, void* data, Pgno nPageNum, int nMode)
       }
       break;
   }
+  sqlite3mcSetCodecLastError(codec, rc);
   return data;
 }
@@ -283879,6 +284007,9 @@ sqlite3mcGetMainCodec(sqlite3* db);
 SQLITE_PRIVATE void
 sqlite3mcSetCodec(sqlite3* db, const char* zDbName, const char* zFileName, Codec* codec);
+SQLITE_PRIVATE int
+sqlite3mcIsEncryptionSupported(sqlite3* db, const char* zDbName);
 static int
 mcAdjustBtree(Btree* pBt, int nPageSize, int nReserved, int isLegacy)
 {
@@ -283894,11 +284025,12 @@ mcAdjustBtree(Btree* pBt, int nPageSize, int nReserved, int isLegacy)
   /* Adjust the page size and the reserved area */
   if (pager->pageSize != pagesize || pager->nReserve != nReserved)
   {
+    int reserved = (nReserved >= 0) ? nReserved : 0;
     if (isLegacy != 0)
     {
       pBt->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
     }
-    rc = sqlite3BtreeSetPageSize(pBt, pagesize, nReserved, 0);
+    rc = sqlite3BtreeSetPageSize(pBt, pagesize, reserved, 0);
   }
   return rc;
 }
@@ -284036,6 +284168,11 @@ SQLITE_API int
 sqlite3_key_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
 {
   int rc = SQLITE_ERROR;
+  if (!sqlite3mcIsEncryptionSupported(db, zDbName))
+  {
+    sqlite3ErrorWithMsg(db, rc, "Setting key failed. Encryption is not supported by the VFS.");
+    return rc;
+  }
   if (zKey != NULL && nKey < 0)
   {
     /* Key is zero-terminated string */
@@ -284088,7 +284225,15 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
   int nReserved;
   Pager* pPager;
   Codec* codec;
+  int codecAllocated = 0;
   int rc = SQLITE_ERROR;
+  char* err = NULL;
+  if (!sqlite3mcIsEncryptionSupported(db, zDbName))
+  {
+    sqlite3ErrorWithMsg(db, rc, "Rekeying failed. Encryption is not supported by the VFS.");
+    return rc;
+  }
   if (zKey != NULL && nKey < 0)
   {
     /* Key is zero-terminated string */
@@ -284121,10 +284266,10 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
     sqlite3ErrorWithMsg(db, rc, "Rekeying is not supported in WAL journal mode.");
     return rc;
   }
   if ((zKey == NULL || nKey == 0) && (codec == NULL || !sqlite3mcIsEncrypted(codec)))
   {
-    /* Database not encrypted and key not specified, therefore do nothing	*/
+    /* Database not encrypted and key not specified, therefore do nothing */
     return SQLITE_OK;
   }
@@ -284132,9 +284277,10 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
   if (codec == NULL || !sqlite3mcIsEncrypted(codec))
   {
-    /* Database not encrypted, but key specified, therefore encrypt database	*/
+    /* Database not encrypted, but key specified, therefore encrypt database */
     if (codec == NULL)
     {
+      codecAllocated = 1;
       codec = (Codec*) sqlite3_malloc(sizeof(Codec));
       rc = (codec != NULL) ? sqlite3mcCodecInit(codec) : SQLITE_NOMEM;
     }
@@ -284158,14 +284304,9 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
         if (nReserved != nReservedWriteCipher)
         {
           /* Use VACUUM to change the number of reserved bytes */
-          char* err = NULL;
           sqlite3mcSetReadReserved(codec, nReserved);
           sqlite3mcSetWriteReserved(codec, nReservedWriteCipher);
           rc = sqlite3mcRunVacuumForRekey(&err, db, dbIndex, NULL, nReservedWriteCipher);
-          if (rc != SQLITE_OK && err != NULL)
-          {
-            sqlite3ErrorWithMsg(db, rc, err);
-          }
           goto leave_rekey;
         }
       }
@@ -284173,12 +284314,17 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
       {
         /* Pagesize cannot be changed for an encrypted database */
         rc = SQLITE_ERROR;
-        sqlite3ErrorWithMsg(db, rc, "Rekeying failed. Pagesize cannot be changed for an encrypted database.");
+        err = "Rekeying failed. Pagesize cannot be changed for an encrypted database.";
         goto leave_rekey;
       }
     }
     else
     {
+      sqlite3_mutex_leave(db->mutex);
+      if (codecAllocated)
+      {
+        sqlite3mcCodecFree(codec);
+      }
       return rc;
     }
   }
@@ -284194,10 +284340,6 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
       sqlite3mcSetReadReserved(codec, nReserved);
       sqlite3mcSetWriteReserved(codec, 0);
       rc = sqlite3mcRunVacuumForRekey(&err, db, dbIndex, NULL, 0);
-      if (rc != SQLITE_OK && err != NULL)
-      {
-        sqlite3ErrorWithMsg(db, rc, err);
-      }
       goto leave_rekey;
     }
   }
@@ -284219,10 +284361,6 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
           sqlite3mcSetReadReserved(codec, nReserved);
           sqlite3mcSetWriteReserved(codec, nReservedWriteCipher);
           rc = sqlite3mcRunVacuumForRekey(&err, db, dbIndex, NULL, nReservedWriteCipher);
-          if (rc != SQLITE_OK && err != NULL)
-          {
-            sqlite3ErrorWithMsg(db, rc, err);
-          }
           goto leave_rekey;
         }
       }
@@ -284230,14 +284368,14 @@ sqlite3_rekey_v2(sqlite3* db, const char* zDbName, const void* zKey, int nKey)
       {
         /* Pagesize cannot be changed for an encrypted database */
         rc = SQLITE_ERROR;
-        sqlite3ErrorWithMsg(db, rc, "Rekeying failed. Pagesize cannot be changed for an encrypted database.");
+        err = "Rekeying failed. Pagesize cannot be changed for an encrypted database.";
         goto leave_rekey;
       }
     }
     else
     {
       /* Setup of write cipher failed */
-      sqlite3ErrorWithMsg(db, rc, "Rekeying failed. Setup of write cipher failed.");
+      err = "Rekeying failed. Setup of write cipher failed.";
       goto leave_rekey;
     }
   }
@@ -284288,8 +284426,15 @@ leave_rekey:
     /* Set read key equal to write key if necessary */
     if (sqlite3mcHasWriteCipher(codec))
     {
+      /* Set Read cipher equal to Write cipher */
       sqlite3mcCopyCipher(codec, 0);
       sqlite3mcSetHasReadCipher(codec, 1);
+      /* Enforce page size and number of reserved bytes per page */
+      int pageSize = sqlite3mcGetPageSizeWriteCipher(codec);
+      int reserved = sqlite3mcGetReservedWriteCipher(codec);
+      mcAdjustBtree(pBt, pageSize, reserved, sqlite3mcGetLegacyWriteCipher(codec));
+      sqlite3mcCodecSizeChange(codec, pageSize, reserved);
     }
     else
     {
@@ -284317,6 +284462,10 @@ leave_rekey:
     /* Remove codec for unencrypted database */
     sqlite3mcSetCodec(db, zDbName, dbFileName, NULL);
   }
+  if (rc != SQLITE_OK && err != NULL)
+  {
+    sqlite3ErrorWithMsg(db, rc, err);
+  }
   return rc;
 }
@@ -284588,7 +284737,7 @@ Usage instructions for the sqlite3 program:
   security measure; see "Security Considerations" in
   http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions.
   If the sqlite3 program and library are built this
-  way, you cannot use these functions from the program, you
+  way, you cannot use these functions from the program, you
   must write your own program using the sqlite3 API, and call
   sqlite3_enable_load_extension as described above, or else
   rebuilt the sqlite3 program to allow loadable extensions.
@@ -284659,7 +284808,7 @@ Original code 2006 June 05 by relicoder.
 #define HAVE_ISBLANK 1
 #endif
 #define SQLITE_SOUNDEX 1
-#define HAVE_TRIM 1		/* LMH 2007-03-25 if sqlite has trim functions */
+#define HAVE_TRIM 1    /* LMH 2007-03-25 if sqlite has trim functions */
 #ifdef COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE
 /* #include "sqlite3ext.h" */
@@ -284678,7 +284827,7 @@ Original code 2006 June 05 by relicoder.
 ** 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
+** as extensions by SQLite should #include this file instead of
 ** sqlite3.h.
 */
 #ifndef SQLITE3EXT_H
@@ -285369,14 +285518,14 @@ typedef int (*sqlite3_loadext_entry)(
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
-  /* This case when the file really is being compiled as a loadable
+  /* This case when the file really is being compiled as a loadable
   ** extension */
 # define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
 # define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
 # define SQLITE_EXTENSION_INIT3     \
     extern const sqlite3_api_routines *sqlite3_api;
 #else
-  /* This case when the file is being statically linked into the
+  /* This case when the file is being statically linked into the
   ** application */
 # define SQLITE_EXTENSION_INIT1     /*no-op*/
 # define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
@@ -285397,7 +285546,7 @@ SQLITE_EXTENSION_INIT1
 #include <math.h>
 #include <string.h>
 #include <stdio.h>
-#include <errno.h>		/* LMH 2007-03-25 */
+#include <errno.h>    /* LMH 2007-03-25 */
 #include <stdlib.h>
 #include <assert.h>
@@ -285577,7 +285726,7 @@ static int sqlite3ReadUtf8(const unsigned char *z){
 ** 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
+** number of unicode characters in the first nByte of pZ (or up to
 ** the first 0x00, whichever comes first).
 */
 static int sqlite3Utf8CharLen(const char *z, int nByte){
@@ -285612,7 +285761,7 @@ static int sqlite3Utf8CharLen(const char *z, int nByte){
 **
 ** Could have been implemented using pointers to functions but this way it's inline
 ** and thus more efficient. Lower * ranking though...
-**
+**
 ** Parameters:
 ** name:      function name to de defined (eg: sinFunc)
 ** function:  function defined in math.h to wrap (eg: sin)
@@ -285658,7 +285807,7 @@ GEN_MATH_WRAP_DOUBLE_1(atanFunc, atan)
 /*
 ** Many of systems don't have inverse hyperbolic trig functions so this will emulate
-** them on those systems in terms of log and sqrt (formulas are too trivial to demand
+** them on those systems in terms of log and sqrt (formulas are too trivial to demand
 ** written proof here)
 */
@@ -285830,7 +285979,7 @@ static void squareFunc(sqlite3_context *context, int argc, sqlite3_value **argv)
 ** (see sqrt just before this). Here the result is always double
 */
 /* LMH 2007-03-25 Changed to use errno; no pre-checking for errors.  Also removes
-  but that was present in the pre-checking that called sqlite3_result_error on
+  but that was present in the pre-checking that called sqlite3_result_error on
   a non-positive first argument, which is not always an error. */
 static void powerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   double r1 = 0.0;
@@ -285838,9 +285987,9 @@ static void powerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   double val;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     r1 = sqlite3_value_double(argv[0]);
     r2 = sqlite3_value_double(argv[1]);
@@ -285848,9 +285997,9 @@ static void powerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
     val = pow(r1,r2);
     if (errno == 0) {
       sqlite3_result_double(context, val);
-    } else {
+    } else {
       sqlite3_result_error(context, strerror(errno), errno);
-    }
+    }
   }
 }
@@ -285864,9 +286013,9 @@ static void atn2Func(sqlite3_context *context, int argc, sqlite3_value **argv){
   double r2 = 0.0;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     r1 = sqlite3_value_double(argv[0]);
     r2 = sqlite3_value_double(argv[1]);
@@ -285963,14 +286112,14 @@ static void floorFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
 /*
-** Given a string (s) in the first argument and an integer (n) in the second returns the
+** Given a string (s) in the first argument and an integer (n) in the second returns the
 ** string that constains s contatenated n times
 */
 static void replicateFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   unsigned char *z;        /* input string */
   unsigned char *zo;       /* result string */
   i64 iCount;              /* times to repeat */
-  i64 nLen;                /* length of the input string (no multibyte considerations) */
+  i64 nLen;                /* length of the input string (no multibyte considerations) */
   i64 nTLen;               /* length of the result string (no multibyte considerations) */
   i64 i=0;
@@ -286005,7 +286154,7 @@ static void replicateFunc(sqlite3_context *context, int argc, sqlite3_value **ar
   }
 }
-/*
+/*
 ** Some systems (win32 among others) don't have an isblank function, this will emulate it.
 ** This function is not UFT-8 safe since it only analyses a byte character.
 */
@@ -286070,9 +286219,9 @@ static void padlFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   char *zt;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     zi = (char *)sqlite3_value_text(argv[0]);
     ilen = sqlite3_value_int64(argv[1]);
@@ -286124,9 +286273,9 @@ static void padrFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   char *zt;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     zi = (char *)sqlite3_value_text(argv[0]);
     ilen = sqlite3_value_int64(argv[1]);
@@ -286179,9 +286328,9 @@ static void padcFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   char *zt;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     zi = (char *)sqlite3_value_text(argv[0]);
     ilen = sqlite3_value_int64(argv[1]);
@@ -286238,17 +286387,17 @@ static void strfilterFunc(sqlite3_context *context, int argc, sqlite3_value **ar
   int c2 = 0;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
-    sqlite3_result_null(context);
+    sqlite3_result_null(context);
   }else{
     zi1 = (char *)sqlite3_value_text(argv[0]);
     zi2 = (char *)sqlite3_value_text(argv[1]);
-    /*
-    ** maybe I could allocate less, but that would imply 2 passes, rather waste
+    /*
+    ** maybe I could allocate less, but that would imply 2 passes, rather waste
     ** (possibly) some memory
     */
-    zo = sqlite3_malloc((int) (strlen(zi1)+1));
+    zo = sqlite3_malloc((int) (strlen(zi1)+1));
     if (!zo){
       sqlite3_result_error_nomem(context);
       return;
@@ -286292,11 +286441,11 @@ static int _substr(const char* z1, const char* z2, int s, const char** p){
   if( '\0'==*z1 ){
     return -1;
   }
   while( (sqliteCharVal((unsigned char *)z2) != 0) && (c++)<s){
     sqliteNextChar(z2);
   }
   c = 0;
   while( (sqliteCharVal((unsigned char *)z2)) != 0 ){
     zt1 = z1;
@@ -286311,9 +286460,9 @@ static int _substr(const char* z1, const char* z2, int s, const char** p){
     if( c1 == 0 ){
       rVal = c;
-      break;
+      break;
     }
     sqliteNextChar(z2);
     ++c;
   }
@@ -286394,7 +286543,7 @@ static void leftFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   }
   strncpy((char*) rz, (char*) z, zt-z);
   *(rz+cc) = '\0';
-  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
   sqlite3_free(rz);
 }
@@ -286433,7 +286582,7 @@ static void rightFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   cc=c-l;
   if(cc<0)
     cc=0;
   while( cc-- > 0 ){
     sqliteNextChar(zt);
   }
@@ -286444,7 +286593,7 @@ static void rightFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
     return;
   }
   strcpy((char*) rz, (char*) (zt));
-  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
   sqlite3_free(rz);
 }
@@ -286482,7 +286631,7 @@ static void ltrimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
     return;
   }
   z = sqlite3_value_text(argv[0]);
-  sqlite3_result_text(context, ltrim(z), -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, ltrim(z), -1, SQLITE_TRANSIENT);
 }
 /*
@@ -286723,7 +286872,7 @@ static void modeStep(sqlite3_context *context, int argc, sqlite3_value **argv){
   if( type == SQLITE_NULL)
     return;
   p = sqlite3_aggregate_context(context, sizeof(*p));
   if( 0==(p->m) ){
@@ -286762,33 +286911,33 @@ static void modeIterate(void* e, i64 c, void* pp){
   i64 ei;
   double ed;
   ModeCtx *p = (ModeCtx*)pp;
   if( 0==p->is_double ){
     ei = *(int*)(e);
-	if( p->mcnt==c ){
+    if( p->mcnt==c ){
       ++p->mn;
     }else if( p->mcnt<c ){
       p->riM = ei;
       p->mcnt = c;
-	  p->mn=1;
+      p->mn=1;
     }
   }else{
     ed = *(double*)(e);
-	if( p->mcnt==c ){
+    if( p->mcnt==c ){
       ++p->mn;
     }else if(p->mcnt<c){
       p->rdM = ed;
       p->mcnt = c;
-	  p->mn=1;
+      p->mn=1;
     }
   }
 }
 /*
 **  Auxiliary function that iterates all elements in a map and finds the median
-**  (the value such that the number of elements smaller is equal the the number of
+**  (the value such that the number of elements smaller is equal the the number of
 **  elements larger)
 */
 static void medianIterate(void* e, i64 c, void* pp){
@@ -286859,9 +287008,9 @@ static void _medianFinalize(sqlite3_context *context){
     if( 0==p->is_double )
       if( 1==p->mn )
-      	sqlite3_result_int64(context, p->riM);
+        sqlite3_result_int64(context, p->riM);
       else
-      	sqlite3_result_double(context, p->riM*1.0/p->mn);
+        sqlite3_result_double(context, p->riM*1.0/p->mn);
     else
       sqlite3_result_double(context, p->rdM/p->mn);
   }
@@ -286981,12 +287130,12 @@ static void differenceFunc(sqlite3_context *context, int argc, sqlite3_value **a
   const u8 *zIn2;
   assert( argc==2 );
   if( sqlite3_value_type(argv[0])==SQLITE_NULL || sqlite3_value_type(argv[1])==SQLITE_NULL ){
     sqlite3_result_null(context);
     return;
   }
   zIn1 = (u8*)sqlite3_value_text(argv[0]);
   zIn2 = (u8*)sqlite3_value_text(argv[1]);
@@ -287123,7 +287272,7 @@ int RegisterExtensionFunctions(sqlite3 *db){
         aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
 #if 0
     if( aFuncs[i].needCollSeq ){
-      struct FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName,
+      struct 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;
@@ -287140,7 +287289,7 @@ int RegisterExtensionFunctions(sqlite3 *db){
     }
     /* sqlite3CreateFunc */
     /* LMH no error checking */
-    sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8,
+    sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8,
         pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
 #if 0
     if( aAggs[i].needCollSeq ){
@@ -287460,7 +287609,7 @@ static int csv_getc(CsvReader *p){
   return ((unsigned char*)p->zIn)[p->iIn++];
 }
-/* Increase the size of p->z and append character c to the end.
+/* Increase the size of p->z and append character c to the end.
 ** Return 0 on success and non-zero if there is an OOM error */
 static CSV_NOINLINE int csv_resize_and_append(CsvReader *p, char c){
   char *zNew;
@@ -287579,9 +287728,9 @@ static char *csv_read_one_field(CsvReader *p){
 /* Forward references to the various virtual table methods implemented
 ** in this file. */
-static int csvtabCreate(sqlite3*, void*, int, const char*const*,
+static int csvtabCreate(sqlite3*, void*, int, const char*const*,
                            sqlite3_vtab**,char**);
-static int csvtabConnect(sqlite3*, void*, int, const char*const*,
+static int csvtabConnect(sqlite3*, void*, int, const char*const*,
                            sqlite3_vtab**,char**);
 static int csvtabBestIndex(sqlite3_vtab*,sqlite3_index_info*);
 static int csvtabDisconnect(sqlite3_vtab*);
@@ -287766,7 +287915,7 @@ static int csv_boolean_parameter(
 **    columns=N                  Assume the CSV file contains N columns.
 **
 ** Only available if compiled with SQLITE_TEST:
-**
+**
 **    testflags=N                Bitmask of test flags.  Optional
 **
 ** If schema= is omitted, then the columns are named "c0", "c1", "c2",
@@ -287793,7 +287942,7 @@ static int csvtabConnect(
   CsvReader sRdr;            /* A CSV file reader used to store an error
                              ** message and/or to count the number of columns */
   static const char *azParam[] = {
-     "filename", "data", "schema",
+     "filename", "data", "schema",
   };
   char *azPValue[3];         /* Parameter values */
 # define CSV_FILENAME (azPValue[0])
@@ -288095,7 +288244,7 @@ static int csvtabEof(sqlite3_vtab_cursor *cur){
 ** the beginning.
 */
 static int csvtabFilter(
-  sqlite3_vtab_cursor *pVtabCursor,
+  sqlite3_vtab_cursor *pVtabCursor,
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
@@ -288151,7 +288300,7 @@ static int csvtabBestIndex(
       unsigned char op;
       if( pIdxInfo->aConstraint[i].usable==0 ) continue;
       op = pIdxInfo->aConstraint[i].op;
-      if( op==SQLITE_INDEX_CONSTRAINT_EQ
+      if( op==SQLITE_INDEX_CONSTRAINT_EQ
        || op==SQLITE_INDEX_CONSTRAINT_LIKE
        || op==SQLITE_INDEX_CONSTRAINT_GLOB
       ){
@@ -288238,14 +288387,14 @@ static sqlite3_module CsvModuleFauxWrite = {
 #ifdef _WIN32
 __declspec(dllexport)
 #endif
-/*
+/*
 ** This routine is called when the extension is loaded.  The new
 ** CSV virtual table module is registered with the calling database
 ** connection.
 */
 int sqlite3_csv_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -290826,7 +290975,7 @@ static unsigned char *SHA3Final(SHA3Context *p){
 ** Implementation of the sha3(X,SIZE) function.
 **
 ** Return a BLOB which is the SIZE-bit SHA3 hash of X.  The default
-** size is 256.  If X is a BLOB, it is hashed as is.
+** size is 256.  If X is a BLOB, it is hashed as is.
 ** For all other non-NULL types of input, X is converted into a UTF-8 string
 ** and the string is hashed without the trailing 0x00 terminator.  The hash
 ** of a NULL value is NULL.
@@ -291117,7 +291266,7 @@ int sqlite3_carray_init(sqlite3* db, char** pzErrMsg, const sqlite3_api_routines
 **       ctype TEXT HIDDEN
 **     );
 **
-** If the hidden columns "pointer" and "count" are unconstrained, then
+** If the hidden columns "pointer" and "count" are unconstrained, then
 ** the virtual table has no rows.  Otherwise, the virtual table interprets
 ** the integer value of "pointer" as a pointer to the array and "count"
 ** as the number of elements in the array.  The virtual table steps through
@@ -291136,7 +291285,7 @@ SQLITE_EXTENSION_INIT1
 #else
 # include <sys/uio.h>
 #endif
 /* Allowed values for the mFlags parameter to sqlite3_carray_bind().
 ** Must exactly match the definitions in carray.h.
 */
@@ -291343,7 +291492,7 @@ static int carrayEof(sqlite3_vtab_cursor *cur){
 ** to the first row of output.
 */
 static int carrayFilter(
-  sqlite3_vtab_cursor *pVtabCursor,
+  sqlite3_vtab_cursor *pVtabCursor,
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
@@ -291457,7 +291606,7 @@ static int carrayBestIndex(
 }
 /*
-** This following structure defines all the methods for the
+** This following structure defines all the methods for the
 ** carray virtual table.
 */
 static sqlite3_module carrayModule = {
@@ -291540,7 +291689,7 @@ SQLITE_API int sqlite3_carray_bind(
       for(i=0; i<nData; i++){
         sz += ((struct iovec*)aData)[i].iov_len;
       }
-    }
+    }
     pNew->aData = sqlite3_malloc64( sz );
     if( pNew->aData==0 ){
       sqlite3_free(pNew);
@@ -291614,8 +291763,8 @@ static void inttoptrFunc(
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
 SQLITE_API int sqlite3_carray_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
@@ -292088,8 +292237,8 @@ INT closedir(
 **            directory, NULL.
 **
 **   If a non-NULL value is specified for the optional $dir parameter and
-**   $path is a relative path, then $path is interpreted relative to $dir.
-**   And the paths returned in the "name" column of the table are also
+**   $path is a relative path, then $path is interpreted relative to $dir.
+**   And the paths returned in the "name" column of the table are also
 **   relative to directory $dir.
 **
 ** Notes on building this extension for Windows:
@@ -292146,7 +292295,7 @@ SQLITE_EXTENSION_INIT1
 /*
-** Set the result stored by context ctx to a blob containing the
+** Set the result stored by context ctx to a blob containing the
 ** contents of file zName.  Or, leave the result unchanged (NULL)
 ** if the file does not exist or is unreadable.
 **
@@ -292379,7 +292528,7 @@ static int makeDirectory(
 }
 /*
-** This function does the work for the writefile() UDF. Refer to
+** This function does the work for the writefile() UDF. Refer to
 ** header comments at the top of this file for details.
 */
 static int writeFile(
@@ -292481,10 +292630,10 @@ static int writeFile(
       return 1;
     }
 #else
-    /* Legacy unix.
+    /* Legacy unix.
     **
     ** Do not use utimes() on a symbolic link - it sees through the link and
-    ** modifies the timestamps on the target. Or fails if the target does
+    ** modifies the timestamps on the target. Or fails if the target does
     ** not exist.  */
     if( 0==S_ISLNK(mode) ){
       struct timeval times[2];
@@ -292502,7 +292651,7 @@ static int writeFile(
 }
 /*
-** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function.
+** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function.
 ** Refer to header comments at the top of this file for details.
 */
 static void writefileFunc(
@@ -292516,7 +292665,7 @@ static void writefileFunc(
   sqlite3_int64 mtime = -1;
   if( argc<2 || argc>4 ){
-    sqlite3_result_error(context,
+    sqlite3_result_error(context,
         "wrong number of arguments to function writefile()", -1
     );
     return;
@@ -292586,7 +292735,7 @@ static void lsModeFunc(
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-/*
+/*
 ** Cursor type for recursively iterating through a directory structure.
 */
 typedef struct fsdir_cursor fsdir_cursor;
@@ -292734,7 +292883,7 @@ static int fsdirNext(sqlite3_vtab_cursor *cur){
     }
     pCur->iLvl = iNew;
     pLvl = &pCur->aLvl[iNew];
     pLvl->zDir = pCur->zPath;
     pCur->zPath = 0;
     pLvl->pDir = opendir(pLvl->zDir);
@@ -292865,7 +293014,7 @@ static int fsdirEof(sqlite3_vtab_cursor *cur){
 ** idxNum==2   Both PATH and DIR supplied
 */
 static int fsdirFilter(
-  sqlite3_vtab_cursor *cur,
+  sqlite3_vtab_cursor *cur,
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
@@ -292954,7 +293103,7 @@ static int fsdirBestIndex(
         }
         break;
       }
-    }
+    }
   }
   if( seenPath || seenDir ){
     /* If input parameters are unusable, disallow this plan */
@@ -293026,14 +293175,14 @@ static int fsdirRegister(sqlite3 *db){
 __declspec(dllexport)
 #endif
 int sqlite3_fileio_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
   SQLITE_EXTENSION_INIT2(pApi);
   (void)pzErrMsg;  /* Unused parameter */
-  rc = sqlite3_create_function(db, "readfile", 1,
+  rc = sqlite3_create_function(db, "readfile", 1,
                                SQLITE_UTF8|SQLITE_DIRECTONLY, 0,
                                readfileFunc, 0, 0);
   if( rc==SQLITE_OK ){
@@ -293637,7 +293786,7 @@ static int seriesBestIndex(
     return SQLITE_CONSTRAINT;
   }
   if( (idxNum & 0x03)==0x03 ){
-    /* Both start= and stop= boundaries are available.  This is the
+    /* Both start= and stop= boundaries are available.  This is the
     ** the preferred case */
     pIdxInfo->estimatedCost = (double)(2 - ((idxNum&4)!=0));
     pIdxInfo->estimatedRows = 1000;
@@ -293663,7 +293812,7 @@ static int seriesBestIndex(
 }
 /*
-** This following structure defines all the methods for the
+** This following structure defines all the methods for the
 ** generate_series virtual table.
 */
 static sqlite3_module seriesModule = {
@@ -293700,8 +293849,8 @@ static sqlite3_module seriesModule = {
 __declspec(dllexport)
 #endif
 int sqlite3_series_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
@@ -293954,7 +294103,7 @@ int sqlite3_uuid_init(
   rc = sqlite3_create_function(db, "uuid", 0, SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
                                sqlite3UuidFunc, 0, 0);
   if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "uuid_str", 1,
+    rc = sqlite3_create_function(db, "uuid_str", 1,
                        SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                        0, sqlite3UuidStrFunc, 0, 0);
   }
@@ -294152,7 +294301,7 @@ static void re_add_state(ReStateSet *pSet, int newState){
 /* Extract the next unicode character from *pzIn and return it.  Advance
 ** *pzIn to the first byte past the end of the character returned.  To
-** be clear:  this routine converts utf8 to unicode.  This routine is
+** be clear:  this routine converts utf8 to unicode.  This routine is
 ** optimized for the common case where the next character is a single byte.
 */
 static unsigned re_next_char(ReInput *p){
@@ -294223,7 +294372,7 @@ static int re_match(ReCompiled *pRe, const unsigned char *zIn, int nIn){
   /* Look for the initial prefix match, if there is one. */
   if( pRe->nInit ){
     unsigned char x = pRe->zInit[0];
-    while( in.i+pRe->nInit<=in.mx
+    while( in.i+pRe->nInit<=in.mx
      && (zIn[in.i]!=x ||
          strncmp((const char*)zIn+in.i, (const char*)pRe->zInit, pRe->nInit)!=0)
     ){
@@ -294693,7 +294842,7 @@ static const char *re_compile(ReCompiled **ppRe, const char *zIn, int noCase){
   /* The following is a performance optimization.  If the regex begins with
   ** ".*" (if the input regex lacks an initial "^") and afterwards there are
   ** one or more matching characters, enter those matching characters into
-  ** zInit[].  The re_match() routine can then search ahead in the input
+  ** zInit[].  The re_match() routine can then search ahead in the input
   ** string looking for the initial match without having to run the whole
   ** regex engine over the string.  Do not worry about trying to match
   ** unicode characters beyond plane 0 - those are very rare and this is
@@ -294836,14 +294985,14 @@ re_bytecode_func_err:
 __declspec(dllexport)
 #endif
 int sqlite3_regexp_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
   SQLITE_EXTENSION_INIT2(pApi);
   (void)pzErrMsg;  /* Unused */
-  rc = sqlite3_create_function(db, "regexp", 2,
+  rc = sqlite3_create_function(db, "regexp", 2,
                             SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
                             0, re_sql_func, 0, 0);
   if( rc==SQLITE_OK ){
@@ -294989,7 +295138,7 @@ int sqlite3_regexp_init(
-/* Defines to completely disable specific portions of miniz.c:
+/* Defines to completely disable specific portions of miniz.c:
    If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl. */
 /* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O. */
@@ -295012,7 +295161,7 @@ int sqlite3_regexp_init(
 /* Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to prevent conflicts against stock zlib. */
 /*#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
-/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
+/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc.
    Note if MINIZ_NO_MALLOC is defined then the user must always provide custom user alloc/free/realloc
    callbacks to the zlib and archive API's, and a few stand-alone helper API's which don't provide custom user
    functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. */
@@ -295448,7 +295597,7 @@ extern MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, si
 #ifdef __cplusplus
 }
 #endif
 #ifdef __cplusplus
@@ -295638,7 +295787,7 @@ MINIZ_EXPORT void tdefl_compressor_free(tdefl_compressor *pComp);
 #ifdef __cplusplus
 }
 #endif
 /* ------------------- Low-level Decompression API Definitions */
@@ -295782,7 +295931,7 @@ struct tinfl_decompressor_tag
 #ifdef __cplusplus
 }
 #endif
@@ -296100,13 +296249,13 @@ MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, c
 #if 0
 /* TODO */
-	typedef void *mz_zip_streaming_extract_state_ptr;
-	mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-	uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
-	size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
-	mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+  typedef void *mz_zip_streaming_extract_state_ptr;
+  mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
+  uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+  uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+  mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
+  size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
+  mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
 #endif
 /* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
@@ -296168,8 +296317,8 @@ MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const cha
 /* Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. */
 /* File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.*/
 MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 max_size,
-	const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-	const char *user_extra_data_central, mz_uint user_extra_data_central_len);
+    const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
+    const char *user_extra_data_central, mz_uint user_extra_data_central_len);
 #ifndef MINIZ_NO_STDIO
@@ -297604,15 +297753,15 @@ static int tdefl_flush_block(tdefl_compressor *d, int flush)
 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
 static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8* p)
 {
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
+    mz_uint16 ret;
+    memcpy(&ret, p, sizeof(mz_uint16));
+    return ret;
 }
 static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16* p)
 {
-	mz_uint16 ret;
-	memcpy(&ret, p, sizeof(mz_uint16));
-	return ret;
+    mz_uint16 ret;
+    memcpy(&ret, p, sizeof(mz_uint16));
+    return ret;
 }
 #else
 #define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p)
@@ -297720,9 +297869,9 @@ static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahe
 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
 static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8* p)
 {
-	mz_uint32 ret;
-	memcpy(&ret, p, sizeof(mz_uint32));
-	return ret;
+    mz_uint32 ret;
+    memcpy(&ret, p, sizeof(mz_uint32));
+    return ret;
 }
 #else
 #define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p)
@@ -297797,7 +297946,7 @@ static mz_bool tdefl_compress_fast(tdefl_compressor *d)
                     pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
-					memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist));
+                    memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist));
 #else
                     *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
 #endif
@@ -298966,7 +299115,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
                     do
                     {
 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
-						memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2);
+                        memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2);
 #else
                         ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
                         ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
@@ -298993,7 +299142,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
                     pOut_buf_cur[2] = pSrc[2];
                     pOut_buf_cur += 3;
                     pSrc += 3;
-					counter -= 3;
+                    counter -= 3;
                 }
                 if (counter > 0)
                 {
@@ -299931,47 +300080,47 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flag
                 if (extra_size_remaining)
                 {
-					const mz_uint8 *pExtra_data;
-					void* buf = NULL;
-					if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n)
-					{
-						buf = MZ_MALLOC(ext_data_size);
-						if(buf==NULL)
-							return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
-						if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size)
-						{
-							MZ_FREE(buf);
-							return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
-						}
-						pExtra_data = (mz_uint8*)buf;
-					}
-					else
-					{
-						pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
-					}
+                    const mz_uint8 *pExtra_data;
+                    void* buf = NULL;
+                    if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n)
+                    {
+                        buf = MZ_MALLOC(ext_data_size);
+                        if(buf==NULL)
+                            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
+                        if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size)
+                        {
+                            MZ_FREE(buf);
+                            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
+                        }
+                        pExtra_data = (mz_uint8*)buf;
+                    }
+                    else
+                    {
+                        pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
+                    }
                     do
                     {
                         mz_uint32 field_id;
                         mz_uint32 field_data_size;
-						if (extra_size_remaining < (sizeof(mz_uint16) * 2))
-						{
-							MZ_FREE(buf);
-							return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-						}
+                        if (extra_size_remaining < (sizeof(mz_uint16) * 2))
+                        {
+                            MZ_FREE(buf);
+                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+                        }
                         field_id = MZ_READ_LE16(pExtra_data);
                         field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
-						if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
-						{
-							MZ_FREE(buf);
-							return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
-						}
+                        if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
+                        {
+                            MZ_FREE(buf);
+                            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+                        }
                         if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
                         {
@@ -299985,7 +300134,7 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flag
                         extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
                     } while (extra_size_remaining);
-					MZ_FREE(buf);
+                    MZ_FREE(buf);
                 }
             }
@@ -300190,7 +300339,7 @@ mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename,
     if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
     {
-	MZ_FCLOSE(pFile);
+        MZ_FCLOSE(pFile);
         return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
     }
@@ -302402,16 +302551,16 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
     }
 #endif /* #ifndef MINIZ_NO_TIME */
-	if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
-	{
-		uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
-		uncomp_size = buf_size;
-		if (uncomp_size <= 3)
-		{
-			level = 0;
-			store_data_uncompressed = MZ_TRUE;
-		}
-	}
+    if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
+    {
+        uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
+        uncomp_size = buf_size;
+        if (uncomp_size <= 3)
+        {
+            level = 0;
+            store_data_uncompressed = MZ_TRUE;
+        }
+    }
     archive_name_size = strlen(pArchive_name);
     if (archive_name_size > MZ_UINT16_MAX)
@@ -302427,9 +302576,9 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
     {
         /* Bail early if the archive would obviously become too large */
         if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size
-			+ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
-			pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
+            + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
+            pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
+            + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
         {
             pState->m_zip64 = MZ_TRUE;
             /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
@@ -302528,13 +302677,13 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
         cur_archive_file_ofs += archive_name_size;
     }
-	if (user_extra_data_len > 0)
-	{
-		if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
-			return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
+    if (user_extra_data_len > 0)
+    {
+        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
+            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
-		cur_archive_file_ofs += user_extra_data_len;
-	}
+        cur_archive_file_ofs += user_extra_data_len;
+    }
     if (store_data_uncompressed)
     {
@@ -302686,8 +302835,8 @@ mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pA
     {
         /* Bail early if the archive would obviously become too large */
         if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
-			+ archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
-			+ MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
+            + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
+            + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
         {
             pState->m_zip64 = MZ_TRUE;
             /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
@@ -302929,7 +303078,7 @@ mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pA
         if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header,
                                                    (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len),
-                                                   (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size,
+                                                   (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size,
                                                     (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : comp_size,
                                                    uncomp_crc32, method, gen_flags, dos_time, dos_date))
             return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
@@ -302978,20 +303127,20 @@ mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pA
 static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
 {
-	MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque;
-	mz_int64 cur_ofs = MZ_FTELL64(pSrc_file);
+    MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque;
+    mz_int64 cur_ofs = MZ_FTELL64(pSrc_file);
-	if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET))))
-		return 0;
+    if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET))))
+        return 0;
-	return MZ_FREAD(pBuf, 1, n, pSrc_file);
+    return MZ_FREAD(pBuf, 1, n, pSrc_file);
 }
 mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-	const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
+    const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
 {
-	return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, pFile_time, pComment, comment_size, level_and_flags,
-		user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
+    return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, pFile_time, pComment, comment_size, level_and_flags,
+        user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
 }
 mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
@@ -303313,11 +303462,11 @@ mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *
         {
             /* src is zip64, dest must be zip64 */
-            /* name			uint32_t's */
-            /* id				1 (optional in zip64?) */
-            /* crc			1 */
-            /* comp_size	2 */
-            /* uncomp_size 2 */
+            /* name         uint32_t's */
+            /* id           1 (optional in zip64?) */
+            /* crc          1 */
+            /* comp_size    2 */
+            /* uncomp_size  2 */
             if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
             {
                 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
@@ -304112,14 +304261,14 @@ static void uncompressFunc(
 __declspec(dllexport)
 #endif
 int sqlite3_compress_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
   SQLITE_EXTENSION_INIT2(pApi);
   (void)pzErrMsg;  /* Unused parameter */
-  rc = sqlite3_create_function(db, "compress", 1,
+  rc = sqlite3_create_function(db, "compress", 1,
                     SQLITE_UTF8 | SQLITE_INNOCUOUS,
                     0, compressFunc, 0, 0);
   if( rc==SQLITE_OK ){
@@ -304254,14 +304403,14 @@ static void sqlarUncompressFunc(
 __declspec(dllexport)
 #endif
 int sqlite3_sqlar_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   int rc = SQLITE_OK;
   SQLITE_EXTENSION_INIT2(pApi);
   (void)pzErrMsg;  /* Unused parameter */
-  rc = sqlite3_create_function(db, "sqlar_compress", 1,
+  rc = sqlite3_create_function(db, "sqlar_compress", 1,
                                SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
                                sqlarCompressFunc, 0, 0);
   if( rc==SQLITE_OK ){
@@ -304365,10 +304514,10 @@ typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
 /*
 ** Definitions for mode bitmasks S_IFDIR, S_IFREG and S_IFLNK.
 **
-** In some ways it would be better to obtain these values from system
+** In some ways it would be better to obtain these values from system
 ** header files. But, the dependency is undesirable and (a) these
 ** have been stable for decades, (b) the values are part of POSIX and
-** are also made explicit in [man stat], and (c) are part of the
+** are also made explicit in [man stat], and (c) are part of the
 ** file format for zip archives.
 */
 #ifndef S_IFDIR
@@ -304381,7 +304530,7 @@ typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
 # define S_IFLNK 0120000
 #endif
-static const char ZIPFILE_SCHEMA[] =
+static const char ZIPFILE_SCHEMA[] =
   "CREATE TABLE y("
     "name PRIMARY KEY,"  /* 0: Name of file in zip archive */
     "mode,"              /* 1: POSIX mode for file */
@@ -304402,8 +304551,8 @@ static const char ZIPFILE_SCHEMA[] =
 **
 ** ZIPFILE_NEWENTRY_MADEBY:
 **   Use this value for the "version-made-by" field in new zip file
-**   entries. The upper byte indicates "unix", and the lower byte
-**   indicates that the zip file matches pkzip specification 3.0.
+**   entries. The upper byte indicates "unix", and the lower byte
+**   indicates that the zip file matches pkzip specification 3.0.
 **   This is what info-zip seems to do.
 **
 ** ZIPFILE_NEWENTRY_REQUIRED:
@@ -304432,7 +304581,7 @@ static const char ZIPFILE_SCHEMA[] =
 #define ZIPFILE_SIGNATURE_EOCD    0x06054b50
 /*
-** The sizes of the fixed-size part of each of the three main data
+** The sizes of the fixed-size part of each of the three main data
 ** structures in a zip archive.
 */
 #define ZIPFILE_LFH_FIXED_SZ      30
@@ -304525,7 +304674,7 @@ struct ZipfileCDS {
 ***   uncompressed size               4 bytes
 ***   file name length                2 bytes
 ***   extra field length              2 bytes
-***
+***
 */
 typedef struct ZipfileLFH ZipfileLFH;
 struct ZipfileLFH {
@@ -304551,7 +304700,7 @@ struct ZipfileEntry {
   ZipfileEntry *pNext;       /* Next element in in-memory CDS */
 };
-/*
+/*
 ** Cursor type for zipfile tables.
 */
 typedef struct ZipfileCsr ZipfileCsr;
@@ -304624,7 +304773,7 @@ static void zipfileDequote(char *zIn){
 /*
 ** Construct a new ZipfileTab virtual table object.
-**
+**
 **   argv[0]   -> module name  ("zipfile")
 **   argv[1]   -> database name
 **   argv[2]   -> table name
@@ -304693,7 +304842,7 @@ static void zipfileEntryFree(ZipfileEntry *p){
 }
 /*
-** Release resources that should be freed at the end of a write
+** Release resources that should be freed at the end of a write
 ** transaction.
 */
 static void zipfileCleanupTransaction(ZipfileTab *pTab){
@@ -304802,7 +304951,7 @@ static void zipfileCursorErr(ZipfileCsr *pCsr, const char *zFmt, ...){
 /*
 ** Read nRead bytes of data from offset iOff of file pFile into buffer
 ** aRead[]. Return SQLITE_OK if successful, or an SQLite error code
-** otherwise.
+** otherwise.
 **
 ** If an error does occur, output variable (*pzErrmsg) may be set to point
 ** to an English language error message. It is the responsibility of the
@@ -305010,7 +305159,7 @@ static int zipfileScanExtra(u8 *aExtra, int nExtra, u32 *pmTime){
 **   File modification date:
 **     Bits 00-04: day
 **     Bits 05-08: month (1-12)
-**     Bits 09-15: years from 1980
+**     Bits 09-15: years from 1980
 **
 ** https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx
 */
@@ -305070,9 +305219,9 @@ static void zipfileMtimeToDos(ZipfileCDS *pCds, u32 mUnixTime){
     pCds->mDate = pCds->mTime = 0;
   }
-  assert( mUnixTime<315507600
-       || mUnixTime==zipfileMtime(pCds)
-       || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds))
+  assert( mUnixTime<315507600
+       || mUnixTime==zipfileMtime(pCds)
+       || ((mUnixTime % 2) && mUnixTime-1==zipfileMtime(pCds))
        /* || (mUnixTime % 2) */
   );
 }
@@ -305140,7 +305289,7 @@ static int zipfileGetEntry(
     if( rc==SQLITE_OK ){
       u32 *pt = &pNew->mUnixTime;
-      pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead);
+      pNew->cds.zFile = sqlite3_mprintf("%.*s", nFile, aRead);
       pNew->aExtra = (u8*)&pNew[1];
       memcpy(pNew->aExtra, &aRead[nFile], nExtra);
       if( pNew->cds.zFile==0 ){
@@ -305168,7 +305317,7 @@ static int zipfileGetEntry(
           memcpy(pNew->aData, &aBlob[pNew->iDataOff], pNew->cds.szCompressed);
         }
       }else{
-        *pzErr = sqlite3_mprintf("failed to read LFH at offset %d",
+        *pzErr = sqlite3_mprintf("failed to read LFH at offset %d",
             (int)pNew->cds.iOffset
         );
       }
@@ -305220,8 +305369,8 @@ static int zipfileNext(sqlite3_vtab_cursor *cur){
   return rc;
 }
-static void zipfileFree(void *p) {
-  sqlite3_free(p);
+static void zipfileFree(void *p) {
+  sqlite3_free(p);
 }
 /*
@@ -305271,7 +305420,7 @@ static void zipfileInflate(
 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function
 ** compresses it and sets (*ppOut) to point to a buffer containing the
 ** compressed data. The caller is responsible for eventually calling
-** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut)
+** sqlite3_free() to release buffer (*ppOut). Before returning, (*pnOut)
 ** is set to the size of buffer (*ppOut) in bytes.
 **
 ** If no error occurs, SQLITE_OK is returned. Otherwise, an SQLite error
@@ -305460,8 +305609,8 @@ static int zipfileReadEOCD(
     /* Scan backwards looking for the signature bytes */
     for(i=nRead-20; i>=0; i--){
-      if( aRead[i]==0x50 && aRead[i+1]==0x4b
-       && aRead[i+2]==0x05 && aRead[i+3]==0x06
+      if( aRead[i]==0x50 && aRead[i+1]==0x4b
+       && aRead[i+2]==0x05 && aRead[i+3]==0x06
       ){
         break;
       }
@@ -305486,14 +305635,14 @@ static int zipfileReadEOCD(
 }
 /*
-** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry
+** Add object pNew to the linked list that begins at ZipfileTab.pFirstEntry
 ** and ends with pLastEntry. If argument pBefore is NULL, then pNew is added
 ** to the end of the list. Otherwise, it is added to the list immediately
 ** before pBefore (which is guaranteed to be a part of said list).
 */
 static void zipfileAddEntry(
-  ZipfileTab *pTab,
-  ZipfileEntry *pBefore,
+  ZipfileTab *pTab,
+  ZipfileEntry *pBefore,
   ZipfileEntry *pNew
 ){
   assert( (pTab->pFirstEntry==0)==(pTab->pLastEntry==0) );
@@ -305539,7 +305688,7 @@ static int zipfileLoadDirectory(ZipfileTab *pTab, const u8 *aBlob, int nBlob){
 ** xFilter callback.
 */
 static int zipfileFilter(
-  sqlite3_vtab_cursor *cur,
+  sqlite3_vtab_cursor *cur,
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
@@ -305702,7 +305851,7 @@ static int zipfileAppendEntry(
 }
 static int zipfileGetMode(
-  sqlite3_value *pVal,
+  sqlite3_value *pVal,
   int bIsDir,                     /* If true, default to directory */
   u32 *pMode,                     /* OUT: Mode value */
   char **pzErr                    /* OUT: Error message */
@@ -305765,7 +305914,7 @@ static int zipfileBegin(sqlite3_vtab *pVtab){
   }
   /* Open a write fd on the file. Also load the entire central directory
-  ** structure into memory. During the transaction any new file data is
+  ** structure into memory. During the transaction any new file data is
   ** appended to the archive file, but the central directory is accumulated
   ** in main-memory until the transaction is committed.  */
   pTab->pWriteFd = fopen(pTab->zFile, "ab+");
@@ -305848,9 +305997,9 @@ static void zipfileRemoveEntryFromList(ZipfileTab *pTab, ZipfileEntry *pOld){
 ** xUpdate method.
 */
 static int zipfileUpdate(
-  sqlite3_vtab *pVtab,
-  int nVal,
-  sqlite3_value **apVal,
+  sqlite3_vtab *pVtab,
+  int nVal,
+  sqlite3_value **apVal,
   sqlite_int64 *pRowid
 ){
   ZipfileTab *pTab = (ZipfileTab*)pVtab;
@@ -305905,7 +306054,7 @@ static int zipfileUpdate(
       rc = SQLITE_CONSTRAINT;
     }
     if( sqlite3_value_type(apVal[6])!=SQLITE_NULL ){
-      zipfileTableErr(pTab, "rawdata must be NULL");
+      zipfileTableErr(pTab, "rawdata must be NULL");
       rc = SQLITE_CONSTRAINT;
     }
@@ -306497,7 +306646,7 @@ static int zipfileRegister(sqlite3 *db){
   int rc = sqlite3_create_module(db, "zipfile"  , &zipfileModule, 0);
   if( rc==SQLITE_OK ) rc = sqlite3_overload_function(db, "zipfile_cds", -1);
   if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0,
+    rc = sqlite3_create_function(db, "zipfile", -1, SQLITE_UTF8, 0, 0,
         zipfileStep, zipfileFinal
     );
   }
@@ -306515,8 +306664,8 @@ static int zipfileRegister(sqlite3 *db){
 __declspec(dllexport)
 #endif
 int sqlite3_zipfile_init(
-  sqlite3 *db,
-  char **pzErrMsg,
+  sqlite3 *db,
+  char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   SQLITE_EXTENSION_INIT2(pApi);
@@ -306635,6 +306784,8 @@ static int mcIoUnfetch(sqlite3_file* pFile, sqlite3_int64 iOfst, void* p);
 #define SQLITE3MC_VFS_NAME ("multipleciphers")
+#define SQLITE3MC_FCNTL_PVFS 0x3f98c078
 /*
 ** Header sizes of WAL journal files
 */
@@ -306750,7 +306901,7 @@ static void mcMainListRemove(sqlite3mc_file* pFile)
 }
 /*
-** Given that zFileName points to a buffer containing a database file name passed to
+** Given that zFileName points to a buffer containing a database file name passed to
 ** either the xOpen() or xAccess() VFS method, search the list of main database files
 ** for a file handle opened by the same database connection on the corresponding
 ** database file.
@@ -306779,36 +306930,29 @@ static sqlite3mc_vfs* mcFindVfs(sqlite3* db, const char* zDbName)
   {
     /*
     ** The top level VFS is not a Multiple Ciphers VFS.
-    ** Retrieve the VFS names stack.
+    ** Retrieve the Multiple Ciphers VFS via file control function,
+    ** if it is included in the VFS stack.
     */
-    char* zVfsNameStack = 0;
-    if ((sqlite3_file_control(db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsNameStack) == SQLITE_OK) && (zVfsNameStack != NULL))
+    sqlite3mc_vfs* pVfs = NULL;
+    if ((sqlite3_file_control(db, zDbName, SQLITE3MC_FCNTL_PVFS, &pVfs) == SQLITE_OK) &&
+        (pVfs && pVfs->base.xOpen == mcVfsOpen))
     {
-      /* Search for the name prefix of a Multiple Ciphers VFS. */
-      char* zVfsName = strstr(zVfsNameStack, SQLITE3MC_VFS_NAME);
-      if (zVfsName != NULL)
-      {
-        /* The prefix was found, now determine the full VFS name. */
-        char* zVfsNameEnd = zVfsName + strlen(SQLITE3MC_VFS_NAME);
-        if (*zVfsNameEnd == '-')
-        {
-          for (++zVfsNameEnd; *zVfsNameEnd != '/'  && *zVfsNameEnd != 0; ++zVfsNameEnd);
-          if (*zVfsNameEnd == '/') *zVfsNameEnd = 0;
-          /* Find a pointer to the VFS with the determined name. */
-          sqlite3_vfs* pVfs = sqlite3_vfs_find(zVfsName);
-          if (pVfs && pVfs->xOpen == mcVfsOpen)
-          {
-            pVfsMC = (sqlite3mc_vfs*) pVfs;
-          }
-        }
-      }
-      sqlite3_free(zVfsNameStack);
+      pVfsMC = pVfs;
     }
   }
   return pVfsMC;
 }
+/*
+** Check whether the VFS of the database file corresponding
+** to the database schema name supports encryption.
+*/
+SQLITE_PRIVATE int sqlite3mcIsEncryptionSupported(sqlite3* db, const char* zDbName)
+{
+  sqlite3mc_vfs* pVfsMC = mcFindVfs(db, zDbName);
+  return (pVfsMC != NULL);
+}
 /*
 ** Find the codec of the database file
 ** corresponding to the database schema name.
@@ -306838,6 +306982,30 @@ SQLITE_PRIVATE Codec* sqlite3mcGetMainCodec(sqlite3* db)
   return sqlite3mcGetCodec(db, "main");
 }
+SQLITE_PRIVATE int sqlite3mcIsBackupSupported(sqlite3* pSrc, const char* zSrc, sqlite3* pDest, const char* zDest)
+{
+  int ok = 1;
+  if (pSrc != pDest)
+  {
+    Codec* codecSrc = sqlite3mcGetCodec(pSrc, zSrc);
+    Codec* codecDest = sqlite3mcGetCodec(pDest, zDest);
+    if (codecSrc && codecDest)
+    {
+      /* Both databases have a codec, are encrypted, and have the same page size */
+      ok = sqlite3mcIsEncrypted(codecSrc) && sqlite3mcIsEncrypted(codecDest) &&
+           (sqlite3mcGetPageSizeReadCipher(codecSrc) == sqlite3mcGetPageSizeWriteCipher(codecDest)) &&
+           (sqlite3mcGetReadReserved(codecSrc) == sqlite3mcGetWriteReserved(codecDest));
+    }
+    else
+    {
+      /* At least one database has no codec */
+      /* Backup supported if both databases are plain databases */
+      ok = !codecSrc && !codecDest;
+    }
+  }
+  return ok;
+}
 /*
 ** Set the codec of the database file with the given database file name.
 **
@@ -306854,12 +307022,13 @@ SQLITE_PRIVATE void sqlite3mcSetCodec(sqlite3* db, const char* zDbName, const ch
   sqlite3mc_vfs* pVfsMC = mcFindVfs(db, zDbName);
   if (pVfsMC)
   {
-    pDbMain = mcFindDbMainFileName((sqlite3mc_vfs*)(db->pVfs), zFileName);
+    pDbMain = mcFindDbMainFileName(pVfsMC, zFileName);
   }
   if (pDbMain)
   {
     Codec* prevCodec = pDbMain->codec;
     Codec* msgCodec = (codec) ? codec : prevCodec;
+    pDbMain->codec = codec;
     if (msgCodec)
     {
       /* Reset error state of pager */
@@ -306872,7 +307041,6 @@ SQLITE_PRIVATE void sqlite3mcSetCodec(sqlite3* db, const char* zDbName, const ch
       */
       sqlite3mcCodecFree(prevCodec);
     }
-    pDbMain->codec = codec;
   }
   else
   {
@@ -306894,8 +307062,8 @@ SQLITE_PRIVATE void* sqlite3mcPagerCodec(PgHdrMC* pPg)
 {
   sqlite3_file* pFile = sqlite3PagerFile(pPg->pPager);
   void* aData = 0;
-  if (pFile->pMethods == &mcIoMethodsGlobal1 ||
-      pFile->pMethods == &mcIoMethodsGlobal2 ||
+  if (pFile->pMethods == &mcIoMethodsGlobal1 ||
+      pFile->pMethods == &mcIoMethodsGlobal2 ||
       pFile->pMethods == &mcIoMethodsGlobal3)
   {
     sqlite3mc_file* mcFile = (sqlite3mc_file*) pFile;
@@ -307169,6 +307337,7 @@ static int mcReadMainDb(sqlite3_file* pFile, void* buffer, int count, sqlite3_in
       */
       pageNo = prevOffset / pageSize + 1;
       bufferDecrypted = sqlite3mcCodec(mcFile->codec, pageBuffer, pageNo, 3);
+      rc = sqlite3mcGetCodecLastError(mcFile->codec);
       /*
       ** Return the requested content
@@ -307197,6 +307366,7 @@ static int mcReadMainDb(sqlite3_file* pFile, void* buffer, int count, sqlite3_in
       for (iPage = 0; iPage < nPages; ++iPage)
       {
         void* bufferDecrypted = sqlite3mcCodec(mcFile->codec, data, pageNo, 3);
+        rc = sqlite3mcGetCodecLastError(mcFile->codec);
         data += pageSize;
         offset += pageSize;
         ++pageNo;
@@ -307225,6 +307395,7 @@ static int mcReadMainJournal(sqlite3_file* pFile, const void* buffer, int count,
       ** Decrypt the page buffer, but only if the page number is valid
       */
       void* bufferDecrypted = sqlite3mcCodec(codec, (char*) buffer, mcFile->pageNo, 3);
+      rc = sqlite3mcGetCodecLastError(codec);
       mcFile->pageNo = 0;
     }
     else if (count == 4)
@@ -307258,6 +307429,7 @@ static int mcReadSubJournal(sqlite3_file* pFile, const void* buffer, int count,
       ** Decrypt the page buffer, but only if the page number is valid
       */
       void* bufferDecrypted = sqlite3mcCodec(codec, (char*) buffer, mcFile->pageNo, 3);
+      rc = sqlite3mcGetCodecLastError(codec);
     }
     else if (count == 4)
     {
@@ -307306,6 +307478,7 @@ static int mcReadWal(sqlite3_file* pFile, const void* buffer, int count, sqlite3
       if (pageNo != 0)
       {
         void* bufferDecrypted = sqlite3mcCodec(codec, (char*)buffer, pageNo, 3);
+        rc = sqlite3mcGetCodecLastError(codec);
       }
     }
     else if (codec->m_walLegacy != 0 && count == pageSize + walFrameHeaderSize)
@@ -307318,6 +307491,7 @@ static int mcReadWal(sqlite3_file* pFile, const void* buffer, int count, sqlite3
       if (pageNo != 0)
       {
         void* bufferDecrypted = sqlite3mcCodec(codec, (char*)buffer+walFrameHeaderSize, pageNo, 3);
+        rc = sqlite3mcGetCodecLastError(codec);
       }
     }
   }
@@ -307729,6 +307903,12 @@ static int mcIoFileControl(sqlite3_file* pFile, int op, void* pArg)
   switch (op)
   {
+    case SQLITE3MC_FCNTL_PVFS:
+      {
+        *(sqlite3mc_vfs**) pArg = p->pVfsMC;
+        doReal = 0;
+      }
+      break;
     case SQLITE_FCNTL_PDB:
       {
 #if 0
@@ -307745,7 +307925,7 @@ static int mcIoFileControl(sqlite3_file* pFile, int op, void* pArg)
         */
         sqlite3* db = *((sqlite3**) pArg);
 #endif
-    }
+      }
       break;
     case SQLITE_FCNTL_PRAGMA:
       {
@@ -308321,7 +308501,7 @@ sqlite3mcTermCipherTables()
   globalCipherCount = 0;
 }
-int
+SQLITE_PRIVATE int
 sqlite3mc_initialize(const char* arg)
 {
   int rc = sqlite3mcInitCipherTables();
@@ -308453,7 +308633,7 @@ sqlite3mc_initialize(const char* arg)
   return rc;
 }
-void
+SQLITE_PRIVATE void
 sqlite3mc_shutdown(void)
 {
   sqlite3mc_vfs_shutdown();
@@ -309526,7 +309706,7 @@ static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value**argv){
         eType = SQLITE_BLOB;
       }else if( (c=='b' && strcmp(zType,"boolean")==0)
              || (c=='w' && strcmp(zType,"wideInt")==0)
-             || (c=='i' && strcmp(zType,"int")==0)
+             || (c=='i' && strcmp(zType,"int")==0)
       ){
         eType = SQLITE_INTEGER;
       }else if( c=='d' && strcmp(zType,"double")==0 ){
@@ -310326,9 +310506,9 @@ static int SQLITE_TCLAPI DbEvalNextCmd(
       if( pArray==0 ){
         Tcl_ObjSetVar2(interp, apColName[i], 0, dbEvalColumnValue(p,i), 0);
       }else if( (p->evalFlags & SQLITE_EVAL_WITHOUTNULLS)!=0
-             && sqlite3_column_type(p->pPreStmt->pStmt, i)==SQLITE_NULL
+             && sqlite3_column_type(p->pPreStmt->pStmt, i)==SQLITE_NULL
       ){
-        Tcl_UnsetVar2(interp, Tcl_GetString(pArray),
+        Tcl_UnsetVar2(interp, Tcl_GetString(pArray),
                       Tcl_GetString(apColName[i]), 0);
       }else{
         Tcl_ObjSetVar2(interp, pArray, apColName[i], dbEvalColumnValue(p,i), 0);
@@ -310440,7 +310620,7 @@ static int SQLITE_TCLAPI DbObjCmd(
     "timeout",                "total_changes",         "trace",
     "trace_v2",               "transaction",           "unlock_notify",
     "update_hook",            "version",               "wal_hook",
-    0
+    0
   };
   enum DB_enum {
     DB_AUTHORIZER,            DB_BACKUP,               DB_BIND_FALLBACK,
@@ -310586,7 +310766,7 @@ static int SQLITE_TCLAPI DbObjCmd(
   ** value of the CALLBACK as the binding.  If CALLBACK returns something
   ** other than TCL_OK or TCL_ERROR then bind a NULL.
   **
-  ** If CALLBACK is an empty string, then revert to the default behavior
+  ** If CALLBACK is an empty string, then revert to the default behavior
   ** which is to set the binding to NULL.
   **
   ** If CALLBACK returns an error, that causes the statement execution to
@@ -311180,7 +311360,7 @@ static int SQLITE_TCLAPI DbObjCmd(
     }
 deserialize_error:
 #endif
-    break;
+    break;
   }
   /*
@@ -311290,7 +311470,7 @@ deserialize_error:
       objv++;
     }
     if( objc<3 || objc>5 ){
-      Tcl_WrongNumArgs(interp, 2, objv,
+      Tcl_WrongNumArgs(interp, 2, objv,
           "?OPTIONS? SQL ?ARRAY-NAME? ?SCRIPT?");
       return TCL_ERROR;
     }
@@ -311693,7 +311873,7 @@ deserialize_error:
   /*
   **     $db serialize ?DATABASE?
   **
-  ** Return a serialization of a database.
+  ** Return a serialization of a database.
   */
   case DB_SERIALIZE: {
 #ifdef SQLITE_OMIT_DESERIALIZE
@@ -312019,7 +312199,7 @@ deserialize_error:
   */
   case DB_PREUPDATE: {
 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
-    Tcl_AppendResult(interp, "preupdate_hook was omitted at compile-time",
+    Tcl_AppendResult(interp, "preupdate_hook was omitted at compile-time",
                      (char*)0);
     rc = TCL_ERROR;
 #else
@@ -312158,7 +312338,7 @@ deserialize_error:
         return TCL_ERROR;
       }
     }
-    if( i==2 ){
+    if( i==2 ){
       Tcl_SetResult(interp, (char *)sqlite3_libversion(), TCL_STATIC);
     }
     break;