chore: Assets 디렉토리 구조 정리 및 네이밍 컨벤션 적용

- Assets/_Game/ 하위로 게임 에셋 통합
- External/ 패키지 벤더별 분류 (Synty, Animations, UI)
- 에셋 네이밍 컨벤션 확립 및 적용
  (Data_Skill_, Data_SkillEffect_, Prefab_, Anim_, Model_, BT_ 등)
- pre-commit hook으로 네이밍 컨벤션 자동 검사 추가
- RESTRUCTURE_CHECKLIST.md 작성

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/Makefile

@@ -0,0 +1,140 @@
+# Android setup
+ANDROID_NDK_ROOT ?=
+# macOS code signing setup
+CODESIGN ?= codesign
+MACOS_CODESIGN_SIGNATURE ?=
+# Download GitHub Action releases
+GITHUB_CLI_BIN ?= gh
+GITHUB_REPO ?= gilzoide/unity-sqlite-net
+RUN_ID ?=
+
+ifeq ($(DEBUG),1)
+	CFLAGS += -O0 -g -DDEBUG
+else
+	CFLAGS += -O3 -DNDEBUG
+endif
+
+BUILD_DIRS = \
+	lib/windows/x86_64 lib/windows/x86 lib/windows/arm64 \
+	lib/linux/x86_64 lib/linux/x86 \
+	lib/macos \
+	lib/android/arm64 lib/android/arm32 lib/android/x86 lib/android/x86_64
+
+SQLITE_SRC = sqlite-amalgamation/sqlite3.c
+SQLITE_NET_SRC = $(wildcard sqlite-net~/src/*.cs) sqlite-net~/LICENSE.txt
+SQLITE_NET_DEST = ../Runtime/sqlite-net
+SQLITE_NET_SED_SCRIPT = tools~/fix-library-path.sed
+
+$(BUILD_DIRS):
+	mkdir -p $@
+
+.PRECIOUS: lib/%/sqlite3.o~
+lib/%/sqlite3.o~: $(SQLITE_SRC) | lib/%
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+# Windows
+lib/windows/%/gilzoide-sqlite-net.dll: LINKFLAGS += -shared
+lib/windows/%/gilzoide-sqlite-net.dll: lib/windows/%/sqlite3.o~ | lib/windows/%
+	$(CC) -o $@ $^ $(LINKFLAGS)
+
+# Linux
+lib/linux/%/libgilzoide-sqlite-net.so: CFLAGS += -fPIC
+
+# Note: The "-Wl,-Bsymbolic" flags prevent the dynamic linker from interposing the plugin’s calls to its 
+# own exported symbols with identically-named symbols in other loaded libraries (like /usr/lib/libsqlite3.so.0)
+# which can cause a Unity Editor crash otherwise.
+lib/linux/%/libgilzoide-sqlite-net.so: LINKFLAGS += -shared -lm -Wl,-Bsymbolic
+
+lib/linux/%/libgilzoide-sqlite-net.so: lib/linux/%/sqlite3.o~ | lib/linux/%
+	$(CC) -o $@ $^ $(LINKFLAGS)
+
+# macOS
+lib/macos/libgilzoide-sqlite-net.dylib: CFLAGS += -arch arm64 -arch x86_64 -isysroot $(shell xcrun --show-sdk-path --sdk macosx)
+lib/macos/libgilzoide-sqlite-net.dylib: LINKFLAGS += -shared -arch arm64 -arch x86_64
+lib/macos/libgilzoide-sqlite-net.dylib: lib/macos/sqlite3.o~ | lib/macos
+	$(CC) -o $@ $^ $(LINKFLAGS)
+ifdef MACOS_CODESIGN_SIGNATURE
+	$(CODESIGN) -s "$(MACOS_CODESIGN_SIGNATURE)" $@
+endif
+
+# Android
+check-ndk-root:
+ifndef ANDROID_NDK_ROOT
+	$(error ANDROID_NDK_ROOT must be set for Android builds!)
+endif
+
+lib/android/%/libgilzoide-sqlite-net.so: CFLAGS += -fPIC
+lib/android/%/libgilzoide-sqlite-net.so: LINKFLAGS += -shared -lm -Wl,-z,max-page-size=16384
+lib/android/%/libgilzoide-sqlite-net.so: lib/android/%/sqlite3.o~ check-ndk-root | lib/android/%
+	$(CC) -o $@ $< $(LINKFLAGS)
+
+lib/android/arm64/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/aarch64-linux-android21-clang)
+lib/android/arm32/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/armv7a-linux-androideabi21-clang)
+lib/android/x86_64/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/x86_64-linux-android21-clang)
+lib/android/x86/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/i686-linux-android21-clang)
+
+
+# Source
+$(SQLITE_NET_DEST)/%.cs: sqlite-net~/src/%.cs $(SQLITE_NET_SED_SCRIPT)
+	cat $< | sed -E -f $(SQLITE_NET_SED_SCRIPT) > $@
+
+$(SQLITE_NET_DEST)/License.txt: sqlite-net~/License.txt
+	cp $< $@
+
+# Targets
+windows-x86_64: lib/windows/x86_64/gilzoide-sqlite-net.dll
+windows-x86: lib/windows/x86/gilzoide-sqlite-net.dll
+windows-arm64: lib/windows/arm64/gilzoide-sqlite-net.dll
+
+windows-mingw-x86_64: CC = x86_64-w64-mingw32-gcc
+windows-mingw-x86_64: LINKFLAGS += -static-libgcc
+windows-mingw-x86_64: lib/windows/x86_64/gilzoide-sqlite-net.dll
+
+windows-mingw-x86: CC = i686-w64-mingw32-gcc
+windows-mingw-x86: LINKFLAGS += -static-libgcc
+windows-mingw-x86: lib/windows/x86/gilzoide-sqlite-net.dll
+
+windows-mingw-arm64: CC = aarch64-w64-mingw32-gcc
+windows-mingw-arm64: LINKFLAGS += -static-libgcc
+windows-mingw-arm64: lib/windows/arm64/gilzoide-sqlite-net.dll
+
+linux-x86_64: lib/linux/x86_64/libgilzoide-sqlite-net.so
+
+macos-universal: lib/macos/libgilzoide-sqlite-net.dylib
+
+android-arm64: lib/android/arm64/libgilzoide-sqlite-net.so
+android-arm32: lib/android/arm32/libgilzoide-sqlite-net.so
+android-x86_64: lib/android/x86_64/libgilzoide-sqlite-net.so
+android-x86: lib/android/x86/libgilzoide-sqlite-net.so
+
+source: $(SQLITE_NET_DEST)/License.txt $(SQLITE_NET_DEST)/AssemblyInfo.cs $(SQLITE_NET_DEST)/SQLite.cs $(SQLITE_NET_DEST)/SQLiteAsync.cs
+
+all-android: android-arm64 android-arm32 android-x86_64 android-x86
+all-apple: macos-universal
+all-linux: linux-x86_64
+all-windows: windows-x86_64 windows-x86
+all-windows-mingw: windows-mingw-x86_64 windows-mingw-x86
+all-windows-llvm-mingw: windows-mingw-x86_64 windows-mingw-x86 windows-mingw-arm64
+
+# Dockerized builds
+docker-all-android:
+	docker build -f tools~/Dockerfile.build.android --platform=linux/amd64 -t gilzoide-sqlite-net-build-android:latest $(DOCKER_BUILD_ARGS) .
+	docker run --rm -v "$(CURDIR)":/src -w /src --platform=linux/amd64 gilzoide-sqlite-net-build-android:latest make all-android
+docker-all-linux:
+	docker build -f tools~/Dockerfile.build.linux --platform=linux/amd64 -t gilzoide-sqlite-net-build-linux:latest $(DOCKER_BUILD_ARGS) .
+	docker run --rm -v "$(CURDIR)":/src -w /src --platform=linux/amd64 gilzoide-sqlite-net-build-linux:latest make all-linux
+docker-all-windows:
+	docker build -f tools~/Dockerfile.build.windows -t gilzoide-sqlite-net-build-windows:latest $(DOCKER_BUILD_ARGS) .
+	docker run --rm -v "$(CURDIR)":/src -w /src gilzoide-sqlite-net-build-windows:latest make all-windows-mingw
+docker-all-windows-llvm:
+	docker run --rm -v "$(CURDIR)":/src -w /src mstorsjo/llvm-mingw:latest make all-windows-llvm-mingw
+
+# Download builds from GitHub Actions
+download-latest-build:
+	$(eval TMPDIR := $(shell mktemp -d))
+	$(GITHUB_CLI_BIN) run download $(RUN_ID) --repo $(GITHUB_REPO) -p gilzoide-sqlite-net-* -D $(TMPDIR)
+	rsync -r $(TMPDIR)/gilzoide-sqlite-net-windows/* lib/windows/
+	rsync -r $(TMPDIR)/gilzoide-sqlite-net-linux/* lib/linux/
+	rsync -r $(TMPDIR)/gilzoide-sqlite-net-android/* lib/android/
+	rsync -r $(TMPDIR)/gilzoide-sqlite-net-macos/* lib/macos/
+	$(RM) -r $(TMPDIR)

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/Makefile.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d937f0ae4113443b78db34d7d15cd41b
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 346c87c5708c44a7bbc2987f97045ee8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/SQLiteVfs.h

@@ -0,0 +1,594 @@
+/** 
+ * @file SQLiteVfs.hpp
+ * Single header with classes for easily implementing SQLite VFS shims in C++11
+ *
+ * How to use it:
+ * ```cpp
+ * #include <iostream>
+ * #include <SQLiteVfs.hpp>
+ *
+ * // 1. Implement your File shim, override any methods you want
+ * struct MySQLiteFile : SQLiteFileImpl {
+ *     int xRead(void *p, int iAmt, sqlite3_int64 iOfst) override {
+ *         std::cout << "READING" << std::endl;
+ *         return SQLiteFileImpl::xRead(p, iAmt, iOfst);
+ *     }
+ * }
+ *
+ * // 2. Implement your VFS shim, override any methods you want
+ * struct MySQLiteVfs : SQLiteVfsImpl<MySQLiteFile> {
+ *     int xOpen(sqlite3_filename zName, SQLiteFile<TFileImpl> *file, int flags, int *pOutFlags) override {
+ *         std::cout << "OPENING FILE " << zName << std::endl;
+ *         return SQLiteVfsImpl::xOpen(zName, file, flags, pOutFlags);
+ *     }
+ * }
+ *
+ * // 3. Register your VFS
+ * static MySQLiteVfs my_vfs("myvfs");
+ * int register_my_vfs() {
+ *     return my_vfs.register_vfs(false);
+ * }
+ *
+ * // 4. (optional) Unregister your VFS
+ * void unregister_my_vfs() {
+ *     my_vfs.unregister_vfs();
+ * }
+ * ```
+ */
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+#ifndef __SQLITE_VFS_HPP__
+#define __SQLITE_VFS_HPP__
+
+#include <new>
+
+#include "../sqlite-amalgamation/sqlite3.h"
+
+namespace sqlitevfs {
+	/**
+	 * SQLite File implementation with virtual methods for C++.
+	 *
+	 * The default method implementations forward execution to `original_file`.
+	 *
+	 * You should not create objects of this type manually.
+	 * Instead, you should subclass it, overriding any of the methods necessary, and pass your subclass to `SQLiteVfsImpl<>`.
+	 * 
+	 * @note Destructors will be called automatically by `SQLiteFile` right after `xClose` is called.
+	 *
+	 * @see https://sqlite.org/c3ref/file.html
+	 */
+	struct SQLiteFileImpl {
+		/**
+		 * File used by the default method implementations.
+		 */
+		sqlite3_file *original_file;
+
+		/**
+		 * Determine which functions are supported by this implementation.
+		 *
+		 * The default implementation returns `original_file`'s `iVersion`, or 1 if it is NULL.
+		 * Override this to report a different version.
+		 * @see https://sqlite.org/c3ref/io_methods.html
+		 */
+		virtual int iVersion() const {
+			return original_file ? original_file->pMethods->iVersion : 1;
+		}
+
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xClose() {
+			return original_file->pMethods->xClose(original_file);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xRead(void *p, int iAmt, sqlite3_int64 iOfst) {
+			return original_file->pMethods->xRead(original_file, p, iAmt, iOfst);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xWrite(const void *p, int iAmt, sqlite3_int64 iOfst) {
+			return original_file->pMethods->xWrite(original_file, p, iAmt, iOfst);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xTruncate(sqlite3_int64 size) {
+			return original_file->pMethods->xTruncate(original_file, size);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xSync(int flags) {
+			return original_file->pMethods->xSync(original_file, flags);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xFileSize(sqlite3_int64 *pSize) {
+			return original_file->pMethods->xFileSize(original_file, pSize);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xLock(int flags) {
+			return original_file->pMethods->xLock(original_file, flags);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xUnlock(int flags) {
+			return original_file->pMethods->xUnlock(original_file, flags);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xCheckReservedLock(int *pResOut) {
+			return original_file->pMethods->xCheckReservedLock(original_file, pResOut);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xFileControl(int op, void *pArg) {
+			return original_file->pMethods->xFileControl(original_file, op, pArg);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xSectorSize() {
+			return original_file->pMethods->xSectorSize(original_file);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xDeviceCharacteristics() {
+			return original_file->pMethods->xDeviceCharacteristics(original_file);
+		}
+		/* Methods above are valid for version 1 */
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xShmMap(int iPg, int pgsz, int flags, void volatile**pp) {
+			return original_file->pMethods->xShmMap(original_file, iPg, pgsz, flags, pp);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xShmLock(int offset, int n, int flags) {
+			return original_file->pMethods->xShmLock(original_file, offset, n, flags);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual void xShmBarrier() {
+			return original_file->pMethods->xShmBarrier(original_file);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xShmUnmap(int deleteFlag) {
+			return original_file->pMethods->xShmUnmap(original_file, deleteFlag);
+		}
+		/* Methods above are valid for version 2 */
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xFetch(sqlite3_int64 iOfst, int iAmt, void **pp) {
+			return original_file->pMethods->xFetch(original_file, iOfst, iAmt, pp);
+		}
+		/// @see https://sqlite.org/c3ref/io_methods.html
+		virtual int xUnfetch(sqlite3_int64 iOfst, void *p) {
+			return original_file->pMethods->xUnfetch(original_file, iOfst, p);
+		}
+		/* Methods above are valid for version 3 */
+		/* Additional methods may be added in future releases */
+	};
+
+	/**
+	 * POD `sqlite3_file` subclass that forwards all invocations to an embedded object that inherits `SQLiteFileImpl`.
+	 *
+	 * You should not create objects of this type manually nor subclass it.
+	 *
+	 * @tparam TFileImpl  `SQLiteFileImpl` subclass
+	 */
+	template<typename TFileImpl>
+	struct SQLiteFile : public sqlite3_file {
+		using FileImpl = TFileImpl;
+
+		/**
+		 * SQLite IO methods populated by `SQLiteFile::setup`.
+		 */
+		sqlite3_io_methods methods;
+		/**
+		 * File implementation object of the `SQLiteFileImpl` subclass passed as template parameter to `SQLiteVfsImpl<>`.
+		 */
+		FileImpl implementation;
+		sqlite3_file original_file[0];
+
+		/**
+		 * Setup internal state based on the `open_result` flag.
+		 *
+		 * This function is called automatically by `SQLiteVfs::wrap_xOpen`.
+		 * If `open_result` is `SQLITE_OK`, `pMethods` will be populated.
+		 * Otherwise, `pMethods` will be set to NULL and SQLite won't call them.
+		 *
+		 * @param open_result  A SQLite error code. Pass `SQLITE_OK` to fully setup the file object.
+		 *                     Pass anything else to set `pMethods` to NULL.
+		 */
+		void setup(int open_result) {
+			if (open_result == SQLITE_OK) {
+				implementation.original_file = original_file;
+				methods = {
+					implementation.iVersion(),
+					&wrap_xClose,
+					&wrap_xRead,
+					&wrap_xWrite,
+					&wrap_xTruncate,
+					&wrap_xSync,
+					&wrap_xFileSize,
+					&wrap_xLock,
+					&wrap_xUnlock,
+					&wrap_xCheckReservedLock,
+					&wrap_xFileControl,
+					&wrap_xSectorSize,
+					&wrap_xDeviceCharacteristics,
+					&wrap_xShmMap,
+					&wrap_xShmLock,
+					&wrap_xShmBarrier,
+					&wrap_xShmUnmap,
+					&wrap_xFetch,
+					&wrap_xUnfetch,
+				};
+				pMethods = &methods;
+			}
+			else {
+				pMethods = nullptr;
+			}
+		}
+	
+	private:
+		static int wrap_xClose(sqlite3_file *file) {
+			int result = static_cast<SQLiteFile *>(file)->implementation.xClose();
+			static_cast<SQLiteFile *>(file)->~SQLiteFile();
+			return result;
+		}
+		static int wrap_xRead(sqlite3_file *file, void *p, int iAmt, sqlite3_int64 iOfst) {
+			return static_cast<SQLiteFile *>(file)->implementation.xRead(p, iAmt, iOfst);
+		}
+		static int wrap_xWrite(sqlite3_file *file, const void *p, int iAmt, sqlite3_int64 iOfst) {
+			return static_cast<SQLiteFile *>(file)->implementation.xWrite(p, iAmt, iOfst);
+		}
+		static int wrap_xTruncate(sqlite3_file *file, sqlite3_int64 size) {
+			return static_cast<SQLiteFile *>(file)->implementation.xTruncate(size);
+		}
+		static int wrap_xSync(sqlite3_file *file, int flags) {
+			return static_cast<SQLiteFile *>(file)->implementation.xSync(flags);
+		}
+		static int wrap_xFileSize(sqlite3_file *file, sqlite3_int64 *pSize) {
+			return static_cast<SQLiteFile *>(file)->implementation.xFileSize(pSize);
+		}
+		static int wrap_xLock(sqlite3_file *file, int flags) {
+			return static_cast<SQLiteFile *>(file)->implementation.xLock(flags);
+		}
+		static int wrap_xUnlock(sqlite3_file *file, int flags) {
+			return static_cast<SQLiteFile *>(file)->implementation.xUnlock(flags);
+		}
+		static int wrap_xCheckReservedLock(sqlite3_file *file, int *pResOut) {
+			return static_cast<SQLiteFile *>(file)->implementation.xCheckReservedLock(pResOut);
+		}
+		static int wrap_xFileControl(sqlite3_file *file, int op, void *pArg) {
+			return static_cast<SQLiteFile *>(file)->implementation.xFileControl(op, pArg);
+		}
+		static int wrap_xSectorSize(sqlite3_file *file) {
+			return static_cast<SQLiteFile *>(file)->implementation.xSectorSize();
+		}
+		static int wrap_xDeviceCharacteristics(sqlite3_file *file) {
+			return static_cast<SQLiteFile *>(file)->implementation.xDeviceCharacteristics();
+		}
+		static int wrap_xShmMap(sqlite3_file *file, int iPg, int pgsz, int flags, void volatile**pp) {
+			return static_cast<SQLiteFile *>(file)->implementation.xShmMap(iPg, pgsz, flags, pp);
+		}
+		static int wrap_xShmLock(sqlite3_file *file, int offset, int n, int flags) {
+			return static_cast<SQLiteFile *>(file)->implementation.xShmLock(offset, n, flags);
+		}
+		static void wrap_xShmBarrier(sqlite3_file *file) {
+			return static_cast<SQLiteFile *>(file)->implementation.xShmBarrier();
+		}
+		static int wrap_xShmUnmap(sqlite3_file *file, int deleteFlag) {
+			return static_cast<SQLiteFile *>(file)->implementation.xShmUnmap(deleteFlag);
+		}
+		static int wrap_xFetch(sqlite3_file *file, sqlite3_int64 iOfst, int iAmt, void **pp) {
+			return static_cast<SQLiteFile *>(file)->implementation.xFetch(iOfst, iAmt, pp);
+		}
+		static int wrap_xUnfetch(sqlite3_file *file, sqlite3_int64 iOfst, void *p) {
+			return static_cast<SQLiteFile *>(file)->implementation.xUnfetch(iOfst, p);
+		}
+	};
+
+	/**
+	 * SQLite VFS implementation with virtual methods for C++.
+	 *
+	 * The default method implementations forward execution to `original_vfs`.
+	 *
+	 * You should not create objects of this type manually.
+	 * Instead, you should subclass it, overriding any of the methods necessary, and pass your subclass to `SQLiteVfs<>`.
+	 *
+	 * @tparam TFileImpl  `SQLiteFileImpl` subclass
+	 * @see https://sqlite.org/c3ref/vfs.html
+	 */
+	template<typename TFileImpl>
+	struct SQLiteVfsImpl {
+		using FileImpl = TFileImpl;
+		
+		/**
+		 * VFS used by the default method implementations.
+		 */
+		sqlite3_vfs *original_vfs;
+		
+		/**
+		 * Open the database.
+		 *
+		 * `file` is guaranteed to have been constructed using the default constructor.
+		 * If you return `SQLITE_OK`, the `file` IO methods will be populated.
+		 * Otherwise, IO methods will be set to NULL and `file` will be automatically destroyed.
+		 *
+		 * @see https://sqlite.org/c3ref/vfs.html
+		 */
+		virtual int xOpen(sqlite3_filename zName, SQLiteFile<TFileImpl> *file, int flags, int *pOutFlags) {
+			return original_vfs->xOpen(original_vfs, zName, file->original_file, flags, pOutFlags);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xDelete(const char *zName, int syncDir) {
+			return original_vfs->xDelete(original_vfs, zName, syncDir);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xAccess(const char *zName, int flags, int *pResOut) {
+			return original_vfs->xAccess(original_vfs, zName, flags, pResOut);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xFullPathname(const char *zName, int nOut, char *zOut) {
+			return original_vfs->xFullPathname(original_vfs, zName, nOut, zOut);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual void *xDlOpen(const char *zFilename) {
+			return original_vfs->xDlOpen(original_vfs, zFilename);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual void xDlError(int nByte, char *zErrMsg) {
+			original_vfs->xDlError(original_vfs, nByte, zErrMsg);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual void (*xDlSym(void *library, const char *zSymbol))(void) {
+			return original_vfs->xDlSym(original_vfs, library, zSymbol);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual void xDlClose(void *library) {
+			return original_vfs->xDlClose(original_vfs, library);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xRandomness(int nByte, char *zOut) {
+			return original_vfs->xRandomness(original_vfs, nByte, zOut);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xSleep(int microseconds) {
+			return original_vfs->xSleep(original_vfs, microseconds);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xCurrentTime(double *pResOut) {
+			return original_vfs->xCurrentTime(original_vfs, pResOut);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xGetLastError(int nByte, char *zOut) {
+			return original_vfs->xGetLastError(original_vfs, nByte, zOut);
+		}
+		/*
+		** The methods above are in version 1 of the sqlite_vfs object
+		** definition.  Those that follow are added in version 2 or later
+		*/
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xCurrentTimeInt64(sqlite3_int64 *pResOut) {
+			return original_vfs->xCurrentTimeInt64(original_vfs, pResOut);
+		}
+		/*
+		** The methods above are in versions 1 and 2 of the sqlite_vfs object.
+		** Those below are for version 3 and greater.
+		*/
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual int xSetSystemCall(const char *zName, sqlite3_syscall_ptr ptr) {
+			return original_vfs->xSetSystemCall(original_vfs, zName, ptr);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual sqlite3_syscall_ptr xGetSystemCall(const char *zName) {
+			return original_vfs->xGetSystemCall(original_vfs, zName);
+		}
+		/// @see https://sqlite.org/c3ref/vfs.html
+		virtual const char *xNextSystemCall(const char *zName) {
+			return original_vfs->xNextSystemCall(original_vfs, zName);
+		}
+		/*
+		** The methods above are in versions 1 through 3 of the sqlite_vfs object.
+		** New fields may be appended in future versions.  The iVersion
+		** value will increment whenever this happens.
+		*/
+	};
+
+	/**
+	 * POD `sqlite3_vfs` subclass that forwards all invocations to an embedded object that inherits `SQLiteVfsImpl`.
+	 *
+	 * You should not subclass this type.
+	 * Pass your `SQLiteVfsImpl` subclass as template argument instead.
+	 *
+	 * @tparam TVfsImpl  `SQLiteVfsImpl` subclass
+	 */
+	template<typename TVfsImpl>
+	struct SQLiteVfs : public sqlite3_vfs {
+		using VfsImpl = TVfsImpl;
+		using FileImpl = typename VfsImpl::FileImpl;
+
+		/**
+		 * VFS implementation object of the `SQLiteVfsImpl` subclass passed as template parameter to `SQLiteVfs<>`.
+		 */
+		VfsImpl implementation;
+
+		/**
+		 * Construct a named VFS with the default VFS as base.
+		 *
+		 * @param name  VFS name.
+		 * @see SQLiteVfs(const char *, sqlite3_vfs *)
+		 */
+		SQLiteVfs(const char *name)
+			: SQLiteVfs(name, (sqlite3_vfs *) nullptr)
+		{	
+		}
+
+		/**
+		 * Construct a named VFS with the VFS named `base_vfs_name` as base.
+		 *
+		 * @param name  VFS name.
+		 * @param base_vfs_name  Base VFS name, used to find the base VFS using `sqlite3_vfs_find`.
+		 * @see SQLiteVfs(const char *, sqlite3_vfs *)
+		 */
+		SQLiteVfs(const char *name, const char *base_vfs_name)
+			: SQLiteVfs(name, sqlite3_vfs_find(base_vfs_name))
+		{
+		}
+
+		/**
+		 * Construct a named VFS with `original_vfs` as base VFS.
+		 *
+		 * The `original_vfs` will be forwarded to the `implementation`.
+		 *
+		 * @warning If a VFS is registered with a name that is NULL or an empty string, then the behavior is undefined.
+		 * @param name  VFS name.
+		 * @param original_vfs  Base VFS. If NULL, the default VFS will be used instead.
+		 * @see SQLiteVfs(const char *, sqlite3_vfs *)
+		 */
+		SQLiteVfs(const char *name, sqlite3_vfs *original_vfs)
+			: SQLiteVfs()
+		{
+			if (original_vfs == nullptr) {
+				original_vfs = sqlite3_vfs_find(nullptr);
+			}
+			implementation.original_vfs = original_vfs;
+
+			iVersion = original_vfs->iVersion;
+			szOsFile = (int) sizeof(SQLiteFile<FileImpl>) + original_vfs->szOsFile;
+			mxPathname = original_vfs->mxPathname;
+			zName = name;
+		}
+
+		/**
+		 * Unregisters the VFS, just to be sure.
+		 * @see unregister_vfs
+		 */
+		~SQLiteVfs() {
+			unregister_vfs();
+		}
+
+		/**
+		 * Register the VFS in SQLite using `sqlite3_vfs_register`.
+		 *
+		 * The same VFS can be registered multiple times without injury.
+		 * To make an existing VFS into the default VFS, register it again with `makeDefault` flag set.
+		 *
+		 * @param makeDefault  Whether the VFS will be the new default VFS.
+		 * @see https://sqlite.org/c3ref/vfs_find.html
+		 */
+		int register_vfs(bool makeDefault) {
+			return sqlite3_vfs_register(this, makeDefault);
+		}
+		
+		/**
+		 * Unregister the VFS in SQLite using `sqlite3_vfs_unregister`.
+		 *
+		 * If the default VFS is unregistered, another VFS is chosen as the default arbitrarily.
+		 * @see https://sqlite.org/c3ref/vfs_find.html
+		 */
+		int unregister_vfs() {
+			return sqlite3_vfs_unregister(this);
+		}
+
+		/**
+		 * Whether this VFS is registered in SQLite, checked using `sqlite3_vfs_find`.
+		 *
+		 * @see https://sqlite.org/c3ref/vfs_find.html
+		 */
+		bool is_registered() const {
+			return sqlite3_vfs_find(zName) == this;
+		}
+
+	private:
+		SQLiteVfs()
+			: implementation()
+		{
+			pNext = nullptr;
+			pAppData = nullptr;
+			xOpen = &wrap_xOpen;
+			xDelete = &wrap_xDelete;
+			xAccess = &wrap_xAccess;
+			xFullPathname = &wrap_xFullPathname;
+			xDlOpen = &wrap_xDlOpen;
+			xDlError = &wrap_xDlError;
+			xDlSym = &wrap_xDlSym;
+			xDlClose = &wrap_xDlClose;
+			xRandomness = &wrap_xRandomness;
+			xSleep = &wrap_xSleep;
+			xCurrentTime = &wrap_xCurrentTime;
+			xGetLastError = &wrap_xGetLastError;
+			xCurrentTimeInt64 = &wrap_xCurrentTimeInt64;
+			xSetSystemCall = &wrap_xSetSystemCall;
+			xGetSystemCall = &wrap_xGetSystemCall;
+			xNextSystemCall = &wrap_xNextSystemCall;
+		}
+		
+		static int wrap_xOpen(sqlite3_vfs *vfs, sqlite3_filename zName, sqlite3_file *raw_file, int flags, int *pOutFlags) {
+			auto file = static_cast<SQLiteFile<FileImpl> *>(raw_file);
+			new (file) SQLiteFile<FileImpl>();
+			int result = static_cast<SQLiteVfs *>(vfs)->implementation.xOpen(zName, file, flags, pOutFlags);
+			file->setup(result);
+			if (result != SQLITE_OK) {
+				file->~SQLiteFile<FileImpl>();
+			}
+			return result;
+		}
+		static int wrap_xDelete(sqlite3_vfs *vfs, const char *zName, int syncDir) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xDelete(zName, syncDir);
+		}
+		static int wrap_xAccess(sqlite3_vfs *vfs, const char *zName, int flags, int *pResOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xAccess(zName, flags, pResOut);
+		}
+		static int wrap_xFullPathname(sqlite3_vfs *vfs, const char *zName, int nOut, char *zOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xFullPathname(zName, nOut, zOut);
+		}
+		static void *wrap_xDlOpen(sqlite3_vfs *vfs, const char *zFilename) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xDlOpen(zFilename);
+		}
+		static void wrap_xDlError(sqlite3_vfs *vfs, int nByte, char *zErrMsg) {
+			static_cast<SQLiteVfs *>(vfs)->implementation.xDlError(nByte, zErrMsg);
+		}
+		static void (*wrap_xDlSym(sqlite3_vfs *vfs, void *library, const char *zSymbol))(void) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xDlSym(library, zSymbol);
+		}
+		static void wrap_xDlClose(sqlite3_vfs *vfs, void *library) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xDlClose(library);
+		}
+		static int wrap_xRandomness(sqlite3_vfs *vfs, int nByte, char *zOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xRandomness(nByte, zOut);
+		}
+		static int wrap_xSleep(sqlite3_vfs *vfs, int microseconds) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xSleep(microseconds);
+		}
+		static int wrap_xCurrentTime(sqlite3_vfs *vfs, double *pResOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xCurrentTime(pResOut);
+		}
+		static int wrap_xGetLastError(sqlite3_vfs *vfs, int nByte, char *zOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xGetLastError(nByte, zOut);
+		}
+		static int wrap_xCurrentTimeInt64(sqlite3_vfs *vfs, sqlite3_int64 *pResOut) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xCurrentTimeInt64(pResOut);
+		}
+		static int wrap_xSetSystemCall(sqlite3_vfs *vfs, const char *zName, sqlite3_syscall_ptr ptr) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xSetSystemCall(zName, ptr);
+		}
+		static sqlite3_syscall_ptr wrap_xGetSystemCall(sqlite3_vfs *vfs, const char *zName) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xGetSystemCall(zName);
+		}
+		static const char *wrap_xNextSystemCall(sqlite3_vfs *vfs, const char *zName) {
+			return static_cast<SQLiteVfs *>(vfs)->implementation.xNextSystemCall(zName);
+		}
+	};
+}
+
+#endif  // __SQLITE_VFS_HPP__

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/SQLiteVfs.h.meta

@@ -0,0 +1,106 @@
+fileFormatVersion: 2
+guid: aac1512bc2fa0445fbef81428fd172e6
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/idbvfs.cpp

@@ -0,0 +1,465 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <vector>
+
+#include "SQLiteVfs.h"
+
+#include "idbvfs.h"
+
+/// Used size for Indexed DB "disk sectors"
+#ifndef DISK_SECTOR_SIZE
+	#define DISK_SECTOR_SIZE 32
+#endif
+
+/// Indexed DB key used to store idbvfs file sizes
+#define IDBVFS_SIZE_KEY "file_size"
+
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#define INLINE_JS(...) EM_ASM(__VA_ARGS__)
+#else
+#define INLINE_JS(...)
+#endif
+
+
+#ifdef TRACE
+static void TRACE_LOG(const char *fmt, ...) {
+	va_list args;
+	va_start(args, fmt);
+	static char _idbvfs_trace_log_buffer[1024];
+	vsnprintf(_idbvfs_trace_log_buffer, sizeof(_idbvfs_trace_log_buffer), fmt, args);
+#ifdef __EMSCRIPTEN__
+	EM_ASM({ console.log(UTF8ToString($0)) }, _idbvfs_trace_log_buffer);
+#else
+	printf("%s\n", _idbvfs_trace_log_buffer);
+#endif
+	va_end(args);
+}
+#else
+	#define TRACE_LOG(...)
+#endif
+
+using namespace sqlitevfs;
+
+class IdbPage {
+public:
+	IdbPage() {}
+
+	IdbPage(const char *dbname, const char *subfilename)
+		: dbname(dbname)
+		, filename(dbname)
+	{
+		filename.append("/");
+		filename.append(subfilename);
+	}
+
+	IdbPage(const char *dbname, int page_number)
+		: IdbPage(dbname, std::to_string(page_number).c_str())
+	{
+	}
+
+	bool exists() const {
+		if (FILE *f = fopen(filename.c_str(), "r")) {
+			fclose(f);
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	int load_into(void *data, size_t data_size, sqlite3_int64 offset_in_page = 0) const {
+		if (FILE *f = fopen(filename.c_str(), "r")) {
+			if (offset_in_page > 0) {
+				fseek(f, offset_in_page, SEEK_SET);
+			}
+			size_t read_bytes = fread(data, 1, data_size, f);
+			fclose(f);
+			return read_bytes;
+		}
+		else {
+			return 0;
+		}
+	}
+
+	int load_into(std::vector<uint8_t>& out_buffer, size_t data_size) const {
+		out_buffer.resize(data_size);
+		return load_into(out_buffer.data(), data_size);
+	}
+
+	int scan_into(const char *fmt, ...) const {
+		if (FILE *f = fopen(filename.c_str(), "r")) {
+			va_list args;
+			va_start(args, fmt);
+			int assigned_items = vfscanf(f, fmt, args);
+			va_end(args);
+			fclose(f);
+			return assigned_items;
+		}
+		else {
+			return 0;
+		}
+	}
+
+	int store(const void *data, size_t data_size) const {
+		mkdir(dbname, 0777);
+
+		if (FILE *f = fopen(filename.c_str(), "w")) {
+			size_t written_bytes = fwrite(data, 1, data_size, f);
+			fclose(f);
+			return written_bytes;
+		}
+		else {
+			return 0;
+		}
+	}
+
+	int store(const std::vector<uint8_t>& data) const {
+		return store(data.data(), data.size());
+	}
+
+	int store(const std::string& data) const {
+		return store(data.c_str(), data.size());
+	}
+
+	bool remove() const {
+		return unlink(filename.c_str()) == 0;
+	}
+
+private:
+	const char *dbname;
+	std::string filename;
+};
+
+struct IdbFileSize : public IdbPage {
+	IdbFileSize() : IdbPage() {}
+	IdbFileSize(sqlite3_filename file_name, bool autoload = true) : IdbPage(file_name, IDBVFS_SIZE_KEY) {
+		if (autoload) {
+			load();
+		}
+	}
+
+	void load() {
+		scan_into("%lu", &file_size);
+		is_dirty = false;
+	}
+
+	size_t get() const {
+		return file_size;
+	}
+
+	void set(size_t new_file_size) {
+		if (new_file_size != file_size) {
+			file_size = new_file_size;
+			is_dirty = true;
+		}
+	}
+
+	void update_if_greater(size_t new_file_size) {
+		if (new_file_size > file_size) {
+			set(new_file_size);
+		}
+	}
+
+	bool sync() const {
+		if (is_dirty) {
+			return store(std::to_string(file_size)) > 0;
+		}
+		else {
+			return true;
+		}
+	}
+
+private:
+	size_t file_size = 0;
+	bool is_dirty = false;
+};
+
+struct IdbFile : public SQLiteFileImpl {
+	sqlite3_filename file_name;
+	IdbFileSize file_size;
+	std::vector<uint8_t> journal_data;
+	bool is_db;
+
+	IdbFile() {}
+	IdbFile(sqlite3_filename file_name, bool is_db) : file_name(file_name), file_size(file_name), is_db(is_db) {}
+
+	int iVersion() const override {
+		return 1;
+	}
+
+	int xClose() override {
+		return SQLITE_OK;
+	}
+
+	int xRead(void *p, int iAmt, sqlite3_int64 iOfst) override {
+		TRACE_LOG("READ %s %d @ %ld", file_name, iAmt, iOfst);
+		if (iAmt + iOfst > file_size.get()) {
+			TRACE_LOG("  > %d", false);
+			return SQLITE_IOERR_SHORT_READ;
+		}
+
+		int result;
+		if (is_db) {
+			result = readDb(p, iAmt, iOfst);
+		}
+		else {
+			result = readJournal(p, iAmt, iOfst);
+		}
+		TRACE_LOG("  > %d", result);
+		return result;
+	}
+
+	int xWrite(const void *p, int iAmt, sqlite3_int64 iOfst) override {
+		TRACE_LOG("WRITE %s %d @ %ld", file_name, iAmt, iOfst);
+		int result;
+		if (is_db) {
+			result = writeDb(p, iAmt, iOfst);
+		}
+		else {
+			result = writeJournal(p, iAmt, iOfst);
+		}
+		TRACE_LOG("  > %d", result);
+		return result;
+	}
+
+	int xTruncate(sqlite3_int64 size) override {
+		TRACE_LOG("TRUNCATE %s to %ld", file_name, size);
+		file_size.set(size);
+		TRACE_LOG("  > %d", true);
+		return SQLITE_OK;
+	}
+
+	int xSync(int flags) override {
+		TRACE_LOG("SYNC %s %d", file_name, flags);
+		// journal data is stored in-memory and synced all at once
+		if (!journal_data.empty()) {
+			IdbPage file(file_name, 0);
+			file.store(journal_data);
+			file_size.set(journal_data.size());
+		}
+		bool success = file_size.sync();
+		INLINE_JS({
+			Module.idbvfsSyncfs();
+		});
+		TRACE_LOG("  > %d", success);
+		return success ? SQLITE_OK : SQLITE_IOERR_FSYNC;
+	}
+
+	int xFileSize(sqlite3_int64 *pSize) override {
+		TRACE_LOG("FILE SIZE %s", file_name);
+		if (!journal_data.empty()) {
+			*pSize = journal_data.size();
+		}
+		else {
+			*pSize = file_size.get();
+		}
+		TRACE_LOG("  > %d", *pSize);
+		return SQLITE_OK;
+	}
+
+	int xLock(int flags) override {
+		return SQLITE_OK;
+	}
+
+	int xUnlock(int flags) override {
+		return SQLITE_OK;
+	}
+
+	int xCheckReservedLock(int *pResOut) override {
+		*pResOut = 0;
+		return SQLITE_OK;
+	}
+
+	int xFileControl(int op, void *pArg) override {
+		switch (op) {
+			case SQLITE_FCNTL_VFSNAME:
+				*(char **) pArg = sqlite3_mprintf("%z", IDBVFS_NAME);
+				return SQLITE_OK;
+		}
+		return SQLITE_NOTFOUND;
+	}
+
+	int xSectorSize() override {
+		return DISK_SECTOR_SIZE;
+	}
+
+	int xDeviceCharacteristics() override {
+		return 0;
+	}
+
+private:
+	int readDb(void *p, int iAmt, sqlite3_int64 iOfst) {
+		int page_number;
+		sqlite3_int64 offset_in_page;
+		if (iOfst + iAmt >= 512) {
+			if (iOfst % iAmt != 0) {
+				return SQLITE_IOERR_READ;
+			}
+			page_number = iOfst / iAmt;
+			offset_in_page = 0;
+		} else {
+			page_number = 0;
+			offset_in_page = iOfst;
+		}
+
+		IdbPage page(file_name, page_number);
+		int loaded_bytes = page.load_into((uint8_t*) p, iAmt, offset_in_page);
+		if (loaded_bytes < iAmt) {
+			return SQLITE_IOERR_SHORT_READ;
+		}
+		else {
+			return SQLITE_OK;
+		}
+	}
+
+	int readJournal(void *p, int iAmt, sqlite3_int64 iOfst) {
+		if (journal_data.empty()) {
+			size_t journal_size = file_size.get();
+			if (journal_size > 0) {
+				IdbPage page(file_name, 0);
+				page.load_into(journal_data, journal_size);
+			}
+		}
+		if (iAmt + iOfst > journal_data.size()) {
+			return SQLITE_IOERR_SHORT_READ;
+		}
+		memcpy(p, journal_data.data() + iOfst, iAmt);
+		return SQLITE_OK;
+	}
+
+	int writeDb(const void *p, int iAmt, sqlite3_int64 iOfst) {
+		int page_number = iOfst ? iOfst / iAmt : 0;
+
+		IdbPage page(file_name, page_number);
+		int stored_bytes = page.store(p, iAmt);
+		if (stored_bytes < iAmt) {
+			return SQLITE_IOERR_WRITE;
+		}
+
+		file_size.update_if_greater(iAmt + iOfst);
+		return SQLITE_OK;
+	}
+
+	int writeJournal(const void *p, int iAmt, sqlite3_int64 iOfst) {
+		if (iAmt + iOfst > journal_data.size()) {
+			journal_data.resize(iAmt + iOfst);
+		}
+		memcpy(journal_data.data() + iOfst, p, iAmt);
+		return SQLITE_OK;
+	}
+};
+
+struct IdbVfs : public SQLiteVfsImpl<IdbFile> {
+	int xOpen(sqlite3_filename zName, SQLiteFile<IdbFile> *file, int flags, int *pOutFlags) override {
+		TRACE_LOG("OPEN %s", zName);
+		bool is_db = (flags & SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_TEMP_DB);
+		file->implementation = IdbFile(zName, is_db);
+		return SQLITE_OK;
+	}
+
+	int xDelete(const char *zName, int syncDir) override {
+		TRACE_LOG("DELETE %s", zName);
+		IdbFileSize file_size(zName, false);
+		if (!file_size.remove()) {
+			return SQLITE_IOERR_DELETE;
+		}
+
+		for (int i = 0; ; i++) {
+			IdbPage page(zName, i);
+			if (!page.remove()) {
+				break;
+			}
+		}
+		rmdir(zName);
+		return SQLITE_OK;
+	}
+
+	int xAccess(const char *zName, int flags, int *pResOut) override {
+		TRACE_LOG("ACCESS %s %d", zName, flags);
+		switch (flags) {
+			case SQLITE_ACCESS_EXISTS:
+			case SQLITE_ACCESS_READWRITE:
+			case SQLITE_ACCESS_READ:
+				IdbFileSize file_size(zName, false);
+				*pResOut = file_size.exists();
+				TRACE_LOG("  > %d", *pResOut);
+				return SQLITE_OK;
+		}
+		return SQLITE_NOTFOUND;
+	}
+
+#ifdef __EMSCRIPTEN__
+	int xFullPathname(const char *zName, int nOut, char *zOut) override {
+		TRACE_LOG("FULL PATH %s", zName);
+		if (zName[0] == '/') {
+			strncpy(zOut, zName, nOut);
+		}
+		else {
+			snprintf(zOut, nOut, "/idbfs/%s", zName);
+		}
+		TRACE_LOG(" > %s", zOut);
+		return SQLITE_OK;
+	}
+#endif
+};
+
+extern "C" {
+	const char *IDBVFS_NAME = "idbvfs";
+
+	int idbvfs_register(int makeDefault) {
+		static SQLiteVfs<IdbVfs> idbvfs(IDBVFS_NAME);
+		INLINE_JS({
+			if (!Module.idbvfsSyncfs) {
+				// Run FS.syncfs in a queue, to avoid concurrent execution errors
+				var syncQueue = 0;
+				function doSync() {
+					FS.syncfs(false, function() {
+						syncQueue--;
+						if (syncQueue > 0) {
+							doSync();
+						}
+					});
+				}
+				Module.idbvfsSyncfs = function() {
+					syncQueue++;
+					if (syncQueue == 1) {
+						doSync();
+					}
+				};
+			}
+		});
+		return idbvfs.register_vfs(makeDefault);
+	}
+}

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/idbvfs.cpp.meta

@@ -0,0 +1,106 @@
+fileFormatVersion: 2
+guid: 33b221fa6bef54ac996317b3a8ab2021
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/idbvfs.h

@@ -0,0 +1,51 @@
+/** @file idbvfs.h
+ *
+ * SQLite VFS that stores data in web browser's Indexed DB using Emscripten.
+ */
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * String containing idbvfs name.
+ */
+extern const char *IDBVFS_NAME;
+
+/**
+ * Registers idbvfs in SQLite 3.
+ *
+ * @param makeDefault  Whether idbvfs will be the new default VFS.
+ * @return Return value from `sqlite3_vfs_register`
+ * @see https://sqlite.org/c3ref/vfs_find.html
+ */
+int idbvfs_register(int makeDefault);
+
+#ifdef __cplusplus
+}
+#endif

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/idbvfs/idbvfs.h.meta

@@ -0,0 +1,106 @@
+fileFormatVersion: 2
+guid: 714e36bffffff4eeca3e5b12e47510eb
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 643c7bd7804e942b597f2f4a297fb3a9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 475700be16f36411b950cc12259f8e0a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/arm32.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 60c565140771d401a95a1f1850ef8d2e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/arm32/libgilzoide-sqlite-net.so.meta

@@ -0,0 +1,101 @@
+fileFormatVersion: 2
+guid: 57126b2d3bafb46e5a7a4ece8eb4d9f8
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 0
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/arm64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bfbafd25ec1ee4915a65b807012dd5eb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/arm64/libgilzoide-sqlite-net.so.meta

@@ -0,0 +1,101 @@
+fileFormatVersion: 2
+guid: 087f5264fe8f3450f8b0e9fd5c0f52d8
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 0
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARM64
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/x86.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dfb87fba928c64a5b8facb61f2e0f711
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/x86/libgilzoide-sqlite-net.so.meta

@@ -0,0 +1,101 @@
+fileFormatVersion: 2
+guid: 0af503a9536c24d738fdf908dfb115eb
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 0
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: X86
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/x86_64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e25ff9771419c407db33c391a0fdadd1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/android/x86_64/libgilzoide-sqlite-net.so.meta

@@ -0,0 +1,101 @@
+fileFormatVersion: 2
+guid: 31ad6577221064c96a1a580ff407e1a2
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 0
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: X86_64
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/linux.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 806517e1ae9d2e84f994c6d6df651af0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/linux/x86_64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 71084fb9a073785c49eb8aac28f0bbfc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/linux/x86_64/libgilzoide-sqlite-net.so.meta

@@ -0,0 +1,101 @@
+fileFormatVersion: 2
+guid: a5ad070f93c93bc05afd06384d710b49
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 0
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 0
+        Exclude Win64: 0
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: Linux
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/macos.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e2b76ac96bd85474a97ccd9fb12e4220
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/macos/libgilzoide-sqlite-net.dylib.meta

@@ -0,0 +1,82 @@
+fileFormatVersion: 2
+guid: 5ac500925e8a7402fabca3baf4eca437
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 0
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: OSX
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ffde8862e849e442a9c6d9e16351bdb6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/arm64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 49731d4518ba8405cb4a2da9941193a7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/arm64/gilzoide-sqlite-net.dll.meta

@@ -0,0 +1,83 @@
+fileFormatVersion: 2
+guid: 6b53346b6b4b8438d8d3d69a36f38fc4
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 0
+        Exclude OSXUniversal: 0
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 0
+        Exclude WindowsStoreApps: 0
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: ARM64
+        DefaultValueInitialized: true
+        OS: Windows
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 1
+      settings:
+        CPU: ARM64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 1
+      settings:
+        CPU: ARM64
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/x86.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5d8321f9eff864a28863a1f1dfef2889
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/x86/gilzoide-sqlite-net.dll.meta

@@ -0,0 +1,112 @@
+fileFormatVersion: 2
+guid: e350d0232f7f0422daaad868e5e48077
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 0
+        Exclude OSXUniversal: 0
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 0
+        Exclude Win64: 1
+        Exclude WindowsStoreApps: 0
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 1
+      settings:
+        CPU: X86
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/x86_64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4a09091ccc924403392207d037cc981e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/lib/windows/x86_64/gilzoide-sqlite-net.dll.meta

@@ -0,0 +1,112 @@
+fileFormatVersion: 2
+guid: 93d2b1d9e859c496e83bc487cf09cf57
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 0
+        Exclude Linux64: 0
+        Exclude OSXUniversal: 0
+        Exclude VisionOS: 1
+        Exclude WebGL: 1
+        Exclude Win: 1
+        Exclude Win64: 0
+        Exclude WindowsStoreApps: 0
+        Exclude iOS: 1
+        Exclude tvOS: 1
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: Windows
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 1
+      settings:
+        CPU: X64
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 0
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b85a4855da6cd47cfa135c60a37af8c8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3.c.meta

@@ -0,0 +1,107 @@
+fileFormatVersion: 2
+guid: 4f4aecd216a78400d96ff7b4a39f0627
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 0
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 0
+        Exclude tvOS: 0
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: ARM64
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3.h.meta

@@ -0,0 +1,86 @@
+fileFormatVersion: 2
+guid: bd619249260364d7c9e09aa0015418e6
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 0
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 0
+        Exclude tvOS: 0
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3_defines.h

@@ -0,0 +1,19 @@
+// Compile-time definitions used to build SQLite
+// This is a separate file so that IL2CPP can use the same flags on all platforms
+#define SQLITE_USE_URI 1
+#define SQLITE_DQS 0 
+#define SQLITE_DEFAULT_MEMSTATUS 0 
+#define SQLITE_DEFAULT_WAL_SYNCHRONOUS 1 
+#define SQLITE_LIKE_DOESNT_MATCH_BLOBS 1
+#define SQLITE_MAX_EXPR_DEPTH 0 
+#define SQLITE_OMIT_DECLTYPE 1
+#define SQLITE_OMIT_DEPRECATED 1
+#define SQLITE_OMIT_PROGRESS_CALLBACK 1
+#define SQLITE_OMIT_SHARED_CACHE 1
+#define SQLITE_USE_ALLOCA 1
+#define SQLITE_ENABLE_RTREE 1
+#define SQLITE_ENABLE_MATH_FUNCTIONS 1
+#define HAVE_ISNAN 1
+#define SQLITE_ENABLE_GEOPOLY 1
+#define SQLITE_ENABLE_FTS5 1
+#define SQLITE_ENABLE_HIDDEN_COLUMNS 1

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3_defines.h.meta

@@ -0,0 +1,107 @@
+fileFormatVersion: 2
+guid: 437dfc5ab03b74410aea0f06ebc8467b
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 0
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 0
+        Exclude tvOS: 0
+  - first:
+      Android: Android
+    second:
+      enabled: 0
+      settings:
+        AndroidSharedLibraryType: Executable
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings:
+        AddToEmbeddedBinaries: false
+        CPU: AnyCPU
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3ext.h

@@ -0,0 +1,721 @@
+#include "sqlite3_defines.h"
+
+/*
+** 2006 June 7
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** This header file defines the SQLite interface for use by
+** shared libraries that want to be imported as extensions into
+** an SQLite instance.  Shared libraries that intend to be loaded
+** as extensions by SQLite should #include this file instead of 
+** sqlite3.h.
+*/
+#ifndef SQLITE3EXT_H
+#define SQLITE3EXT_H
+#include "sqlite3.h"
+
+/*
+** The following structure holds pointers to all of the SQLite API
+** routines.
+**
+** WARNING:  In order to maintain backwards compatibility, add new
+** interfaces to the end of this structure only.  If you insert new
+** interfaces in the middle of this structure, then older different
+** versions of SQLite will not be able to load each other's shared
+** libraries!
+*/
+struct sqlite3_api_routines {
+  void * (*aggregate_context)(sqlite3_context*,int nBytes);
+  int  (*aggregate_count)(sqlite3_context*);
+  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
+  int  (*bind_double)(sqlite3_stmt*,int,double);
+  int  (*bind_int)(sqlite3_stmt*,int,int);
+  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
+  int  (*bind_null)(sqlite3_stmt*,int);
+  int  (*bind_parameter_count)(sqlite3_stmt*);
+  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
+  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
+  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
+  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
+  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
+  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
+  int  (*busy_timeout)(sqlite3*,int ms);
+  int  (*changes)(sqlite3*);
+  int  (*close)(sqlite3*);
+  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                           int eTextRep,const char*));
+  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                             int eTextRep,const void*));
+  const void * (*column_blob)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes)(sqlite3_stmt*,int iCol);
+  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
+  int  (*column_count)(sqlite3_stmt*pStmt);
+  const char * (*column_database_name)(sqlite3_stmt*,int);
+  const void * (*column_database_name16)(sqlite3_stmt*,int);
+  const char * (*column_decltype)(sqlite3_stmt*,int i);
+  const void * (*column_decltype16)(sqlite3_stmt*,int);
+  double  (*column_double)(sqlite3_stmt*,int iCol);
+  int  (*column_int)(sqlite3_stmt*,int iCol);
+  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
+  const char * (*column_name)(sqlite3_stmt*,int);
+  const void * (*column_name16)(sqlite3_stmt*,int);
+  const char * (*column_origin_name)(sqlite3_stmt*,int);
+  const void * (*column_origin_name16)(sqlite3_stmt*,int);
+  const char * (*column_table_name)(sqlite3_stmt*,int);
+  const void * (*column_table_name16)(sqlite3_stmt*,int);
+  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
+  const void * (*column_text16)(sqlite3_stmt*,int iCol);
+  int  (*column_type)(sqlite3_stmt*,int iCol);
+  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
+  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
+  int  (*complete)(const char*sql);
+  int  (*complete16)(const void*sql);
+  int  (*create_collation)(sqlite3*,const char*,int,void*,
+                           int(*)(void*,int,const void*,int,const void*));
+  int  (*create_collation16)(sqlite3*,const void*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*));
+  int  (*create_function)(sqlite3*,const char*,int,int,void*,
+                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xFinal)(sqlite3_context*));
+  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*));
+  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
+  int  (*data_count)(sqlite3_stmt*pStmt);
+  sqlite3 * (*db_handle)(sqlite3_stmt*);
+  int (*declare_vtab)(sqlite3*,const char*);
+  int  (*enable_shared_cache)(int);
+  int  (*errcode)(sqlite3*db);
+  const char * (*errmsg)(sqlite3*);
+  const void * (*errmsg16)(sqlite3*);
+  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
+  int  (*expired)(sqlite3_stmt*);
+  int  (*finalize)(sqlite3_stmt*pStmt);
+  void  (*free)(void*);
+  void  (*free_table)(char**result);
+  int  (*get_autocommit)(sqlite3*);
+  void * (*get_auxdata)(sqlite3_context*,int);
+  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
+  int  (*global_recover)(void);
+  void  (*interruptx)(sqlite3*);
+  sqlite_int64  (*last_insert_rowid)(sqlite3*);
+  const char * (*libversion)(void);
+  int  (*libversion_number)(void);
+  void *(*malloc)(int);
+  char * (*mprintf)(const char*,...);
+  int  (*open)(const char*,sqlite3**);
+  int  (*open16)(const void*,sqlite3**);
+  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
+  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
+  void *(*realloc)(void*,int);
+  int  (*reset)(sqlite3_stmt*pStmt);
+  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_double)(sqlite3_context*,double);
+  void  (*result_error)(sqlite3_context*,const char*,int);
+  void  (*result_error16)(sqlite3_context*,const void*,int);
+  void  (*result_int)(sqlite3_context*,int);
+  void  (*result_int64)(sqlite3_context*,sqlite_int64);
+  void  (*result_null)(sqlite3_context*);
+  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
+  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
+  void  (*result_value)(sqlite3_context*,sqlite3_value*);
+  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
+  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
+                         const char*,const char*),void*);
+  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
+  char * (*xsnprintf)(int,char*,const char*,...);
+  int  (*step)(sqlite3_stmt*);
+  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
+                                char const**,char const**,int*,int*,int*);
+  void  (*thread_cleanup)(void);
+  int  (*total_changes)(sqlite3*);
+  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
+  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
+  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
+                                         sqlite_int64),void*);
+  void * (*user_data)(sqlite3_context*);
+  const void * (*value_blob)(sqlite3_value*);
+  int  (*value_bytes)(sqlite3_value*);
+  int  (*value_bytes16)(sqlite3_value*);
+  double  (*value_double)(sqlite3_value*);
+  int  (*value_int)(sqlite3_value*);
+  sqlite_int64  (*value_int64)(sqlite3_value*);
+  int  (*value_numeric_type)(sqlite3_value*);
+  const unsigned char * (*value_text)(sqlite3_value*);
+  const void * (*value_text16)(sqlite3_value*);
+  const void * (*value_text16be)(sqlite3_value*);
+  const void * (*value_text16le)(sqlite3_value*);
+  int  (*value_type)(sqlite3_value*);
+  char *(*vmprintf)(const char*,va_list);
+  /* Added ??? */
+  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
+  /* Added by 3.3.13 */
+  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
+  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
+  int (*clear_bindings)(sqlite3_stmt*);
+  /* Added by 3.4.1 */
+  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
+                          void (*xDestroy)(void *));
+  /* Added by 3.5.0 */
+  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
+  int (*blob_bytes)(sqlite3_blob*);
+  int (*blob_close)(sqlite3_blob*);
+  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
+                   int,sqlite3_blob**);
+  int (*blob_read)(sqlite3_blob*,void*,int,int);
+  int (*blob_write)(sqlite3_blob*,const void*,int,int);
+  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*),
+                             void(*)(void*));
+  int (*file_control)(sqlite3*,const char*,int,void*);
+  sqlite3_int64 (*memory_highwater)(int);
+  sqlite3_int64 (*memory_used)(void);
+  sqlite3_mutex *(*mutex_alloc)(int);
+  void (*mutex_enter)(sqlite3_mutex*);
+  void (*mutex_free)(sqlite3_mutex*);
+  void (*mutex_leave)(sqlite3_mutex*);
+  int (*mutex_try)(sqlite3_mutex*);
+  int (*open_v2)(const char*,sqlite3**,int,const char*);
+  int (*release_memory)(int);
+  void (*result_error_nomem)(sqlite3_context*);
+  void (*result_error_toobig)(sqlite3_context*);
+  int (*sleep)(int);
+  void (*soft_heap_limit)(int);
+  sqlite3_vfs *(*vfs_find)(const char*);
+  int (*vfs_register)(sqlite3_vfs*,int);
+  int (*vfs_unregister)(sqlite3_vfs*);
+  int (*xthreadsafe)(void);
+  void (*result_zeroblob)(sqlite3_context*,int);
+  void (*result_error_code)(sqlite3_context*,int);
+  int (*test_control)(int, ...);
+  void (*randomness)(int,void*);
+  sqlite3 *(*context_db_handle)(sqlite3_context*);
+  int (*extended_result_codes)(sqlite3*,int);
+  int (*limit)(sqlite3*,int,int);
+  sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
+  const char *(*sql)(sqlite3_stmt*);
+  int (*status)(int,int*,int*,int);
+  int (*backup_finish)(sqlite3_backup*);
+  sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
+  int (*backup_pagecount)(sqlite3_backup*);
+  int (*backup_remaining)(sqlite3_backup*);
+  int (*backup_step)(sqlite3_backup*,int);
+  const char *(*compileoption_get)(int);
+  int (*compileoption_used)(const char*);
+  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*),
+                            void(*xDestroy)(void*));
+  int (*db_config)(sqlite3*,int,...);
+  sqlite3_mutex *(*db_mutex)(sqlite3*);
+  int (*db_status)(sqlite3*,int,int*,int*,int);
+  int (*extended_errcode)(sqlite3*);
+  void (*log)(int,const char*,...);
+  sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
+  const char *(*sourceid)(void);
+  int (*stmt_status)(sqlite3_stmt*,int,int);
+  int (*strnicmp)(const char*,const char*,int);
+  int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
+  int (*wal_autocheckpoint)(sqlite3*,int);
+  int (*wal_checkpoint)(sqlite3*,const char*);
+  void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
+  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
+  int (*vtab_config)(sqlite3*,int op,...);
+  int (*vtab_on_conflict)(sqlite3*);
+  /* Version 3.7.16 and later */
+  int (*close_v2)(sqlite3*);
+  const char *(*db_filename)(sqlite3*,const char*);
+  int (*db_readonly)(sqlite3*,const char*);
+  int (*db_release_memory)(sqlite3*);
+  const char *(*errstr)(int);
+  int (*stmt_busy)(sqlite3_stmt*);
+  int (*stmt_readonly)(sqlite3_stmt*);
+  int (*stricmp)(const char*,const char*);
+  int (*uri_boolean)(const char*,const char*,int);
+  sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
+  const char *(*uri_parameter)(const char*,const char*);
+  char *(*xvsnprintf)(int,char*,const char*,va_list);
+  int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
+  /* Version 3.8.7 and later */
+  int (*auto_extension)(void(*)(void));
+  int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64,
+                     void(*)(void*));
+  int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64,
+                      void(*)(void*),unsigned char);
+  int (*cancel_auto_extension)(void(*)(void));
+  int (*load_extension)(sqlite3*,const char*,const char*,char**);
+  void *(*malloc64)(sqlite3_uint64);
+  sqlite3_uint64 (*msize)(void*);
+  void *(*realloc64)(void*,sqlite3_uint64);
+  void (*reset_auto_extension)(void);
+  void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64,
+                        void(*)(void*));
+  void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
+                         void(*)(void*), unsigned char);
+  int (*strglob)(const char*,const char*);
+  /* Version 3.8.11 and later */
+  sqlite3_value *(*value_dup)(const sqlite3_value*);
+  void (*value_free)(sqlite3_value*);
+  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
+  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
+  /* Version 3.9.0 and later */
+  unsigned int (*value_subtype)(sqlite3_value*);
+  void (*result_subtype)(sqlite3_context*,unsigned int);
+  /* Version 3.10.0 and later */
+  int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int);
+  int (*strlike)(const char*,const char*,unsigned int);
+  int (*db_cacheflush)(sqlite3*);
+  /* Version 3.12.0 and later */
+  int (*system_errno)(sqlite3*);
+  /* Version 3.14.0 and later */
+  int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
+  char *(*expanded_sql)(sqlite3_stmt*);
+  /* Version 3.18.0 and later */
+  void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64);
+  /* Version 3.20.0 and later */
+  int (*prepare_v3)(sqlite3*,const char*,int,unsigned int,
+                    sqlite3_stmt**,const char**);
+  int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int,
+                      sqlite3_stmt**,const void**);
+  int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*));
+  void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*));
+  void *(*value_pointer)(sqlite3_value*,const char*);
+  int (*vtab_nochange)(sqlite3_context*);
+  int (*value_nochange)(sqlite3_value*);
+  const char *(*vtab_collation)(sqlite3_index_info*,int);
+  /* Version 3.24.0 and later */
+  int (*keyword_count)(void);
+  int (*keyword_name)(int,const char**,int*);
+  int (*keyword_check)(const char*,int);
+  sqlite3_str *(*str_new)(sqlite3*);
+  char *(*str_finish)(sqlite3_str*);
+  void (*str_appendf)(sqlite3_str*, const char *zFormat, ...);
+  void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list);
+  void (*str_append)(sqlite3_str*, const char *zIn, int N);
+  void (*str_appendall)(sqlite3_str*, const char *zIn);
+  void (*str_appendchar)(sqlite3_str*, int N, char C);
+  void (*str_reset)(sqlite3_str*);
+  int (*str_errcode)(sqlite3_str*);
+  int (*str_length)(sqlite3_str*);
+  char *(*str_value)(sqlite3_str*);
+  /* Version 3.25.0 and later */
+  int (*create_window_function)(sqlite3*,const char*,int,int,void*,
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*),
+                            void (*xValue)(sqlite3_context*),
+                            void (*xInv)(sqlite3_context*,int,sqlite3_value**),
+                            void(*xDestroy)(void*));
+  /* Version 3.26.0 and later */
+  const char *(*normalized_sql)(sqlite3_stmt*);
+  /* Version 3.28.0 and later */
+  int (*stmt_isexplain)(sqlite3_stmt*);
+  int (*value_frombind)(sqlite3_value*);
+  /* Version 3.30.0 and later */
+  int (*drop_modules)(sqlite3*,const char**);
+  /* Version 3.31.0 and later */
+  sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64);
+  const char *(*uri_key)(const char*,int);
+  const char *(*filename_database)(const char*);
+  const char *(*filename_journal)(const char*);
+  const char *(*filename_wal)(const char*);
+  /* Version 3.32.0 and later */
+  const char *(*create_filename)(const char*,const char*,const char*,
+                           int,const char**);
+  void (*free_filename)(const char*);
+  sqlite3_file *(*database_file_object)(const char*);
+  /* Version 3.34.0 and later */
+  int (*txn_state)(sqlite3*,const char*);
+  /* Version 3.36.1 and later */
+  sqlite3_int64 (*changes64)(sqlite3*);
+  sqlite3_int64 (*total_changes64)(sqlite3*);
+  /* Version 3.37.0 and later */
+  int (*autovacuum_pages)(sqlite3*,
+     unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+     void*, void(*)(void*));
+  /* Version 3.38.0 and later */
+  int (*error_offset)(sqlite3*);
+  int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**);
+  int (*vtab_distinct)(sqlite3_index_info*);
+  int (*vtab_in)(sqlite3_index_info*,int,int);
+  int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
+  int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
+  /* Version 3.39.0 and later */
+  int (*deserialize)(sqlite3*,const char*,unsigned char*,
+                     sqlite3_int64,sqlite3_int64,unsigned);
+  unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*,
+                              unsigned int);
+  const char *(*db_name)(sqlite3*,int);
+  /* Version 3.40.0 and later */
+  int (*value_encoding)(sqlite3_value*);
+  /* Version 3.41.0 and later */
+  int (*is_interrupted)(sqlite3*);
+  /* Version 3.43.0 and later */
+  int (*stmt_explain)(sqlite3_stmt*,int);
+  /* Version 3.44.0 and later */
+  void *(*get_clientdata)(sqlite3*,const char*);
+  int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
+};
+
+/*
+** This is the function signature used for all extension entry points.  It
+** is also defined in the file "loadext.c".
+*/
+typedef int (*sqlite3_loadext_entry)(
+  sqlite3 *db,                       /* Handle to the database. */
+  char **pzErrMsg,                   /* Used to set error string on failure. */
+  const sqlite3_api_routines *pThunk /* Extension API function pointers. */
+);
+
+/*
+** The following macros redefine the API routines so that they are
+** redirected through the global sqlite3_api structure.
+**
+** This header file is also used by the loadext.c source file
+** (part of the main SQLite library - not an extension) so that
+** it can get access to the sqlite3_api_routines structure
+** definition.  But the main library does not want to redefine
+** the API.  So the redefinition macros are only valid if the
+** SQLITE_CORE macros is undefined.
+*/
+#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
+#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
+#endif
+#define sqlite3_bind_blob              sqlite3_api->bind_blob
+#define sqlite3_bind_double            sqlite3_api->bind_double
+#define sqlite3_bind_int               sqlite3_api->bind_int
+#define sqlite3_bind_int64             sqlite3_api->bind_int64
+#define sqlite3_bind_null              sqlite3_api->bind_null
+#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
+#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
+#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
+#define sqlite3_bind_text              sqlite3_api->bind_text
+#define sqlite3_bind_text16            sqlite3_api->bind_text16
+#define sqlite3_bind_value             sqlite3_api->bind_value
+#define sqlite3_busy_handler           sqlite3_api->busy_handler
+#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
+#define sqlite3_changes                sqlite3_api->changes
+#define sqlite3_close                  sqlite3_api->close
+#define sqlite3_collation_needed       sqlite3_api->collation_needed
+#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
+#define sqlite3_column_blob            sqlite3_api->column_blob
+#define sqlite3_column_bytes           sqlite3_api->column_bytes
+#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
+#define sqlite3_column_count           sqlite3_api->column_count
+#define sqlite3_column_database_name   sqlite3_api->column_database_name
+#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
+#define sqlite3_column_decltype        sqlite3_api->column_decltype
+#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
+#define sqlite3_column_double          sqlite3_api->column_double
+#define sqlite3_column_int             sqlite3_api->column_int
+#define sqlite3_column_int64           sqlite3_api->column_int64
+#define sqlite3_column_name            sqlite3_api->column_name
+#define sqlite3_column_name16          sqlite3_api->column_name16
+#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
+#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
+#define sqlite3_column_table_name      sqlite3_api->column_table_name
+#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
+#define sqlite3_column_text            sqlite3_api->column_text
+#define sqlite3_column_text16          sqlite3_api->column_text16
+#define sqlite3_column_type            sqlite3_api->column_type
+#define sqlite3_column_value           sqlite3_api->column_value
+#define sqlite3_commit_hook            sqlite3_api->commit_hook
+#define sqlite3_complete               sqlite3_api->complete
+#define sqlite3_complete16             sqlite3_api->complete16
+#define sqlite3_create_collation       sqlite3_api->create_collation
+#define sqlite3_create_collation16     sqlite3_api->create_collation16
+#define sqlite3_create_function        sqlite3_api->create_function
+#define sqlite3_create_function16      sqlite3_api->create_function16
+#define sqlite3_create_module          sqlite3_api->create_module
+#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
+#define sqlite3_data_count             sqlite3_api->data_count
+#define sqlite3_db_handle              sqlite3_api->db_handle
+#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
+#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
+#define sqlite3_errcode                sqlite3_api->errcode
+#define sqlite3_errmsg                 sqlite3_api->errmsg
+#define sqlite3_errmsg16               sqlite3_api->errmsg16
+#define sqlite3_exec                   sqlite3_api->exec
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_expired                sqlite3_api->expired
+#endif
+#define sqlite3_finalize               sqlite3_api->finalize
+#define sqlite3_free                   sqlite3_api->free
+#define sqlite3_free_table             sqlite3_api->free_table
+#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
+#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
+#define sqlite3_get_table              sqlite3_api->get_table
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_global_recover         sqlite3_api->global_recover
+#endif
+#define sqlite3_interrupt              sqlite3_api->interruptx
+#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
+#define sqlite3_libversion             sqlite3_api->libversion
+#define sqlite3_libversion_number      sqlite3_api->libversion_number
+#define sqlite3_malloc                 sqlite3_api->malloc
+#define sqlite3_mprintf                sqlite3_api->mprintf
+#define sqlite3_open                   sqlite3_api->open
+#define sqlite3_open16                 sqlite3_api->open16
+#define sqlite3_prepare                sqlite3_api->prepare
+#define sqlite3_prepare16              sqlite3_api->prepare16
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_profile                sqlite3_api->profile
+#define sqlite3_progress_handler       sqlite3_api->progress_handler
+#define sqlite3_realloc                sqlite3_api->realloc
+#define sqlite3_reset                  sqlite3_api->reset
+#define sqlite3_result_blob            sqlite3_api->result_blob
+#define sqlite3_result_double          sqlite3_api->result_double
+#define sqlite3_result_error           sqlite3_api->result_error
+#define sqlite3_result_error16         sqlite3_api->result_error16
+#define sqlite3_result_int             sqlite3_api->result_int
+#define sqlite3_result_int64           sqlite3_api->result_int64
+#define sqlite3_result_null            sqlite3_api->result_null
+#define sqlite3_result_text            sqlite3_api->result_text
+#define sqlite3_result_text16          sqlite3_api->result_text16
+#define sqlite3_result_text16be        sqlite3_api->result_text16be
+#define sqlite3_result_text16le        sqlite3_api->result_text16le
+#define sqlite3_result_value           sqlite3_api->result_value
+#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
+#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
+#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
+#define sqlite3_snprintf               sqlite3_api->xsnprintf
+#define sqlite3_step                   sqlite3_api->step
+#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
+#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
+#define sqlite3_total_changes          sqlite3_api->total_changes
+#define sqlite3_trace                  sqlite3_api->trace
+#ifndef SQLITE_OMIT_DEPRECATED
+#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
+#endif
+#define sqlite3_update_hook            sqlite3_api->update_hook
+#define sqlite3_user_data              sqlite3_api->user_data
+#define sqlite3_value_blob             sqlite3_api->value_blob
+#define sqlite3_value_bytes            sqlite3_api->value_bytes
+#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
+#define sqlite3_value_double           sqlite3_api->value_double
+#define sqlite3_value_int              sqlite3_api->value_int
+#define sqlite3_value_int64            sqlite3_api->value_int64
+#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
+#define sqlite3_value_text             sqlite3_api->value_text
+#define sqlite3_value_text16           sqlite3_api->value_text16
+#define sqlite3_value_text16be         sqlite3_api->value_text16be
+#define sqlite3_value_text16le         sqlite3_api->value_text16le
+#define sqlite3_value_type             sqlite3_api->value_type
+#define sqlite3_vmprintf               sqlite3_api->vmprintf
+#define sqlite3_vsnprintf              sqlite3_api->xvsnprintf
+#define sqlite3_overload_function      sqlite3_api->overload_function
+#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
+#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
+#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
+#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
+#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
+#define sqlite3_blob_close             sqlite3_api->blob_close
+#define sqlite3_blob_open              sqlite3_api->blob_open
+#define sqlite3_blob_read              sqlite3_api->blob_read
+#define sqlite3_blob_write             sqlite3_api->blob_write
+#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
+#define sqlite3_file_control           sqlite3_api->file_control
+#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
+#define sqlite3_memory_used            sqlite3_api->memory_used
+#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
+#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
+#define sqlite3_mutex_free             sqlite3_api->mutex_free
+#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
+#define sqlite3_mutex_try              sqlite3_api->mutex_try
+#define sqlite3_open_v2                sqlite3_api->open_v2
+#define sqlite3_release_memory         sqlite3_api->release_memory
+#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
+#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
+#define sqlite3_sleep                  sqlite3_api->sleep
+#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
+#define sqlite3_vfs_find               sqlite3_api->vfs_find
+#define sqlite3_vfs_register           sqlite3_api->vfs_register
+#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
+#define sqlite3_threadsafe             sqlite3_api->xthreadsafe
+#define sqlite3_result_zeroblob        sqlite3_api->result_zeroblob
+#define sqlite3_result_error_code      sqlite3_api->result_error_code
+#define sqlite3_test_control           sqlite3_api->test_control
+#define sqlite3_randomness             sqlite3_api->randomness
+#define sqlite3_context_db_handle      sqlite3_api->context_db_handle
+#define sqlite3_extended_result_codes  sqlite3_api->extended_result_codes
+#define sqlite3_limit                  sqlite3_api->limit
+#define sqlite3_next_stmt              sqlite3_api->next_stmt
+#define sqlite3_sql                    sqlite3_api->sql
+#define sqlite3_status                 sqlite3_api->status
+#define sqlite3_backup_finish          sqlite3_api->backup_finish
+#define sqlite3_backup_init            sqlite3_api->backup_init
+#define sqlite3_backup_pagecount       sqlite3_api->backup_pagecount
+#define sqlite3_backup_remaining       sqlite3_api->backup_remaining
+#define sqlite3_backup_step            sqlite3_api->backup_step
+#define sqlite3_compileoption_get      sqlite3_api->compileoption_get
+#define sqlite3_compileoption_used     sqlite3_api->compileoption_used
+#define sqlite3_create_function_v2     sqlite3_api->create_function_v2
+#define sqlite3_db_config              sqlite3_api->db_config
+#define sqlite3_db_mutex               sqlite3_api->db_mutex
+#define sqlite3_db_status              sqlite3_api->db_status
+#define sqlite3_extended_errcode       sqlite3_api->extended_errcode
+#define sqlite3_log                    sqlite3_api->log
+#define sqlite3_soft_heap_limit64      sqlite3_api->soft_heap_limit64
+#define sqlite3_sourceid               sqlite3_api->sourceid
+#define sqlite3_stmt_status            sqlite3_api->stmt_status
+#define sqlite3_strnicmp               sqlite3_api->strnicmp
+#define sqlite3_unlock_notify          sqlite3_api->unlock_notify
+#define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
+#define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
+#define sqlite3_wal_hook               sqlite3_api->wal_hook
+#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
+#define sqlite3_vtab_config            sqlite3_api->vtab_config
+#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
+/* Version 3.7.16 and later */
+#define sqlite3_close_v2               sqlite3_api->close_v2
+#define sqlite3_db_filename            sqlite3_api->db_filename
+#define sqlite3_db_readonly            sqlite3_api->db_readonly
+#define sqlite3_db_release_memory      sqlite3_api->db_release_memory
+#define sqlite3_errstr                 sqlite3_api->errstr
+#define sqlite3_stmt_busy              sqlite3_api->stmt_busy
+#define sqlite3_stmt_readonly          sqlite3_api->stmt_readonly
+#define sqlite3_stricmp                sqlite3_api->stricmp
+#define sqlite3_uri_boolean            sqlite3_api->uri_boolean
+#define sqlite3_uri_int64              sqlite3_api->uri_int64
+#define sqlite3_uri_parameter          sqlite3_api->uri_parameter
+#define sqlite3_uri_vsnprintf          sqlite3_api->xvsnprintf
+#define sqlite3_wal_checkpoint_v2      sqlite3_api->wal_checkpoint_v2
+/* Version 3.8.7 and later */
+#define sqlite3_auto_extension         sqlite3_api->auto_extension
+#define sqlite3_bind_blob64            sqlite3_api->bind_blob64
+#define sqlite3_bind_text64            sqlite3_api->bind_text64
+#define sqlite3_cancel_auto_extension  sqlite3_api->cancel_auto_extension
+#define sqlite3_load_extension         sqlite3_api->load_extension
+#define sqlite3_malloc64               sqlite3_api->malloc64
+#define sqlite3_msize                  sqlite3_api->msize
+#define sqlite3_realloc64              sqlite3_api->realloc64
+#define sqlite3_reset_auto_extension   sqlite3_api->reset_auto_extension
+#define sqlite3_result_blob64          sqlite3_api->result_blob64
+#define sqlite3_result_text64          sqlite3_api->result_text64
+#define sqlite3_strglob                sqlite3_api->strglob
+/* Version 3.8.11 and later */
+#define sqlite3_value_dup              sqlite3_api->value_dup
+#define sqlite3_value_free             sqlite3_api->value_free
+#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
+#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
+/* Version 3.9.0 and later */
+#define sqlite3_value_subtype          sqlite3_api->value_subtype
+#define sqlite3_result_subtype         sqlite3_api->result_subtype
+/* Version 3.10.0 and later */
+#define sqlite3_status64               sqlite3_api->status64
+#define sqlite3_strlike                sqlite3_api->strlike
+#define sqlite3_db_cacheflush          sqlite3_api->db_cacheflush
+/* Version 3.12.0 and later */
+#define sqlite3_system_errno           sqlite3_api->system_errno
+/* Version 3.14.0 and later */
+#define sqlite3_trace_v2               sqlite3_api->trace_v2
+#define sqlite3_expanded_sql           sqlite3_api->expanded_sql
+/* Version 3.18.0 and later */
+#define sqlite3_set_last_insert_rowid  sqlite3_api->set_last_insert_rowid
+/* Version 3.20.0 and later */
+#define sqlite3_prepare_v3             sqlite3_api->prepare_v3
+#define sqlite3_prepare16_v3           sqlite3_api->prepare16_v3
+#define sqlite3_bind_pointer           sqlite3_api->bind_pointer
+#define sqlite3_result_pointer         sqlite3_api->result_pointer
+#define sqlite3_value_pointer          sqlite3_api->value_pointer
+/* Version 3.22.0 and later */
+#define sqlite3_vtab_nochange          sqlite3_api->vtab_nochange
+#define sqlite3_value_nochange         sqlite3_api->value_nochange
+#define sqlite3_vtab_collation         sqlite3_api->vtab_collation
+/* Version 3.24.0 and later */
+#define sqlite3_keyword_count          sqlite3_api->keyword_count
+#define sqlite3_keyword_name           sqlite3_api->keyword_name
+#define sqlite3_keyword_check          sqlite3_api->keyword_check
+#define sqlite3_str_new                sqlite3_api->str_new
+#define sqlite3_str_finish             sqlite3_api->str_finish
+#define sqlite3_str_appendf            sqlite3_api->str_appendf
+#define sqlite3_str_vappendf           sqlite3_api->str_vappendf
+#define sqlite3_str_append             sqlite3_api->str_append
+#define sqlite3_str_appendall          sqlite3_api->str_appendall
+#define sqlite3_str_appendchar         sqlite3_api->str_appendchar
+#define sqlite3_str_reset              sqlite3_api->str_reset
+#define sqlite3_str_errcode            sqlite3_api->str_errcode
+#define sqlite3_str_length             sqlite3_api->str_length
+#define sqlite3_str_value              sqlite3_api->str_value
+/* Version 3.25.0 and later */
+#define sqlite3_create_window_function sqlite3_api->create_window_function
+/* Version 3.26.0 and later */
+#define sqlite3_normalized_sql         sqlite3_api->normalized_sql
+/* Version 3.28.0 and later */
+#define sqlite3_stmt_isexplain         sqlite3_api->stmt_isexplain
+#define sqlite3_value_frombind         sqlite3_api->value_frombind
+/* Version 3.30.0 and later */
+#define sqlite3_drop_modules           sqlite3_api->drop_modules
+/* Version 3.31.0 and later */
+#define sqlite3_hard_heap_limit64      sqlite3_api->hard_heap_limit64
+#define sqlite3_uri_key                sqlite3_api->uri_key
+#define sqlite3_filename_database      sqlite3_api->filename_database
+#define sqlite3_filename_journal       sqlite3_api->filename_journal
+#define sqlite3_filename_wal           sqlite3_api->filename_wal
+/* Version 3.32.0 and later */
+#define sqlite3_create_filename        sqlite3_api->create_filename
+#define sqlite3_free_filename          sqlite3_api->free_filename
+#define sqlite3_database_file_object   sqlite3_api->database_file_object
+/* Version 3.34.0 and later */
+#define sqlite3_txn_state              sqlite3_api->txn_state
+/* Version 3.36.1 and later */
+#define sqlite3_changes64              sqlite3_api->changes64
+#define sqlite3_total_changes64        sqlite3_api->total_changes64
+/* Version 3.37.0 and later */
+#define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
+/* Version 3.38.0 and later */
+#define sqlite3_error_offset           sqlite3_api->error_offset
+#define sqlite3_vtab_rhs_value         sqlite3_api->vtab_rhs_value
+#define sqlite3_vtab_distinct          sqlite3_api->vtab_distinct
+#define sqlite3_vtab_in                sqlite3_api->vtab_in
+#define sqlite3_vtab_in_first          sqlite3_api->vtab_in_first
+#define sqlite3_vtab_in_next           sqlite3_api->vtab_in_next
+/* Version 3.39.0 and later */
+#ifndef SQLITE_OMIT_DESERIALIZE
+#define sqlite3_deserialize            sqlite3_api->deserialize
+#define sqlite3_serialize              sqlite3_api->serialize
+#endif
+#define sqlite3_db_name                sqlite3_api->db_name
+/* Version 3.40.0 and later */
+#define sqlite3_value_encoding         sqlite3_api->value_encoding
+/* Version 3.41.0 and later */
+#define sqlite3_is_interrupted         sqlite3_api->is_interrupted
+/* Version 3.43.0 and later */
+#define sqlite3_stmt_explain           sqlite3_api->stmt_explain
+/* Version 3.44.0 and later */
+#define sqlite3_get_clientdata         sqlite3_api->get_clientdata
+#define sqlite3_set_clientdata         sqlite3_api->set_clientdata
+#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 
+  ** 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 
+  ** application */
+# define SQLITE_EXTENSION_INIT1     /*no-op*/
+# define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
+# define SQLITE_EXTENSION_INIT3     /*no-op*/
+#endif
+
+#endif /* SQLITE3EXT_H */

Assets/External/Models/SidekickCharacters/Plugins/unity-sqlite-net-1.2.4/Plugins/sqlite-amalgamation/sqlite3ext.h.meta

@@ -0,0 +1,86 @@
+fileFormatVersion: 2
+guid: fcb4567f69dc44be68b6b71003de7ee8
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Android: 1
+        Exclude Editor: 1
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude VisionOS: 0
+        Exclude WebGL: 0
+        Exclude Win: 1
+        Exclude Win64: 1
+        Exclude iOS: 0
+        Exclude tvOS: 0
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      VisionOS: VisionOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: